001/* 002 * This file is part of the Jikes RVM project (http://jikesrvm.org). 003 * 004 * This file is licensed to You under the Eclipse Public License (EPL); 005 * You may not use this file except in compliance with the License. You 006 * may obtain a copy of the License at 007 * 008 * http://www.opensource.org/licenses/eclipse-1.0.php 009 * 010 * See the COPYRIGHT.txt file distributed with this work for information 011 * regarding copyright ownership. 012 */ 013package org.jikesrvm.compilers.opt.lir2mir.ia32_64; 014 015import static org.jikesrvm.compilers.opt.ir.Operators.*; 016import static org.jikesrvm.compilers.opt.ir.ia32.ArchOperators.*; 017import static org.jikesrvm.compilers.opt.lir2mir.ia32_64.BURS_Definitions.*; 018import static org.jikesrvm.compilers.opt.ir.IRTools.*; 019 020import org.jikesrvm.*; 021import org.jikesrvm.classloader.*; 022import org.jikesrvm.compilers.opt.ir.*; 023import org.jikesrvm.compilers.opt.ir.ia32.*; 024import org.jikesrvm.compilers.opt.ir.operand.*; 025import org.jikesrvm.compilers.opt.ir.operand.ia32.*; 026import org.jikesrvm.compilers.opt.lir2mir.ia32.BURS_Helpers; 027import org.jikesrvm.compilers.opt.lir2mir.ia32_64.BURS_TreeNode; 028import org.jikesrvm.compilers.opt.lir2mir.AbstractBURS_TreeNode; 029import org.jikesrvm.compilers.opt.lir2mir.BURS; 030import org.jikesrvm.compilers.opt.lir2mir.BURS_StateCoder; 031import org.jikesrvm.compilers.opt.OptimizingCompilerException; 032import org.jikesrvm.runtime.ArchEntrypoints; 033import org.jikesrvm.util.Bits; //NOPMD 034 035import org.vmmagic.unboxed.*; 036import org.vmmagic.pragma.Inline; 037import org.vmmagic.pragma.Pure; 038 039/** 040 * Machine-specific instruction selection rules. Program generated. 041 * 042 * Note: some of the functions have been taken and modified 043 * from the file gen.c, from the LCC compiler. 044 * See $RVM_ROOT/rvm/src-generated/opt-burs/jburg/COPYRIGHT file for copyright restrictions. 045 * 046 * @see BURS 047 * 048 * NOTE: Program generated file, do not edit! 049 */ 050@SuppressWarnings("unused") // Machine generated code is hard to get perfect 051public class BURS_STATE extends BURS_Helpers implements BURS_StateCoder { 052 053 public BURS_STATE(BURS b) { 054 super(b); 055 } 056 057/*****************************************************************/ 058/* */ 059/* BURS TEMPLATE */ 060/* */ 061/*****************************************************************/ 062 063 /** 064 * Gets the state of a BURS node. This accessor is used by BURS. 065 * 066 * @param a the node 067 * 068 * @return the node's state 069 */ 070 private static AbstractBURS_TreeNode STATE(AbstractBURS_TreeNode a) { return a; } 071 072 /*********************************************************************** 073 * 074 * This file contains BURG utilities 075 * 076 * Note: some of the functions have been taken and modified 077 * from the file gen.c, from the LCC compiler. 078 * 079 ************************************************************************/ 080 081 /** 082 * Prints a debug message. No-op if debugging is disabled. 083 * 084 * @param p the BURS node 085 * @param rule the rule 086 * @param cost the rule's cost 087 * @param bestcost the best cost seen so far 088 */ 089 private static void trace(AbstractBURS_TreeNode p, int rule, int cost, int bestcost) { 090 if (BURS.DEBUG) { 091 VM.sysWriteln(p + " matched " + BURS_Debug.string[rule] + " with cost " + 092 cost + " vs. " + bestcost); 093 } 094 } 095 096 /** 097 * Dumps the whole tree starting at the given node. No-op if 098 * debugging is disabled. 099 * 100 * @param p the node to start at 101 */ 102 public static void dumpTree(AbstractBURS_TreeNode p) { 103 if (BURS.DEBUG) { 104 VM.sysWrite(dumpTree("\n",p,1)); 105 } 106 } 107 108 public static String dumpTree(String out, AbstractBURS_TreeNode p, int indent) { 109 if (p == null) return out; 110 StringBuilder result = new StringBuilder(out); 111 for (int i=0; i<indent; i++) 112 result.append(" "); 113 result.append(p); 114 result.append('\n'); 115 if (p.getChild1() != null) { 116 indent++; 117 result.append(dumpTree("",p.getChild1(),indent)); 118 if (p.getChild2() != null) { 119 result.append(dumpTree("",p.getChild2(),indent)); 120 } 121 } 122 return result.toString(); 123 } 124 125 /** 126 * Dumps the cover of a tree, i.e. the rules 127 * that cover the tree with a minimal cost. No-op if debugging is 128 * disabled. 129 * 130 * @param p the tree's root 131 * @param goalnt the non-terminal that is a goal. This is an external rule number 132 * @param indent number of spaces to use for indentation 133 */ 134 public static void dumpCover(AbstractBURS_TreeNode p, byte goalnt, int indent){ 135 if (BURS.DEBUG) { 136 if (p == null) return; 137 int rule = STATE(p).rule(goalnt); 138 VM.sysWrite(STATE(p).getCost(goalnt)+"\t"); 139 for (int i = 0; i < indent; i++) 140 VM.sysWrite(' '); 141 VM.sysWrite(BURS_Debug.string[rule]+"\n"); 142 for (int i = 0; i < nts[rule].length; i++) 143 dumpCover(kids(p,rule,i), nts[rule][i], indent + 1); 144 } 145 } 146 147 // caution: MARK should be used in single threaded mode, 148 @Inline 149 public static void mark(AbstractBURS_TreeNode p, byte goalnt) { 150 if (p == null) return; 151 int rule = STATE(p).rule(goalnt); 152 byte act = action(rule); 153 if ((act & EMIT_INSTRUCTION) != 0) { 154 p.setNonTerminal(goalnt); 155 } 156 if (rule == 0) { 157 if (BURS.DEBUG) { 158 VM.sysWrite("marking " + p + " with a goalnt of " + goalnt + " failed as the rule " + rule + " has no action"); 159 } 160 throw new OptimizingCompilerException("BURS", "rule missing in ", 161 p.getInstructionString(), dumpTree("", p, 1)); 162 } 163 mark_kids(p,rule); 164 } 165/* 166 * This file is part of the Jikes RVM project (http://jikesrvm.org). 167 * 168 * This file is licensed to You under the Eclipse Public License (EPL); 169 * You may not use this file except in compliance with the License. You 170 * may obtain a copy of the License at 171 * 172 * http://www.opensource.org/licenses/eclipse-1.0.php 173 * 174 * See the COPYRIGHT.txt file distributed with this work for information 175 * regarding copyright ownership. 176 */ 177//ir.brg 178 179 /** 180 * Generate from ir.template and assembled rules files. 181 */ 182 /** Sorted rule number to unsorted rule number map */ 183 private static int[] unsortedErnMap = { 184 0, /* 0 - no rule */ 185 1, /* 1 - stm: r */ 186 3, /* 2 - r: czr */ 187 4, /* 3 - cz: czr */ 188 5, /* 4 - r: szpr */ 189 6, /* 5 - szp: szpr */ 190 7, /* 6 - riv: r */ 191 9, /* 7 - rlv: r */ 192 12, /* 8 - any: riv */ 193 82, /* 9 - address1scaledreg: address1reg */ 194 83, /* 10 - address: address1scaledreg */ 195 386, /* 11 - load8: sload8 */ 196 387, /* 12 - load8: uload8 */ 197 398, /* 13 - load16: sload16 */ 198 399, /* 14 - load16: uload16 */ 199 402, /* 15 - load16_32: load16 */ 200 403, /* 16 - load16_32: load32 */ 201 404, /* 17 - load8_16_32: load16_32 */ 202 405, /* 18 - load8_16_32: load8 */ 203 409, /* 19 - load8_16_32_64: load64 */ 204 410, /* 20 - load8_16_32_64: load8_16_32 */ 205 2, /* 21 - r: REGISTER */ 206 8, /* 22 - riv: INT_CONSTANT */ 207 10, /* 23 - rlv: LONG_CONSTANT */ 208 11, /* 24 - any: NULL */ 209 13, /* 25 - any: ADDRESS_CONSTANT */ 210 14, /* 26 - any: LONG_CONSTANT */ 211 16, /* 27 - stm: IG_PATCH_POINT */ 212 17, /* 28 - stm: UNINT_BEGIN */ 213 18, /* 29 - stm: UNINT_END */ 214 19, /* 30 - stm: YIELDPOINT_PROLOGUE */ 215 20, /* 31 - stm: YIELDPOINT_EPILOGUE */ 216 21, /* 32 - stm: YIELDPOINT_BACKEDGE */ 217 23, /* 33 - stm: RESOLVE */ 218 24, /* 34 - stm: NOP */ 219 25, /* 35 - r: GUARD_MOVE */ 220 26, /* 36 - r: GUARD_COMBINE */ 221 28, /* 37 - stm: IR_PROLOGUE */ 222 29, /* 38 - r: GET_CAUGHT_EXCEPTION */ 223 31, /* 39 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) */ 224 32, /* 40 - stm: TRAP */ 225 62, /* 41 - stm: GOTO */ 226 64, /* 42 - stm: WRITE_FLOOR */ 227 65, /* 43 - stm: READ_CEILING */ 228 66, /* 44 - stm: FENCE */ 229 67, /* 45 - stm: PAUSE */ 230 68, /* 46 - stm: RETURN(NULL) */ 231 69, /* 47 - stm: RETURN(INT_CONSTANT) */ 232 71, /* 48 - stm: RETURN(LONG_CONSTANT) */ 233 80, /* 49 - r: GET_TIME_BASE */ 234 614, /* 50 - stm: CLEAR_FLOATING_POINT_STATE */ 235 15, /* 51 - any: OTHER_OPERAND(any,any) */ 236 35, /* 52 - stm: TRAP_IF(r,r) */ 237 36, /* 53 - stm: TRAP_IF(load32,riv) */ 238 37, /* 54 - stm: TRAP_IF(riv,load32) */ 239 61, /* 55 - r: LONG_CMP(rlv,rlv) */ 240 72, /* 56 - r: CALL(r,any) */ 241 77, /* 57 - r: SYSCALL(r,any) */ 242 81, /* 58 - stm: YIELDPOINT_OSR(any,any) */ 243 87, /* 59 - address: INT_ADD(r,r) */ 244 90, /* 60 - address: INT_ADD(r,address1scaledreg) */ 245 91, /* 61 - address: INT_ADD(address1scaledreg,r) */ 246 93, /* 62 - address: INT_ADD(address1scaledreg,address1reg) */ 247 94, /* 63 - address: INT_ADD(address1reg,address1scaledreg) */ 248 98, /* 64 - address: LONG_ADD(r,r) */ 249 101, /* 65 - address: LONG_ADD(r,address1scaledreg) */ 250 102, /* 66 - address: LONG_ADD(address1scaledreg,r) */ 251 104, /* 67 - address: LONG_ADD(address1scaledreg,address1reg) */ 252 105, /* 68 - address: LONG_ADD(address1reg,address1scaledreg) */ 253 160, /* 69 - r: BOOLEAN_CMP_INT(r,riv) */ 254 161, /* 70 - boolcmp: BOOLEAN_CMP_INT(r,riv) */ 255 178, /* 71 - r: BOOLEAN_CMP_INT(load32,riv) */ 256 179, /* 72 - boolcmp: BOOLEAN_CMP_INT(load32,riv) */ 257 180, /* 73 - r: BOOLEAN_CMP_INT(r,load32) */ 258 181, /* 74 - boolcmp: BOOLEAN_CMP_INT(riv,load32) */ 259 184, /* 75 - r: BOOLEAN_CMP_LONG(r,rlv) */ 260 185, /* 76 - boolcmp: BOOLEAN_CMP_LONG(r,rlv) */ 261 193, /* 77 - r: BOOLEAN_CMP_LONG(load64,rlv) */ 262 194, /* 78 - boolcmp: BOOLEAN_CMP_LONG(load64,rlv) */ 263 195, /* 79 - r: BOOLEAN_CMP_LONG(r,load64) */ 264 196, /* 80 - boolcmp: BOOLEAN_CMP_LONG(rlv,load64) */ 265 240, /* 81 - czr: INT_ADD(r,riv) */ 266 241, /* 82 - r: INT_ADD(r,riv) */ 267 242, /* 83 - czr: INT_ADD(r,load32) */ 268 243, /* 84 - czr: INT_ADD(load32,riv) */ 269 248, /* 85 - szpr: INT_AND(r,riv) */ 270 249, /* 86 - szp: INT_AND(r,riv) */ 271 250, /* 87 - szpr: INT_AND(r,load32) */ 272 251, /* 88 - szpr: INT_AND(load32,riv) */ 273 252, /* 89 - szp: INT_AND(load8_16_32,riv) */ 274 253, /* 90 - szp: INT_AND(r,load8_16_32) */ 275 258, /* 91 - r: INT_DIV(riv,riv) */ 276 259, /* 92 - r: INT_DIV(riv,load32) */ 277 260, /* 93 - stm: INT_IFCMP(r,riv) */ 278 263, /* 94 - stm: INT_IFCMP(uload8,r) */ 279 264, /* 95 - stm: INT_IFCMP(r,uload8) */ 280 266, /* 96 - stm: INT_IFCMP(load32,riv) */ 281 267, /* 97 - stm: INT_IFCMP(r,load32) */ 282 273, /* 98 - stm: INT_IFCMP2(r,riv) */ 283 274, /* 99 - stm: INT_IFCMP2(load32,riv) */ 284 275, /* 100 - stm: INT_IFCMP2(riv,load32) */ 285 276, /* 101 - r: INT_LOAD(rlv,rlv) */ 286 277, /* 102 - r: INT_LOAD(rlv,address1scaledreg) */ 287 278, /* 103 - r: INT_LOAD(address1scaledreg,rlv) */ 288 279, /* 104 - r: INT_LOAD(address1scaledreg,address1reg) */ 289 280, /* 105 - r: INT_LOAD(address1reg,address1scaledreg) */ 290 282, /* 106 - r: INT_ALOAD(rlv,riv) */ 291 295, /* 107 - r: INT_MUL(r,riv) */ 292 296, /* 108 - r: INT_MUL(r,load32) */ 293 297, /* 109 - r: INT_MUL(load32,riv) */ 294 304, /* 110 - szpr: INT_OR(r,riv) */ 295 305, /* 111 - szpr: INT_OR(r,load32) */ 296 306, /* 112 - szpr: INT_OR(load32,riv) */ 297 311, /* 113 - r: INT_REM(riv,riv) */ 298 312, /* 114 - r: INT_REM(riv,load32) */ 299 322, /* 115 - szpr: INT_SHL(riv,riv) */ 300 331, /* 116 - szpr: INT_SHR(riv,riv) */ 301 343, /* 117 - czr: INT_SUB(riv,r) */ 302 344, /* 118 - r: INT_SUB(riv,r) */ 303 345, /* 119 - r: INT_SUB(load32,r) */ 304 346, /* 120 - czr: INT_SUB(riv,load32) */ 305 347, /* 121 - czr: INT_SUB(load32,riv) */ 306 353, /* 122 - szpr: INT_USHR(riv,riv) */ 307 359, /* 123 - szpr: INT_XOR(r,riv) */ 308 360, /* 124 - szpr: INT_XOR(r,load32) */ 309 361, /* 125 - szpr: INT_XOR(load32,riv) */ 310 370, /* 126 - r: LONG_ADD(address1scaledreg,r) */ 311 371, /* 127 - r: LONG_ADD(r,address1scaledreg) */ 312 372, /* 128 - r: LONG_ADD(address1scaledreg,address1reg) */ 313 373, /* 129 - r: LONG_ADD(address1reg,address1scaledreg) */ 314 376, /* 130 - r: BYTE_LOAD(rlv,rlv) */ 315 377, /* 131 - sload8: BYTE_LOAD(rlv,rlv) */ 316 378, /* 132 - r: BYTE_ALOAD(rlv,riv) */ 317 379, /* 133 - r: BYTE_ALOAD(rlv,r) */ 318 380, /* 134 - sload8: BYTE_ALOAD(rlv,riv) */ 319 381, /* 135 - r: UBYTE_LOAD(rlv,rlv) */ 320 382, /* 136 - uload8: UBYTE_LOAD(rlv,rlv) */ 321 383, /* 137 - r: UBYTE_ALOAD(rlv,riv) */ 322 384, /* 138 - r: UBYTE_ALOAD(rlv,r) */ 323 385, /* 139 - uload8: UBYTE_ALOAD(rlv,riv) */ 324 388, /* 140 - r: SHORT_LOAD(rlv,rlv) */ 325 389, /* 141 - sload16: SHORT_LOAD(rlv,rlv) */ 326 390, /* 142 - r: SHORT_ALOAD(rlv,riv) */ 327 391, /* 143 - r: SHORT_ALOAD(rlv,r) */ 328 392, /* 144 - sload16: SHORT_ALOAD(rlv,riv) */ 329 393, /* 145 - r: USHORT_LOAD(rlv,rlv) */ 330 394, /* 146 - uload16: USHORT_LOAD(rlv,rlv) */ 331 395, /* 147 - r: USHORT_ALOAD(rlv,riv) */ 332 396, /* 148 - r: USHORT_ALOAD(rlv,r) */ 333 397, /* 149 - uload16: USHORT_ALOAD(rlv,riv) */ 334 400, /* 150 - load32: INT_LOAD(rlv,rlv) */ 335 401, /* 151 - load32: INT_ALOAD(rlv,riv) */ 336 406, /* 152 - load64: LONG_LOAD(rlv,rlv) */ 337 407, /* 153 - load64: LONG_ALOAD(rlv,rlv) */ 338 408, /* 154 - load64: LONG_ALOAD(rlv,r) */ 339 422, /* 155 - czr: LONG_ADD(r,rlv) */ 340 423, /* 156 - czr: LONG_ADD(r,riv) */ 341 424, /* 157 - czr: LONG_ADD(r,r) */ 342 425, /* 158 - r: LONG_ADD(r,rlv) */ 343 426, /* 159 - czr: LONG_ADD(rlv,load64) */ 344 427, /* 160 - czr: LONG_ADD(load64,rlv) */ 345 432, /* 161 - szpr: LONG_AND(r,rlv) */ 346 433, /* 162 - szpr: LONG_AND(r,r) */ 347 434, /* 163 - szp: LONG_AND(r,rlv) */ 348 435, /* 164 - szpr: LONG_AND(rlv,load64) */ 349 436, /* 165 - szpr: LONG_AND(load64,rlv) */ 350 437, /* 166 - szp: LONG_AND(load8_16_32_64,rlv) */ 351 438, /* 167 - szp: LONG_AND(r,load8_16_32_64) */ 352 443, /* 168 - r: LONG_DIV(rlv,rlv) */ 353 444, /* 169 - r: LONG_DIV(rlv,riv) */ 354 445, /* 170 - r: LONG_DIV(riv,rlv) */ 355 446, /* 171 - r: LONG_DIV(rlv,load64) */ 356 447, /* 172 - r: LONG_DIV(load64,rlv) */ 357 448, /* 173 - stm: LONG_IFCMP(rlv,rlv) */ 358 450, /* 174 - r: LONG_LOAD(rlv,rlv) */ 359 451, /* 175 - r: LONG_LOAD(rlv,address1scaledreg) */ 360 452, /* 176 - r: LONG_LOAD(address1scaledreg,rlv) */ 361 453, /* 177 - r: LONG_LOAD(address1scaledreg,address1reg) */ 362 454, /* 178 - r: LONG_LOAD(address1reg,address1scaledreg) */ 363 456, /* 179 - r: LONG_ALOAD(rlv,riv) */ 364 457, /* 180 - r: LONG_ALOAD(rlv,r) */ 365 461, /* 181 - r: LONG_MUL(r,rlv) */ 366 462, /* 182 - r: INT_MUL(r,load64) */ 367 463, /* 183 - r: INT_MUL(load64,rlv) */ 368 470, /* 184 - szpr: LONG_OR(r,rlv) */ 369 471, /* 185 - szpr: LONG_OR(r,load64) */ 370 472, /* 186 - szpr: LONG_OR(load64,rlv) */ 371 477, /* 187 - r: LONG_REM(rlv,rlv) */ 372 478, /* 188 - r: LONG_REM(rlv,riv) */ 373 479, /* 189 - r: LONG_REM(riv,rlv) */ 374 480, /* 190 - r: LONG_REM(rlv,load64) */ 375 481, /* 191 - r: LONG_REM(load64,rlv) */ 376 483, /* 192 - szpr: LONG_SHL(rlv,riv) */ 377 492, /* 193 - szpr: LONG_SHR(rlv,riv) */ 378 504, /* 194 - czr: LONG_SUB(rlv,r) */ 379 505, /* 195 - r: LONG_SUB(rlv,r) */ 380 506, /* 196 - r: LONG_SUB(load64,r) */ 381 507, /* 197 - czr: LONG_SUB(rlv,load64) */ 382 508, /* 198 - czr: LONG_SUB(load64,rlv) */ 383 514, /* 199 - szpr: LONG_USHR(rlv,riv) */ 384 520, /* 200 - szpr: LONG_XOR(r,rlv) */ 385 521, /* 201 - szpr: LONG_XOR(r,load64) */ 386 522, /* 202 - szpr: LONG_XOR(load64,rlv) */ 387 527, /* 203 - r: FLOAT_ADD(r,r) */ 388 528, /* 204 - r: FLOAT_ADD(r,float_load) */ 389 529, /* 205 - r: FLOAT_ADD(float_load,r) */ 390 530, /* 206 - r: DOUBLE_ADD(r,r) */ 391 531, /* 207 - r: DOUBLE_ADD(r,double_load) */ 392 532, /* 208 - r: DOUBLE_ADD(double_load,r) */ 393 533, /* 209 - r: FLOAT_SUB(r,r) */ 394 534, /* 210 - r: FLOAT_SUB(r,float_load) */ 395 535, /* 211 - r: DOUBLE_SUB(r,r) */ 396 536, /* 212 - r: DOUBLE_SUB(r,double_load) */ 397 537, /* 213 - r: FLOAT_MUL(r,r) */ 398 538, /* 214 - r: FLOAT_MUL(r,float_load) */ 399 539, /* 215 - r: FLOAT_MUL(float_load,r) */ 400 540, /* 216 - r: DOUBLE_MUL(r,r) */ 401 541, /* 217 - r: DOUBLE_MUL(r,double_load) */ 402 542, /* 218 - r: DOUBLE_MUL(double_load,r) */ 403 543, /* 219 - r: FLOAT_DIV(r,r) */ 404 544, /* 220 - r: FLOAT_DIV(r,float_load) */ 405 545, /* 221 - r: DOUBLE_DIV(r,r) */ 406 546, /* 222 - r: DOUBLE_DIV(r,double_load) */ 407 551, /* 223 - r: FLOAT_REM(r,r) */ 408 552, /* 224 - r: DOUBLE_REM(r,r) */ 409 557, /* 225 - r: DOUBLE_LOAD(riv,riv) */ 410 558, /* 226 - r: DOUBLE_LOAD(riv,rlv) */ 411 559, /* 227 - r: DOUBLE_LOAD(rlv,rlv) */ 412 560, /* 228 - double_load: DOUBLE_LOAD(riv,riv) */ 413 561, /* 229 - r: DOUBLE_ALOAD(riv,riv) */ 414 562, /* 230 - double_load: DOUBLE_LOAD(rlv,rlv) */ 415 563, /* 231 - r: DOUBLE_ALOAD(riv,r) */ 416 564, /* 232 - r: DOUBLE_ALOAD(rlv,rlv) */ 417 565, /* 233 - double_load: DOUBLE_ALOAD(riv,riv) */ 418 566, /* 234 - r: FLOAT_LOAD(riv,riv) */ 419 567, /* 235 - r: FLOAT_LOAD(rlv,rlv) */ 420 568, /* 236 - float_load: FLOAT_LOAD(riv,riv) */ 421 569, /* 237 - r: FLOAT_ALOAD(riv,riv) */ 422 570, /* 238 - r: FLOAT_ALOAD(riv,r) */ 423 571, /* 239 - r: FLOAT_ALOAD(rlv,rlv) */ 424 572, /* 240 - float_load: FLOAT_ALOAD(riv,riv) */ 425 615, /* 241 - stm: FLOAT_IFCMP(r,r) */ 426 616, /* 242 - stm: FLOAT_IFCMP(r,float_load) */ 427 617, /* 243 - stm: FLOAT_IFCMP(float_load,r) */ 428 618, /* 244 - stm: DOUBLE_IFCMP(r,r) */ 429 619, /* 245 - stm: DOUBLE_IFCMP(r,double_load) */ 430 620, /* 246 - stm: DOUBLE_IFCMP(double_load,r) */ 431 22, /* 247 - stm: LOWTABLESWITCH(r) */ 432 27, /* 248 - stm: NULL_CHECK(riv) */ 433 30, /* 249 - stm: SET_CAUGHT_EXCEPTION(r) */ 434 33, /* 250 - stm: TRAP_IF(r,INT_CONSTANT) */ 435 34, /* 251 - stm: TRAP_IF(r,LONG_CONSTANT) */ 436 38, /* 252 - uload8: INT_AND(load8_16_32,INT_CONSTANT) */ 437 39, /* 253 - r: INT_AND(load8_16_32,INT_CONSTANT) */ 438 40, /* 254 - r: INT_2BYTE(load8_16_32) */ 439 42, /* 255 - r: INT_AND(load16_32,INT_CONSTANT) */ 440 63, /* 256 - stm: PREFETCH(r) */ 441 70, /* 257 - stm: RETURN(r) */ 442 84, /* 258 - address1scaledreg: INT_SHL(r,INT_CONSTANT) */ 443 85, /* 259 - address1reg: INT_ADD(r,LONG_CONSTANT) */ 444 86, /* 260 - address1reg: INT_MOVE(r) */ 445 88, /* 261 - address1reg: INT_ADD(address1reg,LONG_CONSTANT) */ 446 89, /* 262 - address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) */ 447 92, /* 263 - address: INT_ADD(address1scaledreg,LONG_CONSTANT) */ 448 95, /* 264 - address1scaledreg: LONG_SHL(r,INT_CONSTANT) */ 449 96, /* 265 - address1reg: LONG_ADD(r,LONG_CONSTANT) */ 450 97, /* 266 - address1reg: LONG_MOVE(r) */ 451 99, /* 267 - address1reg: LONG_ADD(address1reg,LONG_CONSTANT) */ 452 100, /* 268 - address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) */ 453 103, /* 269 - address: LONG_ADD(address1scaledreg,LONG_CONSTANT) */ 454 162, /* 270 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 455 163, /* 271 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 456 164, /* 272 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 457 165, /* 273 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) */ 458 166, /* 274 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 459 167, /* 275 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) */ 460 168, /* 276 - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) */ 461 169, /* 277 - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) */ 462 170, /* 278 - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) */ 463 171, /* 279 - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) */ 464 172, /* 280 - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) */ 465 173, /* 281 - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) */ 466 174, /* 282 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 467 175, /* 283 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 468 176, /* 284 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 469 177, /* 285 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 470 186, /* 286 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) */ 471 187, /* 287 - boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) */ 472 188, /* 288 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) */ 473 189, /* 289 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) */ 474 190, /* 290 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) */ 475 191, /* 291 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) */ 476 192, /* 292 - r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) */ 477 197, /* 293 - r: BOOLEAN_NOT(r) */ 478 206, /* 294 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 479 207, /* 295 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 480 208, /* 296 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 481 209, /* 297 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 482 221, /* 298 - r: INT_2BYTE(r) */ 483 222, /* 299 - r: INT_2BYTE(load8_16_32) */ 484 225, /* 300 - r: INT_2LONG(r) */ 485 226, /* 301 - r: INT_2LONG(load32) */ 486 229, /* 302 - r: INT_2ADDRZerExt(r) */ 487 230, /* 303 - r: INT_2SHORT(r) */ 488 231, /* 304 - r: INT_2SHORT(load16_32) */ 489 232, /* 305 - sload16: INT_2SHORT(load16_32) */ 490 235, /* 306 - szpr: INT_2USHORT(r) */ 491 236, /* 307 - uload16: INT_2USHORT(load16_32) */ 492 237, /* 308 - r: INT_2USHORT(load16_32) */ 493 261, /* 309 - stm: INT_IFCMP(r,INT_CONSTANT) */ 494 262, /* 310 - stm: INT_IFCMP(load8,INT_CONSTANT) */ 495 265, /* 311 - stm: INT_IFCMP(sload16,INT_CONSTANT) */ 496 268, /* 312 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 497 269, /* 313 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 498 270, /* 314 - stm: INT_IFCMP(cz,INT_CONSTANT) */ 499 271, /* 315 - stm: INT_IFCMP(szp,INT_CONSTANT) */ 500 272, /* 316 - stm: INT_IFCMP(bittest,INT_CONSTANT) */ 501 281, /* 317 - r: INT_LOAD(address,LONG_CONSTANT) */ 502 283, /* 318 - r: INT_MOVE(riv) */ 503 284, /* 319 - czr: INT_MOVE(czr) */ 504 285, /* 320 - cz: INT_MOVE(cz) */ 505 286, /* 321 - szpr: INT_MOVE(szpr) */ 506 287, /* 322 - szp: INT_MOVE(szp) */ 507 288, /* 323 - sload8: INT_MOVE(sload8) */ 508 289, /* 324 - uload8: INT_MOVE(uload8) */ 509 290, /* 325 - load8: INT_MOVE(load8) */ 510 291, /* 326 - sload16: INT_MOVE(sload16) */ 511 292, /* 327 - uload16: INT_MOVE(uload16) */ 512 293, /* 328 - load16: INT_MOVE(load16) */ 513 294, /* 329 - load32: INT_MOVE(load32) */ 514 298, /* 330 - szpr: INT_NEG(r) */ 515 301, /* 331 - r: INT_NOT(r) */ 516 323, /* 332 - szpr: INT_SHL(r,INT_CONSTANT) */ 517 324, /* 333 - r: INT_SHL(r,INT_CONSTANT) */ 518 332, /* 334 - szpr: INT_SHR(riv,INT_CONSTANT) */ 519 354, /* 335 - szpr: INT_USHR(riv,INT_CONSTANT) */ 520 374, /* 336 - r: LONG_ADD(address,LONG_CONSTANT) */ 521 375, /* 337 - r: LONG_MOVE(address) */ 522 411, /* 338 - r: LONG_2INT(r) */ 523 414, /* 339 - r: LONG_2INT(load64) */ 524 415, /* 340 - load32: LONG_2INT(load64) */ 525 449, /* 341 - stm: LONG_IFCMP(r,LONG_CONSTANT) */ 526 455, /* 342 - r: LONG_LOAD(address,LONG_CONSTANT) */ 527 458, /* 343 - r: LONG_MOVE(rlv) */ 528 459, /* 344 - r: LONG_MOVE(riv) */ 529 460, /* 345 - load64: LONG_MOVE(load64) */ 530 464, /* 346 - szpr: LONG_NEG(r) */ 531 467, /* 347 - r: LONG_NOT(r) */ 532 484, /* 348 - szpr: LONG_SHL(r,INT_CONSTANT) */ 533 485, /* 349 - r: LONG_SHL(r,INT_CONSTANT) */ 534 493, /* 350 - szpr: LONG_SHR(rlv,LONG_CONSTANT) */ 535 515, /* 351 - szpr: LONG_USHR(rlv,LONG_CONSTANT) */ 536 547, /* 352 - r: FLOAT_NEG(r) */ 537 548, /* 353 - r: DOUBLE_NEG(r) */ 538 549, /* 354 - r: FLOAT_SQRT(r) */ 539 550, /* 355 - r: DOUBLE_SQRT(r) */ 540 553, /* 356 - r: LONG_2FLOAT(r) */ 541 554, /* 357 - r: LONG_2DOUBLE(r) */ 542 555, /* 358 - r: FLOAT_MOVE(r) */ 543 556, /* 359 - r: DOUBLE_MOVE(r) */ 544 591, /* 360 - r: INT_2FLOAT(riv) */ 545 592, /* 361 - r: INT_2FLOAT(load32) */ 546 593, /* 362 - r: INT_2DOUBLE(riv) */ 547 594, /* 363 - r: INT_2DOUBLE(load32) */ 548 595, /* 364 - r: FLOAT_2DOUBLE(r) */ 549 596, /* 365 - r: FLOAT_2DOUBLE(float_load) */ 550 597, /* 366 - r: DOUBLE_2FLOAT(r) */ 551 598, /* 367 - r: DOUBLE_2FLOAT(double_load) */ 552 599, /* 368 - r: FLOAT_2INT(r) */ 553 600, /* 369 - r: FLOAT_2LONG(r) */ 554 601, /* 370 - r: DOUBLE_2INT(r) */ 555 602, /* 371 - r: DOUBLE_2LONG(r) */ 556 603, /* 372 - r: FLOAT_AS_INT_BITS(r) */ 557 604, /* 373 - load32: FLOAT_AS_INT_BITS(float_load) */ 558 605, /* 374 - r: DOUBLE_AS_LONG_BITS(r) */ 559 606, /* 375 - load64: DOUBLE_AS_LONG_BITS(double_load) */ 560 607, /* 376 - r: INT_BITS_AS_FLOAT(riv) */ 561 608, /* 377 - float_load: INT_BITS_AS_FLOAT(load32) */ 562 609, /* 378 - r: LONG_BITS_AS_DOUBLE(rlv) */ 563 610, /* 379 - double_load: LONG_BITS_AS_DOUBLE(load64) */ 564 611, /* 380 - r: MATERIALIZE_FP_CONSTANT(any) */ 565 612, /* 381 - float_load: MATERIALIZE_FP_CONSTANT(any) */ 566 613, /* 382 - double_load: MATERIALIZE_FP_CONSTANT(any) */ 567 41, /* 383 - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) */ 568 43, /* 384 - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) */ 569 152, /* 385 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 570 155, /* 386 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 571 227, /* 387 - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) */ 572 228, /* 388 - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) */ 573 325, /* 389 - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 574 416, /* 390 - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) */ 575 417, /* 391 - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) */ 576 418, /* 392 - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) */ 577 419, /* 393 - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) */ 578 420, /* 394 - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) */ 579 421, /* 395 - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) */ 580 486, /* 396 - szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 581 44, /* 397 - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) */ 582 45, /* 398 - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) */ 583 46, /* 399 - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) */ 584 47, /* 400 - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) */ 585 48, /* 401 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) */ 586 49, /* 402 - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) */ 587 50, /* 403 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) */ 588 51, /* 404 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) */ 589 52, /* 405 - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) */ 590 53, /* 406 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) */ 591 54, /* 407 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) */ 592 55, /* 408 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) */ 593 56, /* 409 - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 594 57, /* 410 - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 595 58, /* 411 - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) */ 596 182, /* 412 - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) */ 597 183, /* 413 - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) */ 598 200, /* 414 - stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) */ 599 201, /* 415 - stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) */ 600 202, /* 416 - stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) */ 601 203, /* 417 - stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) */ 602 204, /* 418 - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) */ 603 211, /* 419 - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) */ 604 212, /* 420 - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) */ 605 214, /* 421 - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) */ 606 215, /* 422 - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) */ 607 337, /* 423 - stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) */ 608 338, /* 424 - stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) */ 609 339, /* 425 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) */ 610 340, /* 426 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) */ 611 341, /* 427 - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) */ 612 366, /* 428 - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) */ 613 368, /* 429 - r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) */ 614 369, /* 430 - r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) */ 615 498, /* 431 - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) */ 616 499, /* 432 - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) */ 617 500, /* 433 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) */ 618 501, /* 434 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) */ 619 502, /* 435 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) */ 620 573, /* 436 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) */ 621 574, /* 437 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) */ 622 575, /* 438 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) */ 623 576, /* 439 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) */ 624 577, /* 440 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 625 578, /* 441 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) */ 626 579, /* 442 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) */ 627 580, /* 443 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 628 581, /* 444 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) */ 629 582, /* 445 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) */ 630 583, /* 446 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) */ 631 584, /* 447 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) */ 632 585, /* 448 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) */ 633 586, /* 449 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 634 587, /* 450 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) */ 635 588, /* 451 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) */ 636 589, /* 452 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 637 590, /* 453 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) */ 638 621, /* 454 - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) */ 639 622, /* 455 - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) */ 640 623, /* 456 - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) */ 641 624, /* 457 - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) */ 642 625, /* 458 - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) */ 643 626, /* 459 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) */ 644 631, /* 460 - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) */ 645 632, /* 461 - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) */ 646 649, /* 462 - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) */ 647 650, /* 463 - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) */ 648 651, /* 464 - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) */ 649 652, /* 465 - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) */ 650 59, /* 466 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) */ 651 60, /* 467 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) */ 652 73, /* 468 - r: CALL(BRANCH_TARGET,any) */ 653 75, /* 469 - r: CALL(INT_CONSTANT,any) */ 654 79, /* 470 - r: SYSCALL(INT_CONSTANT,any) */ 655 74, /* 471 - r: CALL(INT_LOAD(riv,riv),any) */ 656 76, /* 472 - r: CALL(LONG_LOAD(rlv,rlv),any) */ 657 78, /* 473 - r: SYSCALL(INT_LOAD(riv,riv),any) */ 658 106, /* 474 - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) */ 659 107, /* 475 - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) */ 660 108, /* 476 - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) */ 661 109, /* 477 - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) */ 662 110, /* 478 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) */ 663 111, /* 479 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) */ 664 112, /* 480 - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) */ 665 129, /* 481 - r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) */ 666 130, /* 482 - r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) */ 667 131, /* 483 - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) */ 668 132, /* 484 - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) */ 669 133, /* 485 - r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) */ 670 627, /* 486 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) */ 671 628, /* 487 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) */ 672 629, /* 488 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) */ 673 630, /* 489 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) */ 674 113, /* 490 - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) */ 675 134, /* 491 - r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) */ 676 114, /* 492 - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) */ 677 135, /* 493 - r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) */ 678 115, /* 494 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 679 116, /* 495 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 680 117, /* 496 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 681 118, /* 497 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 682 119, /* 498 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 683 122, /* 499 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 684 123, /* 500 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 685 124, /* 501 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 686 125, /* 502 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 687 126, /* 503 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 688 136, /* 504 - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 689 137, /* 505 - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 690 138, /* 506 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 691 139, /* 507 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 692 140, /* 508 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 693 143, /* 509 - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 694 144, /* 510 - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 695 145, /* 511 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 696 146, /* 512 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 697 147, /* 513 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 698 120, /* 514 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 699 127, /* 515 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 700 141, /* 516 - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 701 148, /* 517 - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 702 121, /* 518 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 703 128, /* 519 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 704 142, /* 520 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 705 149, /* 521 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) */ 706 150, /* 522 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 707 151, /* 523 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 708 153, /* 524 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 709 154, /* 525 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 710 156, /* 526 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) */ 711 157, /* 527 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) */ 712 158, /* 528 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) */ 713 159, /* 529 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) */ 714 198, /* 530 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 715 199, /* 531 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) */ 716 299, /* 532 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 717 300, /* 533 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 718 302, /* 534 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 719 303, /* 535 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 720 327, /* 536 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 721 329, /* 537 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 722 334, /* 538 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 723 336, /* 539 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 724 356, /* 540 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 725 358, /* 541 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 726 465, /* 542 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 727 466, /* 543 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 728 468, /* 544 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 729 469, /* 545 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 730 488, /* 546 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 731 490, /* 547 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 732 495, /* 548 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) */ 733 497, /* 549 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) */ 734 517, /* 550 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) */ 735 519, /* 551 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) */ 736 205, /* 552 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) */ 737 210, /* 553 - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) */ 738 213, /* 554 - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) */ 739 216, /* 555 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) */ 740 217, /* 556 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) */ 741 218, /* 557 - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) */ 742 219, /* 558 - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) */ 743 220, /* 559 - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) */ 744 367, /* 560 - r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) */ 745 223, /* 561 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) */ 746 224, /* 562 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) */ 747 233, /* 563 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) */ 748 234, /* 564 - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) */ 749 238, /* 565 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) */ 750 239, /* 566 - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) */ 751 412, /* 567 - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) */ 752 413, /* 568 - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) */ 753 244, /* 569 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 754 246, /* 570 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 755 254, /* 571 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 756 256, /* 572 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 757 307, /* 573 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 758 309, /* 574 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 759 348, /* 575 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 760 350, /* 576 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 761 362, /* 577 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 762 364, /* 578 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 763 428, /* 579 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 764 430, /* 580 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 765 439, /* 581 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 766 441, /* 582 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 767 473, /* 583 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 768 475, /* 584 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 769 509, /* 585 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 770 511, /* 586 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 771 523, /* 587 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 772 525, /* 588 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 773 245, /* 589 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 774 247, /* 590 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 775 255, /* 591 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 776 257, /* 592 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 777 308, /* 593 - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 778 310, /* 594 - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 779 349, /* 595 - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 780 351, /* 596 - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 781 363, /* 597 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 782 365, /* 598 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 783 429, /* 599 - stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 784 431, /* 600 - stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 785 440, /* 601 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 786 442, /* 602 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 787 474, /* 603 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 788 476, /* 604 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 789 510, /* 605 - stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 790 512, /* 606 - stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 791 524, /* 607 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 792 526, /* 608 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 793 313, /* 609 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) */ 794 314, /* 610 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) */ 795 315, /* 611 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) */ 796 316, /* 612 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) */ 797 317, /* 613 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) */ 798 320, /* 614 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) */ 799 318, /* 615 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) */ 800 319, /* 616 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) */ 801 321, /* 617 - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) */ 802 330, /* 618 - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) */ 803 342, /* 619 - stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) */ 804 352, /* 620 - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) */ 805 482, /* 621 - szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) */ 806 491, /* 622 - szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) */ 807 503, /* 623 - stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) */ 808 513, /* 624 - szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) */ 809 326, /* 625 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 810 328, /* 626 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 811 333, /* 627 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 812 335, /* 628 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 813 355, /* 629 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 814 357, /* 630 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 815 487, /* 631 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 816 489, /* 632 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 817 494, /* 633 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 818 496, /* 634 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 819 516, /* 635 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 820 518, /* 636 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 821 633, /* 637 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 822 634, /* 638 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 823 641, /* 639 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 824 642, /* 640 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 825 635, /* 641 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) */ 826 636, /* 642 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) */ 827 643, /* 643 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 828 644, /* 644 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 829 637, /* 645 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) */ 830 638, /* 646 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) */ 831 645, /* 647 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 832 646, /* 648 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 833 639, /* 649 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 834 640, /* 650 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 835 647, /* 651 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 836 }; 837 838 /** Ragged array for non-terminal leaves of r_NT, */ 839 private static final byte[] nts_0 = { r_NT, }; 840 /** Ragged array for non-terminal leaves of czr_NT, */ 841 private static final byte[] nts_1 = { czr_NT, }; 842 /** Ragged array for non-terminal leaves of szpr_NT, */ 843 private static final byte[] nts_2 = { szpr_NT, }; 844 /** Ragged array for non-terminal leaves of riv_NT, */ 845 private static final byte[] nts_3 = { riv_NT, }; 846 /** Ragged array for non-terminal leaves of address1reg_NT, */ 847 private static final byte[] nts_4 = { address1reg_NT, }; 848 /** Ragged array for non-terminal leaves of address1scaledreg_NT, */ 849 private static final byte[] nts_5 = { address1scaledreg_NT, }; 850 /** Ragged array for non-terminal leaves of sload8_NT, */ 851 private static final byte[] nts_6 = { sload8_NT, }; 852 /** Ragged array for non-terminal leaves of uload8_NT, */ 853 private static final byte[] nts_7 = { uload8_NT, }; 854 /** Ragged array for non-terminal leaves of sload16_NT, */ 855 private static final byte[] nts_8 = { sload16_NT, }; 856 /** Ragged array for non-terminal leaves of uload16_NT, */ 857 private static final byte[] nts_9 = { uload16_NT, }; 858 /** Ragged array for non-terminal leaves of load16_NT, */ 859 private static final byte[] nts_10 = { load16_NT, }; 860 /** Ragged array for non-terminal leaves of load32_NT, */ 861 private static final byte[] nts_11 = { load32_NT, }; 862 /** Ragged array for non-terminal leaves of load16_32_NT, */ 863 private static final byte[] nts_12 = { load16_32_NT, }; 864 /** Ragged array for non-terminal leaves of load8_NT, */ 865 private static final byte[] nts_13 = { load8_NT, }; 866 /** Ragged array for non-terminal leaves of load64_NT, */ 867 private static final byte[] nts_14 = { load64_NT, }; 868 /** Ragged array for non-terminal leaves of load8_16_32_NT, */ 869 private static final byte[] nts_15 = { load8_16_32_NT, }; 870 /** Ragged array for non-terminal leaves of */ 871 private static final byte[] nts_16 = { }; 872 /** Ragged array for non-terminal leaves of any_NT, any_NT, */ 873 private static final byte[] nts_17 = { any_NT, any_NT, }; 874 /** Ragged array for non-terminal leaves of r_NT, r_NT, */ 875 private static final byte[] nts_18 = { r_NT, r_NT, }; 876 /** Ragged array for non-terminal leaves of load32_NT, riv_NT, */ 877 private static final byte[] nts_19 = { load32_NT, riv_NT, }; 878 /** Ragged array for non-terminal leaves of riv_NT, load32_NT, */ 879 private static final byte[] nts_20 = { riv_NT, load32_NT, }; 880 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, */ 881 private static final byte[] nts_21 = { rlv_NT, rlv_NT, }; 882 /** Ragged array for non-terminal leaves of r_NT, any_NT, */ 883 private static final byte[] nts_22 = { r_NT, any_NT, }; 884 /** Ragged array for non-terminal leaves of r_NT, address1scaledreg_NT, */ 885 private static final byte[] nts_23 = { r_NT, address1scaledreg_NT, }; 886 /** Ragged array for non-terminal leaves of address1scaledreg_NT, r_NT, */ 887 private static final byte[] nts_24 = { address1scaledreg_NT, r_NT, }; 888 /** Ragged array for non-terminal leaves of address1scaledreg_NT, address1reg_NT, */ 889 private static final byte[] nts_25 = { address1scaledreg_NT, address1reg_NT, }; 890 /** Ragged array for non-terminal leaves of address1reg_NT, address1scaledreg_NT, */ 891 private static final byte[] nts_26 = { address1reg_NT, address1scaledreg_NT, }; 892 /** Ragged array for non-terminal leaves of r_NT, riv_NT, */ 893 private static final byte[] nts_27 = { r_NT, riv_NT, }; 894 /** Ragged array for non-terminal leaves of r_NT, load32_NT, */ 895 private static final byte[] nts_28 = { r_NT, load32_NT, }; 896 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, */ 897 private static final byte[] nts_29 = { r_NT, rlv_NT, }; 898 /** Ragged array for non-terminal leaves of load64_NT, rlv_NT, */ 899 private static final byte[] nts_30 = { load64_NT, rlv_NT, }; 900 /** Ragged array for non-terminal leaves of r_NT, load64_NT, */ 901 private static final byte[] nts_31 = { r_NT, load64_NT, }; 902 /** Ragged array for non-terminal leaves of rlv_NT, load64_NT, */ 903 private static final byte[] nts_32 = { rlv_NT, load64_NT, }; 904 /** Ragged array for non-terminal leaves of load8_16_32_NT, riv_NT, */ 905 private static final byte[] nts_33 = { load8_16_32_NT, riv_NT, }; 906 /** Ragged array for non-terminal leaves of r_NT, load8_16_32_NT, */ 907 private static final byte[] nts_34 = { r_NT, load8_16_32_NT, }; 908 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, */ 909 private static final byte[] nts_35 = { riv_NT, riv_NT, }; 910 /** Ragged array for non-terminal leaves of uload8_NT, r_NT, */ 911 private static final byte[] nts_36 = { uload8_NT, r_NT, }; 912 /** Ragged array for non-terminal leaves of r_NT, uload8_NT, */ 913 private static final byte[] nts_37 = { r_NT, uload8_NT, }; 914 /** Ragged array for non-terminal leaves of rlv_NT, address1scaledreg_NT, */ 915 private static final byte[] nts_38 = { rlv_NT, address1scaledreg_NT, }; 916 /** Ragged array for non-terminal leaves of address1scaledreg_NT, rlv_NT, */ 917 private static final byte[] nts_39 = { address1scaledreg_NT, rlv_NT, }; 918 /** Ragged array for non-terminal leaves of rlv_NT, riv_NT, */ 919 private static final byte[] nts_40 = { rlv_NT, riv_NT, }; 920 /** Ragged array for non-terminal leaves of riv_NT, r_NT, */ 921 private static final byte[] nts_41 = { riv_NT, r_NT, }; 922 /** Ragged array for non-terminal leaves of load32_NT, r_NT, */ 923 private static final byte[] nts_42 = { load32_NT, r_NT, }; 924 /** Ragged array for non-terminal leaves of rlv_NT, r_NT, */ 925 private static final byte[] nts_43 = { rlv_NT, r_NT, }; 926 /** Ragged array for non-terminal leaves of load8_16_32_64_NT, rlv_NT, */ 927 private static final byte[] nts_44 = { load8_16_32_64_NT, rlv_NT, }; 928 /** Ragged array for non-terminal leaves of r_NT, load8_16_32_64_NT, */ 929 private static final byte[] nts_45 = { r_NT, load8_16_32_64_NT, }; 930 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, */ 931 private static final byte[] nts_46 = { riv_NT, rlv_NT, }; 932 /** Ragged array for non-terminal leaves of load64_NT, r_NT, */ 933 private static final byte[] nts_47 = { load64_NT, r_NT, }; 934 /** Ragged array for non-terminal leaves of r_NT, float_load_NT, */ 935 private static final byte[] nts_48 = { r_NT, float_load_NT, }; 936 /** Ragged array for non-terminal leaves of float_load_NT, r_NT, */ 937 private static final byte[] nts_49 = { float_load_NT, r_NT, }; 938 /** Ragged array for non-terminal leaves of r_NT, double_load_NT, */ 939 private static final byte[] nts_50 = { r_NT, double_load_NT, }; 940 /** Ragged array for non-terminal leaves of double_load_NT, r_NT, */ 941 private static final byte[] nts_51 = { double_load_NT, r_NT, }; 942 /** Ragged array for non-terminal leaves of cz_NT, */ 943 private static final byte[] nts_52 = { cz_NT, }; 944 /** Ragged array for non-terminal leaves of szp_NT, */ 945 private static final byte[] nts_53 = { szp_NT, }; 946 /** Ragged array for non-terminal leaves of bittest_NT, */ 947 private static final byte[] nts_54 = { bittest_NT, }; 948 /** Ragged array for non-terminal leaves of boolcmp_NT, */ 949 private static final byte[] nts_55 = { boolcmp_NT, }; 950 /** Ragged array for non-terminal leaves of address_NT, */ 951 private static final byte[] nts_56 = { address_NT, }; 952 /** Ragged array for non-terminal leaves of rlv_NT, */ 953 private static final byte[] nts_57 = { rlv_NT, }; 954 /** Ragged array for non-terminal leaves of float_load_NT, */ 955 private static final byte[] nts_58 = { float_load_NT, }; 956 /** Ragged array for non-terminal leaves of double_load_NT, */ 957 private static final byte[] nts_59 = { double_load_NT, }; 958 /** Ragged array for non-terminal leaves of any_NT, */ 959 private static final byte[] nts_60 = { any_NT, }; 960 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, */ 961 private static final byte[] nts_61 = { riv_NT, riv_NT, riv_NT, }; 962 /** Ragged array for non-terminal leaves of load16_NT, riv_NT, riv_NT, */ 963 private static final byte[] nts_62 = { load16_NT, riv_NT, riv_NT, }; 964 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, rlv_NT, */ 965 private static final byte[] nts_63 = { rlv_NT, rlv_NT, rlv_NT, }; 966 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, rlv_NT, */ 967 private static final byte[] nts_64 = { riv_NT, rlv_NT, rlv_NT, }; 968 /** Ragged array for non-terminal leaves of riv_NT, r_NT, r_NT, */ 969 private static final byte[] nts_65 = { riv_NT, r_NT, r_NT, }; 970 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, riv_NT, */ 971 private static final byte[] nts_66 = { riv_NT, rlv_NT, riv_NT, }; 972 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, rlv_NT, */ 973 private static final byte[] nts_67 = { riv_NT, riv_NT, rlv_NT, }; 974 /** Ragged array for non-terminal leaves of r_NT, riv_NT, riv_NT, */ 975 private static final byte[] nts_68 = { r_NT, riv_NT, riv_NT, }; 976 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, rlv_NT, */ 977 private static final byte[] nts_69 = { r_NT, rlv_NT, rlv_NT, }; 978 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, */ 979 private static final byte[] nts_70 = { r_NT, r_NT, r_NT, }; 980 /** Ragged array for non-terminal leaves of boolcmp_NT, riv_NT, riv_NT, */ 981 private static final byte[] nts_71 = { boolcmp_NT, riv_NT, riv_NT, }; 982 /** Ragged array for non-terminal leaves of load8_NT, rlv_NT, rlv_NT, */ 983 private static final byte[] nts_72 = { load8_NT, rlv_NT, rlv_NT, }; 984 /** Ragged array for non-terminal leaves of load8_NT, rlv_NT, riv_NT, */ 985 private static final byte[] nts_73 = { load8_NT, rlv_NT, riv_NT, }; 986 /** Ragged array for non-terminal leaves of r_NT, riv_NT, any_NT, */ 987 private static final byte[] nts_74 = { r_NT, riv_NT, any_NT, }; 988 /** Ragged array for non-terminal leaves of uload8_NT, riv_NT, any_NT, */ 989 private static final byte[] nts_75 = { uload8_NT, riv_NT, any_NT, }; 990 /** Ragged array for non-terminal leaves of riv_NT, uload8_NT, any_NT, */ 991 private static final byte[] nts_76 = { riv_NT, uload8_NT, any_NT, }; 992 /** Ragged array for non-terminal leaves of load32_NT, riv_NT, any_NT, */ 993 private static final byte[] nts_77 = { load32_NT, riv_NT, any_NT, }; 994 /** Ragged array for non-terminal leaves of riv_NT, load32_NT, any_NT, */ 995 private static final byte[] nts_78 = { riv_NT, load32_NT, any_NT, }; 996 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, address1scaledreg_NT, */ 997 private static final byte[] nts_79 = { riv_NT, rlv_NT, address1scaledreg_NT, }; 998 /** Ragged array for non-terminal leaves of riv_NT, address1scaledreg_NT, rlv_NT, */ 999 private static final byte[] nts_80 = { riv_NT, address1scaledreg_NT, rlv_NT, }; 1000 /** Ragged array for non-terminal leaves of riv_NT, address1scaledreg_NT, address1reg_NT, */ 1001 private static final byte[] nts_81 = { riv_NT, address1scaledreg_NT, address1reg_NT, }; 1002 /** Ragged array for non-terminal leaves of riv_NT, address1reg_NT, address1scaledreg_NT, */ 1003 private static final byte[] nts_82 = { riv_NT, address1reg_NT, address1scaledreg_NT, }; 1004 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, any_NT, */ 1005 private static final byte[] nts_83 = { r_NT, rlv_NT, any_NT, }; 1006 /** Ragged array for non-terminal leaves of load64_NT, rlv_NT, any_NT, */ 1007 private static final byte[] nts_84 = { load64_NT, rlv_NT, any_NT, }; 1008 /** Ragged array for non-terminal leaves of rlv_NT, load64_NT, any_NT, */ 1009 private static final byte[] nts_85 = { rlv_NT, load64_NT, any_NT, }; 1010 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, address1scaledreg_NT, */ 1011 private static final byte[] nts_86 = { rlv_NT, rlv_NT, address1scaledreg_NT, }; 1012 /** Ragged array for non-terminal leaves of rlv_NT, address1scaledreg_NT, rlv_NT, */ 1013 private static final byte[] nts_87 = { rlv_NT, address1scaledreg_NT, rlv_NT, }; 1014 /** Ragged array for non-terminal leaves of rlv_NT, address1scaledreg_NT, address1reg_NT, */ 1015 private static final byte[] nts_88 = { rlv_NT, address1scaledreg_NT, address1reg_NT, }; 1016 /** Ragged array for non-terminal leaves of rlv_NT, address1reg_NT, address1scaledreg_NT, */ 1017 private static final byte[] nts_89 = { rlv_NT, address1reg_NT, address1scaledreg_NT, }; 1018 /** Ragged array for non-terminal leaves of r_NT, riv_NT, rlv_NT, */ 1019 private static final byte[] nts_90 = { r_NT, riv_NT, rlv_NT, }; 1020 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, riv_NT, */ 1021 private static final byte[] nts_91 = { r_NT, rlv_NT, riv_NT, }; 1022 /** Ragged array for non-terminal leaves of r_NT, r_NT, any_NT, */ 1023 private static final byte[] nts_92 = { r_NT, r_NT, any_NT, }; 1024 /** Ragged array for non-terminal leaves of r_NT, float_load_NT, any_NT, */ 1025 private static final byte[] nts_93 = { r_NT, float_load_NT, any_NT, }; 1026 /** Ragged array for non-terminal leaves of r_NT, double_load_NT, any_NT, */ 1027 private static final byte[] nts_94 = { r_NT, double_load_NT, any_NT, }; 1028 /** Ragged array for non-terminal leaves of float_load_NT, r_NT, any_NT, */ 1029 private static final byte[] nts_95 = { float_load_NT, r_NT, any_NT, }; 1030 /** Ragged array for non-terminal leaves of double_load_NT, r_NT, any_NT, */ 1031 private static final byte[] nts_96 = { double_load_NT, r_NT, any_NT, }; 1032 /** Ragged array for non-terminal leaves of load64_NT, riv_NT, riv_NT, */ 1033 private static final byte[] nts_97 = { load64_NT, riv_NT, riv_NT, }; 1034 /** Ragged array for non-terminal leaves of load64_NT, rlv_NT, riv_NT, */ 1035 private static final byte[] nts_98 = { load64_NT, rlv_NT, riv_NT, }; 1036 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, any_NT, */ 1037 private static final byte[] nts_99 = { riv_NT, riv_NT, any_NT, }; 1038 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, any_NT, */ 1039 private static final byte[] nts_100 = { rlv_NT, rlv_NT, any_NT, }; 1040 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, riv_NT, */ 1041 private static final byte[] nts_101 = { riv_NT, riv_NT, riv_NT, riv_NT, }; 1042 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, riv_NT, riv_NT, */ 1043 private static final byte[] nts_102 = { riv_NT, rlv_NT, riv_NT, riv_NT, }; 1044 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, riv_NT, riv_NT, */ 1045 private static final byte[] nts_103 = { rlv_NT, rlv_NT, riv_NT, riv_NT, }; 1046 /** Ragged array for non-terminal leaves of r_NT, address1scaledreg_NT, riv_NT, riv_NT, */ 1047 private static final byte[] nts_104 = { r_NT, address1scaledreg_NT, riv_NT, riv_NT, }; 1048 /** Ragged array for non-terminal leaves of address1scaledreg_NT, r_NT, riv_NT, riv_NT, */ 1049 private static final byte[] nts_105 = { address1scaledreg_NT, r_NT, riv_NT, riv_NT, }; 1050 /** Ragged array for non-terminal leaves of address1scaledreg_NT, address1reg_NT, riv_NT, riv_NT, */ 1051 private static final byte[] nts_106 = { address1scaledreg_NT, address1reg_NT, riv_NT, riv_NT, }; 1052 /** Ragged array for non-terminal leaves of address1reg_NT, address1scaledreg_NT, riv_NT, riv_NT, */ 1053 private static final byte[] nts_107 = { address1reg_NT, address1scaledreg_NT, riv_NT, riv_NT, }; 1054 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, rlv_NT, rlv_NT, */ 1055 private static final byte[] nts_108 = { rlv_NT, rlv_NT, rlv_NT, rlv_NT, }; 1056 /** Ragged array for non-terminal leaves of r_NT, address1scaledreg_NT, rlv_NT, rlv_NT, */ 1057 private static final byte[] nts_109 = { r_NT, address1scaledreg_NT, rlv_NT, rlv_NT, }; 1058 /** Ragged array for non-terminal leaves of address1scaledreg_NT, r_NT, rlv_NT, rlv_NT, */ 1059 private static final byte[] nts_110 = { address1scaledreg_NT, r_NT, rlv_NT, rlv_NT, }; 1060 /** Ragged array for non-terminal leaves of address1scaledreg_NT, address1reg_NT, rlv_NT, rlv_NT, */ 1061 private static final byte[] nts_111 = { address1scaledreg_NT, address1reg_NT, rlv_NT, rlv_NT, }; 1062 /** Ragged array for non-terminal leaves of address1reg_NT, address1scaledreg_NT, rlv_NT, rlv_NT, */ 1063 private static final byte[] nts_112 = { address1reg_NT, address1scaledreg_NT, rlv_NT, rlv_NT, }; 1064 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, float_load_NT, */ 1065 private static final byte[] nts_113 = { r_NT, r_NT, r_NT, float_load_NT, }; 1066 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, double_load_NT, */ 1067 private static final byte[] nts_114 = { r_NT, r_NT, r_NT, double_load_NT, }; 1068 /** Ragged array for non-terminal leaves of r_NT, r_NT, float_load_NT, r_NT, */ 1069 private static final byte[] nts_115 = { r_NT, r_NT, float_load_NT, r_NT, }; 1070 /** Ragged array for non-terminal leaves of r_NT, r_NT, double_load_NT, r_NT, */ 1071 private static final byte[] nts_116 = { r_NT, r_NT, double_load_NT, r_NT, }; 1072 /** Ragged array for non-terminal leaves of address_NT, riv_NT, riv_NT, */ 1073 private static final byte[] nts_117 = { address_NT, riv_NT, riv_NT, }; 1074 /** Ragged array for non-terminal leaves of address_NT, rlv_NT, rlv_NT, */ 1075 private static final byte[] nts_118 = { address_NT, rlv_NT, rlv_NT, }; 1076 /** Ragged array for non-terminal leaves of rlv_NT, riv_NT, rlv_NT, riv_NT, */ 1077 private static final byte[] nts_119 = { rlv_NT, riv_NT, rlv_NT, riv_NT, }; 1078 /** Ragged array for non-terminal leaves of load8_NT, any_NT, */ 1079 private static final byte[] nts_120 = { load8_NT, any_NT, }; 1080 /** Ragged array for non-terminal leaves of sload16_NT, any_NT, */ 1081 private static final byte[] nts_121 = { sload16_NT, any_NT, }; 1082 /** Ragged array for non-terminal leaves of boolcmp_NT, any_NT, */ 1083 private static final byte[] nts_122 = { boolcmp_NT, any_NT, }; 1084 /** Ragged array for non-terminal leaves of bittest_NT, any_NT, */ 1085 private static final byte[] nts_123 = { bittest_NT, any_NT, }; 1086 /** Ragged array for non-terminal leaves of cz_NT, any_NT, */ 1087 private static final byte[] nts_124 = { cz_NT, any_NT, }; 1088 /** Ragged array for non-terminal leaves of szp_NT, any_NT, */ 1089 private static final byte[] nts_125 = { szp_NT, any_NT, }; 1090 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, riv_NT, riv_NT, */ 1091 private static final byte[] nts_126 = { riv_NT, riv_NT, riv_NT, riv_NT, riv_NT, }; 1092 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, */ 1093 private static final byte[] nts_127 = { rlv_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, }; 1094 /** Ragged array for non-terminal leaves of r_NT, riv_NT, riv_NT, riv_NT, riv_NT, */ 1095 private static final byte[] nts_128 = { r_NT, riv_NT, riv_NT, riv_NT, riv_NT, }; 1096 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, */ 1097 private static final byte[] nts_129 = { r_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, }; 1098 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, r_NT, */ 1099 private static final byte[] nts_130 = { r_NT, r_NT, r_NT, r_NT, }; 1100 /** Ragged array for non-terminal leaves of riv_NT, address_NT, */ 1101 private static final byte[] nts_131 = { riv_NT, address_NT, }; 1102 /** Ragged array for non-terminal leaves of rlv_NT, address_NT, */ 1103 private static final byte[] nts_132 = { rlv_NT, address_NT, }; 1104 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, r_NT, riv_NT, riv_NT, */ 1105 private static final byte[] nts_133 = { riv_NT, riv_NT, r_NT, riv_NT, riv_NT, }; 1106 1107 /** Map non-terminal to non-terminal leaves */ 1108 private static final byte[][] nts = { 1109 null, /* 0 */ 1110 nts_0, // 1 - stm: r 1111 nts_1, // 2 - r: czr 1112 nts_1, // 3 - cz: czr 1113 nts_2, // 4 - r: szpr 1114 nts_2, // 5 - szp: szpr 1115 nts_0, // 6 - riv: r 1116 nts_0, // 7 - rlv: r 1117 nts_3, // 8 - any: riv 1118 nts_4, // 9 - address1scaledreg: address1reg 1119 nts_5, // 10 - address: address1scaledreg 1120 nts_6, // 11 - load8: sload8 1121 nts_7, // 12 - load8: uload8 1122 nts_8, // 13 - load16: sload16 1123 nts_9, // 14 - load16: uload16 1124 nts_10, // 15 - load16_32: load16 1125 nts_11, // 16 - load16_32: load32 1126 nts_12, // 17 - load8_16_32: load16_32 1127 nts_13, // 18 - load8_16_32: load8 1128 nts_14, // 19 - load8_16_32_64: load64 1129 nts_15, // 20 - load8_16_32_64: load8_16_32 1130 nts_16, // 21 - r: REGISTER 1131 nts_16, // 22 - riv: INT_CONSTANT 1132 nts_16, // 23 - rlv: LONG_CONSTANT 1133 nts_16, // 24 - any: NULL 1134 nts_16, // 25 - any: ADDRESS_CONSTANT 1135 nts_16, // 26 - any: LONG_CONSTANT 1136 nts_16, // 27 - stm: IG_PATCH_POINT 1137 nts_16, // 28 - stm: UNINT_BEGIN 1138 nts_16, // 29 - stm: UNINT_END 1139 nts_16, // 30 - stm: YIELDPOINT_PROLOGUE 1140 nts_16, // 31 - stm: YIELDPOINT_EPILOGUE 1141 nts_16, // 32 - stm: YIELDPOINT_BACKEDGE 1142 nts_16, // 33 - stm: RESOLVE 1143 nts_16, // 34 - stm: NOP 1144 nts_16, // 35 - r: GUARD_MOVE 1145 nts_16, // 36 - r: GUARD_COMBINE 1146 nts_16, // 37 - stm: IR_PROLOGUE 1147 nts_16, // 38 - r: GET_CAUGHT_EXCEPTION 1148 nts_16, // 39 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 1149 nts_16, // 40 - stm: TRAP 1150 nts_16, // 41 - stm: GOTO 1151 nts_16, // 42 - stm: WRITE_FLOOR 1152 nts_16, // 43 - stm: READ_CEILING 1153 nts_16, // 44 - stm: FENCE 1154 nts_16, // 45 - stm: PAUSE 1155 nts_16, // 46 - stm: RETURN(NULL) 1156 nts_16, // 47 - stm: RETURN(INT_CONSTANT) 1157 nts_16, // 48 - stm: RETURN(LONG_CONSTANT) 1158 nts_16, // 49 - r: GET_TIME_BASE 1159 nts_16, // 50 - stm: CLEAR_FLOATING_POINT_STATE 1160 nts_17, // 51 - any: OTHER_OPERAND(any,any) 1161 nts_18, // 52 - stm: TRAP_IF(r,r) 1162 nts_19, // 53 - stm: TRAP_IF(load32,riv) 1163 nts_20, // 54 - stm: TRAP_IF(riv,load32) 1164 nts_21, // 55 - r: LONG_CMP(rlv,rlv) 1165 nts_22, // 56 - r: CALL(r,any) 1166 nts_22, // 57 - r: SYSCALL(r,any) 1167 nts_17, // 58 - stm: YIELDPOINT_OSR(any,any) 1168 nts_18, // 59 - address: INT_ADD(r,r) 1169 nts_23, // 60 - address: INT_ADD(r,address1scaledreg) 1170 nts_24, // 61 - address: INT_ADD(address1scaledreg,r) 1171 nts_25, // 62 - address: INT_ADD(address1scaledreg,address1reg) 1172 nts_26, // 63 - address: INT_ADD(address1reg,address1scaledreg) 1173 nts_18, // 64 - address: LONG_ADD(r,r) 1174 nts_23, // 65 - address: LONG_ADD(r,address1scaledreg) 1175 nts_24, // 66 - address: LONG_ADD(address1scaledreg,r) 1176 nts_25, // 67 - address: LONG_ADD(address1scaledreg,address1reg) 1177 nts_26, // 68 - address: LONG_ADD(address1reg,address1scaledreg) 1178 nts_27, // 69 - r: BOOLEAN_CMP_INT(r,riv) 1179 nts_27, // 70 - boolcmp: BOOLEAN_CMP_INT(r,riv) 1180 nts_19, // 71 - r: BOOLEAN_CMP_INT(load32,riv) 1181 nts_19, // 72 - boolcmp: BOOLEAN_CMP_INT(load32,riv) 1182 nts_28, // 73 - r: BOOLEAN_CMP_INT(r,load32) 1183 nts_20, // 74 - boolcmp: BOOLEAN_CMP_INT(riv,load32) 1184 nts_29, // 75 - r: BOOLEAN_CMP_LONG(r,rlv) 1185 nts_29, // 76 - boolcmp: BOOLEAN_CMP_LONG(r,rlv) 1186 nts_30, // 77 - r: BOOLEAN_CMP_LONG(load64,rlv) 1187 nts_30, // 78 - boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 1188 nts_31, // 79 - r: BOOLEAN_CMP_LONG(r,load64) 1189 nts_32, // 80 - boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 1190 nts_27, // 81 - czr: INT_ADD(r,riv) 1191 nts_27, // 82 - r: INT_ADD(r,riv) 1192 nts_28, // 83 - czr: INT_ADD(r,load32) 1193 nts_19, // 84 - czr: INT_ADD(load32,riv) 1194 nts_27, // 85 - szpr: INT_AND(r,riv) 1195 nts_27, // 86 - szp: INT_AND(r,riv) 1196 nts_28, // 87 - szpr: INT_AND(r,load32) 1197 nts_19, // 88 - szpr: INT_AND(load32,riv) 1198 nts_33, // 89 - szp: INT_AND(load8_16_32,riv) 1199 nts_34, // 90 - szp: INT_AND(r,load8_16_32) 1200 nts_35, // 91 - r: INT_DIV(riv,riv) 1201 nts_20, // 92 - r: INT_DIV(riv,load32) 1202 nts_27, // 93 - stm: INT_IFCMP(r,riv) 1203 nts_36, // 94 - stm: INT_IFCMP(uload8,r) 1204 nts_37, // 95 - stm: INT_IFCMP(r,uload8) 1205 nts_19, // 96 - stm: INT_IFCMP(load32,riv) 1206 nts_28, // 97 - stm: INT_IFCMP(r,load32) 1207 nts_27, // 98 - stm: INT_IFCMP2(r,riv) 1208 nts_19, // 99 - stm: INT_IFCMP2(load32,riv) 1209 nts_20, // 100 - stm: INT_IFCMP2(riv,load32) 1210 nts_21, // 101 - r: INT_LOAD(rlv,rlv) 1211 nts_38, // 102 - r: INT_LOAD(rlv,address1scaledreg) 1212 nts_39, // 103 - r: INT_LOAD(address1scaledreg,rlv) 1213 nts_25, // 104 - r: INT_LOAD(address1scaledreg,address1reg) 1214 nts_26, // 105 - r: INT_LOAD(address1reg,address1scaledreg) 1215 nts_40, // 106 - r: INT_ALOAD(rlv,riv) 1216 nts_27, // 107 - r: INT_MUL(r,riv) 1217 nts_28, // 108 - r: INT_MUL(r,load32) 1218 nts_19, // 109 - r: INT_MUL(load32,riv) 1219 nts_27, // 110 - szpr: INT_OR(r,riv) 1220 nts_28, // 111 - szpr: INT_OR(r,load32) 1221 nts_19, // 112 - szpr: INT_OR(load32,riv) 1222 nts_35, // 113 - r: INT_REM(riv,riv) 1223 nts_20, // 114 - r: INT_REM(riv,load32) 1224 nts_35, // 115 - szpr: INT_SHL(riv,riv) 1225 nts_35, // 116 - szpr: INT_SHR(riv,riv) 1226 nts_41, // 117 - czr: INT_SUB(riv,r) 1227 nts_41, // 118 - r: INT_SUB(riv,r) 1228 nts_42, // 119 - r: INT_SUB(load32,r) 1229 nts_20, // 120 - czr: INT_SUB(riv,load32) 1230 nts_19, // 121 - czr: INT_SUB(load32,riv) 1231 nts_35, // 122 - szpr: INT_USHR(riv,riv) 1232 nts_27, // 123 - szpr: INT_XOR(r,riv) 1233 nts_28, // 124 - szpr: INT_XOR(r,load32) 1234 nts_19, // 125 - szpr: INT_XOR(load32,riv) 1235 nts_24, // 126 - r: LONG_ADD(address1scaledreg,r) 1236 nts_23, // 127 - r: LONG_ADD(r,address1scaledreg) 1237 nts_25, // 128 - r: LONG_ADD(address1scaledreg,address1reg) 1238 nts_26, // 129 - r: LONG_ADD(address1reg,address1scaledreg) 1239 nts_21, // 130 - r: BYTE_LOAD(rlv,rlv) 1240 nts_21, // 131 - sload8: BYTE_LOAD(rlv,rlv) 1241 nts_40, // 132 - r: BYTE_ALOAD(rlv,riv) 1242 nts_43, // 133 - r: BYTE_ALOAD(rlv,r) 1243 nts_40, // 134 - sload8: BYTE_ALOAD(rlv,riv) 1244 nts_21, // 135 - r: UBYTE_LOAD(rlv,rlv) 1245 nts_21, // 136 - uload8: UBYTE_LOAD(rlv,rlv) 1246 nts_40, // 137 - r: UBYTE_ALOAD(rlv,riv) 1247 nts_43, // 138 - r: UBYTE_ALOAD(rlv,r) 1248 nts_40, // 139 - uload8: UBYTE_ALOAD(rlv,riv) 1249 nts_21, // 140 - r: SHORT_LOAD(rlv,rlv) 1250 nts_21, // 141 - sload16: SHORT_LOAD(rlv,rlv) 1251 nts_40, // 142 - r: SHORT_ALOAD(rlv,riv) 1252 nts_43, // 143 - r: SHORT_ALOAD(rlv,r) 1253 nts_40, // 144 - sload16: SHORT_ALOAD(rlv,riv) 1254 nts_21, // 145 - r: USHORT_LOAD(rlv,rlv) 1255 nts_21, // 146 - uload16: USHORT_LOAD(rlv,rlv) 1256 nts_40, // 147 - r: USHORT_ALOAD(rlv,riv) 1257 nts_43, // 148 - r: USHORT_ALOAD(rlv,r) 1258 nts_40, // 149 - uload16: USHORT_ALOAD(rlv,riv) 1259 nts_21, // 150 - load32: INT_LOAD(rlv,rlv) 1260 nts_40, // 151 - load32: INT_ALOAD(rlv,riv) 1261 nts_21, // 152 - load64: LONG_LOAD(rlv,rlv) 1262 nts_21, // 153 - load64: LONG_ALOAD(rlv,rlv) 1263 nts_43, // 154 - load64: LONG_ALOAD(rlv,r) 1264 nts_29, // 155 - czr: LONG_ADD(r,rlv) 1265 nts_27, // 156 - czr: LONG_ADD(r,riv) 1266 nts_18, // 157 - czr: LONG_ADD(r,r) 1267 nts_29, // 158 - r: LONG_ADD(r,rlv) 1268 nts_32, // 159 - czr: LONG_ADD(rlv,load64) 1269 nts_30, // 160 - czr: LONG_ADD(load64,rlv) 1270 nts_29, // 161 - szpr: LONG_AND(r,rlv) 1271 nts_18, // 162 - szpr: LONG_AND(r,r) 1272 nts_29, // 163 - szp: LONG_AND(r,rlv) 1273 nts_32, // 164 - szpr: LONG_AND(rlv,load64) 1274 nts_30, // 165 - szpr: LONG_AND(load64,rlv) 1275 nts_44, // 166 - szp: LONG_AND(load8_16_32_64,rlv) 1276 nts_45, // 167 - szp: LONG_AND(r,load8_16_32_64) 1277 nts_21, // 168 - r: LONG_DIV(rlv,rlv) 1278 nts_40, // 169 - r: LONG_DIV(rlv,riv) 1279 nts_46, // 170 - r: LONG_DIV(riv,rlv) 1280 nts_32, // 171 - r: LONG_DIV(rlv,load64) 1281 nts_30, // 172 - r: LONG_DIV(load64,rlv) 1282 nts_21, // 173 - stm: LONG_IFCMP(rlv,rlv) 1283 nts_21, // 174 - r: LONG_LOAD(rlv,rlv) 1284 nts_38, // 175 - r: LONG_LOAD(rlv,address1scaledreg) 1285 nts_39, // 176 - r: LONG_LOAD(address1scaledreg,rlv) 1286 nts_25, // 177 - r: LONG_LOAD(address1scaledreg,address1reg) 1287 nts_26, // 178 - r: LONG_LOAD(address1reg,address1scaledreg) 1288 nts_40, // 179 - r: LONG_ALOAD(rlv,riv) 1289 nts_43, // 180 - r: LONG_ALOAD(rlv,r) 1290 nts_29, // 181 - r: LONG_MUL(r,rlv) 1291 nts_31, // 182 - r: INT_MUL(r,load64) 1292 nts_30, // 183 - r: INT_MUL(load64,rlv) 1293 nts_29, // 184 - szpr: LONG_OR(r,rlv) 1294 nts_31, // 185 - szpr: LONG_OR(r,load64) 1295 nts_30, // 186 - szpr: LONG_OR(load64,rlv) 1296 nts_21, // 187 - r: LONG_REM(rlv,rlv) 1297 nts_40, // 188 - r: LONG_REM(rlv,riv) 1298 nts_46, // 189 - r: LONG_REM(riv,rlv) 1299 nts_32, // 190 - r: LONG_REM(rlv,load64) 1300 nts_30, // 191 - r: LONG_REM(load64,rlv) 1301 nts_40, // 192 - szpr: LONG_SHL(rlv,riv) 1302 nts_40, // 193 - szpr: LONG_SHR(rlv,riv) 1303 nts_43, // 194 - czr: LONG_SUB(rlv,r) 1304 nts_43, // 195 - r: LONG_SUB(rlv,r) 1305 nts_47, // 196 - r: LONG_SUB(load64,r) 1306 nts_32, // 197 - czr: LONG_SUB(rlv,load64) 1307 nts_30, // 198 - czr: LONG_SUB(load64,rlv) 1308 nts_40, // 199 - szpr: LONG_USHR(rlv,riv) 1309 nts_29, // 200 - szpr: LONG_XOR(r,rlv) 1310 nts_31, // 201 - szpr: LONG_XOR(r,load64) 1311 nts_30, // 202 - szpr: LONG_XOR(load64,rlv) 1312 nts_18, // 203 - r: FLOAT_ADD(r,r) 1313 nts_48, // 204 - r: FLOAT_ADD(r,float_load) 1314 nts_49, // 205 - r: FLOAT_ADD(float_load,r) 1315 nts_18, // 206 - r: DOUBLE_ADD(r,r) 1316 nts_50, // 207 - r: DOUBLE_ADD(r,double_load) 1317 nts_51, // 208 - r: DOUBLE_ADD(double_load,r) 1318 nts_18, // 209 - r: FLOAT_SUB(r,r) 1319 nts_48, // 210 - r: FLOAT_SUB(r,float_load) 1320 nts_18, // 211 - r: DOUBLE_SUB(r,r) 1321 nts_50, // 212 - r: DOUBLE_SUB(r,double_load) 1322 nts_18, // 213 - r: FLOAT_MUL(r,r) 1323 nts_48, // 214 - r: FLOAT_MUL(r,float_load) 1324 nts_49, // 215 - r: FLOAT_MUL(float_load,r) 1325 nts_18, // 216 - r: DOUBLE_MUL(r,r) 1326 nts_50, // 217 - r: DOUBLE_MUL(r,double_load) 1327 nts_51, // 218 - r: DOUBLE_MUL(double_load,r) 1328 nts_18, // 219 - r: FLOAT_DIV(r,r) 1329 nts_48, // 220 - r: FLOAT_DIV(r,float_load) 1330 nts_18, // 221 - r: DOUBLE_DIV(r,r) 1331 nts_50, // 222 - r: DOUBLE_DIV(r,double_load) 1332 nts_18, // 223 - r: FLOAT_REM(r,r) 1333 nts_18, // 224 - r: DOUBLE_REM(r,r) 1334 nts_35, // 225 - r: DOUBLE_LOAD(riv,riv) 1335 nts_46, // 226 - r: DOUBLE_LOAD(riv,rlv) 1336 nts_21, // 227 - r: DOUBLE_LOAD(rlv,rlv) 1337 nts_35, // 228 - double_load: DOUBLE_LOAD(riv,riv) 1338 nts_35, // 229 - r: DOUBLE_ALOAD(riv,riv) 1339 nts_21, // 230 - double_load: DOUBLE_LOAD(rlv,rlv) 1340 nts_41, // 231 - r: DOUBLE_ALOAD(riv,r) 1341 nts_21, // 232 - r: DOUBLE_ALOAD(rlv,rlv) 1342 nts_35, // 233 - double_load: DOUBLE_ALOAD(riv,riv) 1343 nts_35, // 234 - r: FLOAT_LOAD(riv,riv) 1344 nts_21, // 235 - r: FLOAT_LOAD(rlv,rlv) 1345 nts_35, // 236 - float_load: FLOAT_LOAD(riv,riv) 1346 nts_35, // 237 - r: FLOAT_ALOAD(riv,riv) 1347 nts_41, // 238 - r: FLOAT_ALOAD(riv,r) 1348 nts_21, // 239 - r: FLOAT_ALOAD(rlv,rlv) 1349 nts_35, // 240 - float_load: FLOAT_ALOAD(riv,riv) 1350 nts_18, // 241 - stm: FLOAT_IFCMP(r,r) 1351 nts_48, // 242 - stm: FLOAT_IFCMP(r,float_load) 1352 nts_49, // 243 - stm: FLOAT_IFCMP(float_load,r) 1353 nts_18, // 244 - stm: DOUBLE_IFCMP(r,r) 1354 nts_50, // 245 - stm: DOUBLE_IFCMP(r,double_load) 1355 nts_51, // 246 - stm: DOUBLE_IFCMP(double_load,r) 1356 nts_0, // 247 - stm: LOWTABLESWITCH(r) 1357 nts_3, // 248 - stm: NULL_CHECK(riv) 1358 nts_0, // 249 - stm: SET_CAUGHT_EXCEPTION(r) 1359 nts_0, // 250 - stm: TRAP_IF(r,INT_CONSTANT) 1360 nts_0, // 251 - stm: TRAP_IF(r,LONG_CONSTANT) 1361 nts_15, // 252 - uload8: INT_AND(load8_16_32,INT_CONSTANT) 1362 nts_15, // 253 - r: INT_AND(load8_16_32,INT_CONSTANT) 1363 nts_15, // 254 - r: INT_2BYTE(load8_16_32) 1364 nts_12, // 255 - r: INT_AND(load16_32,INT_CONSTANT) 1365 nts_0, // 256 - stm: PREFETCH(r) 1366 nts_0, // 257 - stm: RETURN(r) 1367 nts_0, // 258 - address1scaledreg: INT_SHL(r,INT_CONSTANT) 1368 nts_0, // 259 - address1reg: INT_ADD(r,LONG_CONSTANT) 1369 nts_0, // 260 - address1reg: INT_MOVE(r) 1370 nts_4, // 261 - address1reg: INT_ADD(address1reg,LONG_CONSTANT) 1371 nts_5, // 262 - address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) 1372 nts_5, // 263 - address: INT_ADD(address1scaledreg,LONG_CONSTANT) 1373 nts_0, // 264 - address1scaledreg: LONG_SHL(r,INT_CONSTANT) 1374 nts_0, // 265 - address1reg: LONG_ADD(r,LONG_CONSTANT) 1375 nts_0, // 266 - address1reg: LONG_MOVE(r) 1376 nts_4, // 267 - address1reg: LONG_ADD(address1reg,LONG_CONSTANT) 1377 nts_5, // 268 - address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) 1378 nts_5, // 269 - address: LONG_ADD(address1scaledreg,LONG_CONSTANT) 1379 nts_0, // 270 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1380 nts_0, // 271 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1381 nts_0, // 272 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1382 nts_11, // 273 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 1383 nts_0, // 274 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1384 nts_11, // 275 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 1385 nts_52, // 276 - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 1386 nts_52, // 277 - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 1387 nts_53, // 278 - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 1388 nts_53, // 279 - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 1389 nts_54, // 280 - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 1390 nts_54, // 281 - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 1391 nts_55, // 282 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1392 nts_55, // 283 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1393 nts_55, // 284 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1394 nts_55, // 285 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1395 nts_0, // 286 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 1396 nts_0, // 287 - boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 1397 nts_0, // 288 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 1398 nts_14, // 289 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 1399 nts_0, // 290 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 1400 nts_14, // 291 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 1401 nts_52, // 292 - r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) 1402 nts_0, // 293 - r: BOOLEAN_NOT(r) 1403 nts_0, // 294 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1404 nts_11, // 295 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1405 nts_0, // 296 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1406 nts_11, // 297 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1407 nts_0, // 298 - r: INT_2BYTE(r) 1408 nts_15, // 299 - r: INT_2BYTE(load8_16_32) 1409 nts_0, // 300 - r: INT_2LONG(r) 1410 nts_11, // 301 - r: INT_2LONG(load32) 1411 nts_0, // 302 - r: INT_2ADDRZerExt(r) 1412 nts_0, // 303 - r: INT_2SHORT(r) 1413 nts_12, // 304 - r: INT_2SHORT(load16_32) 1414 nts_12, // 305 - sload16: INT_2SHORT(load16_32) 1415 nts_0, // 306 - szpr: INT_2USHORT(r) 1416 nts_12, // 307 - uload16: INT_2USHORT(load16_32) 1417 nts_12, // 308 - r: INT_2USHORT(load16_32) 1418 nts_0, // 309 - stm: INT_IFCMP(r,INT_CONSTANT) 1419 nts_13, // 310 - stm: INT_IFCMP(load8,INT_CONSTANT) 1420 nts_8, // 311 - stm: INT_IFCMP(sload16,INT_CONSTANT) 1421 nts_55, // 312 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1422 nts_55, // 313 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1423 nts_52, // 314 - stm: INT_IFCMP(cz,INT_CONSTANT) 1424 nts_53, // 315 - stm: INT_IFCMP(szp,INT_CONSTANT) 1425 nts_54, // 316 - stm: INT_IFCMP(bittest,INT_CONSTANT) 1426 nts_56, // 317 - r: INT_LOAD(address,LONG_CONSTANT) 1427 nts_3, // 318 - r: INT_MOVE(riv) 1428 nts_1, // 319 - czr: INT_MOVE(czr) 1429 nts_52, // 320 - cz: INT_MOVE(cz) 1430 nts_2, // 321 - szpr: INT_MOVE(szpr) 1431 nts_53, // 322 - szp: INT_MOVE(szp) 1432 nts_6, // 323 - sload8: INT_MOVE(sload8) 1433 nts_7, // 324 - uload8: INT_MOVE(uload8) 1434 nts_13, // 325 - load8: INT_MOVE(load8) 1435 nts_8, // 326 - sload16: INT_MOVE(sload16) 1436 nts_9, // 327 - uload16: INT_MOVE(uload16) 1437 nts_10, // 328 - load16: INT_MOVE(load16) 1438 nts_11, // 329 - load32: INT_MOVE(load32) 1439 nts_0, // 330 - szpr: INT_NEG(r) 1440 nts_0, // 331 - r: INT_NOT(r) 1441 nts_0, // 332 - szpr: INT_SHL(r,INT_CONSTANT) 1442 nts_0, // 333 - r: INT_SHL(r,INT_CONSTANT) 1443 nts_3, // 334 - szpr: INT_SHR(riv,INT_CONSTANT) 1444 nts_3, // 335 - szpr: INT_USHR(riv,INT_CONSTANT) 1445 nts_56, // 336 - r: LONG_ADD(address,LONG_CONSTANT) 1446 nts_56, // 337 - r: LONG_MOVE(address) 1447 nts_0, // 338 - r: LONG_2INT(r) 1448 nts_14, // 339 - r: LONG_2INT(load64) 1449 nts_14, // 340 - load32: LONG_2INT(load64) 1450 nts_0, // 341 - stm: LONG_IFCMP(r,LONG_CONSTANT) 1451 nts_56, // 342 - r: LONG_LOAD(address,LONG_CONSTANT) 1452 nts_57, // 343 - r: LONG_MOVE(rlv) 1453 nts_3, // 344 - r: LONG_MOVE(riv) 1454 nts_14, // 345 - load64: LONG_MOVE(load64) 1455 nts_0, // 346 - szpr: LONG_NEG(r) 1456 nts_0, // 347 - r: LONG_NOT(r) 1457 nts_0, // 348 - szpr: LONG_SHL(r,INT_CONSTANT) 1458 nts_0, // 349 - r: LONG_SHL(r,INT_CONSTANT) 1459 nts_57, // 350 - szpr: LONG_SHR(rlv,LONG_CONSTANT) 1460 nts_57, // 351 - szpr: LONG_USHR(rlv,LONG_CONSTANT) 1461 nts_0, // 352 - r: FLOAT_NEG(r) 1462 nts_0, // 353 - r: DOUBLE_NEG(r) 1463 nts_0, // 354 - r: FLOAT_SQRT(r) 1464 nts_0, // 355 - r: DOUBLE_SQRT(r) 1465 nts_0, // 356 - r: LONG_2FLOAT(r) 1466 nts_0, // 357 - r: LONG_2DOUBLE(r) 1467 nts_0, // 358 - r: FLOAT_MOVE(r) 1468 nts_0, // 359 - r: DOUBLE_MOVE(r) 1469 nts_3, // 360 - r: INT_2FLOAT(riv) 1470 nts_11, // 361 - r: INT_2FLOAT(load32) 1471 nts_3, // 362 - r: INT_2DOUBLE(riv) 1472 nts_11, // 363 - r: INT_2DOUBLE(load32) 1473 nts_0, // 364 - r: FLOAT_2DOUBLE(r) 1474 nts_58, // 365 - r: FLOAT_2DOUBLE(float_load) 1475 nts_0, // 366 - r: DOUBLE_2FLOAT(r) 1476 nts_59, // 367 - r: DOUBLE_2FLOAT(double_load) 1477 nts_0, // 368 - r: FLOAT_2INT(r) 1478 nts_0, // 369 - r: FLOAT_2LONG(r) 1479 nts_0, // 370 - r: DOUBLE_2INT(r) 1480 nts_0, // 371 - r: DOUBLE_2LONG(r) 1481 nts_0, // 372 - r: FLOAT_AS_INT_BITS(r) 1482 nts_58, // 373 - load32: FLOAT_AS_INT_BITS(float_load) 1483 nts_0, // 374 - r: DOUBLE_AS_LONG_BITS(r) 1484 nts_59, // 375 - load64: DOUBLE_AS_LONG_BITS(double_load) 1485 nts_3, // 376 - r: INT_BITS_AS_FLOAT(riv) 1486 nts_11, // 377 - float_load: INT_BITS_AS_FLOAT(load32) 1487 nts_57, // 378 - r: LONG_BITS_AS_DOUBLE(rlv) 1488 nts_14, // 379 - double_load: LONG_BITS_AS_DOUBLE(load64) 1489 nts_60, // 380 - r: MATERIALIZE_FP_CONSTANT(any) 1490 nts_60, // 381 - float_load: MATERIALIZE_FP_CONSTANT(any) 1491 nts_60, // 382 - double_load: MATERIALIZE_FP_CONSTANT(any) 1492 nts_15, // 383 - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 1493 nts_12, // 384 - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 1494 nts_0, // 385 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 1495 nts_0, // 386 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 1496 nts_0, // 387 - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 1497 nts_11, // 388 - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 1498 nts_0, // 389 - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 1499 nts_0, // 390 - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 1500 nts_0, // 391 - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 1501 nts_14, // 392 - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 1502 nts_14, // 393 - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 1503 nts_14, // 394 - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 1504 nts_14, // 395 - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 1505 nts_0, // 396 - szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) 1506 nts_61, // 397 - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 1507 nts_62, // 398 - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 1508 nts_63, // 399 - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 1509 nts_64, // 400 - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 1510 nts_61, // 401 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 1511 nts_62, // 402 - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 1512 nts_65, // 403 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 1513 nts_61, // 404 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 1514 nts_65, // 405 - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 1515 nts_64, // 406 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 1516 nts_66, // 407 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 1517 nts_67, // 408 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 1518 nts_68, // 409 - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 1519 nts_69, // 410 - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1520 nts_70, // 411 - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 1521 nts_71, // 412 - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 1522 nts_71, // 413 - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 1523 nts_64, // 414 - stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) 1524 nts_72, // 415 - stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) 1525 nts_66, // 416 - stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 1526 nts_73, // 417 - stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) 1527 nts_74, // 418 - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 1528 nts_75, // 419 - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 1529 nts_76, // 420 - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 1530 nts_77, // 421 - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 1531 nts_78, // 422 - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 1532 nts_64, // 423 - stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 1533 nts_79, // 424 - stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) 1534 nts_80, // 425 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) 1535 nts_81, // 426 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 1536 nts_82, // 427 - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 1537 nts_83, // 428 - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 1538 nts_84, // 429 - r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) 1539 nts_85, // 430 - r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) 1540 nts_63, // 431 - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 1541 nts_86, // 432 - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) 1542 nts_87, // 433 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) 1543 nts_88, // 434 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) 1544 nts_89, // 435 - stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) 1545 nts_68, // 436 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 1546 nts_90, // 437 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 1547 nts_91, // 438 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 1548 nts_69, // 439 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 1549 nts_68, // 440 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 1550 nts_91, // 441 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 1551 nts_90, // 442 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 1552 nts_69, // 443 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1553 nts_70, // 444 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 1554 nts_68, // 445 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 1555 nts_69, // 446 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 1556 nts_91, // 447 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 1557 nts_90, // 448 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 1558 nts_68, // 449 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 1559 nts_91, // 450 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 1560 nts_90, // 451 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 1561 nts_69, // 452 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1562 nts_70, // 453 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 1563 nts_92, // 454 - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 1564 nts_93, // 455 - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 1565 nts_94, // 456 - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 1566 nts_95, // 457 - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 1567 nts_96, // 458 - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 1568 nts_92, // 459 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 1569 nts_93, // 460 - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 1570 nts_94, // 461 - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 1571 nts_97, // 462 - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 1572 nts_98, // 463 - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 1573 nts_97, // 464 - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 1574 nts_98, // 465 - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 1575 nts_35, // 466 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 1576 nts_40, // 467 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 1577 nts_60, // 468 - r: CALL(BRANCH_TARGET,any) 1578 nts_60, // 469 - r: CALL(INT_CONSTANT,any) 1579 nts_60, // 470 - r: SYSCALL(INT_CONSTANT,any) 1580 nts_99, // 471 - r: CALL(INT_LOAD(riv,riv),any) 1581 nts_100, // 472 - r: CALL(LONG_LOAD(rlv,rlv),any) 1582 nts_99, // 473 - r: SYSCALL(INT_LOAD(riv,riv),any) 1583 nts_101, // 474 - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 1584 nts_102, // 475 - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 1585 nts_103, // 476 - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 1586 nts_104, // 477 - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 1587 nts_105, // 478 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 1588 nts_106, // 479 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 1589 nts_107, // 480 - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 1590 nts_108, // 481 - r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) 1591 nts_109, // 482 - r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 1592 nts_110, // 483 - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) 1593 nts_111, // 484 - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) 1594 nts_112, // 485 - r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 1595 nts_113, // 486 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 1596 nts_114, // 487 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 1597 nts_115, // 488 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 1598 nts_116, // 489 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 1599 nts_117, // 490 - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 1600 nts_118, // 491 - r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) 1601 nts_117, // 492 - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 1602 nts_118, // 493 - r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) 1603 nts_101, // 494 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1604 nts_104, // 495 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1605 nts_105, // 496 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1606 nts_106, // 497 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1607 nts_107, // 498 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1608 nts_101, // 499 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1609 nts_104, // 500 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1610 nts_105, // 501 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1611 nts_106, // 502 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1612 nts_107, // 503 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1613 nts_108, // 504 - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1614 nts_109, // 505 - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1615 nts_110, // 506 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1616 nts_111, // 507 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1617 nts_112, // 508 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1618 nts_108, // 509 - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1619 nts_109, // 510 - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1620 nts_110, // 511 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1621 nts_111, // 512 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1622 nts_112, // 513 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1623 nts_117, // 514 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1624 nts_117, // 515 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1625 nts_118, // 516 - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1626 nts_118, // 517 - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1627 nts_117, // 518 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1628 nts_117, // 519 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1629 nts_118, // 520 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1630 nts_118, // 521 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 1631 nts_18, // 522 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1632 nts_42, // 523 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1633 nts_18, // 524 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1634 nts_42, // 525 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1635 nts_41, // 526 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 1636 nts_28, // 527 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 1637 nts_18, // 528 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 1638 nts_42, // 529 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 1639 nts_108, // 530 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1640 nts_119, // 531 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) 1641 nts_101, // 532 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1642 nts_101, // 533 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1643 nts_101, // 534 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1644 nts_101, // 535 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1645 nts_101, // 536 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1646 nts_101, // 537 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1647 nts_101, // 538 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1648 nts_101, // 539 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1649 nts_101, // 540 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1650 nts_101, // 541 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1651 nts_101, // 542 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1652 nts_101, // 543 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1653 nts_101, // 544 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1654 nts_101, // 545 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1655 nts_101, // 546 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1656 nts_101, // 547 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1657 nts_101, // 548 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 1658 nts_101, // 549 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 1659 nts_101, // 550 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 1660 nts_101, // 551 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 1661 nts_22, // 552 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 1662 nts_120, // 553 - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 1663 nts_121, // 554 - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 1664 nts_122, // 555 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 1665 nts_122, // 556 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 1666 nts_123, // 557 - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 1667 nts_124, // 558 - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 1668 nts_125, // 559 - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 1669 nts_22, // 560 - r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 1670 nts_68, // 561 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 1671 nts_68, // 562 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 1672 nts_68, // 563 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 1673 nts_68, // 564 - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 1674 nts_68, // 565 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 1675 nts_68, // 566 - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 1676 nts_68, // 567 - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 1677 nts_68, // 568 - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 1678 nts_126, // 569 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1679 nts_126, // 570 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1680 nts_126, // 571 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1681 nts_126, // 572 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1682 nts_126, // 573 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1683 nts_126, // 574 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1684 nts_126, // 575 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1685 nts_126, // 576 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1686 nts_126, // 577 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1687 nts_126, // 578 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1688 nts_127, // 579 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1689 nts_127, // 580 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1690 nts_127, // 581 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1691 nts_127, // 582 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1692 nts_127, // 583 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1693 nts_127, // 584 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1694 nts_127, // 585 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1695 nts_127, // 586 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1696 nts_127, // 587 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1697 nts_127, // 588 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1698 nts_126, // 589 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1699 nts_126, // 590 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1700 nts_128, // 591 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1701 nts_128, // 592 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1702 nts_128, // 593 - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1703 nts_128, // 594 - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1704 nts_126, // 595 - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1705 nts_126, // 596 - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1706 nts_128, // 597 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1707 nts_128, // 598 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1708 nts_127, // 599 - stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1709 nts_127, // 600 - stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1710 nts_129, // 601 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1711 nts_129, // 602 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1712 nts_129, // 603 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1713 nts_129, // 604 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1714 nts_127, // 605 - stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1715 nts_127, // 606 - stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1716 nts_129, // 607 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1717 nts_129, // 608 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1718 nts_18, // 609 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 1719 nts_18, // 610 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 1720 nts_18, // 611 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 1721 nts_18, // 612 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 1722 nts_130, // 613 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 1723 nts_130, // 614 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 1724 nts_130, // 615 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 1725 nts_130, // 616 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 1726 nts_41, // 617 - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 1727 nts_41, // 618 - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 1728 nts_131, // 619 - stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) 1729 nts_41, // 620 - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 1730 nts_43, // 621 - szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) 1731 nts_43, // 622 - szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) 1732 nts_132, // 623 - stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) 1733 nts_43, // 624 - szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) 1734 nts_133, // 625 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1735 nts_133, // 626 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1736 nts_133, // 627 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1737 nts_133, // 628 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1738 nts_133, // 629 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1739 nts_133, // 630 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1740 nts_133, // 631 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1741 nts_133, // 632 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1742 nts_133, // 633 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 1743 nts_133, // 634 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 1744 nts_133, // 635 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 1745 nts_133, // 636 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 1746 nts_70, // 637 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 1747 nts_70, // 638 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 1748 nts_70, // 639 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1749 nts_70, // 640 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1750 nts_70, // 641 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 1751 nts_70, // 642 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 1752 nts_70, // 643 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 1753 nts_70, // 644 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 1754 nts_70, // 645 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 1755 nts_70, // 646 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 1756 nts_70, // 647 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 1757 nts_70, // 648 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 1758 nts_70, // 649 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 1759 nts_70, // 650 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 1760 nts_70, // 651 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1761 nts_70, // 652 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1762 }; 1763 1764 /* private static final byte arity[] = { 1765 0, // 0 - GET_CAUGHT_EXCEPTION 1766 1, // 1 - SET_CAUGHT_EXCEPTION 1767 -1, // 2 - NEW 1768 -1, // 3 - NEW_UNRESOLVED 1769 -1, // 4 - NEWARRAY 1770 -1, // 5 - NEWARRAY_UNRESOLVED 1771 -1, // 6 - ATHROW 1772 -1, // 7 - CHECKCAST 1773 -1, // 8 - CHECKCAST_NOTNULL 1774 -1, // 9 - CHECKCAST_UNRESOLVED 1775 -1, // 10 - MUST_IMPLEMENT_INTERFACE 1776 -1, // 11 - INSTANCEOF 1777 -1, // 12 - INSTANCEOF_NOTNULL 1778 -1, // 13 - INSTANCEOF_UNRESOLVED 1779 -1, // 14 - MONITORENTER 1780 -1, // 15 - MONITOREXIT 1781 -1, // 16 - NEWOBJMULTIARRAY 1782 -1, // 17 - GETSTATIC 1783 -1, // 18 - PUTSTATIC 1784 -1, // 19 - GETFIELD 1785 -1, // 20 - PUTFIELD 1786 -1, // 21 - INT_ZERO_CHECK 1787 -1, // 22 - LONG_ZERO_CHECK 1788 -1, // 23 - BOUNDS_CHECK 1789 -1, // 24 - OBJARRAY_STORE_CHECK 1790 -1, // 25 - OBJARRAY_STORE_CHECK_NOTNULL 1791 0, // 26 - IG_PATCH_POINT 1792 -1, // 27 - IG_CLASS_TEST 1793 -1, // 28 - IG_METHOD_TEST 1794 -1, // 29 - TABLESWITCH 1795 -1, // 30 - LOOKUPSWITCH 1796 2, // 31 - INT_ALOAD 1797 2, // 32 - LONG_ALOAD 1798 2, // 33 - FLOAT_ALOAD 1799 2, // 34 - DOUBLE_ALOAD 1800 -1, // 35 - REF_ALOAD 1801 2, // 36 - UBYTE_ALOAD 1802 2, // 37 - BYTE_ALOAD 1803 2, // 38 - USHORT_ALOAD 1804 2, // 39 - SHORT_ALOAD 1805 2, // 40 - INT_ASTORE 1806 2, // 41 - LONG_ASTORE 1807 2, // 42 - FLOAT_ASTORE 1808 2, // 43 - DOUBLE_ASTORE 1809 -1, // 44 - REF_ASTORE 1810 2, // 45 - BYTE_ASTORE 1811 2, // 46 - SHORT_ASTORE 1812 2, // 47 - INT_IFCMP 1813 2, // 48 - INT_IFCMP2 1814 2, // 49 - LONG_IFCMP 1815 2, // 50 - FLOAT_IFCMP 1816 2, // 51 - DOUBLE_IFCMP 1817 -1, // 52 - REF_IFCMP 1818 -1, // 53 - LABEL 1819 -1, // 54 - BBEND 1820 0, // 55 - UNINT_BEGIN 1821 0, // 56 - UNINT_END 1822 0, // 57 - FENCE 1823 0, // 58 - READ_CEILING 1824 0, // 59 - WRITE_FLOOR 1825 -1, // 60 - PHI 1826 -1, // 61 - SPLIT 1827 -1, // 62 - PI 1828 0, // 63 - NOP 1829 1, // 64 - INT_MOVE 1830 1, // 65 - LONG_MOVE 1831 1, // 66 - FLOAT_MOVE 1832 1, // 67 - DOUBLE_MOVE 1833 -1, // 68 - REF_MOVE 1834 0, // 69 - GUARD_MOVE 1835 -1, // 70 - INT_COND_MOVE 1836 -1, // 71 - LONG_COND_MOVE 1837 -1, // 72 - FLOAT_COND_MOVE 1838 -1, // 73 - DOUBLE_COND_MOVE 1839 -1, // 74 - REF_COND_MOVE 1840 -1, // 75 - GUARD_COND_MOVE 1841 0, // 76 - GUARD_COMBINE 1842 -1, // 77 - REF_ADD 1843 2, // 78 - INT_ADD 1844 2, // 79 - LONG_ADD 1845 2, // 80 - FLOAT_ADD 1846 2, // 81 - DOUBLE_ADD 1847 -1, // 82 - REF_SUB 1848 2, // 83 - INT_SUB 1849 2, // 84 - LONG_SUB 1850 2, // 85 - FLOAT_SUB 1851 2, // 86 - DOUBLE_SUB 1852 2, // 87 - INT_MUL 1853 2, // 88 - LONG_MUL 1854 2, // 89 - FLOAT_MUL 1855 2, // 90 - DOUBLE_MUL 1856 2, // 91 - INT_DIV 1857 2, // 92 - LONG_DIV 1858 2, // 93 - FLOAT_DIV 1859 2, // 94 - DOUBLE_DIV 1860 2, // 95 - INT_REM 1861 2, // 96 - LONG_REM 1862 2, // 97 - FLOAT_REM 1863 2, // 98 - DOUBLE_REM 1864 -1, // 99 - REF_NEG 1865 1, // 100 - INT_NEG 1866 1, // 101 - LONG_NEG 1867 1, // 102 - FLOAT_NEG 1868 1, // 103 - DOUBLE_NEG 1869 1, // 104 - FLOAT_SQRT 1870 1, // 105 - DOUBLE_SQRT 1871 -1, // 106 - REF_SHL 1872 2, // 107 - INT_SHL 1873 2, // 108 - LONG_SHL 1874 -1, // 109 - REF_SHR 1875 2, // 110 - INT_SHR 1876 2, // 111 - LONG_SHR 1877 -1, // 112 - REF_USHR 1878 2, // 113 - INT_USHR 1879 2, // 114 - LONG_USHR 1880 -1, // 115 - REF_AND 1881 2, // 116 - INT_AND 1882 2, // 117 - LONG_AND 1883 -1, // 118 - REF_OR 1884 2, // 119 - INT_OR 1885 2, // 120 - LONG_OR 1886 -1, // 121 - REF_XOR 1887 2, // 122 - INT_XOR 1888 -1, // 123 - REF_NOT 1889 1, // 124 - INT_NOT 1890 1, // 125 - LONG_NOT 1891 2, // 126 - LONG_XOR 1892 -1, // 127 - INT_2ADDRSigExt 1893 1, // 128 - INT_2ADDRZerExt 1894 -1, // 129 - LONG_2ADDR 1895 -1, // 130 - ADDR_2INT 1896 -1, // 131 - ADDR_2LONG 1897 1, // 132 - INT_2LONG 1898 1, // 133 - INT_2FLOAT 1899 1, // 134 - INT_2DOUBLE 1900 1, // 135 - LONG_2INT 1901 1, // 136 - LONG_2FLOAT 1902 1, // 137 - LONG_2DOUBLE 1903 1, // 138 - FLOAT_2INT 1904 1, // 139 - FLOAT_2LONG 1905 1, // 140 - FLOAT_2DOUBLE 1906 1, // 141 - DOUBLE_2INT 1907 1, // 142 - DOUBLE_2LONG 1908 1, // 143 - DOUBLE_2FLOAT 1909 1, // 144 - INT_2BYTE 1910 1, // 145 - INT_2USHORT 1911 1, // 146 - INT_2SHORT 1912 2, // 147 - LONG_CMP 1913 -1, // 148 - FLOAT_CMPL 1914 -1, // 149 - FLOAT_CMPG 1915 -1, // 150 - DOUBLE_CMPL 1916 -1, // 151 - DOUBLE_CMPG 1917 1, // 152 - RETURN 1918 1, // 153 - NULL_CHECK 1919 0, // 154 - GOTO 1920 1, // 155 - BOOLEAN_NOT 1921 2, // 156 - BOOLEAN_CMP_INT 1922 -1, // 157 - BOOLEAN_CMP_ADDR 1923 2, // 158 - BOOLEAN_CMP_LONG 1924 -1, // 159 - BOOLEAN_CMP_FLOAT 1925 -1, // 160 - BOOLEAN_CMP_DOUBLE 1926 2, // 161 - BYTE_LOAD 1927 2, // 162 - UBYTE_LOAD 1928 2, // 163 - SHORT_LOAD 1929 2, // 164 - USHORT_LOAD 1930 -1, // 165 - REF_LOAD 1931 -1, // 166 - REF_STORE 1932 2, // 167 - INT_LOAD 1933 2, // 168 - LONG_LOAD 1934 2, // 169 - FLOAT_LOAD 1935 2, // 170 - DOUBLE_LOAD 1936 2, // 171 - BYTE_STORE 1937 2, // 172 - SHORT_STORE 1938 2, // 173 - INT_STORE 1939 2, // 174 - LONG_STORE 1940 2, // 175 - FLOAT_STORE 1941 2, // 176 - DOUBLE_STORE 1942 -1, // 177 - PREPARE_INT 1943 -1, // 178 - PREPARE_ADDR 1944 -1, // 179 - PREPARE_LONG 1945 2, // 180 - ATTEMPT_INT 1946 -1, // 181 - ATTEMPT_ADDR 1947 2, // 182 - ATTEMPT_LONG 1948 2, // 183 - CALL 1949 2, // 184 - SYSCALL 1950 0, // 185 - YIELDPOINT_PROLOGUE 1951 0, // 186 - YIELDPOINT_EPILOGUE 1952 0, // 187 - YIELDPOINT_BACKEDGE 1953 2, // 188 - YIELDPOINT_OSR 1954 -1, // 189 - OSR_BARRIER 1955 0, // 190 - IR_PROLOGUE 1956 0, // 191 - RESOLVE 1957 -1, // 192 - RESOLVE_MEMBER 1958 0, // 193 - GET_TIME_BASE 1959 -1, // 194 - INSTRUMENTED_EVENT_COUNTER 1960 2, // 195 - TRAP_IF 1961 0, // 196 - TRAP 1962 1, // 197 - FLOAT_AS_INT_BITS 1963 1, // 198 - INT_BITS_AS_FLOAT 1964 1, // 199 - DOUBLE_AS_LONG_BITS 1965 1, // 200 - LONG_BITS_AS_DOUBLE 1966 -1, // 201 - ARRAYLENGTH 1967 -1, // 202 - GET_OBJ_TIB 1968 -1, // 203 - GET_CLASS_TIB 1969 -1, // 204 - GET_TYPE_FROM_TIB 1970 -1, // 205 - GET_SUPERCLASS_IDS_FROM_TIB 1971 -1, // 206 - GET_DOES_IMPLEMENT_FROM_TIB 1972 -1, // 207 - GET_ARRAY_ELEMENT_TIB_FROM_TIB 1973 1, // 208 - LOWTABLESWITCH 1974 0, // 209 - ADDRESS_CONSTANT 1975 0, // 210 - INT_CONSTANT 1976 0, // 211 - LONG_CONSTANT 1977 0, // 212 - REGISTER 1978 2, // 213 - OTHER_OPERAND 1979 0, // 214 - NULL 1980 0, // 215 - BRANCH_TARGET 1981 1, // 216 - MATERIALIZE_FP_CONSTANT 1982 -1, // 217 - ROUND_TO_ZERO 1983 0, // 218 - CLEAR_FLOATING_POINT_STATE 1984 1, // 219 - PREFETCH 1985 0, // 220 - PAUSE 1986 -1, // 221 - FP_ADD 1987 -1, // 222 - FP_SUB 1988 -1, // 223 - FP_MUL 1989 -1, // 224 - FP_DIV 1990 -1, // 225 - FP_NEG 1991 -1, // 226 - FP_REM 1992 -1, // 227 - INT_2FP 1993 -1, // 228 - LONG_2FP 1994 2, // 229 - CMP_CMOV 1995 2, // 230 - FCMP_CMOV 1996 2, // 231 - LCMP_CMOV 1997 -1, // 232 - CMP_FCMOV 1998 2, // 233 - FCMP_FCMOV 1999 -1, // 234 - CALL_SAVE_VOLATILE 2000 -1, // 235 - MIR_START 2001 -1, // 236 - REQUIRE_ESP 2002 -1, // 237 - ADVISE_ESP 2003 -1, // 238 - MIR_LOWTABLESWITCH 2004 -1, // 239 - IA32_METHODSTART 2005 -1, // 240 - IA32_FCLEAR 2006 -1, // 241 - DUMMY_DEF 2007 -1, // 242 - DUMMY_USE 2008 -1, // 243 - IMMQ_MOV 2009 -1, // 244 - IA32_FMOV_ENDING_LIVE_RANGE 2010 -1, // 245 - IA32_FMOV 2011 -1, // 246 - IA32_TRAPIF 2012 -1, // 247 - IA32_OFFSET 2013 -1, // 248 - IA32_LOCK_CMPXCHG 2014 -1, // 249 - IA32_LOCK_CMPXCHG8B 2015 -1, // 250 - IA32_ADC 2016 -1, // 251 - IA32_ADD 2017 -1, // 252 - IA32_AND 2018 -1, // 253 - IA32_BSWAP 2019 -1, // 254 - IA32_BT 2020 -1, // 255 - IA32_BTC 2021 -1, // 256 - IA32_BTR 2022 -1, // 257 - IA32_BTS 2023 -1, // 258 - IA32_SYSCALL 2024 -1, // 259 - IA32_CALL 2025 -1, // 260 - IA32_CDQ 2026 -1, // 261 - IA32_CDO 2027 -1, // 262 - IA32_CDQE 2028 -1, // 263 - IA32_CMOV 2029 -1, // 264 - IA32_CMP 2030 -1, // 265 - IA32_CMPXCHG 2031 -1, // 266 - IA32_CMPXCHG8B 2032 -1, // 267 - IA32_DEC 2033 -1, // 268 - IA32_DIV 2034 -1, // 269 - IA32_FADD 2035 -1, // 270 - IA32_FADDP 2036 -1, // 271 - IA32_FCHS 2037 -1, // 272 - IA32_FCMOV 2038 -1, // 273 - IA32_FCOMI 2039 -1, // 274 - IA32_FCOMIP 2040 -1, // 275 - IA32_FDIV 2041 -1, // 276 - IA32_FDIVP 2042 -1, // 277 - IA32_FDIVR 2043 -1, // 278 - IA32_FDIVRP 2044 -1, // 279 - IA32_FEXAM 2045 -1, // 280 - IA32_FXCH 2046 -1, // 281 - IA32_FFREE 2047 -1, // 282 - IA32_FFREEP 2048 -1, // 283 - IA32_FIADD 2049 -1, // 284 - IA32_FIDIV 2050 -1, // 285 - IA32_FIDIVR 2051 -1, // 286 - IA32_FILD 2052 -1, // 287 - IA32_FIMUL 2053 -1, // 288 - IA32_FINIT 2054 -1, // 289 - IA32_FIST 2055 -1, // 290 - IA32_FISTP 2056 -1, // 291 - IA32_FISUB 2057 -1, // 292 - IA32_FISUBR 2058 -1, // 293 - IA32_FLD 2059 -1, // 294 - IA32_FLDCW 2060 -1, // 295 - IA32_FLD1 2061 -1, // 296 - IA32_FLDL2T 2062 -1, // 297 - IA32_FLDL2E 2063 -1, // 298 - IA32_FLDPI 2064 -1, // 299 - IA32_FLDLG2 2065 -1, // 300 - IA32_FLDLN2 2066 -1, // 301 - IA32_FLDZ 2067 -1, // 302 - IA32_FMUL 2068 -1, // 303 - IA32_FMULP 2069 -1, // 304 - IA32_FNSTCW 2070 -1, // 305 - IA32_FNSTSW 2071 -1, // 306 - IA32_FNINIT 2072 -1, // 307 - IA32_FNSAVE 2073 -1, // 308 - IA32_FPREM 2074 -1, // 309 - IA32_FRSTOR 2075 -1, // 310 - IA32_FST 2076 -1, // 311 - IA32_FSTCW 2077 -1, // 312 - IA32_FSTSW 2078 -1, // 313 - IA32_FSTP 2079 -1, // 314 - IA32_FSUB 2080 -1, // 315 - IA32_FSUBP 2081 -1, // 316 - IA32_FSUBR 2082 -1, // 317 - IA32_FSUBRP 2083 -1, // 318 - IA32_FUCOMI 2084 -1, // 319 - IA32_FUCOMIP 2085 -1, // 320 - IA32_IDIV 2086 -1, // 321 - IA32_IMUL1 2087 -1, // 322 - IA32_IMUL2 2088 -1, // 323 - IA32_INC 2089 -1, // 324 - IA32_INT 2090 -1, // 325 - IA32_JCC 2091 -1, // 326 - IA32_JCC2 2092 -1, // 327 - IA32_JMP 2093 -1, // 328 - IA32_LEA 2094 -1, // 329 - IA32_LOCK 2095 -1, // 330 - IA32_MOV 2096 -1, // 331 - IA32_MOVZX__B 2097 -1, // 332 - IA32_MOVSX__B 2098 -1, // 333 - IA32_MOVZX__W 2099 -1, // 334 - IA32_MOVSX__W 2100 -1, // 335 - IA32_MOVZXQ__B 2101 -1, // 336 - IA32_MOVSXQ__B 2102 -1, // 337 - IA32_MOVZXQ__W 2103 -1, // 338 - IA32_MOVSXQ__W 2104 -1, // 339 - IA32_MOVSXDQ 2105 -1, // 340 - IA32_MUL 2106 -1, // 341 - IA32_NEG 2107 -1, // 342 - IA32_NOT 2108 -1, // 343 - IA32_OR 2109 -1, // 344 - IA32_MFENCE 2110 -1, // 345 - IA32_PAUSE 2111 -1, // 346 - IA32_PREFETCHNTA 2112 -1, // 347 - IA32_POP 2113 -1, // 348 - IA32_PUSH 2114 -1, // 349 - IA32_RCL 2115 -1, // 350 - IA32_RCR 2116 -1, // 351 - IA32_ROL 2117 -1, // 352 - IA32_ROR 2118 -1, // 353 - IA32_RET 2119 -1, // 354 - IA32_SAL 2120 -1, // 355 - IA32_SAR 2121 -1, // 356 - IA32_SHL 2122 -1, // 357 - IA32_SHR 2123 -1, // 358 - IA32_SBB 2124 -1, // 359 - IA32_SET__B 2125 -1, // 360 - IA32_SHLD 2126 -1, // 361 - IA32_SHRD 2127 -1, // 362 - IA32_SUB 2128 -1, // 363 - IA32_TEST 2129 -1, // 364 - IA32_XOR 2130 -1, // 365 - IA32_RDTSC 2131 -1, // 366 - IA32_ADDSS 2132 -1, // 367 - IA32_SUBSS 2133 -1, // 368 - IA32_MULSS 2134 -1, // 369 - IA32_DIVSS 2135 -1, // 370 - IA32_ADDSD 2136 -1, // 371 - IA32_SUBSD 2137 -1, // 372 - IA32_MULSD 2138 -1, // 373 - IA32_DIVSD 2139 -1, // 374 - IA32_ANDPS 2140 -1, // 375 - IA32_ANDPD 2141 -1, // 376 - IA32_ANDNPS 2142 -1, // 377 - IA32_ANDNPD 2143 -1, // 378 - IA32_ORPS 2144 -1, // 379 - IA32_ORPD 2145 -1, // 380 - IA32_XORPS 2146 -1, // 381 - IA32_XORPD 2147 -1, // 382 - IA32_UCOMISS 2148 -1, // 383 - IA32_UCOMISD 2149 -1, // 384 - IA32_CMPEQSS 2150 -1, // 385 - IA32_CMPLTSS 2151 -1, // 386 - IA32_CMPLESS 2152 -1, // 387 - IA32_CMPUNORDSS 2153 -1, // 388 - IA32_CMPNESS 2154 -1, // 389 - IA32_CMPNLTSS 2155 -1, // 390 - IA32_CMPNLESS 2156 -1, // 391 - IA32_CMPORDSS 2157 -1, // 392 - IA32_CMPEQSD 2158 -1, // 393 - IA32_CMPLTSD 2159 -1, // 394 - IA32_CMPLESD 2160 -1, // 395 - IA32_CMPUNORDSD 2161 -1, // 396 - IA32_CMPNESD 2162 -1, // 397 - IA32_CMPNLTSD 2163 -1, // 398 - IA32_CMPNLESD 2164 -1, // 399 - IA32_CMPORDSD 2165 -1, // 400 - IA32_MOVAPD 2166 -1, // 401 - IA32_MOVAPS 2167 -1, // 402 - IA32_MOVLPD 2168 -1, // 403 - IA32_MOVLPS 2169 -1, // 404 - IA32_MOVSS 2170 -1, // 405 - IA32_MOVSD 2171 -1, // 406 - IA32_MOVD 2172 -1, // 407 - IA32_MOVQ 2173 -1, // 408 - IA32_PSLLQ 2174 -1, // 409 - IA32_PSRLQ 2175 -1, // 410 - IA32_SQRTSS 2176 -1, // 411 - IA32_SQRTSD 2177 -1, // 412 - IA32_CVTSI2SS 2178 -1, // 413 - IA32_CVTSS2SD 2179 -1, // 414 - IA32_CVTSS2SI 2180 -1, // 415 - IA32_CVTTSS2SI 2181 -1, // 416 - IA32_CVTSI2SD 2182 -1, // 417 - IA32_CVTSD2SS 2183 -1, // 418 - IA32_CVTSD2SI 2184 -1, // 419 - IA32_CVTTSD2SI 2185 -1, // 420 - IA32_CVTSI2SDQ 2186 -1, // 421 - IA32_CVTSD2SIQ 2187 -1, // 422 - IA32_CVTTSD2SIQ 2188 -1, // 423 - MIR_END 2189 };*/ 2190 2191 /** 2192 * Decoding table. Translate the target non-terminal and minimal cost covering state encoding 2193 * non-terminal into the rule that produces the non-terminal. 2194 * The first index is the non-terminal that we wish to produce. 2195 * The second index is the state non-terminal associated with covering a tree 2196 * with minimal cost and is computed by jburg based on the non-terminal to be produced. 2197 * The value in the array is the rule number 2198 */ 2199 private static final char[][] decode = { 2200 null, // [0][0] 2201 { // stm_NT 2202 0, // [1][0] 2203 1, // [1][1] - stm: r 2204 27, // [1][2] - stm: IG_PATCH_POINT 2205 28, // [1][3] - stm: UNINT_BEGIN 2206 29, // [1][4] - stm: UNINT_END 2207 30, // [1][5] - stm: YIELDPOINT_PROLOGUE 2208 31, // [1][6] - stm: YIELDPOINT_EPILOGUE 2209 32, // [1][7] - stm: YIELDPOINT_BACKEDGE 2210 247, // [1][8] - stm: LOWTABLESWITCH(r) 2211 33, // [1][9] - stm: RESOLVE 2212 34, // [1][10] - stm: NOP 2213 248, // [1][11] - stm: NULL_CHECK(riv) 2214 37, // [1][12] - stm: IR_PROLOGUE 2215 249, // [1][13] - stm: SET_CAUGHT_EXCEPTION(r) 2216 39, // [1][14] - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 2217 40, // [1][15] - stm: TRAP 2218 250, // [1][16] - stm: TRAP_IF(r,INT_CONSTANT) 2219 251, // [1][17] - stm: TRAP_IF(r,LONG_CONSTANT) 2220 52, // [1][18] - stm: TRAP_IF(r,r) 2221 53, // [1][19] - stm: TRAP_IF(load32,riv) 2222 54, // [1][20] - stm: TRAP_IF(riv,load32) 2223 397, // [1][21] - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 2224 398, // [1][22] - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 2225 399, // [1][23] - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 2226 400, // [1][24] - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 2227 401, // [1][25] - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 2228 402, // [1][26] - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 2229 403, // [1][27] - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 2230 404, // [1][28] - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 2231 405, // [1][29] - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 2232 406, // [1][30] - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 2233 407, // [1][31] - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 2234 408, // [1][32] - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 2235 409, // [1][33] - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 2236 410, // [1][34] - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2237 411, // [1][35] - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 2238 466, // [1][36] - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 2239 467, // [1][37] - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 2240 41, // [1][38] - stm: GOTO 2241 256, // [1][39] - stm: PREFETCH(r) 2242 42, // [1][40] - stm: WRITE_FLOOR 2243 43, // [1][41] - stm: READ_CEILING 2244 44, // [1][42] - stm: FENCE 2245 45, // [1][43] - stm: PAUSE 2246 46, // [1][44] - stm: RETURN(NULL) 2247 47, // [1][45] - stm: RETURN(INT_CONSTANT) 2248 257, // [1][46] - stm: RETURN(r) 2249 48, // [1][47] - stm: RETURN(LONG_CONSTANT) 2250 58, // [1][48] - stm: YIELDPOINT_OSR(any,any) 2251 494, // [1][49] - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2252 495, // [1][50] - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2253 496, // [1][51] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2254 497, // [1][52] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2255 498, // [1][53] - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2256 514, // [1][54] - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2257 518, // [1][55] - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2258 499, // [1][56] - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2259 500, // [1][57] - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2260 501, // [1][58] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2261 502, // [1][59] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2262 503, // [1][60] - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2263 515, // [1][61] - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2264 519, // [1][62] - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2265 504, // [1][63] - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2266 505, // [1][64] - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2267 506, // [1][65] - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2268 507, // [1][66] - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2269 508, // [1][67] - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2270 516, // [1][68] - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2271 520, // [1][69] - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2272 509, // [1][70] - stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2273 510, // [1][71] - stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2274 511, // [1][72] - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2275 512, // [1][73] - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2276 513, // [1][74] - stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2277 517, // [1][75] - stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2278 521, // [1][76] - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 2279 412, // [1][77] - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 2280 413, // [1][78] - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 2281 530, // [1][79] - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2282 531, // [1][80] - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) 2283 414, // [1][81] - stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) 2284 415, // [1][82] - stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) 2285 416, // [1][83] - stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 2286 417, // [1][84] - stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) 2287 561, // [1][85] - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 2288 562, // [1][86] - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 2289 563, // [1][87] - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 2290 564, // [1][88] - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 2291 565, // [1][89] - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 2292 566, // [1][90] - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 2293 569, // [1][91] - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2294 589, // [1][92] - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2295 570, // [1][93] - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2296 590, // [1][94] - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2297 571, // [1][95] - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2298 591, // [1][96] - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2299 572, // [1][97] - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2300 592, // [1][98] - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2301 93, // [1][99] - stm: INT_IFCMP(r,riv) 2302 309, // [1][100] - stm: INT_IFCMP(r,INT_CONSTANT) 2303 310, // [1][101] - stm: INT_IFCMP(load8,INT_CONSTANT) 2304 94, // [1][102] - stm: INT_IFCMP(uload8,r) 2305 95, // [1][103] - stm: INT_IFCMP(r,uload8) 2306 311, // [1][104] - stm: INT_IFCMP(sload16,INT_CONSTANT) 2307 96, // [1][105] - stm: INT_IFCMP(load32,riv) 2308 97, // [1][106] - stm: INT_IFCMP(r,load32) 2309 312, // [1][107] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2310 313, // [1][108] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2311 314, // [1][109] - stm: INT_IFCMP(cz,INT_CONSTANT) 2312 315, // [1][110] - stm: INT_IFCMP(szp,INT_CONSTANT) 2313 316, // [1][111] - stm: INT_IFCMP(bittest,INT_CONSTANT) 2314 98, // [1][112] - stm: INT_IFCMP2(r,riv) 2315 99, // [1][113] - stm: INT_IFCMP2(load32,riv) 2316 100, // [1][114] - stm: INT_IFCMP2(riv,load32) 2317 532, // [1][115] - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2318 533, // [1][116] - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2319 534, // [1][117] - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2320 535, // [1][118] - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2321 573, // [1][119] - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2322 593, // [1][120] - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2323 574, // [1][121] - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2324 594, // [1][122] - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2325 625, // [1][123] - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2326 536, // [1][124] - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2327 626, // [1][125] - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2328 537, // [1][126] - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2329 627, // [1][127] - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2330 538, // [1][128] - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2331 628, // [1][129] - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2332 539, // [1][130] - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2333 423, // [1][131] - stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 2334 424, // [1][132] - stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) 2335 425, // [1][133] - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) 2336 426, // [1][134] - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 2337 427, // [1][135] - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 2338 619, // [1][136] - stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) 2339 575, // [1][137] - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2340 595, // [1][138] - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2341 576, // [1][139] - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2342 596, // [1][140] - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2343 629, // [1][141] - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2344 540, // [1][142] - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2345 630, // [1][143] - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2346 541, // [1][144] - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2347 577, // [1][145] - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2348 597, // [1][146] - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2349 578, // [1][147] - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2350 598, // [1][148] - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2351 567, // [1][149] - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 2352 568, // [1][150] - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 2353 579, // [1][151] - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2354 599, // [1][152] - stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2355 580, // [1][153] - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2356 600, // [1][154] - stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2357 581, // [1][155] - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2358 601, // [1][156] - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2359 582, // [1][157] - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2360 602, // [1][158] - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2361 173, // [1][159] - stm: LONG_IFCMP(rlv,rlv) 2362 341, // [1][160] - stm: LONG_IFCMP(r,LONG_CONSTANT) 2363 542, // [1][161] - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2364 543, // [1][162] - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2365 544, // [1][163] - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2366 545, // [1][164] - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2367 583, // [1][165] - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2368 603, // [1][166] - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2369 584, // [1][167] - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2370 604, // [1][168] - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2371 631, // [1][169] - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2372 546, // [1][170] - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2373 632, // [1][171] - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2374 547, // [1][172] - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2375 633, // [1][173] - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 2376 548, // [1][174] - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 2377 634, // [1][175] - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 2378 549, // [1][176] - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 2379 431, // [1][177] - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 2380 432, // [1][178] - stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) 2381 433, // [1][179] - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) 2382 434, // [1][180] - stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) 2383 435, // [1][181] - stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) 2384 623, // [1][182] - stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) 2385 585, // [1][183] - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2386 605, // [1][184] - stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2387 586, // [1][185] - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2388 606, // [1][186] - stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2389 635, // [1][187] - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 2390 550, // [1][188] - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 2391 636, // [1][189] - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 2392 551, // [1][190] - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 2393 587, // [1][191] - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2394 607, // [1][192] - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2395 588, // [1][193] - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2396 608, // [1][194] - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2397 436, // [1][195] - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 2398 437, // [1][196] - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 2399 438, // [1][197] - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 2400 439, // [1][198] - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 2401 440, // [1][199] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 2402 441, // [1][200] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 2403 442, // [1][201] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 2404 443, // [1][202] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2405 444, // [1][203] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 2406 445, // [1][204] - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 2407 446, // [1][205] - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 2408 447, // [1][206] - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 2409 448, // [1][207] - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 2410 449, // [1][208] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 2411 450, // [1][209] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 2412 451, // [1][210] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 2413 452, // [1][211] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2414 453, // [1][212] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 2415 50, // [1][213] - stm: CLEAR_FLOATING_POINT_STATE 2416 241, // [1][214] - stm: FLOAT_IFCMP(r,r) 2417 242, // [1][215] - stm: FLOAT_IFCMP(r,float_load) 2418 243, // [1][216] - stm: FLOAT_IFCMP(float_load,r) 2419 244, // [1][217] - stm: DOUBLE_IFCMP(r,r) 2420 245, // [1][218] - stm: DOUBLE_IFCMP(r,double_load) 2421 246, // [1][219] - stm: DOUBLE_IFCMP(double_load,r) 2422 462, // [1][220] - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 2423 463, // [1][221] - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 2424 464, // [1][222] - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 2425 465, // [1][223] - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 2426 }, 2427 { // r_NT 2428 0, // [2][0] 2429 21, // [2][1] - r: REGISTER 2430 2, // [2][2] - r: czr 2431 4, // [2][3] - r: szpr 2432 35, // [2][4] - r: GUARD_MOVE 2433 36, // [2][5] - r: GUARD_COMBINE 2434 38, // [2][6] - r: GET_CAUGHT_EXCEPTION 2435 253, // [2][7] - r: INT_AND(load8_16_32,INT_CONSTANT) 2436 254, // [2][8] - r: INT_2BYTE(load8_16_32) 2437 383, // [2][9] - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 2438 255, // [2][10] - r: INT_AND(load16_32,INT_CONSTANT) 2439 384, // [2][11] - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 2440 55, // [2][12] - r: LONG_CMP(rlv,rlv) 2441 56, // [2][13] - r: CALL(r,any) 2442 468, // [2][14] - r: CALL(BRANCH_TARGET,any) 2443 471, // [2][15] - r: CALL(INT_LOAD(riv,riv),any) 2444 469, // [2][16] - r: CALL(INT_CONSTANT,any) 2445 472, // [2][17] - r: CALL(LONG_LOAD(rlv,rlv),any) 2446 57, // [2][18] - r: SYSCALL(r,any) 2447 473, // [2][19] - r: SYSCALL(INT_LOAD(riv,riv),any) 2448 470, // [2][20] - r: SYSCALL(INT_CONSTANT,any) 2449 49, // [2][21] - r: GET_TIME_BASE 2450 474, // [2][22] - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 2451 475, // [2][23] - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 2452 476, // [2][24] - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 2453 477, // [2][25] - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 2454 478, // [2][26] - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 2455 479, // [2][27] - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 2456 480, // [2][28] - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 2457 490, // [2][29] - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 2458 492, // [2][30] - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 2459 481, // [2][31] - r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) 2460 482, // [2][32] - r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 2461 483, // [2][33] - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) 2462 484, // [2][34] - r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) 2463 485, // [2][35] - r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 2464 491, // [2][36] - r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) 2465 493, // [2][37] - r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) 2466 69, // [2][38] - r: BOOLEAN_CMP_INT(r,riv) 2467 270, // [2][39] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2468 272, // [2][40] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2469 273, // [2][41] - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 2470 274, // [2][42] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2471 275, // [2][43] - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 2472 276, // [2][44] - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 2473 278, // [2][45] - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 2474 280, // [2][46] - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 2475 282, // [2][47] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2476 284, // [2][48] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2477 71, // [2][49] - r: BOOLEAN_CMP_INT(load32,riv) 2478 73, // [2][50] - r: BOOLEAN_CMP_INT(r,load32) 2479 75, // [2][51] - r: BOOLEAN_CMP_LONG(r,rlv) 2480 286, // [2][52] - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 2481 288, // [2][53] - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 2482 289, // [2][54] - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 2483 290, // [2][55] - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 2484 291, // [2][56] - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 2485 292, // [2][57] - r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) 2486 77, // [2][58] - r: BOOLEAN_CMP_LONG(load64,rlv) 2487 79, // [2][59] - r: BOOLEAN_CMP_LONG(r,load64) 2488 293, // [2][60] - r: BOOLEAN_NOT(r) 2489 418, // [2][61] - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 2490 552, // [2][62] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 2491 294, // [2][63] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2492 295, // [2][64] - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2493 296, // [2][65] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2494 297, // [2][66] - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2495 553, // [2][67] - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 2496 419, // [2][68] - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 2497 420, // [2][69] - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 2498 554, // [2][70] - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 2499 421, // [2][71] - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 2500 422, // [2][72] - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 2501 555, // [2][73] - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 2502 556, // [2][74] - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 2503 557, // [2][75] - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 2504 558, // [2][76] - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 2505 559, // [2][77] - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 2506 298, // [2][78] - r: INT_2BYTE(r) 2507 299, // [2][79] - r: INT_2BYTE(load8_16_32) 2508 300, // [2][80] - r: INT_2LONG(r) 2509 301, // [2][81] - r: INT_2LONG(load32) 2510 387, // [2][82] - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 2511 388, // [2][83] - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 2512 302, // [2][84] - r: INT_2ADDRZerExt(r) 2513 303, // [2][85] - r: INT_2SHORT(r) 2514 304, // [2][86] - r: INT_2SHORT(load16_32) 2515 308, // [2][87] - r: INT_2USHORT(load16_32) 2516 82, // [2][88] - r: INT_ADD(r,riv) 2517 91, // [2][89] - r: INT_DIV(riv,riv) 2518 92, // [2][90] - r: INT_DIV(riv,load32) 2519 101, // [2][91] - r: INT_LOAD(rlv,rlv) 2520 102, // [2][92] - r: INT_LOAD(rlv,address1scaledreg) 2521 103, // [2][93] - r: INT_LOAD(address1scaledreg,rlv) 2522 104, // [2][94] - r: INT_LOAD(address1scaledreg,address1reg) 2523 105, // [2][95] - r: INT_LOAD(address1reg,address1scaledreg) 2524 317, // [2][96] - r: INT_LOAD(address,LONG_CONSTANT) 2525 106, // [2][97] - r: INT_ALOAD(rlv,riv) 2526 318, // [2][98] - r: INT_MOVE(riv) 2527 107, // [2][99] - r: INT_MUL(r,riv) 2528 108, // [2][100] - r: INT_MUL(r,load32) 2529 109, // [2][101] - r: INT_MUL(load32,riv) 2530 331, // [2][102] - r: INT_NOT(r) 2531 113, // [2][103] - r: INT_REM(riv,riv) 2532 114, // [2][104] - r: INT_REM(riv,load32) 2533 609, // [2][105] - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 2534 610, // [2][106] - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 2535 611, // [2][107] - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 2536 612, // [2][108] - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 2537 613, // [2][109] - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 2538 615, // [2][110] - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 2539 616, // [2][111] - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 2540 614, // [2][112] - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 2541 333, // [2][113] - r: INT_SHL(r,INT_CONSTANT) 2542 118, // [2][114] - r: INT_SUB(riv,r) 2543 119, // [2][115] - r: INT_SUB(load32,r) 2544 428, // [2][116] - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 2545 560, // [2][117] - r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 2546 429, // [2][118] - r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) 2547 430, // [2][119] - r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) 2548 126, // [2][120] - r: LONG_ADD(address1scaledreg,r) 2549 127, // [2][121] - r: LONG_ADD(r,address1scaledreg) 2550 128, // [2][122] - r: LONG_ADD(address1scaledreg,address1reg) 2551 129, // [2][123] - r: LONG_ADD(address1reg,address1scaledreg) 2552 336, // [2][124] - r: LONG_ADD(address,LONG_CONSTANT) 2553 337, // [2][125] - r: LONG_MOVE(address) 2554 130, // [2][126] - r: BYTE_LOAD(rlv,rlv) 2555 132, // [2][127] - r: BYTE_ALOAD(rlv,riv) 2556 133, // [2][128] - r: BYTE_ALOAD(rlv,r) 2557 135, // [2][129] - r: UBYTE_LOAD(rlv,rlv) 2558 137, // [2][130] - r: UBYTE_ALOAD(rlv,riv) 2559 138, // [2][131] - r: UBYTE_ALOAD(rlv,r) 2560 140, // [2][132] - r: SHORT_LOAD(rlv,rlv) 2561 142, // [2][133] - r: SHORT_ALOAD(rlv,riv) 2562 143, // [2][134] - r: SHORT_ALOAD(rlv,r) 2563 145, // [2][135] - r: USHORT_LOAD(rlv,rlv) 2564 147, // [2][136] - r: USHORT_ALOAD(rlv,riv) 2565 148, // [2][137] - r: USHORT_ALOAD(rlv,r) 2566 338, // [2][138] - r: LONG_2INT(r) 2567 339, // [2][139] - r: LONG_2INT(load64) 2568 390, // [2][140] - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 2569 391, // [2][141] - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 2570 392, // [2][142] - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 2571 393, // [2][143] - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 2572 158, // [2][144] - r: LONG_ADD(r,rlv) 2573 168, // [2][145] - r: LONG_DIV(rlv,rlv) 2574 169, // [2][146] - r: LONG_DIV(rlv,riv) 2575 170, // [2][147] - r: LONG_DIV(riv,rlv) 2576 171, // [2][148] - r: LONG_DIV(rlv,load64) 2577 172, // [2][149] - r: LONG_DIV(load64,rlv) 2578 174, // [2][150] - r: LONG_LOAD(rlv,rlv) 2579 175, // [2][151] - r: LONG_LOAD(rlv,address1scaledreg) 2580 176, // [2][152] - r: LONG_LOAD(address1scaledreg,rlv) 2581 177, // [2][153] - r: LONG_LOAD(address1scaledreg,address1reg) 2582 178, // [2][154] - r: LONG_LOAD(address1reg,address1scaledreg) 2583 342, // [2][155] - r: LONG_LOAD(address,LONG_CONSTANT) 2584 179, // [2][156] - r: LONG_ALOAD(rlv,riv) 2585 180, // [2][157] - r: LONG_ALOAD(rlv,r) 2586 343, // [2][158] - r: LONG_MOVE(rlv) 2587 344, // [2][159] - r: LONG_MOVE(riv) 2588 181, // [2][160] - r: LONG_MUL(r,rlv) 2589 182, // [2][161] - r: INT_MUL(r,load64) 2590 183, // [2][162] - r: INT_MUL(load64,rlv) 2591 347, // [2][163] - r: LONG_NOT(r) 2592 187, // [2][164] - r: LONG_REM(rlv,rlv) 2593 188, // [2][165] - r: LONG_REM(rlv,riv) 2594 189, // [2][166] - r: LONG_REM(riv,rlv) 2595 190, // [2][167] - r: LONG_REM(rlv,load64) 2596 191, // [2][168] - r: LONG_REM(load64,rlv) 2597 349, // [2][169] - r: LONG_SHL(r,INT_CONSTANT) 2598 195, // [2][170] - r: LONG_SUB(rlv,r) 2599 196, // [2][171] - r: LONG_SUB(load64,r) 2600 203, // [2][172] - r: FLOAT_ADD(r,r) 2601 204, // [2][173] - r: FLOAT_ADD(r,float_load) 2602 205, // [2][174] - r: FLOAT_ADD(float_load,r) 2603 206, // [2][175] - r: DOUBLE_ADD(r,r) 2604 207, // [2][176] - r: DOUBLE_ADD(r,double_load) 2605 208, // [2][177] - r: DOUBLE_ADD(double_load,r) 2606 209, // [2][178] - r: FLOAT_SUB(r,r) 2607 210, // [2][179] - r: FLOAT_SUB(r,float_load) 2608 211, // [2][180] - r: DOUBLE_SUB(r,r) 2609 212, // [2][181] - r: DOUBLE_SUB(r,double_load) 2610 213, // [2][182] - r: FLOAT_MUL(r,r) 2611 214, // [2][183] - r: FLOAT_MUL(r,float_load) 2612 215, // [2][184] - r: FLOAT_MUL(float_load,r) 2613 216, // [2][185] - r: DOUBLE_MUL(r,r) 2614 217, // [2][186] - r: DOUBLE_MUL(r,double_load) 2615 218, // [2][187] - r: DOUBLE_MUL(double_load,r) 2616 219, // [2][188] - r: FLOAT_DIV(r,r) 2617 220, // [2][189] - r: FLOAT_DIV(r,float_load) 2618 221, // [2][190] - r: DOUBLE_DIV(r,r) 2619 222, // [2][191] - r: DOUBLE_DIV(r,double_load) 2620 352, // [2][192] - r: FLOAT_NEG(r) 2621 353, // [2][193] - r: DOUBLE_NEG(r) 2622 354, // [2][194] - r: FLOAT_SQRT(r) 2623 355, // [2][195] - r: DOUBLE_SQRT(r) 2624 223, // [2][196] - r: FLOAT_REM(r,r) 2625 224, // [2][197] - r: DOUBLE_REM(r,r) 2626 356, // [2][198] - r: LONG_2FLOAT(r) 2627 357, // [2][199] - r: LONG_2DOUBLE(r) 2628 358, // [2][200] - r: FLOAT_MOVE(r) 2629 359, // [2][201] - r: DOUBLE_MOVE(r) 2630 225, // [2][202] - r: DOUBLE_LOAD(riv,riv) 2631 226, // [2][203] - r: DOUBLE_LOAD(riv,rlv) 2632 227, // [2][204] - r: DOUBLE_LOAD(rlv,rlv) 2633 229, // [2][205] - r: DOUBLE_ALOAD(riv,riv) 2634 231, // [2][206] - r: DOUBLE_ALOAD(riv,r) 2635 232, // [2][207] - r: DOUBLE_ALOAD(rlv,rlv) 2636 234, // [2][208] - r: FLOAT_LOAD(riv,riv) 2637 235, // [2][209] - r: FLOAT_LOAD(rlv,rlv) 2638 237, // [2][210] - r: FLOAT_ALOAD(riv,riv) 2639 238, // [2][211] - r: FLOAT_ALOAD(riv,r) 2640 239, // [2][212] - r: FLOAT_ALOAD(rlv,rlv) 2641 360, // [2][213] - r: INT_2FLOAT(riv) 2642 361, // [2][214] - r: INT_2FLOAT(load32) 2643 362, // [2][215] - r: INT_2DOUBLE(riv) 2644 363, // [2][216] - r: INT_2DOUBLE(load32) 2645 364, // [2][217] - r: FLOAT_2DOUBLE(r) 2646 365, // [2][218] - r: FLOAT_2DOUBLE(float_load) 2647 366, // [2][219] - r: DOUBLE_2FLOAT(r) 2648 367, // [2][220] - r: DOUBLE_2FLOAT(double_load) 2649 368, // [2][221] - r: FLOAT_2INT(r) 2650 369, // [2][222] - r: FLOAT_2LONG(r) 2651 370, // [2][223] - r: DOUBLE_2INT(r) 2652 371, // [2][224] - r: DOUBLE_2LONG(r) 2653 372, // [2][225] - r: FLOAT_AS_INT_BITS(r) 2654 374, // [2][226] - r: DOUBLE_AS_LONG_BITS(r) 2655 376, // [2][227] - r: INT_BITS_AS_FLOAT(riv) 2656 378, // [2][228] - r: LONG_BITS_AS_DOUBLE(rlv) 2657 380, // [2][229] - r: MATERIALIZE_FP_CONSTANT(any) 2658 454, // [2][230] - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 2659 455, // [2][231] - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 2660 456, // [2][232] - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 2661 457, // [2][233] - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 2662 458, // [2][234] - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 2663 459, // [2][235] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 2664 486, // [2][236] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 2665 487, // [2][237] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 2666 488, // [2][238] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 2667 489, // [2][239] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 2668 460, // [2][240] - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 2669 461, // [2][241] - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 2670 637, // [2][242] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 2671 638, // [2][243] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 2672 641, // [2][244] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 2673 642, // [2][245] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 2674 645, // [2][246] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 2675 646, // [2][247] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 2676 649, // [2][248] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 2677 650, // [2][249] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 2678 639, // [2][250] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2679 640, // [2][251] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2680 643, // [2][252] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 2681 644, // [2][253] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 2682 647, // [2][254] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 2683 648, // [2][255] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 2684 651, // [2][256] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2685 652, // [2][257] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2686 }, 2687 { // czr_NT 2688 0, // [3][0] 2689 81, // [3][1] - czr: INT_ADD(r,riv) 2690 83, // [3][2] - czr: INT_ADD(r,load32) 2691 84, // [3][3] - czr: INT_ADD(load32,riv) 2692 319, // [3][4] - czr: INT_MOVE(czr) 2693 117, // [3][5] - czr: INT_SUB(riv,r) 2694 120, // [3][6] - czr: INT_SUB(riv,load32) 2695 121, // [3][7] - czr: INT_SUB(load32,riv) 2696 155, // [3][8] - czr: LONG_ADD(r,rlv) 2697 156, // [3][9] - czr: LONG_ADD(r,riv) 2698 157, // [3][10] - czr: LONG_ADD(r,r) 2699 159, // [3][11] - czr: LONG_ADD(rlv,load64) 2700 160, // [3][12] - czr: LONG_ADD(load64,rlv) 2701 194, // [3][13] - czr: LONG_SUB(rlv,r) 2702 197, // [3][14] - czr: LONG_SUB(rlv,load64) 2703 198, // [3][15] - czr: LONG_SUB(load64,rlv) 2704 }, 2705 { // cz_NT 2706 0, // [4][0] 2707 3, // [4][1] - cz: czr 2708 320, // [4][2] - cz: INT_MOVE(cz) 2709 }, 2710 { // szpr_NT 2711 0, // [5][0] 2712 306, // [5][1] - szpr: INT_2USHORT(r) 2713 85, // [5][2] - szpr: INT_AND(r,riv) 2714 87, // [5][3] - szpr: INT_AND(r,load32) 2715 88, // [5][4] - szpr: INT_AND(load32,riv) 2716 321, // [5][5] - szpr: INT_MOVE(szpr) 2717 330, // [5][6] - szpr: INT_NEG(r) 2718 110, // [5][7] - szpr: INT_OR(r,riv) 2719 111, // [5][8] - szpr: INT_OR(r,load32) 2720 112, // [5][9] - szpr: INT_OR(load32,riv) 2721 617, // [5][10] - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 2722 115, // [5][11] - szpr: INT_SHL(riv,riv) 2723 332, // [5][12] - szpr: INT_SHL(r,INT_CONSTANT) 2724 389, // [5][13] - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 2725 618, // [5][14] - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 2726 116, // [5][15] - szpr: INT_SHR(riv,riv) 2727 334, // [5][16] - szpr: INT_SHR(riv,INT_CONSTANT) 2728 620, // [5][17] - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 2729 122, // [5][18] - szpr: INT_USHR(riv,riv) 2730 335, // [5][19] - szpr: INT_USHR(riv,INT_CONSTANT) 2731 123, // [5][20] - szpr: INT_XOR(r,riv) 2732 124, // [5][21] - szpr: INT_XOR(r,load32) 2733 125, // [5][22] - szpr: INT_XOR(load32,riv) 2734 161, // [5][23] - szpr: LONG_AND(r,rlv) 2735 162, // [5][24] - szpr: LONG_AND(r,r) 2736 164, // [5][25] - szpr: LONG_AND(rlv,load64) 2737 165, // [5][26] - szpr: LONG_AND(load64,rlv) 2738 346, // [5][27] - szpr: LONG_NEG(r) 2739 184, // [5][28] - szpr: LONG_OR(r,rlv) 2740 185, // [5][29] - szpr: LONG_OR(r,load64) 2741 186, // [5][30] - szpr: LONG_OR(load64,rlv) 2742 621, // [5][31] - szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) 2743 192, // [5][32] - szpr: LONG_SHL(rlv,riv) 2744 348, // [5][33] - szpr: LONG_SHL(r,INT_CONSTANT) 2745 396, // [5][34] - szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) 2746 622, // [5][35] - szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) 2747 193, // [5][36] - szpr: LONG_SHR(rlv,riv) 2748 350, // [5][37] - szpr: LONG_SHR(rlv,LONG_CONSTANT) 2749 624, // [5][38] - szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) 2750 199, // [5][39] - szpr: LONG_USHR(rlv,riv) 2751 351, // [5][40] - szpr: LONG_USHR(rlv,LONG_CONSTANT) 2752 200, // [5][41] - szpr: LONG_XOR(r,rlv) 2753 201, // [5][42] - szpr: LONG_XOR(r,load64) 2754 202, // [5][43] - szpr: LONG_XOR(load64,rlv) 2755 }, 2756 { // szp_NT 2757 0, // [6][0] 2758 5, // [6][1] - szp: szpr 2759 86, // [6][2] - szp: INT_AND(r,riv) 2760 89, // [6][3] - szp: INT_AND(load8_16_32,riv) 2761 90, // [6][4] - szp: INT_AND(r,load8_16_32) 2762 322, // [6][5] - szp: INT_MOVE(szp) 2763 163, // [6][6] - szp: LONG_AND(r,rlv) 2764 166, // [6][7] - szp: LONG_AND(load8_16_32_64,rlv) 2765 167, // [6][8] - szp: LONG_AND(r,load8_16_32_64) 2766 }, 2767 { // riv_NT 2768 0, // [7][0] 2769 6, // [7][1] - riv: r 2770 22, // [7][2] - riv: INT_CONSTANT 2771 }, 2772 { // rlv_NT 2773 0, // [8][0] 2774 7, // [8][1] - rlv: r 2775 23, // [8][2] - rlv: LONG_CONSTANT 2776 }, 2777 { // any_NT 2778 0, // [9][0] 2779 24, // [9][1] - any: NULL 2780 8, // [9][2] - any: riv 2781 25, // [9][3] - any: ADDRESS_CONSTANT 2782 26, // [9][4] - any: LONG_CONSTANT 2783 51, // [9][5] - any: OTHER_OPERAND(any,any) 2784 }, 2785 { // load32_NT 2786 0, // [10][0] 2787 329, // [10][1] - load32: INT_MOVE(load32) 2788 150, // [10][2] - load32: INT_LOAD(rlv,rlv) 2789 151, // [10][3] - load32: INT_ALOAD(rlv,riv) 2790 340, // [10][4] - load32: LONG_2INT(load64) 2791 394, // [10][5] - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 2792 395, // [10][6] - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 2793 373, // [10][7] - load32: FLOAT_AS_INT_BITS(float_load) 2794 }, 2795 { // uload8_NT 2796 0, // [11][0] 2797 252, // [11][1] - uload8: INT_AND(load8_16_32,INT_CONSTANT) 2798 324, // [11][2] - uload8: INT_MOVE(uload8) 2799 136, // [11][3] - uload8: UBYTE_LOAD(rlv,rlv) 2800 139, // [11][4] - uload8: UBYTE_ALOAD(rlv,riv) 2801 }, 2802 { // load8_16_32_NT 2803 0, // [12][0] 2804 17, // [12][1] - load8_16_32: load16_32 2805 18, // [12][2] - load8_16_32: load8 2806 }, 2807 { // load16_32_NT 2808 0, // [13][0] 2809 15, // [13][1] - load16_32: load16 2810 16, // [13][2] - load16_32: load32 2811 }, 2812 { // load16_NT 2813 0, // [14][0] 2814 328, // [14][1] - load16: INT_MOVE(load16) 2815 13, // [14][2] - load16: sload16 2816 14, // [14][3] - load16: uload16 2817 }, 2818 { // address1scaledreg_NT 2819 0, // [15][0] 2820 9, // [15][1] - address1scaledreg: address1reg 2821 258, // [15][2] - address1scaledreg: INT_SHL(r,INT_CONSTANT) 2822 262, // [15][3] - address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) 2823 264, // [15][4] - address1scaledreg: LONG_SHL(r,INT_CONSTANT) 2824 268, // [15][5] - address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) 2825 }, 2826 { // address1reg_NT 2827 0, // [16][0] 2828 259, // [16][1] - address1reg: INT_ADD(r,LONG_CONSTANT) 2829 260, // [16][2] - address1reg: INT_MOVE(r) 2830 261, // [16][3] - address1reg: INT_ADD(address1reg,LONG_CONSTANT) 2831 265, // [16][4] - address1reg: LONG_ADD(r,LONG_CONSTANT) 2832 266, // [16][5] - address1reg: LONG_MOVE(r) 2833 267, // [16][6] - address1reg: LONG_ADD(address1reg,LONG_CONSTANT) 2834 }, 2835 { // address_NT 2836 0, // [17][0] 2837 10, // [17][1] - address: address1scaledreg 2838 59, // [17][2] - address: INT_ADD(r,r) 2839 60, // [17][3] - address: INT_ADD(r,address1scaledreg) 2840 61, // [17][4] - address: INT_ADD(address1scaledreg,r) 2841 263, // [17][5] - address: INT_ADD(address1scaledreg,LONG_CONSTANT) 2842 62, // [17][6] - address: INT_ADD(address1scaledreg,address1reg) 2843 63, // [17][7] - address: INT_ADD(address1reg,address1scaledreg) 2844 64, // [17][8] - address: LONG_ADD(r,r) 2845 65, // [17][9] - address: LONG_ADD(r,address1scaledreg) 2846 66, // [17][10] - address: LONG_ADD(address1scaledreg,r) 2847 269, // [17][11] - address: LONG_ADD(address1scaledreg,LONG_CONSTANT) 2848 67, // [17][12] - address: LONG_ADD(address1scaledreg,address1reg) 2849 68, // [17][13] - address: LONG_ADD(address1reg,address1scaledreg) 2850 }, 2851 { // bittest_NT 2852 0, // [18][0] 2853 522, // [18][1] - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2854 523, // [18][2] - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2855 385, // [18][3] - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 2856 524, // [18][4] - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2857 525, // [18][5] - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2858 386, // [18][6] - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 2859 526, // [18][7] - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 2860 527, // [18][8] - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 2861 528, // [18][9] - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 2862 529, // [18][10] - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 2863 }, 2864 { // boolcmp_NT 2865 0, // [19][0] 2866 70, // [19][1] - boolcmp: BOOLEAN_CMP_INT(r,riv) 2867 271, // [19][2] - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2868 277, // [19][3] - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 2869 279, // [19][4] - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 2870 281, // [19][5] - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 2871 283, // [19][6] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2872 285, // [19][7] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2873 72, // [19][8] - boolcmp: BOOLEAN_CMP_INT(load32,riv) 2874 74, // [19][9] - boolcmp: BOOLEAN_CMP_INT(riv,load32) 2875 76, // [19][10] - boolcmp: BOOLEAN_CMP_LONG(r,rlv) 2876 287, // [19][11] - boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 2877 78, // [19][12] - boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 2878 80, // [19][13] - boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 2879 }, 2880 { // load64_NT 2881 0, // [20][0] 2882 152, // [20][1] - load64: LONG_LOAD(rlv,rlv) 2883 153, // [20][2] - load64: LONG_ALOAD(rlv,rlv) 2884 154, // [20][3] - load64: LONG_ALOAD(rlv,r) 2885 345, // [20][4] - load64: LONG_MOVE(load64) 2886 375, // [20][5] - load64: DOUBLE_AS_LONG_BITS(double_load) 2887 }, 2888 { // load8_NT 2889 0, // [21][0] 2890 325, // [21][1] - load8: INT_MOVE(load8) 2891 11, // [21][2] - load8: sload8 2892 12, // [21][3] - load8: uload8 2893 }, 2894 { // sload16_NT 2895 0, // [22][0] 2896 305, // [22][1] - sload16: INT_2SHORT(load16_32) 2897 326, // [22][2] - sload16: INT_MOVE(sload16) 2898 141, // [22][3] - sload16: SHORT_LOAD(rlv,rlv) 2899 144, // [22][4] - sload16: SHORT_ALOAD(rlv,riv) 2900 }, 2901 { // uload16_NT 2902 0, // [23][0] 2903 307, // [23][1] - uload16: INT_2USHORT(load16_32) 2904 327, // [23][2] - uload16: INT_MOVE(uload16) 2905 146, // [23][3] - uload16: USHORT_LOAD(rlv,rlv) 2906 149, // [23][4] - uload16: USHORT_ALOAD(rlv,riv) 2907 }, 2908 { // sload8_NT 2909 0, // [24][0] 2910 323, // [24][1] - sload8: INT_MOVE(sload8) 2911 131, // [24][2] - sload8: BYTE_LOAD(rlv,rlv) 2912 134, // [24][3] - sload8: BYTE_ALOAD(rlv,riv) 2913 }, 2914 { // load8_16_32_64_NT 2915 0, // [25][0] 2916 19, // [25][1] - load8_16_32_64: load64 2917 20, // [25][2] - load8_16_32_64: load8_16_32 2918 }, 2919 { // float_load_NT 2920 0, // [26][0] 2921 236, // [26][1] - float_load: FLOAT_LOAD(riv,riv) 2922 240, // [26][2] - float_load: FLOAT_ALOAD(riv,riv) 2923 377, // [26][3] - float_load: INT_BITS_AS_FLOAT(load32) 2924 381, // [26][4] - float_load: MATERIALIZE_FP_CONSTANT(any) 2925 }, 2926 { // double_load_NT 2927 0, // [27][0] 2928 228, // [27][1] - double_load: DOUBLE_LOAD(riv,riv) 2929 230, // [27][2] - double_load: DOUBLE_LOAD(rlv,rlv) 2930 233, // [27][3] - double_load: DOUBLE_ALOAD(riv,riv) 2931 379, // [27][4] - double_load: LONG_BITS_AS_DOUBLE(load64) 2932 382, // [27][5] - double_load: MATERIALIZE_FP_CONSTANT(any) 2933 }, 2934 }; 2935 2936 /** 2937 * Create closure for r 2938 * @param p the node 2939 * @param c the cost 2940 */ 2941 @Inline 2942 private static void closure_r(AbstractBURS_TreeNode p, int c) { 2943 if(BURS.DEBUG) trace(p, 7, c + 0, p.getCost(8) /* rlv */); 2944 if (c < p.getCost(8) /* rlv */) { 2945 p.setCost(8 /* rlv */, (char)(c)); 2946 p.writePacked(1, 0xFFFFFF3F, 0x40); // p.rlv = 1 2947 } 2948 if(BURS.DEBUG) trace(p, 6, c + 0, p.getCost(7) /* riv */); 2949 if (c < p.getCost(7) /* riv */) { 2950 p.setCost(7 /* riv */, (char)(c)); 2951 p.writePacked(1, 0xFFFFFFCF, 0x10); // p.riv = 1 2952 closure_riv(p, c); 2953 } 2954 if(BURS.DEBUG) trace(p, 1, c + 0, p.getCost(1) /* stm */); 2955 if (c < p.getCost(1) /* stm */) { 2956 p.setCost(1 /* stm */, (char)(c)); 2957 p.writePacked(0, 0xFFFFFF00, 0x1); // p.stm = 1 2958 } 2959 } 2960 2961 /** 2962 * Create closure for czr 2963 * @param p the node 2964 * @param c the cost 2965 */ 2966 @Inline 2967 private static void closure_czr(AbstractBURS_TreeNode p, int c) { 2968 if(BURS.DEBUG) trace(p, 3, c + 0, p.getCost(4) /* cz */); 2969 if (c < p.getCost(4) /* cz */) { 2970 p.setCost(4 /* cz */, (char)(c)); 2971 p.writePacked(0, 0xFF9FFFFF, 0x200000); // p.cz = 1 2972 } 2973 if(BURS.DEBUG) trace(p, 2, c + 0, p.getCost(2) /* r */); 2974 if (c < p.getCost(2) /* r */) { 2975 p.setCost(2 /* r */, (char)(c)); 2976 p.writePacked(0, 0xFFFE00FF, 0x200); // p.r = 2 2977 closure_r(p, c); 2978 } 2979 } 2980 2981 /** 2982 * Create closure for szpr 2983 * @param p the node 2984 * @param c the cost 2985 */ 2986 @Inline 2987 private static void closure_szpr(AbstractBURS_TreeNode p, int c) { 2988 if(BURS.DEBUG) trace(p, 5, c + 0, p.getCost(6) /* szp */); 2989 if (c < p.getCost(6) /* szp */) { 2990 p.setCost(6 /* szp */, (char)(c)); 2991 p.writePacked(1, 0xFFFFFFF0, 0x1); // p.szp = 1 2992 } 2993 if(BURS.DEBUG) trace(p, 4, c + 0, p.getCost(2) /* r */); 2994 if (c < p.getCost(2) /* r */) { 2995 p.setCost(2 /* r */, (char)(c)); 2996 p.writePacked(0, 0xFFFE00FF, 0x300); // p.r = 3 2997 closure_r(p, c); 2998 } 2999 } 3000 3001 /** 3002 * Create closure for riv 3003 * @param p the node 3004 * @param c the cost 3005 */ 3006 @Inline 3007 private static void closure_riv(AbstractBURS_TreeNode p, int c) { 3008 if(BURS.DEBUG) trace(p, 8, c + 0, p.getCost(9) /* any */); 3009 if (c < p.getCost(9) /* any */) { 3010 p.setCost(9 /* any */, (char)(c)); 3011 p.writePacked(1, 0xFFFFF8FF, 0x200); // p.any = 2 3012 } 3013 } 3014 3015 /** 3016 * Create closure for load32 3017 * @param p the node 3018 * @param c the cost 3019 */ 3020 @Inline 3021 private static void closure_load32(AbstractBURS_TreeNode p, int c) { 3022 if(BURS.DEBUG) trace(p, 16, c + 0, p.getCost(13) /* load16_32 */); 3023 if (c < p.getCost(13) /* load16_32 */) { 3024 p.setCost(13 /* load16_32 */, (char)(c)); 3025 p.writePacked(1, 0xFFE7FFFF, 0x100000); // p.load16_32 = 2 3026 closure_load16_32(p, c); 3027 } 3028 } 3029 3030 /** 3031 * Create closure for uload8 3032 * @param p the node 3033 * @param c the cost 3034 */ 3035 @Inline 3036 private static void closure_uload8(AbstractBURS_TreeNode p, int c) { 3037 if(BURS.DEBUG) trace(p, 12, c + 0, p.getCost(21) /* load8 */); 3038 if (c < p.getCost(21) /* load8 */) { 3039 p.setCost(21 /* load8 */, (char)(c)); 3040 p.writePacked(2, 0xFFFE7FFF, 0x18000); // p.load8 = 3 3041 closure_load8(p, c); 3042 } 3043 } 3044 3045 /** 3046 * Create closure for load8_16_32 3047 * @param p the node 3048 * @param c the cost 3049 */ 3050 @Inline 3051 private static void closure_load8_16_32(AbstractBURS_TreeNode p, int c) { 3052 if(BURS.DEBUG) trace(p, 20, c + 0, p.getCost(25) /* load8_16_32_64 */); 3053 if (c < p.getCost(25) /* load8_16_32_64 */) { 3054 p.setCost(25 /* load8_16_32_64 */, (char)(c)); 3055 p.writePacked(2, 0xF9FFFFFF, 0x4000000); // p.load8_16_32_64 = 2 3056 } 3057 } 3058 3059 /** 3060 * Create closure for load16_32 3061 * @param p the node 3062 * @param c the cost 3063 */ 3064 @Inline 3065 private static void closure_load16_32(AbstractBURS_TreeNode p, int c) { 3066 if(BURS.DEBUG) trace(p, 17, c + 0, p.getCost(12) /* load8_16_32 */); 3067 if (c < p.getCost(12) /* load8_16_32 */) { 3068 p.setCost(12 /* load8_16_32 */, (char)(c)); 3069 p.writePacked(1, 0xFFF9FFFF, 0x20000); // p.load8_16_32 = 1 3070 closure_load8_16_32(p, c); 3071 } 3072 } 3073 3074 /** 3075 * Create closure for load16 3076 * @param p the node 3077 * @param c the cost 3078 */ 3079 @Inline 3080 private static void closure_load16(AbstractBURS_TreeNode p, int c) { 3081 if(BURS.DEBUG) trace(p, 15, c + 0, p.getCost(13) /* load16_32 */); 3082 if (c < p.getCost(13) /* load16_32 */) { 3083 p.setCost(13 /* load16_32 */, (char)(c)); 3084 p.writePacked(1, 0xFFE7FFFF, 0x80000); // p.load16_32 = 1 3085 closure_load16_32(p, c); 3086 } 3087 } 3088 3089 /** 3090 * Create closure for address1scaledreg 3091 * @param p the node 3092 * @param c the cost 3093 */ 3094 @Inline 3095 private static void closure_address1scaledreg(AbstractBURS_TreeNode p, int c) { 3096 if(BURS.DEBUG) trace(p, 10, c + 0, p.getCost(17) /* address */); 3097 if (c < p.getCost(17) /* address */) { 3098 p.setCost(17 /* address */, (char)(c)); 3099 p.writePacked(2, 0xFFFFFFF0, 0x1); // p.address = 1 3100 } 3101 } 3102 3103 /** 3104 * Create closure for address1reg 3105 * @param p the node 3106 * @param c the cost 3107 */ 3108 @Inline 3109 private static void closure_address1reg(AbstractBURS_TreeNode p, int c) { 3110 if(BURS.DEBUG) trace(p, 9, c + 0, p.getCost(15) /* address1scaledreg */); 3111 if (c < p.getCost(15) /* address1scaledreg */) { 3112 p.setCost(15 /* address1scaledreg */, (char)(c)); 3113 p.writePacked(1, 0xFC7FFFFF, 0x800000); // p.address1scaledreg = 1 3114 closure_address1scaledreg(p, c); 3115 } 3116 } 3117 3118 /** 3119 * Create closure for load64 3120 * @param p the node 3121 * @param c the cost 3122 */ 3123 @Inline 3124 private static void closure_load64(AbstractBURS_TreeNode p, int c) { 3125 if(BURS.DEBUG) trace(p, 19, c + 0, p.getCost(25) /* load8_16_32_64 */); 3126 if (c < p.getCost(25) /* load8_16_32_64 */) { 3127 p.setCost(25 /* load8_16_32_64 */, (char)(c)); 3128 p.writePacked(2, 0xF9FFFFFF, 0x2000000); // p.load8_16_32_64 = 1 3129 } 3130 } 3131 3132 /** 3133 * Create closure for load8 3134 * @param p the node 3135 * @param c the cost 3136 */ 3137 @Inline 3138 private static void closure_load8(AbstractBURS_TreeNode p, int c) { 3139 if(BURS.DEBUG) trace(p, 18, c + 0, p.getCost(12) /* load8_16_32 */); 3140 if (c < p.getCost(12) /* load8_16_32 */) { 3141 p.setCost(12 /* load8_16_32 */, (char)(c)); 3142 p.writePacked(1, 0xFFF9FFFF, 0x40000); // p.load8_16_32 = 2 3143 closure_load8_16_32(p, c); 3144 } 3145 } 3146 3147 /** 3148 * Create closure for sload16 3149 * @param p the node 3150 * @param c the cost 3151 */ 3152 @Inline 3153 private static void closure_sload16(AbstractBURS_TreeNode p, int c) { 3154 if(BURS.DEBUG) trace(p, 13, c + 0, p.getCost(14) /* load16 */); 3155 if (c < p.getCost(14) /* load16 */) { 3156 p.setCost(14 /* load16 */, (char)(c)); 3157 p.writePacked(1, 0xFF9FFFFF, 0x400000); // p.load16 = 2 3158 closure_load16(p, c); 3159 } 3160 } 3161 3162 /** 3163 * Create closure for uload16 3164 * @param p the node 3165 * @param c the cost 3166 */ 3167 @Inline 3168 private static void closure_uload16(AbstractBURS_TreeNode p, int c) { 3169 if(BURS.DEBUG) trace(p, 14, c + 0, p.getCost(14) /* load16 */); 3170 if (c < p.getCost(14) /* load16 */) { 3171 p.setCost(14 /* load16 */, (char)(c)); 3172 p.writePacked(1, 0xFF9FFFFF, 0x600000); // p.load16 = 3 3173 closure_load16(p, c); 3174 } 3175 } 3176 3177 /** 3178 * Create closure for sload8 3179 * @param p the node 3180 * @param c the cost 3181 */ 3182 @Inline 3183 private static void closure_sload8(AbstractBURS_TreeNode p, int c) { 3184 if(BURS.DEBUG) trace(p, 11, c + 0, p.getCost(21) /* load8 */); 3185 if (c < p.getCost(21) /* load8 */) { 3186 p.setCost(21 /* load8 */, (char)(c)); 3187 p.writePacked(2, 0xFFFE7FFF, 0x10000); // p.load8 = 2 3188 closure_load8(p, c); 3189 } 3190 } 3191 3192 /** 3193 /** Recursively labels the tree/ 3194 * @param p node to label 3195 */ 3196 public static void label(AbstractBURS_TreeNode p) { 3197 switch (p.getOpcode()) { 3198 case GET_CAUGHT_EXCEPTION_opcode: 3199 label_GET_CAUGHT_EXCEPTION(p); 3200 break; 3201 case SET_CAUGHT_EXCEPTION_opcode: 3202 label_SET_CAUGHT_EXCEPTION(p); 3203 break; 3204 case IG_PATCH_POINT_opcode: 3205 label_IG_PATCH_POINT(p); 3206 break; 3207 case INT_ALOAD_opcode: 3208 label_INT_ALOAD(p); 3209 break; 3210 case LONG_ALOAD_opcode: 3211 label_LONG_ALOAD(p); 3212 break; 3213 case FLOAT_ALOAD_opcode: 3214 label_FLOAT_ALOAD(p); 3215 break; 3216 case DOUBLE_ALOAD_opcode: 3217 label_DOUBLE_ALOAD(p); 3218 break; 3219 case UBYTE_ALOAD_opcode: 3220 label_UBYTE_ALOAD(p); 3221 break; 3222 case BYTE_ALOAD_opcode: 3223 label_BYTE_ALOAD(p); 3224 break; 3225 case USHORT_ALOAD_opcode: 3226 label_USHORT_ALOAD(p); 3227 break; 3228 case SHORT_ALOAD_opcode: 3229 label_SHORT_ALOAD(p); 3230 break; 3231 case INT_ASTORE_opcode: 3232 label_INT_ASTORE(p); 3233 break; 3234 case LONG_ASTORE_opcode: 3235 label_LONG_ASTORE(p); 3236 break; 3237 case FLOAT_ASTORE_opcode: 3238 label_FLOAT_ASTORE(p); 3239 break; 3240 case DOUBLE_ASTORE_opcode: 3241 label_DOUBLE_ASTORE(p); 3242 break; 3243 case BYTE_ASTORE_opcode: 3244 label_BYTE_ASTORE(p); 3245 break; 3246 case SHORT_ASTORE_opcode: 3247 label_SHORT_ASTORE(p); 3248 break; 3249 case INT_IFCMP_opcode: 3250 label_INT_IFCMP(p); 3251 break; 3252 case INT_IFCMP2_opcode: 3253 label_INT_IFCMP2(p); 3254 break; 3255 case LONG_IFCMP_opcode: 3256 label_LONG_IFCMP(p); 3257 break; 3258 case FLOAT_IFCMP_opcode: 3259 label_FLOAT_IFCMP(p); 3260 break; 3261 case DOUBLE_IFCMP_opcode: 3262 label_DOUBLE_IFCMP(p); 3263 break; 3264 case UNINT_BEGIN_opcode: 3265 label_UNINT_BEGIN(p); 3266 break; 3267 case UNINT_END_opcode: 3268 label_UNINT_END(p); 3269 break; 3270 case FENCE_opcode: 3271 label_FENCE(p); 3272 break; 3273 case READ_CEILING_opcode: 3274 label_READ_CEILING(p); 3275 break; 3276 case WRITE_FLOOR_opcode: 3277 label_WRITE_FLOOR(p); 3278 break; 3279 case NOP_opcode: 3280 label_NOP(p); 3281 break; 3282 case INT_MOVE_opcode: 3283 label_INT_MOVE(p); 3284 break; 3285 case LONG_MOVE_opcode: 3286 label_LONG_MOVE(p); 3287 break; 3288 case FLOAT_MOVE_opcode: 3289 label_FLOAT_MOVE(p); 3290 break; 3291 case DOUBLE_MOVE_opcode: 3292 label_DOUBLE_MOVE(p); 3293 break; 3294 case GUARD_MOVE_opcode: 3295 label_GUARD_MOVE(p); 3296 break; 3297 case GUARD_COMBINE_opcode: 3298 label_GUARD_COMBINE(p); 3299 break; 3300 case INT_ADD_opcode: 3301 label_INT_ADD(p); 3302 break; 3303 case LONG_ADD_opcode: 3304 label_LONG_ADD(p); 3305 break; 3306 case FLOAT_ADD_opcode: 3307 label_FLOAT_ADD(p); 3308 break; 3309 case DOUBLE_ADD_opcode: 3310 label_DOUBLE_ADD(p); 3311 break; 3312 case INT_SUB_opcode: 3313 label_INT_SUB(p); 3314 break; 3315 case LONG_SUB_opcode: 3316 label_LONG_SUB(p); 3317 break; 3318 case FLOAT_SUB_opcode: 3319 label_FLOAT_SUB(p); 3320 break; 3321 case DOUBLE_SUB_opcode: 3322 label_DOUBLE_SUB(p); 3323 break; 3324 case INT_MUL_opcode: 3325 label_INT_MUL(p); 3326 break; 3327 case LONG_MUL_opcode: 3328 label_LONG_MUL(p); 3329 break; 3330 case FLOAT_MUL_opcode: 3331 label_FLOAT_MUL(p); 3332 break; 3333 case DOUBLE_MUL_opcode: 3334 label_DOUBLE_MUL(p); 3335 break; 3336 case INT_DIV_opcode: 3337 label_INT_DIV(p); 3338 break; 3339 case LONG_DIV_opcode: 3340 label_LONG_DIV(p); 3341 break; 3342 case FLOAT_DIV_opcode: 3343 label_FLOAT_DIV(p); 3344 break; 3345 case DOUBLE_DIV_opcode: 3346 label_DOUBLE_DIV(p); 3347 break; 3348 case INT_REM_opcode: 3349 label_INT_REM(p); 3350 break; 3351 case LONG_REM_opcode: 3352 label_LONG_REM(p); 3353 break; 3354 case FLOAT_REM_opcode: 3355 label_FLOAT_REM(p); 3356 break; 3357 case DOUBLE_REM_opcode: 3358 label_DOUBLE_REM(p); 3359 break; 3360 case INT_NEG_opcode: 3361 label_INT_NEG(p); 3362 break; 3363 case LONG_NEG_opcode: 3364 label_LONG_NEG(p); 3365 break; 3366 case FLOAT_NEG_opcode: 3367 label_FLOAT_NEG(p); 3368 break; 3369 case DOUBLE_NEG_opcode: 3370 label_DOUBLE_NEG(p); 3371 break; 3372 case FLOAT_SQRT_opcode: 3373 label_FLOAT_SQRT(p); 3374 break; 3375 case DOUBLE_SQRT_opcode: 3376 label_DOUBLE_SQRT(p); 3377 break; 3378 case INT_SHL_opcode: 3379 label_INT_SHL(p); 3380 break; 3381 case LONG_SHL_opcode: 3382 label_LONG_SHL(p); 3383 break; 3384 case INT_SHR_opcode: 3385 label_INT_SHR(p); 3386 break; 3387 case LONG_SHR_opcode: 3388 label_LONG_SHR(p); 3389 break; 3390 case INT_USHR_opcode: 3391 label_INT_USHR(p); 3392 break; 3393 case LONG_USHR_opcode: 3394 label_LONG_USHR(p); 3395 break; 3396 case INT_AND_opcode: 3397 label_INT_AND(p); 3398 break; 3399 case LONG_AND_opcode: 3400 label_LONG_AND(p); 3401 break; 3402 case INT_OR_opcode: 3403 label_INT_OR(p); 3404 break; 3405 case LONG_OR_opcode: 3406 label_LONG_OR(p); 3407 break; 3408 case INT_XOR_opcode: 3409 label_INT_XOR(p); 3410 break; 3411 case INT_NOT_opcode: 3412 label_INT_NOT(p); 3413 break; 3414 case LONG_NOT_opcode: 3415 label_LONG_NOT(p); 3416 break; 3417 case LONG_XOR_opcode: 3418 label_LONG_XOR(p); 3419 break; 3420 case INT_2ADDRZerExt_opcode: 3421 label_INT_2ADDRZerExt(p); 3422 break; 3423 case INT_2LONG_opcode: 3424 label_INT_2LONG(p); 3425 break; 3426 case INT_2FLOAT_opcode: 3427 label_INT_2FLOAT(p); 3428 break; 3429 case INT_2DOUBLE_opcode: 3430 label_INT_2DOUBLE(p); 3431 break; 3432 case LONG_2INT_opcode: 3433 label_LONG_2INT(p); 3434 break; 3435 case LONG_2FLOAT_opcode: 3436 label_LONG_2FLOAT(p); 3437 break; 3438 case LONG_2DOUBLE_opcode: 3439 label_LONG_2DOUBLE(p); 3440 break; 3441 case FLOAT_2INT_opcode: 3442 label_FLOAT_2INT(p); 3443 break; 3444 case FLOAT_2LONG_opcode: 3445 label_FLOAT_2LONG(p); 3446 break; 3447 case FLOAT_2DOUBLE_opcode: 3448 label_FLOAT_2DOUBLE(p); 3449 break; 3450 case DOUBLE_2INT_opcode: 3451 label_DOUBLE_2INT(p); 3452 break; 3453 case DOUBLE_2LONG_opcode: 3454 label_DOUBLE_2LONG(p); 3455 break; 3456 case DOUBLE_2FLOAT_opcode: 3457 label_DOUBLE_2FLOAT(p); 3458 break; 3459 case INT_2BYTE_opcode: 3460 label_INT_2BYTE(p); 3461 break; 3462 case INT_2USHORT_opcode: 3463 label_INT_2USHORT(p); 3464 break; 3465 case INT_2SHORT_opcode: 3466 label_INT_2SHORT(p); 3467 break; 3468 case LONG_CMP_opcode: 3469 label_LONG_CMP(p); 3470 break; 3471 case RETURN_opcode: 3472 label_RETURN(p); 3473 break; 3474 case NULL_CHECK_opcode: 3475 label_NULL_CHECK(p); 3476 break; 3477 case GOTO_opcode: 3478 label_GOTO(p); 3479 break; 3480 case BOOLEAN_NOT_opcode: 3481 label_BOOLEAN_NOT(p); 3482 break; 3483 case BOOLEAN_CMP_INT_opcode: 3484 label_BOOLEAN_CMP_INT(p); 3485 break; 3486 case BOOLEAN_CMP_LONG_opcode: 3487 label_BOOLEAN_CMP_LONG(p); 3488 break; 3489 case BYTE_LOAD_opcode: 3490 label_BYTE_LOAD(p); 3491 break; 3492 case UBYTE_LOAD_opcode: 3493 label_UBYTE_LOAD(p); 3494 break; 3495 case SHORT_LOAD_opcode: 3496 label_SHORT_LOAD(p); 3497 break; 3498 case USHORT_LOAD_opcode: 3499 label_USHORT_LOAD(p); 3500 break; 3501 case INT_LOAD_opcode: 3502 label_INT_LOAD(p); 3503 break; 3504 case LONG_LOAD_opcode: 3505 label_LONG_LOAD(p); 3506 break; 3507 case FLOAT_LOAD_opcode: 3508 label_FLOAT_LOAD(p); 3509 break; 3510 case DOUBLE_LOAD_opcode: 3511 label_DOUBLE_LOAD(p); 3512 break; 3513 case BYTE_STORE_opcode: 3514 label_BYTE_STORE(p); 3515 break; 3516 case SHORT_STORE_opcode: 3517 label_SHORT_STORE(p); 3518 break; 3519 case INT_STORE_opcode: 3520 label_INT_STORE(p); 3521 break; 3522 case LONG_STORE_opcode: 3523 label_LONG_STORE(p); 3524 break; 3525 case FLOAT_STORE_opcode: 3526 label_FLOAT_STORE(p); 3527 break; 3528 case DOUBLE_STORE_opcode: 3529 label_DOUBLE_STORE(p); 3530 break; 3531 case ATTEMPT_INT_opcode: 3532 label_ATTEMPT_INT(p); 3533 break; 3534 case ATTEMPT_LONG_opcode: 3535 label_ATTEMPT_LONG(p); 3536 break; 3537 case CALL_opcode: 3538 label_CALL(p); 3539 break; 3540 case SYSCALL_opcode: 3541 label_SYSCALL(p); 3542 break; 3543 case YIELDPOINT_PROLOGUE_opcode: 3544 label_YIELDPOINT_PROLOGUE(p); 3545 break; 3546 case YIELDPOINT_EPILOGUE_opcode: 3547 label_YIELDPOINT_EPILOGUE(p); 3548 break; 3549 case YIELDPOINT_BACKEDGE_opcode: 3550 label_YIELDPOINT_BACKEDGE(p); 3551 break; 3552 case YIELDPOINT_OSR_opcode: 3553 label_YIELDPOINT_OSR(p); 3554 break; 3555 case IR_PROLOGUE_opcode: 3556 label_IR_PROLOGUE(p); 3557 break; 3558 case RESOLVE_opcode: 3559 label_RESOLVE(p); 3560 break; 3561 case GET_TIME_BASE_opcode: 3562 label_GET_TIME_BASE(p); 3563 break; 3564 case TRAP_IF_opcode: 3565 label_TRAP_IF(p); 3566 break; 3567 case TRAP_opcode: 3568 label_TRAP(p); 3569 break; 3570 case FLOAT_AS_INT_BITS_opcode: 3571 label_FLOAT_AS_INT_BITS(p); 3572 break; 3573 case INT_BITS_AS_FLOAT_opcode: 3574 label_INT_BITS_AS_FLOAT(p); 3575 break; 3576 case DOUBLE_AS_LONG_BITS_opcode: 3577 label_DOUBLE_AS_LONG_BITS(p); 3578 break; 3579 case LONG_BITS_AS_DOUBLE_opcode: 3580 label_LONG_BITS_AS_DOUBLE(p); 3581 break; 3582 case LOWTABLESWITCH_opcode: 3583 label_LOWTABLESWITCH(p); 3584 break; 3585 case ADDRESS_CONSTANT_opcode: 3586 label_ADDRESS_CONSTANT(p); 3587 break; 3588 case INT_CONSTANT_opcode: 3589 label_INT_CONSTANT(p); 3590 break; 3591 case LONG_CONSTANT_opcode: 3592 label_LONG_CONSTANT(p); 3593 break; 3594 case REGISTER_opcode: 3595 label_REGISTER(p); 3596 break; 3597 case OTHER_OPERAND_opcode: 3598 label_OTHER_OPERAND(p); 3599 break; 3600 case NULL_opcode: 3601 label_NULL(p); 3602 break; 3603 case BRANCH_TARGET_opcode: 3604 label_BRANCH_TARGET(p); 3605 break; 3606 case MATERIALIZE_FP_CONSTANT_opcode: 3607 label_MATERIALIZE_FP_CONSTANT(p); 3608 break; 3609 case CLEAR_FLOATING_POINT_STATE_opcode: 3610 label_CLEAR_FLOATING_POINT_STATE(p); 3611 break; 3612 case PREFETCH_opcode: 3613 label_PREFETCH(p); 3614 break; 3615 case PAUSE_opcode: 3616 label_PAUSE(p); 3617 break; 3618 case CMP_CMOV_opcode: 3619 label_CMP_CMOV(p); 3620 break; 3621 case FCMP_CMOV_opcode: 3622 label_FCMP_CMOV(p); 3623 break; 3624 case LCMP_CMOV_opcode: 3625 label_LCMP_CMOV(p); 3626 break; 3627 case FCMP_FCMOV_opcode: 3628 label_FCMP_FCMOV(p); 3629 break; 3630 default: 3631 throw new OptimizingCompilerException("BURS","terminal not in grammar:", 3632 p.toString()); 3633 } 3634 } 3635 3636 /** 3637 * Labels GET_CAUGHT_EXCEPTION tree node 3638 * @param p node to label 3639 */ 3640 private static void label_GET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 3641 p.initCost(); 3642 // r: GET_CAUGHT_EXCEPTION 3643 if(BURS.DEBUG) trace(p, 38, 11 + 0, p.getCost(2) /* r */); 3644 if (11 < p.getCost(2) /* r */) { 3645 p.setCost(2 /* r */, (char)(11)); 3646 p.writePacked(0, 0xFFFE00FF, 0x600); // p.r = 6 3647 closure_r(p, 11); 3648 } 3649 } 3650 3651 /** 3652 * Labels SET_CAUGHT_EXCEPTION tree node 3653 * @param p node to label 3654 */ 3655 private static void label_SET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 3656 p.initCost(); 3657 AbstractBURS_TreeNode lchild; 3658 lchild = p.getChild1(); 3659 label(lchild); 3660 int c; 3661 // stm: SET_CAUGHT_EXCEPTION(r) 3662 c = STATE(lchild).getCost(2 /* r */) + 11; 3663 if(BURS.DEBUG) trace(p, 249, c + 0, p.getCost(1) /* stm */); 3664 if (c < p.getCost(1) /* stm */) { 3665 p.setCost(1 /* stm */, (char)(c)); 3666 p.writePacked(0, 0xFFFFFF00, 0xD); // p.stm = 13 3667 } 3668 if ( // stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 3669 lchild.getOpcode() == INT_CONSTANT_opcode 3670 ) { 3671 c = 20; 3672 if(BURS.DEBUG) trace(p, 39, c + 0, p.getCost(1) /* stm */); 3673 if (c < p.getCost(1) /* stm */) { 3674 p.setCost(1 /* stm */, (char)(c)); 3675 p.writePacked(0, 0xFFFFFF00, 0xE); // p.stm = 14 3676 } 3677 } 3678 } 3679 3680 /** 3681 * Labels IG_PATCH_POINT tree node 3682 * @param p node to label 3683 */ 3684 private static void label_IG_PATCH_POINT(AbstractBURS_TreeNode p) { 3685 p.initCost(); 3686 // stm: IG_PATCH_POINT 3687 if(BURS.DEBUG) trace(p, 27, 10 + 0, p.getCost(1) /* stm */); 3688 if (10 < p.getCost(1) /* stm */) { 3689 p.setCost(1 /* stm */, (char)(10)); 3690 p.writePacked(0, 0xFFFFFF00, 0x2); // p.stm = 2 3691 } 3692 } 3693 3694 /** 3695 * Labels INT_ALOAD tree node 3696 * @param p node to label 3697 */ 3698 private static void label_INT_ALOAD(AbstractBURS_TreeNode p) { 3699 p.initCost(); 3700 AbstractBURS_TreeNode lchild, rchild; 3701 lchild = p.getChild1(); 3702 rchild = p.getChild2(); 3703 label(lchild); 3704 label(rchild); 3705 int c; 3706 // r: INT_ALOAD(rlv,riv) 3707 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3708 if(BURS.DEBUG) trace(p, 106, c + 0, p.getCost(2) /* r */); 3709 if (c < p.getCost(2) /* r */) { 3710 p.setCost(2 /* r */, (char)(c)); 3711 p.writePacked(0, 0xFFFE00FF, 0x6100); // p.r = 97 3712 closure_r(p, c); 3713 } 3714 // load32: INT_ALOAD(rlv,riv) 3715 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3716 if(BURS.DEBUG) trace(p, 151, c + 0, p.getCost(10) /* load32 */); 3717 if (c < p.getCost(10) /* load32 */) { 3718 p.setCost(10 /* load32 */, (char)(c)); 3719 p.writePacked(1, 0xFFFFC7FF, 0x1800); // p.load32 = 3 3720 closure_load32(p, c); 3721 } 3722 } 3723 3724 /** 3725 * Labels LONG_ALOAD tree node 3726 * @param p node to label 3727 */ 3728 private static void label_LONG_ALOAD(AbstractBURS_TreeNode p) { 3729 p.initCost(); 3730 AbstractBURS_TreeNode lchild, rchild; 3731 lchild = p.getChild1(); 3732 rchild = p.getChild2(); 3733 label(lchild); 3734 label(rchild); 3735 int c; 3736 // load64: LONG_ALOAD(rlv,rlv) 3737 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 3738 if(BURS.DEBUG) trace(p, 153, c + 0, p.getCost(20) /* load64 */); 3739 if (c < p.getCost(20) /* load64 */) { 3740 p.setCost(20 /* load64 */, (char)(c)); 3741 p.writePacked(2, 0xFFFF8FFF, 0x2000); // p.load64 = 2 3742 closure_load64(p, c); 3743 } 3744 // load64: LONG_ALOAD(rlv,r) 3745 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 0; 3746 if(BURS.DEBUG) trace(p, 154, c + 0, p.getCost(20) /* load64 */); 3747 if (c < p.getCost(20) /* load64 */) { 3748 p.setCost(20 /* load64 */, (char)(c)); 3749 p.writePacked(2, 0xFFFF8FFF, 0x3000); // p.load64 = 3 3750 closure_load64(p, c); 3751 } 3752 // r: LONG_ALOAD(rlv,riv) 3753 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 30; 3754 if(BURS.DEBUG) trace(p, 179, c + 0, p.getCost(2) /* r */); 3755 if (c < p.getCost(2) /* r */) { 3756 p.setCost(2 /* r */, (char)(c)); 3757 p.writePacked(0, 0xFFFE00FF, 0x9C00); // p.r = 156 3758 closure_r(p, c); 3759 } 3760 // r: LONG_ALOAD(rlv,r) 3761 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 20; 3762 if(BURS.DEBUG) trace(p, 180, c + 0, p.getCost(2) /* r */); 3763 if (c < p.getCost(2) /* r */) { 3764 p.setCost(2 /* r */, (char)(c)); 3765 p.writePacked(0, 0xFFFE00FF, 0x9D00); // p.r = 157 3766 closure_r(p, c); 3767 } 3768 } 3769 3770 /** 3771 * Labels FLOAT_ALOAD tree node 3772 * @param p node to label 3773 */ 3774 private static void label_FLOAT_ALOAD(AbstractBURS_TreeNode p) { 3775 p.initCost(); 3776 AbstractBURS_TreeNode lchild, rchild; 3777 lchild = p.getChild1(); 3778 rchild = p.getChild2(); 3779 label(lchild); 3780 label(rchild); 3781 int c; 3782 // r: FLOAT_ALOAD(riv,riv) 3783 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3784 if(BURS.DEBUG) trace(p, 237, c + 0, p.getCost(2) /* r */); 3785 if (c < p.getCost(2) /* r */) { 3786 p.setCost(2 /* r */, (char)(c)); 3787 p.writePacked(0, 0xFFFE00FF, 0xD200); // p.r = 210 3788 closure_r(p, c); 3789 } 3790 // r: FLOAT_ALOAD(riv,r) 3791 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 10; 3792 if(BURS.DEBUG) trace(p, 238, c + 0, p.getCost(2) /* r */); 3793 if (c < p.getCost(2) /* r */) { 3794 p.setCost(2 /* r */, (char)(c)); 3795 p.writePacked(0, 0xFFFE00FF, 0xD300); // p.r = 211 3796 closure_r(p, c); 3797 } 3798 // r: FLOAT_ALOAD(rlv,rlv) 3799 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 3800 if(BURS.DEBUG) trace(p, 239, c + 0, p.getCost(2) /* r */); 3801 if (c < p.getCost(2) /* r */) { 3802 p.setCost(2 /* r */, (char)(c)); 3803 p.writePacked(0, 0xFFFE00FF, 0xD400); // p.r = 212 3804 closure_r(p, c); 3805 } 3806 // float_load: FLOAT_ALOAD(riv,riv) 3807 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3808 if(BURS.DEBUG) trace(p, 240, c + 0, p.getCost(26) /* float_load */); 3809 if (c < p.getCost(26) /* float_load */) { 3810 p.setCost(26 /* float_load */, (char)(c)); 3811 p.writePacked(2, 0xC7FFFFFF, 0x10000000); // p.float_load = 2 3812 } 3813 } 3814 3815 /** 3816 * Labels DOUBLE_ALOAD tree node 3817 * @param p node to label 3818 */ 3819 private static void label_DOUBLE_ALOAD(AbstractBURS_TreeNode p) { 3820 p.initCost(); 3821 AbstractBURS_TreeNode lchild, rchild; 3822 lchild = p.getChild1(); 3823 rchild = p.getChild2(); 3824 label(lchild); 3825 label(rchild); 3826 int c; 3827 // r: DOUBLE_ALOAD(riv,riv) 3828 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3829 if(BURS.DEBUG) trace(p, 229, c + 0, p.getCost(2) /* r */); 3830 if (c < p.getCost(2) /* r */) { 3831 p.setCost(2 /* r */, (char)(c)); 3832 p.writePacked(0, 0xFFFE00FF, 0xCD00); // p.r = 205 3833 closure_r(p, c); 3834 } 3835 // r: DOUBLE_ALOAD(riv,r) 3836 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 10; 3837 if(BURS.DEBUG) trace(p, 231, c + 0, p.getCost(2) /* r */); 3838 if (c < p.getCost(2) /* r */) { 3839 p.setCost(2 /* r */, (char)(c)); 3840 p.writePacked(0, 0xFFFE00FF, 0xCE00); // p.r = 206 3841 closure_r(p, c); 3842 } 3843 // r: DOUBLE_ALOAD(rlv,rlv) 3844 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 10; 3845 if(BURS.DEBUG) trace(p, 232, c + 0, p.getCost(2) /* r */); 3846 if (c < p.getCost(2) /* r */) { 3847 p.setCost(2 /* r */, (char)(c)); 3848 p.writePacked(0, 0xFFFE00FF, 0xCF00); // p.r = 207 3849 closure_r(p, c); 3850 } 3851 // double_load: DOUBLE_ALOAD(riv,riv) 3852 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3853 if(BURS.DEBUG) trace(p, 233, c + 0, p.getCost(27) /* double_load */); 3854 if (c < p.getCost(27) /* double_load */) { 3855 p.setCost(27 /* double_load */, (char)(c)); 3856 p.writePacked(3, 0xFFFFFFF8, 0x3); // p.double_load = 3 3857 } 3858 } 3859 3860 /** 3861 * Labels UBYTE_ALOAD tree node 3862 * @param p node to label 3863 */ 3864 private static void label_UBYTE_ALOAD(AbstractBURS_TreeNode p) { 3865 p.initCost(); 3866 AbstractBURS_TreeNode lchild, rchild; 3867 lchild = p.getChild1(); 3868 rchild = p.getChild2(); 3869 label(lchild); 3870 label(rchild); 3871 int c; 3872 // r: UBYTE_ALOAD(rlv,riv) 3873 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3874 if(BURS.DEBUG) trace(p, 137, c + 0, p.getCost(2) /* r */); 3875 if (c < p.getCost(2) /* r */) { 3876 p.setCost(2 /* r */, (char)(c)); 3877 p.writePacked(0, 0xFFFE00FF, 0x8200); // p.r = 130 3878 closure_r(p, c); 3879 } 3880 // r: UBYTE_ALOAD(rlv,r) 3881 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 10; 3882 if(BURS.DEBUG) trace(p, 138, c + 0, p.getCost(2) /* r */); 3883 if (c < p.getCost(2) /* r */) { 3884 p.setCost(2 /* r */, (char)(c)); 3885 p.writePacked(0, 0xFFFE00FF, 0x8300); // p.r = 131 3886 closure_r(p, c); 3887 } 3888 // uload8: UBYTE_ALOAD(rlv,riv) 3889 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3890 if(BURS.DEBUG) trace(p, 139, c + 0, p.getCost(11) /* uload8 */); 3891 if (c < p.getCost(11) /* uload8 */) { 3892 p.setCost(11 /* uload8 */, (char)(c)); 3893 p.writePacked(1, 0xFFFE3FFF, 0x10000); // p.uload8 = 4 3894 closure_uload8(p, c); 3895 } 3896 } 3897 3898 /** 3899 * Labels BYTE_ALOAD tree node 3900 * @param p node to label 3901 */ 3902 private static void label_BYTE_ALOAD(AbstractBURS_TreeNode p) { 3903 p.initCost(); 3904 AbstractBURS_TreeNode lchild, rchild; 3905 lchild = p.getChild1(); 3906 rchild = p.getChild2(); 3907 label(lchild); 3908 label(rchild); 3909 int c; 3910 // r: BYTE_ALOAD(rlv,riv) 3911 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 20; 3912 if(BURS.DEBUG) trace(p, 132, c + 0, p.getCost(2) /* r */); 3913 if (c < p.getCost(2) /* r */) { 3914 p.setCost(2 /* r */, (char)(c)); 3915 p.writePacked(0, 0xFFFE00FF, 0x7F00); // p.r = 127 3916 closure_r(p, c); 3917 } 3918 // r: BYTE_ALOAD(rlv,r) 3919 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 15; 3920 if(BURS.DEBUG) trace(p, 133, c + 0, p.getCost(2) /* r */); 3921 if (c < p.getCost(2) /* r */) { 3922 p.setCost(2 /* r */, (char)(c)); 3923 p.writePacked(0, 0xFFFE00FF, 0x8000); // p.r = 128 3924 closure_r(p, c); 3925 } 3926 // sload8: BYTE_ALOAD(rlv,riv) 3927 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3928 if(BURS.DEBUG) trace(p, 134, c + 0, p.getCost(24) /* sload8 */); 3929 if (c < p.getCost(24) /* sload8 */) { 3930 p.setCost(24 /* sload8 */, (char)(c)); 3931 p.writePacked(2, 0xFE7FFFFF, 0x1800000); // p.sload8 = 3 3932 closure_sload8(p, c); 3933 } 3934 } 3935 3936 /** 3937 * Labels USHORT_ALOAD tree node 3938 * @param p node to label 3939 */ 3940 private static void label_USHORT_ALOAD(AbstractBURS_TreeNode p) { 3941 p.initCost(); 3942 AbstractBURS_TreeNode lchild, rchild; 3943 lchild = p.getChild1(); 3944 rchild = p.getChild2(); 3945 label(lchild); 3946 label(rchild); 3947 int c; 3948 // r: USHORT_ALOAD(rlv,riv) 3949 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3950 if(BURS.DEBUG) trace(p, 147, c + 0, p.getCost(2) /* r */); 3951 if (c < p.getCost(2) /* r */) { 3952 p.setCost(2 /* r */, (char)(c)); 3953 p.writePacked(0, 0xFFFE00FF, 0x8800); // p.r = 136 3954 closure_r(p, c); 3955 } 3956 // r: USHORT_ALOAD(rlv,r) 3957 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 10; 3958 if(BURS.DEBUG) trace(p, 148, c + 0, p.getCost(2) /* r */); 3959 if (c < p.getCost(2) /* r */) { 3960 p.setCost(2 /* r */, (char)(c)); 3961 p.writePacked(0, 0xFFFE00FF, 0x8900); // p.r = 137 3962 closure_r(p, c); 3963 } 3964 // uload16: USHORT_ALOAD(rlv,riv) 3965 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3966 if(BURS.DEBUG) trace(p, 149, c + 0, p.getCost(23) /* uload16 */); 3967 if (c < p.getCost(23) /* uload16 */) { 3968 p.setCost(23 /* uload16 */, (char)(c)); 3969 p.writePacked(2, 0xFF8FFFFF, 0x400000); // p.uload16 = 4 3970 closure_uload16(p, c); 3971 } 3972 } 3973 3974 /** 3975 * Labels SHORT_ALOAD tree node 3976 * @param p node to label 3977 */ 3978 private static void label_SHORT_ALOAD(AbstractBURS_TreeNode p) { 3979 p.initCost(); 3980 AbstractBURS_TreeNode lchild, rchild; 3981 lchild = p.getChild1(); 3982 rchild = p.getChild2(); 3983 label(lchild); 3984 label(rchild); 3985 int c; 3986 // r: SHORT_ALOAD(rlv,riv) 3987 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 20; 3988 if(BURS.DEBUG) trace(p, 142, c + 0, p.getCost(2) /* r */); 3989 if (c < p.getCost(2) /* r */) { 3990 p.setCost(2 /* r */, (char)(c)); 3991 p.writePacked(0, 0xFFFE00FF, 0x8500); // p.r = 133 3992 closure_r(p, c); 3993 } 3994 // r: SHORT_ALOAD(rlv,r) 3995 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 15; 3996 if(BURS.DEBUG) trace(p, 143, c + 0, p.getCost(2) /* r */); 3997 if (c < p.getCost(2) /* r */) { 3998 p.setCost(2 /* r */, (char)(c)); 3999 p.writePacked(0, 0xFFFE00FF, 0x8600); // p.r = 134 4000 closure_r(p, c); 4001 } 4002 // sload16: SHORT_ALOAD(rlv,riv) 4003 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 0; 4004 if(BURS.DEBUG) trace(p, 144, c + 0, p.getCost(22) /* sload16 */); 4005 if (c < p.getCost(22) /* sload16 */) { 4006 p.setCost(22 /* sload16 */, (char)(c)); 4007 p.writePacked(2, 0xFFF1FFFF, 0x80000); // p.sload16 = 4 4008 closure_sload16(p, c); 4009 } 4010 } 4011 4012 /** 4013 * Labels INT_ASTORE tree node 4014 * @param p node to label 4015 */ 4016 private static void label_INT_ASTORE(AbstractBURS_TreeNode p) { 4017 p.initCost(); 4018 AbstractBURS_TreeNode lchild, rchild; 4019 lchild = p.getChild1(); 4020 rchild = p.getChild2(); 4021 label(lchild); 4022 label(rchild); 4023 int c; 4024 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 4025 rchild.getOpcode() == OTHER_OPERAND_opcode 4026 ) { 4027 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4028 if(BURS.DEBUG) trace(p, 404, c + 0, p.getCost(1) /* stm */); 4029 if (c < p.getCost(1) /* stm */) { 4030 p.setCost(1 /* stm */, (char)(c)); 4031 p.writePacked(0, 0xFFFFFF00, 0x1C); // p.stm = 28 4032 } 4033 } 4034 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 4035 rchild.getOpcode() == OTHER_OPERAND_opcode 4036 ) { 4037 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 4038 if(BURS.DEBUG) trace(p, 405, c + 0, p.getCost(1) /* stm */); 4039 if (c < p.getCost(1) /* stm */) { 4040 p.setCost(1 /* stm */, (char)(c)); 4041 p.writePacked(0, 0xFFFFFF00, 0x1D); // p.stm = 29 4042 } 4043 } 4044 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 4045 rchild.getOpcode() == OTHER_OPERAND_opcode 4046 ) { 4047 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 4048 if(BURS.DEBUG) trace(p, 406, c + 0, p.getCost(1) /* stm */); 4049 if (c < p.getCost(1) /* stm */) { 4050 p.setCost(1 /* stm */, (char)(c)); 4051 p.writePacked(0, 0xFFFFFF00, 0x1E); // p.stm = 30 4052 } 4053 } 4054 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 4055 rchild.getOpcode() == OTHER_OPERAND_opcode 4056 ) { 4057 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4058 if(BURS.DEBUG) trace(p, 407, c + 0, p.getCost(1) /* stm */); 4059 if (c < p.getCost(1) /* stm */) { 4060 p.setCost(1 /* stm */, (char)(c)); 4061 p.writePacked(0, 0xFFFFFF00, 0x1F); // p.stm = 31 4062 } 4063 } 4064 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 4065 rchild.getOpcode() == OTHER_OPERAND_opcode 4066 ) { 4067 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 4068 if(BURS.DEBUG) trace(p, 408, c + 0, p.getCost(1) /* stm */); 4069 if (c < p.getCost(1) /* stm */) { 4070 p.setCost(1 /* stm */, (char)(c)); 4071 p.writePacked(0, 0xFFFFFF00, 0x20); // p.stm = 32 4072 } 4073 } 4074 if ( // stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 4075 lchild.getOpcode() == INT_ADD_opcode && 4076 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4077 rchild.getOpcode() == OTHER_OPERAND_opcode 4078 ) { 4079 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4080 if(BURS.DEBUG) trace(p, 570, c + 0, p.getCost(1) /* stm */); 4081 if (c < p.getCost(1) /* stm */) { 4082 p.setCost(1 /* stm */, (char)(c)); 4083 p.writePacked(0, 0xFFFFFF00, 0x5D); // p.stm = 93 4084 } 4085 } 4086 if ( // stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4087 lchild.getOpcode() == INT_ADD_opcode && 4088 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 4089 rchild.getOpcode() == OTHER_OPERAND_opcode 4090 ) { 4091 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4092 if(BURS.DEBUG) trace(p, 590, c + 0, p.getCost(1) /* stm */); 4093 if (c < p.getCost(1) /* stm */) { 4094 p.setCost(1 /* stm */, (char)(c)); 4095 p.writePacked(0, 0xFFFFFF00, 0x5E); // p.stm = 94 4096 } 4097 } 4098 if ( // stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 4099 lchild.getOpcode() == INT_AND_opcode && 4100 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4101 rchild.getOpcode() == OTHER_OPERAND_opcode 4102 ) { 4103 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4104 if(BURS.DEBUG) trace(p, 572, c + 0, p.getCost(1) /* stm */); 4105 if (c < p.getCost(1) /* stm */) { 4106 p.setCost(1 /* stm */, (char)(c)); 4107 p.writePacked(0, 0xFFFFFF00, 0x61); // p.stm = 97 4108 } 4109 } 4110 if ( // stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4111 lchild.getOpcode() == INT_AND_opcode && 4112 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 4113 rchild.getOpcode() == OTHER_OPERAND_opcode 4114 ) { 4115 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4116 if(BURS.DEBUG) trace(p, 592, c + 0, p.getCost(1) /* stm */); 4117 if (c < p.getCost(1) /* stm */) { 4118 p.setCost(1 /* stm */, (char)(c)); 4119 p.writePacked(0, 0xFFFFFF00, 0x62); // p.stm = 98 4120 } 4121 } 4122 if ( // stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4123 lchild.getOpcode() == INT_NEG_opcode && 4124 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4125 rchild.getOpcode() == OTHER_OPERAND_opcode 4126 ) { 4127 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4128 if(BURS.DEBUG) trace(p, 533, c + 0, p.getCost(1) /* stm */); 4129 if (c < p.getCost(1) /* stm */) { 4130 p.setCost(1 /* stm */, (char)(c)); 4131 p.writePacked(0, 0xFFFFFF00, 0x74); // p.stm = 116 4132 } 4133 } 4134 if ( // stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4135 lchild.getOpcode() == INT_NOT_opcode && 4136 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4137 rchild.getOpcode() == OTHER_OPERAND_opcode 4138 ) { 4139 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4140 if(BURS.DEBUG) trace(p, 535, c + 0, p.getCost(1) /* stm */); 4141 if (c < p.getCost(1) /* stm */) { 4142 p.setCost(1 /* stm */, (char)(c)); 4143 p.writePacked(0, 0xFFFFFF00, 0x76); // p.stm = 118 4144 } 4145 } 4146 if ( // stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 4147 lchild.getOpcode() == INT_OR_opcode && 4148 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4149 rchild.getOpcode() == OTHER_OPERAND_opcode 4150 ) { 4151 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4152 if(BURS.DEBUG) trace(p, 574, c + 0, p.getCost(1) /* stm */); 4153 if (c < p.getCost(1) /* stm */) { 4154 p.setCost(1 /* stm */, (char)(c)); 4155 p.writePacked(0, 0xFFFFFF00, 0x79); // p.stm = 121 4156 } 4157 } 4158 if ( // stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4159 lchild.getOpcode() == INT_OR_opcode && 4160 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 4161 rchild.getOpcode() == OTHER_OPERAND_opcode 4162 ) { 4163 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4164 if(BURS.DEBUG) trace(p, 594, c + 0, p.getCost(1) /* stm */); 4165 if (c < p.getCost(1) /* stm */) { 4166 p.setCost(1 /* stm */, (char)(c)); 4167 p.writePacked(0, 0xFFFFFF00, 0x7A); // p.stm = 122 4168 } 4169 } 4170 if ( // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 4171 lchild.getOpcode() == INT_SHL_opcode && 4172 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4173 lchild.getChild2().getOpcode() == INT_AND_opcode && 4174 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 4175 rchild.getOpcode() == OTHER_OPERAND_opcode 4176 ) { 4177 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 4178 if(BURS.DEBUG) trace(p, 626, c + 0, p.getCost(1) /* stm */); 4179 if (c < p.getCost(1) /* stm */) { 4180 p.setCost(1 /* stm */, (char)(c)); 4181 p.writePacked(0, 0xFFFFFF00, 0x7D); // p.stm = 125 4182 } 4183 } 4184 if ( // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 4185 lchild.getOpcode() == INT_SHL_opcode && 4186 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4187 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4188 rchild.getOpcode() == OTHER_OPERAND_opcode 4189 ) { 4190 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 31 ? 17 : INFINITE)); 4191 if(BURS.DEBUG) trace(p, 537, c + 0, p.getCost(1) /* stm */); 4192 if (c < p.getCost(1) /* stm */) { 4193 p.setCost(1 /* stm */, (char)(c)); 4194 p.writePacked(0, 0xFFFFFF00, 0x7E); // p.stm = 126 4195 } 4196 } 4197 if ( // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 4198 lchild.getOpcode() == INT_SHR_opcode && 4199 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4200 lchild.getChild2().getOpcode() == INT_AND_opcode && 4201 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 4202 rchild.getOpcode() == OTHER_OPERAND_opcode 4203 ) { 4204 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 4205 if(BURS.DEBUG) trace(p, 628, c + 0, p.getCost(1) /* stm */); 4206 if (c < p.getCost(1) /* stm */) { 4207 p.setCost(1 /* stm */, (char)(c)); 4208 p.writePacked(0, 0xFFFFFF00, 0x81); // p.stm = 129 4209 } 4210 } 4211 if ( // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 4212 lchild.getOpcode() == INT_SHR_opcode && 4213 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4214 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4215 rchild.getOpcode() == OTHER_OPERAND_opcode 4216 ) { 4217 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 31 ? 17 : INFINITE)); 4218 if(BURS.DEBUG) trace(p, 539, c + 0, p.getCost(1) /* stm */); 4219 if (c < p.getCost(1) /* stm */) { 4220 p.setCost(1 /* stm */, (char)(c)); 4221 p.writePacked(0, 0xFFFFFF00, 0x82); // p.stm = 130 4222 } 4223 } 4224 if ( // stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 4225 lchild.getOpcode() == INT_SUB_opcode && 4226 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4227 rchild.getOpcode() == OTHER_OPERAND_opcode 4228 ) { 4229 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4230 if(BURS.DEBUG) trace(p, 576, c + 0, p.getCost(1) /* stm */); 4231 if (c < p.getCost(1) /* stm */) { 4232 p.setCost(1 /* stm */, (char)(c)); 4233 p.writePacked(0, 0xFFFFFF00, 0x8B); // p.stm = 139 4234 } 4235 } 4236 if ( // stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4237 lchild.getOpcode() == INT_SUB_opcode && 4238 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 4239 rchild.getOpcode() == OTHER_OPERAND_opcode 4240 ) { 4241 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 27); 4242 if(BURS.DEBUG) trace(p, 596, c + 0, p.getCost(1) /* stm */); 4243 if (c < p.getCost(1) /* stm */) { 4244 p.setCost(1 /* stm */, (char)(c)); 4245 p.writePacked(0, 0xFFFFFF00, 0x8C); // p.stm = 140 4246 } 4247 } 4248 if ( // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 4249 lchild.getOpcode() == INT_USHR_opcode && 4250 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4251 lchild.getChild2().getOpcode() == INT_AND_opcode && 4252 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 4253 rchild.getOpcode() == OTHER_OPERAND_opcode 4254 ) { 4255 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 4256 if(BURS.DEBUG) trace(p, 630, c + 0, p.getCost(1) /* stm */); 4257 if (c < p.getCost(1) /* stm */) { 4258 p.setCost(1 /* stm */, (char)(c)); 4259 p.writePacked(0, 0xFFFFFF00, 0x8F); // p.stm = 143 4260 } 4261 } 4262 if ( // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 4263 lchild.getOpcode() == INT_USHR_opcode && 4264 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4265 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4266 rchild.getOpcode() == OTHER_OPERAND_opcode 4267 ) { 4268 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 31 ? 17 : INFINITE)); 4269 if(BURS.DEBUG) trace(p, 541, c + 0, p.getCost(1) /* stm */); 4270 if (c < p.getCost(1) /* stm */) { 4271 p.setCost(1 /* stm */, (char)(c)); 4272 p.writePacked(0, 0xFFFFFF00, 0x90); // p.stm = 144 4273 } 4274 } 4275 if ( // stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 4276 lchild.getOpcode() == INT_XOR_opcode && 4277 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 4278 rchild.getOpcode() == OTHER_OPERAND_opcode 4279 ) { 4280 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4281 if(BURS.DEBUG) trace(p, 578, c + 0, p.getCost(1) /* stm */); 4282 if (c < p.getCost(1) /* stm */) { 4283 p.setCost(1 /* stm */, (char)(c)); 4284 p.writePacked(0, 0xFFFFFF00, 0x93); // p.stm = 147 4285 } 4286 } 4287 if ( // stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4288 lchild.getOpcode() == INT_XOR_opcode && 4289 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 4290 rchild.getOpcode() == OTHER_OPERAND_opcode 4291 ) { 4292 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4293 if(BURS.DEBUG) trace(p, 598, c + 0, p.getCost(1) /* stm */); 4294 if (c < p.getCost(1) /* stm */) { 4295 p.setCost(1 /* stm */, (char)(c)); 4296 p.writePacked(0, 0xFFFFFF00, 0x94); // p.stm = 148 4297 } 4298 } 4299 if ( // stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 4300 lchild.getOpcode() == LONG_2INT_opcode && 4301 rchild.getOpcode() == OTHER_OPERAND_opcode 4302 ) { 4303 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4304 if(BURS.DEBUG) trace(p, 568, c + 0, p.getCost(1) /* stm */); 4305 if (c < p.getCost(1) /* stm */) { 4306 p.setCost(1 /* stm */, (char)(c)); 4307 p.writePacked(0, 0xFFFFFF00, 0x96); // p.stm = 150 4308 } 4309 } 4310 } 4311 4312 /** 4313 * Labels LONG_ASTORE tree node 4314 * @param p node to label 4315 */ 4316 private static void label_LONG_ASTORE(AbstractBURS_TreeNode p) { 4317 p.initCost(); 4318 AbstractBURS_TreeNode lchild, rchild; 4319 lchild = p.getChild1(); 4320 rchild = p.getChild2(); 4321 label(lchild); 4322 label(rchild); 4323 int c; 4324 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 4325 rchild.getOpcode() == OTHER_OPERAND_opcode 4326 ) { 4327 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 30; 4328 if(BURS.DEBUG) trace(p, 409, c + 0, p.getCost(1) /* stm */); 4329 if (c < p.getCost(1) /* stm */) { 4330 p.setCost(1 /* stm */, (char)(c)); 4331 p.writePacked(0, 0xFFFFFF00, 0x21); // p.stm = 33 4332 } 4333 } 4334 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 4335 rchild.getOpcode() == OTHER_OPERAND_opcode 4336 ) { 4337 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 4338 if(BURS.DEBUG) trace(p, 410, c + 0, p.getCost(1) /* stm */); 4339 if (c < p.getCost(1) /* stm */) { 4340 p.setCost(1 /* stm */, (char)(c)); 4341 p.writePacked(0, 0xFFFFFF00, 0x22); // p.stm = 34 4342 } 4343 } 4344 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 4345 rchild.getOpcode() == OTHER_OPERAND_opcode 4346 ) { 4347 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 4348 if(BURS.DEBUG) trace(p, 411, c + 0, p.getCost(1) /* stm */); 4349 if (c < p.getCost(1) /* stm */) { 4350 p.setCost(1 /* stm */, (char)(c)); 4351 p.writePacked(0, 0xFFFFFF00, 0x23); // p.stm = 35 4352 } 4353 } 4354 if ( // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 4355 lchild.getOpcode() == LONG_CONSTANT_opcode && 4356 rchild.getOpcode() == OTHER_OPERAND_opcode 4357 ) { 4358 c = STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 26; 4359 if(BURS.DEBUG) trace(p, 466, c + 0, p.getCost(1) /* stm */); 4360 if (c < p.getCost(1) /* stm */) { 4361 p.setCost(1 /* stm */, (char)(c)); 4362 p.writePacked(0, 0xFFFFFF00, 0x24); // p.stm = 36 4363 } 4364 } 4365 if ( // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 4366 lchild.getOpcode() == LONG_CONSTANT_opcode && 4367 rchild.getOpcode() == OTHER_OPERAND_opcode 4368 ) { 4369 c = STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 26; 4370 if(BURS.DEBUG) trace(p, 467, c + 0, p.getCost(1) /* stm */); 4371 if (c < p.getCost(1) /* stm */) { 4372 p.setCost(1 /* stm */, (char)(c)); 4373 p.writePacked(0, 0xFFFFFF00, 0x25); // p.stm = 37 4374 } 4375 } 4376 if ( // stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4377 lchild.getOpcode() == LONG_ADD_opcode && 4378 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4379 rchild.getOpcode() == OTHER_OPERAND_opcode 4380 ) { 4381 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4382 if(BURS.DEBUG) trace(p, 580, c + 0, p.getCost(1) /* stm */); 4383 if (c < p.getCost(1) /* stm */) { 4384 p.setCost(1 /* stm */, (char)(c)); 4385 p.writePacked(0, 0xFFFFFF00, 0x99); // p.stm = 153 4386 } 4387 } 4388 if ( // stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4389 lchild.getOpcode() == LONG_ADD_opcode && 4390 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4391 rchild.getOpcode() == OTHER_OPERAND_opcode 4392 ) { 4393 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4394 if(BURS.DEBUG) trace(p, 600, c + 0, p.getCost(1) /* stm */); 4395 if (c < p.getCost(1) /* stm */) { 4396 p.setCost(1 /* stm */, (char)(c)); 4397 p.writePacked(0, 0xFFFFFF00, 0x9A); // p.stm = 154 4398 } 4399 } 4400 if ( // stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4401 lchild.getOpcode() == LONG_AND_opcode && 4402 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4403 rchild.getOpcode() == OTHER_OPERAND_opcode 4404 ) { 4405 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4406 if(BURS.DEBUG) trace(p, 582, c + 0, p.getCost(1) /* stm */); 4407 if (c < p.getCost(1) /* stm */) { 4408 p.setCost(1 /* stm */, (char)(c)); 4409 p.writePacked(0, 0xFFFFFF00, 0x9D); // p.stm = 157 4410 } 4411 } 4412 if ( // stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4413 lchild.getOpcode() == LONG_AND_opcode && 4414 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4415 rchild.getOpcode() == OTHER_OPERAND_opcode 4416 ) { 4417 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4418 if(BURS.DEBUG) trace(p, 602, c + 0, p.getCost(1) /* stm */); 4419 if (c < p.getCost(1) /* stm */) { 4420 p.setCost(1 /* stm */, (char)(c)); 4421 p.writePacked(0, 0xFFFFFF00, 0x9E); // p.stm = 158 4422 } 4423 } 4424 if ( // stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4425 lchild.getOpcode() == LONG_NEG_opcode && 4426 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4427 rchild.getOpcode() == OTHER_OPERAND_opcode 4428 ) { 4429 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4430 if(BURS.DEBUG) trace(p, 543, c + 0, p.getCost(1) /* stm */); 4431 if (c < p.getCost(1) /* stm */) { 4432 p.setCost(1 /* stm */, (char)(c)); 4433 p.writePacked(0, 0xFFFFFF00, 0xA2); // p.stm = 162 4434 } 4435 } 4436 if ( // stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4437 lchild.getOpcode() == LONG_NOT_opcode && 4438 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4439 rchild.getOpcode() == OTHER_OPERAND_opcode 4440 ) { 4441 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4442 if(BURS.DEBUG) trace(p, 545, c + 0, p.getCost(1) /* stm */); 4443 if (c < p.getCost(1) /* stm */) { 4444 p.setCost(1 /* stm */, (char)(c)); 4445 p.writePacked(0, 0xFFFFFF00, 0xA4); // p.stm = 164 4446 } 4447 } 4448 if ( // stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4449 lchild.getOpcode() == LONG_OR_opcode && 4450 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4451 rchild.getOpcode() == OTHER_OPERAND_opcode 4452 ) { 4453 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4454 if(BURS.DEBUG) trace(p, 584, c + 0, p.getCost(1) /* stm */); 4455 if (c < p.getCost(1) /* stm */) { 4456 p.setCost(1 /* stm */, (char)(c)); 4457 p.writePacked(0, 0xFFFFFF00, 0xA7); // p.stm = 167 4458 } 4459 } 4460 if ( // stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4461 lchild.getOpcode() == LONG_OR_opcode && 4462 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4463 rchild.getOpcode() == OTHER_OPERAND_opcode 4464 ) { 4465 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4466 if(BURS.DEBUG) trace(p, 604, c + 0, p.getCost(1) /* stm */); 4467 if (c < p.getCost(1) /* stm */) { 4468 p.setCost(1 /* stm */, (char)(c)); 4469 p.writePacked(0, 0xFFFFFF00, 0xA8); // p.stm = 168 4470 } 4471 } 4472 if ( // stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 4473 lchild.getOpcode() == LONG_SHL_opcode && 4474 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4475 lchild.getChild2().getOpcode() == INT_AND_opcode && 4476 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 4477 rchild.getOpcode() == OTHER_OPERAND_opcode 4478 ) { 4479 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 4480 if(BURS.DEBUG) trace(p, 632, c + 0, p.getCost(1) /* stm */); 4481 if (c < p.getCost(1) /* stm */) { 4482 p.setCost(1 /* stm */, (char)(c)); 4483 p.writePacked(0, 0xFFFFFF00, 0xAB); // p.stm = 171 4484 } 4485 } 4486 if ( // stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 4487 lchild.getOpcode() == LONG_SHL_opcode && 4488 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4489 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4490 rchild.getOpcode() == OTHER_OPERAND_opcode 4491 ) { 4492 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 63 ? 17 : INFINITE)); 4493 if(BURS.DEBUG) trace(p, 547, c + 0, p.getCost(1) /* stm */); 4494 if (c < p.getCost(1) /* stm */) { 4495 p.setCost(1 /* stm */, (char)(c)); 4496 p.writePacked(0, 0xFFFFFF00, 0xAC); // p.stm = 172 4497 } 4498 } 4499 if ( // stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 4500 lchild.getOpcode() == LONG_SHR_opcode && 4501 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4502 lchild.getChild2().getOpcode() == INT_AND_opcode && 4503 lchild.getChild2().getChild2().getOpcode() == LONG_CONSTANT_opcode && 4504 rchild.getOpcode() == OTHER_OPERAND_opcode 4505 ) { 4506 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 4507 if(BURS.DEBUG) trace(p, 634, c + 0, p.getCost(1) /* stm */); 4508 if (c < p.getCost(1) /* stm */) { 4509 p.setCost(1 /* stm */, (char)(c)); 4510 p.writePacked(0, 0xFFFFFF00, 0xAF); // p.stm = 175 4511 } 4512 } 4513 if ( // stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 4514 lchild.getOpcode() == LONG_SHR_opcode && 4515 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4516 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 4517 rchild.getOpcode() == OTHER_OPERAND_opcode 4518 ) { 4519 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 63 ? 17 : INFINITE)); 4520 if(BURS.DEBUG) trace(p, 549, c + 0, p.getCost(1) /* stm */); 4521 if (c < p.getCost(1) /* stm */) { 4522 p.setCost(1 /* stm */, (char)(c)); 4523 p.writePacked(0, 0xFFFFFF00, 0xB0); // p.stm = 176 4524 } 4525 } 4526 if ( // stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4527 lchild.getOpcode() == LONG_SUB_opcode && 4528 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4529 rchild.getOpcode() == OTHER_OPERAND_opcode 4530 ) { 4531 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4532 if(BURS.DEBUG) trace(p, 586, c + 0, p.getCost(1) /* stm */); 4533 if (c < p.getCost(1) /* stm */) { 4534 p.setCost(1 /* stm */, (char)(c)); 4535 p.writePacked(0, 0xFFFFFF00, 0xB9); // p.stm = 185 4536 } 4537 } 4538 if ( // stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4539 lchild.getOpcode() == LONG_SUB_opcode && 4540 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4541 rchild.getOpcode() == OTHER_OPERAND_opcode 4542 ) { 4543 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 27); 4544 if(BURS.DEBUG) trace(p, 606, c + 0, p.getCost(1) /* stm */); 4545 if (c < p.getCost(1) /* stm */) { 4546 p.setCost(1 /* stm */, (char)(c)); 4547 p.writePacked(0, 0xFFFFFF00, 0xBA); // p.stm = 186 4548 } 4549 } 4550 if ( // stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 4551 lchild.getOpcode() == LONG_USHR_opcode && 4552 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4553 lchild.getChild2().getOpcode() == LONG_AND_opcode && 4554 lchild.getChild2().getChild2().getOpcode() == LONG_CONSTANT_opcode && 4555 rchild.getOpcode() == OTHER_OPERAND_opcode 4556 ) { 4557 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 4558 if(BURS.DEBUG) trace(p, 636, c + 0, p.getCost(1) /* stm */); 4559 if (c < p.getCost(1) /* stm */) { 4560 p.setCost(1 /* stm */, (char)(c)); 4561 p.writePacked(0, 0xFFFFFF00, 0xBD); // p.stm = 189 4562 } 4563 } 4564 if ( // stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 4565 lchild.getOpcode() == LONG_USHR_opcode && 4566 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4567 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 4568 rchild.getOpcode() == OTHER_OPERAND_opcode 4569 ) { 4570 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ARRAY_ADDRESS_EQUAL(P(p), PLL(p), VLR(p) == 63 ? 17 : INFINITE)); 4571 if(BURS.DEBUG) trace(p, 551, c + 0, p.getCost(1) /* stm */); 4572 if (c < p.getCost(1) /* stm */) { 4573 p.setCost(1 /* stm */, (char)(c)); 4574 p.writePacked(0, 0xFFFFFF00, 0xBE); // p.stm = 190 4575 } 4576 } 4577 if ( // stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4578 lchild.getOpcode() == LONG_XOR_opcode && 4579 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4580 rchild.getOpcode() == OTHER_OPERAND_opcode 4581 ) { 4582 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4583 if(BURS.DEBUG) trace(p, 588, c + 0, p.getCost(1) /* stm */); 4584 if (c < p.getCost(1) /* stm */) { 4585 p.setCost(1 /* stm */, (char)(c)); 4586 p.writePacked(0, 0xFFFFFF00, 0xC1); // p.stm = 193 4587 } 4588 } 4589 if ( // stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4590 lchild.getOpcode() == LONG_XOR_opcode && 4591 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4592 rchild.getOpcode() == OTHER_OPERAND_opcode 4593 ) { 4594 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ARRAY_ADDRESS_EQUAL(P(p), PLR(p), 17); 4595 if(BURS.DEBUG) trace(p, 608, c + 0, p.getCost(1) /* stm */); 4596 if (c < p.getCost(1) /* stm */) { 4597 p.setCost(1 /* stm */, (char)(c)); 4598 p.writePacked(0, 0xFFFFFF00, 0xC2); // p.stm = 194 4599 } 4600 } 4601 if ( // stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 4602 rchild.getOpcode() == OTHER_OPERAND_opcode 4603 ) { 4604 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 4605 if(BURS.DEBUG) trace(p, 462, c + 0, p.getCost(1) /* stm */); 4606 if (c < p.getCost(1) /* stm */) { 4607 p.setCost(1 /* stm */, (char)(c)); 4608 p.writePacked(0, 0xFFFFFF00, 0xDC); // p.stm = 220 4609 } 4610 } 4611 if ( // stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 4612 rchild.getOpcode() == OTHER_OPERAND_opcode 4613 ) { 4614 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 4615 if(BURS.DEBUG) trace(p, 463, c + 0, p.getCost(1) /* stm */); 4616 if (c < p.getCost(1) /* stm */) { 4617 p.setCost(1 /* stm */, (char)(c)); 4618 p.writePacked(0, 0xFFFFFF00, 0xDD); // p.stm = 221 4619 } 4620 } 4621 } 4622 4623 /** 4624 * Labels FLOAT_ASTORE tree node 4625 * @param p node to label 4626 */ 4627 private static void label_FLOAT_ASTORE(AbstractBURS_TreeNode p) { 4628 p.initCost(); 4629 AbstractBURS_TreeNode lchild, rchild; 4630 lchild = p.getChild1(); 4631 rchild = p.getChild2(); 4632 label(lchild); 4633 label(rchild); 4634 int c; 4635 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 4636 rchild.getOpcode() == OTHER_OPERAND_opcode 4637 ) { 4638 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4639 if(BURS.DEBUG) trace(p, 449, c + 0, p.getCost(1) /* stm */); 4640 if (c < p.getCost(1) /* stm */) { 4641 p.setCost(1 /* stm */, (char)(c)); 4642 p.writePacked(0, 0xFFFFFF00, 0xD0); // p.stm = 208 4643 } 4644 } 4645 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 4646 rchild.getOpcode() == OTHER_OPERAND_opcode 4647 ) { 4648 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4649 if(BURS.DEBUG) trace(p, 450, c + 0, p.getCost(1) /* stm */); 4650 if (c < p.getCost(1) /* stm */) { 4651 p.setCost(1 /* stm */, (char)(c)); 4652 p.writePacked(0, 0xFFFFFF00, 0xD1); // p.stm = 209 4653 } 4654 } 4655 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 4656 rchild.getOpcode() == OTHER_OPERAND_opcode 4657 ) { 4658 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4659 if(BURS.DEBUG) trace(p, 451, c + 0, p.getCost(1) /* stm */); 4660 if (c < p.getCost(1) /* stm */) { 4661 p.setCost(1 /* stm */, (char)(c)); 4662 p.writePacked(0, 0xFFFFFF00, 0xD2); // p.stm = 210 4663 } 4664 } 4665 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 4666 rchild.getOpcode() == OTHER_OPERAND_opcode 4667 ) { 4668 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4669 if(BURS.DEBUG) trace(p, 452, c + 0, p.getCost(1) /* stm */); 4670 if (c < p.getCost(1) /* stm */) { 4671 p.setCost(1 /* stm */, (char)(c)); 4672 p.writePacked(0, 0xFFFFFF00, 0xD3); // p.stm = 211 4673 } 4674 } 4675 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 4676 rchild.getOpcode() == OTHER_OPERAND_opcode 4677 ) { 4678 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 12; 4679 if(BURS.DEBUG) trace(p, 453, c + 0, p.getCost(1) /* stm */); 4680 if (c < p.getCost(1) /* stm */) { 4681 p.setCost(1 /* stm */, (char)(c)); 4682 p.writePacked(0, 0xFFFFFF00, 0xD4); // p.stm = 212 4683 } 4684 } 4685 } 4686 4687 /** 4688 * Labels DOUBLE_ASTORE tree node 4689 * @param p node to label 4690 */ 4691 private static void label_DOUBLE_ASTORE(AbstractBURS_TreeNode p) { 4692 p.initCost(); 4693 AbstractBURS_TreeNode lchild, rchild; 4694 lchild = p.getChild1(); 4695 rchild = p.getChild2(); 4696 label(lchild); 4697 label(rchild); 4698 int c; 4699 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 4700 rchild.getOpcode() == OTHER_OPERAND_opcode 4701 ) { 4702 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4703 if(BURS.DEBUG) trace(p, 440, c + 0, p.getCost(1) /* stm */); 4704 if (c < p.getCost(1) /* stm */) { 4705 p.setCost(1 /* stm */, (char)(c)); 4706 p.writePacked(0, 0xFFFFFF00, 0xC7); // p.stm = 199 4707 } 4708 } 4709 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 4710 rchild.getOpcode() == OTHER_OPERAND_opcode 4711 ) { 4712 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4713 if(BURS.DEBUG) trace(p, 441, c + 0, p.getCost(1) /* stm */); 4714 if (c < p.getCost(1) /* stm */) { 4715 p.setCost(1 /* stm */, (char)(c)); 4716 p.writePacked(0, 0xFFFFFF00, 0xC8); // p.stm = 200 4717 } 4718 } 4719 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 4720 rchild.getOpcode() == OTHER_OPERAND_opcode 4721 ) { 4722 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4723 if(BURS.DEBUG) trace(p, 442, c + 0, p.getCost(1) /* stm */); 4724 if (c < p.getCost(1) /* stm */) { 4725 p.setCost(1 /* stm */, (char)(c)); 4726 p.writePacked(0, 0xFFFFFF00, 0xC9); // p.stm = 201 4727 } 4728 } 4729 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 4730 rchild.getOpcode() == OTHER_OPERAND_opcode 4731 ) { 4732 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4733 if(BURS.DEBUG) trace(p, 443, c + 0, p.getCost(1) /* stm */); 4734 if (c < p.getCost(1) /* stm */) { 4735 p.setCost(1 /* stm */, (char)(c)); 4736 p.writePacked(0, 0xFFFFFF00, 0xCA); // p.stm = 202 4737 } 4738 } 4739 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 4740 rchild.getOpcode() == OTHER_OPERAND_opcode 4741 ) { 4742 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 12; 4743 if(BURS.DEBUG) trace(p, 444, c + 0, p.getCost(1) /* stm */); 4744 if (c < p.getCost(1) /* stm */) { 4745 p.setCost(1 /* stm */, (char)(c)); 4746 p.writePacked(0, 0xFFFFFF00, 0xCB); // p.stm = 203 4747 } 4748 } 4749 } 4750 4751 /** 4752 * Labels BYTE_ASTORE tree node 4753 * @param p node to label 4754 */ 4755 private static void label_BYTE_ASTORE(AbstractBURS_TreeNode p) { 4756 p.initCost(); 4757 AbstractBURS_TreeNode lchild, rchild; 4758 lchild = p.getChild1(); 4759 rchild = p.getChild2(); 4760 label(lchild); 4761 label(rchild); 4762 int c; 4763 if ( // stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 4764 rchild.getOpcode() == OTHER_OPERAND_opcode 4765 ) { 4766 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4767 if(BURS.DEBUG) trace(p, 413, c + 0, p.getCost(1) /* stm */); 4768 if (c < p.getCost(1) /* stm */) { 4769 p.setCost(1 /* stm */, (char)(c)); 4770 p.writePacked(0, 0xFFFFFF00, 0x4E); // p.stm = 78 4771 } 4772 } 4773 if ( // stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) 4774 lchild.getOpcode() == BOOLEAN_NOT_opcode && 4775 lchild.getChild1().getOpcode() == UBYTE_ALOAD_opcode && 4776 rchild.getOpcode() == OTHER_OPERAND_opcode 4777 ) { 4778 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ARRAY_ADDRESS_EQUAL(P(p), PLL(p), 17); 4779 if(BURS.DEBUG) trace(p, 531, c + 0, p.getCost(1) /* stm */); 4780 if (c < p.getCost(1) /* stm */) { 4781 p.setCost(1 /* stm */, (char)(c)); 4782 p.writePacked(0, 0xFFFFFF00, 0x50); // p.stm = 80 4783 } 4784 } 4785 if ( // stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 4786 rchild.getOpcode() == OTHER_OPERAND_opcode 4787 ) { 4788 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4789 if(BURS.DEBUG) trace(p, 416, c + 0, p.getCost(1) /* stm */); 4790 if (c < p.getCost(1) /* stm */) { 4791 p.setCost(1 /* stm */, (char)(c)); 4792 p.writePacked(0, 0xFFFFFF00, 0x53); // p.stm = 83 4793 } 4794 } 4795 if ( // stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) 4796 rchild.getOpcode() == OTHER_OPERAND_opcode 4797 ) { 4798 c = STATE(lchild).getCost(21 /* load8 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 4799 if(BURS.DEBUG) trace(p, 417, c + 0, p.getCost(1) /* stm */); 4800 if (c < p.getCost(1) /* stm */) { 4801 p.setCost(1 /* stm */, (char)(c)); 4802 p.writePacked(0, 0xFFFFFF00, 0x54); // p.stm = 84 4803 } 4804 } 4805 if ( // stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 4806 lchild.getOpcode() == INT_2BYTE_opcode && 4807 rchild.getOpcode() == OTHER_OPERAND_opcode 4808 ) { 4809 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4810 if(BURS.DEBUG) trace(p, 562, c + 0, p.getCost(1) /* stm */); 4811 if (c < p.getCost(1) /* stm */) { 4812 p.setCost(1 /* stm */, (char)(c)); 4813 p.writePacked(0, 0xFFFFFF00, 0x56); // p.stm = 86 4814 } 4815 } 4816 } 4817 4818 /** 4819 * Labels SHORT_ASTORE tree node 4820 * @param p node to label 4821 */ 4822 private static void label_SHORT_ASTORE(AbstractBURS_TreeNode p) { 4823 p.initCost(); 4824 AbstractBURS_TreeNode lchild, rchild; 4825 lchild = p.getChild1(); 4826 rchild = p.getChild2(); 4827 label(lchild); 4828 label(rchild); 4829 int c; 4830 if ( // stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 4831 rchild.getOpcode() == OTHER_OPERAND_opcode 4832 ) { 4833 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4834 if(BURS.DEBUG) trace(p, 401, c + 0, p.getCost(1) /* stm */); 4835 if (c < p.getCost(1) /* stm */) { 4836 p.setCost(1 /* stm */, (char)(c)); 4837 p.writePacked(0, 0xFFFFFF00, 0x19); // p.stm = 25 4838 } 4839 } 4840 if ( // stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 4841 rchild.getOpcode() == OTHER_OPERAND_opcode 4842 ) { 4843 c = STATE(lchild).getCost(14 /* load16 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 4844 if(BURS.DEBUG) trace(p, 402, c + 0, p.getCost(1) /* stm */); 4845 if (c < p.getCost(1) /* stm */) { 4846 p.setCost(1 /* stm */, (char)(c)); 4847 p.writePacked(0, 0xFFFFFF00, 0x1A); // p.stm = 26 4848 } 4849 } 4850 if ( // stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 4851 rchild.getOpcode() == OTHER_OPERAND_opcode 4852 ) { 4853 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 4854 if(BURS.DEBUG) trace(p, 403, c + 0, p.getCost(1) /* stm */); 4855 if (c < p.getCost(1) /* stm */) { 4856 p.setCost(1 /* stm */, (char)(c)); 4857 p.writePacked(0, 0xFFFFFF00, 0x1B); // p.stm = 27 4858 } 4859 } 4860 if ( // stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 4861 lchild.getOpcode() == INT_2SHORT_opcode && 4862 rchild.getOpcode() == OTHER_OPERAND_opcode 4863 ) { 4864 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4865 if(BURS.DEBUG) trace(p, 564, c + 0, p.getCost(1) /* stm */); 4866 if (c < p.getCost(1) /* stm */) { 4867 p.setCost(1 /* stm */, (char)(c)); 4868 p.writePacked(0, 0xFFFFFF00, 0x58); // p.stm = 88 4869 } 4870 } 4871 if ( // stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 4872 lchild.getOpcode() == INT_2USHORT_opcode && 4873 rchild.getOpcode() == OTHER_OPERAND_opcode 4874 ) { 4875 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4876 if(BURS.DEBUG) trace(p, 566, c + 0, p.getCost(1) /* stm */); 4877 if (c < p.getCost(1) /* stm */) { 4878 p.setCost(1 /* stm */, (char)(c)); 4879 p.writePacked(0, 0xFFFFFF00, 0x5A); // p.stm = 90 4880 } 4881 } 4882 } 4883 4884 /** 4885 * Labels INT_IFCMP tree node 4886 * @param p node to label 4887 */ 4888 private static void label_INT_IFCMP(AbstractBURS_TreeNode p) { 4889 p.initCost(); 4890 AbstractBURS_TreeNode lchild, rchild; 4891 lchild = p.getChild1(); 4892 rchild = p.getChild2(); 4893 label(lchild); 4894 label(rchild); 4895 int c; 4896 if ( // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4897 lchild.getOpcode() == ATTEMPT_INT_opcode && 4898 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4899 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4900 rchild.getOpcode() == INT_CONSTANT_opcode 4901 ) { 4902 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4903 if(BURS.DEBUG) trace(p, 494, c + 0, p.getCost(1) /* stm */); 4904 if (c < p.getCost(1) /* stm */) { 4905 p.setCost(1 /* stm */, (char)(c)); 4906 p.writePacked(0, 0xFFFFFF00, 0x31); // p.stm = 49 4907 } 4908 } 4909 if ( // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4910 lchild.getOpcode() == ATTEMPT_INT_opcode && 4911 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4912 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4913 rchild.getOpcode() == INT_CONSTANT_opcode 4914 ) { 4915 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4916 if(BURS.DEBUG) trace(p, 495, c + 0, p.getCost(1) /* stm */); 4917 if (c < p.getCost(1) /* stm */) { 4918 p.setCost(1 /* stm */, (char)(c)); 4919 p.writePacked(0, 0xFFFFFF00, 0x32); // p.stm = 50 4920 } 4921 } 4922 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4923 lchild.getOpcode() == ATTEMPT_INT_opcode && 4924 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4925 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4926 rchild.getOpcode() == INT_CONSTANT_opcode 4927 ) { 4928 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4929 if(BURS.DEBUG) trace(p, 496, c + 0, p.getCost(1) /* stm */); 4930 if (c < p.getCost(1) /* stm */) { 4931 p.setCost(1 /* stm */, (char)(c)); 4932 p.writePacked(0, 0xFFFFFF00, 0x33); // p.stm = 51 4933 } 4934 } 4935 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4936 lchild.getOpcode() == ATTEMPT_INT_opcode && 4937 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4938 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4939 rchild.getOpcode() == INT_CONSTANT_opcode 4940 ) { 4941 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4942 if(BURS.DEBUG) trace(p, 497, c + 0, p.getCost(1) /* stm */); 4943 if (c < p.getCost(1) /* stm */) { 4944 p.setCost(1 /* stm */, (char)(c)); 4945 p.writePacked(0, 0xFFFFFF00, 0x34); // p.stm = 52 4946 } 4947 } 4948 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4949 lchild.getOpcode() == ATTEMPT_INT_opcode && 4950 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4951 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4952 rchild.getOpcode() == INT_CONSTANT_opcode 4953 ) { 4954 c = STATE(lchild.getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4955 if(BURS.DEBUG) trace(p, 498, c + 0, p.getCost(1) /* stm */); 4956 if (c < p.getCost(1) /* stm */) { 4957 p.setCost(1 /* stm */, (char)(c)); 4958 p.writePacked(0, 0xFFFFFF00, 0x35); // p.stm = 53 4959 } 4960 } 4961 if ( // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4962 lchild.getOpcode() == ATTEMPT_INT_opcode && 4963 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4964 lchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 4965 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4966 rchild.getOpcode() == INT_CONSTANT_opcode 4967 ) { 4968 c = STATE(lchild.getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4969 if(BURS.DEBUG) trace(p, 514, c + 0, p.getCost(1) /* stm */); 4970 if (c < p.getCost(1) /* stm */) { 4971 p.setCost(1 /* stm */, (char)(c)); 4972 p.writePacked(0, 0xFFFFFF00, 0x36); // p.stm = 54 4973 } 4974 } 4975 if ( // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4976 lchild.getOpcode() == ATTEMPT_INT_opcode && 4977 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 4978 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4979 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4980 rchild.getOpcode() == INT_CONSTANT_opcode 4981 ) { 4982 c = STATE(lchild.getChild2().getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4983 if(BURS.DEBUG) trace(p, 518, c + 0, p.getCost(1) /* stm */); 4984 if (c < p.getCost(1) /* stm */) { 4985 p.setCost(1 /* stm */, (char)(c)); 4986 p.writePacked(0, 0xFFFFFF00, 0x37); // p.stm = 55 4987 } 4988 } 4989 if ( // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4990 lchild.getOpcode() == ATTEMPT_INT_opcode && 4991 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4992 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4993 rchild.getOpcode() == INT_CONSTANT_opcode 4994 ) { 4995 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4996 if(BURS.DEBUG) trace(p, 499, c + 0, p.getCost(1) /* stm */); 4997 if (c < p.getCost(1) /* stm */) { 4998 p.setCost(1 /* stm */, (char)(c)); 4999 p.writePacked(0, 0xFFFFFF00, 0x38); // p.stm = 56 5000 } 5001 } 5002 if ( // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5003 lchild.getOpcode() == ATTEMPT_INT_opcode && 5004 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5005 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5006 rchild.getOpcode() == INT_CONSTANT_opcode 5007 ) { 5008 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5009 if(BURS.DEBUG) trace(p, 500, c + 0, p.getCost(1) /* stm */); 5010 if (c < p.getCost(1) /* stm */) { 5011 p.setCost(1 /* stm */, (char)(c)); 5012 p.writePacked(0, 0xFFFFFF00, 0x39); // p.stm = 57 5013 } 5014 } 5015 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5016 lchild.getOpcode() == ATTEMPT_INT_opcode && 5017 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5018 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5019 rchild.getOpcode() == INT_CONSTANT_opcode 5020 ) { 5021 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5022 if(BURS.DEBUG) trace(p, 501, c + 0, p.getCost(1) /* stm */); 5023 if (c < p.getCost(1) /* stm */) { 5024 p.setCost(1 /* stm */, (char)(c)); 5025 p.writePacked(0, 0xFFFFFF00, 0x3A); // p.stm = 58 5026 } 5027 } 5028 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5029 lchild.getOpcode() == ATTEMPT_INT_opcode && 5030 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5031 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5032 rchild.getOpcode() == INT_CONSTANT_opcode 5033 ) { 5034 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5035 if(BURS.DEBUG) trace(p, 502, c + 0, p.getCost(1) /* stm */); 5036 if (c < p.getCost(1) /* stm */) { 5037 p.setCost(1 /* stm */, (char)(c)); 5038 p.writePacked(0, 0xFFFFFF00, 0x3B); // p.stm = 59 5039 } 5040 } 5041 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5042 lchild.getOpcode() == ATTEMPT_INT_opcode && 5043 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5044 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5045 rchild.getOpcode() == INT_CONSTANT_opcode 5046 ) { 5047 c = STATE(lchild.getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5048 if(BURS.DEBUG) trace(p, 503, c + 0, p.getCost(1) /* stm */); 5049 if (c < p.getCost(1) /* stm */) { 5050 p.setCost(1 /* stm */, (char)(c)); 5051 p.writePacked(0, 0xFFFFFF00, 0x3C); // p.stm = 60 5052 } 5053 } 5054 if ( // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5055 lchild.getOpcode() == ATTEMPT_INT_opcode && 5056 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5057 lchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 5058 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5059 rchild.getOpcode() == INT_CONSTANT_opcode 5060 ) { 5061 c = STATE(lchild.getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5062 if(BURS.DEBUG) trace(p, 515, c + 0, p.getCost(1) /* stm */); 5063 if (c < p.getCost(1) /* stm */) { 5064 p.setCost(1 /* stm */, (char)(c)); 5065 p.writePacked(0, 0xFFFFFF00, 0x3D); // p.stm = 61 5066 } 5067 } 5068 if ( // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 5069 lchild.getOpcode() == ATTEMPT_INT_opcode && 5070 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 5071 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5072 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5073 rchild.getOpcode() == INT_CONSTANT_opcode 5074 ) { 5075 c = STATE(lchild.getChild2().getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 5076 if(BURS.DEBUG) trace(p, 519, c + 0, p.getCost(1) /* stm */); 5077 if (c < p.getCost(1) /* stm */) { 5078 p.setCost(1 /* stm */, (char)(c)); 5079 p.writePacked(0, 0xFFFFFF00, 0x3E); // p.stm = 62 5080 } 5081 } 5082 if ( // stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5083 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5084 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5085 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5086 rchild.getOpcode() == INT_CONSTANT_opcode 5087 ) { 5088 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p), 54); 5089 if(BURS.DEBUG) trace(p, 504, c + 0, p.getCost(1) /* stm */); 5090 if (c < p.getCost(1) /* stm */) { 5091 p.setCost(1 /* stm */, (char)(c)); 5092 p.writePacked(0, 0xFFFFFF00, 0x3F); // p.stm = 63 5093 } 5094 } 5095 if ( // stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5096 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5097 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5098 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5099 rchild.getOpcode() == INT_CONSTANT_opcode 5100 ) { 5101 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p), 54); 5102 if(BURS.DEBUG) trace(p, 505, c + 0, p.getCost(1) /* stm */); 5103 if (c < p.getCost(1) /* stm */) { 5104 p.setCost(1 /* stm */, (char)(c)); 5105 p.writePacked(0, 0xFFFFFF00, 0x40); // p.stm = 64 5106 } 5107 } 5108 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5109 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5110 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5111 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5112 rchild.getOpcode() == INT_CONSTANT_opcode 5113 ) { 5114 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p), 54); 5115 if(BURS.DEBUG) trace(p, 506, c + 0, p.getCost(1) /* stm */); 5116 if (c < p.getCost(1) /* stm */) { 5117 p.setCost(1 /* stm */, (char)(c)); 5118 p.writePacked(0, 0xFFFFFF00, 0x41); // p.stm = 65 5119 } 5120 } 5121 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5122 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5123 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5124 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5125 rchild.getOpcode() == INT_CONSTANT_opcode 5126 ) { 5127 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p),54); 5128 if(BURS.DEBUG) trace(p, 507, c + 0, p.getCost(1) /* stm */); 5129 if (c < p.getCost(1) /* stm */) { 5130 p.setCost(1 /* stm */, (char)(c)); 5131 p.writePacked(0, 0xFFFFFF00, 0x42); // p.stm = 66 5132 } 5133 } 5134 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5135 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5136 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5137 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5138 rchild.getOpcode() == INT_CONSTANT_opcode 5139 ) { 5140 c = STATE(lchild.getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p),54); 5141 if(BURS.DEBUG) trace(p, 508, c + 0, p.getCost(1) /* stm */); 5142 if (c < p.getCost(1) /* stm */) { 5143 p.setCost(1 /* stm */, (char)(c)); 5144 p.writePacked(0, 0xFFFFFF00, 0x43); // p.stm = 67 5145 } 5146 } 5147 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5148 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5149 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5150 lchild.getChild2().getChild1().getOpcode() == LONG_CONSTANT_opcode && 5151 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5152 rchild.getOpcode() == INT_CONSTANT_opcode 5153 ) { 5154 c = STATE(lchild.getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p), 54); 5155 if(BURS.DEBUG) trace(p, 516, c + 0, p.getCost(1) /* stm */); 5156 if (c < p.getCost(1) /* stm */) { 5157 p.setCost(1 /* stm */, (char)(c)); 5158 p.writePacked(0, 0xFFFFFF00, 0x44); // p.stm = 68 5159 } 5160 } 5161 if ( // stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5162 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5163 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 5164 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5165 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5166 rchild.getOpcode() == INT_CONSTANT_opcode 5167 ) { 5168 c = STATE(lchild.getChild2().getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isZERO(VR(p),54); 5169 if(BURS.DEBUG) trace(p, 520, c + 0, p.getCost(1) /* stm */); 5170 if (c < p.getCost(1) /* stm */) { 5171 p.setCost(1 /* stm */, (char)(c)); 5172 p.writePacked(0, 0xFFFFFF00, 0x45); // p.stm = 69 5173 } 5174 } 5175 if ( // stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5176 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5177 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5178 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5179 rchild.getOpcode() == INT_CONSTANT_opcode 5180 ) { 5181 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5182 if(BURS.DEBUG) trace(p, 509, c + 0, p.getCost(1) /* stm */); 5183 if (c < p.getCost(1) /* stm */) { 5184 p.setCost(1 /* stm */, (char)(c)); 5185 p.writePacked(0, 0xFFFFFF00, 0x46); // p.stm = 70 5186 } 5187 } 5188 if ( // stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5189 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5190 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5191 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5192 rchild.getOpcode() == INT_CONSTANT_opcode 5193 ) { 5194 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5195 if(BURS.DEBUG) trace(p, 510, c + 0, p.getCost(1) /* stm */); 5196 if (c < p.getCost(1) /* stm */) { 5197 p.setCost(1 /* stm */, (char)(c)); 5198 p.writePacked(0, 0xFFFFFF00, 0x47); // p.stm = 71 5199 } 5200 } 5201 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5202 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5203 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5204 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5205 rchild.getOpcode() == INT_CONSTANT_opcode 5206 ) { 5207 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5208 if(BURS.DEBUG) trace(p, 511, c + 0, p.getCost(1) /* stm */); 5209 if (c < p.getCost(1) /* stm */) { 5210 p.setCost(1 /* stm */, (char)(c)); 5211 p.writePacked(0, 0xFFFFFF00, 0x48); // p.stm = 72 5212 } 5213 } 5214 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5215 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5216 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5217 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5218 rchild.getOpcode() == INT_CONSTANT_opcode 5219 ) { 5220 c = STATE(lchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5221 if(BURS.DEBUG) trace(p, 512, c + 0, p.getCost(1) /* stm */); 5222 if (c < p.getCost(1) /* stm */) { 5223 p.setCost(1 /* stm */, (char)(c)); 5224 p.writePacked(0, 0xFFFFFF00, 0x49); // p.stm = 73 5225 } 5226 } 5227 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5228 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5229 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5230 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5231 rchild.getOpcode() == INT_CONSTANT_opcode 5232 ) { 5233 c = STATE(lchild.getChild1()).getCost(16 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(15 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5234 if(BURS.DEBUG) trace(p, 513, c + 0, p.getCost(1) /* stm */); 5235 if (c < p.getCost(1) /* stm */) { 5236 p.setCost(1 /* stm */, (char)(c)); 5237 p.writePacked(0, 0xFFFFFF00, 0x4A); // p.stm = 74 5238 } 5239 } 5240 if ( // stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5241 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5242 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5243 lchild.getChild2().getChild1().getOpcode() == LONG_CONSTANT_opcode && 5244 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5245 rchild.getOpcode() == INT_CONSTANT_opcode 5246 ) { 5247 c = STATE(lchild.getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5248 if(BURS.DEBUG) trace(p, 517, c + 0, p.getCost(1) /* stm */); 5249 if (c < p.getCost(1) /* stm */) { 5250 p.setCost(1 /* stm */, (char)(c)); 5251 p.writePacked(0, 0xFFFFFF00, 0x4B); // p.stm = 75 5252 } 5253 } 5254 if ( // stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 5255 lchild.getOpcode() == ATTEMPT_LONG_opcode && 5256 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 5257 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 5258 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 5259 rchild.getOpcode() == INT_CONSTANT_opcode 5260 ) { 5261 c = STATE(lchild.getChild2().getChild1()).getCost(17 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(8 /* rlv */) + isONE(VR(p), 54); 5262 if(BURS.DEBUG) trace(p, 521, c + 0, p.getCost(1) /* stm */); 5263 if (c < p.getCost(1) /* stm */) { 5264 p.setCost(1 /* stm */, (char)(c)); 5265 p.writePacked(0, 0xFFFFFF00, 0x4C); // p.stm = 76 5266 } 5267 } 5268 // stm: INT_IFCMP(r,riv) 5269 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 26; 5270 if(BURS.DEBUG) trace(p, 93, c + 0, p.getCost(1) /* stm */); 5271 if (c < p.getCost(1) /* stm */) { 5272 p.setCost(1 /* stm */, (char)(c)); 5273 p.writePacked(0, 0xFFFFFF00, 0x63); // p.stm = 99 5274 } 5275 if ( // stm: INT_IFCMP(r,INT_CONSTANT) 5276 rchild.getOpcode() == INT_CONSTANT_opcode 5277 ) { 5278 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(IfCmp.getCond(P(p))) ? 24:INFINITE); 5279 if(BURS.DEBUG) trace(p, 309, c + 0, p.getCost(1) /* stm */); 5280 if (c < p.getCost(1) /* stm */) { 5281 p.setCost(1 /* stm */, (char)(c)); 5282 p.writePacked(0, 0xFFFFFF00, 0x64); // p.stm = 100 5283 } 5284 } 5285 if ( // stm: INT_IFCMP(load8,INT_CONSTANT) 5286 rchild.getOpcode() == INT_CONSTANT_opcode 5287 ) { 5288 c = STATE(lchild).getCost(21 /* load8 */) + FITS(IfCmp.getVal2(P(p)), 8, 28); 5289 if(BURS.DEBUG) trace(p, 310, c + 0, p.getCost(1) /* stm */); 5290 if (c < p.getCost(1) /* stm */) { 5291 p.setCost(1 /* stm */, (char)(c)); 5292 p.writePacked(0, 0xFFFFFF00, 0x65); // p.stm = 101 5293 } 5294 } 5295 // stm: INT_IFCMP(uload8,r) 5296 c = STATE(lchild).getCost(11 /* uload8 */) + STATE(rchild).getCost(2 /* r */) + 28; 5297 if(BURS.DEBUG) trace(p, 94, c + 0, p.getCost(1) /* stm */); 5298 if (c < p.getCost(1) /* stm */) { 5299 p.setCost(1 /* stm */, (char)(c)); 5300 p.writePacked(0, 0xFFFFFF00, 0x66); // p.stm = 102 5301 } 5302 // stm: INT_IFCMP(r,uload8) 5303 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(11 /* uload8 */) + 28; 5304 if(BURS.DEBUG) trace(p, 95, c + 0, p.getCost(1) /* stm */); 5305 if (c < p.getCost(1) /* stm */) { 5306 p.setCost(1 /* stm */, (char)(c)); 5307 p.writePacked(0, 0xFFFFFF00, 0x67); // p.stm = 103 5308 } 5309 if ( // stm: INT_IFCMP(sload16,INT_CONSTANT) 5310 rchild.getOpcode() == INT_CONSTANT_opcode 5311 ) { 5312 c = STATE(lchild).getCost(22 /* sload16 */) + FITS(IfCmp.getVal2(P(p)), 8, 28); 5313 if(BURS.DEBUG) trace(p, 311, c + 0, p.getCost(1) /* stm */); 5314 if (c < p.getCost(1) /* stm */) { 5315 p.setCost(1 /* stm */, (char)(c)); 5316 p.writePacked(0, 0xFFFFFF00, 0x68); // p.stm = 104 5317 } 5318 } 5319 // stm: INT_IFCMP(load32,riv) 5320 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 28; 5321 if(BURS.DEBUG) trace(p, 96, c + 0, p.getCost(1) /* stm */); 5322 if (c < p.getCost(1) /* stm */) { 5323 p.setCost(1 /* stm */, (char)(c)); 5324 p.writePacked(0, 0xFFFFFF00, 0x69); // p.stm = 105 5325 } 5326 // stm: INT_IFCMP(r,load32) 5327 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 28; 5328 if(BURS.DEBUG) trace(p, 97, c + 0, p.getCost(1) /* stm */); 5329 if (c < p.getCost(1) /* stm */) { 5330 p.setCost(1 /* stm */, (char)(c)); 5331 p.writePacked(0, 0xFFFFFF00, 0x6A); // p.stm = 106 5332 } 5333 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 5334 rchild.getOpcode() == INT_CONSTANT_opcode 5335 ) { 5336 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 0 && IfCmp.getCond(P(p)).isNOT_EQUAL()) || (VR(p) == 1 && IfCmp.getCond(P(p)).isEQUAL()) ? 13:INFINITE); 5337 if(BURS.DEBUG) trace(p, 312, c + 0, p.getCost(1) /* stm */); 5338 if (c < p.getCost(1) /* stm */) { 5339 p.setCost(1 /* stm */, (char)(c)); 5340 p.writePacked(0, 0xFFFFFF00, 0x6B); // p.stm = 107 5341 } 5342 } 5343 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 5344 rchild.getOpcode() == INT_CONSTANT_opcode 5345 ) { 5346 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 0 && IfCmp.getCond(P(p)).isEQUAL()) || (VR(p) == 1 && IfCmp.getCond(P(p)).isNOT_EQUAL()) ? 13:INFINITE); 5347 if(BURS.DEBUG) trace(p, 313, c + 0, p.getCost(1) /* stm */); 5348 if (c < p.getCost(1) /* stm */) { 5349 p.setCost(1 /* stm */, (char)(c)); 5350 p.writePacked(0, 0xFFFFFF00, 0x6C); // p.stm = 108 5351 } 5352 } 5353 if ( // stm: INT_IFCMP(cz,INT_CONSTANT) 5354 rchild.getOpcode() == INT_CONSTANT_opcode 5355 ) { 5356 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 11); 5357 if(BURS.DEBUG) trace(p, 314, c + 0, p.getCost(1) /* stm */); 5358 if (c < p.getCost(1) /* stm */) { 5359 p.setCost(1 /* stm */, (char)(c)); 5360 p.writePacked(0, 0xFFFFFF00, 0x6D); // p.stm = 109 5361 } 5362 } 5363 if ( // stm: INT_IFCMP(szp,INT_CONSTANT) 5364 rchild.getOpcode() == INT_CONSTANT_opcode 5365 ) { 5366 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(IfCmp.getCond(P(p)))?11:INFINITE); 5367 if(BURS.DEBUG) trace(p, 315, c + 0, p.getCost(1) /* stm */); 5368 if (c < p.getCost(1) /* stm */) { 5369 p.setCost(1 /* stm */, (char)(c)); 5370 p.writePacked(0, 0xFFFFFF00, 0x6E); // p.stm = 110 5371 } 5372 } 5373 if ( // stm: INT_IFCMP(bittest,INT_CONSTANT) 5374 rchild.getOpcode() == INT_CONSTANT_opcode 5375 ) { 5376 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(IfCmp.getCond(P(p))) ? 11 : INFINITE); 5377 if(BURS.DEBUG) trace(p, 316, c + 0, p.getCost(1) /* stm */); 5378 if (c < p.getCost(1) /* stm */) { 5379 p.setCost(1 /* stm */, (char)(c)); 5380 p.writePacked(0, 0xFFFFFF00, 0x6F); // p.stm = 111 5381 } 5382 } 5383 } 5384 5385 /** 5386 * Labels INT_IFCMP2 tree node 5387 * @param p node to label 5388 */ 5389 private static void label_INT_IFCMP2(AbstractBURS_TreeNode p) { 5390 p.initCost(); 5391 AbstractBURS_TreeNode lchild, rchild; 5392 lchild = p.getChild1(); 5393 rchild = p.getChild2(); 5394 label(lchild); 5395 label(rchild); 5396 int c; 5397 // stm: INT_IFCMP2(r,riv) 5398 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 26; 5399 if(BURS.DEBUG) trace(p, 98, c + 0, p.getCost(1) /* stm */); 5400 if (c < p.getCost(1) /* stm */) { 5401 p.setCost(1 /* stm */, (char)(c)); 5402 p.writePacked(0, 0xFFFFFF00, 0x70); // p.stm = 112 5403 } 5404 // stm: INT_IFCMP2(load32,riv) 5405 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 28; 5406 if(BURS.DEBUG) trace(p, 99, c + 0, p.getCost(1) /* stm */); 5407 if (c < p.getCost(1) /* stm */) { 5408 p.setCost(1 /* stm */, (char)(c)); 5409 p.writePacked(0, 0xFFFFFF00, 0x71); // p.stm = 113 5410 } 5411 // stm: INT_IFCMP2(riv,load32) 5412 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 28; 5413 if(BURS.DEBUG) trace(p, 100, c + 0, p.getCost(1) /* stm */); 5414 if (c < p.getCost(1) /* stm */) { 5415 p.setCost(1 /* stm */, (char)(c)); 5416 p.writePacked(0, 0xFFFFFF00, 0x72); // p.stm = 114 5417 } 5418 } 5419 5420 /** 5421 * Labels LONG_IFCMP tree node 5422 * @param p node to label 5423 */ 5424 private static void label_LONG_IFCMP(AbstractBURS_TreeNode p) { 5425 p.initCost(); 5426 AbstractBURS_TreeNode lchild, rchild; 5427 lchild = p.getChild1(); 5428 rchild = p.getChild2(); 5429 label(lchild); 5430 label(rchild); 5431 int c; 5432 // stm: LONG_IFCMP(rlv,rlv) 5433 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 26; 5434 if(BURS.DEBUG) trace(p, 173, c + 0, p.getCost(1) /* stm */); 5435 if (c < p.getCost(1) /* stm */) { 5436 p.setCost(1 /* stm */, (char)(c)); 5437 p.writePacked(0, 0xFFFFFF00, 0x9F); // p.stm = 159 5438 } 5439 if ( // stm: LONG_IFCMP(r,LONG_CONSTANT) 5440 rchild.getOpcode() == LONG_CONSTANT_opcode 5441 ) { 5442 c = STATE(lchild).getCost(2 /* r */) + (LV(IfCmp.getVal2(P(p))) == 0 && CMP_TO_TEST(IfCmp.getCond(P(p))) ? 24:INFINITE); 5443 if(BURS.DEBUG) trace(p, 341, c + 0, p.getCost(1) /* stm */); 5444 if (c < p.getCost(1) /* stm */) { 5445 p.setCost(1 /* stm */, (char)(c)); 5446 p.writePacked(0, 0xFFFFFF00, 0xA0); // p.stm = 160 5447 } 5448 } 5449 } 5450 5451 /** 5452 * Labels FLOAT_IFCMP tree node 5453 * @param p node to label 5454 */ 5455 private static void label_FLOAT_IFCMP(AbstractBURS_TreeNode p) { 5456 p.initCost(); 5457 AbstractBURS_TreeNode lchild, rchild; 5458 lchild = p.getChild1(); 5459 rchild = p.getChild2(); 5460 label(lchild); 5461 label(rchild); 5462 int c; 5463 // stm: FLOAT_IFCMP(r,r) 5464 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5465 if(BURS.DEBUG) trace(p, 241, c + 0, p.getCost(1) /* stm */); 5466 if (c < p.getCost(1) /* stm */) { 5467 p.setCost(1 /* stm */, (char)(c)); 5468 p.writePacked(0, 0xFFFFFF00, 0xD6); // p.stm = 214 5469 } 5470 // stm: FLOAT_IFCMP(r,float_load) 5471 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* float_load */) + 15; 5472 if(BURS.DEBUG) trace(p, 242, c + 0, p.getCost(1) /* stm */); 5473 if (c < p.getCost(1) /* stm */) { 5474 p.setCost(1 /* stm */, (char)(c)); 5475 p.writePacked(0, 0xFFFFFF00, 0xD7); // p.stm = 215 5476 } 5477 // stm: FLOAT_IFCMP(float_load,r) 5478 c = STATE(lchild).getCost(26 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5479 if(BURS.DEBUG) trace(p, 243, c + 0, p.getCost(1) /* stm */); 5480 if (c < p.getCost(1) /* stm */) { 5481 p.setCost(1 /* stm */, (char)(c)); 5482 p.writePacked(0, 0xFFFFFF00, 0xD8); // p.stm = 216 5483 } 5484 } 5485 5486 /** 5487 * Labels DOUBLE_IFCMP tree node 5488 * @param p node to label 5489 */ 5490 private static void label_DOUBLE_IFCMP(AbstractBURS_TreeNode p) { 5491 p.initCost(); 5492 AbstractBURS_TreeNode lchild, rchild; 5493 lchild = p.getChild1(); 5494 rchild = p.getChild2(); 5495 label(lchild); 5496 label(rchild); 5497 int c; 5498 // stm: DOUBLE_IFCMP(r,r) 5499 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5500 if(BURS.DEBUG) trace(p, 244, c + 0, p.getCost(1) /* stm */); 5501 if (c < p.getCost(1) /* stm */) { 5502 p.setCost(1 /* stm */, (char)(c)); 5503 p.writePacked(0, 0xFFFFFF00, 0xD9); // p.stm = 217 5504 } 5505 // stm: DOUBLE_IFCMP(r,double_load) 5506 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(27 /* double_load */) + 15; 5507 if(BURS.DEBUG) trace(p, 245, c + 0, p.getCost(1) /* stm */); 5508 if (c < p.getCost(1) /* stm */) { 5509 p.setCost(1 /* stm */, (char)(c)); 5510 p.writePacked(0, 0xFFFFFF00, 0xDA); // p.stm = 218 5511 } 5512 // stm: DOUBLE_IFCMP(double_load,r) 5513 c = STATE(lchild).getCost(27 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5514 if(BURS.DEBUG) trace(p, 246, c + 0, p.getCost(1) /* stm */); 5515 if (c < p.getCost(1) /* stm */) { 5516 p.setCost(1 /* stm */, (char)(c)); 5517 p.writePacked(0, 0xFFFFFF00, 0xDB); // p.stm = 219 5518 } 5519 } 5520 5521 /** 5522 * Labels UNINT_BEGIN tree node 5523 * @param p node to label 5524 */ 5525 private static void label_UNINT_BEGIN(AbstractBURS_TreeNode p) { 5526 p.initCost(); 5527 // stm: UNINT_BEGIN 5528 if(BURS.DEBUG) trace(p, 28, 10 + 0, p.getCost(1) /* stm */); 5529 if (10 < p.getCost(1) /* stm */) { 5530 p.setCost(1 /* stm */, (char)(10)); 5531 p.writePacked(0, 0xFFFFFF00, 0x3); // p.stm = 3 5532 } 5533 } 5534 5535 /** 5536 * Labels UNINT_END tree node 5537 * @param p node to label 5538 */ 5539 private static void label_UNINT_END(AbstractBURS_TreeNode p) { 5540 p.initCost(); 5541 // stm: UNINT_END 5542 if(BURS.DEBUG) trace(p, 29, 10 + 0, p.getCost(1) /* stm */); 5543 if (10 < p.getCost(1) /* stm */) { 5544 p.setCost(1 /* stm */, (char)(10)); 5545 p.writePacked(0, 0xFFFFFF00, 0x4); // p.stm = 4 5546 } 5547 } 5548 5549 /** 5550 * Labels FENCE tree node 5551 * @param p node to label 5552 */ 5553 private static void label_FENCE(AbstractBURS_TreeNode p) { 5554 p.initCost(); 5555 // stm: FENCE 5556 if(BURS.DEBUG) trace(p, 44, 11 + 0, p.getCost(1) /* stm */); 5557 if (11 < p.getCost(1) /* stm */) { 5558 p.setCost(1 /* stm */, (char)(11)); 5559 p.writePacked(0, 0xFFFFFF00, 0x2A); // p.stm = 42 5560 } 5561 } 5562 5563 /** 5564 * Labels READ_CEILING tree node 5565 * @param p node to label 5566 */ 5567 private static void label_READ_CEILING(AbstractBURS_TreeNode p) { 5568 p.initCost(); 5569 // stm: READ_CEILING 5570 if(BURS.DEBUG) trace(p, 43, 11 + 0, p.getCost(1) /* stm */); 5571 if (11 < p.getCost(1) /* stm */) { 5572 p.setCost(1 /* stm */, (char)(11)); 5573 p.writePacked(0, 0xFFFFFF00, 0x29); // p.stm = 41 5574 } 5575 } 5576 5577 /** 5578 * Labels WRITE_FLOOR tree node 5579 * @param p node to label 5580 */ 5581 private static void label_WRITE_FLOOR(AbstractBURS_TreeNode p) { 5582 p.initCost(); 5583 // stm: WRITE_FLOOR 5584 if(BURS.DEBUG) trace(p, 42, 11 + 0, p.getCost(1) /* stm */); 5585 if (11 < p.getCost(1) /* stm */) { 5586 p.setCost(1 /* stm */, (char)(11)); 5587 p.writePacked(0, 0xFFFFFF00, 0x28); // p.stm = 40 5588 } 5589 } 5590 5591 /** 5592 * Labels NOP tree node 5593 * @param p node to label 5594 */ 5595 private static void label_NOP(AbstractBURS_TreeNode p) { 5596 p.initCost(); 5597 // stm: NOP 5598 if(BURS.DEBUG) trace(p, 34, 10 + 0, p.getCost(1) /* stm */); 5599 if (10 < p.getCost(1) /* stm */) { 5600 p.setCost(1 /* stm */, (char)(10)); 5601 p.writePacked(0, 0xFFFFFF00, 0xA); // p.stm = 10 5602 } 5603 } 5604 5605 /** 5606 * Labels INT_MOVE tree node 5607 * @param p node to label 5608 */ 5609 private static void label_INT_MOVE(AbstractBURS_TreeNode p) { 5610 p.initCost(); 5611 AbstractBURS_TreeNode lchild; 5612 lchild = p.getChild1(); 5613 label(lchild); 5614 int c; 5615 // address1reg: INT_MOVE(r) 5616 c = STATE(lchild).getCost(2 /* r */) + 0; 5617 if(BURS.DEBUG) trace(p, 260, c + 0, p.getCost(16) /* address1reg */); 5618 if (c < p.getCost(16) /* address1reg */) { 5619 p.setCost(16 /* address1reg */, (char)(c)); 5620 p.writePacked(1, 0xE3FFFFFF, 0x8000000); // p.address1reg = 2 5621 closure_address1reg(p, c); 5622 } 5623 // r: INT_MOVE(riv) 5624 c = STATE(lchild).getCost(7 /* riv */) + 13; 5625 if(BURS.DEBUG) trace(p, 318, c + 0, p.getCost(2) /* r */); 5626 if (c < p.getCost(2) /* r */) { 5627 p.setCost(2 /* r */, (char)(c)); 5628 p.writePacked(0, 0xFFFE00FF, 0x6200); // p.r = 98 5629 closure_r(p, c); 5630 } 5631 // czr: INT_MOVE(czr) 5632 c = STATE(lchild).getCost(3 /* czr */) + 11; 5633 if(BURS.DEBUG) trace(p, 319, c + 0, p.getCost(3) /* czr */); 5634 if (c < p.getCost(3) /* czr */) { 5635 p.setCost(3 /* czr */, (char)(c)); 5636 p.writePacked(0, 0xFFE1FFFF, 0x80000); // p.czr = 4 5637 closure_czr(p, c); 5638 } 5639 // cz: INT_MOVE(cz) 5640 c = STATE(lchild).getCost(4 /* cz */) + 0; 5641 if(BURS.DEBUG) trace(p, 320, c + 0, p.getCost(4) /* cz */); 5642 if (c < p.getCost(4) /* cz */) { 5643 p.setCost(4 /* cz */, (char)(c)); 5644 p.writePacked(0, 0xFF9FFFFF, 0x400000); // p.cz = 2 5645 } 5646 // szpr: INT_MOVE(szpr) 5647 c = STATE(lchild).getCost(5 /* szpr */) + 11; 5648 if(BURS.DEBUG) trace(p, 321, c + 0, p.getCost(5) /* szpr */); 5649 if (c < p.getCost(5) /* szpr */) { 5650 p.setCost(5 /* szpr */, (char)(c)); 5651 p.writePacked(0, 0xE07FFFFF, 0x2800000); // p.szpr = 5 5652 closure_szpr(p, c); 5653 } 5654 // szp: INT_MOVE(szp) 5655 c = STATE(lchild).getCost(6 /* szp */) + 0; 5656 if(BURS.DEBUG) trace(p, 322, c + 0, p.getCost(6) /* szp */); 5657 if (c < p.getCost(6) /* szp */) { 5658 p.setCost(6 /* szp */, (char)(c)); 5659 p.writePacked(1, 0xFFFFFFF0, 0x5); // p.szp = 5 5660 } 5661 // sload8: INT_MOVE(sload8) 5662 c = STATE(lchild).getCost(24 /* sload8 */) + 0; 5663 if(BURS.DEBUG) trace(p, 323, c + 0, p.getCost(24) /* sload8 */); 5664 if (c < p.getCost(24) /* sload8 */) { 5665 p.setCost(24 /* sload8 */, (char)(c)); 5666 p.writePacked(2, 0xFE7FFFFF, 0x800000); // p.sload8 = 1 5667 closure_sload8(p, c); 5668 } 5669 // uload8: INT_MOVE(uload8) 5670 c = STATE(lchild).getCost(11 /* uload8 */) + 0; 5671 if(BURS.DEBUG) trace(p, 324, c + 0, p.getCost(11) /* uload8 */); 5672 if (c < p.getCost(11) /* uload8 */) { 5673 p.setCost(11 /* uload8 */, (char)(c)); 5674 p.writePacked(1, 0xFFFE3FFF, 0x8000); // p.uload8 = 2 5675 closure_uload8(p, c); 5676 } 5677 // load8: INT_MOVE(load8) 5678 c = STATE(lchild).getCost(21 /* load8 */) + 0; 5679 if(BURS.DEBUG) trace(p, 325, c + 0, p.getCost(21) /* load8 */); 5680 if (c < p.getCost(21) /* load8 */) { 5681 p.setCost(21 /* load8 */, (char)(c)); 5682 p.writePacked(2, 0xFFFE7FFF, 0x8000); // p.load8 = 1 5683 closure_load8(p, c); 5684 } 5685 // sload16: INT_MOVE(sload16) 5686 c = STATE(lchild).getCost(22 /* sload16 */) + 0; 5687 if(BURS.DEBUG) trace(p, 326, c + 0, p.getCost(22) /* sload16 */); 5688 if (c < p.getCost(22) /* sload16 */) { 5689 p.setCost(22 /* sload16 */, (char)(c)); 5690 p.writePacked(2, 0xFFF1FFFF, 0x40000); // p.sload16 = 2 5691 closure_sload16(p, c); 5692 } 5693 // uload16: INT_MOVE(uload16) 5694 c = STATE(lchild).getCost(23 /* uload16 */) + 0; 5695 if(BURS.DEBUG) trace(p, 327, c + 0, p.getCost(23) /* uload16 */); 5696 if (c < p.getCost(23) /* uload16 */) { 5697 p.setCost(23 /* uload16 */, (char)(c)); 5698 p.writePacked(2, 0xFF8FFFFF, 0x200000); // p.uload16 = 2 5699 closure_uload16(p, c); 5700 } 5701 // load16: INT_MOVE(load16) 5702 c = STATE(lchild).getCost(14 /* load16 */) + 0; 5703 if(BURS.DEBUG) trace(p, 328, c + 0, p.getCost(14) /* load16 */); 5704 if (c < p.getCost(14) /* load16 */) { 5705 p.setCost(14 /* load16 */, (char)(c)); 5706 p.writePacked(1, 0xFF9FFFFF, 0x200000); // p.load16 = 1 5707 closure_load16(p, c); 5708 } 5709 // load32: INT_MOVE(load32) 5710 c = STATE(lchild).getCost(10 /* load32 */) + 0; 5711 if(BURS.DEBUG) trace(p, 329, c + 0, p.getCost(10) /* load32 */); 5712 if (c < p.getCost(10) /* load32 */) { 5713 p.setCost(10 /* load32 */, (char)(c)); 5714 p.writePacked(1, 0xFFFFC7FF, 0x800); // p.load32 = 1 5715 closure_load32(p, c); 5716 } 5717 } 5718 5719 /** 5720 * Labels LONG_MOVE tree node 5721 * @param p node to label 5722 */ 5723 private static void label_LONG_MOVE(AbstractBURS_TreeNode p) { 5724 p.initCost(); 5725 AbstractBURS_TreeNode lchild; 5726 lchild = p.getChild1(); 5727 label(lchild); 5728 int c; 5729 // address1reg: LONG_MOVE(r) 5730 c = STATE(lchild).getCost(2 /* r */) + 0; 5731 if(BURS.DEBUG) trace(p, 266, c + 0, p.getCost(16) /* address1reg */); 5732 if (c < p.getCost(16) /* address1reg */) { 5733 p.setCost(16 /* address1reg */, (char)(c)); 5734 p.writePacked(1, 0xE3FFFFFF, 0x14000000); // p.address1reg = 5 5735 closure_address1reg(p, c); 5736 } 5737 // r: LONG_MOVE(address) 5738 c = STATE(lchild).getCost(17 /* address */) + 20; 5739 if(BURS.DEBUG) trace(p, 337, c + 0, p.getCost(2) /* r */); 5740 if (c < p.getCost(2) /* r */) { 5741 p.setCost(2 /* r */, (char)(c)); 5742 p.writePacked(0, 0xFFFE00FF, 0x7D00); // p.r = 125 5743 closure_r(p, c); 5744 } 5745 // r: LONG_MOVE(rlv) 5746 c = STATE(lchild).getCost(8 /* rlv */) + 13; 5747 if(BURS.DEBUG) trace(p, 343, c + 0, p.getCost(2) /* r */); 5748 if (c < p.getCost(2) /* r */) { 5749 p.setCost(2 /* r */, (char)(c)); 5750 p.writePacked(0, 0xFFFE00FF, 0x9E00); // p.r = 158 5751 closure_r(p, c); 5752 } 5753 // r: LONG_MOVE(riv) 5754 c = STATE(lchild).getCost(7 /* riv */) + 13; 5755 if(BURS.DEBUG) trace(p, 344, c + 0, p.getCost(2) /* r */); 5756 if (c < p.getCost(2) /* r */) { 5757 p.setCost(2 /* r */, (char)(c)); 5758 p.writePacked(0, 0xFFFE00FF, 0x9F00); // p.r = 159 5759 closure_r(p, c); 5760 } 5761 // load64: LONG_MOVE(load64) 5762 c = STATE(lchild).getCost(20 /* load64 */) + 0; 5763 if(BURS.DEBUG) trace(p, 345, c + 0, p.getCost(20) /* load64 */); 5764 if (c < p.getCost(20) /* load64 */) { 5765 p.setCost(20 /* load64 */, (char)(c)); 5766 p.writePacked(2, 0xFFFF8FFF, 0x4000); // p.load64 = 4 5767 closure_load64(p, c); 5768 } 5769 } 5770 5771 /** 5772 * Labels FLOAT_MOVE tree node 5773 * @param p node to label 5774 */ 5775 private static void label_FLOAT_MOVE(AbstractBURS_TreeNode p) { 5776 p.initCost(); 5777 AbstractBURS_TreeNode lchild; 5778 lchild = p.getChild1(); 5779 label(lchild); 5780 int c; 5781 // r: FLOAT_MOVE(r) 5782 c = STATE(lchild).getCost(2 /* r */) + 13; 5783 if(BURS.DEBUG) trace(p, 358, c + 0, p.getCost(2) /* r */); 5784 if (c < p.getCost(2) /* r */) { 5785 p.setCost(2 /* r */, (char)(c)); 5786 p.writePacked(0, 0xFFFE00FF, 0xC800); // p.r = 200 5787 closure_r(p, c); 5788 } 5789 } 5790 5791 /** 5792 * Labels DOUBLE_MOVE tree node 5793 * @param p node to label 5794 */ 5795 private static void label_DOUBLE_MOVE(AbstractBURS_TreeNode p) { 5796 p.initCost(); 5797 AbstractBURS_TreeNode lchild; 5798 lchild = p.getChild1(); 5799 label(lchild); 5800 int c; 5801 // r: DOUBLE_MOVE(r) 5802 c = STATE(lchild).getCost(2 /* r */) + 13; 5803 if(BURS.DEBUG) trace(p, 359, c + 0, p.getCost(2) /* r */); 5804 if (c < p.getCost(2) /* r */) { 5805 p.setCost(2 /* r */, (char)(c)); 5806 p.writePacked(0, 0xFFFE00FF, 0xC900); // p.r = 201 5807 closure_r(p, c); 5808 } 5809 } 5810 5811 /** 5812 * Labels GUARD_MOVE tree node 5813 * @param p node to label 5814 */ 5815 private static void label_GUARD_MOVE(AbstractBURS_TreeNode p) { 5816 p.initCost(); 5817 // r: GUARD_MOVE 5818 if(BURS.DEBUG) trace(p, 35, 11 + 0, p.getCost(2) /* r */); 5819 if (11 < p.getCost(2) /* r */) { 5820 p.setCost(2 /* r */, (char)(11)); 5821 p.writePacked(0, 0xFFFE00FF, 0x400); // p.r = 4 5822 closure_r(p, 11); 5823 } 5824 } 5825 5826 /** 5827 * Labels GUARD_COMBINE tree node 5828 * @param p node to label 5829 */ 5830 private static void label_GUARD_COMBINE(AbstractBURS_TreeNode p) { 5831 p.initCost(); 5832 // r: GUARD_COMBINE 5833 if(BURS.DEBUG) trace(p, 36, 11 + 0, p.getCost(2) /* r */); 5834 if (11 < p.getCost(2) /* r */) { 5835 p.setCost(2 /* r */, (char)(11)); 5836 p.writePacked(0, 0xFFFE00FF, 0x500); // p.r = 5 5837 closure_r(p, 11); 5838 } 5839 } 5840 5841 /** 5842 * Labels INT_ADD tree node 5843 * @param p node to label 5844 */ 5845 private static void label_INT_ADD(AbstractBURS_TreeNode p) { 5846 p.initCost(); 5847 AbstractBURS_TreeNode lchild, rchild; 5848 lchild = p.getChild1(); 5849 rchild = p.getChild2(); 5850 label(lchild); 5851 label(rchild); 5852 int c; 5853 if ( // address1reg: INT_ADD(r,LONG_CONSTANT) 5854 rchild.getOpcode() == LONG_CONSTANT_opcode 5855 ) { 5856 c = STATE(lchild).getCost(2 /* r */) + 0; 5857 if(BURS.DEBUG) trace(p, 259, c + 0, p.getCost(16) /* address1reg */); 5858 if (c < p.getCost(16) /* address1reg */) { 5859 p.setCost(16 /* address1reg */, (char)(c)); 5860 p.writePacked(1, 0xE3FFFFFF, 0x4000000); // p.address1reg = 1 5861 closure_address1reg(p, c); 5862 } 5863 } 5864 // address: INT_ADD(r,r) 5865 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 5866 if(BURS.DEBUG) trace(p, 59, c + 0, p.getCost(17) /* address */); 5867 if (c < p.getCost(17) /* address */) { 5868 p.setCost(17 /* address */, (char)(c)); 5869 p.writePacked(2, 0xFFFFFFF0, 0x2); // p.address = 2 5870 } 5871 if ( // address1reg: INT_ADD(address1reg,LONG_CONSTANT) 5872 rchild.getOpcode() == LONG_CONSTANT_opcode 5873 ) { 5874 c = STATE(lchild).getCost(16 /* address1reg */) + 0; 5875 if(BURS.DEBUG) trace(p, 261, c + 0, p.getCost(16) /* address1reg */); 5876 if (c < p.getCost(16) /* address1reg */) { 5877 p.setCost(16 /* address1reg */, (char)(c)); 5878 p.writePacked(1, 0xE3FFFFFF, 0xC000000); // p.address1reg = 3 5879 closure_address1reg(p, c); 5880 } 5881 } 5882 if ( // address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) 5883 rchild.getOpcode() == LONG_CONSTANT_opcode 5884 ) { 5885 c = STATE(lchild).getCost(15 /* address1scaledreg */) + 0; 5886 if(BURS.DEBUG) trace(p, 262, c + 0, p.getCost(15) /* address1scaledreg */); 5887 if (c < p.getCost(15) /* address1scaledreg */) { 5888 p.setCost(15 /* address1scaledreg */, (char)(c)); 5889 p.writePacked(1, 0xFC7FFFFF, 0x1800000); // p.address1scaledreg = 3 5890 closure_address1scaledreg(p, c); 5891 } 5892 } 5893 // address: INT_ADD(r,address1scaledreg) 5894 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 0; 5895 if(BURS.DEBUG) trace(p, 60, c + 0, p.getCost(17) /* address */); 5896 if (c < p.getCost(17) /* address */) { 5897 p.setCost(17 /* address */, (char)(c)); 5898 p.writePacked(2, 0xFFFFFFF0, 0x3); // p.address = 3 5899 } 5900 // address: INT_ADD(address1scaledreg,r) 5901 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(2 /* r */) + 0; 5902 if(BURS.DEBUG) trace(p, 61, c + 0, p.getCost(17) /* address */); 5903 if (c < p.getCost(17) /* address */) { 5904 p.setCost(17 /* address */, (char)(c)); 5905 p.writePacked(2, 0xFFFFFFF0, 0x4); // p.address = 4 5906 } 5907 if ( // address: INT_ADD(address1scaledreg,LONG_CONSTANT) 5908 rchild.getOpcode() == LONG_CONSTANT_opcode 5909 ) { 5910 c = STATE(lchild).getCost(15 /* address1scaledreg */) + 0; 5911 if(BURS.DEBUG) trace(p, 263, c + 0, p.getCost(17) /* address */); 5912 if (c < p.getCost(17) /* address */) { 5913 p.setCost(17 /* address */, (char)(c)); 5914 p.writePacked(2, 0xFFFFFFF0, 0x5); // p.address = 5 5915 } 5916 } 5917 // address: INT_ADD(address1scaledreg,address1reg) 5918 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(16 /* address1reg */) + 0; 5919 if(BURS.DEBUG) trace(p, 62, c + 0, p.getCost(17) /* address */); 5920 if (c < p.getCost(17) /* address */) { 5921 p.setCost(17 /* address */, (char)(c)); 5922 p.writePacked(2, 0xFFFFFFF0, 0x6); // p.address = 6 5923 } 5924 // address: INT_ADD(address1reg,address1scaledreg) 5925 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 0; 5926 if(BURS.DEBUG) trace(p, 63, c + 0, p.getCost(17) /* address */); 5927 if (c < p.getCost(17) /* address */) { 5928 p.setCost(17 /* address */, (char)(c)); 5929 p.writePacked(2, 0xFFFFFFF0, 0x7); // p.address = 7 5930 } 5931 // czr: INT_ADD(r,riv) 5932 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 5933 if(BURS.DEBUG) trace(p, 81, c + 0, p.getCost(3) /* czr */); 5934 if (c < p.getCost(3) /* czr */) { 5935 p.setCost(3 /* czr */, (char)(c)); 5936 p.writePacked(0, 0xFFE1FFFF, 0x20000); // p.czr = 1 5937 closure_czr(p, c); 5938 } 5939 // r: INT_ADD(r,riv) 5940 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 11; 5941 if(BURS.DEBUG) trace(p, 82, c + 0, p.getCost(2) /* r */); 5942 if (c < p.getCost(2) /* r */) { 5943 p.setCost(2 /* r */, (char)(c)); 5944 p.writePacked(0, 0xFFFE00FF, 0x5800); // p.r = 88 5945 closure_r(p, c); 5946 } 5947 // czr: INT_ADD(r,load32) 5948 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 5949 if(BURS.DEBUG) trace(p, 83, c + 0, p.getCost(3) /* czr */); 5950 if (c < p.getCost(3) /* czr */) { 5951 p.setCost(3 /* czr */, (char)(c)); 5952 p.writePacked(0, 0xFFE1FFFF, 0x40000); // p.czr = 2 5953 closure_czr(p, c); 5954 } 5955 // czr: INT_ADD(load32,riv) 5956 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 5957 if(BURS.DEBUG) trace(p, 84, c + 0, p.getCost(3) /* czr */); 5958 if (c < p.getCost(3) /* czr */) { 5959 p.setCost(3 /* czr */, (char)(c)); 5960 p.writePacked(0, 0xFFE1FFFF, 0x60000); // p.czr = 3 5961 closure_czr(p, c); 5962 } 5963 } 5964 5965 /** 5966 * Labels LONG_ADD tree node 5967 * @param p node to label 5968 */ 5969 private static void label_LONG_ADD(AbstractBURS_TreeNode p) { 5970 p.initCost(); 5971 AbstractBURS_TreeNode lchild, rchild; 5972 lchild = p.getChild1(); 5973 rchild = p.getChild2(); 5974 label(lchild); 5975 label(rchild); 5976 int c; 5977 if ( // address1reg: LONG_ADD(r,LONG_CONSTANT) 5978 rchild.getOpcode() == LONG_CONSTANT_opcode 5979 ) { 5980 c = STATE(lchild).getCost(2 /* r */) + 0; 5981 if(BURS.DEBUG) trace(p, 265, c + 0, p.getCost(16) /* address1reg */); 5982 if (c < p.getCost(16) /* address1reg */) { 5983 p.setCost(16 /* address1reg */, (char)(c)); 5984 p.writePacked(1, 0xE3FFFFFF, 0x10000000); // p.address1reg = 4 5985 closure_address1reg(p, c); 5986 } 5987 } 5988 // address: LONG_ADD(r,r) 5989 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 5990 if(BURS.DEBUG) trace(p, 64, c + 0, p.getCost(17) /* address */); 5991 if (c < p.getCost(17) /* address */) { 5992 p.setCost(17 /* address */, (char)(c)); 5993 p.writePacked(2, 0xFFFFFFF0, 0x8); // p.address = 8 5994 } 5995 if ( // address1reg: LONG_ADD(address1reg,LONG_CONSTANT) 5996 rchild.getOpcode() == LONG_CONSTANT_opcode 5997 ) { 5998 c = STATE(lchild).getCost(16 /* address1reg */) + 0; 5999 if(BURS.DEBUG) trace(p, 267, c + 0, p.getCost(16) /* address1reg */); 6000 if (c < p.getCost(16) /* address1reg */) { 6001 p.setCost(16 /* address1reg */, (char)(c)); 6002 p.writePacked(1, 0xE3FFFFFF, 0x18000000); // p.address1reg = 6 6003 closure_address1reg(p, c); 6004 } 6005 } 6006 if ( // address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) 6007 rchild.getOpcode() == LONG_CONSTANT_opcode 6008 ) { 6009 c = STATE(lchild).getCost(15 /* address1scaledreg */) + 0; 6010 if(BURS.DEBUG) trace(p, 268, c + 0, p.getCost(15) /* address1scaledreg */); 6011 if (c < p.getCost(15) /* address1scaledreg */) { 6012 p.setCost(15 /* address1scaledreg */, (char)(c)); 6013 p.writePacked(1, 0xFC7FFFFF, 0x2800000); // p.address1scaledreg = 5 6014 closure_address1scaledreg(p, c); 6015 } 6016 } 6017 // address: LONG_ADD(r,address1scaledreg) 6018 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 0; 6019 if(BURS.DEBUG) trace(p, 65, c + 0, p.getCost(17) /* address */); 6020 if (c < p.getCost(17) /* address */) { 6021 p.setCost(17 /* address */, (char)(c)); 6022 p.writePacked(2, 0xFFFFFFF0, 0x9); // p.address = 9 6023 } 6024 // address: LONG_ADD(address1scaledreg,r) 6025 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(2 /* r */) + 0; 6026 if(BURS.DEBUG) trace(p, 66, c + 0, p.getCost(17) /* address */); 6027 if (c < p.getCost(17) /* address */) { 6028 p.setCost(17 /* address */, (char)(c)); 6029 p.writePacked(2, 0xFFFFFFF0, 0xA); // p.address = 10 6030 } 6031 if ( // address: LONG_ADD(address1scaledreg,LONG_CONSTANT) 6032 rchild.getOpcode() == LONG_CONSTANT_opcode 6033 ) { 6034 c = STATE(lchild).getCost(15 /* address1scaledreg */) + 0; 6035 if(BURS.DEBUG) trace(p, 269, c + 0, p.getCost(17) /* address */); 6036 if (c < p.getCost(17) /* address */) { 6037 p.setCost(17 /* address */, (char)(c)); 6038 p.writePacked(2, 0xFFFFFFF0, 0xB); // p.address = 11 6039 } 6040 } 6041 // address: LONG_ADD(address1scaledreg,address1reg) 6042 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(16 /* address1reg */) + 0; 6043 if(BURS.DEBUG) trace(p, 67, c + 0, p.getCost(17) /* address */); 6044 if (c < p.getCost(17) /* address */) { 6045 p.setCost(17 /* address */, (char)(c)); 6046 p.writePacked(2, 0xFFFFFFF0, 0xC); // p.address = 12 6047 } 6048 // address: LONG_ADD(address1reg,address1scaledreg) 6049 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 0; 6050 if(BURS.DEBUG) trace(p, 68, c + 0, p.getCost(17) /* address */); 6051 if (c < p.getCost(17) /* address */) { 6052 p.setCost(17 /* address */, (char)(c)); 6053 p.writePacked(2, 0xFFFFFFF0, 0xD); // p.address = 13 6054 } 6055 // r: LONG_ADD(address1scaledreg,r) 6056 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(2 /* r */) + 11; 6057 if(BURS.DEBUG) trace(p, 126, c + 0, p.getCost(2) /* r */); 6058 if (c < p.getCost(2) /* r */) { 6059 p.setCost(2 /* r */, (char)(c)); 6060 p.writePacked(0, 0xFFFE00FF, 0x7800); // p.r = 120 6061 closure_r(p, c); 6062 } 6063 // r: LONG_ADD(r,address1scaledreg) 6064 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 11; 6065 if(BURS.DEBUG) trace(p, 127, c + 0, p.getCost(2) /* r */); 6066 if (c < p.getCost(2) /* r */) { 6067 p.setCost(2 /* r */, (char)(c)); 6068 p.writePacked(0, 0xFFFE00FF, 0x7900); // p.r = 121 6069 closure_r(p, c); 6070 } 6071 // r: LONG_ADD(address1scaledreg,address1reg) 6072 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(16 /* address1reg */) + 11; 6073 if(BURS.DEBUG) trace(p, 128, c + 0, p.getCost(2) /* r */); 6074 if (c < p.getCost(2) /* r */) { 6075 p.setCost(2 /* r */, (char)(c)); 6076 p.writePacked(0, 0xFFFE00FF, 0x7A00); // p.r = 122 6077 closure_r(p, c); 6078 } 6079 // r: LONG_ADD(address1reg,address1scaledreg) 6080 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 11; 6081 if(BURS.DEBUG) trace(p, 129, c + 0, p.getCost(2) /* r */); 6082 if (c < p.getCost(2) /* r */) { 6083 p.setCost(2 /* r */, (char)(c)); 6084 p.writePacked(0, 0xFFFE00FF, 0x7B00); // p.r = 123 6085 closure_r(p, c); 6086 } 6087 if ( // r: LONG_ADD(address,LONG_CONSTANT) 6088 rchild.getOpcode() == LONG_CONSTANT_opcode 6089 ) { 6090 c = STATE(lchild).getCost(17 /* address */) + 11; 6091 if(BURS.DEBUG) trace(p, 336, c + 0, p.getCost(2) /* r */); 6092 if (c < p.getCost(2) /* r */) { 6093 p.setCost(2 /* r */, (char)(c)); 6094 p.writePacked(0, 0xFFFE00FF, 0x7C00); // p.r = 124 6095 closure_r(p, c); 6096 } 6097 } 6098 // czr: LONG_ADD(r,rlv) 6099 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 11; 6100 if(BURS.DEBUG) trace(p, 155, c + 0, p.getCost(3) /* czr */); 6101 if (c < p.getCost(3) /* czr */) { 6102 p.setCost(3 /* czr */, (char)(c)); 6103 p.writePacked(0, 0xFFE1FFFF, 0x100000); // p.czr = 8 6104 closure_czr(p, c); 6105 } 6106 // czr: LONG_ADD(r,riv) 6107 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 11; 6108 if(BURS.DEBUG) trace(p, 156, c + 0, p.getCost(3) /* czr */); 6109 if (c < p.getCost(3) /* czr */) { 6110 p.setCost(3 /* czr */, (char)(c)); 6111 p.writePacked(0, 0xFFE1FFFF, 0x120000); // p.czr = 9 6112 closure_czr(p, c); 6113 } 6114 // czr: LONG_ADD(r,r) 6115 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 9; 6116 if(BURS.DEBUG) trace(p, 157, c + 0, p.getCost(3) /* czr */); 6117 if (c < p.getCost(3) /* czr */) { 6118 p.setCost(3 /* czr */, (char)(c)); 6119 p.writePacked(0, 0xFFE1FFFF, 0x140000); // p.czr = 10 6120 closure_czr(p, c); 6121 } 6122 // r: LONG_ADD(r,rlv) 6123 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 6124 if(BURS.DEBUG) trace(p, 158, c + 0, p.getCost(2) /* r */); 6125 if (c < p.getCost(2) /* r */) { 6126 p.setCost(2 /* r */, (char)(c)); 6127 p.writePacked(0, 0xFFFE00FF, 0x9000); // p.r = 144 6128 closure_r(p, c); 6129 } 6130 // czr: LONG_ADD(rlv,load64) 6131 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 15; 6132 if(BURS.DEBUG) trace(p, 159, c + 0, p.getCost(3) /* czr */); 6133 if (c < p.getCost(3) /* czr */) { 6134 p.setCost(3 /* czr */, (char)(c)); 6135 p.writePacked(0, 0xFFE1FFFF, 0x160000); // p.czr = 11 6136 closure_czr(p, c); 6137 } 6138 // czr: LONG_ADD(load64,rlv) 6139 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 6140 if(BURS.DEBUG) trace(p, 160, c + 0, p.getCost(3) /* czr */); 6141 if (c < p.getCost(3) /* czr */) { 6142 p.setCost(3 /* czr */, (char)(c)); 6143 p.writePacked(0, 0xFFE1FFFF, 0x180000); // p.czr = 12 6144 closure_czr(p, c); 6145 } 6146 } 6147 6148 /** 6149 * Labels FLOAT_ADD tree node 6150 * @param p node to label 6151 */ 6152 private static void label_FLOAT_ADD(AbstractBURS_TreeNode p) { 6153 p.initCost(); 6154 AbstractBURS_TreeNode lchild, rchild; 6155 lchild = p.getChild1(); 6156 rchild = p.getChild2(); 6157 label(lchild); 6158 label(rchild); 6159 int c; 6160 // r: FLOAT_ADD(r,r) 6161 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6162 if(BURS.DEBUG) trace(p, 203, c + 0, p.getCost(2) /* r */); 6163 if (c < p.getCost(2) /* r */) { 6164 p.setCost(2 /* r */, (char)(c)); 6165 p.writePacked(0, 0xFFFE00FF, 0xAC00); // p.r = 172 6166 closure_r(p, c); 6167 } 6168 // r: FLOAT_ADD(r,float_load) 6169 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* float_load */) + 15; 6170 if(BURS.DEBUG) trace(p, 204, c + 0, p.getCost(2) /* r */); 6171 if (c < p.getCost(2) /* r */) { 6172 p.setCost(2 /* r */, (char)(c)); 6173 p.writePacked(0, 0xFFFE00FF, 0xAD00); // p.r = 173 6174 closure_r(p, c); 6175 } 6176 // r: FLOAT_ADD(float_load,r) 6177 c = STATE(lchild).getCost(26 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 6178 if(BURS.DEBUG) trace(p, 205, c + 0, p.getCost(2) /* r */); 6179 if (c < p.getCost(2) /* r */) { 6180 p.setCost(2 /* r */, (char)(c)); 6181 p.writePacked(0, 0xFFFE00FF, 0xAE00); // p.r = 174 6182 closure_r(p, c); 6183 } 6184 } 6185 6186 /** 6187 * Labels DOUBLE_ADD tree node 6188 * @param p node to label 6189 */ 6190 private static void label_DOUBLE_ADD(AbstractBURS_TreeNode p) { 6191 p.initCost(); 6192 AbstractBURS_TreeNode lchild, rchild; 6193 lchild = p.getChild1(); 6194 rchild = p.getChild2(); 6195 label(lchild); 6196 label(rchild); 6197 int c; 6198 // r: DOUBLE_ADD(r,r) 6199 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6200 if(BURS.DEBUG) trace(p, 206, c + 0, p.getCost(2) /* r */); 6201 if (c < p.getCost(2) /* r */) { 6202 p.setCost(2 /* r */, (char)(c)); 6203 p.writePacked(0, 0xFFFE00FF, 0xAF00); // p.r = 175 6204 closure_r(p, c); 6205 } 6206 // r: DOUBLE_ADD(r,double_load) 6207 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(27 /* double_load */) + 15; 6208 if(BURS.DEBUG) trace(p, 207, c + 0, p.getCost(2) /* r */); 6209 if (c < p.getCost(2) /* r */) { 6210 p.setCost(2 /* r */, (char)(c)); 6211 p.writePacked(0, 0xFFFE00FF, 0xB000); // p.r = 176 6212 closure_r(p, c); 6213 } 6214 // r: DOUBLE_ADD(double_load,r) 6215 c = STATE(lchild).getCost(27 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 6216 if(BURS.DEBUG) trace(p, 208, c + 0, p.getCost(2) /* r */); 6217 if (c < p.getCost(2) /* r */) { 6218 p.setCost(2 /* r */, (char)(c)); 6219 p.writePacked(0, 0xFFFE00FF, 0xB100); // p.r = 177 6220 closure_r(p, c); 6221 } 6222 } 6223 6224 /** 6225 * Labels INT_SUB tree node 6226 * @param p node to label 6227 */ 6228 private static void label_INT_SUB(AbstractBURS_TreeNode p) { 6229 p.initCost(); 6230 AbstractBURS_TreeNode lchild, rchild; 6231 lchild = p.getChild1(); 6232 rchild = p.getChild2(); 6233 label(lchild); 6234 label(rchild); 6235 int c; 6236 // czr: INT_SUB(riv,r) 6237 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 13; 6238 if(BURS.DEBUG) trace(p, 117, c + 0, p.getCost(3) /* czr */); 6239 if (c < p.getCost(3) /* czr */) { 6240 p.setCost(3 /* czr */, (char)(c)); 6241 p.writePacked(0, 0xFFE1FFFF, 0xA0000); // p.czr = 5 6242 closure_czr(p, c); 6243 } 6244 // r: INT_SUB(riv,r) 6245 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 13-2 : INFINITE); 6246 if(BURS.DEBUG) trace(p, 118, c + 0, p.getCost(2) /* r */); 6247 if (c < p.getCost(2) /* r */) { 6248 p.setCost(2 /* r */, (char)(c)); 6249 p.writePacked(0, 0xFFFE00FF, 0x7200); // p.r = 114 6250 closure_r(p, c); 6251 } 6252 // r: INT_SUB(load32,r) 6253 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 15-2 : INFINITE); 6254 if(BURS.DEBUG) trace(p, 119, c + 0, p.getCost(2) /* r */); 6255 if (c < p.getCost(2) /* r */) { 6256 p.setCost(2 /* r */, (char)(c)); 6257 p.writePacked(0, 0xFFFE00FF, 0x7300); // p.r = 115 6258 closure_r(p, c); 6259 } 6260 // czr: INT_SUB(riv,load32) 6261 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 6262 if(BURS.DEBUG) trace(p, 120, c + 0, p.getCost(3) /* czr */); 6263 if (c < p.getCost(3) /* czr */) { 6264 p.setCost(3 /* czr */, (char)(c)); 6265 p.writePacked(0, 0xFFE1FFFF, 0xC0000); // p.czr = 6 6266 closure_czr(p, c); 6267 } 6268 // czr: INT_SUB(load32,riv) 6269 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 6270 if(BURS.DEBUG) trace(p, 121, c + 0, p.getCost(3) /* czr */); 6271 if (c < p.getCost(3) /* czr */) { 6272 p.setCost(3 /* czr */, (char)(c)); 6273 p.writePacked(0, 0xFFE1FFFF, 0xE0000); // p.czr = 7 6274 closure_czr(p, c); 6275 } 6276 } 6277 6278 /** 6279 * Labels LONG_SUB tree node 6280 * @param p node to label 6281 */ 6282 private static void label_LONG_SUB(AbstractBURS_TreeNode p) { 6283 p.initCost(); 6284 AbstractBURS_TreeNode lchild, rchild; 6285 lchild = p.getChild1(); 6286 rchild = p.getChild2(); 6287 label(lchild); 6288 label(rchild); 6289 int c; 6290 // czr: LONG_SUB(rlv,r) 6291 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + 13; 6292 if(BURS.DEBUG) trace(p, 194, c + 0, p.getCost(3) /* czr */); 6293 if (c < p.getCost(3) /* czr */) { 6294 p.setCost(3 /* czr */, (char)(c)); 6295 p.writePacked(0, 0xFFE1FFFF, 0x1A0000); // p.czr = 13 6296 closure_czr(p, c); 6297 } 6298 // r: LONG_SUB(rlv,r) 6299 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 13-2 : INFINITE); 6300 if(BURS.DEBUG) trace(p, 195, c + 0, p.getCost(2) /* r */); 6301 if (c < p.getCost(2) /* r */) { 6302 p.setCost(2 /* r */, (char)(c)); 6303 p.writePacked(0, 0xFFFE00FF, 0xAA00); // p.r = 170 6304 closure_r(p, c); 6305 } 6306 // r: LONG_SUB(load64,r) 6307 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 15-2 : INFINITE); 6308 if(BURS.DEBUG) trace(p, 196, c + 0, p.getCost(2) /* r */); 6309 if (c < p.getCost(2) /* r */) { 6310 p.setCost(2 /* r */, (char)(c)); 6311 p.writePacked(0, 0xFFFE00FF, 0xAB00); // p.r = 171 6312 closure_r(p, c); 6313 } 6314 // czr: LONG_SUB(rlv,load64) 6315 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 15; 6316 if(BURS.DEBUG) trace(p, 197, c + 0, p.getCost(3) /* czr */); 6317 if (c < p.getCost(3) /* czr */) { 6318 p.setCost(3 /* czr */, (char)(c)); 6319 p.writePacked(0, 0xFFE1FFFF, 0x1C0000); // p.czr = 14 6320 closure_czr(p, c); 6321 } 6322 // czr: LONG_SUB(load64,rlv) 6323 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 6324 if(BURS.DEBUG) trace(p, 198, c + 0, p.getCost(3) /* czr */); 6325 if (c < p.getCost(3) /* czr */) { 6326 p.setCost(3 /* czr */, (char)(c)); 6327 p.writePacked(0, 0xFFE1FFFF, 0x1E0000); // p.czr = 15 6328 closure_czr(p, c); 6329 } 6330 } 6331 6332 /** 6333 * Labels FLOAT_SUB tree node 6334 * @param p node to label 6335 */ 6336 private static void label_FLOAT_SUB(AbstractBURS_TreeNode p) { 6337 p.initCost(); 6338 AbstractBURS_TreeNode lchild, rchild; 6339 lchild = p.getChild1(); 6340 rchild = p.getChild2(); 6341 label(lchild); 6342 label(rchild); 6343 int c; 6344 // r: FLOAT_SUB(r,r) 6345 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6346 if(BURS.DEBUG) trace(p, 209, c + 0, p.getCost(2) /* r */); 6347 if (c < p.getCost(2) /* r */) { 6348 p.setCost(2 /* r */, (char)(c)); 6349 p.writePacked(0, 0xFFFE00FF, 0xB200); // p.r = 178 6350 closure_r(p, c); 6351 } 6352 // r: FLOAT_SUB(r,float_load) 6353 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* float_load */) + 15; 6354 if(BURS.DEBUG) trace(p, 210, c + 0, p.getCost(2) /* r */); 6355 if (c < p.getCost(2) /* r */) { 6356 p.setCost(2 /* r */, (char)(c)); 6357 p.writePacked(0, 0xFFFE00FF, 0xB300); // p.r = 179 6358 closure_r(p, c); 6359 } 6360 } 6361 6362 /** 6363 * Labels DOUBLE_SUB tree node 6364 * @param p node to label 6365 */ 6366 private static void label_DOUBLE_SUB(AbstractBURS_TreeNode p) { 6367 p.initCost(); 6368 AbstractBURS_TreeNode lchild, rchild; 6369 lchild = p.getChild1(); 6370 rchild = p.getChild2(); 6371 label(lchild); 6372 label(rchild); 6373 int c; 6374 // r: DOUBLE_SUB(r,r) 6375 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6376 if(BURS.DEBUG) trace(p, 211, c + 0, p.getCost(2) /* r */); 6377 if (c < p.getCost(2) /* r */) { 6378 p.setCost(2 /* r */, (char)(c)); 6379 p.writePacked(0, 0xFFFE00FF, 0xB400); // p.r = 180 6380 closure_r(p, c); 6381 } 6382 // r: DOUBLE_SUB(r,double_load) 6383 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(27 /* double_load */) + 15; 6384 if(BURS.DEBUG) trace(p, 212, c + 0, p.getCost(2) /* r */); 6385 if (c < p.getCost(2) /* r */) { 6386 p.setCost(2 /* r */, (char)(c)); 6387 p.writePacked(0, 0xFFFE00FF, 0xB500); // p.r = 181 6388 closure_r(p, c); 6389 } 6390 } 6391 6392 /** 6393 * Labels INT_MUL tree node 6394 * @param p node to label 6395 */ 6396 private static void label_INT_MUL(AbstractBURS_TreeNode p) { 6397 p.initCost(); 6398 AbstractBURS_TreeNode lchild, rchild; 6399 lchild = p.getChild1(); 6400 rchild = p.getChild2(); 6401 label(lchild); 6402 label(rchild); 6403 int c; 6404 // r: INT_MUL(r,riv) 6405 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 6406 if(BURS.DEBUG) trace(p, 107, c + 0, p.getCost(2) /* r */); 6407 if (c < p.getCost(2) /* r */) { 6408 p.setCost(2 /* r */, (char)(c)); 6409 p.writePacked(0, 0xFFFE00FF, 0x6300); // p.r = 99 6410 closure_r(p, c); 6411 } 6412 // r: INT_MUL(r,load32) 6413 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 6414 if(BURS.DEBUG) trace(p, 108, c + 0, p.getCost(2) /* r */); 6415 if (c < p.getCost(2) /* r */) { 6416 p.setCost(2 /* r */, (char)(c)); 6417 p.writePacked(0, 0xFFFE00FF, 0x6400); // p.r = 100 6418 closure_r(p, c); 6419 } 6420 // r: INT_MUL(load32,riv) 6421 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 6422 if(BURS.DEBUG) trace(p, 109, c + 0, p.getCost(2) /* r */); 6423 if (c < p.getCost(2) /* r */) { 6424 p.setCost(2 /* r */, (char)(c)); 6425 p.writePacked(0, 0xFFFE00FF, 0x6500); // p.r = 101 6426 closure_r(p, c); 6427 } 6428 // r: INT_MUL(r,load64) 6429 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(20 /* load64 */) + 15; 6430 if(BURS.DEBUG) trace(p, 182, c + 0, p.getCost(2) /* r */); 6431 if (c < p.getCost(2) /* r */) { 6432 p.setCost(2 /* r */, (char)(c)); 6433 p.writePacked(0, 0xFFFE00FF, 0xA100); // p.r = 161 6434 closure_r(p, c); 6435 } 6436 // r: INT_MUL(load64,rlv) 6437 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 6438 if(BURS.DEBUG) trace(p, 183, c + 0, p.getCost(2) /* r */); 6439 if (c < p.getCost(2) /* r */) { 6440 p.setCost(2 /* r */, (char)(c)); 6441 p.writePacked(0, 0xFFFE00FF, 0xA200); // p.r = 162 6442 closure_r(p, c); 6443 } 6444 } 6445 6446 /** 6447 * Labels LONG_MUL tree node 6448 * @param p node to label 6449 */ 6450 private static void label_LONG_MUL(AbstractBURS_TreeNode p) { 6451 p.initCost(); 6452 AbstractBURS_TreeNode lchild, rchild; 6453 lchild = p.getChild1(); 6454 rchild = p.getChild2(); 6455 label(lchild); 6456 label(rchild); 6457 int c; 6458 // r: LONG_MUL(r,rlv) 6459 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 6460 if(BURS.DEBUG) trace(p, 181, c + 0, p.getCost(2) /* r */); 6461 if (c < p.getCost(2) /* r */) { 6462 p.setCost(2 /* r */, (char)(c)); 6463 p.writePacked(0, 0xFFFE00FF, 0xA000); // p.r = 160 6464 closure_r(p, c); 6465 } 6466 } 6467 6468 /** 6469 * Labels FLOAT_MUL tree node 6470 * @param p node to label 6471 */ 6472 private static void label_FLOAT_MUL(AbstractBURS_TreeNode p) { 6473 p.initCost(); 6474 AbstractBURS_TreeNode lchild, rchild; 6475 lchild = p.getChild1(); 6476 rchild = p.getChild2(); 6477 label(lchild); 6478 label(rchild); 6479 int c; 6480 // r: FLOAT_MUL(r,r) 6481 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6482 if(BURS.DEBUG) trace(p, 213, c + 0, p.getCost(2) /* r */); 6483 if (c < p.getCost(2) /* r */) { 6484 p.setCost(2 /* r */, (char)(c)); 6485 p.writePacked(0, 0xFFFE00FF, 0xB600); // p.r = 182 6486 closure_r(p, c); 6487 } 6488 // r: FLOAT_MUL(r,float_load) 6489 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* float_load */) + 15; 6490 if(BURS.DEBUG) trace(p, 214, c + 0, p.getCost(2) /* r */); 6491 if (c < p.getCost(2) /* r */) { 6492 p.setCost(2 /* r */, (char)(c)); 6493 p.writePacked(0, 0xFFFE00FF, 0xB700); // p.r = 183 6494 closure_r(p, c); 6495 } 6496 // r: FLOAT_MUL(float_load,r) 6497 c = STATE(lchild).getCost(26 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 6498 if(BURS.DEBUG) trace(p, 215, c + 0, p.getCost(2) /* r */); 6499 if (c < p.getCost(2) /* r */) { 6500 p.setCost(2 /* r */, (char)(c)); 6501 p.writePacked(0, 0xFFFE00FF, 0xB800); // p.r = 184 6502 closure_r(p, c); 6503 } 6504 } 6505 6506 /** 6507 * Labels DOUBLE_MUL tree node 6508 * @param p node to label 6509 */ 6510 private static void label_DOUBLE_MUL(AbstractBURS_TreeNode p) { 6511 p.initCost(); 6512 AbstractBURS_TreeNode lchild, rchild; 6513 lchild = p.getChild1(); 6514 rchild = p.getChild2(); 6515 label(lchild); 6516 label(rchild); 6517 int c; 6518 // r: DOUBLE_MUL(r,r) 6519 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6520 if(BURS.DEBUG) trace(p, 216, c + 0, p.getCost(2) /* r */); 6521 if (c < p.getCost(2) /* r */) { 6522 p.setCost(2 /* r */, (char)(c)); 6523 p.writePacked(0, 0xFFFE00FF, 0xB900); // p.r = 185 6524 closure_r(p, c); 6525 } 6526 // r: DOUBLE_MUL(r,double_load) 6527 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(27 /* double_load */) + 15; 6528 if(BURS.DEBUG) trace(p, 217, c + 0, p.getCost(2) /* r */); 6529 if (c < p.getCost(2) /* r */) { 6530 p.setCost(2 /* r */, (char)(c)); 6531 p.writePacked(0, 0xFFFE00FF, 0xBA00); // p.r = 186 6532 closure_r(p, c); 6533 } 6534 // r: DOUBLE_MUL(double_load,r) 6535 c = STATE(lchild).getCost(27 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 6536 if(BURS.DEBUG) trace(p, 218, c + 0, p.getCost(2) /* r */); 6537 if (c < p.getCost(2) /* r */) { 6538 p.setCost(2 /* r */, (char)(c)); 6539 p.writePacked(0, 0xFFFE00FF, 0xBB00); // p.r = 187 6540 closure_r(p, c); 6541 } 6542 } 6543 6544 /** 6545 * Labels INT_DIV tree node 6546 * @param p node to label 6547 */ 6548 private static void label_INT_DIV(AbstractBURS_TreeNode p) { 6549 p.initCost(); 6550 AbstractBURS_TreeNode lchild, rchild; 6551 lchild = p.getChild1(); 6552 rchild = p.getChild2(); 6553 label(lchild); 6554 label(rchild); 6555 int c; 6556 // r: INT_DIV(riv,riv) 6557 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 52; 6558 if(BURS.DEBUG) trace(p, 91, c + 0, p.getCost(2) /* r */); 6559 if (c < p.getCost(2) /* r */) { 6560 p.setCost(2 /* r */, (char)(c)); 6561 p.writePacked(0, 0xFFFE00FF, 0x5900); // p.r = 89 6562 closure_r(p, c); 6563 } 6564 // r: INT_DIV(riv,load32) 6565 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 55; 6566 if(BURS.DEBUG) trace(p, 92, c + 0, p.getCost(2) /* r */); 6567 if (c < p.getCost(2) /* r */) { 6568 p.setCost(2 /* r */, (char)(c)); 6569 p.writePacked(0, 0xFFFE00FF, 0x5A00); // p.r = 90 6570 closure_r(p, c); 6571 } 6572 } 6573 6574 /** 6575 * Labels LONG_DIV tree node 6576 * @param p node to label 6577 */ 6578 private static void label_LONG_DIV(AbstractBURS_TreeNode p) { 6579 p.initCost(); 6580 AbstractBURS_TreeNode lchild, rchild; 6581 lchild = p.getChild1(); 6582 rchild = p.getChild2(); 6583 label(lchild); 6584 label(rchild); 6585 int c; 6586 // r: LONG_DIV(rlv,rlv) 6587 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 52; 6588 if(BURS.DEBUG) trace(p, 168, c + 0, p.getCost(2) /* r */); 6589 if (c < p.getCost(2) /* r */) { 6590 p.setCost(2 /* r */, (char)(c)); 6591 p.writePacked(0, 0xFFFE00FF, 0x9100); // p.r = 145 6592 closure_r(p, c); 6593 } 6594 // r: LONG_DIV(rlv,riv) 6595 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 52; 6596 if(BURS.DEBUG) trace(p, 169, c + 0, p.getCost(2) /* r */); 6597 if (c < p.getCost(2) /* r */) { 6598 p.setCost(2 /* r */, (char)(c)); 6599 p.writePacked(0, 0xFFFE00FF, 0x9200); // p.r = 146 6600 closure_r(p, c); 6601 } 6602 // r: LONG_DIV(riv,rlv) 6603 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(8 /* rlv */) + 52; 6604 if(BURS.DEBUG) trace(p, 170, c + 0, p.getCost(2) /* r */); 6605 if (c < p.getCost(2) /* r */) { 6606 p.setCost(2 /* r */, (char)(c)); 6607 p.writePacked(0, 0xFFFE00FF, 0x9300); // p.r = 147 6608 closure_r(p, c); 6609 } 6610 // r: LONG_DIV(rlv,load64) 6611 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 55; 6612 if(BURS.DEBUG) trace(p, 171, c + 0, p.getCost(2) /* r */); 6613 if (c < p.getCost(2) /* r */) { 6614 p.setCost(2 /* r */, (char)(c)); 6615 p.writePacked(0, 0xFFFE00FF, 0x9400); // p.r = 148 6616 closure_r(p, c); 6617 } 6618 // r: LONG_DIV(load64,rlv) 6619 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 55; 6620 if(BURS.DEBUG) trace(p, 172, c + 0, p.getCost(2) /* r */); 6621 if (c < p.getCost(2) /* r */) { 6622 p.setCost(2 /* r */, (char)(c)); 6623 p.writePacked(0, 0xFFFE00FF, 0x9500); // p.r = 149 6624 closure_r(p, c); 6625 } 6626 } 6627 6628 /** 6629 * Labels FLOAT_DIV tree node 6630 * @param p node to label 6631 */ 6632 private static void label_FLOAT_DIV(AbstractBURS_TreeNode p) { 6633 p.initCost(); 6634 AbstractBURS_TreeNode lchild, rchild; 6635 lchild = p.getChild1(); 6636 rchild = p.getChild2(); 6637 label(lchild); 6638 label(rchild); 6639 int c; 6640 // r: FLOAT_DIV(r,r) 6641 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6642 if(BURS.DEBUG) trace(p, 219, c + 0, p.getCost(2) /* r */); 6643 if (c < p.getCost(2) /* r */) { 6644 p.setCost(2 /* r */, (char)(c)); 6645 p.writePacked(0, 0xFFFE00FF, 0xBC00); // p.r = 188 6646 closure_r(p, c); 6647 } 6648 // r: FLOAT_DIV(r,float_load) 6649 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* float_load */) + 15; 6650 if(BURS.DEBUG) trace(p, 220, c + 0, p.getCost(2) /* r */); 6651 if (c < p.getCost(2) /* r */) { 6652 p.setCost(2 /* r */, (char)(c)); 6653 p.writePacked(0, 0xFFFE00FF, 0xBD00); // p.r = 189 6654 closure_r(p, c); 6655 } 6656 } 6657 6658 /** 6659 * Labels DOUBLE_DIV tree node 6660 * @param p node to label 6661 */ 6662 private static void label_DOUBLE_DIV(AbstractBURS_TreeNode p) { 6663 p.initCost(); 6664 AbstractBURS_TreeNode lchild, rchild; 6665 lchild = p.getChild1(); 6666 rchild = p.getChild2(); 6667 label(lchild); 6668 label(rchild); 6669 int c; 6670 // r: DOUBLE_DIV(r,r) 6671 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6672 if(BURS.DEBUG) trace(p, 221, c + 0, p.getCost(2) /* r */); 6673 if (c < p.getCost(2) /* r */) { 6674 p.setCost(2 /* r */, (char)(c)); 6675 p.writePacked(0, 0xFFFE00FF, 0xBE00); // p.r = 190 6676 closure_r(p, c); 6677 } 6678 // r: DOUBLE_DIV(r,double_load) 6679 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(27 /* double_load */) + 15; 6680 if(BURS.DEBUG) trace(p, 222, c + 0, p.getCost(2) /* r */); 6681 if (c < p.getCost(2) /* r */) { 6682 p.setCost(2 /* r */, (char)(c)); 6683 p.writePacked(0, 0xFFFE00FF, 0xBF00); // p.r = 191 6684 closure_r(p, c); 6685 } 6686 } 6687 6688 /** 6689 * Labels INT_REM tree node 6690 * @param p node to label 6691 */ 6692 private static void label_INT_REM(AbstractBURS_TreeNode p) { 6693 p.initCost(); 6694 AbstractBURS_TreeNode lchild, rchild; 6695 lchild = p.getChild1(); 6696 rchild = p.getChild2(); 6697 label(lchild); 6698 label(rchild); 6699 int c; 6700 // r: INT_REM(riv,riv) 6701 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 52; 6702 if(BURS.DEBUG) trace(p, 113, c + 0, p.getCost(2) /* r */); 6703 if (c < p.getCost(2) /* r */) { 6704 p.setCost(2 /* r */, (char)(c)); 6705 p.writePacked(0, 0xFFFE00FF, 0x6700); // p.r = 103 6706 closure_r(p, c); 6707 } 6708 // r: INT_REM(riv,load32) 6709 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 55; 6710 if(BURS.DEBUG) trace(p, 114, c + 0, p.getCost(2) /* r */); 6711 if (c < p.getCost(2) /* r */) { 6712 p.setCost(2 /* r */, (char)(c)); 6713 p.writePacked(0, 0xFFFE00FF, 0x6800); // p.r = 104 6714 closure_r(p, c); 6715 } 6716 } 6717 6718 /** 6719 * Labels LONG_REM tree node 6720 * @param p node to label 6721 */ 6722 private static void label_LONG_REM(AbstractBURS_TreeNode p) { 6723 p.initCost(); 6724 AbstractBURS_TreeNode lchild, rchild; 6725 lchild = p.getChild1(); 6726 rchild = p.getChild2(); 6727 label(lchild); 6728 label(rchild); 6729 int c; 6730 // r: LONG_REM(rlv,rlv) 6731 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 52; 6732 if(BURS.DEBUG) trace(p, 187, c + 0, p.getCost(2) /* r */); 6733 if (c < p.getCost(2) /* r */) { 6734 p.setCost(2 /* r */, (char)(c)); 6735 p.writePacked(0, 0xFFFE00FF, 0xA400); // p.r = 164 6736 closure_r(p, c); 6737 } 6738 // r: LONG_REM(rlv,riv) 6739 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 52; 6740 if(BURS.DEBUG) trace(p, 188, c + 0, p.getCost(2) /* r */); 6741 if (c < p.getCost(2) /* r */) { 6742 p.setCost(2 /* r */, (char)(c)); 6743 p.writePacked(0, 0xFFFE00FF, 0xA500); // p.r = 165 6744 closure_r(p, c); 6745 } 6746 // r: LONG_REM(riv,rlv) 6747 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(8 /* rlv */) + 52; 6748 if(BURS.DEBUG) trace(p, 189, c + 0, p.getCost(2) /* r */); 6749 if (c < p.getCost(2) /* r */) { 6750 p.setCost(2 /* r */, (char)(c)); 6751 p.writePacked(0, 0xFFFE00FF, 0xA600); // p.r = 166 6752 closure_r(p, c); 6753 } 6754 // r: LONG_REM(rlv,load64) 6755 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 55; 6756 if(BURS.DEBUG) trace(p, 190, c + 0, p.getCost(2) /* r */); 6757 if (c < p.getCost(2) /* r */) { 6758 p.setCost(2 /* r */, (char)(c)); 6759 p.writePacked(0, 0xFFFE00FF, 0xA700); // p.r = 167 6760 closure_r(p, c); 6761 } 6762 // r: LONG_REM(load64,rlv) 6763 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 55; 6764 if(BURS.DEBUG) trace(p, 191, c + 0, p.getCost(2) /* r */); 6765 if (c < p.getCost(2) /* r */) { 6766 p.setCost(2 /* r */, (char)(c)); 6767 p.writePacked(0, 0xFFFE00FF, 0xA800); // p.r = 168 6768 closure_r(p, c); 6769 } 6770 } 6771 6772 /** 6773 * Labels FLOAT_REM tree node 6774 * @param p node to label 6775 */ 6776 private static void label_FLOAT_REM(AbstractBURS_TreeNode p) { 6777 p.initCost(); 6778 AbstractBURS_TreeNode lchild, rchild; 6779 lchild = p.getChild1(); 6780 rchild = p.getChild2(); 6781 label(lchild); 6782 label(rchild); 6783 int c; 6784 // r: FLOAT_REM(r,r) 6785 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6786 if(BURS.DEBUG) trace(p, 223, c + 0, p.getCost(2) /* r */); 6787 if (c < p.getCost(2) /* r */) { 6788 p.setCost(2 /* r */, (char)(c)); 6789 p.writePacked(0, 0xFFFE00FF, 0xC400); // p.r = 196 6790 closure_r(p, c); 6791 } 6792 } 6793 6794 /** 6795 * Labels DOUBLE_REM tree node 6796 * @param p node to label 6797 */ 6798 private static void label_DOUBLE_REM(AbstractBURS_TreeNode p) { 6799 p.initCost(); 6800 AbstractBURS_TreeNode lchild, rchild; 6801 lchild = p.getChild1(); 6802 rchild = p.getChild2(); 6803 label(lchild); 6804 label(rchild); 6805 int c; 6806 // r: DOUBLE_REM(r,r) 6807 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 6808 if(BURS.DEBUG) trace(p, 224, c + 0, p.getCost(2) /* r */); 6809 if (c < p.getCost(2) /* r */) { 6810 p.setCost(2 /* r */, (char)(c)); 6811 p.writePacked(0, 0xFFFE00FF, 0xC500); // p.r = 197 6812 closure_r(p, c); 6813 } 6814 } 6815 6816 /** 6817 * Labels INT_NEG tree node 6818 * @param p node to label 6819 */ 6820 private static void label_INT_NEG(AbstractBURS_TreeNode p) { 6821 p.initCost(); 6822 AbstractBURS_TreeNode lchild; 6823 lchild = p.getChild1(); 6824 label(lchild); 6825 int c; 6826 // szpr: INT_NEG(r) 6827 c = STATE(lchild).getCost(2 /* r */) + 13; 6828 if(BURS.DEBUG) trace(p, 330, c + 0, p.getCost(5) /* szpr */); 6829 if (c < p.getCost(5) /* szpr */) { 6830 p.setCost(5 /* szpr */, (char)(c)); 6831 p.writePacked(0, 0xE07FFFFF, 0x3000000); // p.szpr = 6 6832 closure_szpr(p, c); 6833 } 6834 } 6835 6836 /** 6837 * Labels LONG_NEG tree node 6838 * @param p node to label 6839 */ 6840 private static void label_LONG_NEG(AbstractBURS_TreeNode p) { 6841 p.initCost(); 6842 AbstractBURS_TreeNode lchild; 6843 lchild = p.getChild1(); 6844 label(lchild); 6845 int c; 6846 // szpr: LONG_NEG(r) 6847 c = STATE(lchild).getCost(2 /* r */) + 13; 6848 if(BURS.DEBUG) trace(p, 346, c + 0, p.getCost(5) /* szpr */); 6849 if (c < p.getCost(5) /* szpr */) { 6850 p.setCost(5 /* szpr */, (char)(c)); 6851 p.writePacked(0, 0xE07FFFFF, 0xD800000); // p.szpr = 27 6852 closure_szpr(p, c); 6853 } 6854 } 6855 6856 /** 6857 * Labels FLOAT_NEG tree node 6858 * @param p node to label 6859 */ 6860 private static void label_FLOAT_NEG(AbstractBURS_TreeNode p) { 6861 p.initCost(); 6862 AbstractBURS_TreeNode lchild; 6863 lchild = p.getChild1(); 6864 label(lchild); 6865 int c; 6866 // r: FLOAT_NEG(r) 6867 c = STATE(lchild).getCost(2 /* r */) + 26; 6868 if(BURS.DEBUG) trace(p, 352, c + 0, p.getCost(2) /* r */); 6869 if (c < p.getCost(2) /* r */) { 6870 p.setCost(2 /* r */, (char)(c)); 6871 p.writePacked(0, 0xFFFE00FF, 0xC000); // p.r = 192 6872 closure_r(p, c); 6873 } 6874 } 6875 6876 /** 6877 * Labels DOUBLE_NEG tree node 6878 * @param p node to label 6879 */ 6880 private static void label_DOUBLE_NEG(AbstractBURS_TreeNode p) { 6881 p.initCost(); 6882 AbstractBURS_TreeNode lchild; 6883 lchild = p.getChild1(); 6884 label(lchild); 6885 int c; 6886 // r: DOUBLE_NEG(r) 6887 c = STATE(lchild).getCost(2 /* r */) + 26; 6888 if(BURS.DEBUG) trace(p, 353, c + 0, p.getCost(2) /* r */); 6889 if (c < p.getCost(2) /* r */) { 6890 p.setCost(2 /* r */, (char)(c)); 6891 p.writePacked(0, 0xFFFE00FF, 0xC100); // p.r = 193 6892 closure_r(p, c); 6893 } 6894 } 6895 6896 /** 6897 * Labels FLOAT_SQRT tree node 6898 * @param p node to label 6899 */ 6900 private static void label_FLOAT_SQRT(AbstractBURS_TreeNode p) { 6901 p.initCost(); 6902 AbstractBURS_TreeNode lchild; 6903 lchild = p.getChild1(); 6904 label(lchild); 6905 int c; 6906 // r: FLOAT_SQRT(r) 6907 c = STATE(lchild).getCost(2 /* r */) + 13; 6908 if(BURS.DEBUG) trace(p, 354, c + 0, p.getCost(2) /* r */); 6909 if (c < p.getCost(2) /* r */) { 6910 p.setCost(2 /* r */, (char)(c)); 6911 p.writePacked(0, 0xFFFE00FF, 0xC200); // p.r = 194 6912 closure_r(p, c); 6913 } 6914 } 6915 6916 /** 6917 * Labels DOUBLE_SQRT tree node 6918 * @param p node to label 6919 */ 6920 private static void label_DOUBLE_SQRT(AbstractBURS_TreeNode p) { 6921 p.initCost(); 6922 AbstractBURS_TreeNode lchild; 6923 lchild = p.getChild1(); 6924 label(lchild); 6925 int c; 6926 // r: DOUBLE_SQRT(r) 6927 c = STATE(lchild).getCost(2 /* r */) + 13; 6928 if(BURS.DEBUG) trace(p, 355, c + 0, p.getCost(2) /* r */); 6929 if (c < p.getCost(2) /* r */) { 6930 p.setCost(2 /* r */, (char)(c)); 6931 p.writePacked(0, 0xFFFE00FF, 0xC300); // p.r = 195 6932 closure_r(p, c); 6933 } 6934 } 6935 6936 /** 6937 * Labels INT_SHL tree node 6938 * @param p node to label 6939 */ 6940 private static void label_INT_SHL(AbstractBURS_TreeNode p) { 6941 p.initCost(); 6942 AbstractBURS_TreeNode lchild, rchild; 6943 lchild = p.getChild1(); 6944 rchild = p.getChild2(); 6945 label(lchild); 6946 label(rchild); 6947 int c; 6948 if ( // address1scaledreg: INT_SHL(r,INT_CONSTANT) 6949 rchild.getOpcode() == INT_CONSTANT_opcode 6950 ) { 6951 c = STATE(lchild).getCost(2 /* r */) + LEA_SHIFT(Binary.getVal2(P(p)), 0); 6952 if(BURS.DEBUG) trace(p, 258, c + 0, p.getCost(15) /* address1scaledreg */); 6953 if (c < p.getCost(15) /* address1scaledreg */) { 6954 p.setCost(15 /* address1scaledreg */, (char)(c)); 6955 p.writePacked(1, 0xFC7FFFFF, 0x1000000); // p.address1scaledreg = 2 6956 closure_address1scaledreg(p, c); 6957 } 6958 } 6959 if ( // szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 6960 rchild.getOpcode() == INT_AND_opcode && 6961 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6962 ) { 6963 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 6964 if(BURS.DEBUG) trace(p, 617, c + 0, p.getCost(5) /* szpr */); 6965 if (c < p.getCost(5) /* szpr */) { 6966 p.setCost(5 /* szpr */, (char)(c)); 6967 p.writePacked(0, 0xE07FFFFF, 0x5000000); // p.szpr = 10 6968 closure_szpr(p, c); 6969 } 6970 } 6971 // szpr: INT_SHL(riv,riv) 6972 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 6973 if(BURS.DEBUG) trace(p, 115, c + 0, p.getCost(5) /* szpr */); 6974 if (c < p.getCost(5) /* szpr */) { 6975 p.setCost(5 /* szpr */, (char)(c)); 6976 p.writePacked(0, 0xE07FFFFF, 0x5800000); // p.szpr = 11 6977 closure_szpr(p, c); 6978 } 6979 if ( // szpr: INT_SHL(r,INT_CONSTANT) 6980 rchild.getOpcode() == INT_CONSTANT_opcode 6981 ) { 6982 c = STATE(lchild).getCost(2 /* r */) + 13; 6983 if(BURS.DEBUG) trace(p, 332, c + 0, p.getCost(5) /* szpr */); 6984 if (c < p.getCost(5) /* szpr */) { 6985 p.setCost(5 /* szpr */, (char)(c)); 6986 p.writePacked(0, 0xE07FFFFF, 0x6000000); // p.szpr = 12 6987 closure_szpr(p, c); 6988 } 6989 } 6990 if ( // r: INT_SHL(r,INT_CONSTANT) 6991 rchild.getOpcode() == INT_CONSTANT_opcode 6992 ) { 6993 c = STATE(lchild).getCost(2 /* r */) + (!Binary.getResult(P(p)).similar(Binary.getVal1(P(p))) && (Binary.getVal2(P(p)).asIntConstant().value & 0x1f) <= 3 ? 11 : INFINITE); 6994 if(BURS.DEBUG) trace(p, 333, c + 0, p.getCost(2) /* r */); 6995 if (c < p.getCost(2) /* r */) { 6996 p.setCost(2 /* r */, (char)(c)); 6997 p.writePacked(0, 0xFFFE00FF, 0x7100); // p.r = 113 6998 closure_r(p, c); 6999 } 7000 } 7001 if ( // szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 7002 lchild.getOpcode() == INT_SHR_opcode && 7003 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7004 rchild.getOpcode() == INT_CONSTANT_opcode 7005 ) { 7006 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == VLR(p)) ? 23 : INFINITE); 7007 if(BURS.DEBUG) trace(p, 389, c + 0, p.getCost(5) /* szpr */); 7008 if (c < p.getCost(5) /* szpr */) { 7009 p.setCost(5 /* szpr */, (char)(c)); 7010 p.writePacked(0, 0xE07FFFFF, 0x6800000); // p.szpr = 13 7011 closure_szpr(p, c); 7012 } 7013 } 7014 } 7015 7016 /** 7017 * Labels LONG_SHL tree node 7018 * @param p node to label 7019 */ 7020 private static void label_LONG_SHL(AbstractBURS_TreeNode p) { 7021 p.initCost(); 7022 AbstractBURS_TreeNode lchild, rchild; 7023 lchild = p.getChild1(); 7024 rchild = p.getChild2(); 7025 label(lchild); 7026 label(rchild); 7027 int c; 7028 if ( // address1scaledreg: LONG_SHL(r,INT_CONSTANT) 7029 rchild.getOpcode() == INT_CONSTANT_opcode 7030 ) { 7031 c = STATE(lchild).getCost(2 /* r */) + LEA_SHIFT(Binary.getVal2(P(p)), 0); 7032 if(BURS.DEBUG) trace(p, 264, c + 0, p.getCost(15) /* address1scaledreg */); 7033 if (c < p.getCost(15) /* address1scaledreg */) { 7034 p.setCost(15 /* address1scaledreg */, (char)(c)); 7035 p.writePacked(1, 0xFC7FFFFF, 0x2000000); // p.address1scaledreg = 4 7036 closure_address1scaledreg(p, c); 7037 } 7038 } 7039 if ( // szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) 7040 rchild.getOpcode() == INT_AND_opcode && 7041 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7042 ) { 7043 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 63 ? 23 : INFINITE); 7044 if(BURS.DEBUG) trace(p, 621, c + 0, p.getCost(5) /* szpr */); 7045 if (c < p.getCost(5) /* szpr */) { 7046 p.setCost(5 /* szpr */, (char)(c)); 7047 p.writePacked(0, 0xE07FFFFF, 0xF800000); // p.szpr = 31 7048 closure_szpr(p, c); 7049 } 7050 } 7051 // szpr: LONG_SHL(rlv,riv) 7052 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 23; 7053 if(BURS.DEBUG) trace(p, 192, c + 0, p.getCost(5) /* szpr */); 7054 if (c < p.getCost(5) /* szpr */) { 7055 p.setCost(5 /* szpr */, (char)(c)); 7056 p.writePacked(0, 0xE07FFFFF, 0x10000000); // p.szpr = 32 7057 closure_szpr(p, c); 7058 } 7059 if ( // szpr: LONG_SHL(r,INT_CONSTANT) 7060 rchild.getOpcode() == INT_CONSTANT_opcode 7061 ) { 7062 c = STATE(lchild).getCost(2 /* r */) + 13; 7063 if(BURS.DEBUG) trace(p, 348, c + 0, p.getCost(5) /* szpr */); 7064 if (c < p.getCost(5) /* szpr */) { 7065 p.setCost(5 /* szpr */, (char)(c)); 7066 p.writePacked(0, 0xE07FFFFF, 0x10800000); // p.szpr = 33 7067 closure_szpr(p, c); 7068 } 7069 } 7070 if ( // r: LONG_SHL(r,INT_CONSTANT) 7071 rchild.getOpcode() == INT_CONSTANT_opcode 7072 ) { 7073 c = STATE(lchild).getCost(2 /* r */) + (!Binary.getResult(P(p)).similar(Binary.getVal1(P(p))) && (Binary.getVal2(P(p)).asIntConstant().value & 0x3f) <= 3 ? 11 : INFINITE); 7074 if(BURS.DEBUG) trace(p, 349, c + 0, p.getCost(2) /* r */); 7075 if (c < p.getCost(2) /* r */) { 7076 p.setCost(2 /* r */, (char)(c)); 7077 p.writePacked(0, 0xFFFE00FF, 0xA900); // p.r = 169 7078 closure_r(p, c); 7079 } 7080 } 7081 if ( // szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) 7082 lchild.getOpcode() == LONG_SHR_opcode && 7083 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7084 rchild.getOpcode() == INT_CONSTANT_opcode 7085 ) { 7086 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (((VR(p) == VLR(p)) && (VR(p) < 32)) ? 23 : INFINITE); 7087 if(BURS.DEBUG) trace(p, 396, c + 0, p.getCost(5) /* szpr */); 7088 if (c < p.getCost(5) /* szpr */) { 7089 p.setCost(5 /* szpr */, (char)(c)); 7090 p.writePacked(0, 0xE07FFFFF, 0x11000000); // p.szpr = 34 7091 closure_szpr(p, c); 7092 } 7093 } 7094 } 7095 7096 /** 7097 * Labels INT_SHR tree node 7098 * @param p node to label 7099 */ 7100 private static void label_INT_SHR(AbstractBURS_TreeNode p) { 7101 p.initCost(); 7102 AbstractBURS_TreeNode lchild, rchild; 7103 lchild = p.getChild1(); 7104 rchild = p.getChild2(); 7105 label(lchild); 7106 label(rchild); 7107 int c; 7108 if ( // szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 7109 rchild.getOpcode() == INT_AND_opcode && 7110 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7111 ) { 7112 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 7113 if(BURS.DEBUG) trace(p, 618, c + 0, p.getCost(5) /* szpr */); 7114 if (c < p.getCost(5) /* szpr */) { 7115 p.setCost(5 /* szpr */, (char)(c)); 7116 p.writePacked(0, 0xE07FFFFF, 0x7000000); // p.szpr = 14 7117 closure_szpr(p, c); 7118 } 7119 } 7120 // szpr: INT_SHR(riv,riv) 7121 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 7122 if(BURS.DEBUG) trace(p, 116, c + 0, p.getCost(5) /* szpr */); 7123 if (c < p.getCost(5) /* szpr */) { 7124 p.setCost(5 /* szpr */, (char)(c)); 7125 p.writePacked(0, 0xE07FFFFF, 0x7800000); // p.szpr = 15 7126 closure_szpr(p, c); 7127 } 7128 if ( // szpr: INT_SHR(riv,INT_CONSTANT) 7129 rchild.getOpcode() == INT_CONSTANT_opcode 7130 ) { 7131 c = STATE(lchild).getCost(7 /* riv */) + 13; 7132 if(BURS.DEBUG) trace(p, 334, c + 0, p.getCost(5) /* szpr */); 7133 if (c < p.getCost(5) /* szpr */) { 7134 p.setCost(5 /* szpr */, (char)(c)); 7135 p.writePacked(0, 0xE07FFFFF, 0x8000000); // p.szpr = 16 7136 closure_szpr(p, c); 7137 } 7138 } 7139 } 7140 7141 /** 7142 * Labels LONG_SHR tree node 7143 * @param p node to label 7144 */ 7145 private static void label_LONG_SHR(AbstractBURS_TreeNode p) { 7146 p.initCost(); 7147 AbstractBURS_TreeNode lchild, rchild; 7148 lchild = p.getChild1(); 7149 rchild = p.getChild2(); 7150 label(lchild); 7151 label(rchild); 7152 int c; 7153 if ( // szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) 7154 rchild.getOpcode() == INT_AND_opcode && 7155 rchild.getChild2().getOpcode() == LONG_CONSTANT_opcode 7156 ) { 7157 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 63 ? 23 : INFINITE); 7158 if(BURS.DEBUG) trace(p, 622, c + 0, p.getCost(5) /* szpr */); 7159 if (c < p.getCost(5) /* szpr */) { 7160 p.setCost(5 /* szpr */, (char)(c)); 7161 p.writePacked(0, 0xE07FFFFF, 0x11800000); // p.szpr = 35 7162 closure_szpr(p, c); 7163 } 7164 } 7165 // szpr: LONG_SHR(rlv,riv) 7166 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 23; 7167 if(BURS.DEBUG) trace(p, 193, c + 0, p.getCost(5) /* szpr */); 7168 if (c < p.getCost(5) /* szpr */) { 7169 p.setCost(5 /* szpr */, (char)(c)); 7170 p.writePacked(0, 0xE07FFFFF, 0x12000000); // p.szpr = 36 7171 closure_szpr(p, c); 7172 } 7173 if ( // szpr: LONG_SHR(rlv,LONG_CONSTANT) 7174 rchild.getOpcode() == LONG_CONSTANT_opcode 7175 ) { 7176 c = STATE(lchild).getCost(8 /* rlv */) + 13; 7177 if(BURS.DEBUG) trace(p, 350, c + 0, p.getCost(5) /* szpr */); 7178 if (c < p.getCost(5) /* szpr */) { 7179 p.setCost(5 /* szpr */, (char)(c)); 7180 p.writePacked(0, 0xE07FFFFF, 0x12800000); // p.szpr = 37 7181 closure_szpr(p, c); 7182 } 7183 } 7184 } 7185 7186 /** 7187 * Labels INT_USHR tree node 7188 * @param p node to label 7189 */ 7190 private static void label_INT_USHR(AbstractBURS_TreeNode p) { 7191 p.initCost(); 7192 AbstractBURS_TreeNode lchild, rchild; 7193 lchild = p.getChild1(); 7194 rchild = p.getChild2(); 7195 label(lchild); 7196 label(rchild); 7197 int c; 7198 if ( // r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 7199 lchild.getOpcode() == INT_SHL_opcode && 7200 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7201 rchild.getOpcode() == INT_CONSTANT_opcode 7202 ) { 7203 c = STATE(lchild.getChild1()).getCost(12 /* load8_16_32 */) + (VR(p) == 24 && VLLR(p) == 24 ? 15 : INFINITE); 7204 if(BURS.DEBUG) trace(p, 383, c + 0, p.getCost(2) /* r */); 7205 if (c < p.getCost(2) /* r */) { 7206 p.setCost(2 /* r */, (char)(c)); 7207 p.writePacked(0, 0xFFFE00FF, 0x900); // p.r = 9 7208 closure_r(p, c); 7209 } 7210 } 7211 if ( // r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 7212 lchild.getOpcode() == INT_SHL_opcode && 7213 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7214 rchild.getOpcode() == INT_CONSTANT_opcode 7215 ) { 7216 c = STATE(lchild.getChild1()).getCost(13 /* load16_32 */) + (VR(p) == 16 && VLR(p) == 16 ? 15 : INFINITE); 7217 if(BURS.DEBUG) trace(p, 384, c + 0, p.getCost(2) /* r */); 7218 if (c < p.getCost(2) /* r */) { 7219 p.setCost(2 /* r */, (char)(c)); 7220 p.writePacked(0, 0xFFFE00FF, 0xB00); // p.r = 11 7221 closure_r(p, c); 7222 } 7223 } 7224 if ( // szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 7225 rchild.getOpcode() == INT_AND_opcode && 7226 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7227 ) { 7228 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 7229 if(BURS.DEBUG) trace(p, 620, c + 0, p.getCost(5) /* szpr */); 7230 if (c < p.getCost(5) /* szpr */) { 7231 p.setCost(5 /* szpr */, (char)(c)); 7232 p.writePacked(0, 0xE07FFFFF, 0x8800000); // p.szpr = 17 7233 closure_szpr(p, c); 7234 } 7235 } 7236 // szpr: INT_USHR(riv,riv) 7237 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 7238 if(BURS.DEBUG) trace(p, 122, c + 0, p.getCost(5) /* szpr */); 7239 if (c < p.getCost(5) /* szpr */) { 7240 p.setCost(5 /* szpr */, (char)(c)); 7241 p.writePacked(0, 0xE07FFFFF, 0x9000000); // p.szpr = 18 7242 closure_szpr(p, c); 7243 } 7244 if ( // szpr: INT_USHR(riv,INT_CONSTANT) 7245 rchild.getOpcode() == INT_CONSTANT_opcode 7246 ) { 7247 c = STATE(lchild).getCost(7 /* riv */) + 13; 7248 if(BURS.DEBUG) trace(p, 335, c + 0, p.getCost(5) /* szpr */); 7249 if (c < p.getCost(5) /* szpr */) { 7250 p.setCost(5 /* szpr */, (char)(c)); 7251 p.writePacked(0, 0xE07FFFFF, 0x9800000); // p.szpr = 19 7252 closure_szpr(p, c); 7253 } 7254 } 7255 } 7256 7257 /** 7258 * Labels LONG_USHR tree node 7259 * @param p node to label 7260 */ 7261 private static void label_LONG_USHR(AbstractBURS_TreeNode p) { 7262 p.initCost(); 7263 AbstractBURS_TreeNode lchild, rchild; 7264 lchild = p.getChild1(); 7265 rchild = p.getChild2(); 7266 label(lchild); 7267 label(rchild); 7268 int c; 7269 if ( // szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) 7270 rchild.getOpcode() == LONG_AND_opcode && 7271 rchild.getChild2().getOpcode() == LONG_CONSTANT_opcode 7272 ) { 7273 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 63 ? 23 : INFINITE); 7274 if(BURS.DEBUG) trace(p, 624, c + 0, p.getCost(5) /* szpr */); 7275 if (c < p.getCost(5) /* szpr */) { 7276 p.setCost(5 /* szpr */, (char)(c)); 7277 p.writePacked(0, 0xE07FFFFF, 0x13000000); // p.szpr = 38 7278 closure_szpr(p, c); 7279 } 7280 } 7281 // szpr: LONG_USHR(rlv,riv) 7282 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 23; 7283 if(BURS.DEBUG) trace(p, 199, c + 0, p.getCost(5) /* szpr */); 7284 if (c < p.getCost(5) /* szpr */) { 7285 p.setCost(5 /* szpr */, (char)(c)); 7286 p.writePacked(0, 0xE07FFFFF, 0x13800000); // p.szpr = 39 7287 closure_szpr(p, c); 7288 } 7289 if ( // szpr: LONG_USHR(rlv,LONG_CONSTANT) 7290 rchild.getOpcode() == LONG_CONSTANT_opcode 7291 ) { 7292 c = STATE(lchild).getCost(8 /* rlv */) + 13; 7293 if(BURS.DEBUG) trace(p, 351, c + 0, p.getCost(5) /* szpr */); 7294 if (c < p.getCost(5) /* szpr */) { 7295 p.setCost(5 /* szpr */, (char)(c)); 7296 p.writePacked(0, 0xE07FFFFF, 0x14000000); // p.szpr = 40 7297 closure_szpr(p, c); 7298 } 7299 } 7300 } 7301 7302 /** 7303 * Labels INT_AND tree node 7304 * @param p node to label 7305 */ 7306 private static void label_INT_AND(AbstractBURS_TreeNode p) { 7307 p.initCost(); 7308 AbstractBURS_TreeNode lchild, rchild; 7309 lchild = p.getChild1(); 7310 rchild = p.getChild2(); 7311 label(lchild); 7312 label(rchild); 7313 int c; 7314 if ( // uload8: INT_AND(load8_16_32,INT_CONSTANT) 7315 rchild.getOpcode() == INT_CONSTANT_opcode 7316 ) { 7317 c = STATE(lchild).getCost(12 /* load8_16_32 */) + (VR(p) == 0xff ? 0 : INFINITE); 7318 if(BURS.DEBUG) trace(p, 252, c + 0, p.getCost(11) /* uload8 */); 7319 if (c < p.getCost(11) /* uload8 */) { 7320 p.setCost(11 /* uload8 */, (char)(c)); 7321 p.writePacked(1, 0xFFFE3FFF, 0x4000); // p.uload8 = 1 7322 closure_uload8(p, c); 7323 } 7324 } 7325 if ( // r: INT_AND(load8_16_32,INT_CONSTANT) 7326 rchild.getOpcode() == INT_CONSTANT_opcode 7327 ) { 7328 c = STATE(lchild).getCost(12 /* load8_16_32 */) + (VR(p) == 0xff ? 15 : INFINITE); 7329 if(BURS.DEBUG) trace(p, 253, c + 0, p.getCost(2) /* r */); 7330 if (c < p.getCost(2) /* r */) { 7331 p.setCost(2 /* r */, (char)(c)); 7332 p.writePacked(0, 0xFFFE00FF, 0x700); // p.r = 7 7333 closure_r(p, c); 7334 } 7335 } 7336 if ( // r: INT_AND(load16_32,INT_CONSTANT) 7337 rchild.getOpcode() == INT_CONSTANT_opcode 7338 ) { 7339 c = STATE(lchild).getCost(13 /* load16_32 */) + (VR(p) == 0xffff ? 15 : INFINITE); 7340 if(BURS.DEBUG) trace(p, 255, c + 0, p.getCost(2) /* r */); 7341 if (c < p.getCost(2) /* r */) { 7342 p.setCost(2 /* r */, (char)(c)); 7343 p.writePacked(0, 0xFFFE00FF, 0xA00); // p.r = 10 7344 closure_r(p, c); 7345 } 7346 } 7347 if ( // bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 7348 lchild.getOpcode() == INT_USHR_opcode && 7349 lchild.getChild2().getOpcode() == INT_AND_opcode && 7350 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7351 rchild.getOpcode() == INT_CONSTANT_opcode 7352 ) { 7353 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLRR(p) == 31) ? 13:INFINITE); 7354 if(BURS.DEBUG) trace(p, 522, c + 0, p.getCost(18) /* bittest */); 7355 if (c < p.getCost(18) /* bittest */) { 7356 p.setCost(18 /* bittest */, (char)(c)); 7357 p.writePacked(2, 0xFFFFFF0F, 0x10); // p.bittest = 1 7358 } 7359 } 7360 if ( // bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 7361 lchild.getOpcode() == INT_USHR_opcode && 7362 lchild.getChild2().getOpcode() == INT_AND_opcode && 7363 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7364 rchild.getOpcode() == INT_CONSTANT_opcode 7365 ) { 7366 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + (VR(p) == 1 ? 31:INFINITE); 7367 if(BURS.DEBUG) trace(p, 523, c + 0, p.getCost(18) /* bittest */); 7368 if (c < p.getCost(18) /* bittest */) { 7369 p.setCost(18 /* bittest */, (char)(c)); 7370 p.writePacked(2, 0xFFFFFF0F, 0x20); // p.bittest = 2 7371 } 7372 } 7373 if ( // bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 7374 lchild.getOpcode() == INT_USHR_opcode && 7375 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7376 rchild.getOpcode() == INT_CONSTANT_opcode 7377 ) { 7378 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLR(p) <= 31) ? 13:INFINITE); 7379 if(BURS.DEBUG) trace(p, 385, c + 0, p.getCost(18) /* bittest */); 7380 if (c < p.getCost(18) /* bittest */) { 7381 p.setCost(18 /* bittest */, (char)(c)); 7382 p.writePacked(2, 0xFFFFFF0F, 0x30); // p.bittest = 3 7383 } 7384 } 7385 if ( // bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 7386 lchild.getOpcode() == INT_SHR_opcode && 7387 lchild.getChild2().getOpcode() == INT_AND_opcode && 7388 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7389 rchild.getOpcode() == INT_CONSTANT_opcode 7390 ) { 7391 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLRR(p) == 31) ? 13:INFINITE); 7392 if(BURS.DEBUG) trace(p, 524, c + 0, p.getCost(18) /* bittest */); 7393 if (c < p.getCost(18) /* bittest */) { 7394 p.setCost(18 /* bittest */, (char)(c)); 7395 p.writePacked(2, 0xFFFFFF0F, 0x40); // p.bittest = 4 7396 } 7397 } 7398 if ( // bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 7399 lchild.getOpcode() == INT_SHR_opcode && 7400 lchild.getChild2().getOpcode() == INT_AND_opcode && 7401 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7402 rchild.getOpcode() == INT_CONSTANT_opcode 7403 ) { 7404 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + (VR(p) == 1 ? 31:INFINITE); 7405 if(BURS.DEBUG) trace(p, 525, c + 0, p.getCost(18) /* bittest */); 7406 if (c < p.getCost(18) /* bittest */) { 7407 p.setCost(18 /* bittest */, (char)(c)); 7408 p.writePacked(2, 0xFFFFFF0F, 0x50); // p.bittest = 5 7409 } 7410 } 7411 if ( // bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 7412 lchild.getOpcode() == INT_SHR_opcode && 7413 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7414 rchild.getOpcode() == INT_CONSTANT_opcode 7415 ) { 7416 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLR(p) <= 31) ? 13:INFINITE); 7417 if(BURS.DEBUG) trace(p, 386, c + 0, p.getCost(18) /* bittest */); 7418 if (c < p.getCost(18) /* bittest */) { 7419 p.setCost(18 /* bittest */, (char)(c)); 7420 p.writePacked(2, 0xFFFFFF0F, 0x60); // p.bittest = 6 7421 } 7422 } 7423 if ( // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 7424 lchild.getOpcode() == INT_SHL_opcode && 7425 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 7426 lchild.getChild2().getOpcode() == INT_AND_opcode && 7427 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7428 ) { 7429 c = STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + ((VLL(p) == 1) && (VLRR(p) == 31)? 13:INFINITE); 7430 if(BURS.DEBUG) trace(p, 526, c + 0, p.getCost(18) /* bittest */); 7431 if (c < p.getCost(18) /* bittest */) { 7432 p.setCost(18 /* bittest */, (char)(c)); 7433 p.writePacked(2, 0xFFFFFF0F, 0x70); // p.bittest = 7 7434 } 7435 } 7436 if ( // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 7437 lchild.getOpcode() == INT_SHL_opcode && 7438 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 7439 lchild.getChild2().getOpcode() == INT_AND_opcode && 7440 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7441 ) { 7442 c = STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + (VLL(p) == 1 ? 31:INFINITE); 7443 if(BURS.DEBUG) trace(p, 527, c + 0, p.getCost(18) /* bittest */); 7444 if (c < p.getCost(18) /* bittest */) { 7445 p.setCost(18 /* bittest */, (char)(c)); 7446 p.writePacked(2, 0xFFFFFF0F, 0x80); // p.bittest = 8 7447 } 7448 } 7449 if ( // bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 7450 rchild.getOpcode() == INT_SHL_opcode && 7451 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 7452 rchild.getChild2().getOpcode() == INT_AND_opcode && 7453 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7454 ) { 7455 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + ((VRL(p) == 1) && (VRRR(p) == 31) ? 13:INFINITE); 7456 if(BURS.DEBUG) trace(p, 528, c + 0, p.getCost(18) /* bittest */); 7457 if (c < p.getCost(18) /* bittest */) { 7458 p.setCost(18 /* bittest */, (char)(c)); 7459 p.writePacked(2, 0xFFFFFF0F, 0x90); // p.bittest = 9 7460 } 7461 } 7462 if ( // bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 7463 rchild.getOpcode() == INT_SHL_opcode && 7464 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 7465 rchild.getChild2().getOpcode() == INT_AND_opcode && 7466 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7467 ) { 7468 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + (VRL(p) == 1 ? 31:INFINITE); 7469 if(BURS.DEBUG) trace(p, 529, c + 0, p.getCost(18) /* bittest */); 7470 if (c < p.getCost(18) /* bittest */) { 7471 p.setCost(18 /* bittest */, (char)(c)); 7472 p.writePacked(2, 0xFFFFFF0F, 0xA0); // p.bittest = 10 7473 } 7474 } 7475 // szpr: INT_AND(r,riv) 7476 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 7477 if(BURS.DEBUG) trace(p, 85, c + 0, p.getCost(5) /* szpr */); 7478 if (c < p.getCost(5) /* szpr */) { 7479 p.setCost(5 /* szpr */, (char)(c)); 7480 p.writePacked(0, 0xE07FFFFF, 0x1000000); // p.szpr = 2 7481 closure_szpr(p, c); 7482 } 7483 // szp: INT_AND(r,riv) 7484 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 11; 7485 if(BURS.DEBUG) trace(p, 86, c + 0, p.getCost(6) /* szp */); 7486 if (c < p.getCost(6) /* szp */) { 7487 p.setCost(6 /* szp */, (char)(c)); 7488 p.writePacked(1, 0xFFFFFFF0, 0x2); // p.szp = 2 7489 } 7490 // szpr: INT_AND(r,load32) 7491 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 7492 if(BURS.DEBUG) trace(p, 87, c + 0, p.getCost(5) /* szpr */); 7493 if (c < p.getCost(5) /* szpr */) { 7494 p.setCost(5 /* szpr */, (char)(c)); 7495 p.writePacked(0, 0xE07FFFFF, 0x1800000); // p.szpr = 3 7496 closure_szpr(p, c); 7497 } 7498 // szpr: INT_AND(load32,riv) 7499 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 7500 if(BURS.DEBUG) trace(p, 88, c + 0, p.getCost(5) /* szpr */); 7501 if (c < p.getCost(5) /* szpr */) { 7502 p.setCost(5 /* szpr */, (char)(c)); 7503 p.writePacked(0, 0xE07FFFFF, 0x2000000); // p.szpr = 4 7504 closure_szpr(p, c); 7505 } 7506 // szp: INT_AND(load8_16_32,riv) 7507 c = STATE(lchild).getCost(12 /* load8_16_32 */) + STATE(rchild).getCost(7 /* riv */) + 11; 7508 if(BURS.DEBUG) trace(p, 89, c + 0, p.getCost(6) /* szp */); 7509 if (c < p.getCost(6) /* szp */) { 7510 p.setCost(6 /* szp */, (char)(c)); 7511 p.writePacked(1, 0xFFFFFFF0, 0x3); // p.szp = 3 7512 } 7513 // szp: INT_AND(r,load8_16_32) 7514 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(12 /* load8_16_32 */) + 11; 7515 if(BURS.DEBUG) trace(p, 90, c + 0, p.getCost(6) /* szp */); 7516 if (c < p.getCost(6) /* szp */) { 7517 p.setCost(6 /* szp */, (char)(c)); 7518 p.writePacked(1, 0xFFFFFFF0, 0x4); // p.szp = 4 7519 } 7520 } 7521 7522 /** 7523 * Labels LONG_AND tree node 7524 * @param p node to label 7525 */ 7526 private static void label_LONG_AND(AbstractBURS_TreeNode p) { 7527 p.initCost(); 7528 AbstractBURS_TreeNode lchild, rchild; 7529 lchild = p.getChild1(); 7530 rchild = p.getChild2(); 7531 label(lchild); 7532 label(rchild); 7533 int c; 7534 if ( // r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 7535 lchild.getOpcode() == INT_2LONG_opcode && 7536 rchild.getOpcode() == LONG_CONSTANT_opcode 7537 ) { 7538 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((Binary.getVal2(P(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(P(p)).asLongConstant().lower32() == -1)? 11 : INFINITE); 7539 if(BURS.DEBUG) trace(p, 387, c + 0, p.getCost(2) /* r */); 7540 if (c < p.getCost(2) /* r */) { 7541 p.setCost(2 /* r */, (char)(c)); 7542 p.writePacked(0, 0xFFFE00FF, 0x5200); // p.r = 82 7543 closure_r(p, c); 7544 } 7545 } 7546 if ( // r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 7547 lchild.getOpcode() == INT_2LONG_opcode && 7548 rchild.getOpcode() == LONG_CONSTANT_opcode 7549 ) { 7550 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + ((Binary.getVal2(P(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(P(p)).asLongConstant().lower32() == -1)? 13 : INFINITE); 7551 if(BURS.DEBUG) trace(p, 388, c + 0, p.getCost(2) /* r */); 7552 if (c < p.getCost(2) /* r */) { 7553 p.setCost(2 /* r */, (char)(c)); 7554 p.writePacked(0, 0xFFFE00FF, 0x5300); // p.r = 83 7555 closure_r(p, c); 7556 } 7557 } 7558 // szpr: LONG_AND(r,rlv) 7559 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 7560 if(BURS.DEBUG) trace(p, 161, c + 0, p.getCost(5) /* szpr */); 7561 if (c < p.getCost(5) /* szpr */) { 7562 p.setCost(5 /* szpr */, (char)(c)); 7563 p.writePacked(0, 0xE07FFFFF, 0xB800000); // p.szpr = 23 7564 closure_szpr(p, c); 7565 } 7566 // szpr: LONG_AND(r,r) 7567 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 9; 7568 if(BURS.DEBUG) trace(p, 162, c + 0, p.getCost(5) /* szpr */); 7569 if (c < p.getCost(5) /* szpr */) { 7570 p.setCost(5 /* szpr */, (char)(c)); 7571 p.writePacked(0, 0xE07FFFFF, 0xC000000); // p.szpr = 24 7572 closure_szpr(p, c); 7573 } 7574 // szp: LONG_AND(r,rlv) 7575 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 11; 7576 if(BURS.DEBUG) trace(p, 163, c + 0, p.getCost(6) /* szp */); 7577 if (c < p.getCost(6) /* szp */) { 7578 p.setCost(6 /* szp */, (char)(c)); 7579 p.writePacked(1, 0xFFFFFFF0, 0x6); // p.szp = 6 7580 } 7581 // szpr: LONG_AND(rlv,load64) 7582 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 15; 7583 if(BURS.DEBUG) trace(p, 164, c + 0, p.getCost(5) /* szpr */); 7584 if (c < p.getCost(5) /* szpr */) { 7585 p.setCost(5 /* szpr */, (char)(c)); 7586 p.writePacked(0, 0xE07FFFFF, 0xC800000); // p.szpr = 25 7587 closure_szpr(p, c); 7588 } 7589 // szpr: LONG_AND(load64,rlv) 7590 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 7591 if(BURS.DEBUG) trace(p, 165, c + 0, p.getCost(5) /* szpr */); 7592 if (c < p.getCost(5) /* szpr */) { 7593 p.setCost(5 /* szpr */, (char)(c)); 7594 p.writePacked(0, 0xE07FFFFF, 0xD000000); // p.szpr = 26 7595 closure_szpr(p, c); 7596 } 7597 // szp: LONG_AND(load8_16_32_64,rlv) 7598 c = STATE(lchild).getCost(25 /* load8_16_32_64 */) + STATE(rchild).getCost(8 /* rlv */) + 11; 7599 if(BURS.DEBUG) trace(p, 166, c + 0, p.getCost(6) /* szp */); 7600 if (c < p.getCost(6) /* szp */) { 7601 p.setCost(6 /* szp */, (char)(c)); 7602 p.writePacked(1, 0xFFFFFFF0, 0x7); // p.szp = 7 7603 } 7604 // szp: LONG_AND(r,load8_16_32_64) 7605 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* load8_16_32_64 */) + 11; 7606 if(BURS.DEBUG) trace(p, 167, c + 0, p.getCost(6) /* szp */); 7607 if (c < p.getCost(6) /* szp */) { 7608 p.setCost(6 /* szp */, (char)(c)); 7609 p.writePacked(1, 0xFFFFFFF0, 0x8); // p.szp = 8 7610 } 7611 } 7612 7613 /** 7614 * Labels INT_OR tree node 7615 * @param p node to label 7616 */ 7617 private static void label_INT_OR(AbstractBURS_TreeNode p) { 7618 p.initCost(); 7619 AbstractBURS_TreeNode lchild, rchild; 7620 lchild = p.getChild1(); 7621 rchild = p.getChild2(); 7622 label(lchild); 7623 label(rchild); 7624 int c; 7625 // szpr: INT_OR(r,riv) 7626 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 7627 if(BURS.DEBUG) trace(p, 110, c + 0, p.getCost(5) /* szpr */); 7628 if (c < p.getCost(5) /* szpr */) { 7629 p.setCost(5 /* szpr */, (char)(c)); 7630 p.writePacked(0, 0xE07FFFFF, 0x3800000); // p.szpr = 7 7631 closure_szpr(p, c); 7632 } 7633 // szpr: INT_OR(r,load32) 7634 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 7635 if(BURS.DEBUG) trace(p, 111, c + 0, p.getCost(5) /* szpr */); 7636 if (c < p.getCost(5) /* szpr */) { 7637 p.setCost(5 /* szpr */, (char)(c)); 7638 p.writePacked(0, 0xE07FFFFF, 0x4000000); // p.szpr = 8 7639 closure_szpr(p, c); 7640 } 7641 // szpr: INT_OR(load32,riv) 7642 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 7643 if(BURS.DEBUG) trace(p, 112, c + 0, p.getCost(5) /* szpr */); 7644 if (c < p.getCost(5) /* szpr */) { 7645 p.setCost(5 /* szpr */, (char)(c)); 7646 p.writePacked(0, 0xE07FFFFF, 0x4800000); // p.szpr = 9 7647 closure_szpr(p, c); 7648 } 7649 if ( // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 7650 lchild.getOpcode() == INT_SHL_opcode && 7651 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7652 rchild.getOpcode() == INT_USHR_opcode && 7653 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7654 ) { 7655 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && ((-VLR(p)) & 0x1f) == (VRR(p)&0x1f) ? 13 : INFINITE); 7656 if(BURS.DEBUG) trace(p, 609, c + 0, p.getCost(2) /* r */); 7657 if (c < p.getCost(2) /* r */) { 7658 p.setCost(2 /* r */, (char)(c)); 7659 p.writePacked(0, 0xFFFE00FF, 0x6900); // p.r = 105 7660 closure_r(p, c); 7661 } 7662 } 7663 if ( // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 7664 lchild.getOpcode() == INT_USHR_opcode && 7665 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7666 rchild.getOpcode() == INT_SHL_opcode && 7667 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7668 ) { 7669 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && ((-VRR(p)) & 0x1f) == (VLR(p)&0x1f) ? 13 : INFINITE); 7670 if(BURS.DEBUG) trace(p, 610, c + 0, p.getCost(2) /* r */); 7671 if (c < p.getCost(2) /* r */) { 7672 p.setCost(2 /* r */, (char)(c)); 7673 p.writePacked(0, 0xFFFE00FF, 0x6A00); // p.r = 106 7674 closure_r(p, c); 7675 } 7676 } 7677 if ( // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 7678 lchild.getOpcode() == INT_SHL_opcode && 7679 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7680 rchild.getOpcode() == INT_USHR_opcode && 7681 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7682 ) { 7683 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && ((-VLR(p)) & 0x1f) == (VRR(p)&0x1f) && ((VLR(p)&0x1f) == 31) ? 11 : INFINITE); 7684 if(BURS.DEBUG) trace(p, 611, c + 0, p.getCost(2) /* r */); 7685 if (c < p.getCost(2) /* r */) { 7686 p.setCost(2 /* r */, (char)(c)); 7687 p.writePacked(0, 0xFFFE00FF, 0x6B00); // p.r = 107 7688 closure_r(p, c); 7689 } 7690 } 7691 if ( // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 7692 lchild.getOpcode() == INT_USHR_opcode && 7693 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 7694 rchild.getOpcode() == INT_SHL_opcode && 7695 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7696 ) { 7697 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && ((-VRR(p)) & 0x1f) == (VLR(p)&0x1f) && ((VRR(p)&0x1f) == 31) ? 11 : INFINITE); 7698 if(BURS.DEBUG) trace(p, 612, c + 0, p.getCost(2) /* r */); 7699 if (c < p.getCost(2) /* r */) { 7700 p.setCost(2 /* r */, (char)(c)); 7701 p.writePacked(0, 0xFFFE00FF, 0x6C00); // p.r = 108 7702 closure_r(p, c); 7703 } 7704 } 7705 if ( // r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 7706 lchild.getOpcode() == INT_SHL_opcode && 7707 lchild.getChild2().getOpcode() == INT_AND_opcode && 7708 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7709 rchild.getOpcode() == INT_USHR_opcode && 7710 rchild.getChild2().getOpcode() == INT_AND_opcode && 7711 rchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 7712 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7713 ) { 7714 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && (VLRR(p) == 31) && (VRRR(p) == 31) && Binary.getVal1(PLR(p)).similar(Unary.getVal(PRRL(p))) ? 23 : INFINITE); 7715 if(BURS.DEBUG) trace(p, 613, c + 0, p.getCost(2) /* r */); 7716 if (c < p.getCost(2) /* r */) { 7717 p.setCost(2 /* r */, (char)(c)); 7718 p.writePacked(0, 0xFFFE00FF, 0x6D00); // p.r = 109 7719 closure_r(p, c); 7720 } 7721 } 7722 if ( // r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 7723 lchild.getOpcode() == INT_USHR_opcode && 7724 lchild.getChild2().getOpcode() == INT_AND_opcode && 7725 lchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 7726 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7727 rchild.getOpcode() == INT_SHL_opcode && 7728 rchild.getChild2().getOpcode() == INT_AND_opcode && 7729 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7730 ) { 7731 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && (VLRR(p) == 31) && (VRRR(p) == 31) && Binary.getVal1(PRR(p)).similar(Unary.getVal(PLRL(p))) ? 23 : INFINITE); 7732 if(BURS.DEBUG) trace(p, 615, c + 0, p.getCost(2) /* r */); 7733 if (c < p.getCost(2) /* r */) { 7734 p.setCost(2 /* r */, (char)(c)); 7735 p.writePacked(0, 0xFFFE00FF, 0x6E00); // p.r = 110 7736 closure_r(p, c); 7737 } 7738 } 7739 if ( // r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 7740 lchild.getOpcode() == INT_SHL_opcode && 7741 lchild.getChild2().getOpcode() == INT_AND_opcode && 7742 lchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 7743 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7744 rchild.getOpcode() == INT_USHR_opcode && 7745 rchild.getChild2().getOpcode() == INT_AND_opcode && 7746 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7747 ) { 7748 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && (VLRR(p) == 31) && (VRRR(p) == 31) && Binary.getVal1(PRR(p)).similar(Unary.getVal(PLRL(p))) ? 23 : INFINITE); 7749 if(BURS.DEBUG) trace(p, 616, c + 0, p.getCost(2) /* r */); 7750 if (c < p.getCost(2) /* r */) { 7751 p.setCost(2 /* r */, (char)(c)); 7752 p.writePacked(0, 0xFFFE00FF, 0x6F00); // p.r = 111 7753 closure_r(p, c); 7754 } 7755 } 7756 if ( // r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 7757 lchild.getOpcode() == INT_USHR_opcode && 7758 lchild.getChild2().getOpcode() == INT_AND_opcode && 7759 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 7760 rchild.getOpcode() == INT_SHL_opcode && 7761 rchild.getChild2().getOpcode() == INT_AND_opcode && 7762 rchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 7763 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 7764 ) { 7765 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + (Binary.getVal1(PL(p)).similar(Binary.getVal1(PR(p))) && (VLRR(p) == 31) && (VRRR(p) == 31) && Binary.getVal1(PLR(p)).similar(Unary.getVal(PRRL(p))) ? 23 : INFINITE); 7766 if(BURS.DEBUG) trace(p, 614, c + 0, p.getCost(2) /* r */); 7767 if (c < p.getCost(2) /* r */) { 7768 p.setCost(2 /* r */, (char)(c)); 7769 p.writePacked(0, 0xFFFE00FF, 0x7000); // p.r = 112 7770 closure_r(p, c); 7771 } 7772 } 7773 } 7774 7775 /** 7776 * Labels LONG_OR tree node 7777 * @param p node to label 7778 */ 7779 private static void label_LONG_OR(AbstractBURS_TreeNode p) { 7780 p.initCost(); 7781 AbstractBURS_TreeNode lchild, rchild; 7782 lchild = p.getChild1(); 7783 rchild = p.getChild2(); 7784 label(lchild); 7785 label(rchild); 7786 int c; 7787 // szpr: LONG_OR(r,rlv) 7788 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 7789 if(BURS.DEBUG) trace(p, 184, c + 0, p.getCost(5) /* szpr */); 7790 if (c < p.getCost(5) /* szpr */) { 7791 p.setCost(5 /* szpr */, (char)(c)); 7792 p.writePacked(0, 0xE07FFFFF, 0xE000000); // p.szpr = 28 7793 closure_szpr(p, c); 7794 } 7795 // szpr: LONG_OR(r,load64) 7796 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(20 /* load64 */) + 15; 7797 if(BURS.DEBUG) trace(p, 185, c + 0, p.getCost(5) /* szpr */); 7798 if (c < p.getCost(5) /* szpr */) { 7799 p.setCost(5 /* szpr */, (char)(c)); 7800 p.writePacked(0, 0xE07FFFFF, 0xE800000); // p.szpr = 29 7801 closure_szpr(p, c); 7802 } 7803 // szpr: LONG_OR(load64,rlv) 7804 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 7805 if(BURS.DEBUG) trace(p, 186, c + 0, p.getCost(5) /* szpr */); 7806 if (c < p.getCost(5) /* szpr */) { 7807 p.setCost(5 /* szpr */, (char)(c)); 7808 p.writePacked(0, 0xE07FFFFF, 0xF000000); // p.szpr = 30 7809 closure_szpr(p, c); 7810 } 7811 } 7812 7813 /** 7814 * Labels INT_XOR tree node 7815 * @param p node to label 7816 */ 7817 private static void label_INT_XOR(AbstractBURS_TreeNode p) { 7818 p.initCost(); 7819 AbstractBURS_TreeNode lchild, rchild; 7820 lchild = p.getChild1(); 7821 rchild = p.getChild2(); 7822 label(lchild); 7823 label(rchild); 7824 int c; 7825 // szpr: INT_XOR(r,riv) 7826 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 7827 if(BURS.DEBUG) trace(p, 123, c + 0, p.getCost(5) /* szpr */); 7828 if (c < p.getCost(5) /* szpr */) { 7829 p.setCost(5 /* szpr */, (char)(c)); 7830 p.writePacked(0, 0xE07FFFFF, 0xA000000); // p.szpr = 20 7831 closure_szpr(p, c); 7832 } 7833 // szpr: INT_XOR(r,load32) 7834 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 7835 if(BURS.DEBUG) trace(p, 124, c + 0, p.getCost(5) /* szpr */); 7836 if (c < p.getCost(5) /* szpr */) { 7837 p.setCost(5 /* szpr */, (char)(c)); 7838 p.writePacked(0, 0xE07FFFFF, 0xA800000); // p.szpr = 21 7839 closure_szpr(p, c); 7840 } 7841 // szpr: INT_XOR(load32,riv) 7842 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 7843 if(BURS.DEBUG) trace(p, 125, c + 0, p.getCost(5) /* szpr */); 7844 if (c < p.getCost(5) /* szpr */) { 7845 p.setCost(5 /* szpr */, (char)(c)); 7846 p.writePacked(0, 0xE07FFFFF, 0xB000000); // p.szpr = 22 7847 closure_szpr(p, c); 7848 } 7849 } 7850 7851 /** 7852 * Labels INT_NOT tree node 7853 * @param p node to label 7854 */ 7855 private static void label_INT_NOT(AbstractBURS_TreeNode p) { 7856 p.initCost(); 7857 AbstractBURS_TreeNode lchild; 7858 lchild = p.getChild1(); 7859 label(lchild); 7860 int c; 7861 // r: INT_NOT(r) 7862 c = STATE(lchild).getCost(2 /* r */) + 13; 7863 if(BURS.DEBUG) trace(p, 331, c + 0, p.getCost(2) /* r */); 7864 if (c < p.getCost(2) /* r */) { 7865 p.setCost(2 /* r */, (char)(c)); 7866 p.writePacked(0, 0xFFFE00FF, 0x6600); // p.r = 102 7867 closure_r(p, c); 7868 } 7869 } 7870 7871 /** 7872 * Labels LONG_NOT tree node 7873 * @param p node to label 7874 */ 7875 private static void label_LONG_NOT(AbstractBURS_TreeNode p) { 7876 p.initCost(); 7877 AbstractBURS_TreeNode lchild; 7878 lchild = p.getChild1(); 7879 label(lchild); 7880 int c; 7881 // r: LONG_NOT(r) 7882 c = STATE(lchild).getCost(2 /* r */) + 13; 7883 if(BURS.DEBUG) trace(p, 347, c + 0, p.getCost(2) /* r */); 7884 if (c < p.getCost(2) /* r */) { 7885 p.setCost(2 /* r */, (char)(c)); 7886 p.writePacked(0, 0xFFFE00FF, 0xA300); // p.r = 163 7887 closure_r(p, c); 7888 } 7889 } 7890 7891 /** 7892 * Labels LONG_XOR tree node 7893 * @param p node to label 7894 */ 7895 private static void label_LONG_XOR(AbstractBURS_TreeNode p) { 7896 p.initCost(); 7897 AbstractBURS_TreeNode lchild, rchild; 7898 lchild = p.getChild1(); 7899 rchild = p.getChild2(); 7900 label(lchild); 7901 label(rchild); 7902 int c; 7903 // szpr: LONG_XOR(r,rlv) 7904 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 7905 if(BURS.DEBUG) trace(p, 200, c + 0, p.getCost(5) /* szpr */); 7906 if (c < p.getCost(5) /* szpr */) { 7907 p.setCost(5 /* szpr */, (char)(c)); 7908 p.writePacked(0, 0xE07FFFFF, 0x14800000); // p.szpr = 41 7909 closure_szpr(p, c); 7910 } 7911 // szpr: LONG_XOR(r,load64) 7912 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(20 /* load64 */) + 15; 7913 if(BURS.DEBUG) trace(p, 201, c + 0, p.getCost(5) /* szpr */); 7914 if (c < p.getCost(5) /* szpr */) { 7915 p.setCost(5 /* szpr */, (char)(c)); 7916 p.writePacked(0, 0xE07FFFFF, 0x15000000); // p.szpr = 42 7917 closure_szpr(p, c); 7918 } 7919 // szpr: LONG_XOR(load64,rlv) 7920 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 7921 if(BURS.DEBUG) trace(p, 202, c + 0, p.getCost(5) /* szpr */); 7922 if (c < p.getCost(5) /* szpr */) { 7923 p.setCost(5 /* szpr */, (char)(c)); 7924 p.writePacked(0, 0xE07FFFFF, 0x15800000); // p.szpr = 43 7925 closure_szpr(p, c); 7926 } 7927 } 7928 7929 /** 7930 * Labels INT_2ADDRZerExt tree node 7931 * @param p node to label 7932 */ 7933 private static void label_INT_2ADDRZerExt(AbstractBURS_TreeNode p) { 7934 p.initCost(); 7935 AbstractBURS_TreeNode lchild; 7936 lchild = p.getChild1(); 7937 label(lchild); 7938 int c; 7939 // r: INT_2ADDRZerExt(r) 7940 c = STATE(lchild).getCost(2 /* r */) + 15; 7941 if(BURS.DEBUG) trace(p, 302, c + 0, p.getCost(2) /* r */); 7942 if (c < p.getCost(2) /* r */) { 7943 p.setCost(2 /* r */, (char)(c)); 7944 p.writePacked(0, 0xFFFE00FF, 0x5400); // p.r = 84 7945 closure_r(p, c); 7946 } 7947 } 7948 7949 /** 7950 * Labels INT_2LONG tree node 7951 * @param p node to label 7952 */ 7953 private static void label_INT_2LONG(AbstractBURS_TreeNode p) { 7954 p.initCost(); 7955 AbstractBURS_TreeNode lchild; 7956 lchild = p.getChild1(); 7957 label(lchild); 7958 int c; 7959 // r: INT_2LONG(r) 7960 c = STATE(lchild).getCost(2 /* r */) + 15; 7961 if(BURS.DEBUG) trace(p, 300, c + 0, p.getCost(2) /* r */); 7962 if (c < p.getCost(2) /* r */) { 7963 p.setCost(2 /* r */, (char)(c)); 7964 p.writePacked(0, 0xFFFE00FF, 0x5000); // p.r = 80 7965 closure_r(p, c); 7966 } 7967 // r: INT_2LONG(load32) 7968 c = STATE(lchild).getCost(10 /* load32 */) + 13; 7969 if(BURS.DEBUG) trace(p, 301, c + 0, p.getCost(2) /* r */); 7970 if (c < p.getCost(2) /* r */) { 7971 p.setCost(2 /* r */, (char)(c)); 7972 p.writePacked(0, 0xFFFE00FF, 0x5100); // p.r = 81 7973 closure_r(p, c); 7974 } 7975 } 7976 7977 /** 7978 * Labels INT_2FLOAT tree node 7979 * @param p node to label 7980 */ 7981 private static void label_INT_2FLOAT(AbstractBURS_TreeNode p) { 7982 p.initCost(); 7983 AbstractBURS_TreeNode lchild; 7984 lchild = p.getChild1(); 7985 label(lchild); 7986 int c; 7987 // r: INT_2FLOAT(riv) 7988 c = STATE(lchild).getCost(7 /* riv */) + 13; 7989 if(BURS.DEBUG) trace(p, 360, c + 0, p.getCost(2) /* r */); 7990 if (c < p.getCost(2) /* r */) { 7991 p.setCost(2 /* r */, (char)(c)); 7992 p.writePacked(0, 0xFFFE00FF, 0xD500); // p.r = 213 7993 closure_r(p, c); 7994 } 7995 // r: INT_2FLOAT(load32) 7996 c = STATE(lchild).getCost(10 /* load32 */) + 15; 7997 if(BURS.DEBUG) trace(p, 361, c + 0, p.getCost(2) /* r */); 7998 if (c < p.getCost(2) /* r */) { 7999 p.setCost(2 /* r */, (char)(c)); 8000 p.writePacked(0, 0xFFFE00FF, 0xD600); // p.r = 214 8001 closure_r(p, c); 8002 } 8003 } 8004 8005 /** 8006 * Labels INT_2DOUBLE tree node 8007 * @param p node to label 8008 */ 8009 private static void label_INT_2DOUBLE(AbstractBURS_TreeNode p) { 8010 p.initCost(); 8011 AbstractBURS_TreeNode lchild; 8012 lchild = p.getChild1(); 8013 label(lchild); 8014 int c; 8015 // r: INT_2DOUBLE(riv) 8016 c = STATE(lchild).getCost(7 /* riv */) + 13; 8017 if(BURS.DEBUG) trace(p, 362, c + 0, p.getCost(2) /* r */); 8018 if (c < p.getCost(2) /* r */) { 8019 p.setCost(2 /* r */, (char)(c)); 8020 p.writePacked(0, 0xFFFE00FF, 0xD700); // p.r = 215 8021 closure_r(p, c); 8022 } 8023 // r: INT_2DOUBLE(load32) 8024 c = STATE(lchild).getCost(10 /* load32 */) + 15; 8025 if(BURS.DEBUG) trace(p, 363, c + 0, p.getCost(2) /* r */); 8026 if (c < p.getCost(2) /* r */) { 8027 p.setCost(2 /* r */, (char)(c)); 8028 p.writePacked(0, 0xFFFE00FF, 0xD800); // p.r = 216 8029 closure_r(p, c); 8030 } 8031 } 8032 8033 /** 8034 * Labels LONG_2INT tree node 8035 * @param p node to label 8036 */ 8037 private static void label_LONG_2INT(AbstractBURS_TreeNode p) { 8038 p.initCost(); 8039 AbstractBURS_TreeNode lchild; 8040 lchild = p.getChild1(); 8041 label(lchild); 8042 int c; 8043 // r: LONG_2INT(r) 8044 c = STATE(lchild).getCost(2 /* r */) + 13; 8045 if(BURS.DEBUG) trace(p, 338, c + 0, p.getCost(2) /* r */); 8046 if (c < p.getCost(2) /* r */) { 8047 p.setCost(2 /* r */, (char)(c)); 8048 p.writePacked(0, 0xFFFE00FF, 0x8A00); // p.r = 138 8049 closure_r(p, c); 8050 } 8051 // r: LONG_2INT(load64) 8052 c = STATE(lchild).getCost(20 /* load64 */) + 15; 8053 if(BURS.DEBUG) trace(p, 339, c + 0, p.getCost(2) /* r */); 8054 if (c < p.getCost(2) /* r */) { 8055 p.setCost(2 /* r */, (char)(c)); 8056 p.writePacked(0, 0xFFFE00FF, 0x8B00); // p.r = 139 8057 closure_r(p, c); 8058 } 8059 // load32: LONG_2INT(load64) 8060 c = STATE(lchild).getCost(20 /* load64 */) + 0; 8061 if(BURS.DEBUG) trace(p, 340, c + 0, p.getCost(10) /* load32 */); 8062 if (c < p.getCost(10) /* load32 */) { 8063 p.setCost(10 /* load32 */, (char)(c)); 8064 p.writePacked(1, 0xFFFFC7FF, 0x2000); // p.load32 = 4 8065 closure_load32(p, c); 8066 } 8067 if ( // r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 8068 lchild.getOpcode() == LONG_USHR_opcode && 8069 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8070 ) { 8071 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VLR(p) == 32 ? 13 : INFINITE); 8072 if(BURS.DEBUG) trace(p, 390, c + 0, p.getCost(2) /* r */); 8073 if (c < p.getCost(2) /* r */) { 8074 p.setCost(2 /* r */, (char)(c)); 8075 p.writePacked(0, 0xFFFE00FF, 0x8C00); // p.r = 140 8076 closure_r(p, c); 8077 } 8078 } 8079 if ( // r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 8080 lchild.getOpcode() == LONG_SHR_opcode && 8081 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8082 ) { 8083 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VLR(p) == 32 ? 13 : INFINITE); 8084 if(BURS.DEBUG) trace(p, 391, c + 0, p.getCost(2) /* r */); 8085 if (c < p.getCost(2) /* r */) { 8086 p.setCost(2 /* r */, (char)(c)); 8087 p.writePacked(0, 0xFFFE00FF, 0x8D00); // p.r = 141 8088 closure_r(p, c); 8089 } 8090 } 8091 if ( // r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 8092 lchild.getOpcode() == LONG_USHR_opcode && 8093 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8094 ) { 8095 c = STATE(lchild.getChild1()).getCost(20 /* load64 */) + (VLR(p) == 32 ? 15 : INFINITE); 8096 if(BURS.DEBUG) trace(p, 392, c + 0, p.getCost(2) /* r */); 8097 if (c < p.getCost(2) /* r */) { 8098 p.setCost(2 /* r */, (char)(c)); 8099 p.writePacked(0, 0xFFFE00FF, 0x8E00); // p.r = 142 8100 closure_r(p, c); 8101 } 8102 } 8103 if ( // r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 8104 lchild.getOpcode() == LONG_SHR_opcode && 8105 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8106 ) { 8107 c = STATE(lchild.getChild1()).getCost(20 /* load64 */) + (VLR(p) == 32 ? 15 : INFINITE); 8108 if(BURS.DEBUG) trace(p, 393, c + 0, p.getCost(2) /* r */); 8109 if (c < p.getCost(2) /* r */) { 8110 p.setCost(2 /* r */, (char)(c)); 8111 p.writePacked(0, 0xFFFE00FF, 0x8F00); // p.r = 143 8112 closure_r(p, c); 8113 } 8114 } 8115 if ( // load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 8116 lchild.getOpcode() == LONG_USHR_opcode && 8117 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8118 ) { 8119 c = STATE(lchild.getChild1()).getCost(20 /* load64 */) + (VLR(p) == 32 ? 0 : INFINITE); 8120 if(BURS.DEBUG) trace(p, 394, c + 0, p.getCost(10) /* load32 */); 8121 if (c < p.getCost(10) /* load32 */) { 8122 p.setCost(10 /* load32 */, (char)(c)); 8123 p.writePacked(1, 0xFFFFC7FF, 0x2800); // p.load32 = 5 8124 closure_load32(p, c); 8125 } 8126 } 8127 if ( // load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 8128 lchild.getOpcode() == LONG_SHR_opcode && 8129 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8130 ) { 8131 c = STATE(lchild.getChild1()).getCost(20 /* load64 */) + (VLR(p) == 32 ? 0 : INFINITE); 8132 if(BURS.DEBUG) trace(p, 395, c + 0, p.getCost(10) /* load32 */); 8133 if (c < p.getCost(10) /* load32 */) { 8134 p.setCost(10 /* load32 */, (char)(c)); 8135 p.writePacked(1, 0xFFFFC7FF, 0x3000); // p.load32 = 6 8136 closure_load32(p, c); 8137 } 8138 } 8139 } 8140 8141 /** 8142 * Labels LONG_2FLOAT tree node 8143 * @param p node to label 8144 */ 8145 private static void label_LONG_2FLOAT(AbstractBURS_TreeNode p) { 8146 p.initCost(); 8147 AbstractBURS_TreeNode lchild; 8148 lchild = p.getChild1(); 8149 label(lchild); 8150 int c; 8151 // r: LONG_2FLOAT(r) 8152 c = STATE(lchild).getCost(2 /* r */) + 13; 8153 if(BURS.DEBUG) trace(p, 356, c + 0, p.getCost(2) /* r */); 8154 if (c < p.getCost(2) /* r */) { 8155 p.setCost(2 /* r */, (char)(c)); 8156 p.writePacked(0, 0xFFFE00FF, 0xC600); // p.r = 198 8157 closure_r(p, c); 8158 } 8159 } 8160 8161 /** 8162 * Labels LONG_2DOUBLE tree node 8163 * @param p node to label 8164 */ 8165 private static void label_LONG_2DOUBLE(AbstractBURS_TreeNode p) { 8166 p.initCost(); 8167 AbstractBURS_TreeNode lchild; 8168 lchild = p.getChild1(); 8169 label(lchild); 8170 int c; 8171 // r: LONG_2DOUBLE(r) 8172 c = STATE(lchild).getCost(2 /* r */) + 13; 8173 if(BURS.DEBUG) trace(p, 357, c + 0, p.getCost(2) /* r */); 8174 if (c < p.getCost(2) /* r */) { 8175 p.setCost(2 /* r */, (char)(c)); 8176 p.writePacked(0, 0xFFFE00FF, 0xC700); // p.r = 199 8177 closure_r(p, c); 8178 } 8179 } 8180 8181 /** 8182 * Labels FLOAT_2INT tree node 8183 * @param p node to label 8184 */ 8185 private static void label_FLOAT_2INT(AbstractBURS_TreeNode p) { 8186 p.initCost(); 8187 AbstractBURS_TreeNode lchild; 8188 lchild = p.getChild1(); 8189 label(lchild); 8190 int c; 8191 // r: FLOAT_2INT(r) 8192 c = STATE(lchild).getCost(2 /* r */) + 13; 8193 if(BURS.DEBUG) trace(p, 368, c + 0, p.getCost(2) /* r */); 8194 if (c < p.getCost(2) /* r */) { 8195 p.setCost(2 /* r */, (char)(c)); 8196 p.writePacked(0, 0xFFFE00FF, 0xDD00); // p.r = 221 8197 closure_r(p, c); 8198 } 8199 } 8200 8201 /** 8202 * Labels FLOAT_2LONG tree node 8203 * @param p node to label 8204 */ 8205 private static void label_FLOAT_2LONG(AbstractBURS_TreeNode p) { 8206 p.initCost(); 8207 AbstractBURS_TreeNode lchild; 8208 lchild = p.getChild1(); 8209 label(lchild); 8210 int c; 8211 // r: FLOAT_2LONG(r) 8212 c = STATE(lchild).getCost(2 /* r */) + 13; 8213 if(BURS.DEBUG) trace(p, 369, c + 0, p.getCost(2) /* r */); 8214 if (c < p.getCost(2) /* r */) { 8215 p.setCost(2 /* r */, (char)(c)); 8216 p.writePacked(0, 0xFFFE00FF, 0xDE00); // p.r = 222 8217 closure_r(p, c); 8218 } 8219 } 8220 8221 /** 8222 * Labels FLOAT_2DOUBLE tree node 8223 * @param p node to label 8224 */ 8225 private static void label_FLOAT_2DOUBLE(AbstractBURS_TreeNode p) { 8226 p.initCost(); 8227 AbstractBURS_TreeNode lchild; 8228 lchild = p.getChild1(); 8229 label(lchild); 8230 int c; 8231 // r: FLOAT_2DOUBLE(r) 8232 c = STATE(lchild).getCost(2 /* r */) + 13; 8233 if(BURS.DEBUG) trace(p, 364, c + 0, p.getCost(2) /* r */); 8234 if (c < p.getCost(2) /* r */) { 8235 p.setCost(2 /* r */, (char)(c)); 8236 p.writePacked(0, 0xFFFE00FF, 0xD900); // p.r = 217 8237 closure_r(p, c); 8238 } 8239 // r: FLOAT_2DOUBLE(float_load) 8240 c = STATE(lchild).getCost(26 /* float_load */) + 15; 8241 if(BURS.DEBUG) trace(p, 365, c + 0, p.getCost(2) /* r */); 8242 if (c < p.getCost(2) /* r */) { 8243 p.setCost(2 /* r */, (char)(c)); 8244 p.writePacked(0, 0xFFFE00FF, 0xDA00); // p.r = 218 8245 closure_r(p, c); 8246 } 8247 } 8248 8249 /** 8250 * Labels DOUBLE_2INT tree node 8251 * @param p node to label 8252 */ 8253 private static void label_DOUBLE_2INT(AbstractBURS_TreeNode p) { 8254 p.initCost(); 8255 AbstractBURS_TreeNode lchild; 8256 lchild = p.getChild1(); 8257 label(lchild); 8258 int c; 8259 // r: DOUBLE_2INT(r) 8260 c = STATE(lchild).getCost(2 /* r */) + 13; 8261 if(BURS.DEBUG) trace(p, 370, c + 0, p.getCost(2) /* r */); 8262 if (c < p.getCost(2) /* r */) { 8263 p.setCost(2 /* r */, (char)(c)); 8264 p.writePacked(0, 0xFFFE00FF, 0xDF00); // p.r = 223 8265 closure_r(p, c); 8266 } 8267 } 8268 8269 /** 8270 * Labels DOUBLE_2LONG tree node 8271 * @param p node to label 8272 */ 8273 private static void label_DOUBLE_2LONG(AbstractBURS_TreeNode p) { 8274 p.initCost(); 8275 AbstractBURS_TreeNode lchild; 8276 lchild = p.getChild1(); 8277 label(lchild); 8278 int c; 8279 // r: DOUBLE_2LONG(r) 8280 c = STATE(lchild).getCost(2 /* r */) + 13; 8281 if(BURS.DEBUG) trace(p, 371, c + 0, p.getCost(2) /* r */); 8282 if (c < p.getCost(2) /* r */) { 8283 p.setCost(2 /* r */, (char)(c)); 8284 p.writePacked(0, 0xFFFE00FF, 0xE000); // p.r = 224 8285 closure_r(p, c); 8286 } 8287 } 8288 8289 /** 8290 * Labels DOUBLE_2FLOAT tree node 8291 * @param p node to label 8292 */ 8293 private static void label_DOUBLE_2FLOAT(AbstractBURS_TreeNode p) { 8294 p.initCost(); 8295 AbstractBURS_TreeNode lchild; 8296 lchild = p.getChild1(); 8297 label(lchild); 8298 int c; 8299 // r: DOUBLE_2FLOAT(r) 8300 c = STATE(lchild).getCost(2 /* r */) + 13; 8301 if(BURS.DEBUG) trace(p, 366, c + 0, p.getCost(2) /* r */); 8302 if (c < p.getCost(2) /* r */) { 8303 p.setCost(2 /* r */, (char)(c)); 8304 p.writePacked(0, 0xFFFE00FF, 0xDB00); // p.r = 219 8305 closure_r(p, c); 8306 } 8307 // r: DOUBLE_2FLOAT(double_load) 8308 c = STATE(lchild).getCost(27 /* double_load */) + 15; 8309 if(BURS.DEBUG) trace(p, 367, c + 0, p.getCost(2) /* r */); 8310 if (c < p.getCost(2) /* r */) { 8311 p.setCost(2 /* r */, (char)(c)); 8312 p.writePacked(0, 0xFFFE00FF, 0xDC00); // p.r = 220 8313 closure_r(p, c); 8314 } 8315 } 8316 8317 /** 8318 * Labels INT_2BYTE tree node 8319 * @param p node to label 8320 */ 8321 private static void label_INT_2BYTE(AbstractBURS_TreeNode p) { 8322 p.initCost(); 8323 AbstractBURS_TreeNode lchild; 8324 lchild = p.getChild1(); 8325 label(lchild); 8326 int c; 8327 // r: INT_2BYTE(load8_16_32) 8328 c = STATE(lchild).getCost(12 /* load8_16_32 */) + 20; 8329 if(BURS.DEBUG) trace(p, 254, c + 0, p.getCost(2) /* r */); 8330 if (c < p.getCost(2) /* r */) { 8331 p.setCost(2 /* r */, (char)(c)); 8332 p.writePacked(0, 0xFFFE00FF, 0x800); // p.r = 8 8333 closure_r(p, c); 8334 } 8335 // r: INT_2BYTE(r) 8336 c = STATE(lchild).getCost(2 /* r */) + 15; 8337 if(BURS.DEBUG) trace(p, 298, c + 0, p.getCost(2) /* r */); 8338 if (c < p.getCost(2) /* r */) { 8339 p.setCost(2 /* r */, (char)(c)); 8340 p.writePacked(0, 0xFFFE00FF, 0x4E00); // p.r = 78 8341 closure_r(p, c); 8342 } 8343 // r: INT_2BYTE(load8_16_32) 8344 c = STATE(lchild).getCost(12 /* load8_16_32 */) + 17; 8345 if(BURS.DEBUG) trace(p, 299, c + 0, p.getCost(2) /* r */); 8346 if (c < p.getCost(2) /* r */) { 8347 p.setCost(2 /* r */, (char)(c)); 8348 p.writePacked(0, 0xFFFE00FF, 0x4F00); // p.r = 79 8349 closure_r(p, c); 8350 } 8351 } 8352 8353 /** 8354 * Labels INT_2USHORT tree node 8355 * @param p node to label 8356 */ 8357 private static void label_INT_2USHORT(AbstractBURS_TreeNode p) { 8358 p.initCost(); 8359 AbstractBURS_TreeNode lchild; 8360 lchild = p.getChild1(); 8361 label(lchild); 8362 int c; 8363 // szpr: INT_2USHORT(r) 8364 c = STATE(lchild).getCost(2 /* r */) + 23; 8365 if(BURS.DEBUG) trace(p, 306, c + 0, p.getCost(5) /* szpr */); 8366 if (c < p.getCost(5) /* szpr */) { 8367 p.setCost(5 /* szpr */, (char)(c)); 8368 p.writePacked(0, 0xE07FFFFF, 0x800000); // p.szpr = 1 8369 closure_szpr(p, c); 8370 } 8371 // uload16: INT_2USHORT(load16_32) 8372 c = STATE(lchild).getCost(13 /* load16_32 */) + 0; 8373 if(BURS.DEBUG) trace(p, 307, c + 0, p.getCost(23) /* uload16 */); 8374 if (c < p.getCost(23) /* uload16 */) { 8375 p.setCost(23 /* uload16 */, (char)(c)); 8376 p.writePacked(2, 0xFF8FFFFF, 0x100000); // p.uload16 = 1 8377 closure_uload16(p, c); 8378 } 8379 // r: INT_2USHORT(load16_32) 8380 c = STATE(lchild).getCost(13 /* load16_32 */) + 15; 8381 if(BURS.DEBUG) trace(p, 308, c + 0, p.getCost(2) /* r */); 8382 if (c < p.getCost(2) /* r */) { 8383 p.setCost(2 /* r */, (char)(c)); 8384 p.writePacked(0, 0xFFFE00FF, 0x5700); // p.r = 87 8385 closure_r(p, c); 8386 } 8387 } 8388 8389 /** 8390 * Labels INT_2SHORT tree node 8391 * @param p node to label 8392 */ 8393 private static void label_INT_2SHORT(AbstractBURS_TreeNode p) { 8394 p.initCost(); 8395 AbstractBURS_TreeNode lchild; 8396 lchild = p.getChild1(); 8397 label(lchild); 8398 int c; 8399 // r: INT_2SHORT(r) 8400 c = STATE(lchild).getCost(2 /* r */) + 15; 8401 if(BURS.DEBUG) trace(p, 303, c + 0, p.getCost(2) /* r */); 8402 if (c < p.getCost(2) /* r */) { 8403 p.setCost(2 /* r */, (char)(c)); 8404 p.writePacked(0, 0xFFFE00FF, 0x5500); // p.r = 85 8405 closure_r(p, c); 8406 } 8407 // r: INT_2SHORT(load16_32) 8408 c = STATE(lchild).getCost(13 /* load16_32 */) + 17; 8409 if(BURS.DEBUG) trace(p, 304, c + 0, p.getCost(2) /* r */); 8410 if (c < p.getCost(2) /* r */) { 8411 p.setCost(2 /* r */, (char)(c)); 8412 p.writePacked(0, 0xFFFE00FF, 0x5600); // p.r = 86 8413 closure_r(p, c); 8414 } 8415 // sload16: INT_2SHORT(load16_32) 8416 c = STATE(lchild).getCost(13 /* load16_32 */) + 0; 8417 if(BURS.DEBUG) trace(p, 305, c + 0, p.getCost(22) /* sload16 */); 8418 if (c < p.getCost(22) /* sload16 */) { 8419 p.setCost(22 /* sload16 */, (char)(c)); 8420 p.writePacked(2, 0xFFF1FFFF, 0x20000); // p.sload16 = 1 8421 closure_sload16(p, c); 8422 } 8423 } 8424 8425 /** 8426 * Labels LONG_CMP tree node 8427 * @param p node to label 8428 */ 8429 private static void label_LONG_CMP(AbstractBURS_TreeNode p) { 8430 p.initCost(); 8431 AbstractBURS_TreeNode lchild, rchild; 8432 lchild = p.getChild1(); 8433 rchild = p.getChild2(); 8434 label(lchild); 8435 label(rchild); 8436 int c; 8437 // r: LONG_CMP(rlv,rlv) 8438 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 10*13; 8439 if(BURS.DEBUG) trace(p, 55, c + 0, p.getCost(2) /* r */); 8440 if (c < p.getCost(2) /* r */) { 8441 p.setCost(2 /* r */, (char)(c)); 8442 p.writePacked(0, 0xFFFE00FF, 0xC00); // p.r = 12 8443 closure_r(p, c); 8444 } 8445 } 8446 8447 /** 8448 * Labels RETURN tree node 8449 * @param p node to label 8450 */ 8451 private static void label_RETURN(AbstractBURS_TreeNode p) { 8452 p.initCost(); 8453 AbstractBURS_TreeNode lchild; 8454 lchild = p.getChild1(); 8455 label(lchild); 8456 int c; 8457 if ( // stm: RETURN(NULL) 8458 lchild.getOpcode() == NULL_opcode 8459 ) { 8460 c = 13; 8461 if(BURS.DEBUG) trace(p, 46, c + 0, p.getCost(1) /* stm */); 8462 if (c < p.getCost(1) /* stm */) { 8463 p.setCost(1 /* stm */, (char)(c)); 8464 p.writePacked(0, 0xFFFFFF00, 0x2C); // p.stm = 44 8465 } 8466 } 8467 if ( // stm: RETURN(INT_CONSTANT) 8468 lchild.getOpcode() == INT_CONSTANT_opcode 8469 ) { 8470 c = 11; 8471 if(BURS.DEBUG) trace(p, 47, c + 0, p.getCost(1) /* stm */); 8472 if (c < p.getCost(1) /* stm */) { 8473 p.setCost(1 /* stm */, (char)(c)); 8474 p.writePacked(0, 0xFFFFFF00, 0x2D); // p.stm = 45 8475 } 8476 } 8477 // stm: RETURN(r) 8478 c = STATE(lchild).getCost(2 /* r */) + 13; 8479 if(BURS.DEBUG) trace(p, 257, c + 0, p.getCost(1) /* stm */); 8480 if (c < p.getCost(1) /* stm */) { 8481 p.setCost(1 /* stm */, (char)(c)); 8482 p.writePacked(0, 0xFFFFFF00, 0x2E); // p.stm = 46 8483 } 8484 if ( // stm: RETURN(LONG_CONSTANT) 8485 lchild.getOpcode() == LONG_CONSTANT_opcode 8486 ) { 8487 c = 11; 8488 if(BURS.DEBUG) trace(p, 48, c + 0, p.getCost(1) /* stm */); 8489 if (c < p.getCost(1) /* stm */) { 8490 p.setCost(1 /* stm */, (char)(c)); 8491 p.writePacked(0, 0xFFFFFF00, 0x2F); // p.stm = 47 8492 } 8493 } 8494 } 8495 8496 /** 8497 * Labels NULL_CHECK tree node 8498 * @param p node to label 8499 */ 8500 private static void label_NULL_CHECK(AbstractBURS_TreeNode p) { 8501 p.initCost(); 8502 AbstractBURS_TreeNode lchild; 8503 lchild = p.getChild1(); 8504 label(lchild); 8505 int c; 8506 // stm: NULL_CHECK(riv) 8507 c = STATE(lchild).getCost(7 /* riv */) + 11; 8508 if(BURS.DEBUG) trace(p, 248, c + 0, p.getCost(1) /* stm */); 8509 if (c < p.getCost(1) /* stm */) { 8510 p.setCost(1 /* stm */, (char)(c)); 8511 p.writePacked(0, 0xFFFFFF00, 0xB); // p.stm = 11 8512 } 8513 } 8514 8515 /** 8516 * Labels GOTO tree node 8517 * @param p node to label 8518 */ 8519 private static void label_GOTO(AbstractBURS_TreeNode p) { 8520 p.initCost(); 8521 // stm: GOTO 8522 if(BURS.DEBUG) trace(p, 41, 11 + 0, p.getCost(1) /* stm */); 8523 if (11 < p.getCost(1) /* stm */) { 8524 p.setCost(1 /* stm */, (char)(11)); 8525 p.writePacked(0, 0xFFFFFF00, 0x26); // p.stm = 38 8526 } 8527 } 8528 8529 /** 8530 * Labels BOOLEAN_NOT tree node 8531 * @param p node to label 8532 */ 8533 private static void label_BOOLEAN_NOT(AbstractBURS_TreeNode p) { 8534 p.initCost(); 8535 AbstractBURS_TreeNode lchild; 8536 lchild = p.getChild1(); 8537 label(lchild); 8538 int c; 8539 // r: BOOLEAN_NOT(r) 8540 c = STATE(lchild).getCost(2 /* r */) + 13; 8541 if(BURS.DEBUG) trace(p, 293, c + 0, p.getCost(2) /* r */); 8542 if (c < p.getCost(2) /* r */) { 8543 p.setCost(2 /* r */, (char)(c)); 8544 p.writePacked(0, 0xFFFE00FF, 0x3C00); // p.r = 60 8545 closure_r(p, c); 8546 } 8547 } 8548 8549 /** 8550 * Labels BOOLEAN_CMP_INT tree node 8551 * @param p node to label 8552 */ 8553 private static void label_BOOLEAN_CMP_INT(AbstractBURS_TreeNode p) { 8554 p.initCost(); 8555 AbstractBURS_TreeNode lchild, rchild; 8556 lchild = p.getChild1(); 8557 rchild = p.getChild2(); 8558 label(lchild); 8559 label(rchild); 8560 int c; 8561 // r: BOOLEAN_CMP_INT(r,riv) 8562 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 39; 8563 if(BURS.DEBUG) trace(p, 69, c + 0, p.getCost(2) /* r */); 8564 if (c < p.getCost(2) /* r */) { 8565 p.setCost(2 /* r */, (char)(c)); 8566 p.writePacked(0, 0xFFFE00FF, 0x2600); // p.r = 38 8567 closure_r(p, c); 8568 } 8569 // boolcmp: BOOLEAN_CMP_INT(r,riv) 8570 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 8571 if(BURS.DEBUG) trace(p, 70, c + 0, p.getCost(19) /* boolcmp */); 8572 if (c < p.getCost(19) /* boolcmp */) { 8573 p.setCost(19 /* boolcmp */, (char)(c)); 8574 p.writePacked(2, 0xFFFFF0FF, 0x100); // p.boolcmp = 1 8575 } 8576 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 8577 rchild.getOpcode() == INT_CONSTANT_opcode 8578 ) { 8579 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 37:INFINITE); 8580 if(BURS.DEBUG) trace(p, 270, c + 0, p.getCost(2) /* r */); 8581 if (c < p.getCost(2) /* r */) { 8582 p.setCost(2 /* r */, (char)(c)); 8583 p.writePacked(0, 0xFFFE00FF, 0x2700); // p.r = 39 8584 closure_r(p, c); 8585 } 8586 } 8587 if ( // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 8588 rchild.getOpcode() == INT_CONSTANT_opcode 8589 ) { 8590 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 11:INFINITE); 8591 if(BURS.DEBUG) trace(p, 271, c + 0, p.getCost(19) /* boolcmp */); 8592 if (c < p.getCost(19) /* boolcmp */) { 8593 p.setCost(19 /* boolcmp */, (char)(c)); 8594 p.writePacked(2, 0xFFFFF0FF, 0x200); // p.boolcmp = 2 8595 } 8596 } 8597 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 8598 rchild.getOpcode() == INT_CONSTANT_opcode 8599 ) { 8600 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isLESS() ? 11 : INFINITE); 8601 if(BURS.DEBUG) trace(p, 272, c + 0, p.getCost(2) /* r */); 8602 if (c < p.getCost(2) /* r */) { 8603 p.setCost(2 /* r */, (char)(c)); 8604 p.writePacked(0, 0xFFFE00FF, 0x2800); // p.r = 40 8605 closure_r(p, c); 8606 } 8607 } 8608 if ( // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 8609 rchild.getOpcode() == INT_CONSTANT_opcode 8610 ) { 8611 c = STATE(lchild).getCost(10 /* load32 */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isLESS() ? 16 : INFINITE); 8612 if(BURS.DEBUG) trace(p, 273, c + 0, p.getCost(2) /* r */); 8613 if (c < p.getCost(2) /* r */) { 8614 p.setCost(2 /* r */, (char)(c)); 8615 p.writePacked(0, 0xFFFE00FF, 0x2900); // p.r = 41 8616 closure_r(p, c); 8617 } 8618 } 8619 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 8620 rchild.getOpcode() == INT_CONSTANT_opcode 8621 ) { 8622 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 22 : INFINITE); 8623 if(BURS.DEBUG) trace(p, 274, c + 0, p.getCost(2) /* r */); 8624 if (c < p.getCost(2) /* r */) { 8625 p.setCost(2 /* r */, (char)(c)); 8626 p.writePacked(0, 0xFFFE00FF, 0x2A00); // p.r = 42 8627 closure_r(p, c); 8628 } 8629 } 8630 if ( // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 8631 rchild.getOpcode() == INT_CONSTANT_opcode 8632 ) { 8633 c = STATE(lchild).getCost(10 /* load32 */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 27 : INFINITE); 8634 if(BURS.DEBUG) trace(p, 275, c + 0, p.getCost(2) /* r */); 8635 if (c < p.getCost(2) /* r */) { 8636 p.setCost(2 /* r */, (char)(c)); 8637 p.writePacked(0, 0xFFFE00FF, 0x2B00); // p.r = 43 8638 closure_r(p, c); 8639 } 8640 } 8641 if ( // r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 8642 rchild.getOpcode() == INT_CONSTANT_opcode 8643 ) { 8644 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 26); 8645 if(BURS.DEBUG) trace(p, 276, c + 0, p.getCost(2) /* r */); 8646 if (c < p.getCost(2) /* r */) { 8647 p.setCost(2 /* r */, (char)(c)); 8648 p.writePacked(0, 0xFFFE00FF, 0x2C00); // p.r = 44 8649 closure_r(p, c); 8650 } 8651 } 8652 if ( // boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 8653 rchild.getOpcode() == INT_CONSTANT_opcode 8654 ) { 8655 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 0); 8656 if(BURS.DEBUG) trace(p, 277, c + 0, p.getCost(19) /* boolcmp */); 8657 if (c < p.getCost(19) /* boolcmp */) { 8658 p.setCost(19 /* boolcmp */, (char)(c)); 8659 p.writePacked(2, 0xFFFFF0FF, 0x300); // p.boolcmp = 3 8660 } 8661 } 8662 if ( // r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 8663 rchild.getOpcode() == INT_CONSTANT_opcode 8664 ) { 8665 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(BooleanCmp.getCond(P(p)))?26:INFINITE); 8666 if(BURS.DEBUG) trace(p, 278, c + 0, p.getCost(2) /* r */); 8667 if (c < p.getCost(2) /* r */) { 8668 p.setCost(2 /* r */, (char)(c)); 8669 p.writePacked(0, 0xFFFE00FF, 0x2D00); // p.r = 45 8670 closure_r(p, c); 8671 } 8672 } 8673 if ( // boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 8674 rchild.getOpcode() == INT_CONSTANT_opcode 8675 ) { 8676 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(BooleanCmp.getCond(P(p)))?0:INFINITE); 8677 if(BURS.DEBUG) trace(p, 279, c + 0, p.getCost(19) /* boolcmp */); 8678 if (c < p.getCost(19) /* boolcmp */) { 8679 p.setCost(19 /* boolcmp */, (char)(c)); 8680 p.writePacked(2, 0xFFFFF0FF, 0x400); // p.boolcmp = 4 8681 } 8682 } 8683 if ( // r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 8684 rchild.getOpcode() == INT_CONSTANT_opcode 8685 ) { 8686 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(BooleanCmp.getCond(P(p))) ? 26 : INFINITE); 8687 if(BURS.DEBUG) trace(p, 280, c + 0, p.getCost(2) /* r */); 8688 if (c < p.getCost(2) /* r */) { 8689 p.setCost(2 /* r */, (char)(c)); 8690 p.writePacked(0, 0xFFFE00FF, 0x2E00); // p.r = 46 8691 closure_r(p, c); 8692 } 8693 } 8694 if ( // boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 8695 rchild.getOpcode() == INT_CONSTANT_opcode 8696 ) { 8697 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(BooleanCmp.getCond(P(p))) ? 0 : INFINITE); 8698 if(BURS.DEBUG) trace(p, 281, c + 0, p.getCost(19) /* boolcmp */); 8699 if (c < p.getCost(19) /* boolcmp */) { 8700 p.setCost(19 /* boolcmp */, (char)(c)); 8701 p.writePacked(2, 0xFFFFF0FF, 0x500); // p.boolcmp = 5 8702 } 8703 } 8704 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 8705 rchild.getOpcode() == INT_CONSTANT_opcode 8706 ) { 8707 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 0 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()) || (VR(p) == 1 && BooleanCmp.getCond(P(p)).isEQUAL()) ? 26 : INFINITE); 8708 if(BURS.DEBUG) trace(p, 282, c + 0, p.getCost(2) /* r */); 8709 if (c < p.getCost(2) /* r */) { 8710 p.setCost(2 /* r */, (char)(c)); 8711 p.writePacked(0, 0xFFFE00FF, 0x2F00); // p.r = 47 8712 closure_r(p, c); 8713 } 8714 } 8715 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 8716 rchild.getOpcode() == INT_CONSTANT_opcode 8717 ) { 8718 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 0 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()) || (VR(p) == 1 && BooleanCmp.getCond(P(p)).isEQUAL()) ? 0 : INFINITE); 8719 if(BURS.DEBUG) trace(p, 283, c + 0, p.getCost(19) /* boolcmp */); 8720 if (c < p.getCost(19) /* boolcmp */) { 8721 p.setCost(19 /* boolcmp */, (char)(c)); 8722 p.writePacked(2, 0xFFFFF0FF, 0x600); // p.boolcmp = 6 8723 } 8724 } 8725 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 8726 rchild.getOpcode() == INT_CONSTANT_opcode 8727 ) { 8728 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 1 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()) || (VR(p) == 0 && BooleanCmp.getCond(P(p)).isEQUAL()) ? 26 : INFINITE); 8729 if(BURS.DEBUG) trace(p, 284, c + 0, p.getCost(2) /* r */); 8730 if (c < p.getCost(2) /* r */) { 8731 p.setCost(2 /* r */, (char)(c)); 8732 p.writePacked(0, 0xFFFE00FF, 0x3000); // p.r = 48 8733 closure_r(p, c); 8734 } 8735 } 8736 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 8737 rchild.getOpcode() == INT_CONSTANT_opcode 8738 ) { 8739 c = STATE(lchild).getCost(19 /* boolcmp */) + ((VR(p) == 1 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()) || (VR(p) == 0 && BooleanCmp.getCond(P(p)).isEQUAL()) ? 0 : INFINITE); 8740 if(BURS.DEBUG) trace(p, 285, c + 0, p.getCost(19) /* boolcmp */); 8741 if (c < p.getCost(19) /* boolcmp */) { 8742 p.setCost(19 /* boolcmp */, (char)(c)); 8743 p.writePacked(2, 0xFFFFF0FF, 0x700); // p.boolcmp = 7 8744 } 8745 } 8746 // r: BOOLEAN_CMP_INT(load32,riv) 8747 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 41; 8748 if(BURS.DEBUG) trace(p, 71, c + 0, p.getCost(2) /* r */); 8749 if (c < p.getCost(2) /* r */) { 8750 p.setCost(2 /* r */, (char)(c)); 8751 p.writePacked(0, 0xFFFE00FF, 0x3100); // p.r = 49 8752 closure_r(p, c); 8753 } 8754 // boolcmp: BOOLEAN_CMP_INT(load32,riv) 8755 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 8756 if(BURS.DEBUG) trace(p, 72, c + 0, p.getCost(19) /* boolcmp */); 8757 if (c < p.getCost(19) /* boolcmp */) { 8758 p.setCost(19 /* boolcmp */, (char)(c)); 8759 p.writePacked(2, 0xFFFFF0FF, 0x800); // p.boolcmp = 8 8760 } 8761 // r: BOOLEAN_CMP_INT(r,load32) 8762 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 41; 8763 if(BURS.DEBUG) trace(p, 73, c + 0, p.getCost(2) /* r */); 8764 if (c < p.getCost(2) /* r */) { 8765 p.setCost(2 /* r */, (char)(c)); 8766 p.writePacked(0, 0xFFFE00FF, 0x3200); // p.r = 50 8767 closure_r(p, c); 8768 } 8769 // boolcmp: BOOLEAN_CMP_INT(riv,load32) 8770 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 8771 if(BURS.DEBUG) trace(p, 74, c + 0, p.getCost(19) /* boolcmp */); 8772 if (c < p.getCost(19) /* boolcmp */) { 8773 p.setCost(19 /* boolcmp */, (char)(c)); 8774 p.writePacked(2, 0xFFFFF0FF, 0x900); // p.boolcmp = 9 8775 } 8776 } 8777 8778 /** 8779 * Labels BOOLEAN_CMP_LONG tree node 8780 * @param p node to label 8781 */ 8782 private static void label_BOOLEAN_CMP_LONG(AbstractBURS_TreeNode p) { 8783 p.initCost(); 8784 AbstractBURS_TreeNode lchild, rchild; 8785 lchild = p.getChild1(); 8786 rchild = p.getChild2(); 8787 label(lchild); 8788 label(rchild); 8789 int c; 8790 // r: BOOLEAN_CMP_LONG(r,rlv) 8791 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 39; 8792 if(BURS.DEBUG) trace(p, 75, c + 0, p.getCost(2) /* r */); 8793 if (c < p.getCost(2) /* r */) { 8794 p.setCost(2 /* r */, (char)(c)); 8795 p.writePacked(0, 0xFFFE00FF, 0x3300); // p.r = 51 8796 closure_r(p, c); 8797 } 8798 // boolcmp: BOOLEAN_CMP_LONG(r,rlv) 8799 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 13; 8800 if(BURS.DEBUG) trace(p, 76, c + 0, p.getCost(19) /* boolcmp */); 8801 if (c < p.getCost(19) /* boolcmp */) { 8802 p.setCost(19 /* boolcmp */, (char)(c)); 8803 p.writePacked(2, 0xFFFFF0FF, 0xA00); // p.boolcmp = 10 8804 } 8805 if ( // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 8806 rchild.getOpcode() == LONG_CONSTANT_opcode 8807 ) { 8808 c = STATE(lchild).getCost(2 /* r */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 37:INFINITE); 8809 if(BURS.DEBUG) trace(p, 286, c + 0, p.getCost(2) /* r */); 8810 if (c < p.getCost(2) /* r */) { 8811 p.setCost(2 /* r */, (char)(c)); 8812 p.writePacked(0, 0xFFFE00FF, 0x3400); // p.r = 52 8813 closure_r(p, c); 8814 } 8815 } 8816 if ( // boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 8817 rchild.getOpcode() == LONG_CONSTANT_opcode 8818 ) { 8819 c = STATE(lchild).getCost(2 /* r */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 11:INFINITE); 8820 if(BURS.DEBUG) trace(p, 287, c + 0, p.getCost(19) /* boolcmp */); 8821 if (c < p.getCost(19) /* boolcmp */) { 8822 p.setCost(19 /* boolcmp */, (char)(c)); 8823 p.writePacked(2, 0xFFFFF0FF, 0xB00); // p.boolcmp = 11 8824 } 8825 } 8826 if ( // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 8827 rchild.getOpcode() == LONG_CONSTANT_opcode 8828 ) { 8829 c = STATE(lchild).getCost(2 /* r */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && BooleanCmp.getCond(P(p)).isLESS() ? 11 : INFINITE); 8830 if(BURS.DEBUG) trace(p, 288, c + 0, p.getCost(2) /* r */); 8831 if (c < p.getCost(2) /* r */) { 8832 p.setCost(2 /* r */, (char)(c)); 8833 p.writePacked(0, 0xFFFE00FF, 0x3500); // p.r = 53 8834 closure_r(p, c); 8835 } 8836 } 8837 if ( // r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 8838 rchild.getOpcode() == LONG_CONSTANT_opcode 8839 ) { 8840 c = STATE(lchild).getCost(20 /* load64 */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && BooleanCmp.getCond(P(p)).isLESS() ? 16 : INFINITE); 8841 if(BURS.DEBUG) trace(p, 289, c + 0, p.getCost(2) /* r */); 8842 if (c < p.getCost(2) /* r */) { 8843 p.setCost(2 /* r */, (char)(c)); 8844 p.writePacked(0, 0xFFFE00FF, 0x3600); // p.r = 54 8845 closure_r(p, c); 8846 } 8847 } 8848 if ( // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 8849 rchild.getOpcode() == LONG_CONSTANT_opcode 8850 ) { 8851 c = STATE(lchild).getCost(2 /* r */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 22 : INFINITE); 8852 if(BURS.DEBUG) trace(p, 290, c + 0, p.getCost(2) /* r */); 8853 if (c < p.getCost(2) /* r */) { 8854 p.setCost(2 /* r */, (char)(c)); 8855 p.writePacked(0, 0xFFFE00FF, 0x3700); // p.r = 55 8856 closure_r(p, c); 8857 } 8858 } 8859 if ( // r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 8860 rchild.getOpcode() == LONG_CONSTANT_opcode 8861 ) { 8862 c = STATE(lchild).getCost(20 /* load64 */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 27 : INFINITE); 8863 if(BURS.DEBUG) trace(p, 291, c + 0, p.getCost(2) /* r */); 8864 if (c < p.getCost(2) /* r */) { 8865 p.setCost(2 /* r */, (char)(c)); 8866 p.writePacked(0, 0xFFFE00FF, 0x3800); // p.r = 56 8867 closure_r(p, c); 8868 } 8869 } 8870 if ( // r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) 8871 rchild.getOpcode() == LONG_CONSTANT_opcode 8872 ) { 8873 c = STATE(lchild).getCost(4 /* cz */) + ((LV(BooleanCmp.getVal2(P(p))) == 0) ? 26 : INFINITE); 8874 if(BURS.DEBUG) trace(p, 292, c + 0, p.getCost(2) /* r */); 8875 if (c < p.getCost(2) /* r */) { 8876 p.setCost(2 /* r */, (char)(c)); 8877 p.writePacked(0, 0xFFFE00FF, 0x3900); // p.r = 57 8878 closure_r(p, c); 8879 } 8880 } 8881 // r: BOOLEAN_CMP_LONG(load64,rlv) 8882 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 41; 8883 if(BURS.DEBUG) trace(p, 77, c + 0, p.getCost(2) /* r */); 8884 if (c < p.getCost(2) /* r */) { 8885 p.setCost(2 /* r */, (char)(c)); 8886 p.writePacked(0, 0xFFFE00FF, 0x3A00); // p.r = 58 8887 closure_r(p, c); 8888 } 8889 // boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 8890 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 15; 8891 if(BURS.DEBUG) trace(p, 78, c + 0, p.getCost(19) /* boolcmp */); 8892 if (c < p.getCost(19) /* boolcmp */) { 8893 p.setCost(19 /* boolcmp */, (char)(c)); 8894 p.writePacked(2, 0xFFFFF0FF, 0xC00); // p.boolcmp = 12 8895 } 8896 // r: BOOLEAN_CMP_LONG(r,load64) 8897 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(20 /* load64 */) + 41; 8898 if(BURS.DEBUG) trace(p, 79, c + 0, p.getCost(2) /* r */); 8899 if (c < p.getCost(2) /* r */) { 8900 p.setCost(2 /* r */, (char)(c)); 8901 p.writePacked(0, 0xFFFE00FF, 0x3B00); // p.r = 59 8902 closure_r(p, c); 8903 } 8904 // boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 8905 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(20 /* load64 */) + 15; 8906 if(BURS.DEBUG) trace(p, 80, c + 0, p.getCost(19) /* boolcmp */); 8907 if (c < p.getCost(19) /* boolcmp */) { 8908 p.setCost(19 /* boolcmp */, (char)(c)); 8909 p.writePacked(2, 0xFFFFF0FF, 0xD00); // p.boolcmp = 13 8910 } 8911 } 8912 8913 /** 8914 * Labels BYTE_LOAD tree node 8915 * @param p node to label 8916 */ 8917 private static void label_BYTE_LOAD(AbstractBURS_TreeNode p) { 8918 p.initCost(); 8919 AbstractBURS_TreeNode lchild, rchild; 8920 lchild = p.getChild1(); 8921 rchild = p.getChild2(); 8922 label(lchild); 8923 label(rchild); 8924 int c; 8925 // r: BYTE_LOAD(rlv,rlv) 8926 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 20; 8927 if(BURS.DEBUG) trace(p, 130, c + 0, p.getCost(2) /* r */); 8928 if (c < p.getCost(2) /* r */) { 8929 p.setCost(2 /* r */, (char)(c)); 8930 p.writePacked(0, 0xFFFE00FF, 0x7E00); // p.r = 126 8931 closure_r(p, c); 8932 } 8933 // sload8: BYTE_LOAD(rlv,rlv) 8934 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 8935 if(BURS.DEBUG) trace(p, 131, c + 0, p.getCost(24) /* sload8 */); 8936 if (c < p.getCost(24) /* sload8 */) { 8937 p.setCost(24 /* sload8 */, (char)(c)); 8938 p.writePacked(2, 0xFE7FFFFF, 0x1000000); // p.sload8 = 2 8939 closure_sload8(p, c); 8940 } 8941 } 8942 8943 /** 8944 * Labels UBYTE_LOAD tree node 8945 * @param p node to label 8946 */ 8947 private static void label_UBYTE_LOAD(AbstractBURS_TreeNode p) { 8948 p.initCost(); 8949 AbstractBURS_TreeNode lchild, rchild; 8950 lchild = p.getChild1(); 8951 rchild = p.getChild2(); 8952 label(lchild); 8953 label(rchild); 8954 int c; 8955 // r: UBYTE_LOAD(rlv,rlv) 8956 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 8957 if(BURS.DEBUG) trace(p, 135, c + 0, p.getCost(2) /* r */); 8958 if (c < p.getCost(2) /* r */) { 8959 p.setCost(2 /* r */, (char)(c)); 8960 p.writePacked(0, 0xFFFE00FF, 0x8100); // p.r = 129 8961 closure_r(p, c); 8962 } 8963 // uload8: UBYTE_LOAD(rlv,rlv) 8964 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 8965 if(BURS.DEBUG) trace(p, 136, c + 0, p.getCost(11) /* uload8 */); 8966 if (c < p.getCost(11) /* uload8 */) { 8967 p.setCost(11 /* uload8 */, (char)(c)); 8968 p.writePacked(1, 0xFFFE3FFF, 0xC000); // p.uload8 = 3 8969 closure_uload8(p, c); 8970 } 8971 } 8972 8973 /** 8974 * Labels SHORT_LOAD tree node 8975 * @param p node to label 8976 */ 8977 private static void label_SHORT_LOAD(AbstractBURS_TreeNode p) { 8978 p.initCost(); 8979 AbstractBURS_TreeNode lchild, rchild; 8980 lchild = p.getChild1(); 8981 rchild = p.getChild2(); 8982 label(lchild); 8983 label(rchild); 8984 int c; 8985 // r: SHORT_LOAD(rlv,rlv) 8986 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 20; 8987 if(BURS.DEBUG) trace(p, 140, c + 0, p.getCost(2) /* r */); 8988 if (c < p.getCost(2) /* r */) { 8989 p.setCost(2 /* r */, (char)(c)); 8990 p.writePacked(0, 0xFFFE00FF, 0x8400); // p.r = 132 8991 closure_r(p, c); 8992 } 8993 // sload16: SHORT_LOAD(rlv,rlv) 8994 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 8995 if(BURS.DEBUG) trace(p, 141, c + 0, p.getCost(22) /* sload16 */); 8996 if (c < p.getCost(22) /* sload16 */) { 8997 p.setCost(22 /* sload16 */, (char)(c)); 8998 p.writePacked(2, 0xFFF1FFFF, 0x60000); // p.sload16 = 3 8999 closure_sload16(p, c); 9000 } 9001 } 9002 9003 /** 9004 * Labels USHORT_LOAD tree node 9005 * @param p node to label 9006 */ 9007 private static void label_USHORT_LOAD(AbstractBURS_TreeNode p) { 9008 p.initCost(); 9009 AbstractBURS_TreeNode lchild, rchild; 9010 lchild = p.getChild1(); 9011 rchild = p.getChild2(); 9012 label(lchild); 9013 label(rchild); 9014 int c; 9015 // r: USHORT_LOAD(rlv,rlv) 9016 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9017 if(BURS.DEBUG) trace(p, 145, c + 0, p.getCost(2) /* r */); 9018 if (c < p.getCost(2) /* r */) { 9019 p.setCost(2 /* r */, (char)(c)); 9020 p.writePacked(0, 0xFFFE00FF, 0x8700); // p.r = 135 9021 closure_r(p, c); 9022 } 9023 // uload16: USHORT_LOAD(rlv,rlv) 9024 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 9025 if(BURS.DEBUG) trace(p, 146, c + 0, p.getCost(23) /* uload16 */); 9026 if (c < p.getCost(23) /* uload16 */) { 9027 p.setCost(23 /* uload16 */, (char)(c)); 9028 p.writePacked(2, 0xFF8FFFFF, 0x300000); // p.uload16 = 3 9029 closure_uload16(p, c); 9030 } 9031 } 9032 9033 /** 9034 * Labels INT_LOAD tree node 9035 * @param p node to label 9036 */ 9037 private static void label_INT_LOAD(AbstractBURS_TreeNode p) { 9038 p.initCost(); 9039 AbstractBURS_TreeNode lchild, rchild; 9040 lchild = p.getChild1(); 9041 rchild = p.getChild2(); 9042 label(lchild); 9043 label(rchild); 9044 int c; 9045 // r: INT_LOAD(rlv,rlv) 9046 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9047 if(BURS.DEBUG) trace(p, 101, c + 0, p.getCost(2) /* r */); 9048 if (c < p.getCost(2) /* r */) { 9049 p.setCost(2 /* r */, (char)(c)); 9050 p.writePacked(0, 0xFFFE00FF, 0x5B00); // p.r = 91 9051 closure_r(p, c); 9052 } 9053 // r: INT_LOAD(rlv,address1scaledreg) 9054 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 15; 9055 if(BURS.DEBUG) trace(p, 102, c + 0, p.getCost(2) /* r */); 9056 if (c < p.getCost(2) /* r */) { 9057 p.setCost(2 /* r */, (char)(c)); 9058 p.writePacked(0, 0xFFFE00FF, 0x5C00); // p.r = 92 9059 closure_r(p, c); 9060 } 9061 // r: INT_LOAD(address1scaledreg,rlv) 9062 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9063 if(BURS.DEBUG) trace(p, 103, c + 0, p.getCost(2) /* r */); 9064 if (c < p.getCost(2) /* r */) { 9065 p.setCost(2 /* r */, (char)(c)); 9066 p.writePacked(0, 0xFFFE00FF, 0x5D00); // p.r = 93 9067 closure_r(p, c); 9068 } 9069 // r: INT_LOAD(address1scaledreg,address1reg) 9070 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(16 /* address1reg */) + 15; 9071 if(BURS.DEBUG) trace(p, 104, c + 0, p.getCost(2) /* r */); 9072 if (c < p.getCost(2) /* r */) { 9073 p.setCost(2 /* r */, (char)(c)); 9074 p.writePacked(0, 0xFFFE00FF, 0x5E00); // p.r = 94 9075 closure_r(p, c); 9076 } 9077 // r: INT_LOAD(address1reg,address1scaledreg) 9078 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 15; 9079 if(BURS.DEBUG) trace(p, 105, c + 0, p.getCost(2) /* r */); 9080 if (c < p.getCost(2) /* r */) { 9081 p.setCost(2 /* r */, (char)(c)); 9082 p.writePacked(0, 0xFFFE00FF, 0x5F00); // p.r = 95 9083 closure_r(p, c); 9084 } 9085 if ( // r: INT_LOAD(address,LONG_CONSTANT) 9086 rchild.getOpcode() == LONG_CONSTANT_opcode 9087 ) { 9088 c = STATE(lchild).getCost(17 /* address */) + 15; 9089 if(BURS.DEBUG) trace(p, 317, c + 0, p.getCost(2) /* r */); 9090 if (c < p.getCost(2) /* r */) { 9091 p.setCost(2 /* r */, (char)(c)); 9092 p.writePacked(0, 0xFFFE00FF, 0x6000); // p.r = 96 9093 closure_r(p, c); 9094 } 9095 } 9096 // load32: INT_LOAD(rlv,rlv) 9097 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 9098 if(BURS.DEBUG) trace(p, 150, c + 0, p.getCost(10) /* load32 */); 9099 if (c < p.getCost(10) /* load32 */) { 9100 p.setCost(10 /* load32 */, (char)(c)); 9101 p.writePacked(1, 0xFFFFC7FF, 0x1000); // p.load32 = 2 9102 closure_load32(p, c); 9103 } 9104 } 9105 9106 /** 9107 * Labels LONG_LOAD tree node 9108 * @param p node to label 9109 */ 9110 private static void label_LONG_LOAD(AbstractBURS_TreeNode p) { 9111 p.initCost(); 9112 AbstractBURS_TreeNode lchild, rchild; 9113 lchild = p.getChild1(); 9114 rchild = p.getChild2(); 9115 label(lchild); 9116 label(rchild); 9117 int c; 9118 // load64: LONG_LOAD(rlv,rlv) 9119 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 9120 if(BURS.DEBUG) trace(p, 152, c + 0, p.getCost(20) /* load64 */); 9121 if (c < p.getCost(20) /* load64 */) { 9122 p.setCost(20 /* load64 */, (char)(c)); 9123 p.writePacked(2, 0xFFFF8FFF, 0x1000); // p.load64 = 1 9124 closure_load64(p, c); 9125 } 9126 // r: LONG_LOAD(rlv,rlv) 9127 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9128 if(BURS.DEBUG) trace(p, 174, c + 0, p.getCost(2) /* r */); 9129 if (c < p.getCost(2) /* r */) { 9130 p.setCost(2 /* r */, (char)(c)); 9131 p.writePacked(0, 0xFFFE00FF, 0x9600); // p.r = 150 9132 closure_r(p, c); 9133 } 9134 // r: LONG_LOAD(rlv,address1scaledreg) 9135 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 15; 9136 if(BURS.DEBUG) trace(p, 175, c + 0, p.getCost(2) /* r */); 9137 if (c < p.getCost(2) /* r */) { 9138 p.setCost(2 /* r */, (char)(c)); 9139 p.writePacked(0, 0xFFFE00FF, 0x9700); // p.r = 151 9140 closure_r(p, c); 9141 } 9142 // r: LONG_LOAD(address1scaledreg,rlv) 9143 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9144 if(BURS.DEBUG) trace(p, 176, c + 0, p.getCost(2) /* r */); 9145 if (c < p.getCost(2) /* r */) { 9146 p.setCost(2 /* r */, (char)(c)); 9147 p.writePacked(0, 0xFFFE00FF, 0x9800); // p.r = 152 9148 closure_r(p, c); 9149 } 9150 // r: LONG_LOAD(address1scaledreg,address1reg) 9151 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild).getCost(16 /* address1reg */) + 15; 9152 if(BURS.DEBUG) trace(p, 177, c + 0, p.getCost(2) /* r */); 9153 if (c < p.getCost(2) /* r */) { 9154 p.setCost(2 /* r */, (char)(c)); 9155 p.writePacked(0, 0xFFFE00FF, 0x9900); // p.r = 153 9156 closure_r(p, c); 9157 } 9158 // r: LONG_LOAD(address1reg,address1scaledreg) 9159 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild).getCost(15 /* address1scaledreg */) + 15; 9160 if(BURS.DEBUG) trace(p, 178, c + 0, p.getCost(2) /* r */); 9161 if (c < p.getCost(2) /* r */) { 9162 p.setCost(2 /* r */, (char)(c)); 9163 p.writePacked(0, 0xFFFE00FF, 0x9A00); // p.r = 154 9164 closure_r(p, c); 9165 } 9166 if ( // r: LONG_LOAD(address,LONG_CONSTANT) 9167 rchild.getOpcode() == LONG_CONSTANT_opcode 9168 ) { 9169 c = STATE(lchild).getCost(17 /* address */) + 15; 9170 if(BURS.DEBUG) trace(p, 342, c + 0, p.getCost(2) /* r */); 9171 if (c < p.getCost(2) /* r */) { 9172 p.setCost(2 /* r */, (char)(c)); 9173 p.writePacked(0, 0xFFFE00FF, 0x9B00); // p.r = 155 9174 closure_r(p, c); 9175 } 9176 } 9177 } 9178 9179 /** 9180 * Labels FLOAT_LOAD tree node 9181 * @param p node to label 9182 */ 9183 private static void label_FLOAT_LOAD(AbstractBURS_TreeNode p) { 9184 p.initCost(); 9185 AbstractBURS_TreeNode lchild, rchild; 9186 lchild = p.getChild1(); 9187 rchild = p.getChild2(); 9188 label(lchild); 9189 label(rchild); 9190 int c; 9191 // r: FLOAT_LOAD(riv,riv) 9192 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 9193 if(BURS.DEBUG) trace(p, 234, c + 0, p.getCost(2) /* r */); 9194 if (c < p.getCost(2) /* r */) { 9195 p.setCost(2 /* r */, (char)(c)); 9196 p.writePacked(0, 0xFFFE00FF, 0xD000); // p.r = 208 9197 closure_r(p, c); 9198 } 9199 // r: FLOAT_LOAD(rlv,rlv) 9200 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9201 if(BURS.DEBUG) trace(p, 235, c + 0, p.getCost(2) /* r */); 9202 if (c < p.getCost(2) /* r */) { 9203 p.setCost(2 /* r */, (char)(c)); 9204 p.writePacked(0, 0xFFFE00FF, 0xD100); // p.r = 209 9205 closure_r(p, c); 9206 } 9207 // float_load: FLOAT_LOAD(riv,riv) 9208 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 9209 if(BURS.DEBUG) trace(p, 236, c + 0, p.getCost(26) /* float_load */); 9210 if (c < p.getCost(26) /* float_load */) { 9211 p.setCost(26 /* float_load */, (char)(c)); 9212 p.writePacked(2, 0xC7FFFFFF, 0x8000000); // p.float_load = 1 9213 } 9214 } 9215 9216 /** 9217 * Labels DOUBLE_LOAD tree node 9218 * @param p node to label 9219 */ 9220 private static void label_DOUBLE_LOAD(AbstractBURS_TreeNode p) { 9221 p.initCost(); 9222 AbstractBURS_TreeNode lchild, rchild; 9223 lchild = p.getChild1(); 9224 rchild = p.getChild2(); 9225 label(lchild); 9226 label(rchild); 9227 int c; 9228 // r: DOUBLE_LOAD(riv,riv) 9229 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 9230 if(BURS.DEBUG) trace(p, 225, c + 0, p.getCost(2) /* r */); 9231 if (c < p.getCost(2) /* r */) { 9232 p.setCost(2 /* r */, (char)(c)); 9233 p.writePacked(0, 0xFFFE00FF, 0xCA00); // p.r = 202 9234 closure_r(p, c); 9235 } 9236 // r: DOUBLE_LOAD(riv,rlv) 9237 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9238 if(BURS.DEBUG) trace(p, 226, c + 0, p.getCost(2) /* r */); 9239 if (c < p.getCost(2) /* r */) { 9240 p.setCost(2 /* r */, (char)(c)); 9241 p.writePacked(0, 0xFFFE00FF, 0xCB00); // p.r = 203 9242 closure_r(p, c); 9243 } 9244 // r: DOUBLE_LOAD(rlv,rlv) 9245 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 9246 if(BURS.DEBUG) trace(p, 227, c + 0, p.getCost(2) /* r */); 9247 if (c < p.getCost(2) /* r */) { 9248 p.setCost(2 /* r */, (char)(c)); 9249 p.writePacked(0, 0xFFFE00FF, 0xCC00); // p.r = 204 9250 closure_r(p, c); 9251 } 9252 // double_load: DOUBLE_LOAD(riv,riv) 9253 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 9254 if(BURS.DEBUG) trace(p, 228, c + 0, p.getCost(27) /* double_load */); 9255 if (c < p.getCost(27) /* double_load */) { 9256 p.setCost(27 /* double_load */, (char)(c)); 9257 p.writePacked(3, 0xFFFFFFF8, 0x1); // p.double_load = 1 9258 } 9259 // double_load: DOUBLE_LOAD(rlv,rlv) 9260 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 9261 if(BURS.DEBUG) trace(p, 230, c + 0, p.getCost(27) /* double_load */); 9262 if (c < p.getCost(27) /* double_load */) { 9263 p.setCost(27 /* double_load */, (char)(c)); 9264 p.writePacked(3, 0xFFFFFFF8, 0x2); // p.double_load = 2 9265 } 9266 } 9267 9268 /** 9269 * Labels BYTE_STORE tree node 9270 * @param p node to label 9271 */ 9272 private static void label_BYTE_STORE(AbstractBURS_TreeNode p) { 9273 p.initCost(); 9274 AbstractBURS_TreeNode lchild, rchild; 9275 lchild = p.getChild1(); 9276 rchild = p.getChild2(); 9277 label(lchild); 9278 label(rchild); 9279 int c; 9280 if ( // stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 9281 rchild.getOpcode() == OTHER_OPERAND_opcode 9282 ) { 9283 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9284 if(BURS.DEBUG) trace(p, 412, c + 0, p.getCost(1) /* stm */); 9285 if (c < p.getCost(1) /* stm */) { 9286 p.setCost(1 /* stm */, (char)(c)); 9287 p.writePacked(0, 0xFFFFFF00, 0x4D); // p.stm = 77 9288 } 9289 } 9290 if ( // stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 9291 lchild.getOpcode() == BOOLEAN_NOT_opcode && 9292 lchild.getChild1().getOpcode() == UBYTE_LOAD_opcode && 9293 rchild.getOpcode() == OTHER_OPERAND_opcode 9294 ) { 9295 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9296 if(BURS.DEBUG) trace(p, 530, c + 0, p.getCost(1) /* stm */); 9297 if (c < p.getCost(1) /* stm */) { 9298 p.setCost(1 /* stm */, (char)(c)); 9299 p.writePacked(0, 0xFFFFFF00, 0x4F); // p.stm = 79 9300 } 9301 } 9302 if ( // stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) 9303 rchild.getOpcode() == OTHER_OPERAND_opcode 9304 ) { 9305 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9306 if(BURS.DEBUG) trace(p, 414, c + 0, p.getCost(1) /* stm */); 9307 if (c < p.getCost(1) /* stm */) { 9308 p.setCost(1 /* stm */, (char)(c)); 9309 p.writePacked(0, 0xFFFFFF00, 0x51); // p.stm = 81 9310 } 9311 } 9312 if ( // stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) 9313 rchild.getOpcode() == OTHER_OPERAND_opcode 9314 ) { 9315 c = STATE(lchild).getCost(21 /* load8 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 25; 9316 if(BURS.DEBUG) trace(p, 415, c + 0, p.getCost(1) /* stm */); 9317 if (c < p.getCost(1) /* stm */) { 9318 p.setCost(1 /* stm */, (char)(c)); 9319 p.writePacked(0, 0xFFFFFF00, 0x52); // p.stm = 82 9320 } 9321 } 9322 if ( // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 9323 lchild.getOpcode() == INT_2BYTE_opcode && 9324 rchild.getOpcode() == OTHER_OPERAND_opcode 9325 ) { 9326 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9327 if(BURS.DEBUG) trace(p, 561, c + 0, p.getCost(1) /* stm */); 9328 if (c < p.getCost(1) /* stm */) { 9329 p.setCost(1 /* stm */, (char)(c)); 9330 p.writePacked(0, 0xFFFFFF00, 0x55); // p.stm = 85 9331 } 9332 } 9333 } 9334 9335 /** 9336 * Labels SHORT_STORE tree node 9337 * @param p node to label 9338 */ 9339 private static void label_SHORT_STORE(AbstractBURS_TreeNode p) { 9340 p.initCost(); 9341 AbstractBURS_TreeNode lchild, rchild; 9342 lchild = p.getChild1(); 9343 rchild = p.getChild2(); 9344 label(lchild); 9345 label(rchild); 9346 int c; 9347 if ( // stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 9348 rchild.getOpcode() == OTHER_OPERAND_opcode 9349 ) { 9350 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9351 if(BURS.DEBUG) trace(p, 397, c + 0, p.getCost(1) /* stm */); 9352 if (c < p.getCost(1) /* stm */) { 9353 p.setCost(1 /* stm */, (char)(c)); 9354 p.writePacked(0, 0xFFFFFF00, 0x15); // p.stm = 21 9355 } 9356 } 9357 if ( // stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 9358 rchild.getOpcode() == OTHER_OPERAND_opcode 9359 ) { 9360 c = STATE(lchild).getCost(14 /* load16 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 9361 if(BURS.DEBUG) trace(p, 398, c + 0, p.getCost(1) /* stm */); 9362 if (c < p.getCost(1) /* stm */) { 9363 p.setCost(1 /* stm */, (char)(c)); 9364 p.writePacked(0, 0xFFFFFF00, 0x16); // p.stm = 22 9365 } 9366 } 9367 if ( // stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 9368 rchild.getOpcode() == OTHER_OPERAND_opcode 9369 ) { 9370 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9371 if(BURS.DEBUG) trace(p, 399, c + 0, p.getCost(1) /* stm */); 9372 if (c < p.getCost(1) /* stm */) { 9373 p.setCost(1 /* stm */, (char)(c)); 9374 p.writePacked(0, 0xFFFFFF00, 0x17); // p.stm = 23 9375 } 9376 } 9377 if ( // stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 9378 rchild.getOpcode() == OTHER_OPERAND_opcode 9379 ) { 9380 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9381 if(BURS.DEBUG) trace(p, 400, c + 0, p.getCost(1) /* stm */); 9382 if (c < p.getCost(1) /* stm */) { 9383 p.setCost(1 /* stm */, (char)(c)); 9384 p.writePacked(0, 0xFFFFFF00, 0x18); // p.stm = 24 9385 } 9386 } 9387 if ( // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 9388 lchild.getOpcode() == INT_2SHORT_opcode && 9389 rchild.getOpcode() == OTHER_OPERAND_opcode 9390 ) { 9391 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9392 if(BURS.DEBUG) trace(p, 563, c + 0, p.getCost(1) /* stm */); 9393 if (c < p.getCost(1) /* stm */) { 9394 p.setCost(1 /* stm */, (char)(c)); 9395 p.writePacked(0, 0xFFFFFF00, 0x57); // p.stm = 87 9396 } 9397 } 9398 if ( // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 9399 lchild.getOpcode() == INT_2USHORT_opcode && 9400 rchild.getOpcode() == OTHER_OPERAND_opcode 9401 ) { 9402 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9403 if(BURS.DEBUG) trace(p, 565, c + 0, p.getCost(1) /* stm */); 9404 if (c < p.getCost(1) /* stm */) { 9405 p.setCost(1 /* stm */, (char)(c)); 9406 p.writePacked(0, 0xFFFFFF00, 0x59); // p.stm = 89 9407 } 9408 } 9409 } 9410 9411 /** 9412 * Labels INT_STORE tree node 9413 * @param p node to label 9414 */ 9415 private static void label_INT_STORE(AbstractBURS_TreeNode p) { 9416 p.initCost(); 9417 AbstractBURS_TreeNode lchild, rchild; 9418 lchild = p.getChild1(); 9419 rchild = p.getChild2(); 9420 label(lchild); 9421 label(rchild); 9422 int c; 9423 if ( // stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 9424 lchild.getOpcode() == INT_ADD_opcode && 9425 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9426 rchild.getOpcode() == OTHER_OPERAND_opcode 9427 ) { 9428 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9429 if(BURS.DEBUG) trace(p, 569, c + 0, p.getCost(1) /* stm */); 9430 if (c < p.getCost(1) /* stm */) { 9431 p.setCost(1 /* stm */, (char)(c)); 9432 p.writePacked(0, 0xFFFFFF00, 0x5B); // p.stm = 91 9433 } 9434 } 9435 if ( // stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9436 lchild.getOpcode() == INT_ADD_opcode && 9437 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 9438 rchild.getOpcode() == OTHER_OPERAND_opcode 9439 ) { 9440 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9441 if(BURS.DEBUG) trace(p, 589, c + 0, p.getCost(1) /* stm */); 9442 if (c < p.getCost(1) /* stm */) { 9443 p.setCost(1 /* stm */, (char)(c)); 9444 p.writePacked(0, 0xFFFFFF00, 0x5C); // p.stm = 92 9445 } 9446 } 9447 if ( // stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 9448 lchild.getOpcode() == INT_AND_opcode && 9449 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9450 rchild.getOpcode() == OTHER_OPERAND_opcode 9451 ) { 9452 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9453 if(BURS.DEBUG) trace(p, 571, c + 0, p.getCost(1) /* stm */); 9454 if (c < p.getCost(1) /* stm */) { 9455 p.setCost(1 /* stm */, (char)(c)); 9456 p.writePacked(0, 0xFFFFFF00, 0x5F); // p.stm = 95 9457 } 9458 } 9459 if ( // stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9460 lchild.getOpcode() == INT_AND_opcode && 9461 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 9462 rchild.getOpcode() == OTHER_OPERAND_opcode 9463 ) { 9464 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9465 if(BURS.DEBUG) trace(p, 591, c + 0, p.getCost(1) /* stm */); 9466 if (c < p.getCost(1) /* stm */) { 9467 p.setCost(1 /* stm */, (char)(c)); 9468 p.writePacked(0, 0xFFFFFF00, 0x60); // p.stm = 96 9469 } 9470 } 9471 if ( // stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9472 lchild.getOpcode() == INT_NEG_opcode && 9473 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9474 rchild.getOpcode() == OTHER_OPERAND_opcode 9475 ) { 9476 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9477 if(BURS.DEBUG) trace(p, 532, c + 0, p.getCost(1) /* stm */); 9478 if (c < p.getCost(1) /* stm */) { 9479 p.setCost(1 /* stm */, (char)(c)); 9480 p.writePacked(0, 0xFFFFFF00, 0x73); // p.stm = 115 9481 } 9482 } 9483 if ( // stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9484 lchild.getOpcode() == INT_NOT_opcode && 9485 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9486 rchild.getOpcode() == OTHER_OPERAND_opcode 9487 ) { 9488 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9489 if(BURS.DEBUG) trace(p, 534, c + 0, p.getCost(1) /* stm */); 9490 if (c < p.getCost(1) /* stm */) { 9491 p.setCost(1 /* stm */, (char)(c)); 9492 p.writePacked(0, 0xFFFFFF00, 0x75); // p.stm = 117 9493 } 9494 } 9495 if ( // stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 9496 lchild.getOpcode() == INT_OR_opcode && 9497 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9498 rchild.getOpcode() == OTHER_OPERAND_opcode 9499 ) { 9500 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9501 if(BURS.DEBUG) trace(p, 573, c + 0, p.getCost(1) /* stm */); 9502 if (c < p.getCost(1) /* stm */) { 9503 p.setCost(1 /* stm */, (char)(c)); 9504 p.writePacked(0, 0xFFFFFF00, 0x77); // p.stm = 119 9505 } 9506 } 9507 if ( // stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9508 lchild.getOpcode() == INT_OR_opcode && 9509 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 9510 rchild.getOpcode() == OTHER_OPERAND_opcode 9511 ) { 9512 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9513 if(BURS.DEBUG) trace(p, 593, c + 0, p.getCost(1) /* stm */); 9514 if (c < p.getCost(1) /* stm */) { 9515 p.setCost(1 /* stm */, (char)(c)); 9516 p.writePacked(0, 0xFFFFFF00, 0x78); // p.stm = 120 9517 } 9518 } 9519 if ( // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 9520 lchild.getOpcode() == INT_SHL_opcode && 9521 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9522 lchild.getChild2().getOpcode() == INT_AND_opcode && 9523 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 9524 rchild.getOpcode() == OTHER_OPERAND_opcode 9525 ) { 9526 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 9527 if(BURS.DEBUG) trace(p, 625, c + 0, p.getCost(1) /* stm */); 9528 if (c < p.getCost(1) /* stm */) { 9529 p.setCost(1 /* stm */, (char)(c)); 9530 p.writePacked(0, 0xFFFFFF00, 0x7B); // p.stm = 123 9531 } 9532 } 9533 if ( // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 9534 lchild.getOpcode() == INT_SHL_opcode && 9535 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9536 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 9537 rchild.getOpcode() == OTHER_OPERAND_opcode 9538 ) { 9539 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9540 if(BURS.DEBUG) trace(p, 536, c + 0, p.getCost(1) /* stm */); 9541 if (c < p.getCost(1) /* stm */) { 9542 p.setCost(1 /* stm */, (char)(c)); 9543 p.writePacked(0, 0xFFFFFF00, 0x7C); // p.stm = 124 9544 } 9545 } 9546 if ( // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 9547 lchild.getOpcode() == INT_SHR_opcode && 9548 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9549 lchild.getChild2().getOpcode() == INT_AND_opcode && 9550 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 9551 rchild.getOpcode() == OTHER_OPERAND_opcode 9552 ) { 9553 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 9554 if(BURS.DEBUG) trace(p, 627, c + 0, p.getCost(1) /* stm */); 9555 if (c < p.getCost(1) /* stm */) { 9556 p.setCost(1 /* stm */, (char)(c)); 9557 p.writePacked(0, 0xFFFFFF00, 0x7F); // p.stm = 127 9558 } 9559 } 9560 if ( // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 9561 lchild.getOpcode() == INT_SHR_opcode && 9562 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9563 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 9564 rchild.getOpcode() == OTHER_OPERAND_opcode 9565 ) { 9566 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9567 if(BURS.DEBUG) trace(p, 538, c + 0, p.getCost(1) /* stm */); 9568 if (c < p.getCost(1) /* stm */) { 9569 p.setCost(1 /* stm */, (char)(c)); 9570 p.writePacked(0, 0xFFFFFF00, 0x80); // p.stm = 128 9571 } 9572 } 9573 if ( // stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 9574 rchild.getOpcode() == OTHER_OPERAND_opcode 9575 ) { 9576 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9577 if(BURS.DEBUG) trace(p, 423, c + 0, p.getCost(1) /* stm */); 9578 if (c < p.getCost(1) /* stm */) { 9579 p.setCost(1 /* stm */, (char)(c)); 9580 p.writePacked(0, 0xFFFFFF00, 0x83); // p.stm = 131 9581 } 9582 } 9583 if ( // stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) 9584 rchild.getOpcode() == OTHER_OPERAND_opcode 9585 ) { 9586 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(15 /* address1scaledreg */) + 15; 9587 if(BURS.DEBUG) trace(p, 424, c + 0, p.getCost(1) /* stm */); 9588 if (c < p.getCost(1) /* stm */) { 9589 p.setCost(1 /* stm */, (char)(c)); 9590 p.writePacked(0, 0xFFFFFF00, 0x84); // p.stm = 132 9591 } 9592 } 9593 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) 9594 rchild.getOpcode() == OTHER_OPERAND_opcode 9595 ) { 9596 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9597 if(BURS.DEBUG) trace(p, 425, c + 0, p.getCost(1) /* stm */); 9598 if (c < p.getCost(1) /* stm */) { 9599 p.setCost(1 /* stm */, (char)(c)); 9600 p.writePacked(0, 0xFFFFFF00, 0x85); // p.stm = 133 9601 } 9602 } 9603 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 9604 rchild.getOpcode() == OTHER_OPERAND_opcode 9605 ) { 9606 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(16 /* address1reg */) + 15; 9607 if(BURS.DEBUG) trace(p, 426, c + 0, p.getCost(1) /* stm */); 9608 if (c < p.getCost(1) /* stm */) { 9609 p.setCost(1 /* stm */, (char)(c)); 9610 p.writePacked(0, 0xFFFFFF00, 0x86); // p.stm = 134 9611 } 9612 } 9613 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 9614 rchild.getOpcode() == OTHER_OPERAND_opcode 9615 ) { 9616 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(16 /* address1reg */) + STATE(rchild.getChild2()).getCost(15 /* address1scaledreg */) + 15; 9617 if(BURS.DEBUG) trace(p, 427, c + 0, p.getCost(1) /* stm */); 9618 if (c < p.getCost(1) /* stm */) { 9619 p.setCost(1 /* stm */, (char)(c)); 9620 p.writePacked(0, 0xFFFFFF00, 0x87); // p.stm = 135 9621 } 9622 } 9623 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) 9624 rchild.getOpcode() == OTHER_OPERAND_opcode && 9625 rchild.getChild2().getOpcode() == LONG_CONSTANT_opcode 9626 ) { 9627 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(17 /* address */) + 15; 9628 if(BURS.DEBUG) trace(p, 619, c + 0, p.getCost(1) /* stm */); 9629 if (c < p.getCost(1) /* stm */) { 9630 p.setCost(1 /* stm */, (char)(c)); 9631 p.writePacked(0, 0xFFFFFF00, 0x88); // p.stm = 136 9632 } 9633 } 9634 if ( // stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 9635 lchild.getOpcode() == INT_SUB_opcode && 9636 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9637 rchild.getOpcode() == OTHER_OPERAND_opcode 9638 ) { 9639 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9640 if(BURS.DEBUG) trace(p, 575, c + 0, p.getCost(1) /* stm */); 9641 if (c < p.getCost(1) /* stm */) { 9642 p.setCost(1 /* stm */, (char)(c)); 9643 p.writePacked(0, 0xFFFFFF00, 0x89); // p.stm = 137 9644 } 9645 } 9646 if ( // stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9647 lchild.getOpcode() == INT_SUB_opcode && 9648 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 9649 rchild.getOpcode() == OTHER_OPERAND_opcode 9650 ) { 9651 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLR(p), 27); 9652 if(BURS.DEBUG) trace(p, 595, c + 0, p.getCost(1) /* stm */); 9653 if (c < p.getCost(1) /* stm */) { 9654 p.setCost(1 /* stm */, (char)(c)); 9655 p.writePacked(0, 0xFFFFFF00, 0x8A); // p.stm = 138 9656 } 9657 } 9658 if ( // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 9659 lchild.getOpcode() == INT_USHR_opcode && 9660 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9661 lchild.getChild2().getOpcode() == INT_AND_opcode && 9662 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 9663 rchild.getOpcode() == OTHER_OPERAND_opcode 9664 ) { 9665 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 31 ? 27 : INFINITE)); 9666 if(BURS.DEBUG) trace(p, 629, c + 0, p.getCost(1) /* stm */); 9667 if (c < p.getCost(1) /* stm */) { 9668 p.setCost(1 /* stm */, (char)(c)); 9669 p.writePacked(0, 0xFFFFFF00, 0x8D); // p.stm = 141 9670 } 9671 } 9672 if ( // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 9673 lchild.getOpcode() == INT_USHR_opcode && 9674 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9675 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 9676 rchild.getOpcode() == OTHER_OPERAND_opcode 9677 ) { 9678 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9679 if(BURS.DEBUG) trace(p, 540, c + 0, p.getCost(1) /* stm */); 9680 if (c < p.getCost(1) /* stm */) { 9681 p.setCost(1 /* stm */, (char)(c)); 9682 p.writePacked(0, 0xFFFFFF00, 0x8E); // p.stm = 142 9683 } 9684 } 9685 if ( // stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 9686 lchild.getOpcode() == INT_XOR_opcode && 9687 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 9688 rchild.getOpcode() == OTHER_OPERAND_opcode 9689 ) { 9690 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9691 if(BURS.DEBUG) trace(p, 577, c + 0, p.getCost(1) /* stm */); 9692 if (c < p.getCost(1) /* stm */) { 9693 p.setCost(1 /* stm */, (char)(c)); 9694 p.writePacked(0, 0xFFFFFF00, 0x91); // p.stm = 145 9695 } 9696 } 9697 if ( // stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9698 lchild.getOpcode() == INT_XOR_opcode && 9699 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 9700 rchild.getOpcode() == OTHER_OPERAND_opcode 9701 ) { 9702 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9703 if(BURS.DEBUG) trace(p, 597, c + 0, p.getCost(1) /* stm */); 9704 if (c < p.getCost(1) /* stm */) { 9705 p.setCost(1 /* stm */, (char)(c)); 9706 p.writePacked(0, 0xFFFFFF00, 0x92); // p.stm = 146 9707 } 9708 } 9709 if ( // stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 9710 lchild.getOpcode() == LONG_2INT_opcode && 9711 rchild.getOpcode() == OTHER_OPERAND_opcode 9712 ) { 9713 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 9714 if(BURS.DEBUG) trace(p, 567, c + 0, p.getCost(1) /* stm */); 9715 if (c < p.getCost(1) /* stm */) { 9716 p.setCost(1 /* stm */, (char)(c)); 9717 p.writePacked(0, 0xFFFFFF00, 0x95); // p.stm = 149 9718 } 9719 } 9720 } 9721 9722 /** 9723 * Labels LONG_STORE tree node 9724 * @param p node to label 9725 */ 9726 private static void label_LONG_STORE(AbstractBURS_TreeNode p) { 9727 p.initCost(); 9728 AbstractBURS_TreeNode lchild, rchild; 9729 lchild = p.getChild1(); 9730 rchild = p.getChild2(); 9731 label(lchild); 9732 label(rchild); 9733 int c; 9734 if ( // stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 9735 lchild.getOpcode() == LONG_ADD_opcode && 9736 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9737 rchild.getOpcode() == OTHER_OPERAND_opcode 9738 ) { 9739 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9740 if(BURS.DEBUG) trace(p, 579, c + 0, p.getCost(1) /* stm */); 9741 if (c < p.getCost(1) /* stm */) { 9742 p.setCost(1 /* stm */, (char)(c)); 9743 p.writePacked(0, 0xFFFFFF00, 0x97); // p.stm = 151 9744 } 9745 } 9746 if ( // stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 9747 lchild.getOpcode() == LONG_ADD_opcode && 9748 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 9749 rchild.getOpcode() == OTHER_OPERAND_opcode 9750 ) { 9751 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9752 if(BURS.DEBUG) trace(p, 599, c + 0, p.getCost(1) /* stm */); 9753 if (c < p.getCost(1) /* stm */) { 9754 p.setCost(1 /* stm */, (char)(c)); 9755 p.writePacked(0, 0xFFFFFF00, 0x98); // p.stm = 152 9756 } 9757 } 9758 if ( // stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 9759 lchild.getOpcode() == LONG_AND_opcode && 9760 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9761 rchild.getOpcode() == OTHER_OPERAND_opcode 9762 ) { 9763 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9764 if(BURS.DEBUG) trace(p, 581, c + 0, p.getCost(1) /* stm */); 9765 if (c < p.getCost(1) /* stm */) { 9766 p.setCost(1 /* stm */, (char)(c)); 9767 p.writePacked(0, 0xFFFFFF00, 0x9B); // p.stm = 155 9768 } 9769 } 9770 if ( // stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 9771 lchild.getOpcode() == LONG_AND_opcode && 9772 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 9773 rchild.getOpcode() == OTHER_OPERAND_opcode 9774 ) { 9775 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9776 if(BURS.DEBUG) trace(p, 601, c + 0, p.getCost(1) /* stm */); 9777 if (c < p.getCost(1) /* stm */) { 9778 p.setCost(1 /* stm */, (char)(c)); 9779 p.writePacked(0, 0xFFFFFF00, 0x9C); // p.stm = 156 9780 } 9781 } 9782 if ( // stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9783 lchild.getOpcode() == LONG_NEG_opcode && 9784 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9785 rchild.getOpcode() == OTHER_OPERAND_opcode 9786 ) { 9787 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9788 if(BURS.DEBUG) trace(p, 542, c + 0, p.getCost(1) /* stm */); 9789 if (c < p.getCost(1) /* stm */) { 9790 p.setCost(1 /* stm */, (char)(c)); 9791 p.writePacked(0, 0xFFFFFF00, 0xA1); // p.stm = 161 9792 } 9793 } 9794 if ( // stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 9795 lchild.getOpcode() == LONG_NOT_opcode && 9796 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9797 rchild.getOpcode() == OTHER_OPERAND_opcode 9798 ) { 9799 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9800 if(BURS.DEBUG) trace(p, 544, c + 0, p.getCost(1) /* stm */); 9801 if (c < p.getCost(1) /* stm */) { 9802 p.setCost(1 /* stm */, (char)(c)); 9803 p.writePacked(0, 0xFFFFFF00, 0xA3); // p.stm = 163 9804 } 9805 } 9806 if ( // stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 9807 lchild.getOpcode() == LONG_OR_opcode && 9808 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9809 rchild.getOpcode() == OTHER_OPERAND_opcode 9810 ) { 9811 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9812 if(BURS.DEBUG) trace(p, 583, c + 0, p.getCost(1) /* stm */); 9813 if (c < p.getCost(1) /* stm */) { 9814 p.setCost(1 /* stm */, (char)(c)); 9815 p.writePacked(0, 0xFFFFFF00, 0xA5); // p.stm = 165 9816 } 9817 } 9818 if ( // stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 9819 lchild.getOpcode() == LONG_OR_opcode && 9820 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 9821 rchild.getOpcode() == OTHER_OPERAND_opcode 9822 ) { 9823 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 9824 if(BURS.DEBUG) trace(p, 603, c + 0, p.getCost(1) /* stm */); 9825 if (c < p.getCost(1) /* stm */) { 9826 p.setCost(1 /* stm */, (char)(c)); 9827 p.writePacked(0, 0xFFFFFF00, 0xA6); // p.stm = 166 9828 } 9829 } 9830 if ( // stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 9831 lchild.getOpcode() == LONG_SHL_opcode && 9832 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9833 lchild.getChild2().getOpcode() == INT_AND_opcode && 9834 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 9835 rchild.getOpcode() == OTHER_OPERAND_opcode 9836 ) { 9837 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 9838 if(BURS.DEBUG) trace(p, 631, c + 0, p.getCost(1) /* stm */); 9839 if (c < p.getCost(1) /* stm */) { 9840 p.setCost(1 /* stm */, (char)(c)); 9841 p.writePacked(0, 0xFFFFFF00, 0xA9); // p.stm = 169 9842 } 9843 } 9844 if ( // stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 9845 lchild.getOpcode() == LONG_SHL_opcode && 9846 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9847 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 9848 rchild.getOpcode() == OTHER_OPERAND_opcode 9849 ) { 9850 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9851 if(BURS.DEBUG) trace(p, 546, c + 0, p.getCost(1) /* stm */); 9852 if (c < p.getCost(1) /* stm */) { 9853 p.setCost(1 /* stm */, (char)(c)); 9854 p.writePacked(0, 0xFFFFFF00, 0xAA); // p.stm = 170 9855 } 9856 } 9857 if ( // stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 9858 lchild.getOpcode() == LONG_SHR_opcode && 9859 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9860 lchild.getChild2().getOpcode() == INT_AND_opcode && 9861 lchild.getChild2().getChild2().getOpcode() == LONG_CONSTANT_opcode && 9862 rchild.getOpcode() == OTHER_OPERAND_opcode 9863 ) { 9864 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 9865 if(BURS.DEBUG) trace(p, 633, c + 0, p.getCost(1) /* stm */); 9866 if (c < p.getCost(1) /* stm */) { 9867 p.setCost(1 /* stm */, (char)(c)); 9868 p.writePacked(0, 0xFFFFFF00, 0xAD); // p.stm = 173 9869 } 9870 } 9871 if ( // stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 9872 lchild.getOpcode() == LONG_SHR_opcode && 9873 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9874 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 9875 rchild.getOpcode() == OTHER_OPERAND_opcode 9876 ) { 9877 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9878 if(BURS.DEBUG) trace(p, 548, c + 0, p.getCost(1) /* stm */); 9879 if (c < p.getCost(1) /* stm */) { 9880 p.setCost(1 /* stm */, (char)(c)); 9881 p.writePacked(0, 0xFFFFFF00, 0xAE); // p.stm = 174 9882 } 9883 } 9884 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 9885 rchild.getOpcode() == OTHER_OPERAND_opcode 9886 ) { 9887 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9888 if(BURS.DEBUG) trace(p, 431, c + 0, p.getCost(1) /* stm */); 9889 if (c < p.getCost(1) /* stm */) { 9890 p.setCost(1 /* stm */, (char)(c)); 9891 p.writePacked(0, 0xFFFFFF00, 0xB1); // p.stm = 177 9892 } 9893 } 9894 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) 9895 rchild.getOpcode() == OTHER_OPERAND_opcode 9896 ) { 9897 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(15 /* address1scaledreg */) + 15; 9898 if(BURS.DEBUG) trace(p, 432, c + 0, p.getCost(1) /* stm */); 9899 if (c < p.getCost(1) /* stm */) { 9900 p.setCost(1 /* stm */, (char)(c)); 9901 p.writePacked(0, 0xFFFFFF00, 0xB2); // p.stm = 178 9902 } 9903 } 9904 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) 9905 rchild.getOpcode() == OTHER_OPERAND_opcode 9906 ) { 9907 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 9908 if(BURS.DEBUG) trace(p, 433, c + 0, p.getCost(1) /* stm */); 9909 if (c < p.getCost(1) /* stm */) { 9910 p.setCost(1 /* stm */, (char)(c)); 9911 p.writePacked(0, 0xFFFFFF00, 0xB3); // p.stm = 179 9912 } 9913 } 9914 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) 9915 rchild.getOpcode() == OTHER_OPERAND_opcode 9916 ) { 9917 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(16 /* address1reg */) + 15; 9918 if(BURS.DEBUG) trace(p, 434, c + 0, p.getCost(1) /* stm */); 9919 if (c < p.getCost(1) /* stm */) { 9920 p.setCost(1 /* stm */, (char)(c)); 9921 p.writePacked(0, 0xFFFFFF00, 0xB4); // p.stm = 180 9922 } 9923 } 9924 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) 9925 rchild.getOpcode() == OTHER_OPERAND_opcode 9926 ) { 9927 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(16 /* address1reg */) + STATE(rchild.getChild2()).getCost(15 /* address1scaledreg */) + 15; 9928 if(BURS.DEBUG) trace(p, 435, c + 0, p.getCost(1) /* stm */); 9929 if (c < p.getCost(1) /* stm */) { 9930 p.setCost(1 /* stm */, (char)(c)); 9931 p.writePacked(0, 0xFFFFFF00, 0xB5); // p.stm = 181 9932 } 9933 } 9934 if ( // stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) 9935 rchild.getOpcode() == OTHER_OPERAND_opcode && 9936 rchild.getChild2().getOpcode() == LONG_CONSTANT_opcode 9937 ) { 9938 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(17 /* address */) + 15; 9939 if(BURS.DEBUG) trace(p, 623, c + 0, p.getCost(1) /* stm */); 9940 if (c < p.getCost(1) /* stm */) { 9941 p.setCost(1 /* stm */, (char)(c)); 9942 p.writePacked(0, 0xFFFFFF00, 0xB6); // p.stm = 182 9943 } 9944 } 9945 if ( // stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 9946 lchild.getOpcode() == LONG_SUB_opcode && 9947 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9948 rchild.getOpcode() == OTHER_OPERAND_opcode 9949 ) { 9950 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9951 if(BURS.DEBUG) trace(p, 585, c + 0, p.getCost(1) /* stm */); 9952 if (c < p.getCost(1) /* stm */) { 9953 p.setCost(1 /* stm */, (char)(c)); 9954 p.writePacked(0, 0xFFFFFF00, 0xB7); // p.stm = 183 9955 } 9956 } 9957 if ( // stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 9958 lchild.getOpcode() == LONG_SUB_opcode && 9959 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 9960 rchild.getOpcode() == OTHER_OPERAND_opcode 9961 ) { 9962 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLR(p), 27); 9963 if(BURS.DEBUG) trace(p, 605, c + 0, p.getCost(1) /* stm */); 9964 if (c < p.getCost(1) /* stm */) { 9965 p.setCost(1 /* stm */, (char)(c)); 9966 p.writePacked(0, 0xFFFFFF00, 0xB8); // p.stm = 184 9967 } 9968 } 9969 if ( // stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 9970 lchild.getOpcode() == LONG_USHR_opcode && 9971 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9972 lchild.getChild2().getOpcode() == LONG_AND_opcode && 9973 lchild.getChild2().getChild2().getOpcode() == LONG_CONSTANT_opcode && 9974 rchild.getOpcode() == OTHER_OPERAND_opcode 9975 ) { 9976 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + (ADDRESS_EQUAL(P(p), PLL(p), VLRR(p) == 63 ? 27 : INFINITE)); 9977 if(BURS.DEBUG) trace(p, 635, c + 0, p.getCost(1) /* stm */); 9978 if (c < p.getCost(1) /* stm */) { 9979 p.setCost(1 /* stm */, (char)(c)); 9980 p.writePacked(0, 0xFFFFFF00, 0xBB); // p.stm = 187 9981 } 9982 } 9983 if ( // stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 9984 lchild.getOpcode() == LONG_USHR_opcode && 9985 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9986 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 9987 rchild.getOpcode() == OTHER_OPERAND_opcode 9988 ) { 9989 c = STATE(lchild.getChild1().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild1().getChild2()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 9990 if(BURS.DEBUG) trace(p, 550, c + 0, p.getCost(1) /* stm */); 9991 if (c < p.getCost(1) /* stm */) { 9992 p.setCost(1 /* stm */, (char)(c)); 9993 p.writePacked(0, 0xFFFFFF00, 0xBC); // p.stm = 188 9994 } 9995 } 9996 if ( // stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 9997 lchild.getOpcode() == LONG_XOR_opcode && 9998 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 9999 rchild.getOpcode() == OTHER_OPERAND_opcode 10000 ) { 10001 c = STATE(lchild.getChild1().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild1().getChild2()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLL(p), 17); 10002 if(BURS.DEBUG) trace(p, 587, c + 0, p.getCost(1) /* stm */); 10003 if (c < p.getCost(1) /* stm */) { 10004 p.setCost(1 /* stm */, (char)(c)); 10005 p.writePacked(0, 0xFFFFFF00, 0xBF); // p.stm = 191 10006 } 10007 } 10008 if ( // stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 10009 lchild.getOpcode() == LONG_XOR_opcode && 10010 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 10011 rchild.getOpcode() == OTHER_OPERAND_opcode 10012 ) { 10013 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2().getChild2()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + ADDRESS_EQUAL(P(p), PLR(p), 17); 10014 if(BURS.DEBUG) trace(p, 607, c + 0, p.getCost(1) /* stm */); 10015 if (c < p.getCost(1) /* stm */) { 10016 p.setCost(1 /* stm */, (char)(c)); 10017 p.writePacked(0, 0xFFFFFF00, 0xC0); // p.stm = 192 10018 } 10019 } 10020 if ( // stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 10021 rchild.getOpcode() == OTHER_OPERAND_opcode 10022 ) { 10023 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 10024 if(BURS.DEBUG) trace(p, 464, c + 0, p.getCost(1) /* stm */); 10025 if (c < p.getCost(1) /* stm */) { 10026 p.setCost(1 /* stm */, (char)(c)); 10027 p.writePacked(0, 0xFFFFFF00, 0xDE); // p.stm = 222 10028 } 10029 } 10030 if ( // stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 10031 rchild.getOpcode() == OTHER_OPERAND_opcode 10032 ) { 10033 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 10034 if(BURS.DEBUG) trace(p, 465, c + 0, p.getCost(1) /* stm */); 10035 if (c < p.getCost(1) /* stm */) { 10036 p.setCost(1 /* stm */, (char)(c)); 10037 p.writePacked(0, 0xFFFFFF00, 0xDF); // p.stm = 223 10038 } 10039 } 10040 } 10041 10042 /** 10043 * Labels FLOAT_STORE tree node 10044 * @param p node to label 10045 */ 10046 private static void label_FLOAT_STORE(AbstractBURS_TreeNode p) { 10047 p.initCost(); 10048 AbstractBURS_TreeNode lchild, rchild; 10049 lchild = p.getChild1(); 10050 rchild = p.getChild2(); 10051 label(lchild); 10052 label(rchild); 10053 int c; 10054 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 10055 rchild.getOpcode() == OTHER_OPERAND_opcode 10056 ) { 10057 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 10058 if(BURS.DEBUG) trace(p, 445, c + 0, p.getCost(1) /* stm */); 10059 if (c < p.getCost(1) /* stm */) { 10060 p.setCost(1 /* stm */, (char)(c)); 10061 p.writePacked(0, 0xFFFFFF00, 0xCC); // p.stm = 204 10062 } 10063 } 10064 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 10065 rchild.getOpcode() == OTHER_OPERAND_opcode 10066 ) { 10067 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 10068 if(BURS.DEBUG) trace(p, 446, c + 0, p.getCost(1) /* stm */); 10069 if (c < p.getCost(1) /* stm */) { 10070 p.setCost(1 /* stm */, (char)(c)); 10071 p.writePacked(0, 0xFFFFFF00, 0xCD); // p.stm = 205 10072 } 10073 } 10074 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 10075 rchild.getOpcode() == OTHER_OPERAND_opcode 10076 ) { 10077 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 10078 if(BURS.DEBUG) trace(p, 447, c + 0, p.getCost(1) /* stm */); 10079 if (c < p.getCost(1) /* stm */) { 10080 p.setCost(1 /* stm */, (char)(c)); 10081 p.writePacked(0, 0xFFFFFF00, 0xCE); // p.stm = 206 10082 } 10083 } 10084 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 10085 rchild.getOpcode() == OTHER_OPERAND_opcode 10086 ) { 10087 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 10088 if(BURS.DEBUG) trace(p, 448, c + 0, p.getCost(1) /* stm */); 10089 if (c < p.getCost(1) /* stm */) { 10090 p.setCost(1 /* stm */, (char)(c)); 10091 p.writePacked(0, 0xFFFFFF00, 0xCF); // p.stm = 207 10092 } 10093 } 10094 } 10095 10096 /** 10097 * Labels DOUBLE_STORE tree node 10098 * @param p node to label 10099 */ 10100 private static void label_DOUBLE_STORE(AbstractBURS_TreeNode p) { 10101 p.initCost(); 10102 AbstractBURS_TreeNode lchild, rchild; 10103 lchild = p.getChild1(); 10104 rchild = p.getChild2(); 10105 label(lchild); 10106 label(rchild); 10107 int c; 10108 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 10109 rchild.getOpcode() == OTHER_OPERAND_opcode 10110 ) { 10111 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 10112 if(BURS.DEBUG) trace(p, 436, c + 0, p.getCost(1) /* stm */); 10113 if (c < p.getCost(1) /* stm */) { 10114 p.setCost(1 /* stm */, (char)(c)); 10115 p.writePacked(0, 0xFFFFFF00, 0xC3); // p.stm = 195 10116 } 10117 } 10118 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 10119 rchild.getOpcode() == OTHER_OPERAND_opcode 10120 ) { 10121 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 10122 if(BURS.DEBUG) trace(p, 437, c + 0, p.getCost(1) /* stm */); 10123 if (c < p.getCost(1) /* stm */) { 10124 p.setCost(1 /* stm */, (char)(c)); 10125 p.writePacked(0, 0xFFFFFF00, 0xC4); // p.stm = 196 10126 } 10127 } 10128 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 10129 rchild.getOpcode() == OTHER_OPERAND_opcode 10130 ) { 10131 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 10132 if(BURS.DEBUG) trace(p, 438, c + 0, p.getCost(1) /* stm */); 10133 if (c < p.getCost(1) /* stm */) { 10134 p.setCost(1 /* stm */, (char)(c)); 10135 p.writePacked(0, 0xFFFFFF00, 0xC5); // p.stm = 197 10136 } 10137 } 10138 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 10139 rchild.getOpcode() == OTHER_OPERAND_opcode 10140 ) { 10141 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 10142 if(BURS.DEBUG) trace(p, 439, c + 0, p.getCost(1) /* stm */); 10143 if (c < p.getCost(1) /* stm */) { 10144 p.setCost(1 /* stm */, (char)(c)); 10145 p.writePacked(0, 0xFFFFFF00, 0xC6); // p.stm = 198 10146 } 10147 } 10148 } 10149 10150 /** 10151 * Labels ATTEMPT_INT tree node 10152 * @param p node to label 10153 */ 10154 private static void label_ATTEMPT_INT(AbstractBURS_TreeNode p) { 10155 p.initCost(); 10156 AbstractBURS_TreeNode lchild, rchild; 10157 lchild = p.getChild1(); 10158 rchild = p.getChild2(); 10159 label(lchild); 10160 label(rchild); 10161 int c; 10162 if ( // r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 10163 rchild.getOpcode() == OTHER_OPERAND_opcode && 10164 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10165 ) { 10166 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10167 if(BURS.DEBUG) trace(p, 474, c + 0, p.getCost(2) /* r */); 10168 if (c < p.getCost(2) /* r */) { 10169 p.setCost(2 /* r */, (char)(c)); 10170 p.writePacked(0, 0xFFFE00FF, 0x1600); // p.r = 22 10171 closure_r(p, c); 10172 } 10173 } 10174 if ( // r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 10175 rchild.getOpcode() == OTHER_OPERAND_opcode && 10176 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10177 ) { 10178 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10179 if(BURS.DEBUG) trace(p, 475, c + 0, p.getCost(2) /* r */); 10180 if (c < p.getCost(2) /* r */) { 10181 p.setCost(2 /* r */, (char)(c)); 10182 p.writePacked(0, 0xFFFE00FF, 0x1700); // p.r = 23 10183 closure_r(p, c); 10184 } 10185 } 10186 if ( // r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 10187 rchild.getOpcode() == OTHER_OPERAND_opcode && 10188 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10189 ) { 10190 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10191 if(BURS.DEBUG) trace(p, 476, c + 0, p.getCost(2) /* r */); 10192 if (c < p.getCost(2) /* r */) { 10193 p.setCost(2 /* r */, (char)(c)); 10194 p.writePacked(0, 0xFFFE00FF, 0x1800); // p.r = 24 10195 closure_r(p, c); 10196 } 10197 } 10198 if ( // r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 10199 rchild.getOpcode() == OTHER_OPERAND_opcode && 10200 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10201 ) { 10202 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10203 if(BURS.DEBUG) trace(p, 477, c + 0, p.getCost(2) /* r */); 10204 if (c < p.getCost(2) /* r */) { 10205 p.setCost(2 /* r */, (char)(c)); 10206 p.writePacked(0, 0xFFFE00FF, 0x1900); // p.r = 25 10207 closure_r(p, c); 10208 } 10209 } 10210 if ( // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 10211 rchild.getOpcode() == OTHER_OPERAND_opcode && 10212 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10213 ) { 10214 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10215 if(BURS.DEBUG) trace(p, 478, c + 0, p.getCost(2) /* r */); 10216 if (c < p.getCost(2) /* r */) { 10217 p.setCost(2 /* r */, (char)(c)); 10218 p.writePacked(0, 0xFFFE00FF, 0x1A00); // p.r = 26 10219 closure_r(p, c); 10220 } 10221 } 10222 if ( // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 10223 rchild.getOpcode() == OTHER_OPERAND_opcode && 10224 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10225 ) { 10226 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(16 /* address1reg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10227 if(BURS.DEBUG) trace(p, 479, c + 0, p.getCost(2) /* r */); 10228 if (c < p.getCost(2) /* r */) { 10229 p.setCost(2 /* r */, (char)(c)); 10230 p.writePacked(0, 0xFFFE00FF, 0x1B00); // p.r = 27 10231 closure_r(p, c); 10232 } 10233 } 10234 if ( // r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 10235 rchild.getOpcode() == OTHER_OPERAND_opcode && 10236 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10237 ) { 10238 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10239 if(BURS.DEBUG) trace(p, 480, c + 0, p.getCost(2) /* r */); 10240 if (c < p.getCost(2) /* r */) { 10241 p.setCost(2 /* r */, (char)(c)); 10242 p.writePacked(0, 0xFFFE00FF, 0x1C00); // p.r = 28 10243 closure_r(p, c); 10244 } 10245 } 10246 if ( // r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 10247 rchild.getOpcode() == OTHER_OPERAND_opcode && 10248 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 10249 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10250 ) { 10251 c = STATE(lchild).getCost(17 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10252 if(BURS.DEBUG) trace(p, 490, c + 0, p.getCost(2) /* r */); 10253 if (c < p.getCost(2) /* r */) { 10254 p.setCost(2 /* r */, (char)(c)); 10255 p.writePacked(0, 0xFFFE00FF, 0x1D00); // p.r = 29 10256 closure_r(p, c); 10257 } 10258 } 10259 if ( // r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 10260 lchild.getOpcode() == INT_CONSTANT_opcode && 10261 rchild.getOpcode() == OTHER_OPERAND_opcode && 10262 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10263 ) { 10264 c = STATE(rchild.getChild1()).getCost(17 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 10265 if(BURS.DEBUG) trace(p, 492, c + 0, p.getCost(2) /* r */); 10266 if (c < p.getCost(2) /* r */) { 10267 p.setCost(2 /* r */, (char)(c)); 10268 p.writePacked(0, 0xFFFE00FF, 0x1E00); // p.r = 30 10269 closure_r(p, c); 10270 } 10271 } 10272 } 10273 10274 /** 10275 * Labels ATTEMPT_LONG tree node 10276 * @param p node to label 10277 */ 10278 private static void label_ATTEMPT_LONG(AbstractBURS_TreeNode p) { 10279 p.initCost(); 10280 AbstractBURS_TreeNode lchild, rchild; 10281 lchild = p.getChild1(); 10282 rchild = p.getChild2(); 10283 label(lchild); 10284 label(rchild); 10285 int c; 10286 if ( // r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) 10287 rchild.getOpcode() == OTHER_OPERAND_opcode && 10288 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10289 ) { 10290 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10291 if(BURS.DEBUG) trace(p, 481, c + 0, p.getCost(2) /* r */); 10292 if (c < p.getCost(2) /* r */) { 10293 p.setCost(2 /* r */, (char)(c)); 10294 p.writePacked(0, 0xFFFE00FF, 0x1F00); // p.r = 31 10295 closure_r(p, c); 10296 } 10297 } 10298 if ( // r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 10299 rchild.getOpcode() == OTHER_OPERAND_opcode && 10300 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10301 ) { 10302 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10303 if(BURS.DEBUG) trace(p, 482, c + 0, p.getCost(2) /* r */); 10304 if (c < p.getCost(2) /* r */) { 10305 p.setCost(2 /* r */, (char)(c)); 10306 p.writePacked(0, 0xFFFE00FF, 0x2000); // p.r = 32 10307 closure_r(p, c); 10308 } 10309 } 10310 if ( // r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) 10311 rchild.getOpcode() == OTHER_OPERAND_opcode && 10312 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10313 ) { 10314 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10315 if(BURS.DEBUG) trace(p, 483, c + 0, p.getCost(2) /* r */); 10316 if (c < p.getCost(2) /* r */) { 10317 p.setCost(2 /* r */, (char)(c)); 10318 p.writePacked(0, 0xFFFE00FF, 0x2100); // p.r = 33 10319 closure_r(p, c); 10320 } 10321 } 10322 if ( // r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) 10323 rchild.getOpcode() == OTHER_OPERAND_opcode && 10324 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10325 ) { 10326 c = STATE(lchild).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(16 /* address1reg */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10327 if(BURS.DEBUG) trace(p, 484, c + 0, p.getCost(2) /* r */); 10328 if (c < p.getCost(2) /* r */) { 10329 p.setCost(2 /* r */, (char)(c)); 10330 p.writePacked(0, 0xFFFE00FF, 0x2200); // p.r = 34 10331 closure_r(p, c); 10332 } 10333 } 10334 if ( // r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 10335 rchild.getOpcode() == OTHER_OPERAND_opcode && 10336 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10337 ) { 10338 c = STATE(lchild).getCost(16 /* address1reg */) + STATE(rchild.getChild1()).getCost(15 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10339 if(BURS.DEBUG) trace(p, 485, c + 0, p.getCost(2) /* r */); 10340 if (c < p.getCost(2) /* r */) { 10341 p.setCost(2 /* r */, (char)(c)); 10342 p.writePacked(0, 0xFFFE00FF, 0x2300); // p.r = 35 10343 closure_r(p, c); 10344 } 10345 } 10346 if ( // r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) 10347 rchild.getOpcode() == OTHER_OPERAND_opcode && 10348 rchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 10349 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10350 ) { 10351 c = STATE(lchild).getCost(17 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10352 if(BURS.DEBUG) trace(p, 491, c + 0, p.getCost(2) /* r */); 10353 if (c < p.getCost(2) /* r */) { 10354 p.setCost(2 /* r */, (char)(c)); 10355 p.writePacked(0, 0xFFFE00FF, 0x2400); // p.r = 36 10356 closure_r(p, c); 10357 } 10358 } 10359 if ( // r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) 10360 lchild.getOpcode() == LONG_CONSTANT_opcode && 10361 rchild.getOpcode() == OTHER_OPERAND_opcode && 10362 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10363 ) { 10364 c = STATE(rchild.getChild1()).getCost(17 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 10365 if(BURS.DEBUG) trace(p, 493, c + 0, p.getCost(2) /* r */); 10366 if (c < p.getCost(2) /* r */) { 10367 p.setCost(2 /* r */, (char)(c)); 10368 p.writePacked(0, 0xFFFE00FF, 0x2500); // p.r = 37 10369 closure_r(p, c); 10370 } 10371 } 10372 } 10373 10374 /** 10375 * Labels CALL tree node 10376 * @param p node to label 10377 */ 10378 private static void label_CALL(AbstractBURS_TreeNode p) { 10379 p.initCost(); 10380 AbstractBURS_TreeNode lchild, rchild; 10381 lchild = p.getChild1(); 10382 rchild = p.getChild2(); 10383 label(lchild); 10384 label(rchild); 10385 int c; 10386 // r: CALL(r,any) 10387 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(9 /* any */) + 13; 10388 if(BURS.DEBUG) trace(p, 56, c + 0, p.getCost(2) /* r */); 10389 if (c < p.getCost(2) /* r */) { 10390 p.setCost(2 /* r */, (char)(c)); 10391 p.writePacked(0, 0xFFFE00FF, 0xD00); // p.r = 13 10392 closure_r(p, c); 10393 } 10394 if ( // r: CALL(BRANCH_TARGET,any) 10395 lchild.getOpcode() == BRANCH_TARGET_opcode 10396 ) { 10397 c = STATE(rchild).getCost(9 /* any */) + 13; 10398 if(BURS.DEBUG) trace(p, 468, c + 0, p.getCost(2) /* r */); 10399 if (c < p.getCost(2) /* r */) { 10400 p.setCost(2 /* r */, (char)(c)); 10401 p.writePacked(0, 0xFFFE00FF, 0xE00); // p.r = 14 10402 closure_r(p, c); 10403 } 10404 } 10405 if ( // r: CALL(INT_LOAD(riv,riv),any) 10406 lchild.getOpcode() == INT_LOAD_opcode 10407 ) { 10408 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild).getCost(9 /* any */) + 11; 10409 if(BURS.DEBUG) trace(p, 471, c + 0, p.getCost(2) /* r */); 10410 if (c < p.getCost(2) /* r */) { 10411 p.setCost(2 /* r */, (char)(c)); 10412 p.writePacked(0, 0xFFFE00FF, 0xF00); // p.r = 15 10413 closure_r(p, c); 10414 } 10415 } 10416 if ( // r: CALL(INT_CONSTANT,any) 10417 lchild.getOpcode() == INT_CONSTANT_opcode 10418 ) { 10419 c = STATE(rchild).getCost(9 /* any */) + 23; 10420 if(BURS.DEBUG) trace(p, 469, c + 0, p.getCost(2) /* r */); 10421 if (c < p.getCost(2) /* r */) { 10422 p.setCost(2 /* r */, (char)(c)); 10423 p.writePacked(0, 0xFFFE00FF, 0x1000); // p.r = 16 10424 closure_r(p, c); 10425 } 10426 } 10427 if ( // r: CALL(LONG_LOAD(rlv,rlv),any) 10428 lchild.getOpcode() == LONG_LOAD_opcode 10429 ) { 10430 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild).getCost(9 /* any */) + 11; 10431 if(BURS.DEBUG) trace(p, 472, c + 0, p.getCost(2) /* r */); 10432 if (c < p.getCost(2) /* r */) { 10433 p.setCost(2 /* r */, (char)(c)); 10434 p.writePacked(0, 0xFFFE00FF, 0x1100); // p.r = 17 10435 closure_r(p, c); 10436 } 10437 } 10438 } 10439 10440 /** 10441 * Labels SYSCALL tree node 10442 * @param p node to label 10443 */ 10444 private static void label_SYSCALL(AbstractBURS_TreeNode p) { 10445 p.initCost(); 10446 AbstractBURS_TreeNode lchild, rchild; 10447 lchild = p.getChild1(); 10448 rchild = p.getChild2(); 10449 label(lchild); 10450 label(rchild); 10451 int c; 10452 // r: SYSCALL(r,any) 10453 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(9 /* any */) + 13; 10454 if(BURS.DEBUG) trace(p, 57, c + 0, p.getCost(2) /* r */); 10455 if (c < p.getCost(2) /* r */) { 10456 p.setCost(2 /* r */, (char)(c)); 10457 p.writePacked(0, 0xFFFE00FF, 0x1200); // p.r = 18 10458 closure_r(p, c); 10459 } 10460 if ( // r: SYSCALL(INT_LOAD(riv,riv),any) 10461 lchild.getOpcode() == INT_LOAD_opcode 10462 ) { 10463 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild).getCost(9 /* any */) + 11; 10464 if(BURS.DEBUG) trace(p, 473, c + 0, p.getCost(2) /* r */); 10465 if (c < p.getCost(2) /* r */) { 10466 p.setCost(2 /* r */, (char)(c)); 10467 p.writePacked(0, 0xFFFE00FF, 0x1300); // p.r = 19 10468 closure_r(p, c); 10469 } 10470 } 10471 if ( // r: SYSCALL(INT_CONSTANT,any) 10472 lchild.getOpcode() == INT_CONSTANT_opcode 10473 ) { 10474 c = STATE(rchild).getCost(9 /* any */) + 23; 10475 if(BURS.DEBUG) trace(p, 470, c + 0, p.getCost(2) /* r */); 10476 if (c < p.getCost(2) /* r */) { 10477 p.setCost(2 /* r */, (char)(c)); 10478 p.writePacked(0, 0xFFFE00FF, 0x1400); // p.r = 20 10479 closure_r(p, c); 10480 } 10481 } 10482 } 10483 10484 /** 10485 * Labels YIELDPOINT_PROLOGUE tree node 10486 * @param p node to label 10487 */ 10488 private static void label_YIELDPOINT_PROLOGUE(AbstractBURS_TreeNode p) { 10489 p.initCost(); 10490 // stm: YIELDPOINT_PROLOGUE 10491 if(BURS.DEBUG) trace(p, 30, 10 + 0, p.getCost(1) /* stm */); 10492 if (10 < p.getCost(1) /* stm */) { 10493 p.setCost(1 /* stm */, (char)(10)); 10494 p.writePacked(0, 0xFFFFFF00, 0x5); // p.stm = 5 10495 } 10496 } 10497 10498 /** 10499 * Labels YIELDPOINT_EPILOGUE tree node 10500 * @param p node to label 10501 */ 10502 private static void label_YIELDPOINT_EPILOGUE(AbstractBURS_TreeNode p) { 10503 p.initCost(); 10504 // stm: YIELDPOINT_EPILOGUE 10505 if(BURS.DEBUG) trace(p, 31, 10 + 0, p.getCost(1) /* stm */); 10506 if (10 < p.getCost(1) /* stm */) { 10507 p.setCost(1 /* stm */, (char)(10)); 10508 p.writePacked(0, 0xFFFFFF00, 0x6); // p.stm = 6 10509 } 10510 } 10511 10512 /** 10513 * Labels YIELDPOINT_BACKEDGE tree node 10514 * @param p node to label 10515 */ 10516 private static void label_YIELDPOINT_BACKEDGE(AbstractBURS_TreeNode p) { 10517 p.initCost(); 10518 // stm: YIELDPOINT_BACKEDGE 10519 if(BURS.DEBUG) trace(p, 32, 10 + 0, p.getCost(1) /* stm */); 10520 if (10 < p.getCost(1) /* stm */) { 10521 p.setCost(1 /* stm */, (char)(10)); 10522 p.writePacked(0, 0xFFFFFF00, 0x7); // p.stm = 7 10523 } 10524 } 10525 10526 /** 10527 * Labels YIELDPOINT_OSR tree node 10528 * @param p node to label 10529 */ 10530 private static void label_YIELDPOINT_OSR(AbstractBURS_TreeNode p) { 10531 p.initCost(); 10532 AbstractBURS_TreeNode lchild, rchild; 10533 lchild = p.getChild1(); 10534 rchild = p.getChild2(); 10535 label(lchild); 10536 label(rchild); 10537 int c; 10538 // stm: YIELDPOINT_OSR(any,any) 10539 c = STATE(lchild).getCost(9 /* any */) + STATE(rchild).getCost(9 /* any */) + 10; 10540 if(BURS.DEBUG) trace(p, 58, c + 0, p.getCost(1) /* stm */); 10541 if (c < p.getCost(1) /* stm */) { 10542 p.setCost(1 /* stm */, (char)(c)); 10543 p.writePacked(0, 0xFFFFFF00, 0x30); // p.stm = 48 10544 } 10545 } 10546 10547 /** 10548 * Labels IR_PROLOGUE tree node 10549 * @param p node to label 10550 */ 10551 private static void label_IR_PROLOGUE(AbstractBURS_TreeNode p) { 10552 p.initCost(); 10553 // stm: IR_PROLOGUE 10554 if(BURS.DEBUG) trace(p, 37, 11 + 0, p.getCost(1) /* stm */); 10555 if (11 < p.getCost(1) /* stm */) { 10556 p.setCost(1 /* stm */, (char)(11)); 10557 p.writePacked(0, 0xFFFFFF00, 0xC); // p.stm = 12 10558 } 10559 } 10560 10561 /** 10562 * Labels RESOLVE tree node 10563 * @param p node to label 10564 */ 10565 private static void label_RESOLVE(AbstractBURS_TreeNode p) { 10566 p.initCost(); 10567 // stm: RESOLVE 10568 if(BURS.DEBUG) trace(p, 33, 10 + 0, p.getCost(1) /* stm */); 10569 if (10 < p.getCost(1) /* stm */) { 10570 p.setCost(1 /* stm */, (char)(10)); 10571 p.writePacked(0, 0xFFFFFF00, 0x9); // p.stm = 9 10572 } 10573 } 10574 10575 /** 10576 * Labels GET_TIME_BASE tree node 10577 * @param p node to label 10578 */ 10579 private static void label_GET_TIME_BASE(AbstractBURS_TreeNode p) { 10580 p.initCost(); 10581 // r: GET_TIME_BASE 10582 if(BURS.DEBUG) trace(p, 49, 15 + 0, p.getCost(2) /* r */); 10583 if (15 < p.getCost(2) /* r */) { 10584 p.setCost(2 /* r */, (char)(15)); 10585 p.writePacked(0, 0xFFFE00FF, 0x1500); // p.r = 21 10586 closure_r(p, 15); 10587 } 10588 } 10589 10590 /** 10591 * Labels TRAP_IF tree node 10592 * @param p node to label 10593 */ 10594 private static void label_TRAP_IF(AbstractBURS_TreeNode p) { 10595 p.initCost(); 10596 AbstractBURS_TreeNode lchild, rchild; 10597 lchild = p.getChild1(); 10598 rchild = p.getChild2(); 10599 label(lchild); 10600 label(rchild); 10601 int c; 10602 if ( // stm: TRAP_IF(r,INT_CONSTANT) 10603 rchild.getOpcode() == INT_CONSTANT_opcode 10604 ) { 10605 c = STATE(lchild).getCost(2 /* r */) + 10; 10606 if(BURS.DEBUG) trace(p, 250, c + 0, p.getCost(1) /* stm */); 10607 if (c < p.getCost(1) /* stm */) { 10608 p.setCost(1 /* stm */, (char)(c)); 10609 p.writePacked(0, 0xFFFFFF00, 0x10); // p.stm = 16 10610 } 10611 } 10612 if ( // stm: TRAP_IF(r,LONG_CONSTANT) 10613 rchild.getOpcode() == LONG_CONSTANT_opcode 10614 ) { 10615 c = STATE(lchild).getCost(2 /* r */) + 10; 10616 if(BURS.DEBUG) trace(p, 251, c + 0, p.getCost(1) /* stm */); 10617 if (c < p.getCost(1) /* stm */) { 10618 p.setCost(1 /* stm */, (char)(c)); 10619 p.writePacked(0, 0xFFFFFF00, 0x11); // p.stm = 17 10620 } 10621 } 10622 // stm: TRAP_IF(r,r) 10623 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 10624 if(BURS.DEBUG) trace(p, 52, c + 0, p.getCost(1) /* stm */); 10625 if (c < p.getCost(1) /* stm */) { 10626 p.setCost(1 /* stm */, (char)(c)); 10627 p.writePacked(0, 0xFFFFFF00, 0x12); // p.stm = 18 10628 } 10629 // stm: TRAP_IF(load32,riv) 10630 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 10631 if(BURS.DEBUG) trace(p, 53, c + 0, p.getCost(1) /* stm */); 10632 if (c < p.getCost(1) /* stm */) { 10633 p.setCost(1 /* stm */, (char)(c)); 10634 p.writePacked(0, 0xFFFFFF00, 0x13); // p.stm = 19 10635 } 10636 // stm: TRAP_IF(riv,load32) 10637 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 10638 if(BURS.DEBUG) trace(p, 54, c + 0, p.getCost(1) /* stm */); 10639 if (c < p.getCost(1) /* stm */) { 10640 p.setCost(1 /* stm */, (char)(c)); 10641 p.writePacked(0, 0xFFFFFF00, 0x14); // p.stm = 20 10642 } 10643 } 10644 10645 /** 10646 * Labels TRAP tree node 10647 * @param p node to label 10648 */ 10649 private static void label_TRAP(AbstractBURS_TreeNode p) { 10650 p.initCost(); 10651 // stm: TRAP 10652 if(BURS.DEBUG) trace(p, 40, 10 + 0, p.getCost(1) /* stm */); 10653 if (10 < p.getCost(1) /* stm */) { 10654 p.setCost(1 /* stm */, (char)(10)); 10655 p.writePacked(0, 0xFFFFFF00, 0xF); // p.stm = 15 10656 } 10657 } 10658 10659 /** 10660 * Labels FLOAT_AS_INT_BITS tree node 10661 * @param p node to label 10662 */ 10663 private static void label_FLOAT_AS_INT_BITS(AbstractBURS_TreeNode p) { 10664 p.initCost(); 10665 AbstractBURS_TreeNode lchild; 10666 lchild = p.getChild1(); 10667 label(lchild); 10668 int c; 10669 // r: FLOAT_AS_INT_BITS(r) 10670 c = STATE(lchild).getCost(2 /* r */) + 13; 10671 if(BURS.DEBUG) trace(p, 372, c + 0, p.getCost(2) /* r */); 10672 if (c < p.getCost(2) /* r */) { 10673 p.setCost(2 /* r */, (char)(c)); 10674 p.writePacked(0, 0xFFFE00FF, 0xE100); // p.r = 225 10675 closure_r(p, c); 10676 } 10677 // load32: FLOAT_AS_INT_BITS(float_load) 10678 c = STATE(lchild).getCost(26 /* float_load */) + 0; 10679 if(BURS.DEBUG) trace(p, 373, c + 0, p.getCost(10) /* load32 */); 10680 if (c < p.getCost(10) /* load32 */) { 10681 p.setCost(10 /* load32 */, (char)(c)); 10682 p.writePacked(1, 0xFFFFC7FF, 0x3800); // p.load32 = 7 10683 closure_load32(p, c); 10684 } 10685 } 10686 10687 /** 10688 * Labels INT_BITS_AS_FLOAT tree node 10689 * @param p node to label 10690 */ 10691 private static void label_INT_BITS_AS_FLOAT(AbstractBURS_TreeNode p) { 10692 p.initCost(); 10693 AbstractBURS_TreeNode lchild; 10694 lchild = p.getChild1(); 10695 label(lchild); 10696 int c; 10697 // r: INT_BITS_AS_FLOAT(riv) 10698 c = STATE(lchild).getCost(7 /* riv */) + 13; 10699 if(BURS.DEBUG) trace(p, 376, c + 0, p.getCost(2) /* r */); 10700 if (c < p.getCost(2) /* r */) { 10701 p.setCost(2 /* r */, (char)(c)); 10702 p.writePacked(0, 0xFFFE00FF, 0xE300); // p.r = 227 10703 closure_r(p, c); 10704 } 10705 // float_load: INT_BITS_AS_FLOAT(load32) 10706 c = STATE(lchild).getCost(10 /* load32 */) + 0; 10707 if(BURS.DEBUG) trace(p, 377, c + 0, p.getCost(26) /* float_load */); 10708 if (c < p.getCost(26) /* float_load */) { 10709 p.setCost(26 /* float_load */, (char)(c)); 10710 p.writePacked(2, 0xC7FFFFFF, 0x18000000); // p.float_load = 3 10711 } 10712 } 10713 10714 /** 10715 * Labels DOUBLE_AS_LONG_BITS tree node 10716 * @param p node to label 10717 */ 10718 private static void label_DOUBLE_AS_LONG_BITS(AbstractBURS_TreeNode p) { 10719 p.initCost(); 10720 AbstractBURS_TreeNode lchild; 10721 lchild = p.getChild1(); 10722 label(lchild); 10723 int c; 10724 // r: DOUBLE_AS_LONG_BITS(r) 10725 c = STATE(lchild).getCost(2 /* r */) + 13; 10726 if(BURS.DEBUG) trace(p, 374, c + 0, p.getCost(2) /* r */); 10727 if (c < p.getCost(2) /* r */) { 10728 p.setCost(2 /* r */, (char)(c)); 10729 p.writePacked(0, 0xFFFE00FF, 0xE200); // p.r = 226 10730 closure_r(p, c); 10731 } 10732 // load64: DOUBLE_AS_LONG_BITS(double_load) 10733 c = STATE(lchild).getCost(27 /* double_load */) + 0; 10734 if(BURS.DEBUG) trace(p, 375, c + 0, p.getCost(20) /* load64 */); 10735 if (c < p.getCost(20) /* load64 */) { 10736 p.setCost(20 /* load64 */, (char)(c)); 10737 p.writePacked(2, 0xFFFF8FFF, 0x5000); // p.load64 = 5 10738 closure_load64(p, c); 10739 } 10740 } 10741 10742 /** 10743 * Labels LONG_BITS_AS_DOUBLE tree node 10744 * @param p node to label 10745 */ 10746 private static void label_LONG_BITS_AS_DOUBLE(AbstractBURS_TreeNode p) { 10747 p.initCost(); 10748 AbstractBURS_TreeNode lchild; 10749 lchild = p.getChild1(); 10750 label(lchild); 10751 int c; 10752 // r: LONG_BITS_AS_DOUBLE(rlv) 10753 c = STATE(lchild).getCost(8 /* rlv */) + 13; 10754 if(BURS.DEBUG) trace(p, 378, c + 0, p.getCost(2) /* r */); 10755 if (c < p.getCost(2) /* r */) { 10756 p.setCost(2 /* r */, (char)(c)); 10757 p.writePacked(0, 0xFFFE00FF, 0xE400); // p.r = 228 10758 closure_r(p, c); 10759 } 10760 // double_load: LONG_BITS_AS_DOUBLE(load64) 10761 c = STATE(lchild).getCost(20 /* load64 */) + 0; 10762 if(BURS.DEBUG) trace(p, 379, c + 0, p.getCost(27) /* double_load */); 10763 if (c < p.getCost(27) /* double_load */) { 10764 p.setCost(27 /* double_load */, (char)(c)); 10765 p.writePacked(3, 0xFFFFFFF8, 0x4); // p.double_load = 4 10766 } 10767 } 10768 10769 /** 10770 * Labels LOWTABLESWITCH tree node 10771 * @param p node to label 10772 */ 10773 private static void label_LOWTABLESWITCH(AbstractBURS_TreeNode p) { 10774 p.initCost(); 10775 AbstractBURS_TreeNode lchild; 10776 lchild = p.getChild1(); 10777 label(lchild); 10778 int c; 10779 // stm: LOWTABLESWITCH(r) 10780 c = STATE(lchild).getCost(2 /* r */) + 10; 10781 if(BURS.DEBUG) trace(p, 247, c + 0, p.getCost(1) /* stm */); 10782 if (c < p.getCost(1) /* stm */) { 10783 p.setCost(1 /* stm */, (char)(c)); 10784 p.writePacked(0, 0xFFFFFF00, 0x8); // p.stm = 8 10785 } 10786 } 10787 10788 /** 10789 * Labels ADDRESS_CONSTANT tree node 10790 * @param p node to label 10791 */ 10792 private static void label_ADDRESS_CONSTANT(AbstractBURS_TreeNode p) { 10793 p.initCost(); 10794 // any: ADDRESS_CONSTANT 10795 if(BURS.DEBUG) trace(p, 25, 0 + 0, p.getCost(9) /* any */); 10796 if (0 < p.getCost(9) /* any */) { 10797 p.setCost(9 /* any */, (char)(0)); 10798 p.writePacked(1, 0xFFFFF8FF, 0x300); // p.any = 3 10799 } 10800 } 10801 10802 /** 10803 * Labels INT_CONSTANT tree node 10804 * @param p node to label 10805 */ 10806 private static void label_INT_CONSTANT(AbstractBURS_TreeNode p) { 10807 p.initCost(); 10808 // riv: INT_CONSTANT 10809 if(BURS.DEBUG) trace(p, 22, 0 + 0, p.getCost(7) /* riv */); 10810 if (0 < p.getCost(7) /* riv */) { 10811 p.setCost(7 /* riv */, (char)(0)); 10812 p.writePacked(1, 0xFFFFFFCF, 0x20); // p.riv = 2 10813 closure_riv(p, 0); 10814 } 10815 } 10816 10817 /** 10818 * Labels LONG_CONSTANT tree node 10819 * @param p node to label 10820 */ 10821 private static void label_LONG_CONSTANT(AbstractBURS_TreeNode p) { 10822 p.initCost(); 10823 // rlv: LONG_CONSTANT 10824 if(BURS.DEBUG) trace(p, 23, 0 + 0, p.getCost(8) /* rlv */); 10825 if (0 < p.getCost(8) /* rlv */) { 10826 p.setCost(8 /* rlv */, (char)(0)); 10827 p.writePacked(1, 0xFFFFFF3F, 0x80); // p.rlv = 2 10828 } 10829 // any: LONG_CONSTANT 10830 if(BURS.DEBUG) trace(p, 26, 0 + 0, p.getCost(9) /* any */); 10831 if (0 < p.getCost(9) /* any */) { 10832 p.setCost(9 /* any */, (char)(0)); 10833 p.writePacked(1, 0xFFFFF8FF, 0x400); // p.any = 4 10834 } 10835 } 10836 10837 /** 10838 * Labels REGISTER tree node 10839 * @param p node to label 10840 */ 10841 private static void label_REGISTER(AbstractBURS_TreeNode p) { 10842 p.initCost(); 10843 // r: REGISTER 10844 if(BURS.DEBUG) trace(p, 21, 0 + 0, p.getCost(2) /* r */); 10845 if (0 < p.getCost(2) /* r */) { 10846 p.setCost(2 /* r */, (char)(0)); 10847 p.writePacked(0, 0xFFFE00FF, 0x100); // p.r = 1 10848 closure_r(p, 0); 10849 } 10850 } 10851 10852 /** 10853 * Labels OTHER_OPERAND tree node 10854 * @param p node to label 10855 */ 10856 private static void label_OTHER_OPERAND(AbstractBURS_TreeNode p) { 10857 p.initCost(); 10858 AbstractBURS_TreeNode lchild, rchild; 10859 lchild = p.getChild1(); 10860 rchild = p.getChild2(); 10861 label(lchild); 10862 label(rchild); 10863 int c; 10864 // any: OTHER_OPERAND(any,any) 10865 c = STATE(lchild).getCost(9 /* any */) + STATE(rchild).getCost(9 /* any */) + 0; 10866 if(BURS.DEBUG) trace(p, 51, c + 0, p.getCost(9) /* any */); 10867 if (c < p.getCost(9) /* any */) { 10868 p.setCost(9 /* any */, (char)(c)); 10869 p.writePacked(1, 0xFFFFF8FF, 0x500); // p.any = 5 10870 } 10871 } 10872 10873 /** 10874 * Labels NULL tree node 10875 * @param p node to label 10876 */ 10877 private static void label_NULL(AbstractBURS_TreeNode p) { 10878 p.initCost(); 10879 // any: NULL 10880 if(BURS.DEBUG) trace(p, 24, 0 + 0, p.getCost(9) /* any */); 10881 if (0 < p.getCost(9) /* any */) { 10882 p.setCost(9 /* any */, (char)(0)); 10883 p.writePacked(1, 0xFFFFF8FF, 0x100); // p.any = 1 10884 } 10885 } 10886 10887 /** 10888 * Labels BRANCH_TARGET tree node 10889 * @param p node to label 10890 */ 10891 private static void label_BRANCH_TARGET(AbstractBURS_TreeNode p) { 10892 p.initCost(); 10893 } 10894 10895 /** 10896 * Labels MATERIALIZE_FP_CONSTANT tree node 10897 * @param p node to label 10898 */ 10899 private static void label_MATERIALIZE_FP_CONSTANT(AbstractBURS_TreeNode p) { 10900 p.initCost(); 10901 AbstractBURS_TreeNode lchild; 10902 lchild = p.getChild1(); 10903 label(lchild); 10904 int c; 10905 // r: MATERIALIZE_FP_CONSTANT(any) 10906 c = STATE(lchild).getCost(9 /* any */) + 15; 10907 if(BURS.DEBUG) trace(p, 380, c + 0, p.getCost(2) /* r */); 10908 if (c < p.getCost(2) /* r */) { 10909 p.setCost(2 /* r */, (char)(c)); 10910 p.writePacked(0, 0xFFFE00FF, 0xE500); // p.r = 229 10911 closure_r(p, c); 10912 } 10913 // float_load: MATERIALIZE_FP_CONSTANT(any) 10914 c = STATE(lchild).getCost(9 /* any */) + (Binary.getResult(P(p)).isFloat() ? 0 : INFINITE); 10915 if(BURS.DEBUG) trace(p, 381, c + 0, p.getCost(26) /* float_load */); 10916 if (c < p.getCost(26) /* float_load */) { 10917 p.setCost(26 /* float_load */, (char)(c)); 10918 p.writePacked(2, 0xC7FFFFFF, 0x20000000); // p.float_load = 4 10919 } 10920 // double_load: MATERIALIZE_FP_CONSTANT(any) 10921 c = STATE(lchild).getCost(9 /* any */) + (Binary.getResult(P(p)).isDouble() ? 0 : INFINITE); 10922 if(BURS.DEBUG) trace(p, 382, c + 0, p.getCost(27) /* double_load */); 10923 if (c < p.getCost(27) /* double_load */) { 10924 p.setCost(27 /* double_load */, (char)(c)); 10925 p.writePacked(3, 0xFFFFFFF8, 0x5); // p.double_load = 5 10926 } 10927 } 10928 10929 /** 10930 * Labels CLEAR_FLOATING_POINT_STATE tree node 10931 * @param p node to label 10932 */ 10933 private static void label_CLEAR_FLOATING_POINT_STATE(AbstractBURS_TreeNode p) { 10934 p.initCost(); 10935 // stm: CLEAR_FLOATING_POINT_STATE 10936 if(BURS.DEBUG) trace(p, 50, 0 + 0, p.getCost(1) /* stm */); 10937 if (0 < p.getCost(1) /* stm */) { 10938 p.setCost(1 /* stm */, (char)(0)); 10939 p.writePacked(0, 0xFFFFFF00, 0xD5); // p.stm = 213 10940 } 10941 } 10942 10943 /** 10944 * Labels PREFETCH tree node 10945 * @param p node to label 10946 */ 10947 private static void label_PREFETCH(AbstractBURS_TreeNode p) { 10948 p.initCost(); 10949 AbstractBURS_TreeNode lchild; 10950 lchild = p.getChild1(); 10951 label(lchild); 10952 int c; 10953 // stm: PREFETCH(r) 10954 c = STATE(lchild).getCost(2 /* r */) + 11; 10955 if(BURS.DEBUG) trace(p, 256, c + 0, p.getCost(1) /* stm */); 10956 if (c < p.getCost(1) /* stm */) { 10957 p.setCost(1 /* stm */, (char)(c)); 10958 p.writePacked(0, 0xFFFFFF00, 0x27); // p.stm = 39 10959 } 10960 } 10961 10962 /** 10963 * Labels PAUSE tree node 10964 * @param p node to label 10965 */ 10966 private static void label_PAUSE(AbstractBURS_TreeNode p) { 10967 p.initCost(); 10968 // stm: PAUSE 10969 if(BURS.DEBUG) trace(p, 45, 11 + 0, p.getCost(1) /* stm */); 10970 if (11 < p.getCost(1) /* stm */) { 10971 p.setCost(1 /* stm */, (char)(11)); 10972 p.writePacked(0, 0xFFFFFF00, 0x2B); // p.stm = 43 10973 } 10974 } 10975 10976 /** 10977 * Labels CMP_CMOV tree node 10978 * @param p node to label 10979 */ 10980 private static void label_CMP_CMOV(AbstractBURS_TreeNode p) { 10981 p.initCost(); 10982 AbstractBURS_TreeNode lchild, rchild; 10983 lchild = p.getChild1(); 10984 rchild = p.getChild2(); 10985 label(lchild); 10986 label(rchild); 10987 int c; 10988 if ( // r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 10989 rchild.getOpcode() == OTHER_OPERAND_opcode 10990 ) { 10991 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (13 + 30); 10992 if(BURS.DEBUG) trace(p, 418, c + 0, p.getCost(2) /* r */); 10993 if (c < p.getCost(2) /* r */) { 10994 p.setCost(2 /* r */, (char)(c)); 10995 p.writePacked(0, 0xFFFE00FF, 0x3D00); // p.r = 61 10996 closure_r(p, c); 10997 } 10998 } 10999 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 11000 rchild.getOpcode() == OTHER_OPERAND_opcode && 11001 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11002 ) { 11003 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (VRL(p) == 0 && CMP_TO_TEST(CondMove.getCond(P(p))) ? (11 + 30):INFINITE); 11004 if(BURS.DEBUG) trace(p, 552, c + 0, p.getCost(2) /* r */); 11005 if (c < p.getCost(2) /* r */) { 11006 p.setCost(2 /* r */, (char)(c)); 11007 p.writePacked(0, 0xFFFE00FF, 0x3E00); // p.r = 62 11008 closure_r(p, c); 11009 } 11010 } 11011 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11012 rchild.getOpcode() == OTHER_OPERAND_opcode && 11013 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11014 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11015 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 11016 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 11017 ) { 11018 c = STATE(lchild).getCost(2 /* r */) + ((VRL(p) == 0 && CondMove.getCond(P(p)).isLESS() && VRRL(p) == -1 && VRRR(p) == 0) || (VRL(p) == 0 && CondMove.getCond(P(p)).isGREATER_EQUAL() && VRRL(p) == 0 && VRRR(p) == -1) ? 13 : INFINITE); 11019 if(BURS.DEBUG) trace(p, 294, c + 0, p.getCost(2) /* r */); 11020 if (c < p.getCost(2) /* r */) { 11021 p.setCost(2 /* r */, (char)(c)); 11022 p.writePacked(0, 0xFFFE00FF, 0x3F00); // p.r = 63 11023 closure_r(p, c); 11024 } 11025 } 11026 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11027 rchild.getOpcode() == OTHER_OPERAND_opcode && 11028 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11029 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11030 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 11031 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 11032 ) { 11033 c = STATE(lchild).getCost(10 /* load32 */) + ((VRL(p) == 0 && CondMove.getCond(P(p)).isLESS() && VRRL(p) == -1 && VRRR(p) == 0) || (VRL(p) == 0 && CondMove.getCond(P(p)).isGREATER_EQUAL() && VRRL(p) == 0 && VRRR(p) == -1) ? 18 : INFINITE); 11034 if(BURS.DEBUG) trace(p, 295, c + 0, p.getCost(2) /* r */); 11035 if (c < p.getCost(2) /* r */) { 11036 p.setCost(2 /* r */, (char)(c)); 11037 p.writePacked(0, 0xFFFE00FF, 0x4000); // p.r = 64 11038 closure_r(p, c); 11039 } 11040 } 11041 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11042 rchild.getOpcode() == OTHER_OPERAND_opcode && 11043 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11044 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11045 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 11046 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 11047 ) { 11048 c = STATE(lchild).getCost(2 /* r */) + ((VRL(p) == 0 && CondMove.getCond(P(p)).isLESS() && VRRL(p) == 0 && VRRR(p) == -1) || (VRL(p) == 0 && CondMove.getCond(P(p)).isGREATER_EQUAL() && VRRL(p) == -1 && VRRR(p) == 0) ? 26 : INFINITE); 11049 if(BURS.DEBUG) trace(p, 296, c + 0, p.getCost(2) /* r */); 11050 if (c < p.getCost(2) /* r */) { 11051 p.setCost(2 /* r */, (char)(c)); 11052 p.writePacked(0, 0xFFFE00FF, 0x4100); // p.r = 65 11053 closure_r(p, c); 11054 } 11055 } 11056 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11057 rchild.getOpcode() == OTHER_OPERAND_opcode && 11058 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11059 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11060 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 11061 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 11062 ) { 11063 c = STATE(lchild).getCost(10 /* load32 */) + ((VRL(p) == 0 && CondMove.getCond(P(p)).isLESS() && VRRL(p) == 0 && VRRR(p) == -1) || (VRL(p) == 0 && CondMove.getCond(P(p)).isGREATER_EQUAL() && VRRL(p) == -1 && VRRR(p) == 0) ? 31 : INFINITE); 11064 if(BURS.DEBUG) trace(p, 297, c + 0, p.getCost(2) /* r */); 11065 if (c < p.getCost(2) /* r */) { 11066 p.setCost(2 /* r */, (char)(c)); 11067 p.writePacked(0, 0xFFFE00FF, 0x4200); // p.r = 66 11068 closure_r(p, c); 11069 } 11070 } 11071 if ( // r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 11072 rchild.getOpcode() == OTHER_OPERAND_opcode && 11073 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11074 ) { 11075 c = STATE(lchild).getCost(21 /* load8 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + FITS(CondMove.getVal2(P(p)), 8, (15 + 30)); 11076 if(BURS.DEBUG) trace(p, 553, c + 0, p.getCost(2) /* r */); 11077 if (c < p.getCost(2) /* r */) { 11078 p.setCost(2 /* r */, (char)(c)); 11079 p.writePacked(0, 0xFFFE00FF, 0x4300); // p.r = 67 11080 closure_r(p, c); 11081 } 11082 } 11083 if ( // r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 11084 rchild.getOpcode() == OTHER_OPERAND_opcode 11085 ) { 11086 c = STATE(lchild).getCost(11 /* uload8 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11087 if(BURS.DEBUG) trace(p, 419, c + 0, p.getCost(2) /* r */); 11088 if (c < p.getCost(2) /* r */) { 11089 p.setCost(2 /* r */, (char)(c)); 11090 p.writePacked(0, 0xFFFE00FF, 0x4400); // p.r = 68 11091 closure_r(p, c); 11092 } 11093 } 11094 if ( // r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 11095 rchild.getOpcode() == OTHER_OPERAND_opcode 11096 ) { 11097 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(11 /* uload8 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11098 if(BURS.DEBUG) trace(p, 420, c + 0, p.getCost(2) /* r */); 11099 if (c < p.getCost(2) /* r */) { 11100 p.setCost(2 /* r */, (char)(c)); 11101 p.writePacked(0, 0xFFFE00FF, 0x4500); // p.r = 69 11102 closure_r(p, c); 11103 } 11104 } 11105 if ( // r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 11106 rchild.getOpcode() == OTHER_OPERAND_opcode && 11107 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11108 ) { 11109 c = STATE(lchild).getCost(22 /* sload16 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + FITS(CondMove.getVal2(P(p)), 8, (15 + 30)); 11110 if(BURS.DEBUG) trace(p, 554, c + 0, p.getCost(2) /* r */); 11111 if (c < p.getCost(2) /* r */) { 11112 p.setCost(2 /* r */, (char)(c)); 11113 p.writePacked(0, 0xFFFE00FF, 0x4600); // p.r = 70 11114 closure_r(p, c); 11115 } 11116 } 11117 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 11118 rchild.getOpcode() == OTHER_OPERAND_opcode 11119 ) { 11120 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11121 if(BURS.DEBUG) trace(p, 421, c + 0, p.getCost(2) /* r */); 11122 if (c < p.getCost(2) /* r */) { 11123 p.setCost(2 /* r */, (char)(c)); 11124 p.writePacked(0, 0xFFFE00FF, 0x4700); // p.r = 71 11125 closure_r(p, c); 11126 } 11127 } 11128 if ( // r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 11129 rchild.getOpcode() == OTHER_OPERAND_opcode 11130 ) { 11131 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(10 /* load32 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11132 if(BURS.DEBUG) trace(p, 422, c + 0, p.getCost(2) /* r */); 11133 if (c < p.getCost(2) /* r */) { 11134 p.setCost(2 /* r */, (char)(c)); 11135 p.writePacked(0, 0xFFFE00FF, 0x4800); // p.r = 72 11136 closure_r(p, c); 11137 } 11138 } 11139 if ( // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 11140 rchild.getOpcode() == OTHER_OPERAND_opcode && 11141 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11142 ) { 11143 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild2()).getCost(9 /* any */) + ((VRL(p) == 0 && CondMove.getCond(P(p)).isNOT_EQUAL()) || (VRL(p) == 1 && CondMove.getCond(P(p)).isEQUAL()) ? 30 : INFINITE); 11144 if(BURS.DEBUG) trace(p, 555, c + 0, p.getCost(2) /* r */); 11145 if (c < p.getCost(2) /* r */) { 11146 p.setCost(2 /* r */, (char)(c)); 11147 p.writePacked(0, 0xFFFE00FF, 0x4900); // p.r = 73 11148 closure_r(p, c); 11149 } 11150 } 11151 if ( // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 11152 rchild.getOpcode() == OTHER_OPERAND_opcode && 11153 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11154 ) { 11155 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild2()).getCost(9 /* any */) + ((VRL(p) == 1 && CondMove.getCond(P(p)).isNOT_EQUAL()) || (VRL(p) == 0 && CondMove.getCond(P(p)).isEQUAL()) ? 30 : INFINITE); 11156 if(BURS.DEBUG) trace(p, 556, c + 0, p.getCost(2) /* r */); 11157 if (c < p.getCost(2) /* r */) { 11158 p.setCost(2 /* r */, (char)(c)); 11159 p.writePacked(0, 0xFFFE00FF, 0x4A00); // p.r = 74 11160 closure_r(p, c); 11161 } 11162 } 11163 if ( // r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 11164 rchild.getOpcode() == OTHER_OPERAND_opcode && 11165 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11166 ) { 11167 c = STATE(lchild).getCost(18 /* bittest */) + STATE(rchild.getChild2()).getCost(9 /* any */) + ((VRL(p) == 0 || VRL(p) == 1) && EQ_NE(CondMove.getCond(P(p))) ? 30 : INFINITE); 11168 if(BURS.DEBUG) trace(p, 557, c + 0, p.getCost(2) /* r */); 11169 if (c < p.getCost(2) /* r */) { 11170 p.setCost(2 /* r */, (char)(c)); 11171 p.writePacked(0, 0xFFFE00FF, 0x4B00); // p.r = 75 11172 closure_r(p, c); 11173 } 11174 } 11175 if ( // r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 11176 rchild.getOpcode() == OTHER_OPERAND_opcode && 11177 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11178 ) { 11179 c = STATE(lchild).getCost(4 /* cz */) + STATE(rchild.getChild2()).getCost(9 /* any */) + isZERO(VRL(p), 30); 11180 if(BURS.DEBUG) trace(p, 558, c + 0, p.getCost(2) /* r */); 11181 if (c < p.getCost(2) /* r */) { 11182 p.setCost(2 /* r */, (char)(c)); 11183 p.writePacked(0, 0xFFFE00FF, 0x4C00); // p.r = 76 11184 closure_r(p, c); 11185 } 11186 } 11187 if ( // r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 11188 rchild.getOpcode() == OTHER_OPERAND_opcode && 11189 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11190 ) { 11191 c = STATE(lchild).getCost(6 /* szp */) + STATE(rchild.getChild2()).getCost(9 /* any */) + isZERO(VRL(p), 30); 11192 if(BURS.DEBUG) trace(p, 559, c + 0, p.getCost(2) /* r */); 11193 if (c < p.getCost(2) /* r */) { 11194 p.setCost(2 /* r */, (char)(c)); 11195 p.writePacked(0, 0xFFFE00FF, 0x4D00); // p.r = 77 11196 closure_r(p, c); 11197 } 11198 } 11199 } 11200 11201 /** 11202 * Labels FCMP_CMOV tree node 11203 * @param p node to label 11204 */ 11205 private static void label_FCMP_CMOV(AbstractBURS_TreeNode p) { 11206 p.initCost(); 11207 AbstractBURS_TreeNode lchild, rchild; 11208 lchild = p.getChild1(); 11209 rchild = p.getChild2(); 11210 label(lchild); 11211 label(rchild); 11212 int c; 11213 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 11214 rchild.getOpcode() == OTHER_OPERAND_opcode 11215 ) { 11216 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13*2; 11217 if(BURS.DEBUG) trace(p, 454, c + 0, p.getCost(2) /* r */); 11218 if (c < p.getCost(2) /* r */) { 11219 p.setCost(2 /* r */, (char)(c)); 11220 p.writePacked(0, 0xFFFE00FF, 0xE600); // p.r = 230 11221 closure_r(p, c); 11222 } 11223 } 11224 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 11225 rchild.getOpcode() == OTHER_OPERAND_opcode 11226 ) { 11227 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(26 /* float_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 11228 if(BURS.DEBUG) trace(p, 455, c + 0, p.getCost(2) /* r */); 11229 if (c < p.getCost(2) /* r */) { 11230 p.setCost(2 /* r */, (char)(c)); 11231 p.writePacked(0, 0xFFFE00FF, 0xE700); // p.r = 231 11232 closure_r(p, c); 11233 } 11234 } 11235 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 11236 rchild.getOpcode() == OTHER_OPERAND_opcode 11237 ) { 11238 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(27 /* double_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 11239 if(BURS.DEBUG) trace(p, 456, c + 0, p.getCost(2) /* r */); 11240 if (c < p.getCost(2) /* r */) { 11241 p.setCost(2 /* r */, (char)(c)); 11242 p.writePacked(0, 0xFFFE00FF, 0xE800); // p.r = 232 11243 closure_r(p, c); 11244 } 11245 } 11246 if ( // r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 11247 rchild.getOpcode() == OTHER_OPERAND_opcode 11248 ) { 11249 c = STATE(lchild).getCost(26 /* float_load */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 11250 if(BURS.DEBUG) trace(p, 457, c + 0, p.getCost(2) /* r */); 11251 if (c < p.getCost(2) /* r */) { 11252 p.setCost(2 /* r */, (char)(c)); 11253 p.writePacked(0, 0xFFFE00FF, 0xE900); // p.r = 233 11254 closure_r(p, c); 11255 } 11256 } 11257 if ( // r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 11258 rchild.getOpcode() == OTHER_OPERAND_opcode 11259 ) { 11260 c = STATE(lchild).getCost(27 /* double_load */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 11261 if(BURS.DEBUG) trace(p, 458, c + 0, p.getCost(2) /* r */); 11262 if (c < p.getCost(2) /* r */) { 11263 p.setCost(2 /* r */, (char)(c)); 11264 p.writePacked(0, 0xFFFE00FF, 0xEA00); // p.r = 234 11265 closure_r(p, c); 11266 } 11267 } 11268 } 11269 11270 /** 11271 * Labels LCMP_CMOV tree node 11272 * @param p node to label 11273 */ 11274 private static void label_LCMP_CMOV(AbstractBURS_TreeNode p) { 11275 p.initCost(); 11276 AbstractBURS_TreeNode lchild, rchild; 11277 lchild = p.getChild1(); 11278 rchild = p.getChild2(); 11279 label(lchild); 11280 label(rchild); 11281 int c; 11282 if ( // r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 11283 rchild.getOpcode() == OTHER_OPERAND_opcode 11284 ) { 11285 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (13 + 30); 11286 if(BURS.DEBUG) trace(p, 428, c + 0, p.getCost(2) /* r */); 11287 if (c < p.getCost(2) /* r */) { 11288 p.setCost(2 /* r */, (char)(c)); 11289 p.writePacked(0, 0xFFFE00FF, 0x7400); // p.r = 116 11290 closure_r(p, c); 11291 } 11292 } 11293 if ( // r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 11294 rchild.getOpcode() == OTHER_OPERAND_opcode && 11295 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 11296 ) { 11297 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (VRL(p) == 0 && CMP_TO_TEST(CondMove.getCond(P(p))) ? (11 + 30):INFINITE); 11298 if(BURS.DEBUG) trace(p, 560, c + 0, p.getCost(2) /* r */); 11299 if (c < p.getCost(2) /* r */) { 11300 p.setCost(2 /* r */, (char)(c)); 11301 p.writePacked(0, 0xFFFE00FF, 0x7500); // p.r = 117 11302 closure_r(p, c); 11303 } 11304 } 11305 if ( // r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) 11306 rchild.getOpcode() == OTHER_OPERAND_opcode 11307 ) { 11308 c = STATE(lchild).getCost(20 /* load64 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11309 if(BURS.DEBUG) trace(p, 429, c + 0, p.getCost(2) /* r */); 11310 if (c < p.getCost(2) /* r */) { 11311 p.setCost(2 /* r */, (char)(c)); 11312 p.writePacked(0, 0xFFFE00FF, 0x7600); // p.r = 118 11313 closure_r(p, c); 11314 } 11315 } 11316 if ( // r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) 11317 rchild.getOpcode() == OTHER_OPERAND_opcode 11318 ) { 11319 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(20 /* load64 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 11320 if(BURS.DEBUG) trace(p, 430, c + 0, p.getCost(2) /* r */); 11321 if (c < p.getCost(2) /* r */) { 11322 p.setCost(2 /* r */, (char)(c)); 11323 p.writePacked(0, 0xFFFE00FF, 0x7700); // p.r = 119 11324 closure_r(p, c); 11325 } 11326 } 11327 } 11328 11329 /** 11330 * Labels FCMP_FCMOV tree node 11331 * @param p node to label 11332 */ 11333 private static void label_FCMP_FCMOV(AbstractBURS_TreeNode p) { 11334 p.initCost(); 11335 AbstractBURS_TreeNode lchild, rchild; 11336 lchild = p.getChild1(); 11337 rchild = p.getChild2(); 11338 label(lchild); 11339 label(rchild); 11340 int c; 11341 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 11342 rchild.getOpcode() == OTHER_OPERAND_opcode 11343 ) { 11344 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13*4; 11345 if(BURS.DEBUG) trace(p, 459, c + 0, p.getCost(2) /* r */); 11346 if (c < p.getCost(2) /* r */) { 11347 p.setCost(2 /* r */, (char)(c)); 11348 p.writePacked(0, 0xFFFE00FF, 0xEB00); // p.r = 235 11349 closure_r(p, c); 11350 } 11351 } 11352 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 11353 rchild.getOpcode() == OTHER_OPERAND_opcode && 11354 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 11355 ) { 11356 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(26 /* float_load */) + 15+13*3; 11357 if(BURS.DEBUG) trace(p, 486, c + 0, p.getCost(2) /* r */); 11358 if (c < p.getCost(2) /* r */) { 11359 p.setCost(2 /* r */, (char)(c)); 11360 p.writePacked(0, 0xFFFE00FF, 0xEC00); // p.r = 236 11361 closure_r(p, c); 11362 } 11363 } 11364 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 11365 rchild.getOpcode() == OTHER_OPERAND_opcode && 11366 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 11367 ) { 11368 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(27 /* double_load */) + 15+13*3; 11369 if(BURS.DEBUG) trace(p, 487, c + 0, p.getCost(2) /* r */); 11370 if (c < p.getCost(2) /* r */) { 11371 p.setCost(2 /* r */, (char)(c)); 11372 p.writePacked(0, 0xFFFE00FF, 0xED00); // p.r = 237 11373 closure_r(p, c); 11374 } 11375 } 11376 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 11377 rchild.getOpcode() == OTHER_OPERAND_opcode && 11378 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 11379 ) { 11380 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(26 /* float_load */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + 15+13*3; 11381 if(BURS.DEBUG) trace(p, 488, c + 0, p.getCost(2) /* r */); 11382 if (c < p.getCost(2) /* r */) { 11383 p.setCost(2 /* r */, (char)(c)); 11384 p.writePacked(0, 0xFFFE00FF, 0xEE00); // p.r = 238 11385 closure_r(p, c); 11386 } 11387 } 11388 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 11389 rchild.getOpcode() == OTHER_OPERAND_opcode && 11390 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 11391 ) { 11392 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(27 /* double_load */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + 15+13*3; 11393 if(BURS.DEBUG) trace(p, 489, c + 0, p.getCost(2) /* r */); 11394 if (c < p.getCost(2) /* r */) { 11395 p.setCost(2 /* r */, (char)(c)); 11396 p.writePacked(0, 0xFFFE00FF, 0xEF00); // p.r = 239 11397 closure_r(p, c); 11398 } 11399 } 11400 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 11401 rchild.getOpcode() == OTHER_OPERAND_opcode 11402 ) { 11403 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(26 /* float_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (SSE2_CMP_OP(CondMove.getCond(P(p)), true) != null ? 15+13*3 : INFINITE); 11404 if(BURS.DEBUG) trace(p, 460, c + 0, p.getCost(2) /* r */); 11405 if (c < p.getCost(2) /* r */) { 11406 p.setCost(2 /* r */, (char)(c)); 11407 p.writePacked(0, 0xFFFE00FF, 0xF000); // p.r = 240 11408 closure_r(p, c); 11409 } 11410 } 11411 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 11412 rchild.getOpcode() == OTHER_OPERAND_opcode 11413 ) { 11414 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(27 /* double_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (SSE2_CMP_OP(CondMove.getCond(P(p)), false) != null ? 15+13*3 : INFINITE); 11415 if(BURS.DEBUG) trace(p, 461, c + 0, p.getCost(2) /* r */); 11416 if (c < p.getCost(2) /* r */) { 11417 p.setCost(2 /* r */, (char)(c)); 11418 p.writePacked(0, 0xFFFE00FF, 0xF100); // p.r = 241 11419 closure_r(p, c); 11420 } 11421 } 11422 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11423 rchild.getOpcode() == OTHER_OPERAND_opcode && 11424 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11425 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 11426 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11427 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 11428 ) { 11429 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11430 if(BURS.DEBUG) trace(p, 637, c + 0, p.getCost(2) /* r */); 11431 if (c < p.getCost(2) /* r */) { 11432 p.setCost(2 /* r */, (char)(c)); 11433 p.writePacked(0, 0xFFFE00FF, 0xF200); // p.r = 242 11434 closure_r(p, c); 11435 } 11436 } 11437 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11438 rchild.getOpcode() == OTHER_OPERAND_opcode && 11439 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11440 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 11441 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11442 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 11443 ) { 11444 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11445 if(BURS.DEBUG) trace(p, 638, c + 0, p.getCost(2) /* r */); 11446 if (c < p.getCost(2) /* r */) { 11447 p.setCost(2 /* r */, (char)(c)); 11448 p.writePacked(0, 0xFFFE00FF, 0xF300); // p.r = 243 11449 closure_r(p, c); 11450 } 11451 } 11452 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11453 rchild.getOpcode() == OTHER_OPERAND_opcode && 11454 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11455 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 11456 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11457 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 11458 ) { 11459 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11460 if(BURS.DEBUG) trace(p, 641, c + 0, p.getCost(2) /* r */); 11461 if (c < p.getCost(2) /* r */) { 11462 p.setCost(2 /* r */, (char)(c)); 11463 p.writePacked(0, 0xFFFE00FF, 0xF400); // p.r = 244 11464 closure_r(p, c); 11465 } 11466 } 11467 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11468 rchild.getOpcode() == OTHER_OPERAND_opcode && 11469 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11470 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 11471 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11472 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 11473 ) { 11474 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11475 if(BURS.DEBUG) trace(p, 642, c + 0, p.getCost(2) /* r */); 11476 if (c < p.getCost(2) /* r */) { 11477 p.setCost(2 /* r */, (char)(c)); 11478 p.writePacked(0, 0xFFFE00FF, 0xF500); // p.r = 245 11479 closure_r(p, c); 11480 } 11481 } 11482 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11483 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11484 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11485 rchild.getOpcode() == OTHER_OPERAND_opcode && 11486 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11487 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 11488 ) { 11489 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11490 if(BURS.DEBUG) trace(p, 645, c + 0, p.getCost(2) /* r */); 11491 if (c < p.getCost(2) /* r */) { 11492 p.setCost(2 /* r */, (char)(c)); 11493 p.writePacked(0, 0xFFFE00FF, 0xF600); // p.r = 246 11494 closure_r(p, c); 11495 } 11496 } 11497 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11498 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11499 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 11500 rchild.getOpcode() == OTHER_OPERAND_opcode && 11501 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11502 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 11503 ) { 11504 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11505 if(BURS.DEBUG) trace(p, 646, c + 0, p.getCost(2) /* r */); 11506 if (c < p.getCost(2) /* r */) { 11507 p.setCost(2 /* r */, (char)(c)); 11508 p.writePacked(0, 0xFFFE00FF, 0xF700); // p.r = 247 11509 closure_r(p, c); 11510 } 11511 } 11512 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11513 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11514 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11515 rchild.getOpcode() == OTHER_OPERAND_opcode && 11516 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11517 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 11518 ) { 11519 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11520 if(BURS.DEBUG) trace(p, 649, c + 0, p.getCost(2) /* r */); 11521 if (c < p.getCost(2) /* r */) { 11522 p.setCost(2 /* r */, (char)(c)); 11523 p.writePacked(0, 0xFFFE00FF, 0xF800); // p.r = 248 11524 closure_r(p, c); 11525 } 11526 } 11527 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11528 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11529 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 11530 rchild.getOpcode() == OTHER_OPERAND_opcode && 11531 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11532 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 11533 ) { 11534 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11535 if(BURS.DEBUG) trace(p, 650, c + 0, p.getCost(2) /* r */); 11536 if (c < p.getCost(2) /* r */) { 11537 p.setCost(2 /* r */, (char)(c)); 11538 p.writePacked(0, 0xFFFE00FF, 0xF900); // p.r = 249 11539 closure_r(p, c); 11540 } 11541 } 11542 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11543 rchild.getOpcode() == OTHER_OPERAND_opcode && 11544 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11545 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 11546 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11547 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 11548 ) { 11549 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11550 if(BURS.DEBUG) trace(p, 639, c + 0, p.getCost(2) /* r */); 11551 if (c < p.getCost(2) /* r */) { 11552 p.setCost(2 /* r */, (char)(c)); 11553 p.writePacked(0, 0xFFFE00FF, 0xFA00); // p.r = 250 11554 closure_r(p, c); 11555 } 11556 } 11557 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11558 rchild.getOpcode() == OTHER_OPERAND_opcode && 11559 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11560 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 11561 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11562 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 11563 ) { 11564 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11565 if(BURS.DEBUG) trace(p, 640, c + 0, p.getCost(2) /* r */); 11566 if (c < p.getCost(2) /* r */) { 11567 p.setCost(2 /* r */, (char)(c)); 11568 p.writePacked(0, 0xFFFE00FF, 0xFB00); // p.r = 251 11569 closure_r(p, c); 11570 } 11571 } 11572 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11573 rchild.getOpcode() == OTHER_OPERAND_opcode && 11574 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11575 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 11576 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11577 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 11578 ) { 11579 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11580 if(BURS.DEBUG) trace(p, 643, c + 0, p.getCost(2) /* r */); 11581 if (c < p.getCost(2) /* r */) { 11582 p.setCost(2 /* r */, (char)(c)); 11583 p.writePacked(0, 0xFFFE00FF, 0xFC00); // p.r = 252 11584 closure_r(p, c); 11585 } 11586 } 11587 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11588 rchild.getOpcode() == OTHER_OPERAND_opcode && 11589 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11590 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 11591 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11592 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 11593 ) { 11594 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal1(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11595 if(BURS.DEBUG) trace(p, 644, c + 0, p.getCost(2) /* r */); 11596 if (c < p.getCost(2) /* r */) { 11597 p.setCost(2 /* r */, (char)(c)); 11598 p.writePacked(0, 0xFFFE00FF, 0xFD00); // p.r = 253 11599 closure_r(p, c); 11600 } 11601 } 11602 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11603 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11604 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11605 rchild.getOpcode() == OTHER_OPERAND_opcode && 11606 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11607 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 11608 ) { 11609 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11610 if(BURS.DEBUG) trace(p, 647, c + 0, p.getCost(2) /* r */); 11611 if (c < p.getCost(2) /* r */) { 11612 p.setCost(2 /* r */, (char)(c)); 11613 p.writePacked(0, 0xFFFE00FF, 0xFE00); // p.r = 254 11614 closure_r(p, c); 11615 } 11616 } 11617 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11618 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11619 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 11620 rchild.getOpcode() == OTHER_OPERAND_opcode && 11621 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11622 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 11623 ) { 11624 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_GT_OR_GE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getFalseValue(P(p)), Unary.getVal(PRRL(p))) ? 11 : INFINITE ); 11625 if(BURS.DEBUG) trace(p, 648, c + 0, p.getCost(2) /* r */); 11626 if (c < p.getCost(2) /* r */) { 11627 p.setCost(2 /* r */, (char)(c)); 11628 p.writePacked(0, 0xFFFE00FF, 0xFF00); // p.r = 255 11629 closure_r(p, c); 11630 } 11631 } 11632 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11633 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11634 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 11635 rchild.getOpcode() == OTHER_OPERAND_opcode && 11636 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11637 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 11638 ) { 11639 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11640 if(BURS.DEBUG) trace(p, 651, c + 0, p.getCost(2) /* r */); 11641 if (c < p.getCost(2) /* r */) { 11642 p.setCost(2 /* r */, (char)(c)); 11643 p.writePacked(0, 0xFFFE00FF, 0x10000); // p.r = 256 11644 closure_r(p, c); 11645 } 11646 } 11647 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11648 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 11649 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 11650 rchild.getOpcode() == OTHER_OPERAND_opcode && 11651 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 11652 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 11653 ) { 11654 c = STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2().getChild1()).getCost(2 /* r */) + (IS_MATERIALIZE_ZERO(PRL(p)) && SSE2_IS_LT_OR_LE(CondMove.getCond(P(p))) && SIMILAR_REGISTERS(CondMove.getVal2(P(p)), CondMove.getTrueValue(P(p)), Unary.getVal(PRRR(p))) ? 11 : INFINITE ); 11655 if(BURS.DEBUG) trace(p, 652, c + 0, p.getCost(2) /* r */); 11656 if (c < p.getCost(2) /* r */) { 11657 p.setCost(2 /* r */, (char)(c)); 11658 p.writePacked(0, 0xFFFE00FF, 0x10100); // p.r = 257 11659 closure_r(p, c); 11660 } 11661 } 11662 } 11663 11664 /** 11665 * Give leaf child corresponding to external rule and child number. 11666 * e.g. . 11667 * 11668 * @param p tree node to get child for 11669 * @param eruleno external rule number 11670 * @param kidnumber the child to return 11671 * @return the requested child 11672 */ 11673 private static AbstractBURS_TreeNode kids(AbstractBURS_TreeNode p, int eruleno, int kidnumber) { 11674 if (BURS.DEBUG) { 11675 switch (eruleno) { 11676 case 20: // load8_16_32_64: load8_16_32 11677 case 19: // load8_16_32_64: load64 11678 case 18: // load8_16_32: load8 11679 case 17: // load8_16_32: load16_32 11680 case 16: // load16_32: load32 11681 case 15: // load16_32: load16 11682 case 14: // load16: uload16 11683 case 13: // load16: sload16 11684 case 12: // load8: uload8 11685 case 11: // load8: sload8 11686 case 10: // address: address1scaledreg 11687 case 9: // address1scaledreg: address1reg 11688 case 8: // any: riv 11689 case 7: // rlv: r 11690 case 6: // riv: r 11691 case 5: // szp: szpr 11692 case 4: // r: szpr 11693 case 3: // cz: czr 11694 case 2: // r: czr 11695 case 1: // stm: r 11696 if (kidnumber == 0) { 11697 return p; 11698 } 11699 break; 11700 case 50: // stm: CLEAR_FLOATING_POINT_STATE 11701 case 49: // r: GET_TIME_BASE 11702 case 48: // stm: RETURN(LONG_CONSTANT) 11703 case 47: // stm: RETURN(INT_CONSTANT) 11704 case 46: // stm: RETURN(NULL) 11705 case 45: // stm: PAUSE 11706 case 44: // stm: FENCE 11707 case 43: // stm: READ_CEILING 11708 case 42: // stm: WRITE_FLOOR 11709 case 41: // stm: GOTO 11710 case 40: // stm: TRAP 11711 case 39: // stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 11712 case 38: // r: GET_CAUGHT_EXCEPTION 11713 case 37: // stm: IR_PROLOGUE 11714 case 36: // r: GUARD_COMBINE 11715 case 35: // r: GUARD_MOVE 11716 case 34: // stm: NOP 11717 case 33: // stm: RESOLVE 11718 case 32: // stm: YIELDPOINT_BACKEDGE 11719 case 31: // stm: YIELDPOINT_EPILOGUE 11720 case 30: // stm: YIELDPOINT_PROLOGUE 11721 case 29: // stm: UNINT_END 11722 case 28: // stm: UNINT_BEGIN 11723 case 27: // stm: IG_PATCH_POINT 11724 case 26: // any: LONG_CONSTANT 11725 case 25: // any: ADDRESS_CONSTANT 11726 case 24: // any: NULL 11727 case 23: // rlv: LONG_CONSTANT 11728 case 22: // riv: INT_CONSTANT 11729 case 21: // r: REGISTER 11730 break; 11731 case 246: // stm: DOUBLE_IFCMP(double_load,r) 11732 case 245: // stm: DOUBLE_IFCMP(r,double_load) 11733 case 244: // stm: DOUBLE_IFCMP(r,r) 11734 case 243: // stm: FLOAT_IFCMP(float_load,r) 11735 case 242: // stm: FLOAT_IFCMP(r,float_load) 11736 case 241: // stm: FLOAT_IFCMP(r,r) 11737 case 240: // float_load: FLOAT_ALOAD(riv,riv) 11738 case 239: // r: FLOAT_ALOAD(rlv,rlv) 11739 case 238: // r: FLOAT_ALOAD(riv,r) 11740 case 237: // r: FLOAT_ALOAD(riv,riv) 11741 case 236: // float_load: FLOAT_LOAD(riv,riv) 11742 case 235: // r: FLOAT_LOAD(rlv,rlv) 11743 case 234: // r: FLOAT_LOAD(riv,riv) 11744 case 233: // double_load: DOUBLE_ALOAD(riv,riv) 11745 case 232: // r: DOUBLE_ALOAD(rlv,rlv) 11746 case 231: // r: DOUBLE_ALOAD(riv,r) 11747 case 230: // double_load: DOUBLE_LOAD(rlv,rlv) 11748 case 229: // r: DOUBLE_ALOAD(riv,riv) 11749 case 228: // double_load: DOUBLE_LOAD(riv,riv) 11750 case 227: // r: DOUBLE_LOAD(rlv,rlv) 11751 case 226: // r: DOUBLE_LOAD(riv,rlv) 11752 case 225: // r: DOUBLE_LOAD(riv,riv) 11753 case 224: // r: DOUBLE_REM(r,r) 11754 case 223: // r: FLOAT_REM(r,r) 11755 case 222: // r: DOUBLE_DIV(r,double_load) 11756 case 221: // r: DOUBLE_DIV(r,r) 11757 case 220: // r: FLOAT_DIV(r,float_load) 11758 case 219: // r: FLOAT_DIV(r,r) 11759 case 218: // r: DOUBLE_MUL(double_load,r) 11760 case 217: // r: DOUBLE_MUL(r,double_load) 11761 case 216: // r: DOUBLE_MUL(r,r) 11762 case 215: // r: FLOAT_MUL(float_load,r) 11763 case 214: // r: FLOAT_MUL(r,float_load) 11764 case 213: // r: FLOAT_MUL(r,r) 11765 case 212: // r: DOUBLE_SUB(r,double_load) 11766 case 211: // r: DOUBLE_SUB(r,r) 11767 case 210: // r: FLOAT_SUB(r,float_load) 11768 case 209: // r: FLOAT_SUB(r,r) 11769 case 208: // r: DOUBLE_ADD(double_load,r) 11770 case 207: // r: DOUBLE_ADD(r,double_load) 11771 case 206: // r: DOUBLE_ADD(r,r) 11772 case 205: // r: FLOAT_ADD(float_load,r) 11773 case 204: // r: FLOAT_ADD(r,float_load) 11774 case 203: // r: FLOAT_ADD(r,r) 11775 case 202: // szpr: LONG_XOR(load64,rlv) 11776 case 201: // szpr: LONG_XOR(r,load64) 11777 case 200: // szpr: LONG_XOR(r,rlv) 11778 case 199: // szpr: LONG_USHR(rlv,riv) 11779 case 198: // czr: LONG_SUB(load64,rlv) 11780 case 197: // czr: LONG_SUB(rlv,load64) 11781 case 196: // r: LONG_SUB(load64,r) 11782 case 195: // r: LONG_SUB(rlv,r) 11783 case 194: // czr: LONG_SUB(rlv,r) 11784 case 193: // szpr: LONG_SHR(rlv,riv) 11785 case 192: // szpr: LONG_SHL(rlv,riv) 11786 case 191: // r: LONG_REM(load64,rlv) 11787 case 190: // r: LONG_REM(rlv,load64) 11788 case 189: // r: LONG_REM(riv,rlv) 11789 case 188: // r: LONG_REM(rlv,riv) 11790 case 187: // r: LONG_REM(rlv,rlv) 11791 case 186: // szpr: LONG_OR(load64,rlv) 11792 case 185: // szpr: LONG_OR(r,load64) 11793 case 184: // szpr: LONG_OR(r,rlv) 11794 case 183: // r: INT_MUL(load64,rlv) 11795 case 182: // r: INT_MUL(r,load64) 11796 case 181: // r: LONG_MUL(r,rlv) 11797 case 180: // r: LONG_ALOAD(rlv,r) 11798 case 179: // r: LONG_ALOAD(rlv,riv) 11799 case 178: // r: LONG_LOAD(address1reg,address1scaledreg) 11800 case 177: // r: LONG_LOAD(address1scaledreg,address1reg) 11801 case 176: // r: LONG_LOAD(address1scaledreg,rlv) 11802 case 175: // r: LONG_LOAD(rlv,address1scaledreg) 11803 case 174: // r: LONG_LOAD(rlv,rlv) 11804 case 173: // stm: LONG_IFCMP(rlv,rlv) 11805 case 172: // r: LONG_DIV(load64,rlv) 11806 case 171: // r: LONG_DIV(rlv,load64) 11807 case 170: // r: LONG_DIV(riv,rlv) 11808 case 169: // r: LONG_DIV(rlv,riv) 11809 case 168: // r: LONG_DIV(rlv,rlv) 11810 case 167: // szp: LONG_AND(r,load8_16_32_64) 11811 case 166: // szp: LONG_AND(load8_16_32_64,rlv) 11812 case 165: // szpr: LONG_AND(load64,rlv) 11813 case 164: // szpr: LONG_AND(rlv,load64) 11814 case 163: // szp: LONG_AND(r,rlv) 11815 case 162: // szpr: LONG_AND(r,r) 11816 case 161: // szpr: LONG_AND(r,rlv) 11817 case 160: // czr: LONG_ADD(load64,rlv) 11818 case 159: // czr: LONG_ADD(rlv,load64) 11819 case 158: // r: LONG_ADD(r,rlv) 11820 case 157: // czr: LONG_ADD(r,r) 11821 case 156: // czr: LONG_ADD(r,riv) 11822 case 155: // czr: LONG_ADD(r,rlv) 11823 case 154: // load64: LONG_ALOAD(rlv,r) 11824 case 153: // load64: LONG_ALOAD(rlv,rlv) 11825 case 152: // load64: LONG_LOAD(rlv,rlv) 11826 case 151: // load32: INT_ALOAD(rlv,riv) 11827 case 150: // load32: INT_LOAD(rlv,rlv) 11828 case 149: // uload16: USHORT_ALOAD(rlv,riv) 11829 case 148: // r: USHORT_ALOAD(rlv,r) 11830 case 147: // r: USHORT_ALOAD(rlv,riv) 11831 case 146: // uload16: USHORT_LOAD(rlv,rlv) 11832 case 145: // r: USHORT_LOAD(rlv,rlv) 11833 case 144: // sload16: SHORT_ALOAD(rlv,riv) 11834 case 143: // r: SHORT_ALOAD(rlv,r) 11835 case 142: // r: SHORT_ALOAD(rlv,riv) 11836 case 141: // sload16: SHORT_LOAD(rlv,rlv) 11837 case 140: // r: SHORT_LOAD(rlv,rlv) 11838 case 139: // uload8: UBYTE_ALOAD(rlv,riv) 11839 case 138: // r: UBYTE_ALOAD(rlv,r) 11840 case 137: // r: UBYTE_ALOAD(rlv,riv) 11841 case 136: // uload8: UBYTE_LOAD(rlv,rlv) 11842 case 135: // r: UBYTE_LOAD(rlv,rlv) 11843 case 134: // sload8: BYTE_ALOAD(rlv,riv) 11844 case 133: // r: BYTE_ALOAD(rlv,r) 11845 case 132: // r: BYTE_ALOAD(rlv,riv) 11846 case 131: // sload8: BYTE_LOAD(rlv,rlv) 11847 case 130: // r: BYTE_LOAD(rlv,rlv) 11848 case 129: // r: LONG_ADD(address1reg,address1scaledreg) 11849 case 128: // r: LONG_ADD(address1scaledreg,address1reg) 11850 case 127: // r: LONG_ADD(r,address1scaledreg) 11851 case 126: // r: LONG_ADD(address1scaledreg,r) 11852 case 125: // szpr: INT_XOR(load32,riv) 11853 case 124: // szpr: INT_XOR(r,load32) 11854 case 123: // szpr: INT_XOR(r,riv) 11855 case 122: // szpr: INT_USHR(riv,riv) 11856 case 121: // czr: INT_SUB(load32,riv) 11857 case 120: // czr: INT_SUB(riv,load32) 11858 case 119: // r: INT_SUB(load32,r) 11859 case 118: // r: INT_SUB(riv,r) 11860 case 117: // czr: INT_SUB(riv,r) 11861 case 116: // szpr: INT_SHR(riv,riv) 11862 case 115: // szpr: INT_SHL(riv,riv) 11863 case 114: // r: INT_REM(riv,load32) 11864 case 113: // r: INT_REM(riv,riv) 11865 case 112: // szpr: INT_OR(load32,riv) 11866 case 111: // szpr: INT_OR(r,load32) 11867 case 110: // szpr: INT_OR(r,riv) 11868 case 109: // r: INT_MUL(load32,riv) 11869 case 108: // r: INT_MUL(r,load32) 11870 case 107: // r: INT_MUL(r,riv) 11871 case 106: // r: INT_ALOAD(rlv,riv) 11872 case 105: // r: INT_LOAD(address1reg,address1scaledreg) 11873 case 104: // r: INT_LOAD(address1scaledreg,address1reg) 11874 case 103: // r: INT_LOAD(address1scaledreg,rlv) 11875 case 102: // r: INT_LOAD(rlv,address1scaledreg) 11876 case 101: // r: INT_LOAD(rlv,rlv) 11877 case 100: // stm: INT_IFCMP2(riv,load32) 11878 case 99: // stm: INT_IFCMP2(load32,riv) 11879 case 98: // stm: INT_IFCMP2(r,riv) 11880 case 97: // stm: INT_IFCMP(r,load32) 11881 case 96: // stm: INT_IFCMP(load32,riv) 11882 case 95: // stm: INT_IFCMP(r,uload8) 11883 case 94: // stm: INT_IFCMP(uload8,r) 11884 case 93: // stm: INT_IFCMP(r,riv) 11885 case 92: // r: INT_DIV(riv,load32) 11886 case 91: // r: INT_DIV(riv,riv) 11887 case 90: // szp: INT_AND(r,load8_16_32) 11888 case 89: // szp: INT_AND(load8_16_32,riv) 11889 case 88: // szpr: INT_AND(load32,riv) 11890 case 87: // szpr: INT_AND(r,load32) 11891 case 86: // szp: INT_AND(r,riv) 11892 case 85: // szpr: INT_AND(r,riv) 11893 case 84: // czr: INT_ADD(load32,riv) 11894 case 83: // czr: INT_ADD(r,load32) 11895 case 82: // r: INT_ADD(r,riv) 11896 case 81: // czr: INT_ADD(r,riv) 11897 case 80: // boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 11898 case 79: // r: BOOLEAN_CMP_LONG(r,load64) 11899 case 78: // boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 11900 case 77: // r: BOOLEAN_CMP_LONG(load64,rlv) 11901 case 76: // boolcmp: BOOLEAN_CMP_LONG(r,rlv) 11902 case 75: // r: BOOLEAN_CMP_LONG(r,rlv) 11903 case 74: // boolcmp: BOOLEAN_CMP_INT(riv,load32) 11904 case 73: // r: BOOLEAN_CMP_INT(r,load32) 11905 case 72: // boolcmp: BOOLEAN_CMP_INT(load32,riv) 11906 case 71: // r: BOOLEAN_CMP_INT(load32,riv) 11907 case 70: // boolcmp: BOOLEAN_CMP_INT(r,riv) 11908 case 69: // r: BOOLEAN_CMP_INT(r,riv) 11909 case 68: // address: LONG_ADD(address1reg,address1scaledreg) 11910 case 67: // address: LONG_ADD(address1scaledreg,address1reg) 11911 case 66: // address: LONG_ADD(address1scaledreg,r) 11912 case 65: // address: LONG_ADD(r,address1scaledreg) 11913 case 64: // address: LONG_ADD(r,r) 11914 case 63: // address: INT_ADD(address1reg,address1scaledreg) 11915 case 62: // address: INT_ADD(address1scaledreg,address1reg) 11916 case 61: // address: INT_ADD(address1scaledreg,r) 11917 case 60: // address: INT_ADD(r,address1scaledreg) 11918 case 59: // address: INT_ADD(r,r) 11919 case 58: // stm: YIELDPOINT_OSR(any,any) 11920 case 57: // r: SYSCALL(r,any) 11921 case 56: // r: CALL(r,any) 11922 case 55: // r: LONG_CMP(rlv,rlv) 11923 case 54: // stm: TRAP_IF(riv,load32) 11924 case 53: // stm: TRAP_IF(load32,riv) 11925 case 52: // stm: TRAP_IF(r,r) 11926 case 51: // any: OTHER_OPERAND(any,any) 11927 if (kidnumber == 0) { 11928 return p.getChild1(); 11929 } 11930 if (kidnumber == 1) { 11931 return p.getChild2(); 11932 } 11933 break; 11934 case 382: // double_load: MATERIALIZE_FP_CONSTANT(any) 11935 case 381: // float_load: MATERIALIZE_FP_CONSTANT(any) 11936 case 380: // r: MATERIALIZE_FP_CONSTANT(any) 11937 case 379: // double_load: LONG_BITS_AS_DOUBLE(load64) 11938 case 378: // r: LONG_BITS_AS_DOUBLE(rlv) 11939 case 377: // float_load: INT_BITS_AS_FLOAT(load32) 11940 case 376: // r: INT_BITS_AS_FLOAT(riv) 11941 case 375: // load64: DOUBLE_AS_LONG_BITS(double_load) 11942 case 374: // r: DOUBLE_AS_LONG_BITS(r) 11943 case 373: // load32: FLOAT_AS_INT_BITS(float_load) 11944 case 372: // r: FLOAT_AS_INT_BITS(r) 11945 case 371: // r: DOUBLE_2LONG(r) 11946 case 370: // r: DOUBLE_2INT(r) 11947 case 369: // r: FLOAT_2LONG(r) 11948 case 368: // r: FLOAT_2INT(r) 11949 case 367: // r: DOUBLE_2FLOAT(double_load) 11950 case 366: // r: DOUBLE_2FLOAT(r) 11951 case 365: // r: FLOAT_2DOUBLE(float_load) 11952 case 364: // r: FLOAT_2DOUBLE(r) 11953 case 363: // r: INT_2DOUBLE(load32) 11954 case 362: // r: INT_2DOUBLE(riv) 11955 case 361: // r: INT_2FLOAT(load32) 11956 case 360: // r: INT_2FLOAT(riv) 11957 case 359: // r: DOUBLE_MOVE(r) 11958 case 358: // r: FLOAT_MOVE(r) 11959 case 357: // r: LONG_2DOUBLE(r) 11960 case 356: // r: LONG_2FLOAT(r) 11961 case 355: // r: DOUBLE_SQRT(r) 11962 case 354: // r: FLOAT_SQRT(r) 11963 case 353: // r: DOUBLE_NEG(r) 11964 case 352: // r: FLOAT_NEG(r) 11965 case 351: // szpr: LONG_USHR(rlv,LONG_CONSTANT) 11966 case 350: // szpr: LONG_SHR(rlv,LONG_CONSTANT) 11967 case 349: // r: LONG_SHL(r,INT_CONSTANT) 11968 case 348: // szpr: LONG_SHL(r,INT_CONSTANT) 11969 case 347: // r: LONG_NOT(r) 11970 case 346: // szpr: LONG_NEG(r) 11971 case 345: // load64: LONG_MOVE(load64) 11972 case 344: // r: LONG_MOVE(riv) 11973 case 343: // r: LONG_MOVE(rlv) 11974 case 342: // r: LONG_LOAD(address,LONG_CONSTANT) 11975 case 341: // stm: LONG_IFCMP(r,LONG_CONSTANT) 11976 case 340: // load32: LONG_2INT(load64) 11977 case 339: // r: LONG_2INT(load64) 11978 case 338: // r: LONG_2INT(r) 11979 case 337: // r: LONG_MOVE(address) 11980 case 336: // r: LONG_ADD(address,LONG_CONSTANT) 11981 case 335: // szpr: INT_USHR(riv,INT_CONSTANT) 11982 case 334: // szpr: INT_SHR(riv,INT_CONSTANT) 11983 case 333: // r: INT_SHL(r,INT_CONSTANT) 11984 case 332: // szpr: INT_SHL(r,INT_CONSTANT) 11985 case 331: // r: INT_NOT(r) 11986 case 330: // szpr: INT_NEG(r) 11987 case 329: // load32: INT_MOVE(load32) 11988 case 328: // load16: INT_MOVE(load16) 11989 case 327: // uload16: INT_MOVE(uload16) 11990 case 326: // sload16: INT_MOVE(sload16) 11991 case 325: // load8: INT_MOVE(load8) 11992 case 324: // uload8: INT_MOVE(uload8) 11993 case 323: // sload8: INT_MOVE(sload8) 11994 case 322: // szp: INT_MOVE(szp) 11995 case 321: // szpr: INT_MOVE(szpr) 11996 case 320: // cz: INT_MOVE(cz) 11997 case 319: // czr: INT_MOVE(czr) 11998 case 318: // r: INT_MOVE(riv) 11999 case 317: // r: INT_LOAD(address,LONG_CONSTANT) 12000 case 316: // stm: INT_IFCMP(bittest,INT_CONSTANT) 12001 case 315: // stm: INT_IFCMP(szp,INT_CONSTANT) 12002 case 314: // stm: INT_IFCMP(cz,INT_CONSTANT) 12003 case 313: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 12004 case 312: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 12005 case 311: // stm: INT_IFCMP(sload16,INT_CONSTANT) 12006 case 310: // stm: INT_IFCMP(load8,INT_CONSTANT) 12007 case 309: // stm: INT_IFCMP(r,INT_CONSTANT) 12008 case 308: // r: INT_2USHORT(load16_32) 12009 case 307: // uload16: INT_2USHORT(load16_32) 12010 case 306: // szpr: INT_2USHORT(r) 12011 case 305: // sload16: INT_2SHORT(load16_32) 12012 case 304: // r: INT_2SHORT(load16_32) 12013 case 303: // r: INT_2SHORT(r) 12014 case 302: // r: INT_2ADDRZerExt(r) 12015 case 301: // r: INT_2LONG(load32) 12016 case 300: // r: INT_2LONG(r) 12017 case 299: // r: INT_2BYTE(load8_16_32) 12018 case 298: // r: INT_2BYTE(r) 12019 case 297: // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12020 case 296: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12021 case 295: // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12022 case 294: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12023 case 293: // r: BOOLEAN_NOT(r) 12024 case 292: // r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) 12025 case 291: // r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 12026 case 290: // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12027 case 289: // r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 12028 case 288: // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12029 case 287: // boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12030 case 286: // r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12031 case 285: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12032 case 284: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12033 case 283: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12034 case 282: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12035 case 281: // boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 12036 case 280: // r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 12037 case 279: // boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 12038 case 278: // r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 12039 case 277: // boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 12040 case 276: // r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 12041 case 275: // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 12042 case 274: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12043 case 273: // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 12044 case 272: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12045 case 271: // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12046 case 270: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12047 case 269: // address: LONG_ADD(address1scaledreg,LONG_CONSTANT) 12048 case 268: // address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) 12049 case 267: // address1reg: LONG_ADD(address1reg,LONG_CONSTANT) 12050 case 266: // address1reg: LONG_MOVE(r) 12051 case 265: // address1reg: LONG_ADD(r,LONG_CONSTANT) 12052 case 264: // address1scaledreg: LONG_SHL(r,INT_CONSTANT) 12053 case 263: // address: INT_ADD(address1scaledreg,LONG_CONSTANT) 12054 case 262: // address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) 12055 case 261: // address1reg: INT_ADD(address1reg,LONG_CONSTANT) 12056 case 260: // address1reg: INT_MOVE(r) 12057 case 259: // address1reg: INT_ADD(r,LONG_CONSTANT) 12058 case 258: // address1scaledreg: INT_SHL(r,INT_CONSTANT) 12059 case 257: // stm: RETURN(r) 12060 case 256: // stm: PREFETCH(r) 12061 case 255: // r: INT_AND(load16_32,INT_CONSTANT) 12062 case 254: // r: INT_2BYTE(load8_16_32) 12063 case 253: // r: INT_AND(load8_16_32,INT_CONSTANT) 12064 case 252: // uload8: INT_AND(load8_16_32,INT_CONSTANT) 12065 case 251: // stm: TRAP_IF(r,LONG_CONSTANT) 12066 case 250: // stm: TRAP_IF(r,INT_CONSTANT) 12067 case 249: // stm: SET_CAUGHT_EXCEPTION(r) 12068 case 248: // stm: NULL_CHECK(riv) 12069 case 247: // stm: LOWTABLESWITCH(r) 12070 if (kidnumber == 0) { 12071 return p.getChild1(); 12072 } 12073 break; 12074 case 396: // szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) 12075 case 395: // load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 12076 case 394: // load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 12077 case 393: // r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 12078 case 392: // r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 12079 case 391: // r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 12080 case 390: // r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 12081 case 389: // szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 12082 case 388: // r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 12083 case 387: // r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 12084 case 386: // bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 12085 case 385: // bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 12086 case 384: // r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 12087 case 383: // r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 12088 if (kidnumber == 0) { 12089 return p.getChild1().getChild1(); 12090 } 12091 break; 12092 case 465: // stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 12093 case 464: // stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 12094 case 463: // stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 12095 case 462: // stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 12096 case 461: // r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 12097 case 460: // r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 12098 case 459: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 12099 case 458: // r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 12100 case 457: // r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 12101 case 456: // r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 12102 case 455: // r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 12103 case 454: // r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 12104 case 453: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 12105 case 452: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 12106 case 451: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 12107 case 450: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 12108 case 449: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 12109 case 448: // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 12110 case 447: // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 12111 case 446: // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 12112 case 445: // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 12113 case 444: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 12114 case 443: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 12115 case 442: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 12116 case 441: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 12117 case 440: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 12118 case 439: // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 12119 case 438: // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 12120 case 437: // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 12121 case 436: // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 12122 case 435: // stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) 12123 case 434: // stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) 12124 case 433: // stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) 12125 case 432: // stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) 12126 case 431: // stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 12127 case 430: // r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) 12128 case 429: // r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) 12129 case 428: // r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 12130 case 427: // stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 12131 case 426: // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 12132 case 425: // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) 12133 case 424: // stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) 12134 case 423: // stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 12135 case 422: // r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 12136 case 421: // r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 12137 case 420: // r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 12138 case 419: // r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 12139 case 418: // r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 12140 case 417: // stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) 12141 case 416: // stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 12142 case 415: // stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) 12143 case 414: // stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) 12144 case 413: // stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 12145 case 412: // stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 12146 case 411: // stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 12147 case 410: // stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 12148 case 409: // stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 12149 case 408: // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 12150 case 407: // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 12151 case 406: // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 12152 case 405: // stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 12153 case 404: // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 12154 case 403: // stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 12155 case 402: // stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 12156 case 401: // stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 12157 case 400: // stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 12158 case 399: // stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 12159 case 398: // stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 12160 case 397: // stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 12161 if (kidnumber == 0) { 12162 return p.getChild1(); 12163 } 12164 if (kidnumber == 1) { 12165 return p.getChild2().getChild1(); 12166 } 12167 if (kidnumber == 2) { 12168 return p.getChild2().getChild2(); 12169 } 12170 break; 12171 case 467: // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 12172 case 466: // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 12173 if (kidnumber == 0) { 12174 return p.getChild2().getChild1(); 12175 } 12176 if (kidnumber == 1) { 12177 return p.getChild2().getChild2(); 12178 } 12179 break; 12180 case 470: // r: SYSCALL(INT_CONSTANT,any) 12181 case 469: // r: CALL(INT_CONSTANT,any) 12182 case 468: // r: CALL(BRANCH_TARGET,any) 12183 if (kidnumber == 0) { 12184 return p.getChild2(); 12185 } 12186 break; 12187 case 473: // r: SYSCALL(INT_LOAD(riv,riv),any) 12188 case 472: // r: CALL(LONG_LOAD(rlv,rlv),any) 12189 case 471: // r: CALL(INT_LOAD(riv,riv),any) 12190 if (kidnumber == 0) { 12191 return p.getChild1().getChild1(); 12192 } 12193 if (kidnumber == 1) { 12194 return p.getChild1().getChild2(); 12195 } 12196 if (kidnumber == 2) { 12197 return p.getChild2(); 12198 } 12199 break; 12200 case 489: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 12201 case 488: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 12202 case 487: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 12203 case 486: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 12204 case 485: // r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 12205 case 484: // r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) 12206 case 483: // r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) 12207 case 482: // r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 12208 case 481: // r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) 12209 case 480: // r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 12210 case 479: // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 12211 case 478: // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 12212 case 477: // r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 12213 case 476: // r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 12214 case 475: // r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 12215 case 474: // r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 12216 if (kidnumber == 0) { 12217 return p.getChild1(); 12218 } 12219 if (kidnumber == 1) { 12220 return p.getChild2().getChild1(); 12221 } 12222 if (kidnumber == 2) { 12223 return p.getChild2().getChild2().getChild1(); 12224 } 12225 if (kidnumber == 3) { 12226 return p.getChild2().getChild2().getChild2(); 12227 } 12228 break; 12229 case 491: // r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) 12230 case 490: // r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 12231 if (kidnumber == 0) { 12232 return p.getChild1(); 12233 } 12234 if (kidnumber == 1) { 12235 return p.getChild2().getChild2().getChild1(); 12236 } 12237 if (kidnumber == 2) { 12238 return p.getChild2().getChild2().getChild2(); 12239 } 12240 break; 12241 case 493: // r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) 12242 case 492: // r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 12243 if (kidnumber == 0) { 12244 return p.getChild2().getChild1(); 12245 } 12246 if (kidnumber == 1) { 12247 return p.getChild2().getChild2().getChild1(); 12248 } 12249 if (kidnumber == 2) { 12250 return p.getChild2().getChild2().getChild2(); 12251 } 12252 break; 12253 case 513: // stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12254 case 512: // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12255 case 511: // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12256 case 510: // stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12257 case 509: // stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12258 case 508: // stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12259 case 507: // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12260 case 506: // stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12261 case 505: // stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12262 case 504: // stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12263 case 503: // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12264 case 502: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12265 case 501: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12266 case 500: // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12267 case 499: // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12268 case 498: // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12269 case 497: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12270 case 496: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12271 case 495: // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12272 case 494: // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12273 if (kidnumber == 0) { 12274 return p.getChild1().getChild1(); 12275 } 12276 if (kidnumber == 1) { 12277 return p.getChild1().getChild2().getChild1(); 12278 } 12279 if (kidnumber == 2) { 12280 return p.getChild1().getChild2().getChild2().getChild1(); 12281 } 12282 if (kidnumber == 3) { 12283 return p.getChild1().getChild2().getChild2().getChild2(); 12284 } 12285 break; 12286 case 517: // stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12287 case 516: // stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12288 case 515: // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12289 case 514: // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12290 if (kidnumber == 0) { 12291 return p.getChild1().getChild1(); 12292 } 12293 if (kidnumber == 1) { 12294 return p.getChild1().getChild2().getChild2().getChild1(); 12295 } 12296 if (kidnumber == 2) { 12297 return p.getChild1().getChild2().getChild2().getChild2(); 12298 } 12299 break; 12300 case 521: // stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12301 case 520: // stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 12302 case 519: // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12303 case 518: // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12304 if (kidnumber == 0) { 12305 return p.getChild1().getChild2().getChild1(); 12306 } 12307 if (kidnumber == 1) { 12308 return p.getChild1().getChild2().getChild2().getChild1(); 12309 } 12310 if (kidnumber == 2) { 12311 return p.getChild1().getChild2().getChild2().getChild2(); 12312 } 12313 break; 12314 case 525: // bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12315 case 524: // bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12316 case 523: // bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12317 case 522: // bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12318 if (kidnumber == 0) { 12319 return p.getChild1().getChild1(); 12320 } 12321 if (kidnumber == 1) { 12322 return p.getChild1().getChild2().getChild1(); 12323 } 12324 break; 12325 case 527: // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 12326 case 526: // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 12327 if (kidnumber == 0) { 12328 return p.getChild1().getChild2().getChild1(); 12329 } 12330 if (kidnumber == 1) { 12331 return p.getChild2(); 12332 } 12333 break; 12334 case 529: // bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 12335 case 528: // bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 12336 if (kidnumber == 0) { 12337 return p.getChild1(); 12338 } 12339 if (kidnumber == 1) { 12340 return p.getChild2().getChild2().getChild1(); 12341 } 12342 break; 12343 case 551: // stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 12344 case 550: // stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 12345 case 549: // stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 12346 case 548: // stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 12347 case 547: // stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12348 case 546: // stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12349 case 545: // stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12350 case 544: // stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12351 case 543: // stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12352 case 542: // stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12353 case 541: // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12354 case 540: // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12355 case 539: // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12356 case 538: // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12357 case 537: // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12358 case 536: // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 12359 case 535: // stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12360 case 534: // stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12361 case 533: // stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12362 case 532: // stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12363 case 531: // stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) 12364 case 530: // stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12365 if (kidnumber == 0) { 12366 return p.getChild1().getChild1().getChild1(); 12367 } 12368 if (kidnumber == 1) { 12369 return p.getChild1().getChild1().getChild2(); 12370 } 12371 if (kidnumber == 2) { 12372 return p.getChild2().getChild1(); 12373 } 12374 if (kidnumber == 3) { 12375 return p.getChild2().getChild2(); 12376 } 12377 break; 12378 case 560: // r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 12379 case 559: // r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 12380 case 558: // r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 12381 case 557: // r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 12382 case 556: // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 12383 case 555: // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 12384 case 554: // r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 12385 case 553: // r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 12386 case 552: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 12387 if (kidnumber == 0) { 12388 return p.getChild1(); 12389 } 12390 if (kidnumber == 1) { 12391 return p.getChild2().getChild2(); 12392 } 12393 break; 12394 case 568: // stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 12395 case 567: // stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 12396 case 566: // stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 12397 case 565: // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 12398 case 564: // stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 12399 case 563: // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 12400 case 562: // stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 12401 case 561: // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 12402 if (kidnumber == 0) { 12403 return p.getChild1().getChild1(); 12404 } 12405 if (kidnumber == 1) { 12406 return p.getChild2().getChild1(); 12407 } 12408 if (kidnumber == 2) { 12409 return p.getChild2().getChild2(); 12410 } 12411 break; 12412 case 588: // stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12413 case 587: // stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12414 case 586: // stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12415 case 585: // stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12416 case 584: // stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12417 case 583: // stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12418 case 582: // stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12419 case 581: // stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12420 case 580: // stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12421 case 579: // stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 12422 case 578: // stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12423 case 577: // stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12424 case 576: // stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12425 case 575: // stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12426 case 574: // stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12427 case 573: // stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12428 case 572: // stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12429 case 571: // stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12430 case 570: // stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12431 case 569: // stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 12432 if (kidnumber == 0) { 12433 return p.getChild1().getChild1().getChild1(); 12434 } 12435 if (kidnumber == 1) { 12436 return p.getChild1().getChild1().getChild2(); 12437 } 12438 if (kidnumber == 2) { 12439 return p.getChild1().getChild2(); 12440 } 12441 if (kidnumber == 3) { 12442 return p.getChild2().getChild1(); 12443 } 12444 if (kidnumber == 4) { 12445 return p.getChild2().getChild2(); 12446 } 12447 break; 12448 case 608: // stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12449 case 607: // stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12450 case 606: // stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12451 case 605: // stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12452 case 604: // stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12453 case 603: // stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12454 case 602: // stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12455 case 601: // stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12456 case 600: // stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12457 case 599: // stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 12458 case 598: // stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12459 case 597: // stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12460 case 596: // stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12461 case 595: // stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12462 case 594: // stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12463 case 593: // stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12464 case 592: // stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12465 case 591: // stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12466 case 590: // stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12467 case 589: // stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 12468 if (kidnumber == 0) { 12469 return p.getChild1().getChild1(); 12470 } 12471 if (kidnumber == 1) { 12472 return p.getChild1().getChild2().getChild1(); 12473 } 12474 if (kidnumber == 2) { 12475 return p.getChild1().getChild2().getChild2(); 12476 } 12477 if (kidnumber == 3) { 12478 return p.getChild2().getChild1(); 12479 } 12480 if (kidnumber == 4) { 12481 return p.getChild2().getChild2(); 12482 } 12483 break; 12484 case 612: // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 12485 case 611: // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 12486 case 610: // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 12487 case 609: // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 12488 if (kidnumber == 0) { 12489 return p.getChild1().getChild1(); 12490 } 12491 if (kidnumber == 1) { 12492 return p.getChild2().getChild1(); 12493 } 12494 break; 12495 case 614: // r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 12496 case 613: // r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 12497 if (kidnumber == 0) { 12498 return p.getChild1().getChild1(); 12499 } 12500 if (kidnumber == 1) { 12501 return p.getChild1().getChild2().getChild1(); 12502 } 12503 if (kidnumber == 2) { 12504 return p.getChild2().getChild1(); 12505 } 12506 if (kidnumber == 3) { 12507 return p.getChild2().getChild2().getChild1().getChild1(); 12508 } 12509 break; 12510 case 616: // r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 12511 case 615: // r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 12512 if (kidnumber == 0) { 12513 return p.getChild1().getChild1(); 12514 } 12515 if (kidnumber == 1) { 12516 return p.getChild1().getChild2().getChild1().getChild1(); 12517 } 12518 if (kidnumber == 2) { 12519 return p.getChild2().getChild1(); 12520 } 12521 if (kidnumber == 3) { 12522 return p.getChild2().getChild2().getChild1(); 12523 } 12524 break; 12525 case 624: // szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) 12526 case 623: // stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) 12527 case 622: // szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) 12528 case 621: // szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) 12529 case 620: // szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 12530 case 619: // stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) 12531 case 618: // szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 12532 case 617: // szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 12533 if (kidnumber == 0) { 12534 return p.getChild1(); 12535 } 12536 if (kidnumber == 1) { 12537 return p.getChild2().getChild1(); 12538 } 12539 break; 12540 case 636: // stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 12541 case 635: // stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 12542 case 634: // stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 12543 case 633: // stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 12544 case 632: // stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12545 case 631: // stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12546 case 630: // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12547 case 629: // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12548 case 628: // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12549 case 627: // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12550 case 626: // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12551 case 625: // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 12552 if (kidnumber == 0) { 12553 return p.getChild1().getChild1().getChild1(); 12554 } 12555 if (kidnumber == 1) { 12556 return p.getChild1().getChild1().getChild2(); 12557 } 12558 if (kidnumber == 2) { 12559 return p.getChild1().getChild2().getChild1(); 12560 } 12561 if (kidnumber == 3) { 12562 return p.getChild2().getChild1(); 12563 } 12564 if (kidnumber == 4) { 12565 return p.getChild2().getChild2(); 12566 } 12567 break; 12568 case 640: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 12569 case 639: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 12570 case 638: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 12571 case 637: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 12572 if (kidnumber == 0) { 12573 return p.getChild1(); 12574 } 12575 if (kidnumber == 1) { 12576 return p.getChild2().getChild2().getChild1(); 12577 } 12578 if (kidnumber == 2) { 12579 return p.getChild2().getChild2().getChild2().getChild1(); 12580 } 12581 break; 12582 case 644: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 12583 case 643: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 12584 case 642: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 12585 case 641: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 12586 if (kidnumber == 0) { 12587 return p.getChild1(); 12588 } 12589 if (kidnumber == 1) { 12590 return p.getChild2().getChild2().getChild1().getChild1(); 12591 } 12592 if (kidnumber == 2) { 12593 return p.getChild2().getChild2().getChild2(); 12594 } 12595 break; 12596 case 648: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 12597 case 647: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 12598 case 646: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 12599 case 645: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 12600 if (kidnumber == 0) { 12601 return p.getChild2().getChild1(); 12602 } 12603 if (kidnumber == 1) { 12604 return p.getChild2().getChild2().getChild1().getChild1(); 12605 } 12606 if (kidnumber == 2) { 12607 return p.getChild2().getChild2().getChild2(); 12608 } 12609 break; 12610 case 652: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 12611 case 651: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 12612 case 650: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 12613 case 649: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 12614 if (kidnumber == 0) { 12615 return p.getChild2().getChild1(); 12616 } 12617 if (kidnumber == 1) { 12618 return p.getChild2().getChild2().getChild1(); 12619 } 12620 if (kidnumber == 2) { 12621 return p.getChild2().getChild2().getChild2().getChild1(); 12622 } 12623 break; 12624 } 12625 throw new OptimizingCompilerException("BURS","Bad rule number ", 12626 Integer.toString(eruleno)); 12627 } else { 12628 return null; 12629 } 12630 } 12631 12632 /** 12633 * @param p node whose kids will be marked 12634 * @param eruleno rule number 12635 */ 12636 private static void mark_kids(AbstractBURS_TreeNode p, int eruleno) 12637 { 12638 byte[] ntsrule = nts[eruleno]; 12639 // 20: load8_16_32_64: load8_16_32 12640 // 19: load8_16_32_64: load64 12641 // 18: load8_16_32: load8 12642 // 17: load8_16_32: load16_32 12643 // 16: load16_32: load32 12644 // 15: load16_32: load16 12645 // 14: load16: uload16 12646 // 13: load16: sload16 12647 // 12: load8: uload8 12648 // 11: load8: sload8 12649 // 10: address: address1scaledreg 12650 // 9: address1scaledreg: address1reg 12651 // 8: any: riv 12652 // 7: rlv: r 12653 // 6: riv: r 12654 // 5: szp: szpr 12655 // 4: r: szpr 12656 // 3: cz: czr 12657 // 2: r: czr 12658 // 1: stm: r 12659 if (eruleno <= 20) { 12660 if (VM.VerifyAssertions) VM._assert(eruleno > 0); 12661 mark(p, ntsrule[0]); 12662 } 12663 // 50: stm: CLEAR_FLOATING_POINT_STATE 12664 // 49: r: GET_TIME_BASE 12665 // 48: stm: RETURN(LONG_CONSTANT) 12666 // 47: stm: RETURN(INT_CONSTANT) 12667 // 46: stm: RETURN(NULL) 12668 // 45: stm: PAUSE 12669 // 44: stm: FENCE 12670 // 43: stm: READ_CEILING 12671 // 42: stm: WRITE_FLOOR 12672 // 41: stm: GOTO 12673 // 40: stm: TRAP 12674 // 39: stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 12675 // 38: r: GET_CAUGHT_EXCEPTION 12676 // 37: stm: IR_PROLOGUE 12677 // 36: r: GUARD_COMBINE 12678 // 35: r: GUARD_MOVE 12679 // 34: stm: NOP 12680 // 33: stm: RESOLVE 12681 // 32: stm: YIELDPOINT_BACKEDGE 12682 // 31: stm: YIELDPOINT_EPILOGUE 12683 // 30: stm: YIELDPOINT_PROLOGUE 12684 // 29: stm: UNINT_END 12685 // 28: stm: UNINT_BEGIN 12686 // 27: stm: IG_PATCH_POINT 12687 // 26: any: LONG_CONSTANT 12688 // 25: any: ADDRESS_CONSTANT 12689 // 24: any: NULL 12690 // 23: rlv: LONG_CONSTANT 12691 // 22: riv: INT_CONSTANT 12692 // 21: r: REGISTER 12693 else if (eruleno <= 50) { 12694 } 12695 // 246: stm: DOUBLE_IFCMP(double_load,r) 12696 // 245: stm: DOUBLE_IFCMP(r,double_load) 12697 // 244: stm: DOUBLE_IFCMP(r,r) 12698 // 243: stm: FLOAT_IFCMP(float_load,r) 12699 // 242: stm: FLOAT_IFCMP(r,float_load) 12700 // 241: stm: FLOAT_IFCMP(r,r) 12701 // 240: float_load: FLOAT_ALOAD(riv,riv) 12702 // 239: r: FLOAT_ALOAD(rlv,rlv) 12703 // 238: r: FLOAT_ALOAD(riv,r) 12704 // 237: r: FLOAT_ALOAD(riv,riv) 12705 // 236: float_load: FLOAT_LOAD(riv,riv) 12706 // 235: r: FLOAT_LOAD(rlv,rlv) 12707 // 234: r: FLOAT_LOAD(riv,riv) 12708 // 233: double_load: DOUBLE_ALOAD(riv,riv) 12709 // 232: r: DOUBLE_ALOAD(rlv,rlv) 12710 // 231: r: DOUBLE_ALOAD(riv,r) 12711 // 230: double_load: DOUBLE_LOAD(rlv,rlv) 12712 // 229: r: DOUBLE_ALOAD(riv,riv) 12713 // 228: double_load: DOUBLE_LOAD(riv,riv) 12714 // 227: r: DOUBLE_LOAD(rlv,rlv) 12715 // 226: r: DOUBLE_LOAD(riv,rlv) 12716 // 225: r: DOUBLE_LOAD(riv,riv) 12717 // 224: r: DOUBLE_REM(r,r) 12718 // 223: r: FLOAT_REM(r,r) 12719 // 222: r: DOUBLE_DIV(r,double_load) 12720 // 221: r: DOUBLE_DIV(r,r) 12721 // 220: r: FLOAT_DIV(r,float_load) 12722 // 219: r: FLOAT_DIV(r,r) 12723 // 218: r: DOUBLE_MUL(double_load,r) 12724 // 217: r: DOUBLE_MUL(r,double_load) 12725 // 216: r: DOUBLE_MUL(r,r) 12726 // 215: r: FLOAT_MUL(float_load,r) 12727 // 214: r: FLOAT_MUL(r,float_load) 12728 // 213: r: FLOAT_MUL(r,r) 12729 // 212: r: DOUBLE_SUB(r,double_load) 12730 // 211: r: DOUBLE_SUB(r,r) 12731 // 210: r: FLOAT_SUB(r,float_load) 12732 // 209: r: FLOAT_SUB(r,r) 12733 // 208: r: DOUBLE_ADD(double_load,r) 12734 // 207: r: DOUBLE_ADD(r,double_load) 12735 // 206: r: DOUBLE_ADD(r,r) 12736 // 205: r: FLOAT_ADD(float_load,r) 12737 // 204: r: FLOAT_ADD(r,float_load) 12738 // 203: r: FLOAT_ADD(r,r) 12739 // 202: szpr: LONG_XOR(load64,rlv) 12740 // 201: szpr: LONG_XOR(r,load64) 12741 // 200: szpr: LONG_XOR(r,rlv) 12742 // 199: szpr: LONG_USHR(rlv,riv) 12743 // 198: czr: LONG_SUB(load64,rlv) 12744 // 197: czr: LONG_SUB(rlv,load64) 12745 // 196: r: LONG_SUB(load64,r) 12746 // 195: r: LONG_SUB(rlv,r) 12747 // 194: czr: LONG_SUB(rlv,r) 12748 // 193: szpr: LONG_SHR(rlv,riv) 12749 // 192: szpr: LONG_SHL(rlv,riv) 12750 // 191: r: LONG_REM(load64,rlv) 12751 // 190: r: LONG_REM(rlv,load64) 12752 // 189: r: LONG_REM(riv,rlv) 12753 // 188: r: LONG_REM(rlv,riv) 12754 // 187: r: LONG_REM(rlv,rlv) 12755 // 186: szpr: LONG_OR(load64,rlv) 12756 // 185: szpr: LONG_OR(r,load64) 12757 // 184: szpr: LONG_OR(r,rlv) 12758 // 183: r: INT_MUL(load64,rlv) 12759 // 182: r: INT_MUL(r,load64) 12760 // 181: r: LONG_MUL(r,rlv) 12761 // 180: r: LONG_ALOAD(rlv,r) 12762 // 179: r: LONG_ALOAD(rlv,riv) 12763 // 178: r: LONG_LOAD(address1reg,address1scaledreg) 12764 // 177: r: LONG_LOAD(address1scaledreg,address1reg) 12765 // 176: r: LONG_LOAD(address1scaledreg,rlv) 12766 // 175: r: LONG_LOAD(rlv,address1scaledreg) 12767 // 174: r: LONG_LOAD(rlv,rlv) 12768 // 173: stm: LONG_IFCMP(rlv,rlv) 12769 // 172: r: LONG_DIV(load64,rlv) 12770 // 171: r: LONG_DIV(rlv,load64) 12771 // 170: r: LONG_DIV(riv,rlv) 12772 // 169: r: LONG_DIV(rlv,riv) 12773 // 168: r: LONG_DIV(rlv,rlv) 12774 // 167: szp: LONG_AND(r,load8_16_32_64) 12775 // 166: szp: LONG_AND(load8_16_32_64,rlv) 12776 // 165: szpr: LONG_AND(load64,rlv) 12777 // 164: szpr: LONG_AND(rlv,load64) 12778 // 163: szp: LONG_AND(r,rlv) 12779 // 162: szpr: LONG_AND(r,r) 12780 // 161: szpr: LONG_AND(r,rlv) 12781 // 160: czr: LONG_ADD(load64,rlv) 12782 // 159: czr: LONG_ADD(rlv,load64) 12783 // 158: r: LONG_ADD(r,rlv) 12784 // 157: czr: LONG_ADD(r,r) 12785 // 156: czr: LONG_ADD(r,riv) 12786 // 155: czr: LONG_ADD(r,rlv) 12787 // 154: load64: LONG_ALOAD(rlv,r) 12788 // 153: load64: LONG_ALOAD(rlv,rlv) 12789 // 152: load64: LONG_LOAD(rlv,rlv) 12790 // 151: load32: INT_ALOAD(rlv,riv) 12791 // 150: load32: INT_LOAD(rlv,rlv) 12792 // 149: uload16: USHORT_ALOAD(rlv,riv) 12793 // 148: r: USHORT_ALOAD(rlv,r) 12794 // 147: r: USHORT_ALOAD(rlv,riv) 12795 // 146: uload16: USHORT_LOAD(rlv,rlv) 12796 // 145: r: USHORT_LOAD(rlv,rlv) 12797 // 144: sload16: SHORT_ALOAD(rlv,riv) 12798 // 143: r: SHORT_ALOAD(rlv,r) 12799 // 142: r: SHORT_ALOAD(rlv,riv) 12800 // 141: sload16: SHORT_LOAD(rlv,rlv) 12801 // 140: r: SHORT_LOAD(rlv,rlv) 12802 // 139: uload8: UBYTE_ALOAD(rlv,riv) 12803 // 138: r: UBYTE_ALOAD(rlv,r) 12804 // 137: r: UBYTE_ALOAD(rlv,riv) 12805 // 136: uload8: UBYTE_LOAD(rlv,rlv) 12806 // 135: r: UBYTE_LOAD(rlv,rlv) 12807 // 134: sload8: BYTE_ALOAD(rlv,riv) 12808 // 133: r: BYTE_ALOAD(rlv,r) 12809 // 132: r: BYTE_ALOAD(rlv,riv) 12810 // 131: sload8: BYTE_LOAD(rlv,rlv) 12811 // 130: r: BYTE_LOAD(rlv,rlv) 12812 // 129: r: LONG_ADD(address1reg,address1scaledreg) 12813 // 128: r: LONG_ADD(address1scaledreg,address1reg) 12814 // 127: r: LONG_ADD(r,address1scaledreg) 12815 // 126: r: LONG_ADD(address1scaledreg,r) 12816 // 125: szpr: INT_XOR(load32,riv) 12817 // 124: szpr: INT_XOR(r,load32) 12818 // 123: szpr: INT_XOR(r,riv) 12819 // 122: szpr: INT_USHR(riv,riv) 12820 // 121: czr: INT_SUB(load32,riv) 12821 // 120: czr: INT_SUB(riv,load32) 12822 // 119: r: INT_SUB(load32,r) 12823 // 118: r: INT_SUB(riv,r) 12824 // 117: czr: INT_SUB(riv,r) 12825 // 116: szpr: INT_SHR(riv,riv) 12826 // 115: szpr: INT_SHL(riv,riv) 12827 // 114: r: INT_REM(riv,load32) 12828 // 113: r: INT_REM(riv,riv) 12829 // 112: szpr: INT_OR(load32,riv) 12830 // 111: szpr: INT_OR(r,load32) 12831 // 110: szpr: INT_OR(r,riv) 12832 // 109: r: INT_MUL(load32,riv) 12833 // 108: r: INT_MUL(r,load32) 12834 // 107: r: INT_MUL(r,riv) 12835 // 106: r: INT_ALOAD(rlv,riv) 12836 // 105: r: INT_LOAD(address1reg,address1scaledreg) 12837 // 104: r: INT_LOAD(address1scaledreg,address1reg) 12838 // 103: r: INT_LOAD(address1scaledreg,rlv) 12839 // 102: r: INT_LOAD(rlv,address1scaledreg) 12840 // 101: r: INT_LOAD(rlv,rlv) 12841 // 100: stm: INT_IFCMP2(riv,load32) 12842 // 99: stm: INT_IFCMP2(load32,riv) 12843 // 98: stm: INT_IFCMP2(r,riv) 12844 // 97: stm: INT_IFCMP(r,load32) 12845 // 96: stm: INT_IFCMP(load32,riv) 12846 // 95: stm: INT_IFCMP(r,uload8) 12847 // 94: stm: INT_IFCMP(uload8,r) 12848 // 93: stm: INT_IFCMP(r,riv) 12849 // 92: r: INT_DIV(riv,load32) 12850 // 91: r: INT_DIV(riv,riv) 12851 // 90: szp: INT_AND(r,load8_16_32) 12852 // 89: szp: INT_AND(load8_16_32,riv) 12853 // 88: szpr: INT_AND(load32,riv) 12854 // 87: szpr: INT_AND(r,load32) 12855 // 86: szp: INT_AND(r,riv) 12856 // 85: szpr: INT_AND(r,riv) 12857 // 84: czr: INT_ADD(load32,riv) 12858 // 83: czr: INT_ADD(r,load32) 12859 // 82: r: INT_ADD(r,riv) 12860 // 81: czr: INT_ADD(r,riv) 12861 // 80: boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 12862 // 79: r: BOOLEAN_CMP_LONG(r,load64) 12863 // 78: boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 12864 // 77: r: BOOLEAN_CMP_LONG(load64,rlv) 12865 // 76: boolcmp: BOOLEAN_CMP_LONG(r,rlv) 12866 // 75: r: BOOLEAN_CMP_LONG(r,rlv) 12867 // 74: boolcmp: BOOLEAN_CMP_INT(riv,load32) 12868 // 73: r: BOOLEAN_CMP_INT(r,load32) 12869 // 72: boolcmp: BOOLEAN_CMP_INT(load32,riv) 12870 // 71: r: BOOLEAN_CMP_INT(load32,riv) 12871 // 70: boolcmp: BOOLEAN_CMP_INT(r,riv) 12872 // 69: r: BOOLEAN_CMP_INT(r,riv) 12873 // 68: address: LONG_ADD(address1reg,address1scaledreg) 12874 // 67: address: LONG_ADD(address1scaledreg,address1reg) 12875 // 66: address: LONG_ADD(address1scaledreg,r) 12876 // 65: address: LONG_ADD(r,address1scaledreg) 12877 // 64: address: LONG_ADD(r,r) 12878 // 63: address: INT_ADD(address1reg,address1scaledreg) 12879 // 62: address: INT_ADD(address1scaledreg,address1reg) 12880 // 61: address: INT_ADD(address1scaledreg,r) 12881 // 60: address: INT_ADD(r,address1scaledreg) 12882 // 59: address: INT_ADD(r,r) 12883 // 58: stm: YIELDPOINT_OSR(any,any) 12884 // 57: r: SYSCALL(r,any) 12885 // 56: r: CALL(r,any) 12886 // 55: r: LONG_CMP(rlv,rlv) 12887 // 54: stm: TRAP_IF(riv,load32) 12888 // 53: stm: TRAP_IF(load32,riv) 12889 // 52: stm: TRAP_IF(r,r) 12890 // 51: any: OTHER_OPERAND(any,any) 12891 else if (eruleno <= 246) { 12892 mark(p.getChild1(), ntsrule[0]); 12893 mark(p.getChild2(), ntsrule[1]); 12894 } 12895 // 382: double_load: MATERIALIZE_FP_CONSTANT(any) 12896 // 381: float_load: MATERIALIZE_FP_CONSTANT(any) 12897 // 380: r: MATERIALIZE_FP_CONSTANT(any) 12898 // 379: double_load: LONG_BITS_AS_DOUBLE(load64) 12899 // 378: r: LONG_BITS_AS_DOUBLE(rlv) 12900 // 377: float_load: INT_BITS_AS_FLOAT(load32) 12901 // 376: r: INT_BITS_AS_FLOAT(riv) 12902 // 375: load64: DOUBLE_AS_LONG_BITS(double_load) 12903 // 374: r: DOUBLE_AS_LONG_BITS(r) 12904 // 373: load32: FLOAT_AS_INT_BITS(float_load) 12905 // 372: r: FLOAT_AS_INT_BITS(r) 12906 // 371: r: DOUBLE_2LONG(r) 12907 // 370: r: DOUBLE_2INT(r) 12908 // 369: r: FLOAT_2LONG(r) 12909 // 368: r: FLOAT_2INT(r) 12910 // 367: r: DOUBLE_2FLOAT(double_load) 12911 // 366: r: DOUBLE_2FLOAT(r) 12912 // 365: r: FLOAT_2DOUBLE(float_load) 12913 // 364: r: FLOAT_2DOUBLE(r) 12914 // 363: r: INT_2DOUBLE(load32) 12915 // 362: r: INT_2DOUBLE(riv) 12916 // 361: r: INT_2FLOAT(load32) 12917 // 360: r: INT_2FLOAT(riv) 12918 // 359: r: DOUBLE_MOVE(r) 12919 // 358: r: FLOAT_MOVE(r) 12920 // 357: r: LONG_2DOUBLE(r) 12921 // 356: r: LONG_2FLOAT(r) 12922 // 355: r: DOUBLE_SQRT(r) 12923 // 354: r: FLOAT_SQRT(r) 12924 // 353: r: DOUBLE_NEG(r) 12925 // 352: r: FLOAT_NEG(r) 12926 // 351: szpr: LONG_USHR(rlv,LONG_CONSTANT) 12927 // 350: szpr: LONG_SHR(rlv,LONG_CONSTANT) 12928 // 349: r: LONG_SHL(r,INT_CONSTANT) 12929 // 348: szpr: LONG_SHL(r,INT_CONSTANT) 12930 // 347: r: LONG_NOT(r) 12931 // 346: szpr: LONG_NEG(r) 12932 // 345: load64: LONG_MOVE(load64) 12933 // 344: r: LONG_MOVE(riv) 12934 // 343: r: LONG_MOVE(rlv) 12935 // 342: r: LONG_LOAD(address,LONG_CONSTANT) 12936 // 341: stm: LONG_IFCMP(r,LONG_CONSTANT) 12937 // 340: load32: LONG_2INT(load64) 12938 // 339: r: LONG_2INT(load64) 12939 // 338: r: LONG_2INT(r) 12940 // 337: r: LONG_MOVE(address) 12941 // 336: r: LONG_ADD(address,LONG_CONSTANT) 12942 // 335: szpr: INT_USHR(riv,INT_CONSTANT) 12943 // 334: szpr: INT_SHR(riv,INT_CONSTANT) 12944 // 333: r: INT_SHL(r,INT_CONSTANT) 12945 // 332: szpr: INT_SHL(r,INT_CONSTANT) 12946 // 331: r: INT_NOT(r) 12947 // 330: szpr: INT_NEG(r) 12948 // 329: load32: INT_MOVE(load32) 12949 // 328: load16: INT_MOVE(load16) 12950 // 327: uload16: INT_MOVE(uload16) 12951 // 326: sload16: INT_MOVE(sload16) 12952 // 325: load8: INT_MOVE(load8) 12953 // 324: uload8: INT_MOVE(uload8) 12954 // 323: sload8: INT_MOVE(sload8) 12955 // 322: szp: INT_MOVE(szp) 12956 // 321: szpr: INT_MOVE(szpr) 12957 // 320: cz: INT_MOVE(cz) 12958 // 319: czr: INT_MOVE(czr) 12959 // 318: r: INT_MOVE(riv) 12960 // 317: r: INT_LOAD(address,LONG_CONSTANT) 12961 // 316: stm: INT_IFCMP(bittest,INT_CONSTANT) 12962 // 315: stm: INT_IFCMP(szp,INT_CONSTANT) 12963 // 314: stm: INT_IFCMP(cz,INT_CONSTANT) 12964 // 313: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 12965 // 312: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 12966 // 311: stm: INT_IFCMP(sload16,INT_CONSTANT) 12967 // 310: stm: INT_IFCMP(load8,INT_CONSTANT) 12968 // 309: stm: INT_IFCMP(r,INT_CONSTANT) 12969 // 308: r: INT_2USHORT(load16_32) 12970 // 307: uload16: INT_2USHORT(load16_32) 12971 // 306: szpr: INT_2USHORT(r) 12972 // 305: sload16: INT_2SHORT(load16_32) 12973 // 304: r: INT_2SHORT(load16_32) 12974 // 303: r: INT_2SHORT(r) 12975 // 302: r: INT_2ADDRZerExt(r) 12976 // 301: r: INT_2LONG(load32) 12977 // 300: r: INT_2LONG(r) 12978 // 299: r: INT_2BYTE(load8_16_32) 12979 // 298: r: INT_2BYTE(r) 12980 // 297: r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12981 // 296: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12982 // 295: r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12983 // 294: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 12984 // 293: r: BOOLEAN_NOT(r) 12985 // 292: r: BOOLEAN_CMP_LONG(cz,LONG_CONSTANT) 12986 // 291: r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 12987 // 290: r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12988 // 289: r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 12989 // 288: r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12990 // 287: boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12991 // 286: r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 12992 // 285: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12993 // 284: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12994 // 283: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12995 // 282: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 12996 // 281: boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 12997 // 280: r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 12998 // 279: boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 12999 // 278: r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 13000 // 277: boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 13001 // 276: r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 13002 // 275: r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13003 // 274: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13004 // 273: r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13005 // 272: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13006 // 271: boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13007 // 270: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13008 // 269: address: LONG_ADD(address1scaledreg,LONG_CONSTANT) 13009 // 268: address1scaledreg: LONG_ADD(address1scaledreg,LONG_CONSTANT) 13010 // 267: address1reg: LONG_ADD(address1reg,LONG_CONSTANT) 13011 // 266: address1reg: LONG_MOVE(r) 13012 // 265: address1reg: LONG_ADD(r,LONG_CONSTANT) 13013 // 264: address1scaledreg: LONG_SHL(r,INT_CONSTANT) 13014 // 263: address: INT_ADD(address1scaledreg,LONG_CONSTANT) 13015 // 262: address1scaledreg: INT_ADD(address1scaledreg,LONG_CONSTANT) 13016 // 261: address1reg: INT_ADD(address1reg,LONG_CONSTANT) 13017 // 260: address1reg: INT_MOVE(r) 13018 // 259: address1reg: INT_ADD(r,LONG_CONSTANT) 13019 // 258: address1scaledreg: INT_SHL(r,INT_CONSTANT) 13020 // 257: stm: RETURN(r) 13021 // 256: stm: PREFETCH(r) 13022 // 255: r: INT_AND(load16_32,INT_CONSTANT) 13023 // 254: r: INT_2BYTE(load8_16_32) 13024 // 253: r: INT_AND(load8_16_32,INT_CONSTANT) 13025 // 252: uload8: INT_AND(load8_16_32,INT_CONSTANT) 13026 // 251: stm: TRAP_IF(r,LONG_CONSTANT) 13027 // 250: stm: TRAP_IF(r,INT_CONSTANT) 13028 // 249: stm: SET_CAUGHT_EXCEPTION(r) 13029 // 248: stm: NULL_CHECK(riv) 13030 // 247: stm: LOWTABLESWITCH(r) 13031 else if (eruleno <= 382) { 13032 mark(p.getChild1(), ntsrule[0]); 13033 } 13034 // 396: szpr: LONG_SHL(LONG_SHR(r,INT_CONSTANT),INT_CONSTANT) 13035 // 395: load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 13036 // 394: load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 13037 // 393: r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 13038 // 392: r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 13039 // 391: r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 13040 // 390: r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 13041 // 389: szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 13042 // 388: r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 13043 // 387: r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 13044 // 386: bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 13045 // 385: bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 13046 // 384: r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 13047 // 383: r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 13048 else if (eruleno <= 396) { 13049 mark(p.getChild1().getChild1(), ntsrule[0]); 13050 } 13051 // 465: stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 13052 // 464: stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 13053 // 463: stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 13054 // 462: stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 13055 // 461: r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 13056 // 460: r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 13057 // 459: r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 13058 // 458: r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 13059 // 457: r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 13060 // 456: r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 13061 // 455: r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 13062 // 454: r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 13063 // 453: stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 13064 // 452: stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 13065 // 451: stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 13066 // 450: stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 13067 // 449: stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 13068 // 448: stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 13069 // 447: stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 13070 // 446: stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 13071 // 445: stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 13072 // 444: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 13073 // 443: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 13074 // 442: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 13075 // 441: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 13076 // 440: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 13077 // 439: stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 13078 // 438: stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 13079 // 437: stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 13080 // 436: stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 13081 // 435: stm: LONG_STORE(rlv,OTHER_OPERAND(address1reg,address1scaledreg)) 13082 // 434: stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,address1reg)) 13083 // 433: stm: LONG_STORE(rlv,OTHER_OPERAND(address1scaledreg,rlv)) 13084 // 432: stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,address1scaledreg)) 13085 // 431: stm: LONG_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 13086 // 430: r: LCMP_CMOV(rlv,OTHER_OPERAND(load64,any)) 13087 // 429: r: LCMP_CMOV(load64,OTHER_OPERAND(rlv,any)) 13088 // 428: r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 13089 // 427: stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 13090 // 426: stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 13091 // 425: stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,rlv)) 13092 // 424: stm: INT_STORE(riv,OTHER_OPERAND(rlv,address1scaledreg)) 13093 // 423: stm: INT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 13094 // 422: r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 13095 // 421: r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 13096 // 420: r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 13097 // 419: r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 13098 // 418: r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 13099 // 417: stm: BYTE_ASTORE(load8,OTHER_OPERAND(rlv,riv)) 13100 // 416: stm: BYTE_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 13101 // 415: stm: BYTE_STORE(load8,OTHER_OPERAND(rlv,rlv)) 13102 // 414: stm: BYTE_STORE(riv,OTHER_OPERAND(rlv,rlv)) 13103 // 413: stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 13104 // 412: stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 13105 // 411: stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 13106 // 410: stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 13107 // 409: stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 13108 // 408: stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 13109 // 407: stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 13110 // 406: stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 13111 // 405: stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 13112 // 404: stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 13113 // 403: stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 13114 // 402: stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 13115 // 401: stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 13116 // 400: stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 13117 // 399: stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 13118 // 398: stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 13119 // 397: stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 13120 else if (eruleno <= 465) { 13121 mark(p.getChild1(), ntsrule[0]); 13122 mark(p.getChild2().getChild1(), ntsrule[1]); 13123 mark(p.getChild2().getChild2(), ntsrule[2]); 13124 } 13125 // 467: stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 13126 // 466: stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 13127 else if (eruleno <= 467) { 13128 mark(p.getChild2().getChild1(), ntsrule[0]); 13129 mark(p.getChild2().getChild2(), ntsrule[1]); 13130 } 13131 // 470: r: SYSCALL(INT_CONSTANT,any) 13132 // 469: r: CALL(INT_CONSTANT,any) 13133 // 468: r: CALL(BRANCH_TARGET,any) 13134 else if (eruleno <= 470) { 13135 mark(p.getChild2(), ntsrule[0]); 13136 } 13137 // 473: r: SYSCALL(INT_LOAD(riv,riv),any) 13138 // 472: r: CALL(LONG_LOAD(rlv,rlv),any) 13139 // 471: r: CALL(INT_LOAD(riv,riv),any) 13140 else if (eruleno <= 473) { 13141 mark(p.getChild1().getChild1(), ntsrule[0]); 13142 mark(p.getChild1().getChild2(), ntsrule[1]); 13143 mark(p.getChild2(), ntsrule[2]); 13144 } 13145 // 489: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 13146 // 488: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 13147 // 487: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 13148 // 486: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 13149 // 485: r: ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 13150 // 484: r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))) 13151 // 483: r: ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))) 13152 // 482: r: ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))) 13153 // 481: r: ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))) 13154 // 480: r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 13155 // 479: r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 13156 // 478: r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 13157 // 477: r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 13158 // 476: r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 13159 // 475: r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 13160 // 474: r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 13161 else if (eruleno <= 489) { 13162 mark(p.getChild1(), ntsrule[0]); 13163 mark(p.getChild2().getChild1(), ntsrule[1]); 13164 mark(p.getChild2().getChild2().getChild1(), ntsrule[2]); 13165 mark(p.getChild2().getChild2().getChild2(), ntsrule[3]); 13166 } 13167 // 491: r: ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))) 13168 // 490: r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 13169 else if (eruleno <= 491) { 13170 mark(p.getChild1(), ntsrule[0]); 13171 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 13172 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 13173 } 13174 // 493: r: ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))) 13175 // 492: r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 13176 else if (eruleno <= 493) { 13177 mark(p.getChild2().getChild1(), ntsrule[0]); 13178 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 13179 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 13180 } 13181 // 513: stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13182 // 512: stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13183 // 511: stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13184 // 510: stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13185 // 509: stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13186 // 508: stm: INT_IFCMP(ATTEMPT_LONG(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13187 // 507: stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13188 // 506: stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13189 // 505: stm: INT_IFCMP(ATTEMPT_LONG(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13190 // 504: stm: INT_IFCMP(ATTEMPT_LONG(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13191 // 503: stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13192 // 502: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13193 // 501: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13194 // 500: stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13195 // 499: stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13196 // 498: stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13197 // 497: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13198 // 496: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13199 // 495: stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13200 // 494: stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13201 else if (eruleno <= 513) { 13202 mark(p.getChild1().getChild1(), ntsrule[0]); 13203 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 13204 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[2]); 13205 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[3]); 13206 } 13207 // 517: stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13208 // 516: stm: INT_IFCMP(ATTEMPT_LONG(address,OTHER_OPERAND(LONG_CONSTANT,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13209 // 515: stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13210 // 514: stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13211 else if (eruleno <= 517) { 13212 mark(p.getChild1().getChild1(), ntsrule[0]); 13213 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[1]); 13214 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[2]); 13215 } 13216 // 521: stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13217 // 520: stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13218 // 519: stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13219 // 518: stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13220 else if (eruleno <= 521) { 13221 mark(p.getChild1().getChild2().getChild1(), ntsrule[0]); 13222 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[1]); 13223 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[2]); 13224 } 13225 // 525: bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13226 // 524: bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13227 // 523: bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13228 // 522: bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13229 else if (eruleno <= 525) { 13230 mark(p.getChild1().getChild1(), ntsrule[0]); 13231 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 13232 } 13233 // 527: bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 13234 // 526: bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 13235 else if (eruleno <= 527) { 13236 mark(p.getChild1().getChild2().getChild1(), ntsrule[0]); 13237 mark(p.getChild2(), ntsrule[1]); 13238 } 13239 // 529: bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 13240 // 528: bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 13241 else if (eruleno <= 529) { 13242 mark(p.getChild1(), ntsrule[0]); 13243 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 13244 } 13245 // 551: stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 13246 // 550: stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 13247 // 549: stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 13248 // 548: stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),LONG_CONSTANT),OTHER_OPERAND(riv,riv)) 13249 // 547: stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13250 // 546: stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13251 // 545: stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13252 // 544: stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13253 // 543: stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13254 // 542: stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13255 // 541: stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13256 // 540: stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13257 // 539: stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13258 // 538: stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13259 // 537: stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13260 // 536: stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 13261 // 535: stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13262 // 534: stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13263 // 533: stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13264 // 532: stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13265 // 531: stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv,riv)) 13266 // 530: stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13267 else if (eruleno <= 551) { 13268 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 13269 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 13270 mark(p.getChild2().getChild1(), ntsrule[2]); 13271 mark(p.getChild2().getChild2(), ntsrule[3]); 13272 } 13273 // 560: r: LCMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 13274 // 559: r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 13275 // 558: r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 13276 // 557: r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 13277 // 556: r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 13278 // 555: r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 13279 // 554: r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 13280 // 553: r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 13281 // 552: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 13282 else if (eruleno <= 560) { 13283 mark(p.getChild1(), ntsrule[0]); 13284 mark(p.getChild2().getChild2(), ntsrule[1]); 13285 } 13286 // 568: stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 13287 // 567: stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 13288 // 566: stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 13289 // 565: stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 13290 // 564: stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 13291 // 563: stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 13292 // 562: stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 13293 // 561: stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 13294 else if (eruleno <= 568) { 13295 mark(p.getChild1().getChild1(), ntsrule[0]); 13296 mark(p.getChild2().getChild1(), ntsrule[1]); 13297 mark(p.getChild2().getChild2(), ntsrule[2]); 13298 } 13299 // 588: stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13300 // 587: stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13301 // 586: stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13302 // 585: stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13303 // 584: stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13304 // 583: stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13305 // 582: stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13306 // 581: stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13307 // 580: stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13308 // 579: stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 13309 // 578: stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13310 // 577: stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13311 // 576: stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13312 // 575: stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13313 // 574: stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13314 // 573: stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13315 // 572: stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13316 // 571: stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13317 // 570: stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13318 // 569: stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 13319 else if (eruleno <= 588) { 13320 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 13321 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 13322 mark(p.getChild1().getChild2(), ntsrule[2]); 13323 mark(p.getChild2().getChild1(), ntsrule[3]); 13324 mark(p.getChild2().getChild2(), ntsrule[4]); 13325 } 13326 // 608: stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13327 // 607: stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13328 // 606: stm: LONG_ASTORE(LONG_SUB(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13329 // 605: stm: LONG_STORE(LONG_SUB(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13330 // 604: stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13331 // 603: stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13332 // 602: stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13333 // 601: stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13334 // 600: stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13335 // 599: stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 13336 // 598: stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13337 // 597: stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13338 // 596: stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13339 // 595: stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13340 // 594: stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13341 // 593: stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13342 // 592: stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13343 // 591: stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13344 // 590: stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13345 // 589: stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 13346 else if (eruleno <= 608) { 13347 mark(p.getChild1().getChild1(), ntsrule[0]); 13348 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 13349 mark(p.getChild1().getChild2().getChild2(), ntsrule[2]); 13350 mark(p.getChild2().getChild1(), ntsrule[3]); 13351 mark(p.getChild2().getChild2(), ntsrule[4]); 13352 } 13353 // 612: r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 13354 // 611: r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 13355 // 610: r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 13356 // 609: r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 13357 else if (eruleno <= 612) { 13358 mark(p.getChild1().getChild1(), ntsrule[0]); 13359 mark(p.getChild2().getChild1(), ntsrule[1]); 13360 } 13361 // 614: r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 13362 // 613: r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 13363 else if (eruleno <= 614) { 13364 mark(p.getChild1().getChild1(), ntsrule[0]); 13365 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 13366 mark(p.getChild2().getChild1(), ntsrule[2]); 13367 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[3]); 13368 } 13369 // 616: r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 13370 // 615: r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 13371 else if (eruleno <= 616) { 13372 mark(p.getChild1().getChild1(), ntsrule[0]); 13373 mark(p.getChild1().getChild2().getChild1().getChild1(), ntsrule[1]); 13374 mark(p.getChild2().getChild1(), ntsrule[2]); 13375 mark(p.getChild2().getChild2().getChild1(), ntsrule[3]); 13376 } 13377 // 624: szpr: LONG_USHR(rlv,LONG_AND(r,LONG_CONSTANT)) 13378 // 623: stm: LONG_STORE(rlv,OTHER_OPERAND(address,LONG_CONSTANT)) 13379 // 622: szpr: LONG_SHR(rlv,INT_AND(r,LONG_CONSTANT)) 13380 // 621: szpr: LONG_SHL(rlv,INT_AND(r,INT_CONSTANT)) 13381 // 620: szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 13382 // 619: stm: INT_STORE(riv,OTHER_OPERAND(address,LONG_CONSTANT)) 13383 // 618: szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 13384 // 617: szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 13385 else if (eruleno <= 624) { 13386 mark(p.getChild1(), ntsrule[0]); 13387 mark(p.getChild2().getChild1(), ntsrule[1]); 13388 } 13389 // 636: stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 13390 // 635: stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 13391 // 634: stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 13392 // 633: stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv,riv)) 13393 // 632: stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13394 // 631: stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13395 // 630: stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13396 // 629: stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13397 // 628: stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13398 // 627: stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13399 // 626: stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13400 // 625: stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 13401 else if (eruleno <= 636) { 13402 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 13403 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 13404 mark(p.getChild1().getChild2().getChild1(), ntsrule[2]); 13405 mark(p.getChild2().getChild1(), ntsrule[3]); 13406 mark(p.getChild2().getChild2(), ntsrule[4]); 13407 } 13408 // 640: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 13409 // 639: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 13410 // 638: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 13411 // 637: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 13412 else if (eruleno <= 640) { 13413 mark(p.getChild1(), ntsrule[0]); 13414 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 13415 mark(p.getChild2().getChild2().getChild2().getChild1(), ntsrule[2]); 13416 } 13417 // 644: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 13418 // 643: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 13419 // 642: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 13420 // 641: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 13421 else if (eruleno <= 644) { 13422 mark(p.getChild1(), ntsrule[0]); 13423 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[1]); 13424 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 13425 } 13426 // 648: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 13427 // 647: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 13428 // 646: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 13429 // 645: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 13430 else if (eruleno <= 648) { 13431 mark(p.getChild2().getChild1(), ntsrule[0]); 13432 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[1]); 13433 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 13434 } 13435 // 652: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 13436 // 651: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 13437 // 650: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 13438 // 649: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 13439 else { 13440 if (VM.VerifyAssertions) VM._assert(eruleno <= 652); 13441 mark(p.getChild2().getChild1(), ntsrule[0]); 13442 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 13443 mark(p.getChild2().getChild2().getChild2().getChild1(), ntsrule[2]); 13444 } 13445 } 13446 13447 /** 13448 * For each BURS rule (the number of which provides the index) give its flags byte 13449 */ 13450 private static final byte[] action={ 13451 0, 13452 NOFLAGS, // 1 - stm: r 13453 NOFLAGS, // 2 - r: REGISTER 13454 NOFLAGS, // 3 - r: czr 13455 NOFLAGS, // 4 - cz: czr 13456 NOFLAGS, // 5 - r: szpr 13457 NOFLAGS, // 6 - szp: szpr 13458 NOFLAGS, // 7 - riv: r 13459 NOFLAGS, // 8 - riv: INT_CONSTANT 13460 NOFLAGS, // 9 - rlv: r 13461 NOFLAGS, // 10 - rlv: LONG_CONSTANT 13462 NOFLAGS, // 11 - any: NULL 13463 NOFLAGS, // 12 - any: riv 13464 NOFLAGS, // 13 - any: ADDRESS_CONSTANT 13465 NOFLAGS, // 14 - any: LONG_CONSTANT 13466 NOFLAGS, // 15 - any: OTHER_OPERAND(any, any) 13467 EMIT_INSTRUCTION, // 16 - stm: IG_PATCH_POINT 13468 EMIT_INSTRUCTION, // 17 - stm: UNINT_BEGIN 13469 EMIT_INSTRUCTION, // 18 - stm: UNINT_END 13470 EMIT_INSTRUCTION, // 19 - stm: YIELDPOINT_PROLOGUE 13471 EMIT_INSTRUCTION, // 20 - stm: YIELDPOINT_EPILOGUE 13472 EMIT_INSTRUCTION, // 21 - stm: YIELDPOINT_BACKEDGE 13473 EMIT_INSTRUCTION, // 22 - stm: LOWTABLESWITCH(r) 13474 EMIT_INSTRUCTION, // 23 - stm: RESOLVE 13475 NOFLAGS, // 24 - stm: NOP 13476 EMIT_INSTRUCTION, // 25 - r: GUARD_MOVE 13477 EMIT_INSTRUCTION, // 26 - r: GUARD_COMBINE 13478 EMIT_INSTRUCTION, // 27 - stm: NULL_CHECK(riv) 13479 EMIT_INSTRUCTION, // 28 - stm: IR_PROLOGUE 13480 EMIT_INSTRUCTION, // 29 - r: GET_CAUGHT_EXCEPTION 13481 EMIT_INSTRUCTION, // 30 - stm: SET_CAUGHT_EXCEPTION(r) 13482 EMIT_INSTRUCTION, // 31 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 13483 EMIT_INSTRUCTION, // 32 - stm: TRAP 13484 EMIT_INSTRUCTION, // 33 - stm: TRAP_IF(r, INT_CONSTANT) 13485 EMIT_INSTRUCTION, // 34 - stm: TRAP_IF(r, LONG_CONSTANT) 13486 EMIT_INSTRUCTION, // 35 - stm: TRAP_IF(r, r) 13487 EMIT_INSTRUCTION, // 36 - stm: TRAP_IF(load32, riv) 13488 EMIT_INSTRUCTION, // 37 - stm: TRAP_IF(riv, load32) 13489 EMIT_INSTRUCTION, // 38 - uload8: INT_AND(load8_16_32, INT_CONSTANT) 13490 EMIT_INSTRUCTION, // 39 - r: INT_AND(load8_16_32, INT_CONSTANT) 13491 EMIT_INSTRUCTION, // 40 - r: INT_2BYTE(load8_16_32) 13492 EMIT_INSTRUCTION, // 41 - r: INT_USHR(INT_SHL(load8_16_32, INT_CONSTANT), INT_CONSTANT) 13493 EMIT_INSTRUCTION, // 42 - r: INT_AND(load16_32, INT_CONSTANT) 13494 EMIT_INSTRUCTION, // 43 - r: INT_USHR(INT_SHL(load16_32, INT_CONSTANT), INT_CONSTANT) 13495 EMIT_INSTRUCTION, // 44 - stm: SHORT_STORE(riv, OTHER_OPERAND(riv, riv)) 13496 EMIT_INSTRUCTION, // 45 - stm: SHORT_STORE(load16, OTHER_OPERAND(riv, riv)) 13497 EMIT_INSTRUCTION, // 46 - stm: SHORT_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 13498 EMIT_INSTRUCTION, // 47 - stm: SHORT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 13499 EMIT_INSTRUCTION, // 48 - stm: SHORT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 13500 EMIT_INSTRUCTION, // 49 - stm: SHORT_ASTORE(load16, OTHER_OPERAND(riv, riv)) 13501 EMIT_INSTRUCTION, // 50 - stm: SHORT_ASTORE(riv, OTHER_OPERAND(r, r)) 13502 EMIT_INSTRUCTION, // 51 - stm: INT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 13503 EMIT_INSTRUCTION, // 52 - stm: INT_ASTORE(riv, OTHER_OPERAND(r, r)) 13504 EMIT_INSTRUCTION, // 53 - stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, rlv)) 13505 EMIT_INSTRUCTION, // 54 - stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 13506 EMIT_INSTRUCTION, // 55 - stm: INT_ASTORE(riv, OTHER_OPERAND(riv, rlv)) 13507 EMIT_INSTRUCTION, // 56 - stm: LONG_ASTORE(r, OTHER_OPERAND(riv, riv)) 13508 EMIT_INSTRUCTION, // 57 - stm: LONG_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 13509 EMIT_INSTRUCTION, // 58 - stm: LONG_ASTORE(r, OTHER_OPERAND(r, r)) 13510 EMIT_INSTRUCTION, // 59 - stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 13511 EMIT_INSTRUCTION, // 60 - stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(rlv, riv)) 13512 EMIT_INSTRUCTION, // 61 - r: LONG_CMP(rlv,rlv) 13513 EMIT_INSTRUCTION, // 62 - stm: GOTO 13514 EMIT_INSTRUCTION, // 63 - stm: PREFETCH(r) 13515 EMIT_INSTRUCTION, // 64 - stm: WRITE_FLOOR 13516 EMIT_INSTRUCTION, // 65 - stm: READ_CEILING 13517 EMIT_INSTRUCTION, // 66 - stm: FENCE 13518 EMIT_INSTRUCTION, // 67 - stm: PAUSE 13519 EMIT_INSTRUCTION, // 68 - stm: RETURN(NULL) 13520 EMIT_INSTRUCTION, // 69 - stm: RETURN(INT_CONSTANT) 13521 EMIT_INSTRUCTION, // 70 - stm: RETURN(r) 13522 EMIT_INSTRUCTION, // 71 - stm: RETURN(LONG_CONSTANT) 13523 EMIT_INSTRUCTION, // 72 - r: CALL(r, any) 13524 EMIT_INSTRUCTION, // 73 - r: CALL(BRANCH_TARGET, any) 13525 EMIT_INSTRUCTION, // 74 - r: CALL(INT_LOAD(riv, riv), any) 13526 EMIT_INSTRUCTION, // 75 - r: CALL(INT_CONSTANT, any) 13527 EMIT_INSTRUCTION, // 76 - r: CALL(LONG_LOAD(rlv, rlv), any) 13528 EMIT_INSTRUCTION, // 77 - r: SYSCALL(r, any) 13529 EMIT_INSTRUCTION, // 78 - r: SYSCALL(INT_LOAD(riv, riv), any) 13530 EMIT_INSTRUCTION, // 79 - r: SYSCALL(INT_CONSTANT, any) 13531 EMIT_INSTRUCTION, // 80 - r: GET_TIME_BASE 13532 EMIT_INSTRUCTION, // 81 - stm: YIELDPOINT_OSR(any, any) 13533 NOFLAGS, // 82 - address1scaledreg: address1reg 13534 NOFLAGS, // 83 - address: address1scaledreg 13535 EMIT_INSTRUCTION, // 84 - address1scaledreg: INT_SHL(r, INT_CONSTANT) 13536 EMIT_INSTRUCTION, // 85 - address1reg: INT_ADD(r, LONG_CONSTANT) 13537 EMIT_INSTRUCTION, // 86 - address1reg: INT_MOVE(r) 13538 EMIT_INSTRUCTION, // 87 - address: INT_ADD(r, r) 13539 EMIT_INSTRUCTION, // 88 - address1reg: INT_ADD(address1reg, LONG_CONSTANT) 13540 EMIT_INSTRUCTION, // 89 - address1scaledreg: INT_ADD(address1scaledreg, LONG_CONSTANT) 13541 EMIT_INSTRUCTION, // 90 - address: INT_ADD(r, address1scaledreg) 13542 EMIT_INSTRUCTION, // 91 - address: INT_ADD(address1scaledreg, r) 13543 EMIT_INSTRUCTION, // 92 - address: INT_ADD(address1scaledreg, LONG_CONSTANT) 13544 EMIT_INSTRUCTION, // 93 - address: INT_ADD(address1scaledreg, address1reg) 13545 EMIT_INSTRUCTION, // 94 - address: INT_ADD(address1reg, address1scaledreg) 13546 EMIT_INSTRUCTION, // 95 - address1scaledreg: LONG_SHL(r, INT_CONSTANT) 13547 EMIT_INSTRUCTION, // 96 - address1reg: LONG_ADD(r, LONG_CONSTANT) 13548 EMIT_INSTRUCTION, // 97 - address1reg: LONG_MOVE(r) 13549 EMIT_INSTRUCTION, // 98 - address: LONG_ADD(r, r) 13550 EMIT_INSTRUCTION, // 99 - address1reg: LONG_ADD(address1reg, LONG_CONSTANT) 13551 EMIT_INSTRUCTION, // 100 - address1scaledreg: LONG_ADD(address1scaledreg, LONG_CONSTANT) 13552 EMIT_INSTRUCTION, // 101 - address: LONG_ADD(r, address1scaledreg) 13553 EMIT_INSTRUCTION, // 102 - address: LONG_ADD(address1scaledreg, r) 13554 EMIT_INSTRUCTION, // 103 - address: LONG_ADD(address1scaledreg, LONG_CONSTANT) 13555 EMIT_INSTRUCTION, // 104 - address: LONG_ADD(address1scaledreg, address1reg) 13556 EMIT_INSTRUCTION, // 105 - address: LONG_ADD(address1reg, address1scaledreg) 13557 EMIT_INSTRUCTION, // 106 - r: ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv, riv))) 13558 EMIT_INSTRUCTION, // 107 - r: ATTEMPT_INT(riv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 13559 EMIT_INSTRUCTION, // 108 - r: ATTEMPT_INT(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 13560 EMIT_INSTRUCTION, // 109 - r: ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 13561 EMIT_INSTRUCTION, // 110 - r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv, riv))) 13562 EMIT_INSTRUCTION, // 111 - r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv, riv))) 13563 EMIT_INSTRUCTION, // 112 - r: ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 13564 EMIT_INSTRUCTION, // 113 - r: ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv, riv))) 13565 EMIT_INSTRUCTION, // 114 - r: ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv, riv))) 13566 EMIT_INSTRUCTION, // 115 - stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13567 EMIT_INSTRUCTION, // 116 - stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13568 EMIT_INSTRUCTION, // 117 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13569 EMIT_INSTRUCTION, // 118 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13570 EMIT_INSTRUCTION, // 119 - stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13571 EMIT_INSTRUCTION, // 120 - stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13572 EMIT_INSTRUCTION, // 121 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13573 EMIT_INSTRUCTION, // 122 - stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))), INT_CONSTANT) 13574 EMIT_INSTRUCTION, // 123 - stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13575 EMIT_INSTRUCTION, // 124 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13576 EMIT_INSTRUCTION, // 125 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13577 EMIT_INSTRUCTION, // 126 - stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13578 EMIT_INSTRUCTION, // 127 - stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13579 EMIT_INSTRUCTION, // 128 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13580 EMIT_INSTRUCTION, // 129 - r: ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv, rlv))) 13581 EMIT_INSTRUCTION, // 130 - r: ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv, rlv))) 13582 EMIT_INSTRUCTION, // 131 - r: ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv, rlv))) 13583 EMIT_INSTRUCTION, // 132 - r: ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv, rlv))) 13584 EMIT_INSTRUCTION, // 133 - r: ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv, rlv))) 13585 EMIT_INSTRUCTION, // 134 - r: ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv, rlv))) 13586 EMIT_INSTRUCTION, // 135 - r: ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv, rlv))) 13587 EMIT_INSTRUCTION, // 136 - stm: INT_IFCMP(ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13588 EMIT_INSTRUCTION, // 137 - stm: INT_IFCMP(ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13589 EMIT_INSTRUCTION, // 138 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13590 EMIT_INSTRUCTION, // 139 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13591 EMIT_INSTRUCTION, // 140 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13592 EMIT_INSTRUCTION, // 141 - stm: INT_IFCMP(ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13593 EMIT_INSTRUCTION, // 142 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13594 EMIT_INSTRUCTION, // 143 - stm: INT_IFCMP(ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv,rlv))), INT_CONSTANT) 13595 EMIT_INSTRUCTION, // 144 - stm: INT_IFCMP(ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13596 EMIT_INSTRUCTION, // 145 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13597 EMIT_INSTRUCTION, // 146 - stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13598 EMIT_INSTRUCTION, // 147 - stm: INT_IFCMP(ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13599 EMIT_INSTRUCTION, // 148 - stm: INT_IFCMP(ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13600 EMIT_INSTRUCTION, // 149 - stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 13601 EMIT_INSTRUCTION, // 150 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13602 EMIT_INSTRUCTION, // 151 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13603 EMIT_INSTRUCTION, // 152 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 13604 EMIT_INSTRUCTION, // 153 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13605 EMIT_INSTRUCTION, // 154 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13606 EMIT_INSTRUCTION, // 155 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 13607 EMIT_INSTRUCTION, // 156 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 13608 EMIT_INSTRUCTION, // 157 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT)),load32) 13609 EMIT_INSTRUCTION, // 158 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 13610 EMIT_INSTRUCTION, // 159 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 13611 EMIT_INSTRUCTION, // 160 - r: BOOLEAN_CMP_INT(r,riv) 13612 EMIT_INSTRUCTION, // 161 - boolcmp: BOOLEAN_CMP_INT(r,riv) 13613 EMIT_INSTRUCTION, // 162 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13614 EMIT_INSTRUCTION, // 163 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13615 EMIT_INSTRUCTION, // 164 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13616 EMIT_INSTRUCTION, // 165 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13617 EMIT_INSTRUCTION, // 166 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13618 EMIT_INSTRUCTION, // 167 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13619 EMIT_INSTRUCTION, // 168 - r: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 13620 EMIT_INSTRUCTION, // 169 - boolcmp: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 13621 EMIT_INSTRUCTION, // 170 - r: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 13622 EMIT_INSTRUCTION, // 171 - boolcmp: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 13623 EMIT_INSTRUCTION, // 172 - r: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 13624 EMIT_INSTRUCTION, // 173 - boolcmp: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 13625 EMIT_INSTRUCTION, // 174 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13626 NOFLAGS, // 175 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13627 EMIT_INSTRUCTION, // 176 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13628 EMIT_INSTRUCTION, // 177 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13629 EMIT_INSTRUCTION, // 178 - r: BOOLEAN_CMP_INT(load32,riv) 13630 EMIT_INSTRUCTION, // 179 - boolcmp: BOOLEAN_CMP_INT(load32,riv) 13631 EMIT_INSTRUCTION, // 180 - r: BOOLEAN_CMP_INT(r,load32) 13632 EMIT_INSTRUCTION, // 181 - boolcmp: BOOLEAN_CMP_INT(riv,load32) 13633 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 182 - stm: BYTE_STORE(boolcmp, OTHER_OPERAND(riv,riv)) 13634 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 183 - stm: BYTE_ASTORE(boolcmp, OTHER_OPERAND(riv, riv)) 13635 EMIT_INSTRUCTION, // 184 - r: BOOLEAN_CMP_LONG(r,rlv) 13636 EMIT_INSTRUCTION, // 185 - boolcmp: BOOLEAN_CMP_LONG(r,rlv) 13637 EMIT_INSTRUCTION, // 186 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 13638 EMIT_INSTRUCTION, // 187 - boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 13639 EMIT_INSTRUCTION, // 188 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 13640 EMIT_INSTRUCTION, // 189 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 13641 EMIT_INSTRUCTION, // 190 - r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 13642 EMIT_INSTRUCTION, // 191 - r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 13643 EMIT_INSTRUCTION, // 192 - r: BOOLEAN_CMP_LONG(cz, LONG_CONSTANT) 13644 EMIT_INSTRUCTION, // 193 - r: BOOLEAN_CMP_LONG(load64,rlv) 13645 EMIT_INSTRUCTION, // 194 - boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 13646 EMIT_INSTRUCTION, // 195 - r: BOOLEAN_CMP_LONG(r,load64) 13647 EMIT_INSTRUCTION, // 196 - boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 13648 EMIT_INSTRUCTION, // 197 - r: BOOLEAN_NOT(r) 13649 EMIT_INSTRUCTION, // 198 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13650 EMIT_INSTRUCTION, // 199 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv, riv)) 13651 EMIT_INSTRUCTION, // 200 - stm: BYTE_STORE(riv, OTHER_OPERAND(rlv, rlv)) 13652 EMIT_INSTRUCTION, // 201 - stm: BYTE_STORE(load8, OTHER_OPERAND(rlv, rlv)) 13653 EMIT_INSTRUCTION, // 202 - stm: BYTE_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 13654 EMIT_INSTRUCTION, // 203 - stm: BYTE_ASTORE(load8, OTHER_OPERAND(rlv, riv)) 13655 EMIT_INSTRUCTION, // 204 - r: CMP_CMOV(r, OTHER_OPERAND(riv, any)) 13656 EMIT_INSTRUCTION, // 205 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 13657 EMIT_INSTRUCTION, // 206 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 13658 EMIT_INSTRUCTION, // 207 - r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 13659 EMIT_INSTRUCTION, // 208 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 13660 EMIT_INSTRUCTION, // 209 - r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 13661 EMIT_INSTRUCTION, // 210 - r: CMP_CMOV(load8, OTHER_OPERAND(INT_CONSTANT, any)) 13662 EMIT_INSTRUCTION, // 211 - r: CMP_CMOV(uload8, OTHER_OPERAND(riv, any)) 13663 EMIT_INSTRUCTION, // 212 - r: CMP_CMOV(riv, OTHER_OPERAND(uload8, any)) 13664 EMIT_INSTRUCTION, // 213 - r: CMP_CMOV(sload16, OTHER_OPERAND(INT_CONSTANT, any)) 13665 EMIT_INSTRUCTION, // 214 - r: CMP_CMOV(load32, OTHER_OPERAND(riv, any)) 13666 EMIT_INSTRUCTION, // 215 - r: CMP_CMOV(riv, OTHER_OPERAND(load32, any)) 13667 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 216 - r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 13668 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 217 - r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 13669 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 218 - r: CMP_CMOV(bittest, OTHER_OPERAND(INT_CONSTANT, any)) 13670 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 219 - r: CMP_CMOV(cz, OTHER_OPERAND(INT_CONSTANT, any)) 13671 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 220 - r: CMP_CMOV(szp, OTHER_OPERAND(INT_CONSTANT, any)) 13672 EMIT_INSTRUCTION, // 221 - r: INT_2BYTE(r) 13673 EMIT_INSTRUCTION, // 222 - r: INT_2BYTE(load8_16_32) 13674 EMIT_INSTRUCTION, // 223 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 13675 EMIT_INSTRUCTION, // 224 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 13676 EMIT_INSTRUCTION, // 225 - r: INT_2LONG(r) 13677 EMIT_INSTRUCTION, // 226 - r: INT_2LONG(load32) 13678 EMIT_INSTRUCTION, // 227 - r: LONG_AND(INT_2LONG(r), LONG_CONSTANT) 13679 EMIT_INSTRUCTION, // 228 - r: LONG_AND(INT_2LONG(load32), LONG_CONSTANT) 13680 EMIT_INSTRUCTION, // 229 - r: INT_2ADDRZerExt(r) 13681 EMIT_INSTRUCTION, // 230 - r: INT_2SHORT(r) 13682 EMIT_INSTRUCTION, // 231 - r: INT_2SHORT(load16_32) 13683 EMIT_INSTRUCTION, // 232 - sload16: INT_2SHORT(load16_32) 13684 EMIT_INSTRUCTION, // 233 - stm: SHORT_STORE(INT_2SHORT(r), OTHER_OPERAND(riv,riv)) 13685 EMIT_INSTRUCTION, // 234 - stm: SHORT_ASTORE(INT_2SHORT(r), OTHER_OPERAND(riv, riv)) 13686 EMIT_INSTRUCTION, // 235 - szpr: INT_2USHORT(r) 13687 EMIT_INSTRUCTION, // 236 - uload16: INT_2USHORT(load16_32) 13688 EMIT_INSTRUCTION, // 237 - r: INT_2USHORT(load16_32) 13689 EMIT_INSTRUCTION, // 238 - stm: SHORT_STORE(INT_2USHORT(r), OTHER_OPERAND(riv,riv)) 13690 EMIT_INSTRUCTION, // 239 - stm: SHORT_ASTORE(INT_2USHORT(r), OTHER_OPERAND(riv, riv)) 13691 EMIT_INSTRUCTION, // 240 - czr: INT_ADD(r, riv) 13692 EMIT_INSTRUCTION, // 241 - r: INT_ADD(r, riv) 13693 EMIT_INSTRUCTION, // 242 - czr: INT_ADD(r, load32) 13694 EMIT_INSTRUCTION, // 243 - czr: INT_ADD(load32, riv) 13695 EMIT_INSTRUCTION, // 244 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13696 EMIT_INSTRUCTION, // 245 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13697 EMIT_INSTRUCTION, // 246 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13698 EMIT_INSTRUCTION, // 247 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13699 EMIT_INSTRUCTION, // 248 - szpr: INT_AND(r, riv) 13700 EMIT_INSTRUCTION, // 249 - szp: INT_AND(r, riv) 13701 EMIT_INSTRUCTION, // 250 - szpr: INT_AND(r, load32) 13702 EMIT_INSTRUCTION, // 251 - szpr: INT_AND(load32, riv) 13703 EMIT_INSTRUCTION, // 252 - szp: INT_AND(load8_16_32, riv) 13704 EMIT_INSTRUCTION, // 253 - szp: INT_AND(r, load8_16_32) 13705 EMIT_INSTRUCTION, // 254 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13706 EMIT_INSTRUCTION, // 255 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13707 EMIT_INSTRUCTION, // 256 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13708 EMIT_INSTRUCTION, // 257 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13709 EMIT_INSTRUCTION, // 258 - r: INT_DIV(riv, riv) 13710 EMIT_INSTRUCTION, // 259 - r: INT_DIV(riv, load32) 13711 EMIT_INSTRUCTION, // 260 - stm: INT_IFCMP(r,riv) 13712 EMIT_INSTRUCTION, // 261 - stm: INT_IFCMP(r, INT_CONSTANT) 13713 EMIT_INSTRUCTION, // 262 - stm: INT_IFCMP(load8, INT_CONSTANT) 13714 EMIT_INSTRUCTION, // 263 - stm: INT_IFCMP(uload8, r) 13715 EMIT_INSTRUCTION, // 264 - stm: INT_IFCMP(r, uload8) 13716 EMIT_INSTRUCTION, // 265 - stm: INT_IFCMP(sload16, INT_CONSTANT) 13717 EMIT_INSTRUCTION, // 266 - stm: INT_IFCMP(load32, riv) 13718 EMIT_INSTRUCTION, // 267 - stm: INT_IFCMP(r, load32) 13719 EMIT_INSTRUCTION, // 268 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 13720 EMIT_INSTRUCTION, // 269 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 13721 EMIT_INSTRUCTION, // 270 - stm: INT_IFCMP(cz, INT_CONSTANT) 13722 EMIT_INSTRUCTION, // 271 - stm: INT_IFCMP(szp, INT_CONSTANT) 13723 EMIT_INSTRUCTION, // 272 - stm: INT_IFCMP(bittest, INT_CONSTANT) 13724 EMIT_INSTRUCTION, // 273 - stm: INT_IFCMP2(r,riv) 13725 EMIT_INSTRUCTION, // 274 - stm: INT_IFCMP2(load32,riv) 13726 EMIT_INSTRUCTION, // 275 - stm: INT_IFCMP2(riv,load32) 13727 EMIT_INSTRUCTION, // 276 - r: INT_LOAD(rlv, rlv) 13728 EMIT_INSTRUCTION, // 277 - r: INT_LOAD(rlv, address1scaledreg) 13729 EMIT_INSTRUCTION, // 278 - r: INT_LOAD(address1scaledreg, rlv) 13730 EMIT_INSTRUCTION, // 279 - r: INT_LOAD(address1scaledreg, address1reg) 13731 EMIT_INSTRUCTION, // 280 - r: INT_LOAD(address1reg, address1scaledreg) 13732 EMIT_INSTRUCTION, // 281 - r: INT_LOAD(address, LONG_CONSTANT) 13733 EMIT_INSTRUCTION, // 282 - r: INT_ALOAD(rlv, riv) 13734 EMIT_INSTRUCTION, // 283 - r: INT_MOVE(riv) 13735 EMIT_INSTRUCTION, // 284 - czr: INT_MOVE(czr) 13736 NOFLAGS, // 285 - cz: INT_MOVE(cz) 13737 EMIT_INSTRUCTION, // 286 - szpr: INT_MOVE(szpr) 13738 NOFLAGS, // 287 - szp: INT_MOVE(szp) 13739 NOFLAGS, // 288 - sload8: INT_MOVE(sload8) 13740 NOFLAGS, // 289 - uload8: INT_MOVE(uload8) 13741 NOFLAGS, // 290 - load8: INT_MOVE(load8) 13742 NOFLAGS, // 291 - sload16: INT_MOVE(sload16) 13743 NOFLAGS, // 292 - uload16: INT_MOVE(uload16) 13744 NOFLAGS, // 293 - load16: INT_MOVE(load16) 13745 NOFLAGS, // 294 - load32: INT_MOVE(load32) 13746 EMIT_INSTRUCTION, // 295 - r: INT_MUL(r, riv) 13747 EMIT_INSTRUCTION, // 296 - r: INT_MUL(r, load32) 13748 EMIT_INSTRUCTION, // 297 - r: INT_MUL(load32, riv) 13749 EMIT_INSTRUCTION, // 298 - szpr: INT_NEG(r) 13750 EMIT_INSTRUCTION, // 299 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13751 EMIT_INSTRUCTION, // 300 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13752 EMIT_INSTRUCTION, // 301 - r: INT_NOT(r) 13753 EMIT_INSTRUCTION, // 302 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13754 EMIT_INSTRUCTION, // 303 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13755 EMIT_INSTRUCTION, // 304 - szpr: INT_OR(r, riv) 13756 EMIT_INSTRUCTION, // 305 - szpr: INT_OR(r, load32) 13757 EMIT_INSTRUCTION, // 306 - szpr: INT_OR(load32, riv) 13758 EMIT_INSTRUCTION, // 307 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13759 EMIT_INSTRUCTION, // 308 - stm: INT_STORE(INT_OR(r, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13760 EMIT_INSTRUCTION, // 309 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13761 EMIT_INSTRUCTION, // 310 - stm: INT_ASTORE(INT_OR(r, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13762 EMIT_INSTRUCTION, // 311 - r: INT_REM(riv, riv) 13763 EMIT_INSTRUCTION, // 312 - r: INT_REM(riv, load32) 13764 EMIT_INSTRUCTION, // 313 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 13765 EMIT_INSTRUCTION, // 314 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 13766 EMIT_INSTRUCTION, // 315 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 13767 EMIT_INSTRUCTION, // 316 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 13768 EMIT_INSTRUCTION, // 317 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 13769 EMIT_INSTRUCTION, // 318 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 13770 EMIT_INSTRUCTION, // 319 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 13771 EMIT_INSTRUCTION, // 320 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 13772 EMIT_INSTRUCTION, // 321 - szpr: INT_SHL(riv, INT_AND(r, INT_CONSTANT)) 13773 EMIT_INSTRUCTION, // 322 - szpr: INT_SHL(riv, riv) 13774 EMIT_INSTRUCTION, // 323 - szpr: INT_SHL(r, INT_CONSTANT) 13775 EMIT_INSTRUCTION, // 324 - r: INT_SHL(r, INT_CONSTANT) 13776 EMIT_INSTRUCTION, // 325 - szpr: INT_SHL(INT_SHR(r, INT_CONSTANT), INT_CONSTANT) 13777 EMIT_INSTRUCTION, // 326 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13778 EMIT_INSTRUCTION, // 327 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13779 EMIT_INSTRUCTION, // 328 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13780 EMIT_INSTRUCTION, // 329 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13781 EMIT_INSTRUCTION, // 330 - szpr: INT_SHR(riv, INT_AND(r, INT_CONSTANT)) 13782 EMIT_INSTRUCTION, // 331 - szpr: INT_SHR(riv, riv) 13783 EMIT_INSTRUCTION, // 332 - szpr: INT_SHR(riv, INT_CONSTANT) 13784 EMIT_INSTRUCTION, // 333 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13785 EMIT_INSTRUCTION, // 334 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13786 EMIT_INSTRUCTION, // 335 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13787 EMIT_INSTRUCTION, // 336 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13788 EMIT_INSTRUCTION, // 337 - stm: INT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 13789 EMIT_INSTRUCTION, // 338 - stm: INT_STORE(riv, OTHER_OPERAND(rlv, address1scaledreg)) 13790 EMIT_INSTRUCTION, // 339 - stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, rlv)) 13791 EMIT_INSTRUCTION, // 340 - stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, address1reg)) 13792 EMIT_INSTRUCTION, // 341 - stm: INT_STORE(riv, OTHER_OPERAND(address1reg, address1scaledreg)) 13793 EMIT_INSTRUCTION, // 342 - stm: INT_STORE(riv, OTHER_OPERAND(address, LONG_CONSTANT)) 13794 EMIT_INSTRUCTION, // 343 - czr: INT_SUB(riv, r) 13795 EMIT_INSTRUCTION, // 344 - r: INT_SUB(riv, r) 13796 EMIT_INSTRUCTION, // 345 - r: INT_SUB(load32, r) 13797 EMIT_INSTRUCTION, // 346 - czr: INT_SUB(riv, load32) 13798 EMIT_INSTRUCTION, // 347 - czr: INT_SUB(load32, riv) 13799 EMIT_INSTRUCTION, // 348 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13800 EMIT_INSTRUCTION, // 349 - stm: INT_STORE(INT_SUB(riv, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13801 EMIT_INSTRUCTION, // 350 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13802 EMIT_INSTRUCTION, // 351 - stm: INT_ASTORE(INT_SUB(riv, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13803 EMIT_INSTRUCTION, // 352 - szpr: INT_USHR(riv, INT_AND(r, INT_CONSTANT)) 13804 EMIT_INSTRUCTION, // 353 - szpr: INT_USHR(riv, riv) 13805 EMIT_INSTRUCTION, // 354 - szpr: INT_USHR(riv, INT_CONSTANT) 13806 EMIT_INSTRUCTION, // 355 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13807 EMIT_INSTRUCTION, // 356 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13808 EMIT_INSTRUCTION, // 357 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13809 EMIT_INSTRUCTION, // 358 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13810 EMIT_INSTRUCTION, // 359 - szpr: INT_XOR(r, riv) 13811 EMIT_INSTRUCTION, // 360 - szpr: INT_XOR(r, load32) 13812 EMIT_INSTRUCTION, // 361 - szpr: INT_XOR(load32, riv) 13813 EMIT_INSTRUCTION, // 362 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13814 EMIT_INSTRUCTION, // 363 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13815 EMIT_INSTRUCTION, // 364 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 13816 EMIT_INSTRUCTION, // 365 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13817 EMIT_INSTRUCTION, // 366 - r: LCMP_CMOV(r, OTHER_OPERAND(rlv, any)) 13818 EMIT_INSTRUCTION, // 367 - r: LCMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 13819 EMIT_INSTRUCTION, // 368 - r: LCMP_CMOV(load64, OTHER_OPERAND(rlv, any)) 13820 EMIT_INSTRUCTION, // 369 - r: LCMP_CMOV(rlv, OTHER_OPERAND(load64, any)) 13821 EMIT_INSTRUCTION, // 370 - r: LONG_ADD(address1scaledreg, r) 13822 EMIT_INSTRUCTION, // 371 - r: LONG_ADD(r, address1scaledreg) 13823 EMIT_INSTRUCTION, // 372 - r: LONG_ADD(address1scaledreg, address1reg) 13824 EMIT_INSTRUCTION, // 373 - r: LONG_ADD(address1reg, address1scaledreg) 13825 EMIT_INSTRUCTION, // 374 - r: LONG_ADD(address, LONG_CONSTANT) 13826 EMIT_INSTRUCTION, // 375 - r: LONG_MOVE(address) 13827 EMIT_INSTRUCTION, // 376 - r: BYTE_LOAD(rlv, rlv) 13828 EMIT_INSTRUCTION, // 377 - sload8: BYTE_LOAD(rlv, rlv) 13829 EMIT_INSTRUCTION, // 378 - r: BYTE_ALOAD(rlv, riv) 13830 EMIT_INSTRUCTION, // 379 - r: BYTE_ALOAD(rlv, r) 13831 EMIT_INSTRUCTION, // 380 - sload8: BYTE_ALOAD(rlv, riv) 13832 EMIT_INSTRUCTION, // 381 - r: UBYTE_LOAD(rlv, rlv) 13833 EMIT_INSTRUCTION, // 382 - uload8: UBYTE_LOAD(rlv, rlv) 13834 EMIT_INSTRUCTION, // 383 - r: UBYTE_ALOAD(rlv, riv) 13835 EMIT_INSTRUCTION, // 384 - r: UBYTE_ALOAD(rlv, r) 13836 EMIT_INSTRUCTION, // 385 - uload8: UBYTE_ALOAD(rlv, riv) 13837 NOFLAGS, // 386 - load8: sload8 13838 NOFLAGS, // 387 - load8: uload8 13839 EMIT_INSTRUCTION, // 388 - r: SHORT_LOAD(rlv, rlv) 13840 EMIT_INSTRUCTION, // 389 - sload16: SHORT_LOAD(rlv, rlv) 13841 EMIT_INSTRUCTION, // 390 - r: SHORT_ALOAD(rlv, riv) 13842 EMIT_INSTRUCTION, // 391 - r: SHORT_ALOAD(rlv, r) 13843 EMIT_INSTRUCTION, // 392 - sload16: SHORT_ALOAD(rlv, riv) 13844 EMIT_INSTRUCTION, // 393 - r: USHORT_LOAD(rlv, rlv) 13845 EMIT_INSTRUCTION, // 394 - uload16: USHORT_LOAD(rlv, rlv) 13846 EMIT_INSTRUCTION, // 395 - r: USHORT_ALOAD(rlv, riv) 13847 EMIT_INSTRUCTION, // 396 - r: USHORT_ALOAD(rlv, r) 13848 EMIT_INSTRUCTION, // 397 - uload16: USHORT_ALOAD(rlv, riv) 13849 NOFLAGS, // 398 - load16: sload16 13850 NOFLAGS, // 399 - load16: uload16 13851 EMIT_INSTRUCTION, // 400 - load32: INT_LOAD(rlv, rlv) 13852 EMIT_INSTRUCTION, // 401 - load32: INT_ALOAD(rlv, riv) 13853 NOFLAGS, // 402 - load16_32: load16 13854 NOFLAGS, // 403 - load16_32: load32 13855 NOFLAGS, // 404 - load8_16_32: load16_32 13856 NOFLAGS, // 405 - load8_16_32: load8 13857 EMIT_INSTRUCTION, // 406 - load64: LONG_LOAD(rlv, rlv) 13858 EMIT_INSTRUCTION, // 407 - load64: LONG_ALOAD(rlv, rlv) 13859 EMIT_INSTRUCTION, // 408 - load64: LONG_ALOAD(rlv, r) 13860 NOFLAGS, // 409 - load8_16_32_64: load64 13861 NOFLAGS, // 410 - load8_16_32_64: load8_16_32 13862 EMIT_INSTRUCTION, // 411 - r: LONG_2INT(r) 13863 EMIT_INSTRUCTION, // 412 - stm: INT_STORE(LONG_2INT(r), OTHER_OPERAND(riv,riv)) 13864 EMIT_INSTRUCTION, // 413 - stm: INT_ASTORE(LONG_2INT(r), OTHER_OPERAND(riv, riv)) 13865 EMIT_INSTRUCTION, // 414 - r: LONG_2INT(load64) 13866 EMIT_INSTRUCTION, // 415 - load32: LONG_2INT(load64) 13867 EMIT_INSTRUCTION, // 416 - r: LONG_2INT(LONG_USHR(r, INT_CONSTANT)) 13868 EMIT_INSTRUCTION, // 417 - r: LONG_2INT(LONG_SHR(r, INT_CONSTANT)) 13869 EMIT_INSTRUCTION, // 418 - r: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 13870 EMIT_INSTRUCTION, // 419 - r: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 13871 EMIT_INSTRUCTION, // 420 - load32: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 13872 EMIT_INSTRUCTION, // 421 - load32: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 13873 EMIT_INSTRUCTION, // 422 - czr: LONG_ADD(r, rlv) 13874 EMIT_INSTRUCTION, // 423 - czr: LONG_ADD(r, riv) 13875 EMIT_INSTRUCTION, // 424 - czr: LONG_ADD(r,r) 13876 EMIT_INSTRUCTION, // 425 - r: LONG_ADD(r, rlv) 13877 EMIT_INSTRUCTION, // 426 - czr: LONG_ADD(rlv, load64) 13878 EMIT_INSTRUCTION, // 427 - czr: LONG_ADD(load64, rlv) 13879 EMIT_INSTRUCTION, // 428 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13880 EMIT_INSTRUCTION, // 429 - stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13881 EMIT_INSTRUCTION, // 430 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13882 EMIT_INSTRUCTION, // 431 - stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13883 EMIT_INSTRUCTION, // 432 - szpr: LONG_AND(r, rlv) 13884 EMIT_INSTRUCTION, // 433 - szpr: LONG_AND(r,r) 13885 EMIT_INSTRUCTION, // 434 - szp: LONG_AND(r, rlv) 13886 EMIT_INSTRUCTION, // 435 - szpr: LONG_AND(rlv, load64) 13887 EMIT_INSTRUCTION, // 436 - szpr: LONG_AND(load64, rlv) 13888 EMIT_INSTRUCTION, // 437 - szp: LONG_AND(load8_16_32_64, rlv) 13889 EMIT_INSTRUCTION, // 438 - szp: LONG_AND(r, load8_16_32_64) 13890 EMIT_INSTRUCTION, // 439 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13891 EMIT_INSTRUCTION, // 440 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13892 EMIT_INSTRUCTION, // 441 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13893 EMIT_INSTRUCTION, // 442 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13894 EMIT_INSTRUCTION, // 443 - r: LONG_DIV(rlv, rlv) 13895 EMIT_INSTRUCTION, // 444 - r: LONG_DIV(rlv, riv) 13896 EMIT_INSTRUCTION, // 445 - r: LONG_DIV(riv, rlv) 13897 EMIT_INSTRUCTION, // 446 - r: LONG_DIV(rlv, load64) 13898 EMIT_INSTRUCTION, // 447 - r: LONG_DIV(load64,rlv) 13899 EMIT_INSTRUCTION, // 448 - stm: LONG_IFCMP(rlv,rlv) 13900 EMIT_INSTRUCTION, // 449 - stm: LONG_IFCMP(r, LONG_CONSTANT) 13901 EMIT_INSTRUCTION, // 450 - r: LONG_LOAD(rlv, rlv) 13902 EMIT_INSTRUCTION, // 451 - r: LONG_LOAD(rlv, address1scaledreg) 13903 EMIT_INSTRUCTION, // 452 - r: LONG_LOAD(address1scaledreg, rlv) 13904 EMIT_INSTRUCTION, // 453 - r: LONG_LOAD(address1scaledreg, address1reg) 13905 EMIT_INSTRUCTION, // 454 - r: LONG_LOAD(address1reg, address1scaledreg) 13906 EMIT_INSTRUCTION, // 455 - r: LONG_LOAD(address, LONG_CONSTANT) 13907 EMIT_INSTRUCTION, // 456 - r: LONG_ALOAD(rlv, riv) 13908 EMIT_INSTRUCTION, // 457 - r: LONG_ALOAD(rlv, r) 13909 EMIT_INSTRUCTION, // 458 - r: LONG_MOVE(rlv) 13910 EMIT_INSTRUCTION, // 459 - r: LONG_MOVE(riv) 13911 NOFLAGS, // 460 - load64: LONG_MOVE(load64) 13912 EMIT_INSTRUCTION, // 461 - r: LONG_MUL(r, rlv) 13913 EMIT_INSTRUCTION, // 462 - r: INT_MUL(r, load64) 13914 EMIT_INSTRUCTION, // 463 - r: INT_MUL(load64, rlv) 13915 EMIT_INSTRUCTION, // 464 - szpr: LONG_NEG(r) 13916 EMIT_INSTRUCTION, // 465 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13917 EMIT_INSTRUCTION, // 466 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13918 EMIT_INSTRUCTION, // 467 - r: LONG_NOT(r) 13919 EMIT_INSTRUCTION, // 468 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13920 EMIT_INSTRUCTION, // 469 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13921 EMIT_INSTRUCTION, // 470 - szpr: LONG_OR(r, rlv) 13922 EMIT_INSTRUCTION, // 471 - szpr: LONG_OR(r, load64) 13923 EMIT_INSTRUCTION, // 472 - szpr: LONG_OR(load64, rlv) 13924 EMIT_INSTRUCTION, // 473 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13925 EMIT_INSTRUCTION, // 474 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13926 EMIT_INSTRUCTION, // 475 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13927 EMIT_INSTRUCTION, // 476 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13928 EMIT_INSTRUCTION, // 477 - r: LONG_REM(rlv, rlv) 13929 EMIT_INSTRUCTION, // 478 - r: LONG_REM(rlv, riv) 13930 EMIT_INSTRUCTION, // 479 - r: LONG_REM(riv, rlv) 13931 EMIT_INSTRUCTION, // 480 - r: LONG_REM(rlv, load64) 13932 EMIT_INSTRUCTION, // 481 - r: LONG_REM(load64,rlv) 13933 EMIT_INSTRUCTION, // 482 - szpr: LONG_SHL(rlv, INT_AND(r, INT_CONSTANT)) 13934 EMIT_INSTRUCTION, // 483 - szpr: LONG_SHL(rlv, riv) 13935 EMIT_INSTRUCTION, // 484 - szpr: LONG_SHL(r, INT_CONSTANT) 13936 EMIT_INSTRUCTION, // 485 - r: LONG_SHL(r, INT_CONSTANT) 13937 EMIT_INSTRUCTION, // 486 - szpr: LONG_SHL(LONG_SHR(r, INT_CONSTANT), INT_CONSTANT) 13938 EMIT_INSTRUCTION, // 487 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13939 EMIT_INSTRUCTION, // 488 - stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13940 EMIT_INSTRUCTION, // 489 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 13941 EMIT_INSTRUCTION, // 490 - stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 13942 EMIT_INSTRUCTION, // 491 - szpr: LONG_SHR(rlv, INT_AND(r, LONG_CONSTANT)) 13943 EMIT_INSTRUCTION, // 492 - szpr: LONG_SHR(rlv, riv) 13944 EMIT_INSTRUCTION, // 493 - szpr: LONG_SHR(rlv, LONG_CONSTANT) 13945 EMIT_INSTRUCTION, // 494 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 13946 EMIT_INSTRUCTION, // 495 - stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 13947 EMIT_INSTRUCTION, // 496 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r, LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 13948 EMIT_INSTRUCTION, // 497 - stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 13949 EMIT_INSTRUCTION, // 498 - stm: LONG_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 13950 EMIT_INSTRUCTION, // 499 - stm: LONG_STORE(rlv, OTHER_OPERAND(rlv, address1scaledreg)) 13951 EMIT_INSTRUCTION, // 500 - stm: LONG_STORE(rlv, OTHER_OPERAND(address1scaledreg, rlv)) 13952 EMIT_INSTRUCTION, // 501 - stm: LONG_STORE(rlv, OTHER_OPERAND(address1scaledreg, address1reg)) 13953 EMIT_INSTRUCTION, // 502 - stm: LONG_STORE(rlv, OTHER_OPERAND(address1reg, address1scaledreg)) 13954 EMIT_INSTRUCTION, // 503 - stm: LONG_STORE(rlv, OTHER_OPERAND(address, LONG_CONSTANT)) 13955 EMIT_INSTRUCTION, // 504 - czr: LONG_SUB(rlv, r) 13956 EMIT_INSTRUCTION, // 505 - r: LONG_SUB(rlv, r) 13957 EMIT_INSTRUCTION, // 506 - r: LONG_SUB(load64, r) 13958 EMIT_INSTRUCTION, // 507 - czr: LONG_SUB(rlv, load64) 13959 EMIT_INSTRUCTION, // 508 - czr: LONG_SUB(load64, rlv) 13960 EMIT_INSTRUCTION, // 509 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13961 EMIT_INSTRUCTION, // 510 - stm: LONG_STORE(LONG_SUB(rlv, LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13962 EMIT_INSTRUCTION, // 511 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13963 EMIT_INSTRUCTION, // 512 - stm: LONG_ASTORE(LONG_SUB(rlv, LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13964 EMIT_INSTRUCTION, // 513 - szpr: LONG_USHR(rlv, LONG_AND(r, LONG_CONSTANT)) 13965 EMIT_INSTRUCTION, // 514 - szpr: LONG_USHR(rlv, riv) 13966 EMIT_INSTRUCTION, // 515 - szpr: LONG_USHR(rlv, LONG_CONSTANT) 13967 EMIT_INSTRUCTION, // 516 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 13968 EMIT_INSTRUCTION, // 517 - stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 13969 EMIT_INSTRUCTION, // 518 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r, LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 13970 EMIT_INSTRUCTION, // 519 - stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 13971 EMIT_INSTRUCTION, // 520 - szpr: LONG_XOR(r, rlv) 13972 EMIT_INSTRUCTION, // 521 - szpr: LONG_XOR(r, load64) 13973 EMIT_INSTRUCTION, // 522 - szpr: LONG_XOR(load64, rlv) 13974 EMIT_INSTRUCTION, // 523 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13975 EMIT_INSTRUCTION, // 524 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13976 EMIT_INSTRUCTION, // 525 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 13977 EMIT_INSTRUCTION, // 526 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 13978 EMIT_INSTRUCTION, // 527 - r: FLOAT_ADD(r, r) 13979 EMIT_INSTRUCTION, // 528 - r: FLOAT_ADD(r, float_load) 13980 EMIT_INSTRUCTION, // 529 - r: FLOAT_ADD(float_load,r) 13981 EMIT_INSTRUCTION, // 530 - r: DOUBLE_ADD(r, r) 13982 EMIT_INSTRUCTION, // 531 - r: DOUBLE_ADD(r, double_load) 13983 EMIT_INSTRUCTION, // 532 - r: DOUBLE_ADD(double_load,r) 13984 EMIT_INSTRUCTION, // 533 - r: FLOAT_SUB(r, r) 13985 EMIT_INSTRUCTION, // 534 - r: FLOAT_SUB(r, float_load) 13986 EMIT_INSTRUCTION, // 535 - r: DOUBLE_SUB(r, r) 13987 EMIT_INSTRUCTION, // 536 - r: DOUBLE_SUB(r, double_load) 13988 EMIT_INSTRUCTION, // 537 - r: FLOAT_MUL(r, r) 13989 EMIT_INSTRUCTION, // 538 - r: FLOAT_MUL(r, float_load) 13990 EMIT_INSTRUCTION, // 539 - r: FLOAT_MUL(float_load, r) 13991 EMIT_INSTRUCTION, // 540 - r: DOUBLE_MUL(r, r) 13992 EMIT_INSTRUCTION, // 541 - r: DOUBLE_MUL(r, double_load) 13993 EMIT_INSTRUCTION, // 542 - r: DOUBLE_MUL(double_load, r) 13994 EMIT_INSTRUCTION, // 543 - r: FLOAT_DIV(r, r) 13995 EMIT_INSTRUCTION, // 544 - r: FLOAT_DIV(r, float_load) 13996 EMIT_INSTRUCTION, // 545 - r: DOUBLE_DIV(r, r) 13997 EMIT_INSTRUCTION, // 546 - r: DOUBLE_DIV(r, double_load) 13998 EMIT_INSTRUCTION, // 547 - r: FLOAT_NEG(r) 13999 EMIT_INSTRUCTION, // 548 - r: DOUBLE_NEG(r) 14000 EMIT_INSTRUCTION, // 549 - r: FLOAT_SQRT(r) 14001 EMIT_INSTRUCTION, // 550 - r: DOUBLE_SQRT(r) 14002 EMIT_INSTRUCTION, // 551 - r: FLOAT_REM(r, r) 14003 EMIT_INSTRUCTION, // 552 - r: DOUBLE_REM(r, r) 14004 EMIT_INSTRUCTION, // 553 - r: LONG_2FLOAT(r) 14005 EMIT_INSTRUCTION, // 554 - r: LONG_2DOUBLE(r) 14006 EMIT_INSTRUCTION, // 555 - r: FLOAT_MOVE(r) 14007 EMIT_INSTRUCTION, // 556 - r: DOUBLE_MOVE(r) 14008 EMIT_INSTRUCTION, // 557 - r: DOUBLE_LOAD(riv, riv) 14009 EMIT_INSTRUCTION, // 558 - r: DOUBLE_LOAD(riv, rlv) 14010 EMIT_INSTRUCTION, // 559 - r: DOUBLE_LOAD(rlv, rlv) 14011 EMIT_INSTRUCTION, // 560 - double_load: DOUBLE_LOAD(riv, riv) 14012 EMIT_INSTRUCTION, // 561 - r: DOUBLE_ALOAD(riv, riv) 14013 EMIT_INSTRUCTION, // 562 - double_load: DOUBLE_LOAD(rlv, rlv) 14014 EMIT_INSTRUCTION, // 563 - r: DOUBLE_ALOAD(riv, r) 14015 EMIT_INSTRUCTION, // 564 - r: DOUBLE_ALOAD(rlv, rlv) 14016 EMIT_INSTRUCTION, // 565 - double_load: DOUBLE_ALOAD(riv, riv) 14017 EMIT_INSTRUCTION, // 566 - r: FLOAT_LOAD(riv, riv) 14018 EMIT_INSTRUCTION, // 567 - r: FLOAT_LOAD(rlv, rlv) 14019 EMIT_INSTRUCTION, // 568 - float_load: FLOAT_LOAD(riv, riv) 14020 EMIT_INSTRUCTION, // 569 - r: FLOAT_ALOAD(riv, riv) 14021 EMIT_INSTRUCTION, // 570 - r: FLOAT_ALOAD(riv, r) 14022 EMIT_INSTRUCTION, // 571 - r: FLOAT_ALOAD(rlv, rlv) 14023 EMIT_INSTRUCTION, // 572 - float_load: FLOAT_ALOAD(riv, riv) 14024 EMIT_INSTRUCTION, // 573 - stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, riv)) 14025 EMIT_INSTRUCTION, // 574 - stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, rlv)) 14026 EMIT_INSTRUCTION, // 575 - stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, riv)) 14027 EMIT_INSTRUCTION, // 576 - stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, rlv)) 14028 EMIT_INSTRUCTION, // 577 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, riv)) 14029 EMIT_INSTRUCTION, // 578 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, riv)) 14030 EMIT_INSTRUCTION, // 579 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, rlv)) 14031 EMIT_INSTRUCTION, // 580 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 14032 EMIT_INSTRUCTION, // 581 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(r, r)) 14033 EMIT_INSTRUCTION, // 582 - stm: FLOAT_STORE(r, OTHER_OPERAND(riv, riv)) 14034 EMIT_INSTRUCTION, // 583 - stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, rlv)) 14035 EMIT_INSTRUCTION, // 584 - stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, riv)) 14036 EMIT_INSTRUCTION, // 585 - stm: FLOAT_STORE(r, OTHER_OPERAND(riv, rlv)) 14037 EMIT_INSTRUCTION, // 586 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, riv)) 14038 EMIT_INSTRUCTION, // 587 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, riv)) 14039 EMIT_INSTRUCTION, // 588 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, rlv)) 14040 EMIT_INSTRUCTION, // 589 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 14041 EMIT_INSTRUCTION, // 590 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(r, r)) 14042 EMIT_INSTRUCTION, // 591 - r: INT_2FLOAT(riv) 14043 EMIT_INSTRUCTION, // 592 - r: INT_2FLOAT(load32) 14044 EMIT_INSTRUCTION, // 593 - r: INT_2DOUBLE(riv) 14045 EMIT_INSTRUCTION, // 594 - r: INT_2DOUBLE(load32) 14046 EMIT_INSTRUCTION, // 595 - r: FLOAT_2DOUBLE(r) 14047 EMIT_INSTRUCTION, // 596 - r: FLOAT_2DOUBLE(float_load) 14048 EMIT_INSTRUCTION, // 597 - r: DOUBLE_2FLOAT(r) 14049 EMIT_INSTRUCTION, // 598 - r: DOUBLE_2FLOAT(double_load) 14050 EMIT_INSTRUCTION, // 599 - r: FLOAT_2INT(r) 14051 EMIT_INSTRUCTION, // 600 - r: FLOAT_2LONG(r) 14052 EMIT_INSTRUCTION, // 601 - r: DOUBLE_2INT(r) 14053 EMIT_INSTRUCTION, // 602 - r: DOUBLE_2LONG(r) 14054 EMIT_INSTRUCTION, // 603 - r: FLOAT_AS_INT_BITS(r) 14055 NOFLAGS, // 604 - load32: FLOAT_AS_INT_BITS(float_load) 14056 EMIT_INSTRUCTION, // 605 - r: DOUBLE_AS_LONG_BITS(r) 14057 NOFLAGS, // 606 - load64: DOUBLE_AS_LONG_BITS(double_load) 14058 EMIT_INSTRUCTION, // 607 - r: INT_BITS_AS_FLOAT(riv) 14059 NOFLAGS, // 608 - float_load: INT_BITS_AS_FLOAT(load32) 14060 EMIT_INSTRUCTION, // 609 - r: LONG_BITS_AS_DOUBLE(rlv) 14061 NOFLAGS, // 610 - double_load: LONG_BITS_AS_DOUBLE(load64) 14062 EMIT_INSTRUCTION, // 611 - r: MATERIALIZE_FP_CONSTANT(any) 14063 EMIT_INSTRUCTION, // 612 - float_load: MATERIALIZE_FP_CONSTANT(any) 14064 EMIT_INSTRUCTION, // 613 - double_load: MATERIALIZE_FP_CONSTANT(any) 14065 EMIT_INSTRUCTION, // 614 - stm: CLEAR_FLOATING_POINT_STATE 14066 EMIT_INSTRUCTION, // 615 - stm: FLOAT_IFCMP(r,r) 14067 EMIT_INSTRUCTION, // 616 - stm: FLOAT_IFCMP(r,float_load) 14068 EMIT_INSTRUCTION, // 617 - stm: FLOAT_IFCMP(float_load,r) 14069 EMIT_INSTRUCTION, // 618 - stm: DOUBLE_IFCMP(r,r) 14070 EMIT_INSTRUCTION, // 619 - stm: DOUBLE_IFCMP(r,double_load) 14071 EMIT_INSTRUCTION, // 620 - stm: DOUBLE_IFCMP(double_load,r) 14072 EMIT_INSTRUCTION, // 621 - r: FCMP_CMOV(r, OTHER_OPERAND(r, any)) 14073 EMIT_INSTRUCTION, // 622 - r: FCMP_CMOV(r, OTHER_OPERAND(float_load, any)) 14074 EMIT_INSTRUCTION, // 623 - r: FCMP_CMOV(r, OTHER_OPERAND(double_load, any)) 14075 EMIT_INSTRUCTION, // 624 - r: FCMP_CMOV(float_load, OTHER_OPERAND(r, any)) 14076 EMIT_INSTRUCTION, // 625 - r: FCMP_CMOV(double_load, OTHER_OPERAND(r, any)) 14077 EMIT_INSTRUCTION, // 626 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, any)) 14078 EMIT_INSTRUCTION, // 627 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, float_load))) 14079 EMIT_INSTRUCTION, // 628 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, double_load))) 14080 EMIT_INSTRUCTION, // 629 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(float_load, r))) 14081 EMIT_INSTRUCTION, // 630 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(double_load, r))) 14082 EMIT_INSTRUCTION, // 631 - r: FCMP_FCMOV(r, OTHER_OPERAND(float_load, any)) 14083 EMIT_INSTRUCTION, // 632 - r: FCMP_FCMOV(r, OTHER_OPERAND(double_load, any)) 14084 EMIT_INSTRUCTION, // 633 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 14085 EMIT_INSTRUCTION, // 634 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 14086 EMIT_INSTRUCTION, // 635 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 14087 EMIT_INSTRUCTION, // 636 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 14088 EMIT_INSTRUCTION, // 637 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 14089 EMIT_INSTRUCTION, // 638 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 14090 EMIT_INSTRUCTION, // 639 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 14091 EMIT_INSTRUCTION, // 640 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 14092 EMIT_INSTRUCTION, // 641 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 14093 EMIT_INSTRUCTION, // 642 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 14094 EMIT_INSTRUCTION, // 643 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 14095 EMIT_INSTRUCTION, // 644 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 14096 EMIT_INSTRUCTION, // 645 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 14097 EMIT_INSTRUCTION, // 646 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 14098 EMIT_INSTRUCTION, // 647 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 14099 EMIT_INSTRUCTION, // 648 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 14100 EMIT_INSTRUCTION, // 649 - stm: LONG_ASTORE(load64, OTHER_OPERAND(riv, riv)) 14101 EMIT_INSTRUCTION, // 650 - stm: LONG_ASTORE(load64, OTHER_OPERAND(rlv, riv)) 14102 EMIT_INSTRUCTION, // 651 - stm: LONG_STORE(load64, OTHER_OPERAND(riv, riv)) 14103 EMIT_INSTRUCTION, // 652 - stm: LONG_STORE(load64, OTHER_OPERAND(rlv, riv)) 14104 }; 14105 14106 /** 14107 * Gets the action flags (such as EMIT_INSTRUCTION) associated with the given 14108 * rule number. 14109 * 14110 * @param ruleno the rule number we want the action flags for 14111 * @return the action byte for the rule 14112 */ 14113 @Pure 14114 public static byte action(int ruleno) { 14115 return action[unsortedErnMap[ruleno]]; 14116 } 14117 14118 /** 14119 * Decode the target non-terminal and minimal cost covering statement 14120 * into the rule that produces the non-terminal 14121 * 14122 * @param goalnt the non-terminal that we wish to produce. 14123 * @param stateNT the state encoding the non-terminals associated associated 14124 * with covering a tree with minimal cost (computed by at compile time 14125 * by jburg). 14126 * @return the rule number 14127 */ 14128 @Pure 14129 public static char decode(int goalnt, int stateNT) { 14130 return decode[goalnt][stateNT]; 14131 } 14132 14133 14134 /** 14135 * Emit code for rule number 16: 14136 * stm: IG_PATCH_POINT 14137 * @param p BURS node to apply the rule to 14138 */ 14139 private void code16(AbstractBURS_TreeNode p) { 14140 EMIT(InlineGuard.mutate(P(p), IG_PATCH_POINT, null, null, null, InlineGuard.getTarget(P(p)), InlineGuard.getBranchProfile(P(p)))); 14141 } 14142 14143 /** 14144 * Emit code for rule number 17: 14145 * stm: UNINT_BEGIN 14146 * @param p BURS node to apply the rule to 14147 */ 14148 private void code17(AbstractBURS_TreeNode p) { 14149 EMIT(P(p)); 14150 } 14151 14152 /** 14153 * Emit code for rule number 18: 14154 * stm: UNINT_END 14155 * @param p BURS node to apply the rule to 14156 */ 14157 private void code18(AbstractBURS_TreeNode p) { 14158 EMIT(P(p)); 14159 } 14160 14161 /** 14162 * Emit code for rule number 19: 14163 * stm: YIELDPOINT_PROLOGUE 14164 * @param p BURS node to apply the rule to 14165 */ 14166 private void code19(AbstractBURS_TreeNode p) { 14167 EMIT(P(p)); 14168 } 14169 14170 /** 14171 * Emit code for rule number 20: 14172 * stm: YIELDPOINT_EPILOGUE 14173 * @param p BURS node to apply the rule to 14174 */ 14175 private void code20(AbstractBURS_TreeNode p) { 14176 EMIT(P(p)); 14177 } 14178 14179 /** 14180 * Emit code for rule number 21: 14181 * stm: YIELDPOINT_BACKEDGE 14182 * @param p BURS node to apply the rule to 14183 */ 14184 private void code21(AbstractBURS_TreeNode p) { 14185 EMIT(P(p)); 14186 } 14187 14188 /** 14189 * Emit code for rule number 22: 14190 * stm: LOWTABLESWITCH(r) 14191 * @param p BURS node to apply the rule to 14192 */ 14193 private void code22(AbstractBURS_TreeNode p) { 14194 LOWTABLESWITCH(P(p)); 14195 } 14196 14197 /** 14198 * Emit code for rule number 23: 14199 * stm: RESOLVE 14200 * @param p BURS node to apply the rule to 14201 */ 14202 private void code23(AbstractBURS_TreeNode p) { 14203 RESOLVE(P(p)); 14204 } 14205 14206 /** 14207 * Emit code for rule number 25: 14208 * r: GUARD_MOVE 14209 * @param p BURS node to apply the rule to 14210 */ 14211 private void code25(AbstractBURS_TreeNode p) { 14212 EMIT(P(p)); 14213 } 14214 14215 /** 14216 * Emit code for rule number 26: 14217 * r: GUARD_COMBINE 14218 * @param p BURS node to apply the rule to 14219 */ 14220 private void code26(AbstractBURS_TreeNode p) { 14221 EMIT(P(p)); 14222 } 14223 14224 /** 14225 * Emit code for rule number 27: 14226 * stm: NULL_CHECK(riv) 14227 * @param p BURS node to apply the rule to 14228 */ 14229 private void code27(AbstractBURS_TreeNode p) { 14230 EMIT(P(p)); 14231 } 14232 14233 /** 14234 * Emit code for rule number 28: 14235 * stm: IR_PROLOGUE 14236 * @param p BURS node to apply the rule to 14237 */ 14238 private void code28(AbstractBURS_TreeNode p) { 14239 PROLOGUE(P(p)); 14240 } 14241 14242 /** 14243 * Emit code for rule number 29: 14244 * r: GET_CAUGHT_EXCEPTION 14245 * @param p BURS node to apply the rule to 14246 */ 14247 private void code29(AbstractBURS_TreeNode p) { 14248 GET_EXCEPTION_OBJECT(P(p)); 14249 } 14250 14251 /** 14252 * Emit code for rule number 30: 14253 * stm: SET_CAUGHT_EXCEPTION(r) 14254 * @param p BURS node to apply the rule to 14255 */ 14256 private void code30(AbstractBURS_TreeNode p) { 14257 SET_EXCEPTION_OBJECT(P(p)); 14258 } 14259 14260 /** 14261 * Emit code for rule number 31: 14262 * stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 14263 * @param p BURS node to apply the rule to 14264 */ 14265 private void code31(AbstractBURS_TreeNode p) { 14266 SET_EXCEPTION_OBJECT(P(p)); 14267 } 14268 14269 /** 14270 * Emit code for rule number 32: 14271 * stm: TRAP 14272 * @param p BURS node to apply the rule to 14273 */ 14274 private void code32(AbstractBURS_TreeNode p) { 14275 EMIT(MIR_Trap.mutate(P(p), IA32_INT, Trap.getGuardResult(P(p)), Trap.getTCode(P(p)))); 14276 } 14277 14278 /** 14279 * Emit code for rule number 33: 14280 * stm: TRAP_IF(r, INT_CONSTANT) 14281 * @param p BURS node to apply the rule to 14282 */ 14283 private void code33(AbstractBURS_TreeNode p) { 14284 TRAP_IF_IMM(P(p), false); 14285 } 14286 14287 /** 14288 * Emit code for rule number 34: 14289 * stm: TRAP_IF(r, LONG_CONSTANT) 14290 * @param p BURS node to apply the rule to 14291 */ 14292 private void code34(AbstractBURS_TreeNode p) { 14293 TRAP_IF_IMM(P(p), true); 14294 } 14295 14296 /** 14297 * Emit code for rule number 35: 14298 * stm: TRAP_IF(r, r) 14299 * @param p BURS node to apply the rule to 14300 */ 14301 private void code35(AbstractBURS_TreeNode p) { 14302 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 14303 TrapIf.getGuardResult(P(p)), 14304 TrapIf.getVal1(P(p)), 14305 TrapIf.getVal2(P(p)), 14306 COND(TrapIf.getCond(P(p))), 14307 TrapIf.getTCode(P(p)))); 14308 } 14309 14310 /** 14311 * Emit code for rule number 36: 14312 * stm: TRAP_IF(load32, riv) 14313 * @param p BURS node to apply the rule to 14314 */ 14315 private void code36(AbstractBURS_TreeNode p) { 14316 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 14317 TrapIf.getGuardResult(P(p)), 14318 consumeMO(), 14319 TrapIf.getVal2(P(p)), 14320 COND(TrapIf.getCond(P(p))), 14321 TrapIf.getTCode(P(p)))); 14322 } 14323 14324 /** 14325 * Emit code for rule number 37: 14326 * stm: TRAP_IF(riv, load32) 14327 * @param p BURS node to apply the rule to 14328 */ 14329 private void code37(AbstractBURS_TreeNode p) { 14330 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 14331 TrapIf.getGuardResult(P(p)), 14332 TrapIf.getVal1(P(p)), 14333 consumeMO(), 14334 COND(TrapIf.getCond(P(p))), 14335 TrapIf.getTCode(P(p)))); 14336 } 14337 14338 /** 14339 * Emit code for rule number 38: 14340 * uload8: INT_AND(load8_16_32, INT_CONSTANT) 14341 * @param p BURS node to apply the rule to 14342 */ 14343 private void code38(AbstractBURS_TreeNode p) { 14344 pushMO(setSize(consumeMO(),1)); 14345 } 14346 14347 /** 14348 * Emit code for rule number 39: 14349 * r: INT_AND(load8_16_32, INT_CONSTANT) 14350 * @param p BURS node to apply the rule to 14351 */ 14352 private void code39(AbstractBURS_TreeNode p) { 14353 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Binary.getResult(P(p)), setSize(consumeMO(),1))); 14354 } 14355 14356 /** 14357 * Emit code for rule number 40: 14358 * r: INT_2BYTE(load8_16_32) 14359 * @param p BURS node to apply the rule to 14360 */ 14361 private void code40(AbstractBURS_TreeNode p) { 14362 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), setSize(consumeMO(),1))); 14363 } 14364 14365 /** 14366 * Emit code for rule number 41: 14367 * r: INT_USHR(INT_SHL(load8_16_32, INT_CONSTANT), INT_CONSTANT) 14368 * @param p BURS node to apply the rule to 14369 */ 14370 private void code41(AbstractBURS_TreeNode p) { 14371 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Binary.getResult(P(p)), setSize(consumeMO(),1))); 14372 } 14373 14374 /** 14375 * Emit code for rule number 42: 14376 * r: INT_AND(load16_32, INT_CONSTANT) 14377 * @param p BURS node to apply the rule to 14378 */ 14379 private void code42(AbstractBURS_TreeNode p) { 14380 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Binary.getResult(P(p)), setSize(consumeMO(),2))); 14381 } 14382 14383 /** 14384 * Emit code for rule number 43: 14385 * r: INT_USHR(INT_SHL(load16_32, INT_CONSTANT), INT_CONSTANT) 14386 * @param p BURS node to apply the rule to 14387 */ 14388 private void code43(AbstractBURS_TreeNode p) { 14389 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Binary.getResult(P(p)), setSize(consumeMO(),2))); 14390 } 14391 14392 /** 14393 * Emit code for rule number 44: 14394 * stm: SHORT_STORE(riv, OTHER_OPERAND(riv, riv)) 14395 * @param p BURS node to apply the rule to 14396 */ 14397 private void code44(AbstractBURS_TreeNode p) { 14398 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 14399 } 14400 14401 /** 14402 * Emit code for rule number 45: 14403 * stm: SHORT_STORE(load16, OTHER_OPERAND(riv, riv)) 14404 * @param p BURS node to apply the rule to 14405 */ 14406 private void code45(AbstractBURS_TreeNode p) { 14407 Register tmp = regpool.getInteger(); 14408EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 14409EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), new RegisterOperand(tmp, TypeReference.Int))); 14410 } 14411 14412 /** 14413 * Emit code for rule number 46: 14414 * stm: SHORT_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 14415 * @param p BURS node to apply the rule to 14416 */ 14417 private void code46(AbstractBURS_TreeNode p) { 14418 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 14419 } 14420 14421 /** 14422 * Emit code for rule number 47: 14423 * stm: SHORT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 14424 * @param p BURS node to apply the rule to 14425 */ 14426 private void code47(AbstractBURS_TreeNode p) { 14427 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 14428 } 14429 14430 /** 14431 * Emit code for rule number 48: 14432 * stm: SHORT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 14433 * @param p BURS node to apply the rule to 14434 */ 14435 private void code48(AbstractBURS_TreeNode p) { 14436 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 14437 } 14438 14439 /** 14440 * Emit code for rule number 49: 14441 * stm: SHORT_ASTORE(load16, OTHER_OPERAND(riv, riv)) 14442 * @param p BURS node to apply the rule to 14443 */ 14444 private void code49(AbstractBURS_TreeNode p) { 14445 Register tmp = regpool.getInteger(); 14446EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 14447EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), new RegisterOperand(tmp, TypeReference.Int))); 14448 } 14449 14450 /** 14451 * Emit code for rule number 50: 14452 * stm: SHORT_ASTORE(riv, OTHER_OPERAND(r, r)) 14453 * @param p BURS node to apply the rule to 14454 */ 14455 private void code50(AbstractBURS_TreeNode p) { 14456 RegisterOperand index = AStore.getIndex(P(p)).asRegister(); 14457if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 14458 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 14459 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 14460} else { 14461 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 14462} 14463 } 14464 14465 /** 14466 * Emit code for rule number 51: 14467 * stm: INT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 14468 * @param p BURS node to apply the rule to 14469 */ 14470 private void code51(AbstractBURS_TreeNode p) { 14471 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14472 } 14473 14474 /** 14475 * Emit code for rule number 52: 14476 * stm: INT_ASTORE(riv, OTHER_OPERAND(r, r)) 14477 * @param p BURS node to apply the rule to 14478 */ 14479 private void code52(AbstractBURS_TreeNode p) { 14480 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 14481if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 14482 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 14483 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14484} else { 14485 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14486} 14487 } 14488 14489 /** 14490 * Emit code for rule number 53: 14491 * stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, rlv)) 14492 * @param p BURS node to apply the rule to 14493 */ 14494 private void code53(AbstractBURS_TreeNode p) { 14495 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14496 } 14497 14498 /** 14499 * Emit code for rule number 54: 14500 * stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 14501 * @param p BURS node to apply the rule to 14502 */ 14503 private void code54(AbstractBURS_TreeNode p) { 14504 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14505 } 14506 14507 /** 14508 * Emit code for rule number 55: 14509 * stm: INT_ASTORE(riv, OTHER_OPERAND(riv, rlv)) 14510 * @param p BURS node to apply the rule to 14511 */ 14512 private void code55(AbstractBURS_TreeNode p) { 14513 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 14514 } 14515 14516 /** 14517 * Emit code for rule number 56: 14518 * stm: LONG_ASTORE(r, OTHER_OPERAND(riv, riv)) 14519 * @param p BURS node to apply the rule to 14520 */ 14521 private void code56(AbstractBURS_TreeNode p) { 14522 if (VM.BuildFor32Addr){ 14523 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 14524 hval.setType(TypeReference.Int); 14525 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 14526 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 14527 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 14528} else { 14529 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 14530} 14531 } 14532 14533 /** 14534 * Emit code for rule number 57: 14535 * stm: LONG_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 14536 * @param p BURS node to apply the rule to 14537 */ 14538 private void code57(AbstractBURS_TreeNode p) { 14539 if (VM.BuildFor32Addr) { 14540 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 14541 hval.setType(TypeReference.Int); 14542 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 14543 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 14544 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 14545} else { 14546 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 14547} 14548 } 14549 14550 /** 14551 * Emit code for rule number 58: 14552 * stm: LONG_ASTORE(r, OTHER_OPERAND(r, r)) 14553 * @param p BURS node to apply the rule to 14554 */ 14555 private void code58(AbstractBURS_TreeNode p) { 14556 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 14557if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 14558 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 14559} 14560if (VM.BuildFor32Addr) { 14561 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 14562 hval.setType(TypeReference.Int); 14563 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 14564 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 14565 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 14566} else { 14567 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 14568} 14569 } 14570 14571 /** 14572 * Emit code for rule number 59: 14573 * stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 14574 * @param p BURS node to apply the rule to 14575 */ 14576 private void code59(AbstractBURS_TreeNode p) { 14577 if (VM.BuildFor32Addr) { 14578 LongConstantOperand val = LC(AStore.getValue(P(p))); 14579 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), IC(val.upper32())))); 14580 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), IC(val.lower32()))); 14581} else { 14582 LongConstantOperand val = LC(AStore.getValue(P(p))); 14583 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), LC(val))); 14584} 14585 } 14586 14587 /** 14588 * Emit code for rule number 60: 14589 * stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(rlv, riv)) 14590 * @param p BURS node to apply the rule to 14591 */ 14592 private void code60(AbstractBURS_TreeNode p) { 14593 if (VM.BuildFor32Addr) { 14594 LongConstantOperand val = LC(AStore.getValue(P(p))); 14595 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), IC(val.upper32())))); 14596 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), IC(val.lower32()))); 14597} else { 14598 LongConstantOperand val = LC(AStore.getValue(P(p))); 14599 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), LC(val))); 14600} 14601 } 14602 14603 /** 14604 * Emit code for rule number 61: 14605 * r: LONG_CMP(rlv,rlv) 14606 * @param p BURS node to apply the rule to 14607 */ 14608 private void code61(AbstractBURS_TreeNode p) { 14609 LONG_CMP(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 14610 } 14611 14612 /** 14613 * Emit code for rule number 62: 14614 * stm: GOTO 14615 * @param p BURS node to apply the rule to 14616 */ 14617 private void code62(AbstractBURS_TreeNode p) { 14618 EMIT(MIR_Branch.mutate(P(p), IA32_JMP, Goto.getTarget(P(p)))); 14619 } 14620 14621 /** 14622 * Emit code for rule number 63: 14623 * stm: PREFETCH(r) 14624 * @param p BURS node to apply the rule to 14625 */ 14626 private void code63(AbstractBURS_TreeNode p) { 14627 EMIT(MIR_CacheOp.mutate(P(p), IA32_PREFETCHNTA, R(CacheOp.getRef(P(p))))); 14628 } 14629 14630 /** 14631 * Emit code for rule number 64: 14632 * stm: WRITE_FLOOR 14633 * @param p BURS node to apply the rule to 14634 */ 14635 private void code64(AbstractBURS_TreeNode p) { 14636 EMIT(P(p)); // Pass through to maintain barrier semantics for code motion 14637 } 14638 14639 /** 14640 * Emit code for rule number 65: 14641 * stm: READ_CEILING 14642 * @param p BURS node to apply the rule to 14643 */ 14644 private void code65(AbstractBURS_TreeNode p) { 14645 EMIT(P(p)); // Pass through to maintain barrier semantics for code motion 14646 } 14647 14648 /** 14649 * Emit code for rule number 66: 14650 * stm: FENCE 14651 * @param p BURS node to apply the rule to 14652 */ 14653 private void code66(AbstractBURS_TreeNode p) { 14654 EMIT(MIR_Empty.mutate(P(p), IA32_MFENCE)); 14655 } 14656 14657 /** 14658 * Emit code for rule number 67: 14659 * stm: PAUSE 14660 * @param p BURS node to apply the rule to 14661 */ 14662 private void code67(AbstractBURS_TreeNode p) { 14663 EMIT(MIR_Empty.mutate(P(p), IA32_PAUSE)); 14664 } 14665 14666 /** 14667 * Emit code for rule number 68: 14668 * stm: RETURN(NULL) 14669 * @param p BURS node to apply the rule to 14670 */ 14671 private void code68(AbstractBURS_TreeNode p) { 14672 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, null, null)); 14673 } 14674 14675 /** 14676 * Emit code for rule number 69: 14677 * stm: RETURN(INT_CONSTANT) 14678 * @param p BURS node to apply the rule to 14679 */ 14680 private void code69(AbstractBURS_TreeNode p) { 14681 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, Return.getVal(P(p)), null)); 14682 } 14683 14684 /** 14685 * Emit code for rule number 70: 14686 * stm: RETURN(r) 14687 * @param p BURS node to apply the rule to 14688 */ 14689 private void code70(AbstractBURS_TreeNode p) { 14690 RegisterOperand ret = R(Return.getVal(P(p))); 14691RegisterOperand ret2 = null; 14692if (VM.BuildFor32Addr && ret.getType().isLongType()) { 14693 ret.setType(TypeReference.Int); 14694 ret2 = new RegisterOperand(regpool.getSecondReg(ret.getRegister()), TypeReference.Int); 14695} 14696EMIT(MIR_Return.mutate(P(p), IA32_RET, null, ret, ret2)); 14697 } 14698 14699 /** 14700 * Emit code for rule number 71: 14701 * stm: RETURN(LONG_CONSTANT) 14702 * @param p BURS node to apply the rule to 14703 */ 14704 private void code71(AbstractBURS_TreeNode p) { 14705 LongConstantOperand val = LC(Return.getVal(P(p))); 14706if (VM.BuildFor32Addr) { 14707 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, IC(val.upper32()), IC(val.lower32()))); 14708} else { 14709 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, val, null)); 14710} 14711 } 14712 14713 /** 14714 * Emit code for rule number 72: 14715 * r: CALL(r, any) 14716 * @param p BURS node to apply the rule to 14717 */ 14718 private void code72(AbstractBURS_TreeNode p) { 14719 CALL(P(p), Call.getAddress(P(p))); 14720 } 14721 14722 /** 14723 * Emit code for rule number 73: 14724 * r: CALL(BRANCH_TARGET, any) 14725 * @param p BURS node to apply the rule to 14726 */ 14727 private void code73(AbstractBURS_TreeNode p) { 14728 CALL(P(p), Call.getAddress(P(p))); 14729 } 14730 14731 /** 14732 * Emit code for rule number 74: 14733 * r: CALL(INT_LOAD(riv, riv), any) 14734 * @param p BURS node to apply the rule to 14735 */ 14736 private void code74(AbstractBURS_TreeNode p) { 14737 CALL(P(p), MO_L(PL(p), DW)); 14738 } 14739 14740 /** 14741 * Emit code for rule number 75: 14742 * r: CALL(INT_CONSTANT, any) 14743 * @param p BURS node to apply the rule to 14744 */ 14745 private void code75(AbstractBURS_TreeNode p) { 14746 RegisterOperand temp = regpool.makeTemp(TypeReference.Int); 14747EMIT(MIR_Move.create(IA32_MOV, temp, Call.getAddress(P(p)))); 14748CALL(P(p), temp.copyRO()); 14749 } 14750 14751 /** 14752 * Emit code for rule number 76: 14753 * r: CALL(LONG_LOAD(rlv, rlv), any) 14754 * @param p BURS node to apply the rule to 14755 */ 14756 private void code76(AbstractBURS_TreeNode p) { 14757 CALL(P(p), MO_L(PL(p), QW)); 14758 } 14759 14760 /** 14761 * Emit code for rule number 77: 14762 * r: SYSCALL(r, any) 14763 * @param p BURS node to apply the rule to 14764 */ 14765 private void code77(AbstractBURS_TreeNode p) { 14766 SYSCALL(P(p), Call.getAddress(P(p))); 14767 } 14768 14769 /** 14770 * Emit code for rule number 78: 14771 * r: SYSCALL(INT_LOAD(riv, riv), any) 14772 * @param p BURS node to apply the rule to 14773 */ 14774 private void code78(AbstractBURS_TreeNode p) { 14775 SYSCALL(P(p), MO_L(PL(p), DW)); 14776 } 14777 14778 /** 14779 * Emit code for rule number 79: 14780 * r: SYSCALL(INT_CONSTANT, any) 14781 * @param p BURS node to apply the rule to 14782 */ 14783 private void code79(AbstractBURS_TreeNode p) { 14784 RegisterOperand temp = regpool.makeTemp(TypeReference.Int); 14785EMIT(MIR_Move.create(IA32_MOV, temp, Call.getAddress(P(p)))); 14786SYSCALL(P(p), temp.copyRO()); 14787 } 14788 14789 /** 14790 * Emit code for rule number 80: 14791 * r: GET_TIME_BASE 14792 * @param p BURS node to apply the rule to 14793 */ 14794 private void code80(AbstractBURS_TreeNode p) { 14795 GET_TIME_BASE(P(p), Nullary.getResult(P(p))); 14796 } 14797 14798 /** 14799 * Emit code for rule number 81: 14800 * stm: YIELDPOINT_OSR(any, any) 14801 * @param p BURS node to apply the rule to 14802 */ 14803 private void code81(AbstractBURS_TreeNode p) { 14804 OSR(burs, P(p)); 14805 } 14806 14807 /** 14808 * Emit code for rule number 84: 14809 * address1scaledreg: INT_SHL(r, INT_CONSTANT) 14810 * @param p BURS node to apply the rule to 14811 */ 14812 private void code84(AbstractBURS_TreeNode p) { 14813 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 14814 } 14815 14816 /** 14817 * Emit code for rule number 85: 14818 * address1reg: INT_ADD(r, LONG_CONSTANT) 14819 * @param p BURS node to apply the rule to 14820 */ 14821 private void code85(AbstractBURS_TreeNode p) { 14822 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromLong(LV(Binary.getVal2(P(p))))); 14823 } 14824 14825 /** 14826 * Emit code for rule number 86: 14827 * address1reg: INT_MOVE(r) 14828 * @param p BURS node to apply the rule to 14829 */ 14830 private void code86(AbstractBURS_TreeNode p) { 14831 pushAddress(R(Move.getVal(P(p))), null, B_S, Offset.zero()); 14832 } 14833 14834 /** 14835 * Emit code for rule number 87: 14836 * address: INT_ADD(r, r) 14837 * @param p BURS node to apply the rule to 14838 */ 14839 private void code87(AbstractBURS_TreeNode p) { 14840 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 14841 } 14842 14843 /** 14844 * Emit code for rule number 88: 14845 * address1reg: INT_ADD(address1reg, LONG_CONSTANT) 14846 * @param p BURS node to apply the rule to 14847 */ 14848 private void code88(AbstractBURS_TreeNode p) { 14849 augmentAddress(Binary.getVal2(P(p))); 14850 } 14851 14852 /** 14853 * Emit code for rule number 89: 14854 * address1scaledreg: INT_ADD(address1scaledreg, LONG_CONSTANT) 14855 * @param p BURS node to apply the rule to 14856 */ 14857 private void code89(AbstractBURS_TreeNode p) { 14858 augmentAddress(Binary.getVal2(P(p))); 14859 } 14860 14861 /** 14862 * Emit code for rule number 90: 14863 * address: INT_ADD(r, address1scaledreg) 14864 * @param p BURS node to apply the rule to 14865 */ 14866 private void code90(AbstractBURS_TreeNode p) { 14867 augmentAddress(Binary.getVal1(P(p))); 14868 } 14869 14870 /** 14871 * Emit code for rule number 91: 14872 * address: INT_ADD(address1scaledreg, r) 14873 * @param p BURS node to apply the rule to 14874 */ 14875 private void code91(AbstractBURS_TreeNode p) { 14876 augmentAddress(Binary.getVal2(P(p))); 14877 } 14878 14879 /** 14880 * Emit code for rule number 92: 14881 * address: INT_ADD(address1scaledreg, LONG_CONSTANT) 14882 * @param p BURS node to apply the rule to 14883 */ 14884 private void code92(AbstractBURS_TreeNode p) { 14885 augmentAddress(Binary.getVal2(P(p))); 14886 } 14887 14888 /** 14889 * Emit code for rule number 93: 14890 * address: INT_ADD(address1scaledreg, address1reg) 14891 * @param p BURS node to apply the rule to 14892 */ 14893 private void code93(AbstractBURS_TreeNode p) { 14894 combineAddresses(); 14895 } 14896 14897 /** 14898 * Emit code for rule number 94: 14899 * address: INT_ADD(address1reg, address1scaledreg) 14900 * @param p BURS node to apply the rule to 14901 */ 14902 private void code94(AbstractBURS_TreeNode p) { 14903 combineAddresses(); 14904 } 14905 14906 /** 14907 * Emit code for rule number 95: 14908 * address1scaledreg: LONG_SHL(r, INT_CONSTANT) 14909 * @param p BURS node to apply the rule to 14910 */ 14911 private void code95(AbstractBURS_TreeNode p) { 14912 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 14913 } 14914 14915 /** 14916 * Emit code for rule number 96: 14917 * address1reg: LONG_ADD(r, LONG_CONSTANT) 14918 * @param p BURS node to apply the rule to 14919 */ 14920 private void code96(AbstractBURS_TreeNode p) { 14921 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromLong(LV(Binary.getVal2(P(p))))); 14922 } 14923 14924 /** 14925 * Emit code for rule number 97: 14926 * address1reg: LONG_MOVE(r) 14927 * @param p BURS node to apply the rule to 14928 */ 14929 private void code97(AbstractBURS_TreeNode p) { 14930 pushAddress(R(Move.getVal(P(p))), null, B_S, Offset.zero()); 14931 } 14932 14933 /** 14934 * Emit code for rule number 98: 14935 * address: LONG_ADD(r, r) 14936 * @param p BURS node to apply the rule to 14937 */ 14938 private void code98(AbstractBURS_TreeNode p) { 14939 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 14940 } 14941 14942 /** 14943 * Emit code for rule number 99: 14944 * address1reg: LONG_ADD(address1reg, LONG_CONSTANT) 14945 * @param p BURS node to apply the rule to 14946 */ 14947 private void code99(AbstractBURS_TreeNode p) { 14948 augmentAddress(Binary.getVal2(P(p))); 14949 } 14950 14951 /** 14952 * Emit code for rule number 100: 14953 * address1scaledreg: LONG_ADD(address1scaledreg, LONG_CONSTANT) 14954 * @param p BURS node to apply the rule to 14955 */ 14956 private void code100(AbstractBURS_TreeNode p) { 14957 augmentAddress(Binary.getVal2(P(p))); 14958 } 14959 14960 /** 14961 * Emit code for rule number 101: 14962 * address: LONG_ADD(r, address1scaledreg) 14963 * @param p BURS node to apply the rule to 14964 */ 14965 private void code101(AbstractBURS_TreeNode p) { 14966 augmentAddress(Binary.getVal1(P(p))); 14967 } 14968 14969 /** 14970 * Emit code for rule number 102: 14971 * address: LONG_ADD(address1scaledreg, r) 14972 * @param p BURS node to apply the rule to 14973 */ 14974 private void code102(AbstractBURS_TreeNode p) { 14975 augmentAddress(Binary.getVal2(P(p))); 14976 } 14977 14978 /** 14979 * Emit code for rule number 103: 14980 * address: LONG_ADD(address1scaledreg, LONG_CONSTANT) 14981 * @param p BURS node to apply the rule to 14982 */ 14983 private void code103(AbstractBURS_TreeNode p) { 14984 augmentAddress(Binary.getVal2(P(p))); 14985 } 14986 14987 /** 14988 * Emit code for rule number 104: 14989 * address: LONG_ADD(address1scaledreg, address1reg) 14990 * @param p BURS node to apply the rule to 14991 */ 14992 private void code104(AbstractBURS_TreeNode p) { 14993 combineAddresses(); 14994 } 14995 14996 /** 14997 * Emit code for rule number 105: 14998 * address: LONG_ADD(address1reg, address1scaledreg) 14999 * @param p BURS node to apply the rule to 15000 */ 15001 private void code105(AbstractBURS_TreeNode p) { 15002 combineAddresses(); 15003 } 15004 15005 /** 15006 * Emit code for rule number 106: 15007 * r: ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv, riv))) 15008 * @param p BURS node to apply the rule to 15009 */ 15010 private void code106(AbstractBURS_TreeNode p) { 15011 ATTEMPT(Attempt.getResult(P(p)), 15012 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15013 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15014 } 15015 15016 /** 15017 * Emit code for rule number 107: 15018 * r: ATTEMPT_INT(riv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 15019 * @param p BURS node to apply the rule to 15020 */ 15021 private void code107(AbstractBURS_TreeNode p) { 15022 ATTEMPT(Attempt.getResult(P(p)), 15023 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15024 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15025 } 15026 15027 /** 15028 * Emit code for rule number 108: 15029 * r: ATTEMPT_INT(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 15030 * @param p BURS node to apply the rule to 15031 */ 15032 private void code108(AbstractBURS_TreeNode p) { 15033 ATTEMPT(Attempt.getResult(P(p)), 15034 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15035 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15036 } 15037 15038 /** 15039 * Emit code for rule number 109: 15040 * r: ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 15041 * @param p BURS node to apply the rule to 15042 */ 15043 private void code109(AbstractBURS_TreeNode p) { 15044 augmentAddress(Attempt.getAddress(P(p))); 15045ATTEMPT(Attempt.getResult(P(p)), 15046 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15047 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15048 } 15049 15050 /** 15051 * Emit code for rule number 110: 15052 * r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv, riv))) 15053 * @param p BURS node to apply the rule to 15054 */ 15055 private void code110(AbstractBURS_TreeNode p) { 15056 augmentAddress(Attempt.getOffset(P(p))); 15057ATTEMPT(Attempt.getResult(P(p)), 15058 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15059 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15060 } 15061 15062 /** 15063 * Emit code for rule number 111: 15064 * r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv, riv))) 15065 * @param p BURS node to apply the rule to 15066 */ 15067 private void code111(AbstractBURS_TreeNode p) { 15068 combineAddresses(); 15069ATTEMPT(Attempt.getResult(P(p)), 15070 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15071 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15072 } 15073 15074 /** 15075 * Emit code for rule number 112: 15076 * r: ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 15077 * @param p BURS node to apply the rule to 15078 */ 15079 private void code112(AbstractBURS_TreeNode p) { 15080 combineAddresses(); 15081ATTEMPT(Attempt.getResult(P(p)), 15082 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15083 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15084 } 15085 15086 /** 15087 * Emit code for rule number 113: 15088 * r: ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv, riv))) 15089 * @param p BURS node to apply the rule to 15090 */ 15091 private void code113(AbstractBURS_TreeNode p) { 15092 augmentAddress(Attempt.getOffset(P(p))); 15093ATTEMPT(Attempt.getResult(P(p)), 15094 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15095 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15096 } 15097 15098 /** 15099 * Emit code for rule number 114: 15100 * r: ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv, riv))) 15101 * @param p BURS node to apply the rule to 15102 */ 15103 private void code114(AbstractBURS_TreeNode p) { 15104 augmentAddress(Attempt.getAddress(P(p))); 15105ATTEMPT(Attempt.getResult(P(p)), 15106 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15107 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15108 } 15109 15110 /** 15111 * Emit code for rule number 115: 15112 * stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15113 * @param p BURS node to apply the rule to 15114 */ 15115 private void code115(AbstractBURS_TreeNode p) { 15116 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15117 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15118 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15119 } 15120 15121 /** 15122 * Emit code for rule number 116: 15123 * stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15124 * @param p BURS node to apply the rule to 15125 */ 15126 private void code116(AbstractBURS_TreeNode p) { 15127 augmentAddress(Attempt.getAddress(PL(p))); 15128ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15129 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15130 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15131 } 15132 15133 /** 15134 * Emit code for rule number 117: 15135 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15136 * @param p BURS node to apply the rule to 15137 */ 15138 private void code117(AbstractBURS_TreeNode p) { 15139 augmentAddress(Attempt.getOffset(PL(p))); 15140ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15141 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15142 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15143 } 15144 15145 /** 15146 * Emit code for rule number 118: 15147 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15148 * @param p BURS node to apply the rule to 15149 */ 15150 private void code118(AbstractBURS_TreeNode p) { 15151 combineAddresses(); 15152ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15153 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15154 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15155 } 15156 15157 /** 15158 * Emit code for rule number 119: 15159 * stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15160 * @param p BURS node to apply the rule to 15161 */ 15162 private void code119(AbstractBURS_TreeNode p) { 15163 combineAddresses(); 15164ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15165 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15166 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15167 } 15168 15169 /** 15170 * Emit code for rule number 120: 15171 * stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15172 * @param p BURS node to apply the rule to 15173 */ 15174 private void code120(AbstractBURS_TreeNode p) { 15175 augmentAddress(Attempt.getOffset(PL(p))); 15176ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15177 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15178 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15179 } 15180 15181 /** 15182 * Emit code for rule number 121: 15183 * stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15184 * @param p BURS node to apply the rule to 15185 */ 15186 private void code121(AbstractBURS_TreeNode p) { 15187 augmentAddress(Attempt.getAddress(PL(p))); 15188ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15189 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15190 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15191 } 15192 15193 /** 15194 * Emit code for rule number 122: 15195 * stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))), INT_CONSTANT) 15196 * @param p BURS node to apply the rule to 15197 */ 15198 private void code122(AbstractBURS_TreeNode p) { 15199 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15200 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15201 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15202 } 15203 15204 /** 15205 * Emit code for rule number 123: 15206 * stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15207 * @param p BURS node to apply the rule to 15208 */ 15209 private void code123(AbstractBURS_TreeNode p) { 15210 augmentAddress(Attempt.getAddress(PL(p))); 15211ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15212 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15213 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15214 } 15215 15216 /** 15217 * Emit code for rule number 124: 15218 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15219 * @param p BURS node to apply the rule to 15220 */ 15221 private void code124(AbstractBURS_TreeNode p) { 15222 augmentAddress(Attempt.getOffset(PL(p))); 15223ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15224 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15225 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15226 } 15227 15228 /** 15229 * Emit code for rule number 125: 15230 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15231 * @param p BURS node to apply the rule to 15232 */ 15233 private void code125(AbstractBURS_TreeNode p) { 15234 combineAddresses(); 15235ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15236 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15237 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15238 } 15239 15240 /** 15241 * Emit code for rule number 126: 15242 * stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15243 * @param p BURS node to apply the rule to 15244 */ 15245 private void code126(AbstractBURS_TreeNode p) { 15246 combineAddresses(); 15247ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15248 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15249 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15250 } 15251 15252 /** 15253 * Emit code for rule number 127: 15254 * stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15255 * @param p BURS node to apply the rule to 15256 */ 15257 private void code127(AbstractBURS_TreeNode p) { 15258 augmentAddress(Attempt.getOffset(PL(p))); 15259ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15260 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15261 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15262 } 15263 15264 /** 15265 * Emit code for rule number 128: 15266 * stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 15267 * @param p BURS node to apply the rule to 15268 */ 15269 private void code128(AbstractBURS_TreeNode p) { 15270 augmentAddress(Attempt.getAddress(PL(p))); 15271ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15272 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15273 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15274 } 15275 15276 /** 15277 * Emit code for rule number 129: 15278 * r: ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv, rlv))) 15279 * @param p BURS node to apply the rule to 15280 */ 15281 private void code129(AbstractBURS_TreeNode p) { 15282 ATTEMPT(Attempt.getResult(P(p)), 15283 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15284 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15285 } 15286 15287 /** 15288 * Emit code for rule number 130: 15289 * r: ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv, rlv))) 15290 * @param p BURS node to apply the rule to 15291 */ 15292 private void code130(AbstractBURS_TreeNode p) { 15293 augmentAddress(Attempt.getAddress(P(p))); 15294ATTEMPT(Attempt.getResult(P(p)), 15295 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15296 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15297 } 15298 15299 /** 15300 * Emit code for rule number 131: 15301 * r: ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv, rlv))) 15302 * @param p BURS node to apply the rule to 15303 */ 15304 private void code131(AbstractBURS_TreeNode p) { 15305 augmentAddress(Attempt.getOffset(P(p))); 15306ATTEMPT(Attempt.getResult(P(p)), 15307 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15308 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15309 } 15310 15311 /** 15312 * Emit code for rule number 132: 15313 * r: ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv, rlv))) 15314 * @param p BURS node to apply the rule to 15315 */ 15316 private void code132(AbstractBURS_TreeNode p) { 15317 combineAddresses(); 15318ATTEMPT(Attempt.getResult(P(p)), 15319 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15320 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15321 } 15322 15323 /** 15324 * Emit code for rule number 133: 15325 * r: ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv, rlv))) 15326 * @param p BURS node to apply the rule to 15327 */ 15328 private void code133(AbstractBURS_TreeNode p) { 15329 combineAddresses(); 15330ATTEMPT(Attempt.getResult(P(p)), 15331 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15332 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15333 } 15334 15335 /** 15336 * Emit code for rule number 134: 15337 * r: ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv, rlv))) 15338 * @param p BURS node to apply the rule to 15339 */ 15340 private void code134(AbstractBURS_TreeNode p) { 15341 augmentAddress(Attempt.getOffset(P(p))); 15342ATTEMPT(Attempt.getResult(P(p)), 15343 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15344 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15345 } 15346 15347 /** 15348 * Emit code for rule number 135: 15349 * r: ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv, rlv))) 15350 * @param p BURS node to apply the rule to 15351 */ 15352 private void code135(AbstractBURS_TreeNode p) { 15353 augmentAddress(Attempt.getAddress(P(p))); 15354ATTEMPT(Attempt.getResult(P(p)), 15355 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 15356 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 15357 } 15358 15359 /** 15360 * Emit code for rule number 136: 15361 * stm: INT_IFCMP(ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15362 * @param p BURS node to apply the rule to 15363 */ 15364 private void code136(AbstractBURS_TreeNode p) { 15365 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15366 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15367 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15368 } 15369 15370 /** 15371 * Emit code for rule number 137: 15372 * stm: INT_IFCMP(ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15373 * @param p BURS node to apply the rule to 15374 */ 15375 private void code137(AbstractBURS_TreeNode p) { 15376 augmentAddress(Attempt.getAddress(PL(p))); 15377ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15378 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15379 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15380 } 15381 15382 /** 15383 * Emit code for rule number 138: 15384 * stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15385 * @param p BURS node to apply the rule to 15386 */ 15387 private void code138(AbstractBURS_TreeNode p) { 15388 augmentAddress(Attempt.getOffset(PL(p))); 15389ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15390 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15391 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15392 } 15393 15394 /** 15395 * Emit code for rule number 139: 15396 * stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15397 * @param p BURS node to apply the rule to 15398 */ 15399 private void code139(AbstractBURS_TreeNode p) { 15400 combineAddresses(); 15401ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15402 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15403 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15404 } 15405 15406 /** 15407 * Emit code for rule number 140: 15408 * stm: INT_IFCMP(ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15409 * @param p BURS node to apply the rule to 15410 */ 15411 private void code140(AbstractBURS_TreeNode p) { 15412 combineAddresses(); 15413ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15414 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15415 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15416 } 15417 15418 /** 15419 * Emit code for rule number 141: 15420 * stm: INT_IFCMP(ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15421 * @param p BURS node to apply the rule to 15422 */ 15423 private void code141(AbstractBURS_TreeNode p) { 15424 augmentAddress(Attempt.getOffset(PL(p))); 15425ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15426 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15427 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15428 } 15429 15430 /** 15431 * Emit code for rule number 142: 15432 * stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15433 * @param p BURS node to apply the rule to 15434 */ 15435 private void code142(AbstractBURS_TreeNode p) { 15436 augmentAddress(Attempt.getAddress(PL(p))); 15437ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15438 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15439 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15440 } 15441 15442 /** 15443 * Emit code for rule number 143: 15444 * stm: INT_IFCMP(ATTEMPT_LONG(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(rlv,rlv))), INT_CONSTANT) 15445 * @param p BURS node to apply the rule to 15446 */ 15447 private void code143(AbstractBURS_TreeNode p) { 15448 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15449 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15450 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15451 } 15452 15453 /** 15454 * Emit code for rule number 144: 15455 * stm: INT_IFCMP(ATTEMPT_LONG(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15456 * @param p BURS node to apply the rule to 15457 */ 15458 private void code144(AbstractBURS_TreeNode p) { 15459 augmentAddress(Attempt.getAddress(PL(p))); 15460ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15461 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15462 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15463 } 15464 15465 /** 15466 * Emit code for rule number 145: 15467 * stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15468 * @param p BURS node to apply the rule to 15469 */ 15470 private void code145(AbstractBURS_TreeNode p) { 15471 augmentAddress(Attempt.getOffset(PL(p))); 15472ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15473 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15474 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15475 } 15476 15477 /** 15478 * Emit code for rule number 146: 15479 * stm: INT_IFCMP(ATTEMPT_LONG(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15480 * @param p BURS node to apply the rule to 15481 */ 15482 private void code146(AbstractBURS_TreeNode p) { 15483 combineAddresses(); 15484ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15485 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15486 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15487 } 15488 15489 /** 15490 * Emit code for rule number 147: 15491 * stm: INT_IFCMP(ATTEMPT_LONG(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15492 * @param p BURS node to apply the rule to 15493 */ 15494 private void code147(AbstractBURS_TreeNode p) { 15495 combineAddresses(); 15496ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15497 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15498 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15499 } 15500 15501 /** 15502 * Emit code for rule number 148: 15503 * stm: INT_IFCMP(ATTEMPT_LONG(address, OTHER_OPERAND(LONG_CONSTANT, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15504 * @param p BURS node to apply the rule to 15505 */ 15506 private void code148(AbstractBURS_TreeNode p) { 15507 augmentAddress(Attempt.getOffset(PL(p))); 15508ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15509 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15510 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15511 } 15512 15513 /** 15514 * Emit code for rule number 149: 15515 * stm: INT_IFCMP(ATTEMPT_LONG(LONG_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(rlv,rlv))),INT_CONSTANT) 15516 * @param p BURS node to apply the rule to 15517 */ 15518 private void code149(AbstractBURS_TreeNode p) { 15519 augmentAddress(Attempt.getAddress(PL(p))); 15520ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 15521 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 15522 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 15523 } 15524 15525 /** 15526 * Emit code for rule number 150: 15527 * bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 15528 * @param p BURS node to apply the rule to 15529 */ 15530 private void code150(AbstractBURS_TreeNode p) { 15531 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), Binary.getVal1(PLR(p)).copy())); 15532 } 15533 15534 /** 15535 * Emit code for rule number 151: 15536 * bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 15537 * @param p BURS node to apply the rule to 15538 */ 15539 private void code151(AbstractBURS_TreeNode p) { 15540 Register tmp = regpool.getInteger(); 15541if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 15542EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 15543EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 15544EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 15545 } 15546 15547 /** 15548 * Emit code for rule number 152: 15549 * bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 15550 * @param p BURS node to apply the rule to 15551 */ 15552 private void code152(AbstractBURS_TreeNode p) { 15553 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), IC(VLR(p)))); 15554 } 15555 15556 /** 15557 * Emit code for rule number 153: 15558 * bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 15559 * @param p BURS node to apply the rule to 15560 */ 15561 private void code153(AbstractBURS_TreeNode p) { 15562 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), Binary.getVal1(PLR(p)).copy())); 15563 } 15564 15565 /** 15566 * Emit code for rule number 154: 15567 * bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 15568 * @param p BURS node to apply the rule to 15569 */ 15570 private void code154(AbstractBURS_TreeNode p) { 15571 Register tmp = regpool.getInteger(); 15572if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 15573EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 15574EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 15575EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 15576 } 15577 15578 /** 15579 * Emit code for rule number 155: 15580 * bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 15581 * @param p BURS node to apply the rule to 15582 */ 15583 private void code155(AbstractBURS_TreeNode p) { 15584 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), IC(VLR(p)))); 15585 } 15586 15587 /** 15588 * Emit code for rule number 156: 15589 * bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 15590 * @param p BURS node to apply the rule to 15591 */ 15592 private void code156(AbstractBURS_TreeNode p) { 15593 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal2(P(p)), Binary.getVal1(PLR(p)).copy())); 15594 } 15595 15596 /** 15597 * Emit code for rule number 157: 15598 * bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT)),load32) 15599 * @param p BURS node to apply the rule to 15600 */ 15601 private void code157(AbstractBURS_TreeNode p) { 15602 Register tmp = regpool.getInteger(); 15603if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 15604EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 15605EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 15606EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 15607 } 15608 15609 /** 15610 * Emit code for rule number 158: 15611 * bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 15612 * @param p BURS node to apply the rule to 15613 */ 15614 private void code158(AbstractBURS_TreeNode p) { 15615 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(P(p)), Binary.getVal1(PRR(p)).copy())); 15616 } 15617 15618 /** 15619 * Emit code for rule number 159: 15620 * bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 15621 * @param p BURS node to apply the rule to 15622 */ 15623 private void code159(AbstractBURS_TreeNode p) { 15624 Register tmp = regpool.getInteger(); 15625if (VM.VerifyAssertions) VM._assert((VRRR(p) & 0x7FFFFFFF) <= 31); 15626EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PRR(p))))); 15627EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VRRR(p))))); 15628EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 15629 } 15630 15631 /** 15632 * Emit code for rule number 160: 15633 * r: BOOLEAN_CMP_INT(r,riv) 15634 * @param p BURS node to apply the rule to 15635 */ 15636 private void code160(AbstractBURS_TreeNode p) { 15637 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), 15638 BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), 15639 BooleanCmp.getCond(P(p))); 15640 } 15641 15642 /** 15643 * Emit code for rule number 161: 15644 * boolcmp: BOOLEAN_CMP_INT(r,riv) 15645 * @param p BURS node to apply the rule to 15646 */ 15647 private void code161(AbstractBURS_TreeNode p) { 15648 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15649pushCOND(cond); 15650EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p))); 15651 } 15652 15653 /** 15654 * Emit code for rule number 162: 15655 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 15656 * @param p BURS node to apply the rule to 15657 */ 15658 private void code162(AbstractBURS_TreeNode p) { 15659 EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 15660BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 15661 } 15662 15663 /** 15664 * Emit code for rule number 163: 15665 * boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 15666 * @param p BURS node to apply the rule to 15667 */ 15668 private void code163(AbstractBURS_TreeNode p) { 15669 pushCOND(BooleanCmp.getCond(P(p))); 15670EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 15671 } 15672 15673 /** 15674 * Emit code for rule number 164: 15675 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 15676 * @param p BURS node to apply the rule to 15677 */ 15678 private void code164(AbstractBURS_TreeNode p) { 15679 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getVal1(P(p)), IC(31)); 15680 } 15681 15682 /** 15683 * Emit code for rule number 165: 15684 * r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 15685 * @param p BURS node to apply the rule to 15686 */ 15687 private void code165(AbstractBURS_TreeNode p) { 15688 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), consumeMO(), IC(31)); 15689 } 15690 15691 /** 15692 * Emit code for rule number 166: 15693 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 15694 * @param p BURS node to apply the rule to 15695 */ 15696 private void code166(AbstractBURS_TreeNode p) { 15697 RegisterOperand result = BooleanCmp.getResult(P(p)); 15698EMIT_Commutative(IA32_SHR, P(p), result, BooleanCmp.getVal1(P(p)), IC(31)); 15699EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 15700 } 15701 15702 /** 15703 * Emit code for rule number 167: 15704 * r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 15705 * @param p BURS node to apply the rule to 15706 */ 15707 private void code167(AbstractBURS_TreeNode p) { 15708 RegisterOperand result = BooleanCmp.getResult(P(p)); 15709EMIT_Commutative(IA32_SHR, P(p), result, consumeMO(), IC(31)); 15710EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 15711 } 15712 15713 /** 15714 * Emit code for rule number 168: 15715 * r: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 15716 * @param p BURS node to apply the rule to 15717 */ 15718 private void code168(AbstractBURS_TreeNode p) { 15719 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 15720 } 15721 15722 /** 15723 * Emit code for rule number 169: 15724 * boolcmp: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 15725 * @param p BURS node to apply the rule to 15726 */ 15727 private void code169(AbstractBURS_TreeNode p) { 15728 pushCOND(BooleanCmp.getCond(P(p))); 15729 } 15730 15731 /** 15732 * Emit code for rule number 170: 15733 * r: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 15734 * @param p BURS node to apply the rule to 15735 */ 15736 private void code170(AbstractBURS_TreeNode p) { 15737 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 15738 } 15739 15740 /** 15741 * Emit code for rule number 171: 15742 * boolcmp: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 15743 * @param p BURS node to apply the rule to 15744 */ 15745 private void code171(AbstractBURS_TreeNode p) { 15746 pushCOND(BooleanCmp.getCond(P(p))); 15747 } 15748 15749 /** 15750 * Emit code for rule number 172: 15751 * r: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 15752 * @param p BURS node to apply the rule to 15753 */ 15754 private void code172(AbstractBURS_TreeNode p) { 15755 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BIT_TEST(VR(p),BooleanCmp.getCond(P(p)))); 15756 } 15757 15758 /** 15759 * Emit code for rule number 173: 15760 * boolcmp: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 15761 * @param p BURS node to apply the rule to 15762 */ 15763 private void code173(AbstractBURS_TreeNode p) { 15764 pushCOND(BIT_TEST(VR(p),BooleanCmp.getCond(P(p)))); 15765 } 15766 15767 /** 15768 * Emit code for rule number 174: 15769 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 15770 * @param p BURS node to apply the rule to 15771 */ 15772 private void code174(AbstractBURS_TreeNode p) { 15773 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), consumeCOND()); 15774 } 15775 15776 /** 15777 * Emit code for rule number 176: 15778 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 15779 * @param p BURS node to apply the rule to 15780 */ 15781 private void code176(AbstractBURS_TreeNode p) { 15782 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), consumeCOND().flipCode()); 15783 } 15784 15785 /** 15786 * Emit code for rule number 177: 15787 * boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 15788 * @param p BURS node to apply the rule to 15789 */ 15790 private void code177(AbstractBURS_TreeNode p) { 15791 pushCOND(consumeCOND().flipCode()); // invert already pushed condition 15792 } 15793 15794 /** 15795 * Emit code for rule number 178: 15796 * r: BOOLEAN_CMP_INT(load32,riv) 15797 * @param p BURS node to apply the rule to 15798 */ 15799 private void code178(AbstractBURS_TreeNode p) { 15800 BOOLEAN_CMP_INT(PL(p), BooleanCmp.getResult(P(p)), 15801 consumeMO(), BooleanCmp.getVal2(P(p)), 15802 BooleanCmp.getCond(P(p))); 15803 } 15804 15805 /** 15806 * Emit code for rule number 179: 15807 * boolcmp: BOOLEAN_CMP_INT(load32,riv) 15808 * @param p BURS node to apply the rule to 15809 */ 15810 private void code179(AbstractBURS_TreeNode p) { 15811 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15812pushCOND(cond); 15813EMIT_Compare(P(p), cond, consumeMO(), BooleanCmp.getVal2(P(p))); 15814 } 15815 15816 /** 15817 * Emit code for rule number 180: 15818 * r: BOOLEAN_CMP_INT(r,load32) 15819 * @param p BURS node to apply the rule to 15820 */ 15821 private void code180(AbstractBURS_TreeNode p) { 15822 BOOLEAN_CMP_INT(PR(p), BooleanCmp.getResult(P(p)), 15823 BooleanCmp.getVal1(P(p)), consumeMO(), 15824 BooleanCmp.getCond(P(p))); 15825 } 15826 15827 /** 15828 * Emit code for rule number 181: 15829 * boolcmp: BOOLEAN_CMP_INT(riv,load32) 15830 * @param p BURS node to apply the rule to 15831 */ 15832 private void code181(AbstractBURS_TreeNode p) { 15833 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15834pushCOND(cond); 15835EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), consumeMO()); 15836 } 15837 15838 /** 15839 * Emit code for rule number 182: 15840 * stm: BYTE_STORE(boolcmp, OTHER_OPERAND(riv,riv)) 15841 * @param p BURS node to apply the rule to 15842 */ 15843 private void code182(AbstractBURS_TreeNode p) { 15844 EMIT(MIR_Set.mutate(P(p), IA32_SET__B, MO_S(P(p),B), COND(consumeCOND()))); 15845 } 15846 15847 /** 15848 * Emit code for rule number 183: 15849 * stm: BYTE_ASTORE(boolcmp, OTHER_OPERAND(riv, riv)) 15850 * @param p BURS node to apply the rule to 15851 */ 15852 private void code183(AbstractBURS_TreeNode p) { 15853 EMIT(MIR_Set.mutate(P(p), IA32_SET__B, MO_AS(P(p),B_S,B), COND(consumeCOND()))); 15854 } 15855 15856 /** 15857 * Emit code for rule number 184: 15858 * r: BOOLEAN_CMP_LONG(r,rlv) 15859 * @param p BURS node to apply the rule to 15860 */ 15861 private void code184(AbstractBURS_TreeNode p) { 15862 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), 15863 BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), 15864 BooleanCmp.getCond(P(p))); 15865 } 15866 15867 /** 15868 * Emit code for rule number 185: 15869 * boolcmp: BOOLEAN_CMP_LONG(r,rlv) 15870 * @param p BURS node to apply the rule to 15871 */ 15872 private void code185(AbstractBURS_TreeNode p) { 15873 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15874pushCOND(cond); 15875EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p))); 15876 } 15877 15878 /** 15879 * Emit code for rule number 186: 15880 * r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 15881 * @param p BURS node to apply the rule to 15882 */ 15883 private void code186(AbstractBURS_TreeNode p) { 15884 EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 15885BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 15886 } 15887 15888 /** 15889 * Emit code for rule number 187: 15890 * boolcmp: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 15891 * @param p BURS node to apply the rule to 15892 */ 15893 private void code187(AbstractBURS_TreeNode p) { 15894 pushCOND(BooleanCmp.getCond(P(p))); 15895EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 15896 } 15897 15898 /** 15899 * Emit code for rule number 188: 15900 * r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 15901 * @param p BURS node to apply the rule to 15902 */ 15903 private void code188(AbstractBURS_TreeNode p) { 15904 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getVal1(P(p)), IC(63)); 15905 } 15906 15907 /** 15908 * Emit code for rule number 189: 15909 * r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 15910 * @param p BURS node to apply the rule to 15911 */ 15912 private void code189(AbstractBURS_TreeNode p) { 15913 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), consumeMO(), IC(63)); 15914 } 15915 15916 /** 15917 * Emit code for rule number 190: 15918 * r: BOOLEAN_CMP_LONG(r,LONG_CONSTANT) 15919 * @param p BURS node to apply the rule to 15920 */ 15921 private void code190(AbstractBURS_TreeNode p) { 15922 RegisterOperand result = BooleanCmp.getResult(P(p)); 15923EMIT_Commutative(IA32_SHR, P(p), result, BooleanCmp.getVal1(P(p)), IC(63)); 15924EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 15925 } 15926 15927 /** 15928 * Emit code for rule number 191: 15929 * r: BOOLEAN_CMP_LONG(load64,LONG_CONSTANT) 15930 * @param p BURS node to apply the rule to 15931 */ 15932 private void code191(AbstractBURS_TreeNode p) { 15933 RegisterOperand result = BooleanCmp.getResult(P(p)); 15934EMIT_Commutative(IA32_SHR, P(p), result, consumeMO(), IC(63)); 15935EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 15936 } 15937 15938 /** 15939 * Emit code for rule number 192: 15940 * r: BOOLEAN_CMP_LONG(cz, LONG_CONSTANT) 15941 * @param p BURS node to apply the rule to 15942 */ 15943 private void code192(AbstractBURS_TreeNode p) { 15944 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 15945 } 15946 15947 /** 15948 * Emit code for rule number 193: 15949 * r: BOOLEAN_CMP_LONG(load64,rlv) 15950 * @param p BURS node to apply the rule to 15951 */ 15952 private void code193(AbstractBURS_TreeNode p) { 15953 BOOLEAN_CMP_INT(PL(p), BooleanCmp.getResult(P(p)), 15954 consumeMO(), BooleanCmp.getVal2(P(p)), 15955 BooleanCmp.getCond(P(p))); 15956 } 15957 15958 /** 15959 * Emit code for rule number 194: 15960 * boolcmp: BOOLEAN_CMP_LONG(load64,rlv) 15961 * @param p BURS node to apply the rule to 15962 */ 15963 private void code194(AbstractBURS_TreeNode p) { 15964 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15965pushCOND(cond); 15966EMIT_Compare(P(p), cond, consumeMO(), BooleanCmp.getVal2(P(p))); 15967 } 15968 15969 /** 15970 * Emit code for rule number 195: 15971 * r: BOOLEAN_CMP_LONG(r,load64) 15972 * @param p BURS node to apply the rule to 15973 */ 15974 private void code195(AbstractBURS_TreeNode p) { 15975 BOOLEAN_CMP_INT(PR(p), BooleanCmp.getResult(P(p)), 15976 BooleanCmp.getVal1(P(p)), consumeMO(), 15977 BooleanCmp.getCond(P(p))); 15978 } 15979 15980 /** 15981 * Emit code for rule number 196: 15982 * boolcmp: BOOLEAN_CMP_LONG(rlv,load64) 15983 * @param p BURS node to apply the rule to 15984 */ 15985 private void code196(AbstractBURS_TreeNode p) { 15986 ConditionOperand cond = BooleanCmp.getCond(P(p)); 15987pushCOND(cond); 15988EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), consumeMO()); 15989 } 15990 15991 /** 15992 * Emit code for rule number 197: 15993 * r: BOOLEAN_NOT(r) 15994 * @param p BURS node to apply the rule to 15995 */ 15996 private void code197(AbstractBURS_TreeNode p) { 15997 EMIT_Commutative(IA32_XOR, P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), IC(1)); 15998 } 15999 16000 /** 16001 * Emit code for rule number 198: 16002 * stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16003 * @param p BURS node to apply the rule to 16004 */ 16005 private void code198(AbstractBURS_TreeNode p) { 16006 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), B), MO_S(P(p), B), IC(1)); 16007 } 16008 16009 /** 16010 * Emit code for rule number 199: 16011 * stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(rlv,riv)),OTHER_OPERAND(rlv, riv)) 16012 * @param p BURS node to apply the rule to 16013 */ 16014 private void code199(AbstractBURS_TreeNode p) { 16015 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), B_S, B), MO_AS(P(p), B_S, B), IC(1)); 16016 } 16017 16018 /** 16019 * Emit code for rule number 200: 16020 * stm: BYTE_STORE(riv, OTHER_OPERAND(rlv, rlv)) 16021 * @param p BURS node to apply the rule to 16022 */ 16023 private void code200(AbstractBURS_TreeNode p) { 16024 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), Store.getValue(P(p)))); 16025 } 16026 16027 /** 16028 * Emit code for rule number 201: 16029 * stm: BYTE_STORE(load8, OTHER_OPERAND(rlv, rlv)) 16030 * @param p BURS node to apply the rule to 16031 */ 16032 private void code201(AbstractBURS_TreeNode p) { 16033 Register tmp = regpool.getInteger(); 16034EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 16035EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), new RegisterOperand(tmp, TypeReference.Int))); 16036 } 16037 16038 /** 16039 * Emit code for rule number 202: 16040 * stm: BYTE_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 16041 * @param p BURS node to apply the rule to 16042 */ 16043 private void code202(AbstractBURS_TreeNode p) { 16044 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), AStore.getValue(P(p)))); 16045 } 16046 16047 /** 16048 * Emit code for rule number 203: 16049 * stm: BYTE_ASTORE(load8, OTHER_OPERAND(rlv, riv)) 16050 * @param p BURS node to apply the rule to 16051 */ 16052 private void code203(AbstractBURS_TreeNode p) { 16053 Register tmp = regpool.getInteger(); 16054EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 16055EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), new RegisterOperand(tmp, TypeReference.Int))); 16056 } 16057 16058 /** 16059 * Emit code for rule number 204: 16060 * r: CMP_CMOV(r, OTHER_OPERAND(riv, any)) 16061 * @param p BURS node to apply the rule to 16062 */ 16063 private void code204(AbstractBURS_TreeNode p) { 16064 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, CondMove.getVal1(P(p)), CondMove.getVal2(P(p))))); 16065CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16066 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16067 } 16068 16069 /** 16070 * Emit code for rule number 205: 16071 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 16072 * @param p BURS node to apply the rule to 16073 */ 16074 private void code205(AbstractBURS_TreeNode p) { 16075 EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, CondMove.getVal1(P(p)), CondMove.getVal1(P(p)).copy()))); 16076CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16077 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16078 } 16079 16080 /** 16081 * Emit code for rule number 206: 16082 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 16083 * @param p BURS node to apply the rule to 16084 */ 16085 private void code206(AbstractBURS_TreeNode p) { 16086 EMIT_Commutative(IA32_SAR, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), IC(31)); 16087 } 16088 16089 /** 16090 * Emit code for rule number 207: 16091 * r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 16092 * @param p BURS node to apply the rule to 16093 */ 16094 private void code207(AbstractBURS_TreeNode p) { 16095 EMIT_Commutative(IA32_SAR, P(p), CondMove.getResult(P(p)), consumeMO(), IC(31)); 16096 } 16097 16098 /** 16099 * Emit code for rule number 208: 16100 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 16101 * @param p BURS node to apply the rule to 16102 */ 16103 private void code208(AbstractBURS_TreeNode p) { 16104 RegisterOperand result = CondMove.getResult(P(p)); 16105EMIT_Commutative(IA32_SAR, P(p), result, CondMove.getVal1(P(p)), IC(31)); 16106EMIT(CPOS(P(p),MIR_UnaryAcc.create(IA32_NOT, result.copyRO()))); 16107 } 16108 16109 /** 16110 * Emit code for rule number 209: 16111 * r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 16112 * @param p BURS node to apply the rule to 16113 */ 16114 private void code209(AbstractBURS_TreeNode p) { 16115 RegisterOperand result = CondMove.getResult(P(p)); 16116EMIT_Commutative(IA32_SAR, P(p), result, consumeMO(), IC(31)); 16117EMIT(CPOS(P(p),MIR_UnaryAcc.create(IA32_NOT, result.copyRO()))); 16118 } 16119 16120 /** 16121 * Emit code for rule number 210: 16122 * r: CMP_CMOV(load8, OTHER_OPERAND(INT_CONSTANT, any)) 16123 * @param p BURS node to apply the rule to 16124 */ 16125 private void code210(AbstractBURS_TreeNode p) { 16126 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 16127CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16128 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16129 } 16130 16131 /** 16132 * Emit code for rule number 211: 16133 * r: CMP_CMOV(uload8, OTHER_OPERAND(riv, any)) 16134 * @param p BURS node to apply the rule to 16135 */ 16136 private void code211(AbstractBURS_TreeNode p) { 16137 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 16138CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16139 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16140 } 16141 16142 /** 16143 * Emit code for rule number 212: 16144 * r: CMP_CMOV(riv, OTHER_OPERAND(uload8, any)) 16145 * @param p BURS node to apply the rule to 16146 */ 16147 private void code212(AbstractBURS_TreeNode p) { 16148 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 16149CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16150 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16151 } 16152 16153 /** 16154 * Emit code for rule number 213: 16155 * r: CMP_CMOV(sload16, OTHER_OPERAND(INT_CONSTANT, any)) 16156 * @param p BURS node to apply the rule to 16157 */ 16158 private void code213(AbstractBURS_TreeNode p) { 16159 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 16160CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16161 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16162 } 16163 16164 /** 16165 * Emit code for rule number 214: 16166 * r: CMP_CMOV(load32, OTHER_OPERAND(riv, any)) 16167 * @param p BURS node to apply the rule to 16168 */ 16169 private void code214(AbstractBURS_TreeNode p) { 16170 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 16171CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16172 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16173 } 16174 16175 /** 16176 * Emit code for rule number 215: 16177 * r: CMP_CMOV(riv, OTHER_OPERAND(load32, any)) 16178 * @param p BURS node to apply the rule to 16179 */ 16180 private void code215(AbstractBURS_TreeNode p) { 16181 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal1(P(p))))); 16182CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).flipOperands(), 16183 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16184 } 16185 16186 /** 16187 * Emit code for rule number 216: 16188 * r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 16189 * @param p BURS node to apply the rule to 16190 */ 16191 private void code216(AbstractBURS_TreeNode p) { 16192 CMOV_MOV(P(p), CondMove.getResult(P(p)), consumeCOND(), 16193 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16194 } 16195 16196 /** 16197 * Emit code for rule number 217: 16198 * r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 16199 * @param p BURS node to apply the rule to 16200 */ 16201 private void code217(AbstractBURS_TreeNode p) { 16202 CMOV_MOV(P(p), CondMove.getResult(P(p)), consumeCOND().flipCode(), 16203 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16204 } 16205 16206 /** 16207 * Emit code for rule number 218: 16208 * r: CMP_CMOV(bittest, OTHER_OPERAND(INT_CONSTANT, any)) 16209 * @param p BURS node to apply the rule to 16210 */ 16211 private void code218(AbstractBURS_TreeNode p) { 16212 CMOV_MOV(P(p), CondMove.getResult(P(p)), BIT_TEST(VRL(p), CondMove.getCond(P(p))), 16213 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16214 } 16215 16216 /** 16217 * Emit code for rule number 219: 16218 * r: CMP_CMOV(cz, OTHER_OPERAND(INT_CONSTANT, any)) 16219 * @param p BURS node to apply the rule to 16220 */ 16221 private void code219(AbstractBURS_TreeNode p) { 16222 CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16223 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16224 } 16225 16226 /** 16227 * Emit code for rule number 220: 16228 * r: CMP_CMOV(szp, OTHER_OPERAND(INT_CONSTANT, any)) 16229 * @param p BURS node to apply the rule to 16230 */ 16231 private void code220(AbstractBURS_TreeNode p) { 16232 CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 16233 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 16234 } 16235 16236 /** 16237 * Emit code for rule number 221: 16238 * r: INT_2BYTE(r) 16239 * @param p BURS node to apply the rule to 16240 */ 16241 private void code221(AbstractBURS_TreeNode p) { 16242 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), Unary.getVal(P(p)))); 16243 } 16244 16245 /** 16246 * Emit code for rule number 222: 16247 * r: INT_2BYTE(load8_16_32) 16248 * @param p BURS node to apply the rule to 16249 */ 16250 private void code222(AbstractBURS_TreeNode p) { 16251 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), consumeMO())); 16252 } 16253 16254 /** 16255 * Emit code for rule number 223: 16256 * stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 16257 * @param p BURS node to apply the rule to 16258 */ 16259 private void code223(AbstractBURS_TreeNode p) { 16260 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), Unary.getVal(PL(p)))); 16261 } 16262 16263 /** 16264 * Emit code for rule number 224: 16265 * stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 16266 * @param p BURS node to apply the rule to 16267 */ 16268 private void code224(AbstractBURS_TreeNode p) { 16269 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), Unary.getVal(PL(p)))); 16270 } 16271 16272 /** 16273 * Emit code for rule number 225: 16274 * r: INT_2LONG(r) 16275 * @param p BURS node to apply the rule to 16276 */ 16277 private void code225(AbstractBURS_TreeNode p) { 16278 INT_2LONG(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), true); 16279 } 16280 16281 /** 16282 * Emit code for rule number 226: 16283 * r: INT_2LONG(load32) 16284 * @param p BURS node to apply the rule to 16285 */ 16286 private void code226(AbstractBURS_TreeNode p) { 16287 INT_2LONG(P(p), Unary.getResult(P(p)), consumeMO(), true); 16288 } 16289 16290 /** 16291 * Emit code for rule number 227: 16292 * r: LONG_AND(INT_2LONG(r), LONG_CONSTANT) 16293 * @param p BURS node to apply the rule to 16294 */ 16295 private void code227(AbstractBURS_TreeNode p) { 16296 INT_2LONG(P(p), Binary.getResult(P(p)), Unary.getVal(PL(p)), false); 16297 } 16298 16299 /** 16300 * Emit code for rule number 228: 16301 * r: LONG_AND(INT_2LONG(load32), LONG_CONSTANT) 16302 * @param p BURS node to apply the rule to 16303 */ 16304 private void code228(AbstractBURS_TreeNode p) { 16305 INT_2LONG(P(p), Binary.getResult(P(p)), consumeMO(), false); 16306 } 16307 16308 /** 16309 * Emit code for rule number 229: 16310 * r: INT_2ADDRZerExt(r) 16311 * @param p BURS node to apply the rule to 16312 */ 16313 private void code229(AbstractBURS_TreeNode p) { 16314 INT_2LONG(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), false); 16315 } 16316 16317 /** 16318 * Emit code for rule number 230: 16319 * r: INT_2SHORT(r) 16320 * @param p BURS node to apply the rule to 16321 */ 16322 private void code230(AbstractBURS_TreeNode p) { 16323 if (VM.BuildFor32Addr) { 16324EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Unary.getResult(P(p)), Unary.getVal(P(p)))); 16325} else { 16326EMIT(MIR_Unary.mutate(P(p), IA32_MOVSXQ__W, Unary.getResult(P(p)), Unary.getVal(P(p)))); 16327} 16328 } 16329 16330 /** 16331 * Emit code for rule number 231: 16332 * r: INT_2SHORT(load16_32) 16333 * @param p BURS node to apply the rule to 16334 */ 16335 private void code231(AbstractBURS_TreeNode p) { 16336 if (VM.BuildFor32Addr) { 16337EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Unary.getResult(P(p)), setSize(consumeMO(), 2))); 16338} else { 16339EMIT(MIR_Unary.mutate(P(p), IA32_MOVSXQ__W, Unary.getResult(P(p)), setSize(consumeMO(), 2))); 16340} 16341 } 16342 16343 /** 16344 * Emit code for rule number 232: 16345 * sload16: INT_2SHORT(load16_32) 16346 * @param p BURS node to apply the rule to 16347 */ 16348 private void code232(AbstractBURS_TreeNode p) { 16349 pushMO(setSize(consumeMO(),2)); 16350 } 16351 16352 /** 16353 * Emit code for rule number 233: 16354 * stm: SHORT_STORE(INT_2SHORT(r), OTHER_OPERAND(riv,riv)) 16355 * @param p BURS node to apply the rule to 16356 */ 16357 private void code233(AbstractBURS_TreeNode p) { 16358 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Unary.getVal(PL(p)))); 16359 } 16360 16361 /** 16362 * Emit code for rule number 234: 16363 * stm: SHORT_ASTORE(INT_2SHORT(r), OTHER_OPERAND(riv, riv)) 16364 * @param p BURS node to apply the rule to 16365 */ 16366 private void code234(AbstractBURS_TreeNode p) { 16367 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), Unary.getVal(PL(p)))); 16368 } 16369 16370 /** 16371 * Emit code for rule number 235: 16372 * szpr: INT_2USHORT(r) 16373 * @param p BURS node to apply the rule to 16374 */ 16375 private void code235(AbstractBURS_TreeNode p) { 16376 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, Unary.getResult(P(p)), Unary.getVal(P(p))))); 16377EMIT(MIR_BinaryAcc.mutate(P(p), IA32_AND, Unary.getResult(P(p)).copyRO(), IC(0xFFFF))); 16378 } 16379 16380 /** 16381 * Emit code for rule number 236: 16382 * uload16: INT_2USHORT(load16_32) 16383 * @param p BURS node to apply the rule to 16384 */ 16385 private void code236(AbstractBURS_TreeNode p) { 16386 pushMO(setSize(consumeMO(),2)); 16387 } 16388 16389 /** 16390 * Emit code for rule number 237: 16391 * r: INT_2USHORT(load16_32) 16392 * @param p BURS node to apply the rule to 16393 */ 16394 private void code237(AbstractBURS_TreeNode p) { 16395 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Unary.getResult(P(p)), setSize(consumeMO(),2))); 16396 } 16397 16398 /** 16399 * Emit code for rule number 238: 16400 * stm: SHORT_STORE(INT_2USHORT(r), OTHER_OPERAND(riv,riv)) 16401 * @param p BURS node to apply the rule to 16402 */ 16403 private void code238(AbstractBURS_TreeNode p) { 16404 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Unary.getVal(PL(p)))); 16405 } 16406 16407 /** 16408 * Emit code for rule number 239: 16409 * stm: SHORT_ASTORE(INT_2USHORT(r), OTHER_OPERAND(riv, riv)) 16410 * @param p BURS node to apply the rule to 16411 */ 16412 private void code239(AbstractBURS_TreeNode p) { 16413 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), Unary.getVal(PL(p)))); 16414 } 16415 16416 /** 16417 * Emit code for rule number 240: 16418 * czr: INT_ADD(r, riv) 16419 * @param p BURS node to apply the rule to 16420 */ 16421 private void code240(AbstractBURS_TreeNode p) { 16422 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16423 } 16424 16425 /** 16426 * Emit code for rule number 241: 16427 * r: INT_ADD(r, riv) 16428 * @param p BURS node to apply the rule to 16429 */ 16430 private void code241(AbstractBURS_TreeNode p) { 16431 if (Binary.getVal2(P(p)).isIntConstant()) { 16432 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromIntSignExtend(VR(p))); 16433} else { 16434 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 16435} 16436EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 16437 } 16438 16439 /** 16440 * Emit code for rule number 242: 16441 * czr: INT_ADD(r, load32) 16442 * @param p BURS node to apply the rule to 16443 */ 16444 private void code242(AbstractBURS_TreeNode p) { 16445 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16446 } 16447 16448 /** 16449 * Emit code for rule number 243: 16450 * czr: INT_ADD(load32, riv) 16451 * @param p BURS node to apply the rule to 16452 */ 16453 private void code243(AbstractBURS_TreeNode p) { 16454 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16455 } 16456 16457 /** 16458 * Emit code for rule number 244: 16459 * stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16460 * @param p BURS node to apply the rule to 16461 */ 16462 private void code244(AbstractBURS_TreeNode p) { 16463 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p))); 16464 } 16465 16466 /** 16467 * Emit code for rule number 245: 16468 * stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16469 * @param p BURS node to apply the rule to 16470 */ 16471 private void code245(AbstractBURS_TreeNode p) { 16472 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p))); 16473 } 16474 16475 /** 16476 * Emit code for rule number 246: 16477 * stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16478 * @param p BURS node to apply the rule to 16479 */ 16480 private void code246(AbstractBURS_TreeNode p) { 16481 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p))); 16482 } 16483 16484 /** 16485 * Emit code for rule number 247: 16486 * stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16487 * @param p BURS node to apply the rule to 16488 */ 16489 private void code247(AbstractBURS_TreeNode p) { 16490 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p))); 16491 } 16492 16493 /** 16494 * Emit code for rule number 248: 16495 * szpr: INT_AND(r, riv) 16496 * @param p BURS node to apply the rule to 16497 */ 16498 private void code248(AbstractBURS_TreeNode p) { 16499 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16500 } 16501 16502 /** 16503 * Emit code for rule number 249: 16504 * szp: INT_AND(r, riv) 16505 * @param p BURS node to apply the rule to 16506 */ 16507 private void code249(AbstractBURS_TreeNode p) { 16508 EMIT(MIR_Test.mutate(P(p), IA32_TEST, Binary.getVal1(P(p)), Binary.getVal2(P(p)))); 16509 } 16510 16511 /** 16512 * Emit code for rule number 250: 16513 * szpr: INT_AND(r, load32) 16514 * @param p BURS node to apply the rule to 16515 */ 16516 private void code250(AbstractBURS_TreeNode p) { 16517 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16518 } 16519 16520 /** 16521 * Emit code for rule number 251: 16522 * szpr: INT_AND(load32, riv) 16523 * @param p BURS node to apply the rule to 16524 */ 16525 private void code251(AbstractBURS_TreeNode p) { 16526 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16527 } 16528 16529 /** 16530 * Emit code for rule number 252: 16531 * szp: INT_AND(load8_16_32, riv) 16532 * @param p BURS node to apply the rule to 16533 */ 16534 private void code252(AbstractBURS_TreeNode p) { 16535 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal2(P(p)))); 16536 } 16537 16538 /** 16539 * Emit code for rule number 253: 16540 * szp: INT_AND(r, load8_16_32) 16541 * @param p BURS node to apply the rule to 16542 */ 16543 private void code253(AbstractBURS_TreeNode p) { 16544 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal1(P(p)))); 16545 } 16546 16547 /** 16548 * Emit code for rule number 254: 16549 * stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16550 * @param p BURS node to apply the rule to 16551 */ 16552 private void code254(AbstractBURS_TreeNode p) { 16553 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 16554 } 16555 16556 /** 16557 * Emit code for rule number 255: 16558 * stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16559 * @param p BURS node to apply the rule to 16560 */ 16561 private void code255(AbstractBURS_TreeNode p) { 16562 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 16563 } 16564 16565 /** 16566 * Emit code for rule number 256: 16567 * stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16568 * @param p BURS node to apply the rule to 16569 */ 16570 private void code256(AbstractBURS_TreeNode p) { 16571 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 16572 } 16573 16574 /** 16575 * Emit code for rule number 257: 16576 * stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16577 * @param p BURS node to apply the rule to 16578 */ 16579 private void code257(AbstractBURS_TreeNode p) { 16580 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 16581 } 16582 16583 /** 16584 * Emit code for rule number 258: 16585 * r: INT_DIV(riv, riv) 16586 * @param p BURS node to apply the rule to 16587 */ 16588 private void code258(AbstractBURS_TreeNode p) { 16589 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 16590 GuardedBinary.getVal2(P(p)), true, true); 16591 } 16592 16593 /** 16594 * Emit code for rule number 259: 16595 * r: INT_DIV(riv, load32) 16596 * @param p BURS node to apply the rule to 16597 */ 16598 private void code259(AbstractBURS_TreeNode p) { 16599 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 16600 consumeMO(), true, true); 16601 } 16602 16603 /** 16604 * Emit code for rule number 260: 16605 * stm: INT_IFCMP(r,riv) 16606 * @param p BURS node to apply the rule to 16607 */ 16608 private void code260(AbstractBURS_TreeNode p) { 16609 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 16610 } 16611 16612 /** 16613 * Emit code for rule number 261: 16614 * stm: INT_IFCMP(r, INT_CONSTANT) 16615 * @param p BURS node to apply the rule to 16616 */ 16617 private void code261(AbstractBURS_TreeNode p) { 16618 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16619EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, IfCmp.getVal1(P(p)), IfCmp.getVal1(P(p)).copy()))); 16620EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16621 } 16622 16623 /** 16624 * Emit code for rule number 262: 16625 * stm: INT_IFCMP(load8, INT_CONSTANT) 16626 * @param p BURS node to apply the rule to 16627 */ 16628 private void code262(AbstractBURS_TreeNode p) { 16629 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 16630 } 16631 16632 /** 16633 * Emit code for rule number 263: 16634 * stm: INT_IFCMP(uload8, r) 16635 * @param p BURS node to apply the rule to 16636 */ 16637 private void code263(AbstractBURS_TreeNode p) { 16638 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 16639 } 16640 16641 /** 16642 * Emit code for rule number 264: 16643 * stm: INT_IFCMP(r, uload8) 16644 * @param p BURS node to apply the rule to 16645 */ 16646 private void code264(AbstractBURS_TreeNode p) { 16647 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), consumeMO(), IfCmp.getCond(P(p))); 16648 } 16649 16650 /** 16651 * Emit code for rule number 265: 16652 * stm: INT_IFCMP(sload16, INT_CONSTANT) 16653 * @param p BURS node to apply the rule to 16654 */ 16655 private void code265(AbstractBURS_TreeNode p) { 16656 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 16657 } 16658 16659 /** 16660 * Emit code for rule number 266: 16661 * stm: INT_IFCMP(load32, riv) 16662 * @param p BURS node to apply the rule to 16663 */ 16664 private void code266(AbstractBURS_TreeNode p) { 16665 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 16666 } 16667 16668 /** 16669 * Emit code for rule number 267: 16670 * stm: INT_IFCMP(r, load32) 16671 * @param p BURS node to apply the rule to 16672 */ 16673 private void code267(AbstractBURS_TreeNode p) { 16674 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), consumeMO(), IfCmp.getCond(P(p))); 16675 } 16676 16677 /** 16678 * Emit code for rule number 268: 16679 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 16680 * @param p BURS node to apply the rule to 16681 */ 16682 private void code268(AbstractBURS_TreeNode p) { 16683 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16684EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(consumeCOND()), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16685 } 16686 16687 /** 16688 * Emit code for rule number 269: 16689 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 16690 * @param p BURS node to apply the rule to 16691 */ 16692 private void code269(AbstractBURS_TreeNode p) { 16693 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16694EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(consumeCOND().flipCode()), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16695 } 16696 16697 /** 16698 * Emit code for rule number 270: 16699 * stm: INT_IFCMP(cz, INT_CONSTANT) 16700 * @param p BURS node to apply the rule to 16701 */ 16702 private void code270(AbstractBURS_TreeNode p) { 16703 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16704EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16705 } 16706 16707 /** 16708 * Emit code for rule number 271: 16709 * stm: INT_IFCMP(szp, INT_CONSTANT) 16710 * @param p BURS node to apply the rule to 16711 */ 16712 private void code271(AbstractBURS_TreeNode p) { 16713 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16714EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16715 } 16716 16717 /** 16718 * Emit code for rule number 272: 16719 * stm: INT_IFCMP(bittest, INT_CONSTANT) 16720 * @param p BURS node to apply the rule to 16721 */ 16722 private void code272(AbstractBURS_TreeNode p) { 16723 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 16724EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(BIT_TEST(VR(p), IfCmp.getCond(P(p)))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 16725 } 16726 16727 /** 16728 * Emit code for rule number 273: 16729 * stm: INT_IFCMP2(r,riv) 16730 * @param p BURS node to apply the rule to 16731 */ 16732 private void code273(AbstractBURS_TreeNode p) { 16733 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 16734EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, IfCmp2.getVal1(P(p)), IfCmp2.getVal2(P(p))))); 16735EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 16736 COND(IfCmp2.getCond1(P(p))), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 16737 COND(IfCmp2.getCond2(P(p))), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 16738 } 16739 16740 /** 16741 * Emit code for rule number 274: 16742 * stm: INT_IFCMP2(load32,riv) 16743 * @param p BURS node to apply the rule to 16744 */ 16745 private void code274(AbstractBURS_TreeNode p) { 16746 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 16747EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), IfCmp2.getVal2(P(p))))); 16748EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 16749 COND(IfCmp2.getCond1(P(p))), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 16750 COND(IfCmp2.getCond2(P(p))), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 16751 } 16752 16753 /** 16754 * Emit code for rule number 275: 16755 * stm: INT_IFCMP2(riv,load32) 16756 * @param p BURS node to apply the rule to 16757 */ 16758 private void code275(AbstractBURS_TreeNode p) { 16759 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 16760EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), IfCmp2.getVal1(P(p))))); 16761EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 16762 COND(IfCmp2.getCond1(P(p)).flipOperands()), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 16763 COND(IfCmp2.getCond2(P(p)).flipOperands()), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 16764 } 16765 16766 /** 16767 * Emit code for rule number 276: 16768 * r: INT_LOAD(rlv, rlv) 16769 * @param p BURS node to apply the rule to 16770 */ 16771 private void code276(AbstractBURS_TreeNode p) { 16772 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), MO_L(P(p), DW))); 16773 } 16774 16775 /** 16776 * Emit code for rule number 277: 16777 * r: INT_LOAD(rlv, address1scaledreg) 16778 * @param p BURS node to apply the rule to 16779 */ 16780 private void code277(AbstractBURS_TreeNode p) { 16781 augmentAddress(Load.getAddress(P(p))); 16782EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 16783 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 16784 } 16785 16786 /** 16787 * Emit code for rule number 278: 16788 * r: INT_LOAD(address1scaledreg, rlv) 16789 * @param p BURS node to apply the rule to 16790 */ 16791 private void code278(AbstractBURS_TreeNode p) { 16792 augmentAddress(Load.getOffset(P(p))); 16793EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 16794 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 16795 } 16796 16797 /** 16798 * Emit code for rule number 279: 16799 * r: INT_LOAD(address1scaledreg, address1reg) 16800 * @param p BURS node to apply the rule to 16801 */ 16802 private void code279(AbstractBURS_TreeNode p) { 16803 combineAddresses(); 16804EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 16805 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 16806 } 16807 16808 /** 16809 * Emit code for rule number 280: 16810 * r: INT_LOAD(address1reg, address1scaledreg) 16811 * @param p BURS node to apply the rule to 16812 */ 16813 private void code280(AbstractBURS_TreeNode p) { 16814 combineAddresses(); 16815EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 16816 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 16817 } 16818 16819 /** 16820 * Emit code for rule number 281: 16821 * r: INT_LOAD(address, LONG_CONSTANT) 16822 * @param p BURS node to apply the rule to 16823 */ 16824 private void code281(AbstractBURS_TreeNode p) { 16825 augmentAddress(Load.getOffset(P(p))); 16826EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 16827 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 16828 } 16829 16830 /** 16831 * Emit code for rule number 282: 16832 * r: INT_ALOAD(rlv, riv) 16833 * @param p BURS node to apply the rule to 16834 */ 16835 private void code282(AbstractBURS_TreeNode p) { 16836 EMIT(MIR_Move.mutate(P(p), IA32_MOV, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 16837 } 16838 16839 /** 16840 * Emit code for rule number 283: 16841 * r: INT_MOVE(riv) 16842 * @param p BURS node to apply the rule to 16843 */ 16844 private void code283(AbstractBURS_TreeNode p) { 16845 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 16846 } 16847 16848 /** 16849 * Emit code for rule number 284: 16850 * czr: INT_MOVE(czr) 16851 * @param p BURS node to apply the rule to 16852 */ 16853 private void code284(AbstractBURS_TreeNode p) { 16854 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 16855 } 16856 16857 /** 16858 * Emit code for rule number 286: 16859 * szpr: INT_MOVE(szpr) 16860 * @param p BURS node to apply the rule to 16861 */ 16862 private void code286(AbstractBURS_TreeNode p) { 16863 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 16864 } 16865 16866 /** 16867 * Emit code for rule number 295: 16868 * r: INT_MUL(r, riv) 16869 * @param p BURS node to apply the rule to 16870 */ 16871 private void code295(AbstractBURS_TreeNode p) { 16872 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16873 } 16874 16875 /** 16876 * Emit code for rule number 296: 16877 * r: INT_MUL(r, load32) 16878 * @param p BURS node to apply the rule to 16879 */ 16880 private void code296(AbstractBURS_TreeNode p) { 16881 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16882 } 16883 16884 /** 16885 * Emit code for rule number 297: 16886 * r: INT_MUL(load32, riv) 16887 * @param p BURS node to apply the rule to 16888 */ 16889 private void code297(AbstractBURS_TreeNode p) { 16890 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16891 } 16892 16893 /** 16894 * Emit code for rule number 298: 16895 * szpr: INT_NEG(r) 16896 * @param p BURS node to apply the rule to 16897 */ 16898 private void code298(AbstractBURS_TreeNode p) { 16899 EMIT_Unary(IA32_NEG, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 16900 } 16901 16902 /** 16903 * Emit code for rule number 299: 16904 * stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16905 * @param p BURS node to apply the rule to 16906 */ 16907 private void code299(AbstractBURS_TreeNode p) { 16908 EMIT_Unary(IA32_NEG, P(p), MO_S(P(p), DW), MO_S(P(p), DW)); 16909 } 16910 16911 /** 16912 * Emit code for rule number 300: 16913 * stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16914 * @param p BURS node to apply the rule to 16915 */ 16916 private void code300(AbstractBURS_TreeNode p) { 16917 EMIT_Unary(IA32_NEG, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW)); 16918 } 16919 16920 /** 16921 * Emit code for rule number 301: 16922 * r: INT_NOT(r) 16923 * @param p BURS node to apply the rule to 16924 */ 16925 private void code301(AbstractBURS_TreeNode p) { 16926 EMIT_Unary(IA32_NOT, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 16927 } 16928 16929 /** 16930 * Emit code for rule number 302: 16931 * stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16932 * @param p BURS node to apply the rule to 16933 */ 16934 private void code302(AbstractBURS_TreeNode p) { 16935 EMIT_Unary(IA32_NOT, P(p), MO_S(P(p), DW), MO_S(P(p), DW)); 16936 } 16937 16938 /** 16939 * Emit code for rule number 303: 16940 * stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16941 * @param p BURS node to apply the rule to 16942 */ 16943 private void code303(AbstractBURS_TreeNode p) { 16944 EMIT_Unary(IA32_NOT, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW)); 16945 } 16946 16947 /** 16948 * Emit code for rule number 304: 16949 * szpr: INT_OR(r, riv) 16950 * @param p BURS node to apply the rule to 16951 */ 16952 private void code304(AbstractBURS_TreeNode p) { 16953 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16954 } 16955 16956 /** 16957 * Emit code for rule number 305: 16958 * szpr: INT_OR(r, load32) 16959 * @param p BURS node to apply the rule to 16960 */ 16961 private void code305(AbstractBURS_TreeNode p) { 16962 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO() ); 16963 } 16964 16965 /** 16966 * Emit code for rule number 306: 16967 * szpr: INT_OR(load32, riv) 16968 * @param p BURS node to apply the rule to 16969 */ 16970 private void code306(AbstractBURS_TreeNode p) { 16971 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO() ); 16972 } 16973 16974 /** 16975 * Emit code for rule number 307: 16976 * stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16977 * @param p BURS node to apply the rule to 16978 */ 16979 private void code307(AbstractBURS_TreeNode p) { 16980 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 16981 } 16982 16983 /** 16984 * Emit code for rule number 308: 16985 * stm: INT_STORE(INT_OR(r, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16986 * @param p BURS node to apply the rule to 16987 */ 16988 private void code308(AbstractBURS_TreeNode p) { 16989 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 16990 } 16991 16992 /** 16993 * Emit code for rule number 309: 16994 * stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 16995 * @param p BURS node to apply the rule to 16996 */ 16997 private void code309(AbstractBURS_TreeNode p) { 16998 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 16999 } 17000 17001 /** 17002 * Emit code for rule number 310: 17003 * stm: INT_ASTORE(INT_OR(r, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 17004 * @param p BURS node to apply the rule to 17005 */ 17006 private void code310(AbstractBURS_TreeNode p) { 17007 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 17008 } 17009 17010 /** 17011 * Emit code for rule number 311: 17012 * r: INT_REM(riv, riv) 17013 * @param p BURS node to apply the rule to 17014 */ 17015 private void code311(AbstractBURS_TreeNode p) { 17016 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 17017 GuardedBinary.getVal2(P(p)), false, true); 17018 } 17019 17020 /** 17021 * Emit code for rule number 312: 17022 * r: INT_REM(riv, load32) 17023 * @param p BURS node to apply the rule to 17024 */ 17025 private void code312(AbstractBURS_TreeNode p) { 17026 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 17027 consumeMO(), false, true); 17028 } 17029 17030 /** 17031 * Emit code for rule number 313: 17032 * r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 17033 * @param p BURS node to apply the rule to 17034 */ 17035 private void code313(AbstractBURS_TreeNode p) { 17036 EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(VLR(p)&0x1f)); 17037 } 17038 17039 /** 17040 * Emit code for rule number 314: 17041 * r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 17042 * @param p BURS node to apply the rule to 17043 */ 17044 private void code314(AbstractBURS_TreeNode p) { 17045 EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(VRR(p)&0x1f)); 17046 } 17047 17048 /** 17049 * Emit code for rule number 315: 17050 * r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 17051 * @param p BURS node to apply the rule to 17052 */ 17053 private void code315(AbstractBURS_TreeNode p) { 17054 EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(1)); 17055 } 17056 17057 /** 17058 * Emit code for rule number 316: 17059 * r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 17060 * @param p BURS node to apply the rule to 17061 */ 17062 private void code316(AbstractBURS_TreeNode p) { 17063 EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(1)); 17064 } 17065 17066 /** 17067 * Emit code for rule number 317: 17068 * r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 17069 * @param p BURS node to apply the rule to 17070 */ 17071 private void code317(AbstractBURS_TreeNode p) { 17072 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 17073EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 17074 } 17075 17076 /** 17077 * Emit code for rule number 318: 17078 * r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 17079 * @param p BURS node to apply the rule to 17080 */ 17081 private void code318(AbstractBURS_TreeNode p) { 17082 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PRR(p))))); 17083EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 17084 } 17085 17086 /** 17087 * Emit code for rule number 319: 17088 * r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 17089 * @param p BURS node to apply the rule to 17090 */ 17091 private void code319(AbstractBURS_TreeNode p) { 17092 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PRR(p))))); 17093EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 17094 } 17095 17096 /** 17097 * Emit code for rule number 320: 17098 * r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 17099 * @param p BURS node to apply the rule to 17100 */ 17101 private void code320(AbstractBURS_TreeNode p) { 17102 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 17103EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 17104 } 17105 17106 /** 17107 * Emit code for rule number 321: 17108 * szpr: INT_SHL(riv, INT_AND(r, INT_CONSTANT)) 17109 * @param p BURS node to apply the rule to 17110 */ 17111 private void code321(AbstractBURS_TreeNode p) { 17112 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 17113EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17114 } 17115 17116 /** 17117 * Emit code for rule number 322: 17118 * szpr: INT_SHL(riv, riv) 17119 * @param p BURS node to apply the rule to 17120 */ 17121 private void code322(AbstractBURS_TreeNode p) { 17122 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 17123EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17124 } 17125 17126 /** 17127 * Emit code for rule number 323: 17128 * szpr: INT_SHL(r, INT_CONSTANT) 17129 * @param p BURS node to apply the rule to 17130 */ 17131 private void code323(AbstractBURS_TreeNode p) { 17132 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); if(Binary.getVal2(P(p)).asIntConstant().value == 1) { 17133 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(P(p)).copy()); 17134} else { 17135 EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 17136} 17137 } 17138 17139 /** 17140 * Emit code for rule number 324: 17141 * r: INT_SHL(r, INT_CONSTANT) 17142 * @param p BURS node to apply the rule to 17143 */ 17144 private void code324(AbstractBURS_TreeNode p) { 17145 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 17146EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17147 } 17148 17149 /** 17150 * Emit code for rule number 325: 17151 * szpr: INT_SHL(INT_SHR(r, INT_CONSTANT), INT_CONSTANT) 17152 * @param p BURS node to apply the rule to 17153 */ 17154 private void code325(AbstractBURS_TreeNode p) { 17155 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)), IC(0xffffffff << VR(p))); 17156 } 17157 17158 /** 17159 * Emit code for rule number 326: 17160 * stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17161 * @param p BURS node to apply the rule to 17162 */ 17163 private void code326(AbstractBURS_TreeNode p) { 17164 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 17165EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 17166 } 17167 17168 /** 17169 * Emit code for rule number 327: 17170 * stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17171 * @param p BURS node to apply the rule to 17172 */ 17173 private void code327(AbstractBURS_TreeNode p) { 17174 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 17175EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 17176 } 17177 17178 /** 17179 * Emit code for rule number 328: 17180 * stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17181 * @param p BURS node to apply the rule to 17182 */ 17183 private void code328(AbstractBURS_TreeNode p) { 17184 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 17185EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 17186 } 17187 17188 /** 17189 * Emit code for rule number 329: 17190 * stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17191 * @param p BURS node to apply the rule to 17192 */ 17193 private void code329(AbstractBURS_TreeNode p) { 17194 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 17195 } 17196 17197 /** 17198 * Emit code for rule number 330: 17199 * szpr: INT_SHR(riv, INT_AND(r, INT_CONSTANT)) 17200 * @param p BURS node to apply the rule to 17201 */ 17202 private void code330(AbstractBURS_TreeNode p) { 17203 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 17204EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17205 } 17206 17207 /** 17208 * Emit code for rule number 331: 17209 * szpr: INT_SHR(riv, riv) 17210 * @param p BURS node to apply the rule to 17211 */ 17212 private void code331(AbstractBURS_TreeNode p) { 17213 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 17214EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17215 } 17216 17217 /** 17218 * Emit code for rule number 332: 17219 * szpr: INT_SHR(riv, INT_CONSTANT) 17220 * @param p BURS node to apply the rule to 17221 */ 17222 private void code332(AbstractBURS_TreeNode p) { 17223 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); 17224EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 17225 } 17226 17227 /** 17228 * Emit code for rule number 333: 17229 * stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17230 * @param p BURS node to apply the rule to 17231 */ 17232 private void code333(AbstractBURS_TreeNode p) { 17233 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 17234EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 17235 } 17236 17237 /** 17238 * Emit code for rule number 334: 17239 * stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17240 * @param p BURS node to apply the rule to 17241 */ 17242 private void code334(AbstractBURS_TreeNode p) { 17243 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 17244EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 17245 } 17246 17247 /** 17248 * Emit code for rule number 335: 17249 * stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17250 * @param p BURS node to apply the rule to 17251 */ 17252 private void code335(AbstractBURS_TreeNode p) { 17253 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 17254EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 17255 } 17256 17257 /** 17258 * Emit code for rule number 336: 17259 * stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17260 * @param p BURS node to apply the rule to 17261 */ 17262 private void code336(AbstractBURS_TreeNode p) { 17263 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 17264 } 17265 17266 /** 17267 * Emit code for rule number 337: 17268 * stm: INT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 17269 * @param p BURS node to apply the rule to 17270 */ 17271 private void code337(AbstractBURS_TreeNode p) { 17272 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), Store.getValue(P(p)))); 17273 } 17274 17275 /** 17276 * Emit code for rule number 338: 17277 * stm: INT_STORE(riv, OTHER_OPERAND(rlv, address1scaledreg)) 17278 * @param p BURS node to apply the rule to 17279 */ 17280 private void code338(AbstractBURS_TreeNode p) { 17281 augmentAddress(Store.getAddress(P(p))); 17282EMIT(MIR_Move.mutate(P(p), IA32_MOV, 17283 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 17284 Store.getValue(P(p)))); 17285 } 17286 17287 /** 17288 * Emit code for rule number 339: 17289 * stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, rlv)) 17290 * @param p BURS node to apply the rule to 17291 */ 17292 private void code339(AbstractBURS_TreeNode p) { 17293 augmentAddress(Store.getOffset(P(p))); 17294EMIT(MIR_Move.mutate(P(p), IA32_MOV, 17295 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 17296 Store.getValue(P(p)))); 17297 } 17298 17299 /** 17300 * Emit code for rule number 340: 17301 * stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, address1reg)) 17302 * @param p BURS node to apply the rule to 17303 */ 17304 private void code340(AbstractBURS_TreeNode p) { 17305 combineAddresses(); 17306EMIT(MIR_Move.mutate(P(p), IA32_MOV, 17307 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 17308 Store.getValue(P(p)))); 17309 } 17310 17311 /** 17312 * Emit code for rule number 341: 17313 * stm: INT_STORE(riv, OTHER_OPERAND(address1reg, address1scaledreg)) 17314 * @param p BURS node to apply the rule to 17315 */ 17316 private void code341(AbstractBURS_TreeNode p) { 17317 combineAddresses(); 17318EMIT(MIR_Move.mutate(P(p), IA32_MOV, 17319 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 17320 Store.getValue(P(p)))); 17321 } 17322 17323 /** 17324 * Emit code for rule number 342: 17325 * stm: INT_STORE(riv, OTHER_OPERAND(address, LONG_CONSTANT)) 17326 * @param p BURS node to apply the rule to 17327 */ 17328 private void code342(AbstractBURS_TreeNode p) { 17329 augmentAddress(Store.getOffset(P(p))); 17330EMIT(MIR_Move.mutate(P(p), IA32_MOV, 17331 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 17332 Store.getValue(P(p)))); 17333 } 17334 17335 /** 17336 * Emit code for rule number 343: 17337 * czr: INT_SUB(riv, r) 17338 * @param p BURS node to apply the rule to 17339 */ 17340 private void code343(AbstractBURS_TreeNode p) { 17341 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 17342 } 17343 17344 /** 17345 * Emit code for rule number 344: 17346 * r: INT_SUB(riv, r) 17347 * @param p BURS node to apply the rule to 17348 */ 17349 private void code344(AbstractBURS_TreeNode p) { 17350 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 17351EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), Binary.getVal1(P(p)))); 17352 } 17353 17354 /** 17355 * Emit code for rule number 345: 17356 * r: INT_SUB(load32, r) 17357 * @param p BURS node to apply the rule to 17358 */ 17359 private void code345(AbstractBURS_TreeNode p) { 17360 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 17361EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), consumeMO())); 17362 } 17363 17364 /** 17365 * Emit code for rule number 346: 17366 * czr: INT_SUB(riv, load32) 17367 * @param p BURS node to apply the rule to 17368 */ 17369 private void code346(AbstractBURS_TreeNode p) { 17370 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 17371 } 17372 17373 /** 17374 * Emit code for rule number 347: 17375 * czr: INT_SUB(load32, riv) 17376 * @param p BURS node to apply the rule to 17377 */ 17378 private void code347(AbstractBURS_TreeNode p) { 17379 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), consumeMO(), Binary.getVal2(P(p))); 17380 } 17381 17382 /** 17383 * Emit code for rule number 348: 17384 * stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 17385 * @param p BURS node to apply the rule to 17386 */ 17387 private void code348(AbstractBURS_TreeNode p) { 17388 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 17389 } 17390 17391 /** 17392 * Emit code for rule number 349: 17393 * stm: INT_STORE(INT_SUB(riv, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 17394 * @param p BURS node to apply the rule to 17395 */ 17396 private void code349(AbstractBURS_TreeNode p) { 17397 MemoryOperand result = MO_S(P(p), DW); 17398EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 17399EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 17400 } 17401 17402 /** 17403 * Emit code for rule number 350: 17404 * stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 17405 * @param p BURS node to apply the rule to 17406 */ 17407 private void code350(AbstractBURS_TreeNode p) { 17408 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 17409 } 17410 17411 /** 17412 * Emit code for rule number 351: 17413 * stm: INT_ASTORE(INT_SUB(riv, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 17414 * @param p BURS node to apply the rule to 17415 */ 17416 private void code351(AbstractBURS_TreeNode p) { 17417 MemoryOperand result = MO_AS(P(p), DW_S, DW); 17418EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 17419EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 17420 } 17421 17422 /** 17423 * Emit code for rule number 352: 17424 * szpr: INT_USHR(riv, INT_AND(r, INT_CONSTANT)) 17425 * @param p BURS node to apply the rule to 17426 */ 17427 private void code352(AbstractBURS_TreeNode p) { 17428 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 17429EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17430 } 17431 17432 /** 17433 * Emit code for rule number 353: 17434 * szpr: INT_USHR(riv, riv) 17435 * @param p BURS node to apply the rule to 17436 */ 17437 private void code353(AbstractBURS_TreeNode p) { 17438 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 17439EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 17440 } 17441 17442 /** 17443 * Emit code for rule number 354: 17444 * szpr: INT_USHR(riv, INT_CONSTANT) 17445 * @param p BURS node to apply the rule to 17446 */ 17447 private void code354(AbstractBURS_TreeNode p) { 17448 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); 17449EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 17450 } 17451 17452 /** 17453 * Emit code for rule number 355: 17454 * stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17455 * @param p BURS node to apply the rule to 17456 */ 17457 private void code355(AbstractBURS_TreeNode p) { 17458 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 17459EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 17460 } 17461 17462 /** 17463 * Emit code for rule number 356: 17464 * stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17465 * @param p BURS node to apply the rule to 17466 */ 17467 private void code356(AbstractBURS_TreeNode p) { 17468 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 17469EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 17470 } 17471 17472 /** 17473 * Emit code for rule number 357: 17474 * stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 17475 * @param p BURS node to apply the rule to 17476 */ 17477 private void code357(AbstractBURS_TreeNode p) { 17478 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 17479EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 17480 } 17481 17482 /** 17483 * Emit code for rule number 358: 17484 * stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 17485 * @param p BURS node to apply the rule to 17486 */ 17487 private void code358(AbstractBURS_TreeNode p) { 17488 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 17489 } 17490 17491 /** 17492 * Emit code for rule number 359: 17493 * szpr: INT_XOR(r, riv) 17494 * @param p BURS node to apply the rule to 17495 */ 17496 private void code359(AbstractBURS_TreeNode p) { 17497 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 17498 } 17499 17500 /** 17501 * Emit code for rule number 360: 17502 * szpr: INT_XOR(r, load32) 17503 * @param p BURS node to apply the rule to 17504 */ 17505 private void code360(AbstractBURS_TreeNode p) { 17506 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO() ); 17507 } 17508 17509 /** 17510 * Emit code for rule number 361: 17511 * szpr: INT_XOR(load32, riv) 17512 * @param p BURS node to apply the rule to 17513 */ 17514 private void code361(AbstractBURS_TreeNode p) { 17515 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO() ); 17516 } 17517 17518 /** 17519 * Emit code for rule number 362: 17520 * stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 17521 * @param p BURS node to apply the rule to 17522 */ 17523 private void code362(AbstractBURS_TreeNode p) { 17524 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 17525 } 17526 17527 /** 17528 * Emit code for rule number 363: 17529 * stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 17530 * @param p BURS node to apply the rule to 17531 */ 17532 private void code363(AbstractBURS_TreeNode p) { 17533 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 17534 } 17535 17536 /** 17537 * Emit code for rule number 364: 17538 * stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 17539 * @param p BURS node to apply the rule to 17540 */ 17541 private void code364(AbstractBURS_TreeNode p) { 17542 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 17543 } 17544 17545 /** 17546 * Emit code for rule number 365: 17547 * stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 17548 * @param p BURS node to apply the rule to 17549 */ 17550 private void code365(AbstractBURS_TreeNode p) { 17551 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 17552 } 17553 17554 /** 17555 * Emit code for rule number 366: 17556 * r: LCMP_CMOV(r, OTHER_OPERAND(rlv, any)) 17557 * @param p BURS node to apply the rule to 17558 */ 17559 private void code366(AbstractBURS_TreeNode p) { 17560 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, CondMove.getVal1(P(p)), CondMove.getVal2(P(p))))); 17561CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 17562 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 17563 } 17564 17565 /** 17566 * Emit code for rule number 367: 17567 * r: LCMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 17568 * @param p BURS node to apply the rule to 17569 */ 17570 private void code367(AbstractBURS_TreeNode p) { 17571 EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, CondMove.getVal1(P(p)), CondMove.getVal1(P(p)).copy()))); 17572CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 17573 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 17574 } 17575 17576 /** 17577 * Emit code for rule number 368: 17578 * r: LCMP_CMOV(load64, OTHER_OPERAND(rlv, any)) 17579 * @param p BURS node to apply the rule to 17580 */ 17581 private void code368(AbstractBURS_TreeNode p) { 17582 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 17583CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 17584 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 17585 } 17586 17587 /** 17588 * Emit code for rule number 369: 17589 * r: LCMP_CMOV(rlv, OTHER_OPERAND(load64, any)) 17590 * @param p BURS node to apply the rule to 17591 */ 17592 private void code369(AbstractBURS_TreeNode p) { 17593 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal1(P(p))))); 17594CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).flipOperands(), 17595 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 17596 } 17597 17598 /** 17599 * Emit code for rule number 370: 17600 * r: LONG_ADD(address1scaledreg, r) 17601 * @param p BURS node to apply the rule to 17602 */ 17603 private void code370(AbstractBURS_TreeNode p) { 17604 augmentAddress(Binary.getVal2(P(p))); 17605EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17606 } 17607 17608 /** 17609 * Emit code for rule number 371: 17610 * r: LONG_ADD(r, address1scaledreg) 17611 * @param p BURS node to apply the rule to 17612 */ 17613 private void code371(AbstractBURS_TreeNode p) { 17614 augmentAddress(Binary.getVal1(P(p))); 17615EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17616 } 17617 17618 /** 17619 * Emit code for rule number 372: 17620 * r: LONG_ADD(address1scaledreg, address1reg) 17621 * @param p BURS node to apply the rule to 17622 */ 17623 private void code372(AbstractBURS_TreeNode p) { 17624 combineAddresses(); 17625EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17626 } 17627 17628 /** 17629 * Emit code for rule number 373: 17630 * r: LONG_ADD(address1reg, address1scaledreg) 17631 * @param p BURS node to apply the rule to 17632 */ 17633 private void code373(AbstractBURS_TreeNode p) { 17634 combineAddresses(); 17635EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17636 } 17637 17638 /** 17639 * Emit code for rule number 374: 17640 * r: LONG_ADD(address, LONG_CONSTANT) 17641 * @param p BURS node to apply the rule to 17642 */ 17643 private void code374(AbstractBURS_TreeNode p) { 17644 augmentAddress(Binary.getVal2(P(p))); 17645EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 17646 } 17647 17648 /** 17649 * Emit code for rule number 375: 17650 * r: LONG_MOVE(address) 17651 * @param p BURS node to apply the rule to 17652 */ 17653 private void code375(AbstractBURS_TreeNode p) { 17654 EMIT_Lea(P(p), Move.getResult(P(p)), consumeAddress(DW, null, null)); 17655 } 17656 17657 /** 17658 * Emit code for rule number 376: 17659 * r: BYTE_LOAD(rlv, rlv) 17660 * @param p BURS node to apply the rule to 17661 */ 17662 private void code376(AbstractBURS_TreeNode p) { 17663 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Load.getResult(P(p)), MO_L(P(p), B))); 17664 } 17665 17666 /** 17667 * Emit code for rule number 377: 17668 * sload8: BYTE_LOAD(rlv, rlv) 17669 * @param p BURS node to apply the rule to 17670 */ 17671 private void code377(AbstractBURS_TreeNode p) { 17672 pushMO(MO_L(P(p), B)); 17673 } 17674 17675 /** 17676 * Emit code for rule number 378: 17677 * r: BYTE_ALOAD(rlv, riv) 17678 * @param p BURS node to apply the rule to 17679 */ 17680 private void code378(AbstractBURS_TreeNode p) { 17681 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17682 } 17683 17684 /** 17685 * Emit code for rule number 379: 17686 * r: BYTE_ALOAD(rlv, r) 17687 * @param p BURS node to apply the rule to 17688 */ 17689 private void code379(AbstractBURS_TreeNode p) { 17690 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 17691if (index.getRegister().isInteger()) { 17692EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17693EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17694} else { 17695EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17696} 17697 } 17698 17699 /** 17700 * Emit code for rule number 380: 17701 * sload8: BYTE_ALOAD(rlv, riv) 17702 * @param p BURS node to apply the rule to 17703 */ 17704 private void code380(AbstractBURS_TreeNode p) { 17705 pushMO(MO_AL(P(p), B_S, B)); 17706 } 17707 17708 /** 17709 * Emit code for rule number 381: 17710 * r: UBYTE_LOAD(rlv, rlv) 17711 * @param p BURS node to apply the rule to 17712 */ 17713 private void code381(AbstractBURS_TreeNode p) { 17714 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Load.getResult(P(p)), MO_L(P(p), B))); 17715 } 17716 17717 /** 17718 * Emit code for rule number 382: 17719 * uload8: UBYTE_LOAD(rlv, rlv) 17720 * @param p BURS node to apply the rule to 17721 */ 17722 private void code382(AbstractBURS_TreeNode p) { 17723 pushMO(MO_L(P(p), B)); 17724 } 17725 17726 /** 17727 * Emit code for rule number 383: 17728 * r: UBYTE_ALOAD(rlv, riv) 17729 * @param p BURS node to apply the rule to 17730 */ 17731 private void code383(AbstractBURS_TreeNode p) { 17732 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17733 } 17734 17735 /** 17736 * Emit code for rule number 384: 17737 * r: UBYTE_ALOAD(rlv, r) 17738 * @param p BURS node to apply the rule to 17739 */ 17740 private void code384(AbstractBURS_TreeNode p) { 17741 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 17742if (index.getRegister().isInteger()) { 17743EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17744EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17745} else { 17746EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 17747} 17748 } 17749 17750 /** 17751 * Emit code for rule number 385: 17752 * uload8: UBYTE_ALOAD(rlv, riv) 17753 * @param p BURS node to apply the rule to 17754 */ 17755 private void code385(AbstractBURS_TreeNode p) { 17756 pushMO(MO_AL(P(p), B_S, B)); 17757 } 17758 17759 /** 17760 * Emit code for rule number 388: 17761 * r: SHORT_LOAD(rlv, rlv) 17762 * @param p BURS node to apply the rule to 17763 */ 17764 private void code388(AbstractBURS_TreeNode p) { 17765 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Load.getResult(P(p)), MO_L(P(p), W))); 17766 } 17767 17768 /** 17769 * Emit code for rule number 389: 17770 * sload16: SHORT_LOAD(rlv, rlv) 17771 * @param p BURS node to apply the rule to 17772 */ 17773 private void code389(AbstractBURS_TreeNode p) { 17774 pushMO(MO_L(P(p), W)); 17775 } 17776 17777 /** 17778 * Emit code for rule number 390: 17779 * r: SHORT_ALOAD(rlv, riv) 17780 * @param p BURS node to apply the rule to 17781 */ 17782 private void code390(AbstractBURS_TreeNode p) { 17783 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17784 } 17785 17786 /** 17787 * Emit code for rule number 391: 17788 * r: SHORT_ALOAD(rlv, r) 17789 * @param p BURS node to apply the rule to 17790 */ 17791 private void code391(AbstractBURS_TreeNode p) { 17792 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 17793if (index.getRegister().isInteger()) { 17794EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17795EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17796} else { 17797EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17798} 17799 } 17800 17801 /** 17802 * Emit code for rule number 392: 17803 * sload16: SHORT_ALOAD(rlv, riv) 17804 * @param p BURS node to apply the rule to 17805 */ 17806 private void code392(AbstractBURS_TreeNode p) { 17807 pushMO(MO_AL(P(p), W_S, W)); 17808 } 17809 17810 /** 17811 * Emit code for rule number 393: 17812 * r: USHORT_LOAD(rlv, rlv) 17813 * @param p BURS node to apply the rule to 17814 */ 17815 private void code393(AbstractBURS_TreeNode p) { 17816 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Load.getResult(P(p)), MO_L(P(p), W))); 17817 } 17818 17819 /** 17820 * Emit code for rule number 394: 17821 * uload16: USHORT_LOAD(rlv, rlv) 17822 * @param p BURS node to apply the rule to 17823 */ 17824 private void code394(AbstractBURS_TreeNode p) { 17825 pushMO(MO_L(P(p), W)); 17826 } 17827 17828 /** 17829 * Emit code for rule number 395: 17830 * r: USHORT_ALOAD(rlv, riv) 17831 * @param p BURS node to apply the rule to 17832 */ 17833 private void code395(AbstractBURS_TreeNode p) { 17834 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17835 } 17836 17837 /** 17838 * Emit code for rule number 396: 17839 * r: USHORT_ALOAD(rlv, r) 17840 * @param p BURS node to apply the rule to 17841 */ 17842 private void code396(AbstractBURS_TreeNode p) { 17843 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 17844if (index.getRegister().isInteger()) { 17845EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17846EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17847} else { 17848EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 17849} 17850 } 17851 17852 /** 17853 * Emit code for rule number 397: 17854 * uload16: USHORT_ALOAD(rlv, riv) 17855 * @param p BURS node to apply the rule to 17856 */ 17857 private void code397(AbstractBURS_TreeNode p) { 17858 pushMO(MO_AL(P(p), W_S, W)); 17859 } 17860 17861 /** 17862 * Emit code for rule number 400: 17863 * load32: INT_LOAD(rlv, rlv) 17864 * @param p BURS node to apply the rule to 17865 */ 17866 private void code400(AbstractBURS_TreeNode p) { 17867 pushMO(MO_L(P(p), DW)); 17868 } 17869 17870 /** 17871 * Emit code for rule number 401: 17872 * load32: INT_ALOAD(rlv, riv) 17873 * @param p BURS node to apply the rule to 17874 */ 17875 private void code401(AbstractBURS_TreeNode p) { 17876 pushMO(MO_AL(P(p), DW_S, DW)); 17877 } 17878 17879 /** 17880 * Emit code for rule number 406: 17881 * load64: LONG_LOAD(rlv, rlv) 17882 * @param p BURS node to apply the rule to 17883 */ 17884 private void code406(AbstractBURS_TreeNode p) { 17885 pushMO(MO_L(P(p), QW)); 17886 } 17887 17888 /** 17889 * Emit code for rule number 407: 17890 * load64: LONG_ALOAD(rlv, rlv) 17891 * @param p BURS node to apply the rule to 17892 */ 17893 private void code407(AbstractBURS_TreeNode p) { 17894 pushMO(MO_AL(P(p), QW_S, QW)); 17895 } 17896 17897 /** 17898 * Emit code for rule number 408: 17899 * load64: LONG_ALOAD(rlv, r) 17900 * @param p BURS node to apply the rule to 17901 */ 17902 private void code408(AbstractBURS_TreeNode p) { 17903 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 17904if (index.getRegister().isInteger()) { 17905EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17906pushMO(MO_AL(P(p), QW_S, QW)); 17907} else { 17908pushMO(MO_AL(P(p), QW_S, QW)); 17909} 17910 } 17911 17912 /** 17913 * Emit code for rule number 411: 17914 * r: LONG_2INT(r) 17915 * @param p BURS node to apply the rule to 17916 */ 17917 private void code411(AbstractBURS_TreeNode p) { 17918 RegisterOperand val = R(Unary.getVal(P(p))); 17919if (VM.BuildFor64Addr) { 17920RegisterOperand r = Unary.getResult(P(p)); 17921RegisterOperand temp = regpool.makeTempInt(); 17922EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 17923EMIT(MIR_Move.mutate(P(p), IA32_MOV, r, temp)); 17924} else { 17925Register lh = regpool.getSecondReg(R(Unary.getVal(P(p))).getRegister()); 17926EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(lh, TypeReference.Int))); 17927} 17928 } 17929 17930 /** 17931 * Emit code for rule number 412: 17932 * stm: INT_STORE(LONG_2INT(r), OTHER_OPERAND(riv,riv)) 17933 * @param p BURS node to apply the rule to 17934 */ 17935 private void code412(AbstractBURS_TreeNode p) { 17936 RegisterOperand val = R(Unary.getVal(PL(p))); 17937if (VM.BuildFor64Addr) { 17938RegisterOperand temp = regpool.makeTempInt(); 17939EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 17940EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW),temp)); 17941} else { 17942Register lh = regpool.getSecondReg(R(Unary.getVal(PL(p))).getRegister()); 17943EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), new RegisterOperand(lh, TypeReference.Int))); 17944} 17945 } 17946 17947 /** 17948 * Emit code for rule number 413: 17949 * stm: INT_ASTORE(LONG_2INT(r), OTHER_OPERAND(riv, riv)) 17950 * @param p BURS node to apply the rule to 17951 */ 17952 private void code413(AbstractBURS_TreeNode p) { 17953 RegisterOperand val = R(Unary.getVal(PL(p))); 17954if (VM.BuildFor64Addr) { 17955RegisterOperand temp = regpool.makeTempInt(); 17956EMIT(CPOS(P(p),MIR_Move.create(IA32_MOV, temp, val))); 17957EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW),temp)); 17958} else { 17959Register lh = regpool.getSecondReg(R(Unary.getVal(PL(p))).getRegister()); 17960EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), new RegisterOperand(lh, TypeReference.Int))); 17961} 17962 } 17963 17964 /** 17965 * Emit code for rule number 414: 17966 * r: LONG_2INT(load64) 17967 * @param p BURS node to apply the rule to 17968 */ 17969 private void code414(AbstractBURS_TreeNode p) { 17970 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), setSize(consumeMO(), 4))); 17971 } 17972 17973 /** 17974 * Emit code for rule number 415: 17975 * load32: LONG_2INT(load64) 17976 * @param p BURS node to apply the rule to 17977 */ 17978 private void code415(AbstractBURS_TreeNode p) { 17979 pushMO(setSize(consumeMO(), 4)); 17980 } 17981 17982 /** 17983 * Emit code for rule number 416: 17984 * r: LONG_2INT(LONG_USHR(r, INT_CONSTANT)) 17985 * @param p BURS node to apply the rule to 17986 */ 17987 private void code416(AbstractBURS_TreeNode p) { 17988 RegisterOperand val = R(Binary.getVal1(PL(p))); 17989if (VM.BuildFor64Addr) { 17990RegisterOperand temp = regpool.makeTempInt(); 17991EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 17992EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_SHR,temp,LC(32)))); 17993EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), temp)); 17994} else { 17995Register uh = Binary.getVal1(PL(p)).asRegister().getRegister(); 17996EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(uh, TypeReference.Int))); 17997} 17998 } 17999 18000 /** 18001 * Emit code for rule number 417: 18002 * r: LONG_2INT(LONG_SHR(r, INT_CONSTANT)) 18003 * @param p BURS node to apply the rule to 18004 */ 18005 private void code417(AbstractBURS_TreeNode p) { 18006 RegisterOperand val = R(Binary.getVal1(PL(p))); 18007if (VM.BuildFor64Addr) { 18008RegisterOperand temp = regpool.makeTempInt(); 18009EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 18010EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_SAR,temp,LC(32)))); 18011EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), temp)); 18012} else { 18013Register uh = Binary.getVal1(PL(p)).asRegister().getRegister(); 18014EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(uh, TypeReference.Int))); 18015} 18016 } 18017 18018 /** 18019 * Emit code for rule number 418: 18020 * r: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 18021 * @param p BURS node to apply the rule to 18022 */ 18023 private void code418(AbstractBURS_TreeNode p) { 18024 MemoryOperand mo = consumeMO(); 18025mo.disp = mo.disp.plus(4); 18026mo = setSize(mo,4); 18027EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), mo)); 18028 } 18029 18030 /** 18031 * Emit code for rule number 419: 18032 * r: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 18033 * @param p BURS node to apply the rule to 18034 */ 18035 private void code419(AbstractBURS_TreeNode p) { 18036 MemoryOperand mo = consumeMO(); 18037mo.disp = mo.disp.plus(4); 18038mo = setSize(mo,4); 18039EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), mo)); 18040 } 18041 18042 /** 18043 * Emit code for rule number 420: 18044 * load32: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 18045 * @param p BURS node to apply the rule to 18046 */ 18047 private void code420(AbstractBURS_TreeNode p) { 18048 MemoryOperand mo = consumeMO(); 18049mo.disp = mo.disp.plus(4); 18050mo = setSize(mo,4); 18051pushMO(mo); 18052 } 18053 18054 /** 18055 * Emit code for rule number 421: 18056 * load32: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 18057 * @param p BURS node to apply the rule to 18058 */ 18059 private void code421(AbstractBURS_TreeNode p) { 18060 MemoryOperand mo = consumeMO(); 18061mo.disp = mo.disp.plus(4); 18062mo = setSize(mo,4); 18063pushMO(mo); 18064 } 18065 18066 /** 18067 * Emit code for rule number 422: 18068 * czr: LONG_ADD(r, rlv) 18069 * @param p BURS node to apply the rule to 18070 */ 18071 private void code422(AbstractBURS_TreeNode p) { 18072 if (Binary.getVal2(P(p)).isLongConstant()) { 18073RegisterOperand tmp = regpool.makeTempLong(); 18074EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, tmp, Binary.getVal2(P(p))))); 18075EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), tmp); 18076} else { 18077EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18078} 18079 } 18080 18081 /** 18082 * Emit code for rule number 423: 18083 * czr: LONG_ADD(r, riv) 18084 * @param p BURS node to apply the rule to 18085 */ 18086 private void code423(AbstractBURS_TreeNode p) { 18087 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18088 } 18089 18090 /** 18091 * Emit code for rule number 424: 18092 * czr: LONG_ADD(r,r) 18093 * @param p BURS node to apply the rule to 18094 */ 18095 private void code424(AbstractBURS_TreeNode p) { 18096 if (Binary.getVal1(P(p)).asRegister().getRegister().isInteger()) { 18097RegisterOperand tmp = regpool.makeTempLong(); 18098EMIT(CPOS(P(p), MIR_Unary.create(IA32_MOVSXQ__W, tmp,Binary.getVal1(P(p))))); 18099EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)),tmp, Binary.getVal2(P(p))); 18100} else if (Binary.getVal2(P(p)).asRegister().getRegister().isInteger()) { 18101RegisterOperand tmp = regpool.makeTempLong(); 18102EMIT(CPOS(P(p), MIR_Unary.create(IA32_MOVSXQ__W, tmp,Binary.getVal2(P(p))))); 18103EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)),Binary.getVal1(P(p)),tmp); 18104} else { 18105EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18106} 18107 } 18108 18109 /** 18110 * Emit code for rule number 425: 18111 * r: LONG_ADD(r, rlv) 18112 * @param p BURS node to apply the rule to 18113 */ 18114 private void code425(AbstractBURS_TreeNode p) { 18115 if (Binary.getVal2(P(p)).isLongConstant()) { 18116 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromLong(LV(Binary.getVal2(P(p))))); 18117} else { 18118 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 18119} 18120EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(QW, null, null)); 18121 } 18122 18123 /** 18124 * Emit code for rule number 426: 18125 * czr: LONG_ADD(rlv, load64) 18126 * @param p BURS node to apply the rule to 18127 */ 18128 private void code426(AbstractBURS_TreeNode p) { 18129 if (Binary.getVal1(P(p)).isLongConstant()) { 18130RegisterOperand tmp = regpool.makeTempLong(); 18131EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, tmp,Binary.getVal1(P(p))))); 18132EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), tmp, consumeMO()); 18133} else { 18134EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 18135} 18136 } 18137 18138 /** 18139 * Emit code for rule number 427: 18140 * czr: LONG_ADD(load64, rlv) 18141 * @param p BURS node to apply the rule to 18142 */ 18143 private void code427(AbstractBURS_TreeNode p) { 18144 if (Binary.getVal2(P(p)).isLongConstant()) { 18145RegisterOperand tmp = regpool.makeTempLong(); 18146EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, tmp, Binary.getVal2(P(p))))); 18147EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), consumeMO(), tmp); 18148} else { 18149EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 18150} 18151 } 18152 18153 /** 18154 * Emit code for rule number 428: 18155 * stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18156 * @param p BURS node to apply the rule to 18157 */ 18158 private void code428(AbstractBURS_TreeNode p) { 18159 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p))); 18160 } 18161 18162 /** 18163 * Emit code for rule number 429: 18164 * stm: LONG_STORE(LONG_ADD(rlv,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18165 * @param p BURS node to apply the rule to 18166 */ 18167 private void code429(AbstractBURS_TreeNode p) { 18168 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p))); 18169 } 18170 18171 /** 18172 * Emit code for rule number 430: 18173 * stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18174 * @param p BURS node to apply the rule to 18175 */ 18176 private void code430(AbstractBURS_TreeNode p) { 18177 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p))); 18178 } 18179 18180 /** 18181 * Emit code for rule number 431: 18182 * stm: LONG_ASTORE(LONG_ADD(rlv,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18183 * @param p BURS node to apply the rule to 18184 */ 18185 private void code431(AbstractBURS_TreeNode p) { 18186 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p))); 18187 } 18188 18189 /** 18190 * Emit code for rule number 432: 18191 * szpr: LONG_AND(r, rlv) 18192 * @param p BURS node to apply the rule to 18193 */ 18194 private void code432(AbstractBURS_TreeNode p) { 18195 if (Binary.getVal2(P(p)).isLongConstant()) { 18196Register tmp = regpool.getLong(); 18197EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Long), Binary.getVal2(P(p))))); 18198EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(tmp, TypeReference.Long)); 18199}else{ 18200EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18201} 18202 } 18203 18204 /** 18205 * Emit code for rule number 433: 18206 * szpr: LONG_AND(r,r) 18207 * @param p BURS node to apply the rule to 18208 */ 18209 private void code433(AbstractBURS_TreeNode p) { 18210 if (Binary.getVal1(P(p)).asRegister().getRegister().isInteger()) { 18211RegisterOperand tmp = regpool.makeTempLong(); 18212EMIT(CPOS(P(p), MIR_Unary.create(IA32_MOVSXQ__W, tmp, Binary.getVal1(P(p))))); 18213EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), tmp, Binary.getVal2(P(p))); 18214} else if (Binary.getVal2(P(p)).asRegister().getRegister().isInteger()) { 18215RegisterOperand tmp = regpool.makeTempLong(); 18216EMIT(CPOS(P(p), MIR_Unary.create(IA32_MOVSXQ__W, tmp, Binary.getVal2(P(p))))); 18217EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), tmp); 18218} else { 18219EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18220} 18221 } 18222 18223 /** 18224 * Emit code for rule number 434: 18225 * szp: LONG_AND(r, rlv) 18226 * @param p BURS node to apply the rule to 18227 */ 18228 private void code434(AbstractBURS_TreeNode p) { 18229 EMIT(MIR_Test.mutate(P(p), IA32_TEST, Binary.getVal1(P(p)), Binary.getVal2(P(p)))); 18230 } 18231 18232 /** 18233 * Emit code for rule number 435: 18234 * szpr: LONG_AND(rlv, load64) 18235 * @param p BURS node to apply the rule to 18236 */ 18237 private void code435(AbstractBURS_TreeNode p) { 18238 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 18239 } 18240 18241 /** 18242 * Emit code for rule number 436: 18243 * szpr: LONG_AND(load64, rlv) 18244 * @param p BURS node to apply the rule to 18245 */ 18246 private void code436(AbstractBURS_TreeNode p) { 18247 if (Binary.getVal2(P(p)).isLongConstant()) { 18248Register tmp = regpool.getLong(); 18249EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Long), Binary.getVal2(P(p))))); 18250EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), new RegisterOperand(tmp, TypeReference.Long), consumeMO()); 18251} else { 18252EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 18253} 18254 } 18255 18256 /** 18257 * Emit code for rule number 437: 18258 * szp: LONG_AND(load8_16_32_64, rlv) 18259 * @param p BURS node to apply the rule to 18260 */ 18261 private void code437(AbstractBURS_TreeNode p) { 18262 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal2(P(p)))); 18263 } 18264 18265 /** 18266 * Emit code for rule number 438: 18267 * szp: LONG_AND(r, load8_16_32_64) 18268 * @param p BURS node to apply the rule to 18269 */ 18270 private void code438(AbstractBURS_TreeNode p) { 18271 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal1(P(p)))); 18272 } 18273 18274 /** 18275 * Emit code for rule number 439: 18276 * stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18277 * @param p BURS node to apply the rule to 18278 */ 18279 private void code439(AbstractBURS_TreeNode p) { 18280 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)) ); 18281 } 18282 18283 /** 18284 * Emit code for rule number 440: 18285 * stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18286 * @param p BURS node to apply the rule to 18287 */ 18288 private void code440(AbstractBURS_TreeNode p) { 18289 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)) ); 18290 } 18291 18292 /** 18293 * Emit code for rule number 441: 18294 * stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18295 * @param p BURS node to apply the rule to 18296 */ 18297 private void code441(AbstractBURS_TreeNode p) { 18298 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)) ); 18299 } 18300 18301 /** 18302 * Emit code for rule number 442: 18303 * stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18304 * @param p BURS node to apply the rule to 18305 */ 18306 private void code442(AbstractBURS_TreeNode p) { 18307 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)) ); 18308 } 18309 18310 /** 18311 * Emit code for rule number 443: 18312 * r: LONG_DIV(rlv, rlv) 18313 * @param p BURS node to apply the rule to 18314 */ 18315 private void code443(AbstractBURS_TreeNode p) { 18316 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18317 GuardedBinary.getVal2(P(p)), true, true); 18318 } 18319 18320 /** 18321 * Emit code for rule number 444: 18322 * r: LONG_DIV(rlv, riv) 18323 * @param p BURS node to apply the rule to 18324 */ 18325 private void code444(AbstractBURS_TreeNode p) { 18326 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18327 GuardedBinary.getVal2(P(p)), true, true); 18328 } 18329 18330 /** 18331 * Emit code for rule number 445: 18332 * r: LONG_DIV(riv, rlv) 18333 * @param p BURS node to apply the rule to 18334 */ 18335 private void code445(AbstractBURS_TreeNode p) { 18336 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18337 GuardedBinary.getVal2(P(p)), true, true); 18338 } 18339 18340 /** 18341 * Emit code for rule number 446: 18342 * r: LONG_DIV(rlv, load64) 18343 * @param p BURS node to apply the rule to 18344 */ 18345 private void code446(AbstractBURS_TreeNode p) { 18346 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18347 consumeMO(), true, true); 18348 } 18349 18350 /** 18351 * Emit code for rule number 447: 18352 * r: LONG_DIV(load64,rlv) 18353 * @param p BURS node to apply the rule to 18354 */ 18355 private void code447(AbstractBURS_TreeNode p) { 18356 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), consumeMO(), GuardedBinary.getVal2(P(p)), 18357 true, true); 18358 } 18359 18360 /** 18361 * Emit code for rule number 448: 18362 * stm: LONG_IFCMP(rlv,rlv) 18363 * @param p BURS node to apply the rule to 18364 */ 18365 private void code448(AbstractBURS_TreeNode p) { 18366 if (IfCmp.getVal1(P(p)).isLongConstant()) { 18367Register tmp = regpool.getLong(); 18368EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Long),IfCmp.getVal1(P(p))))); 18369IFCMP(P(p), IfCmp.getGuardResult(P(p)), new RegisterOperand(tmp, TypeReference.Long), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 18370} else if (IfCmp.getVal2(P(p)).isLongConstant()) { 18371Register tmp = regpool.getLong(); 18372EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Long), IfCmp.getVal2(P(p))))); 18373IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), new RegisterOperand(tmp, TypeReference.Long), IfCmp.getCond(P(p))); 18374} else { 18375IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 18376} 18377 } 18378 18379 /** 18380 * Emit code for rule number 449: 18381 * stm: LONG_IFCMP(r, LONG_CONSTANT) 18382 * @param p BURS node to apply the rule to 18383 */ 18384 private void code449(AbstractBURS_TreeNode p) { 18385 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 18386EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, IfCmp.getVal1(P(p)), IfCmp.getVal1(P(p)).copy()))); 18387EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 18388 } 18389 18390 /** 18391 * Emit code for rule number 450: 18392 * r: LONG_LOAD(rlv, rlv) 18393 * @param p BURS node to apply the rule to 18394 */ 18395 private void code450(AbstractBURS_TreeNode p) { 18396 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), MO_L(P(p), QW))); 18397 } 18398 18399 /** 18400 * Emit code for rule number 451: 18401 * r: LONG_LOAD(rlv, address1scaledreg) 18402 * @param p BURS node to apply the rule to 18403 */ 18404 private void code451(AbstractBURS_TreeNode p) { 18405 augmentAddress(Load.getAddress(P(p))); 18406EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 18407 consumeAddress(QW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 18408 } 18409 18410 /** 18411 * Emit code for rule number 452: 18412 * r: LONG_LOAD(address1scaledreg, rlv) 18413 * @param p BURS node to apply the rule to 18414 */ 18415 private void code452(AbstractBURS_TreeNode p) { 18416 augmentAddress(Load.getOffset(P(p))); 18417EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 18418 consumeAddress(QW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 18419 } 18420 18421 /** 18422 * Emit code for rule number 453: 18423 * r: LONG_LOAD(address1scaledreg, address1reg) 18424 * @param p BURS node to apply the rule to 18425 */ 18426 private void code453(AbstractBURS_TreeNode p) { 18427 combineAddresses(); 18428EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 18429 consumeAddress(QW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 18430 } 18431 18432 /** 18433 * Emit code for rule number 454: 18434 * r: LONG_LOAD(address1reg, address1scaledreg) 18435 * @param p BURS node to apply the rule to 18436 */ 18437 private void code454(AbstractBURS_TreeNode p) { 18438 combineAddresses(); 18439EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 18440 consumeAddress(QW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 18441 } 18442 18443 /** 18444 * Emit code for rule number 455: 18445 * r: LONG_LOAD(address, LONG_CONSTANT) 18446 * @param p BURS node to apply the rule to 18447 */ 18448 private void code455(AbstractBURS_TreeNode p) { 18449 augmentAddress(Load.getOffset(P(p))); 18450EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 18451 consumeAddress(QW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 18452 } 18453 18454 /** 18455 * Emit code for rule number 456: 18456 * r: LONG_ALOAD(rlv, riv) 18457 * @param p BURS node to apply the rule to 18458 */ 18459 private void code456(AbstractBURS_TreeNode p) { 18460 EMIT(MIR_Move.mutate(P(p), IA32_MOV, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 18461 } 18462 18463 /** 18464 * Emit code for rule number 457: 18465 * r: LONG_ALOAD(rlv, r) 18466 * @param p BURS node to apply the rule to 18467 */ 18468 private void code457(AbstractBURS_TreeNode p) { 18469 RegisterOperand index = ALoad.getIndex(P(p)).asRegister(); 18470if (index.getRegister().isInteger()) { 18471EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 18472EMIT(MIR_Move.mutate(P(p), IA32_MOV, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 18473} else { 18474EMIT(MIR_Move.mutate(P(p), IA32_MOV, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 18475} 18476 } 18477 18478 /** 18479 * Emit code for rule number 458: 18480 * r: LONG_MOVE(rlv) 18481 * @param p BURS node to apply the rule to 18482 */ 18483 private void code458(AbstractBURS_TreeNode p) { 18484 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 18485 } 18486 18487 /** 18488 * Emit code for rule number 459: 18489 * r: LONG_MOVE(riv) 18490 * @param p BURS node to apply the rule to 18491 */ 18492 private void code459(AbstractBURS_TreeNode p) { 18493 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 18494 } 18495 18496 /** 18497 * Emit code for rule number 461: 18498 * r: LONG_MUL(r, rlv) 18499 * @param p BURS node to apply the rule to 18500 */ 18501 private void code461(AbstractBURS_TreeNode p) { 18502 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18503 } 18504 18505 /** 18506 * Emit code for rule number 462: 18507 * r: INT_MUL(r, load64) 18508 * @param p BURS node to apply the rule to 18509 */ 18510 private void code462(AbstractBURS_TreeNode p) { 18511 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 18512 } 18513 18514 /** 18515 * Emit code for rule number 463: 18516 * r: INT_MUL(load64, rlv) 18517 * @param p BURS node to apply the rule to 18518 */ 18519 private void code463(AbstractBURS_TreeNode p) { 18520 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 18521 } 18522 18523 /** 18524 * Emit code for rule number 464: 18525 * szpr: LONG_NEG(r) 18526 * @param p BURS node to apply the rule to 18527 */ 18528 private void code464(AbstractBURS_TreeNode p) { 18529 EMIT_Unary(IA32_NEG, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 18530 } 18531 18532 /** 18533 * Emit code for rule number 465: 18534 * stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 18535 * @param p BURS node to apply the rule to 18536 */ 18537 private void code465(AbstractBURS_TreeNode p) { 18538 EMIT_Unary(IA32_NEG, P(p), MO_S(P(p), QW), MO_S(P(p), QW)); 18539 } 18540 18541 /** 18542 * Emit code for rule number 466: 18543 * stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 18544 * @param p BURS node to apply the rule to 18545 */ 18546 private void code466(AbstractBURS_TreeNode p) { 18547 EMIT_Unary(IA32_NEG, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW)); 18548 } 18549 18550 /** 18551 * Emit code for rule number 467: 18552 * r: LONG_NOT(r) 18553 * @param p BURS node to apply the rule to 18554 */ 18555 private void code467(AbstractBURS_TreeNode p) { 18556 EMIT_Unary(IA32_NOT, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 18557 } 18558 18559 /** 18560 * Emit code for rule number 468: 18561 * stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 18562 * @param p BURS node to apply the rule to 18563 */ 18564 private void code468(AbstractBURS_TreeNode p) { 18565 EMIT_Unary(IA32_NOT, P(p), MO_S(P(p), QW), MO_S(P(p), QW)); 18566 } 18567 18568 /** 18569 * Emit code for rule number 469: 18570 * stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 18571 * @param p BURS node to apply the rule to 18572 */ 18573 private void code469(AbstractBURS_TreeNode p) { 18574 EMIT_Unary(IA32_NOT, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW)); 18575 } 18576 18577 /** 18578 * Emit code for rule number 470: 18579 * szpr: LONG_OR(r, rlv) 18580 * @param p BURS node to apply the rule to 18581 */ 18582 private void code470(AbstractBURS_TreeNode p) { 18583 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18584 } 18585 18586 /** 18587 * Emit code for rule number 471: 18588 * szpr: LONG_OR(r, load64) 18589 * @param p BURS node to apply the rule to 18590 */ 18591 private void code471(AbstractBURS_TreeNode p) { 18592 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 18593 } 18594 18595 /** 18596 * Emit code for rule number 472: 18597 * szpr: LONG_OR(load64, rlv) 18598 * @param p BURS node to apply the rule to 18599 */ 18600 private void code472(AbstractBURS_TreeNode p) { 18601 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 18602 } 18603 18604 /** 18605 * Emit code for rule number 473: 18606 * stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18607 * @param p BURS node to apply the rule to 18608 */ 18609 private void code473(AbstractBURS_TreeNode p) { 18610 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)) ); 18611 } 18612 18613 /** 18614 * Emit code for rule number 474: 18615 * stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18616 * @param p BURS node to apply the rule to 18617 */ 18618 private void code474(AbstractBURS_TreeNode p) { 18619 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)) ); 18620 } 18621 18622 /** 18623 * Emit code for rule number 475: 18624 * stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18625 * @param p BURS node to apply the rule to 18626 */ 18627 private void code475(AbstractBURS_TreeNode p) { 18628 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)) ); 18629 } 18630 18631 /** 18632 * Emit code for rule number 476: 18633 * stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18634 * @param p BURS node to apply the rule to 18635 */ 18636 private void code476(AbstractBURS_TreeNode p) { 18637 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)) ); 18638 } 18639 18640 /** 18641 * Emit code for rule number 477: 18642 * r: LONG_REM(rlv, rlv) 18643 * @param p BURS node to apply the rule to 18644 */ 18645 private void code477(AbstractBURS_TreeNode p) { 18646 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18647 GuardedBinary.getVal2(P(p)), false, true); 18648 } 18649 18650 /** 18651 * Emit code for rule number 478: 18652 * r: LONG_REM(rlv, riv) 18653 * @param p BURS node to apply the rule to 18654 */ 18655 private void code478(AbstractBURS_TreeNode p) { 18656 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18657 GuardedBinary.getVal2(P(p)), false, true); 18658 } 18659 18660 /** 18661 * Emit code for rule number 479: 18662 * r: LONG_REM(riv, rlv) 18663 * @param p BURS node to apply the rule to 18664 */ 18665 private void code479(AbstractBURS_TreeNode p) { 18666 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18667 GuardedBinary.getVal2(P(p)), false, true); 18668 } 18669 18670 /** 18671 * Emit code for rule number 480: 18672 * r: LONG_REM(rlv, load64) 18673 * @param p BURS node to apply the rule to 18674 */ 18675 private void code480(AbstractBURS_TreeNode p) { 18676 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 18677 consumeMO(), false, true); 18678 } 18679 18680 /** 18681 * Emit code for rule number 481: 18682 * r: LONG_REM(load64,rlv) 18683 * @param p BURS node to apply the rule to 18684 */ 18685 private void code481(AbstractBURS_TreeNode p) { 18686 LONG_DIVIDES(P(p), GuardedBinary.getResult(P(p)), consumeMO(), GuardedBinary.getVal2(P(p)), 18687 false, true); 18688 } 18689 18690 /** 18691 * Emit code for rule number 482: 18692 * szpr: LONG_SHL(rlv, INT_AND(r, INT_CONSTANT)) 18693 * @param p BURS node to apply the rule to 18694 */ 18695 private void code482(AbstractBURS_TreeNode p) { 18696 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 18697EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 18698 } 18699 18700 /** 18701 * Emit code for rule number 483: 18702 * szpr: LONG_SHL(rlv, riv) 18703 * @param p BURS node to apply the rule to 18704 */ 18705 private void code483(AbstractBURS_TreeNode p) { 18706 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 18707EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 18708 } 18709 18710 /** 18711 * Emit code for rule number 484: 18712 * szpr: LONG_SHL(r, INT_CONSTANT) 18713 * @param p BURS node to apply the rule to 18714 */ 18715 private void code484(AbstractBURS_TreeNode p) { 18716 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 63); if(Binary.getVal2(P(p)).asIntConstant().value == 1) { 18717 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(P(p)).copy()); 18718} else { 18719 EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18720} 18721 } 18722 18723 /** 18724 * Emit code for rule number 485: 18725 * r: LONG_SHL(r, INT_CONSTANT) 18726 * @param p BURS node to apply the rule to 18727 */ 18728 private void code485(AbstractBURS_TreeNode p) { 18729 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 18730EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(QW, null, null)); 18731 } 18732 18733 /** 18734 * Emit code for rule number 486: 18735 * szpr: LONG_SHL(LONG_SHR(r, INT_CONSTANT), INT_CONSTANT) 18736 * @param p BURS node to apply the rule to 18737 */ 18738 private void code486(AbstractBURS_TreeNode p) { 18739 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)), IC(0xffffffff << VR(p))); 18740 } 18741 18742 /** 18743 * Emit code for rule number 487: 18744 * stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 18745 * @param p BURS node to apply the rule to 18746 */ 18747 private void code487(AbstractBURS_TreeNode p) { 18748 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 18749EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), QW), new RegisterOperand(getECX(), TypeReference.Int))); 18750 } 18751 18752 /** 18753 * Emit code for rule number 488: 18754 * stm: LONG_STORE(LONG_SHL(LONG_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 18755 * @param p BURS node to apply the rule to 18756 */ 18757 private void code488(AbstractBURS_TreeNode p) { 18758 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 63); 18759EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), QW), Binary.getVal2(PL(p)))); 18760 } 18761 18762 /** 18763 * Emit code for rule number 489: 18764 * stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 18765 * @param p BURS node to apply the rule to 18766 */ 18767 private void code489(AbstractBURS_TreeNode p) { 18768 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 18769EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), QW_S, QW), new RegisterOperand(getECX(), TypeReference.Int))); 18770 } 18771 18772 /** 18773 * Emit code for rule number 490: 18774 * stm: LONG_ASTORE(LONG_SHL(LONG_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 18775 * @param p BURS node to apply the rule to 18776 */ 18777 private void code490(AbstractBURS_TreeNode p) { 18778 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)))); 18779 } 18780 18781 /** 18782 * Emit code for rule number 491: 18783 * szpr: LONG_SHR(rlv, INT_AND(r, LONG_CONSTANT)) 18784 * @param p BURS node to apply the rule to 18785 */ 18786 private void code491(AbstractBURS_TreeNode p) { 18787 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 18788EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 18789 } 18790 18791 /** 18792 * Emit code for rule number 492: 18793 * szpr: LONG_SHR(rlv, riv) 18794 * @param p BURS node to apply the rule to 18795 */ 18796 private void code492(AbstractBURS_TreeNode p) { 18797 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 18798EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 18799 } 18800 18801 /** 18802 * Emit code for rule number 493: 18803 * szpr: LONG_SHR(rlv, LONG_CONSTANT) 18804 * @param p BURS node to apply the rule to 18805 */ 18806 private void code493(AbstractBURS_TreeNode p) { 18807 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 63); 18808EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18809 } 18810 18811 /** 18812 * Emit code for rule number 494: 18813 * stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv),INT_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 18814 * @param p BURS node to apply the rule to 18815 */ 18816 private void code494(AbstractBURS_TreeNode p) { 18817 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 18818EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), QW), new RegisterOperand(getECX(), TypeReference.Int))); 18819 } 18820 18821 /** 18822 * Emit code for rule number 495: 18823 * stm: LONG_STORE(LONG_SHR(LONG_LOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 18824 * @param p BURS node to apply the rule to 18825 */ 18826 private void code495(AbstractBURS_TreeNode p) { 18827 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 63); 18828EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), QW), Binary.getVal2(PL(p)))); 18829 } 18830 18831 /** 18832 * Emit code for rule number 496: 18833 * stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv),INT_AND(r, LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 18834 * @param p BURS node to apply the rule to 18835 */ 18836 private void code496(AbstractBURS_TreeNode p) { 18837 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 18838EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), QW_S, QW), new RegisterOperand(getECX(), TypeReference.Int))); 18839 } 18840 18841 /** 18842 * Emit code for rule number 497: 18843 * stm: LONG_ASTORE(LONG_SHR(LONG_ALOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 18844 * @param p BURS node to apply the rule to 18845 */ 18846 private void code497(AbstractBURS_TreeNode p) { 18847 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)))); 18848 } 18849 18850 /** 18851 * Emit code for rule number 498: 18852 * stm: LONG_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 18853 * @param p BURS node to apply the rule to 18854 */ 18855 private void code498(AbstractBURS_TreeNode p) { 18856 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), QW), Store.getValue(P(p)))); 18857 } 18858 18859 /** 18860 * Emit code for rule number 499: 18861 * stm: LONG_STORE(rlv, OTHER_OPERAND(rlv, address1scaledreg)) 18862 * @param p BURS node to apply the rule to 18863 */ 18864 private void code499(AbstractBURS_TreeNode p) { 18865 augmentAddress(Store.getAddress(P(p))); 18866EMIT(MIR_Move.mutate(P(p), IA32_MOV, 18867 consumeAddress(QW, Store.getLocation(P(p)), Store.getGuard(P(p))), 18868 Store.getValue(P(p)))); 18869 } 18870 18871 /** 18872 * Emit code for rule number 500: 18873 * stm: LONG_STORE(rlv, OTHER_OPERAND(address1scaledreg, rlv)) 18874 * @param p BURS node to apply the rule to 18875 */ 18876 private void code500(AbstractBURS_TreeNode p) { 18877 augmentAddress(Store.getOffset(P(p))); 18878EMIT(MIR_Move.mutate(P(p), IA32_MOV, 18879 consumeAddress(QW, Store.getLocation(P(p)), Store.getGuard(P(p))), 18880 Store.getValue(P(p)))); 18881 } 18882 18883 /** 18884 * Emit code for rule number 501: 18885 * stm: LONG_STORE(rlv, OTHER_OPERAND(address1scaledreg, address1reg)) 18886 * @param p BURS node to apply the rule to 18887 */ 18888 private void code501(AbstractBURS_TreeNode p) { 18889 combineAddresses(); 18890EMIT(MIR_Move.mutate(P(p), IA32_MOV, 18891 consumeAddress(QW, Store.getLocation(P(p)), Store.getGuard(P(p))), 18892 Store.getValue(P(p)))); 18893 } 18894 18895 /** 18896 * Emit code for rule number 502: 18897 * stm: LONG_STORE(rlv, OTHER_OPERAND(address1reg, address1scaledreg)) 18898 * @param p BURS node to apply the rule to 18899 */ 18900 private void code502(AbstractBURS_TreeNode p) { 18901 combineAddresses(); 18902EMIT(MIR_Move.mutate(P(p), IA32_MOV, 18903 consumeAddress(QW, Store.getLocation(P(p)), Store.getGuard(P(p))), 18904 Store.getValue(P(p)))); 18905 } 18906 18907 /** 18908 * Emit code for rule number 503: 18909 * stm: LONG_STORE(rlv, OTHER_OPERAND(address, LONG_CONSTANT)) 18910 * @param p BURS node to apply the rule to 18911 */ 18912 private void code503(AbstractBURS_TreeNode p) { 18913 augmentAddress(Store.getOffset(P(p))); 18914EMIT(MIR_Move.mutate(P(p), IA32_MOV, 18915 consumeAddress(QW, Store.getLocation(P(p)), Store.getGuard(P(p))), 18916 Store.getValue(P(p)))); 18917 } 18918 18919 /** 18920 * Emit code for rule number 504: 18921 * czr: LONG_SUB(rlv, r) 18922 * @param p BURS node to apply the rule to 18923 */ 18924 private void code504(AbstractBURS_TreeNode p) { 18925 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 18926 } 18927 18928 /** 18929 * Emit code for rule number 505: 18930 * r: LONG_SUB(rlv, r) 18931 * @param p BURS node to apply the rule to 18932 */ 18933 private void code505(AbstractBURS_TreeNode p) { 18934 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 18935EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), Binary.getVal1(P(p)))); 18936 } 18937 18938 /** 18939 * Emit code for rule number 506: 18940 * r: LONG_SUB(load64, r) 18941 * @param p BURS node to apply the rule to 18942 */ 18943 private void code506(AbstractBURS_TreeNode p) { 18944 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 18945EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), consumeMO())); 18946 } 18947 18948 /** 18949 * Emit code for rule number 507: 18950 * czr: LONG_SUB(rlv, load64) 18951 * @param p BURS node to apply the rule to 18952 */ 18953 private void code507(AbstractBURS_TreeNode p) { 18954 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 18955 } 18956 18957 /** 18958 * Emit code for rule number 508: 18959 * czr: LONG_SUB(load64, rlv) 18960 * @param p BURS node to apply the rule to 18961 */ 18962 private void code508(AbstractBURS_TreeNode p) { 18963 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), consumeMO(), Binary.getVal2(P(p))); 18964 } 18965 18966 /** 18967 * Emit code for rule number 509: 18968 * stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18969 * @param p BURS node to apply the rule to 18970 */ 18971 private void code509(AbstractBURS_TreeNode p) { 18972 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_S(P(p), QW), Binary.getVal2(PL(p)))); 18973 } 18974 18975 /** 18976 * Emit code for rule number 510: 18977 * stm: LONG_STORE(LONG_SUB(rlv, LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18978 * @param p BURS node to apply the rule to 18979 */ 18980 private void code510(AbstractBURS_TreeNode p) { 18981 MemoryOperand result = MO_S(P(p), QW); 18982EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 18983EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 18984 } 18985 18986 /** 18987 * Emit code for rule number 511: 18988 * stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 18989 * @param p BURS node to apply the rule to 18990 */ 18991 private void code511(AbstractBURS_TreeNode p) { 18992 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)))); 18993 } 18994 18995 /** 18996 * Emit code for rule number 512: 18997 * stm: LONG_ASTORE(LONG_SUB(rlv, LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 18998 * @param p BURS node to apply the rule to 18999 */ 19000 private void code512(AbstractBURS_TreeNode p) { 19001 MemoryOperand result = MO_AS(P(p), QW_S, QW); 19002EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 19003EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 19004 } 19005 19006 /** 19007 * Emit code for rule number 513: 19008 * szpr: LONG_USHR(rlv, LONG_AND(r, LONG_CONSTANT)) 19009 * @param p BURS node to apply the rule to 19010 */ 19011 private void code513(AbstractBURS_TreeNode p) { 19012 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 19013EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 19014 } 19015 19016 /** 19017 * Emit code for rule number 514: 19018 * szpr: LONG_USHR(rlv, riv) 19019 * @param p BURS node to apply the rule to 19020 */ 19021 private void code514(AbstractBURS_TreeNode p) { 19022 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 19023EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 19024 } 19025 19026 /** 19027 * Emit code for rule number 515: 19028 * szpr: LONG_USHR(rlv, LONG_CONSTANT) 19029 * @param p BURS node to apply the rule to 19030 */ 19031 private void code515(AbstractBURS_TreeNode p) { 19032 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 63); 19033EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19034 } 19035 19036 /** 19037 * Emit code for rule number 516: 19038 * stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv),LONG_AND(r,LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 19039 * @param p BURS node to apply the rule to 19040 */ 19041 private void code516(AbstractBURS_TreeNode p) { 19042 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 19043EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), QW), new RegisterOperand(getECX(), TypeReference.Int))); 19044 } 19045 19046 /** 19047 * Emit code for rule number 517: 19048 * stm: LONG_STORE(LONG_USHR(LONG_LOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 19049 * @param p BURS node to apply the rule to 19050 */ 19051 private void code517(AbstractBURS_TreeNode p) { 19052 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 63); 19053EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), QW), Binary.getVal2(PL(p)))); 19054 } 19055 19056 /** 19057 * Emit code for rule number 518: 19058 * stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv),LONG_AND(r, LONG_CONSTANT)),OTHER_OPERAND(riv, riv)) 19059 * @param p BURS node to apply the rule to 19060 */ 19061 private void code518(AbstractBURS_TreeNode p) { 19062 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 19063EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), QW_S, QW), new RegisterOperand(getECX(), TypeReference.Int))); 19064 } 19065 19066 /** 19067 * Emit code for rule number 519: 19068 * stm: LONG_ASTORE(LONG_USHR(LONG_ALOAD(riv,riv), LONG_CONSTANT),OTHER_OPERAND(riv, riv)) 19069 * @param p BURS node to apply the rule to 19070 */ 19071 private void code519(AbstractBURS_TreeNode p) { 19072 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)))); 19073 } 19074 19075 /** 19076 * Emit code for rule number 520: 19077 * szpr: LONG_XOR(r, rlv) 19078 * @param p BURS node to apply the rule to 19079 */ 19080 private void code520(AbstractBURS_TreeNode p) { 19081 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19082 } 19083 19084 /** 19085 * Emit code for rule number 521: 19086 * szpr: LONG_XOR(r, load64) 19087 * @param p BURS node to apply the rule to 19088 */ 19089 private void code521(AbstractBURS_TreeNode p) { 19090 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19091 } 19092 19093 /** 19094 * Emit code for rule number 522: 19095 * szpr: LONG_XOR(load64, rlv) 19096 * @param p BURS node to apply the rule to 19097 */ 19098 private void code522(AbstractBURS_TreeNode p) { 19099 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 19100 } 19101 19102 /** 19103 * Emit code for rule number 523: 19104 * stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 19105 * @param p BURS node to apply the rule to 19106 */ 19107 private void code523(AbstractBURS_TreeNode p) { 19108 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)) ); 19109 } 19110 19111 /** 19112 * Emit code for rule number 524: 19113 * stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 19114 * @param p BURS node to apply the rule to 19115 */ 19116 private void code524(AbstractBURS_TreeNode p) { 19117 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)) ); 19118 } 19119 19120 /** 19121 * Emit code for rule number 525: 19122 * stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 19123 * @param p BURS node to apply the rule to 19124 */ 19125 private void code525(AbstractBURS_TreeNode p) { 19126 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)) ); 19127 } 19128 19129 /** 19130 * Emit code for rule number 526: 19131 * stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 19132 * @param p BURS node to apply the rule to 19133 */ 19134 private void code526(AbstractBURS_TreeNode p) { 19135 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)) ); 19136 } 19137 19138 /** 19139 * Emit code for rule number 527: 19140 * r: FLOAT_ADD(r, r) 19141 * @param p BURS node to apply the rule to 19142 */ 19143 private void code527(AbstractBURS_TreeNode p) { 19144 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19145 } 19146 19147 /** 19148 * Emit code for rule number 528: 19149 * r: FLOAT_ADD(r, float_load) 19150 * @param p BURS node to apply the rule to 19151 */ 19152 private void code528(AbstractBURS_TreeNode p) { 19153 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19154 } 19155 19156 /** 19157 * Emit code for rule number 529: 19158 * r: FLOAT_ADD(float_load,r) 19159 * @param p BURS node to apply the rule to 19160 */ 19161 private void code529(AbstractBURS_TreeNode p) { 19162 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 19163 } 19164 19165 /** 19166 * Emit code for rule number 530: 19167 * r: DOUBLE_ADD(r, r) 19168 * @param p BURS node to apply the rule to 19169 */ 19170 private void code530(AbstractBURS_TreeNode p) { 19171 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), Binary.getVal1(P(p))); 19172 } 19173 19174 /** 19175 * Emit code for rule number 531: 19176 * r: DOUBLE_ADD(r, double_load) 19177 * @param p BURS node to apply the rule to 19178 */ 19179 private void code531(AbstractBURS_TreeNode p) { 19180 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19181 } 19182 19183 /** 19184 * Emit code for rule number 532: 19185 * r: DOUBLE_ADD(double_load,r) 19186 * @param p BURS node to apply the rule to 19187 */ 19188 private void code532(AbstractBURS_TreeNode p) { 19189 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 19190 } 19191 19192 /** 19193 * Emit code for rule number 533: 19194 * r: FLOAT_SUB(r, r) 19195 * @param p BURS node to apply the rule to 19196 */ 19197 private void code533(AbstractBURS_TreeNode p) { 19198 SSE2_NCOP(IA32_SUBSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19199 } 19200 19201 /** 19202 * Emit code for rule number 534: 19203 * r: FLOAT_SUB(r, float_load) 19204 * @param p BURS node to apply the rule to 19205 */ 19206 private void code534(AbstractBURS_TreeNode p) { 19207 SSE2_NCOP(IA32_SUBSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19208 } 19209 19210 /** 19211 * Emit code for rule number 535: 19212 * r: DOUBLE_SUB(r, r) 19213 * @param p BURS node to apply the rule to 19214 */ 19215 private void code535(AbstractBURS_TreeNode p) { 19216 SSE2_NCOP(IA32_SUBSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19217 } 19218 19219 /** 19220 * Emit code for rule number 536: 19221 * r: DOUBLE_SUB(r, double_load) 19222 * @param p BURS node to apply the rule to 19223 */ 19224 private void code536(AbstractBURS_TreeNode p) { 19225 SSE2_NCOP(IA32_SUBSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19226 } 19227 19228 /** 19229 * Emit code for rule number 537: 19230 * r: FLOAT_MUL(r, r) 19231 * @param p BURS node to apply the rule to 19232 */ 19233 private void code537(AbstractBURS_TreeNode p) { 19234 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19235 } 19236 19237 /** 19238 * Emit code for rule number 538: 19239 * r: FLOAT_MUL(r, float_load) 19240 * @param p BURS node to apply the rule to 19241 */ 19242 private void code538(AbstractBURS_TreeNode p) { 19243 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19244 } 19245 19246 /** 19247 * Emit code for rule number 539: 19248 * r: FLOAT_MUL(float_load, r) 19249 * @param p BURS node to apply the rule to 19250 */ 19251 private void code539(AbstractBURS_TreeNode p) { 19252 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 19253 } 19254 19255 /** 19256 * Emit code for rule number 540: 19257 * r: DOUBLE_MUL(r, r) 19258 * @param p BURS node to apply the rule to 19259 */ 19260 private void code540(AbstractBURS_TreeNode p) { 19261 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19262 } 19263 19264 /** 19265 * Emit code for rule number 541: 19266 * r: DOUBLE_MUL(r, double_load) 19267 * @param p BURS node to apply the rule to 19268 */ 19269 private void code541(AbstractBURS_TreeNode p) { 19270 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19271 } 19272 19273 /** 19274 * Emit code for rule number 542: 19275 * r: DOUBLE_MUL(double_load, r) 19276 * @param p BURS node to apply the rule to 19277 */ 19278 private void code542(AbstractBURS_TreeNode p) { 19279 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 19280 } 19281 19282 /** 19283 * Emit code for rule number 543: 19284 * r: FLOAT_DIV(r, r) 19285 * @param p BURS node to apply the rule to 19286 */ 19287 private void code543(AbstractBURS_TreeNode p) { 19288 SSE2_NCOP(IA32_DIVSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19289 } 19290 19291 /** 19292 * Emit code for rule number 544: 19293 * r: FLOAT_DIV(r, float_load) 19294 * @param p BURS node to apply the rule to 19295 */ 19296 private void code544(AbstractBURS_TreeNode p) { 19297 SSE2_NCOP(IA32_DIVSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19298 } 19299 19300 /** 19301 * Emit code for rule number 545: 19302 * r: DOUBLE_DIV(r, r) 19303 * @param p BURS node to apply the rule to 19304 */ 19305 private void code545(AbstractBURS_TreeNode p) { 19306 SSE2_NCOP(IA32_DIVSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 19307 } 19308 19309 /** 19310 * Emit code for rule number 546: 19311 * r: DOUBLE_DIV(r, double_load) 19312 * @param p BURS node to apply the rule to 19313 */ 19314 private void code546(AbstractBURS_TreeNode p) { 19315 SSE2_NCOP(IA32_DIVSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 19316 } 19317 19318 /** 19319 * Emit code for rule number 547: 19320 * r: FLOAT_NEG(r) 19321 * @param p BURS node to apply the rule to 19322 */ 19323 private void code547(AbstractBURS_TreeNode p) { 19324 SSE2_NEG(true, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19325 } 19326 19327 /** 19328 * Emit code for rule number 548: 19329 * r: DOUBLE_NEG(r) 19330 * @param p BURS node to apply the rule to 19331 */ 19332 private void code548(AbstractBURS_TreeNode p) { 19333 SSE2_NEG(false, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19334 } 19335 19336 /** 19337 * Emit code for rule number 549: 19338 * r: FLOAT_SQRT(r) 19339 * @param p BURS node to apply the rule to 19340 */ 19341 private void code549(AbstractBURS_TreeNode p) { 19342 EMIT(MIR_Unary.mutate(P(p), IA32_SQRTSS, Unary.getResult(P(p)), Unary.getVal(P(p)))); 19343 } 19344 19345 /** 19346 * Emit code for rule number 550: 19347 * r: DOUBLE_SQRT(r) 19348 * @param p BURS node to apply the rule to 19349 */ 19350 private void code550(AbstractBURS_TreeNode p) { 19351 EMIT(MIR_Unary.mutate(P(p), IA32_SQRTSD, Unary.getResult(P(p)), Unary.getVal(P(p)))); 19352 } 19353 19354 /** 19355 * Emit code for rule number 551: 19356 * r: FLOAT_REM(r, r) 19357 * @param p BURS node to apply the rule to 19358 */ 19359 private void code551(AbstractBURS_TreeNode p) { 19360 SSE2_X87_REM(P(p)); 19361 } 19362 19363 /** 19364 * Emit code for rule number 552: 19365 * r: DOUBLE_REM(r, r) 19366 * @param p BURS node to apply the rule to 19367 */ 19368 private void code552(AbstractBURS_TreeNode p) { 19369 SSE2_X87_REM(P(p)); 19370 } 19371 19372 /** 19373 * Emit code for rule number 553: 19374 * r: LONG_2FLOAT(r) 19375 * @param p BURS node to apply the rule to 19376 */ 19377 private void code553(AbstractBURS_TreeNode p) { 19378 SSE2_X87_FROMLONG(P(p)); 19379 } 19380 19381 /** 19382 * Emit code for rule number 554: 19383 * r: LONG_2DOUBLE(r) 19384 * @param p BURS node to apply the rule to 19385 */ 19386 private void code554(AbstractBURS_TreeNode p) { 19387 SSE2_X87_FROMLONG(P(p)); 19388 } 19389 19390 /** 19391 * Emit code for rule number 555: 19392 * r: FLOAT_MOVE(r) 19393 * @param p BURS node to apply the rule to 19394 */ 19395 private void code555(AbstractBURS_TreeNode p) { 19396 EMIT(MIR_Move.mutate(P(p), IA32_MOVAPS, Move.getResult(P(p)), Move.getVal(P(p)))); 19397 } 19398 19399 /** 19400 * Emit code for rule number 556: 19401 * r: DOUBLE_MOVE(r) 19402 * @param p BURS node to apply the rule to 19403 */ 19404 private void code556(AbstractBURS_TreeNode p) { 19405 EMIT(MIR_Move.mutate(P(p), IA32_MOVAPD, Move.getResult(P(p)), Move.getVal(P(p)))); 19406 } 19407 19408 /** 19409 * Emit code for rule number 557: 19410 * r: DOUBLE_LOAD(riv, riv) 19411 * @param p BURS node to apply the rule to 19412 */ 19413 private void code557(AbstractBURS_TreeNode p) { 19414 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 19415 } 19416 19417 /** 19418 * Emit code for rule number 558: 19419 * r: DOUBLE_LOAD(riv, rlv) 19420 * @param p BURS node to apply the rule to 19421 */ 19422 private void code558(AbstractBURS_TreeNode p) { 19423 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 19424 } 19425 19426 /** 19427 * Emit code for rule number 559: 19428 * r: DOUBLE_LOAD(rlv, rlv) 19429 * @param p BURS node to apply the rule to 19430 */ 19431 private void code559(AbstractBURS_TreeNode p) { 19432 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 19433 } 19434 19435 /** 19436 * Emit code for rule number 560: 19437 * double_load: DOUBLE_LOAD(riv, riv) 19438 * @param p BURS node to apply the rule to 19439 */ 19440 private void code560(AbstractBURS_TreeNode p) { 19441 pushMO(MO_L(P(p), QW)); 19442 } 19443 19444 /** 19445 * Emit code for rule number 561: 19446 * r: DOUBLE_ALOAD(riv, riv) 19447 * @param p BURS node to apply the rule to 19448 */ 19449 private void code561(AbstractBURS_TreeNode p) { 19450 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 19451 } 19452 19453 /** 19454 * Emit code for rule number 562: 19455 * double_load: DOUBLE_LOAD(rlv, rlv) 19456 * @param p BURS node to apply the rule to 19457 */ 19458 private void code562(AbstractBURS_TreeNode p) { 19459 pushMO(MO_L(P(p), QW)); 19460 } 19461 19462 /** 19463 * Emit code for rule number 563: 19464 * r: DOUBLE_ALOAD(riv, r) 19465 * @param p BURS node to apply the rule to 19466 */ 19467 private void code563(AbstractBURS_TreeNode p) { 19468 RegisterOperand index=ALoad.getIndex(P(p)).asRegister(); 19469if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 19470EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 19471EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 19472}else{ 19473EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 19474} 19475 } 19476 19477 /** 19478 * Emit code for rule number 564: 19479 * r: DOUBLE_ALOAD(rlv, rlv) 19480 * @param p BURS node to apply the rule to 19481 */ 19482 private void code564(AbstractBURS_TreeNode p) { 19483 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 19484 } 19485 19486 /** 19487 * Emit code for rule number 565: 19488 * double_load: DOUBLE_ALOAD(riv, riv) 19489 * @param p BURS node to apply the rule to 19490 */ 19491 private void code565(AbstractBURS_TreeNode p) { 19492 pushMO(MO_AL(P(p), QW_S, QW)); 19493 } 19494 19495 /** 19496 * Emit code for rule number 566: 19497 * r: FLOAT_LOAD(riv, riv) 19498 * @param p BURS node to apply the rule to 19499 */ 19500 private void code566(AbstractBURS_TreeNode p) { 19501 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, Load.getResult(P(p)), MO_L(P(p), DW))); 19502 } 19503 19504 /** 19505 * Emit code for rule number 567: 19506 * r: FLOAT_LOAD(rlv, rlv) 19507 * @param p BURS node to apply the rule to 19508 */ 19509 private void code567(AbstractBURS_TreeNode p) { 19510 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, Load.getResult(P(p)), MO_L(P(p), DW))); 19511 } 19512 19513 /** 19514 * Emit code for rule number 568: 19515 * float_load: FLOAT_LOAD(riv, riv) 19516 * @param p BURS node to apply the rule to 19517 */ 19518 private void code568(AbstractBURS_TreeNode p) { 19519 pushMO(MO_L(P(p), DW)); 19520 } 19521 19522 /** 19523 * Emit code for rule number 569: 19524 * r: FLOAT_ALOAD(riv, riv) 19525 * @param p BURS node to apply the rule to 19526 */ 19527 private void code569(AbstractBURS_TreeNode p) { 19528 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 19529 } 19530 19531 /** 19532 * Emit code for rule number 570: 19533 * r: FLOAT_ALOAD(riv, r) 19534 * @param p BURS node to apply the rule to 19535 */ 19536 private void code570(AbstractBURS_TreeNode p) { 19537 RegisterOperand index=ALoad.getIndex(P(p)).asRegister(); 19538if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 19539EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 19540EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 19541}else{ 19542EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 19543} 19544 } 19545 19546 /** 19547 * Emit code for rule number 571: 19548 * r: FLOAT_ALOAD(rlv, rlv) 19549 * @param p BURS node to apply the rule to 19550 */ 19551 private void code571(AbstractBURS_TreeNode p) { 19552 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 19553 } 19554 19555 /** 19556 * Emit code for rule number 572: 19557 * float_load: FLOAT_ALOAD(riv, riv) 19558 * @param p BURS node to apply the rule to 19559 */ 19560 private void code572(AbstractBURS_TreeNode p) { 19561 pushMO(MO_AL(P(p), DW_S, DW)); 19562 } 19563 19564 /** 19565 * Emit code for rule number 573: 19566 * stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, riv)) 19567 * @param p BURS node to apply the rule to 19568 */ 19569 private void code573(AbstractBURS_TreeNode p) { 19570 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 19571 } 19572 19573 /** 19574 * Emit code for rule number 574: 19575 * stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, rlv)) 19576 * @param p BURS node to apply the rule to 19577 */ 19578 private void code574(AbstractBURS_TreeNode p) { 19579 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 19580 } 19581 19582 /** 19583 * Emit code for rule number 575: 19584 * stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, riv)) 19585 * @param p BURS node to apply the rule to 19586 */ 19587 private void code575(AbstractBURS_TreeNode p) { 19588 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 19589 } 19590 19591 /** 19592 * Emit code for rule number 576: 19593 * stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, rlv)) 19594 * @param p BURS node to apply the rule to 19595 */ 19596 private void code576(AbstractBURS_TreeNode p) { 19597 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 19598 } 19599 19600 /** 19601 * Emit code for rule number 577: 19602 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, riv)) 19603 * @param p BURS node to apply the rule to 19604 */ 19605 private void code577(AbstractBURS_TreeNode p) { 19606 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19607 } 19608 19609 /** 19610 * Emit code for rule number 578: 19611 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, riv)) 19612 * @param p BURS node to apply the rule to 19613 */ 19614 private void code578(AbstractBURS_TreeNode p) { 19615 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19616 } 19617 19618 /** 19619 * Emit code for rule number 579: 19620 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, rlv)) 19621 * @param p BURS node to apply the rule to 19622 */ 19623 private void code579(AbstractBURS_TreeNode p) { 19624 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19625 } 19626 19627 /** 19628 * Emit code for rule number 580: 19629 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 19630 * @param p BURS node to apply the rule to 19631 */ 19632 private void code580(AbstractBURS_TreeNode p) { 19633 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19634 } 19635 19636 /** 19637 * Emit code for rule number 581: 19638 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(r, r)) 19639 * @param p BURS node to apply the rule to 19640 */ 19641 private void code581(AbstractBURS_TreeNode p) { 19642 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 19643if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 19644EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 19645EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19646}else{ 19647EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 19648} 19649 } 19650 19651 /** 19652 * Emit code for rule number 582: 19653 * stm: FLOAT_STORE(r, OTHER_OPERAND(riv, riv)) 19654 * @param p BURS node to apply the rule to 19655 */ 19656 private void code582(AbstractBURS_TreeNode p) { 19657 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 19658 } 19659 19660 /** 19661 * Emit code for rule number 583: 19662 * stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, rlv)) 19663 * @param p BURS node to apply the rule to 19664 */ 19665 private void code583(AbstractBURS_TreeNode p) { 19666 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 19667 } 19668 19669 /** 19670 * Emit code for rule number 584: 19671 * stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, riv)) 19672 * @param p BURS node to apply the rule to 19673 */ 19674 private void code584(AbstractBURS_TreeNode p) { 19675 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 19676 } 19677 19678 /** 19679 * Emit code for rule number 585: 19680 * stm: FLOAT_STORE(r, OTHER_OPERAND(riv, rlv)) 19681 * @param p BURS node to apply the rule to 19682 */ 19683 private void code585(AbstractBURS_TreeNode p) { 19684 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 19685 } 19686 19687 /** 19688 * Emit code for rule number 586: 19689 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, riv)) 19690 * @param p BURS node to apply the rule to 19691 */ 19692 private void code586(AbstractBURS_TreeNode p) { 19693 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19694 } 19695 19696 /** 19697 * Emit code for rule number 587: 19698 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, riv)) 19699 * @param p BURS node to apply the rule to 19700 */ 19701 private void code587(AbstractBURS_TreeNode p) { 19702 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19703 } 19704 19705 /** 19706 * Emit code for rule number 588: 19707 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, rlv)) 19708 * @param p BURS node to apply the rule to 19709 */ 19710 private void code588(AbstractBURS_TreeNode p) { 19711 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19712 } 19713 19714 /** 19715 * Emit code for rule number 589: 19716 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 19717 * @param p BURS node to apply the rule to 19718 */ 19719 private void code589(AbstractBURS_TreeNode p) { 19720 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19721 } 19722 19723 /** 19724 * Emit code for rule number 590: 19725 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(r, r)) 19726 * @param p BURS node to apply the rule to 19727 */ 19728 private void code590(AbstractBURS_TreeNode p) { 19729 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 19730if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 19731EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 19732EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19733}else{ 19734EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 19735} 19736 } 19737 19738 /** 19739 * Emit code for rule number 591: 19740 * r: INT_2FLOAT(riv) 19741 * @param p BURS node to apply the rule to 19742 */ 19743 private void code591(AbstractBURS_TreeNode p) { 19744 SSE2_CONV(IA32_CVTSI2SS, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19745 } 19746 19747 /** 19748 * Emit code for rule number 592: 19749 * r: INT_2FLOAT(load32) 19750 * @param p BURS node to apply the rule to 19751 */ 19752 private void code592(AbstractBURS_TreeNode p) { 19753 SSE2_CONV(IA32_CVTSI2SS, P(p), Unary.getResult(P(p)), consumeMO()); 19754 } 19755 19756 /** 19757 * Emit code for rule number 593: 19758 * r: INT_2DOUBLE(riv) 19759 * @param p BURS node to apply the rule to 19760 */ 19761 private void code593(AbstractBURS_TreeNode p) { 19762 SSE2_CONV(IA32_CVTSI2SD, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19763 } 19764 19765 /** 19766 * Emit code for rule number 594: 19767 * r: INT_2DOUBLE(load32) 19768 * @param p BURS node to apply the rule to 19769 */ 19770 private void code594(AbstractBURS_TreeNode p) { 19771 SSE2_CONV(IA32_CVTSI2SD, P(p), Unary.getResult(P(p)), consumeMO()); 19772 } 19773 19774 /** 19775 * Emit code for rule number 595: 19776 * r: FLOAT_2DOUBLE(r) 19777 * @param p BURS node to apply the rule to 19778 */ 19779 private void code595(AbstractBURS_TreeNode p) { 19780 SSE2_CONV(IA32_CVTSS2SD, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19781 } 19782 19783 /** 19784 * Emit code for rule number 596: 19785 * r: FLOAT_2DOUBLE(float_load) 19786 * @param p BURS node to apply the rule to 19787 */ 19788 private void code596(AbstractBURS_TreeNode p) { 19789 SSE2_CONV(IA32_CVTSS2SD, P(p), Unary.getResult(P(p)), consumeMO()); 19790 } 19791 19792 /** 19793 * Emit code for rule number 597: 19794 * r: DOUBLE_2FLOAT(r) 19795 * @param p BURS node to apply the rule to 19796 */ 19797 private void code597(AbstractBURS_TreeNode p) { 19798 SSE2_CONV(IA32_CVTSD2SS, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 19799 } 19800 19801 /** 19802 * Emit code for rule number 598: 19803 * r: DOUBLE_2FLOAT(double_load) 19804 * @param p BURS node to apply the rule to 19805 */ 19806 private void code598(AbstractBURS_TreeNode p) { 19807 SSE2_CONV(IA32_CVTSD2SS, P(p), Unary.getResult(P(p)), consumeMO()); 19808 } 19809 19810 /** 19811 * Emit code for rule number 599: 19812 * r: FLOAT_2INT(r) 19813 * @param p BURS node to apply the rule to 19814 */ 19815 private void code599(AbstractBURS_TreeNode p) { 19816 EMIT(P(p)); /* leave for complex operators */ 19817 } 19818 19819 /** 19820 * Emit code for rule number 600: 19821 * r: FLOAT_2LONG(r) 19822 * @param p BURS node to apply the rule to 19823 */ 19824 private void code600(AbstractBURS_TreeNode p) { 19825 EMIT(P(p)); /* leave for complex operators */ 19826 } 19827 19828 /** 19829 * Emit code for rule number 601: 19830 * r: DOUBLE_2INT(r) 19831 * @param p BURS node to apply the rule to 19832 */ 19833 private void code601(AbstractBURS_TreeNode p) { 19834 EMIT(P(p)); /* leave for complex operators */ 19835 } 19836 19837 /** 19838 * Emit code for rule number 602: 19839 * r: DOUBLE_2LONG(r) 19840 * @param p BURS node to apply the rule to 19841 */ 19842 private void code602(AbstractBURS_TreeNode p) { 19843 EMIT(P(p)); /* leave for complex operators */ 19844 } 19845 19846 /** 19847 * Emit code for rule number 603: 19848 * r: FLOAT_AS_INT_BITS(r) 19849 * @param p BURS node to apply the rule to 19850 */ 19851 private void code603(AbstractBURS_TreeNode p) { 19852 SSE2_FPR2GPR_32(P(p)); 19853 } 19854 19855 /** 19856 * Emit code for rule number 605: 19857 * r: DOUBLE_AS_LONG_BITS(r) 19858 * @param p BURS node to apply the rule to 19859 */ 19860 private void code605(AbstractBURS_TreeNode p) { 19861 SSE2_FPR2GPR_64(P(p)); 19862 } 19863 19864 /** 19865 * Emit code for rule number 607: 19866 * r: INT_BITS_AS_FLOAT(riv) 19867 * @param p BURS node to apply the rule to 19868 */ 19869 private void code607(AbstractBURS_TreeNode p) { 19870 SSE2_GPR2FPR_32(P(p)); 19871 } 19872 19873 /** 19874 * Emit code for rule number 609: 19875 * r: LONG_BITS_AS_DOUBLE(rlv) 19876 * @param p BURS node to apply the rule to 19877 */ 19878 private void code609(AbstractBURS_TreeNode p) { 19879 SSE2_GPR2FPR_64(P(p)); 19880 } 19881 19882 /** 19883 * Emit code for rule number 611: 19884 * r: MATERIALIZE_FP_CONSTANT(any) 19885 * @param p BURS node to apply the rule to 19886 */ 19887 private void code611(AbstractBURS_TreeNode p) { 19888 SSE2_FPCONSTANT(P(p)); 19889 } 19890 19891 /** 19892 * Emit code for rule number 612: 19893 * float_load: MATERIALIZE_FP_CONSTANT(any) 19894 * @param p BURS node to apply the rule to 19895 */ 19896 private void code612(AbstractBURS_TreeNode p) { 19897 pushMO(MO_MC(P(p))); 19898 } 19899 19900 /** 19901 * Emit code for rule number 613: 19902 * double_load: MATERIALIZE_FP_CONSTANT(any) 19903 * @param p BURS node to apply the rule to 19904 */ 19905 private void code613(AbstractBURS_TreeNode p) { 19906 pushMO(MO_MC(P(p))); 19907 } 19908 19909 /** 19910 * Emit code for rule number 614: 19911 * stm: CLEAR_FLOATING_POINT_STATE 19912 * @param p BURS node to apply the rule to 19913 */ 19914 private void code614(AbstractBURS_TreeNode p) { 19915 EMIT(MIR_Empty.mutate(P(p), IA32_FNINIT)); 19916 } 19917 19918 /** 19919 * Emit code for rule number 615: 19920 * stm: FLOAT_IFCMP(r,r) 19921 * @param p BURS node to apply the rule to 19922 */ 19923 private void code615(AbstractBURS_TreeNode p) { 19924 SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal1(P(p)), IfCmp.getClearVal2(P(p))); 19925 } 19926 19927 /** 19928 * Emit code for rule number 616: 19929 * stm: FLOAT_IFCMP(r,float_load) 19930 * @param p BURS node to apply the rule to 19931 */ 19932 private void code616(AbstractBURS_TreeNode p) { 19933 SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal1(P(p)), consumeMO()); 19934 } 19935 19936 /** 19937 * Emit code for rule number 617: 19938 * stm: FLOAT_IFCMP(float_load,r) 19939 * @param p BURS node to apply the rule to 19940 */ 19941 private void code617(AbstractBURS_TreeNode p) { 19942 IfCmp.getCond(P(p)).flipOperands(); SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal2(P(p)), consumeMO()); 19943 } 19944 19945 /** 19946 * Emit code for rule number 618: 19947 * stm: DOUBLE_IFCMP(r,r) 19948 * @param p BURS node to apply the rule to 19949 */ 19950 private void code618(AbstractBURS_TreeNode p) { 19951 SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal1(P(p)), IfCmp.getClearVal2(P(p))); 19952 } 19953 19954 /** 19955 * Emit code for rule number 619: 19956 * stm: DOUBLE_IFCMP(r,double_load) 19957 * @param p BURS node to apply the rule to 19958 */ 19959 private void code619(AbstractBURS_TreeNode p) { 19960 SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal1(P(p)), consumeMO()); 19961 } 19962 19963 /** 19964 * Emit code for rule number 620: 19965 * stm: DOUBLE_IFCMP(double_load,r) 19966 * @param p BURS node to apply the rule to 19967 */ 19968 private void code620(AbstractBURS_TreeNode p) { 19969 IfCmp.getCond(P(p)).flipOperands(); SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal2(P(p)), consumeMO()); 19970 } 19971 19972 /** 19973 * Emit code for rule number 621: 19974 * r: FCMP_CMOV(r, OTHER_OPERAND(r, any)) 19975 * @param p BURS node to apply the rule to 19976 */ 19977 private void code621(AbstractBURS_TreeNode p) { 19978 EMIT(CPOS(P(p), MIR_Compare.create(CondMove.getVal1(P(p)).isFloat() ? IA32_UCOMISS : IA32_UCOMISD, CondMove.getVal1(P(p)), CondMove.getVal2(P(p))))); CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).translateUNSIGNED(), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 19979 } 19980 19981 /** 19982 * Emit code for rule number 622: 19983 * r: FCMP_CMOV(r, OTHER_OPERAND(float_load, any)) 19984 * @param p BURS node to apply the rule to 19985 */ 19986 private void code622(AbstractBURS_TreeNode p) { 19987 EMIT(CPOS(P(p), MIR_Compare.create(IA32_UCOMISS, CondMove.getVal1(P(p)), consumeMO()))); CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).translateUNSIGNED(), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 19988 } 19989 19990 /** 19991 * Emit code for rule number 623: 19992 * r: FCMP_CMOV(r, OTHER_OPERAND(double_load, any)) 19993 * @param p BURS node to apply the rule to 19994 */ 19995 private void code623(AbstractBURS_TreeNode p) { 19996 EMIT(CPOS(P(p), MIR_Compare.create(IA32_UCOMISD, CondMove.getVal1(P(p)), consumeMO()))); CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).translateUNSIGNED(), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 19997 } 19998 19999 /** 20000 * Emit code for rule number 624: 20001 * r: FCMP_CMOV(float_load, OTHER_OPERAND(r, any)) 20002 * @param p BURS node to apply the rule to 20003 */ 20004 private void code624(AbstractBURS_TreeNode p) { 20005 CondMove.getCond(P(p)).flipOperands(); EMIT(CPOS(P(p), MIR_Compare.create(IA32_UCOMISS, CondMove.getVal1(P(p)), consumeMO()))); CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).translateUNSIGNED(), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 20006 } 20007 20008 /** 20009 * Emit code for rule number 625: 20010 * r: FCMP_CMOV(double_load, OTHER_OPERAND(r, any)) 20011 * @param p BURS node to apply the rule to 20012 */ 20013 private void code625(AbstractBURS_TreeNode p) { 20014 CondMove.getCond(P(p)).flipOperands(); EMIT(CPOS(P(p), MIR_Compare.create(IA32_UCOMISD, CondMove.getVal1(P(p)), consumeMO()))); CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).translateUNSIGNED(), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 20015 } 20016 20017 /** 20018 * Emit code for rule number 626: 20019 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, any)) 20020 * @param p BURS node to apply the rule to 20021 */ 20022 private void code626(AbstractBURS_TreeNode p) { 20023 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), CondMove.getCond(P(p)), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 20024 } 20025 20026 /** 20027 * Emit code for rule number 627: 20028 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, float_load))) 20029 * @param p BURS node to apply the rule to 20030 */ 20031 private void code627(AbstractBURS_TreeNode p) { 20032 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), CondMove.getCond(P(p)), CondMove.getTrueValue(P(p)), consumeMO()); 20033 } 20034 20035 /** 20036 * Emit code for rule number 628: 20037 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, double_load))) 20038 * @param p BURS node to apply the rule to 20039 */ 20040 private void code628(AbstractBURS_TreeNode p) { 20041 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), CondMove.getCond(P(p)), CondMove.getTrueValue(P(p)), consumeMO()); 20042 } 20043 20044 /** 20045 * Emit code for rule number 629: 20046 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(float_load, r))) 20047 * @param p BURS node to apply the rule to 20048 */ 20049 private void code629(AbstractBURS_TreeNode p) { 20050 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), CondMove.getCond(P(p)), consumeMO(), CondMove.getFalseValue(P(p))); 20051 } 20052 20053 /** 20054 * Emit code for rule number 630: 20055 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(double_load, r))) 20056 * @param p BURS node to apply the rule to 20057 */ 20058 private void code630(AbstractBURS_TreeNode p) { 20059 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), CondMove.getCond(P(p)), consumeMO(), CondMove.getFalseValue(P(p))); 20060 } 20061 20062 /** 20063 * Emit code for rule number 631: 20064 * r: FCMP_FCMOV(r, OTHER_OPERAND(float_load, any)) 20065 * @param p BURS node to apply the rule to 20066 */ 20067 private void code631(AbstractBURS_TreeNode p) { 20068 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), consumeMO(), CondMove.getCond(P(p)), CondMove.getFalseValue(P(p)), CondMove.getTrueValue(P(p))); 20069 } 20070 20071 /** 20072 * Emit code for rule number 632: 20073 * r: FCMP_FCMOV(r, OTHER_OPERAND(double_load, any)) 20074 * @param p BURS node to apply the rule to 20075 */ 20076 private void code632(AbstractBURS_TreeNode p) { 20077 SSE2_FCMP_FCMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), consumeMO(), CondMove.getCond(P(p)), CondMove.getFalseValue(P(p)), CondMove.getTrueValue(P(p))); 20078 } 20079 20080 /** 20081 * Emit code for rule number 633: 20082 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 20083 * @param p BURS node to apply the rule to 20084 */ 20085 private void code633(AbstractBURS_TreeNode p) { 20086 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20087 } 20088 20089 /** 20090 * Emit code for rule number 634: 20091 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 20092 * @param p BURS node to apply the rule to 20093 */ 20094 private void code634(AbstractBURS_TreeNode p) { 20095 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20096 } 20097 20098 /** 20099 * Emit code for rule number 635: 20100 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 20101 * @param p BURS node to apply the rule to 20102 */ 20103 private void code635(AbstractBURS_TreeNode p) { 20104 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20105 } 20106 20107 /** 20108 * Emit code for rule number 636: 20109 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 20110 * @param p BURS node to apply the rule to 20111 */ 20112 private void code636(AbstractBURS_TreeNode p) { 20113 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20114 } 20115 20116 /** 20117 * Emit code for rule number 637: 20118 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 20119 * @param p BURS node to apply the rule to 20120 */ 20121 private void code637(AbstractBURS_TreeNode p) { 20122 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20123 } 20124 20125 /** 20126 * Emit code for rule number 638: 20127 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 20128 * @param p BURS node to apply the rule to 20129 */ 20130 private void code638(AbstractBURS_TreeNode p) { 20131 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20132 } 20133 20134 /** 20135 * Emit code for rule number 639: 20136 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 20137 * @param p BURS node to apply the rule to 20138 */ 20139 private void code639(AbstractBURS_TreeNode p) { 20140 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20141 } 20142 20143 /** 20144 * Emit code for rule number 640: 20145 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 20146 * @param p BURS node to apply the rule to 20147 */ 20148 private void code640(AbstractBURS_TreeNode p) { 20149 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20150 } 20151 20152 /** 20153 * Emit code for rule number 641: 20154 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 20155 * @param p BURS node to apply the rule to 20156 */ 20157 private void code641(AbstractBURS_TreeNode p) { 20158 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20159 } 20160 20161 /** 20162 * Emit code for rule number 642: 20163 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 20164 * @param p BURS node to apply the rule to 20165 */ 20166 private void code642(AbstractBURS_TreeNode p) { 20167 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20168 } 20169 20170 /** 20171 * Emit code for rule number 643: 20172 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 20173 * @param p BURS node to apply the rule to 20174 */ 20175 private void code643(AbstractBURS_TreeNode p) { 20176 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20177 } 20178 20179 /** 20180 * Emit code for rule number 644: 20181 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 20182 * @param p BURS node to apply the rule to 20183 */ 20184 private void code644(AbstractBURS_TreeNode p) { 20185 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 20186 } 20187 20188 /** 20189 * Emit code for rule number 645: 20190 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 20191 * @param p BURS node to apply the rule to 20192 */ 20193 private void code645(AbstractBURS_TreeNode p) { 20194 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20195 } 20196 20197 /** 20198 * Emit code for rule number 646: 20199 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 20200 * @param p BURS node to apply the rule to 20201 */ 20202 private void code646(AbstractBURS_TreeNode p) { 20203 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20204 } 20205 20206 /** 20207 * Emit code for rule number 647: 20208 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 20209 * @param p BURS node to apply the rule to 20210 */ 20211 private void code647(AbstractBURS_TreeNode p) { 20212 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20213 } 20214 20215 /** 20216 * Emit code for rule number 648: 20217 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 20218 * @param p BURS node to apply the rule to 20219 */ 20220 private void code648(AbstractBURS_TreeNode p) { 20221 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 20222 } 20223 20224 /** 20225 * Emit code for rule number 649: 20226 * stm: LONG_ASTORE(load64, OTHER_OPERAND(riv, riv)) 20227 * @param p BURS node to apply the rule to 20228 */ 20229 private void code649(AbstractBURS_TreeNode p) { 20230 RegisterOperand temp = regpool.makeTemp(TypeReference.Double); EMIT(MIR_Move.mutate(PL(p), IA32_MOVQ, temp, consumeMO())); EMIT(MIR_Move.mutate(P(p), IA32_MOVQ, MO_AS(P(p), QW_S, QW), temp.copyRO())); 20231 } 20232 20233 /** 20234 * Emit code for rule number 650: 20235 * stm: LONG_ASTORE(load64, OTHER_OPERAND(rlv, riv)) 20236 * @param p BURS node to apply the rule to 20237 */ 20238 private void code650(AbstractBURS_TreeNode p) { 20239 RegisterOperand temp = regpool.makeTemp(TypeReference.Double); EMIT(MIR_Move.mutate(PL(p), IA32_MOVQ, temp, consumeMO())); EMIT(MIR_Move.mutate(P(p), IA32_MOVQ, MO_AS(P(p), QW_S, QW), temp.copyRO())); 20240 } 20241 20242 /** 20243 * Emit code for rule number 651: 20244 * stm: LONG_STORE(load64, OTHER_OPERAND(riv, riv)) 20245 * @param p BURS node to apply the rule to 20246 */ 20247 private void code651(AbstractBURS_TreeNode p) { 20248 RegisterOperand temp = regpool.makeTemp(TypeReference.Double); EMIT(MIR_Move.mutate(PL(p), IA32_MOVQ, temp, consumeMO())); EMIT(MIR_Move.mutate(P(p), IA32_MOVQ, MO_S(P(p), QW), temp.copyRO())); 20249 } 20250 20251 /** 20252 * Emit code for rule number 652: 20253 * stm: LONG_STORE(load64, OTHER_OPERAND(rlv, riv)) 20254 * @param p BURS node to apply the rule to 20255 */ 20256 private void code652(AbstractBURS_TreeNode p) { 20257 RegisterOperand temp = regpool.makeTemp(TypeReference.Double); EMIT(MIR_Move.mutate(PL(p), IA32_MOVQ, temp, consumeMO())); EMIT(MIR_Move.mutate(P(p), IA32_MOVQ, MO_S(P(p), QW), temp.copyRO())); 20258 } 20259 20260 /** 20261 * Emit code using given rule number 20262 * 20263 * @param p the tree that's being emitted 20264 * @param n the non-terminal goal of that tree 20265 * @param ruleno the rule that will generate the tree 20266 */ 20267 @Override 20268 public void code(AbstractBURS_TreeNode p, int n, int ruleno) { 20269 switch(unsortedErnMap[ruleno]) { 20270 case 16: code16(p); break; 20271 case 17: code17(p); break; 20272 case 18: code18(p); break; 20273 case 19: code19(p); break; 20274 case 20: code20(p); break; 20275 case 21: code21(p); break; 20276 case 22: code22(p); break; 20277 case 23: code23(p); break; 20278 case 25: code25(p); break; 20279 case 26: code26(p); break; 20280 case 27: code27(p); break; 20281 case 28: code28(p); break; 20282 case 29: code29(p); break; 20283 case 30: code30(p); break; 20284 case 31: code31(p); break; 20285 case 32: code32(p); break; 20286 case 33: code33(p); break; 20287 case 34: code34(p); break; 20288 case 35: code35(p); break; 20289 case 36: code36(p); break; 20290 case 37: code37(p); break; 20291 case 38: code38(p); break; 20292 case 39: code39(p); break; 20293 case 40: code40(p); break; 20294 case 41: code41(p); break; 20295 case 42: code42(p); break; 20296 case 43: code43(p); break; 20297 case 44: code44(p); break; 20298 case 45: code45(p); break; 20299 case 46: code46(p); break; 20300 case 47: code47(p); break; 20301 case 48: code48(p); break; 20302 case 49: code49(p); break; 20303 case 50: code50(p); break; 20304 case 51: code51(p); break; 20305 case 52: code52(p); break; 20306 case 53: code53(p); break; 20307 case 54: code54(p); break; 20308 case 55: code55(p); break; 20309 case 56: code56(p); break; 20310 case 57: code57(p); break; 20311 case 58: code58(p); break; 20312 case 59: code59(p); break; 20313 case 60: code60(p); break; 20314 case 61: code61(p); break; 20315 case 62: code62(p); break; 20316 case 63: code63(p); break; 20317 case 64: code64(p); break; 20318 case 65: code65(p); break; 20319 case 66: code66(p); break; 20320 case 67: code67(p); break; 20321 case 68: code68(p); break; 20322 case 69: code69(p); break; 20323 case 70: code70(p); break; 20324 case 71: code71(p); break; 20325 case 72: code72(p); break; 20326 case 73: code73(p); break; 20327 case 74: code74(p); break; 20328 case 75: code75(p); break; 20329 case 76: code76(p); break; 20330 case 77: code77(p); break; 20331 case 78: code78(p); break; 20332 case 79: code79(p); break; 20333 case 80: code80(p); break; 20334 case 81: code81(p); break; 20335 case 84: code84(p); break; 20336 case 85: code85(p); break; 20337 case 86: code86(p); break; 20338 case 87: code87(p); break; 20339 case 88: code88(p); break; 20340 case 89: code89(p); break; 20341 case 90: code90(p); break; 20342 case 91: code91(p); break; 20343 case 92: code92(p); break; 20344 case 93: code93(p); break; 20345 case 94: code94(p); break; 20346 case 95: code95(p); break; 20347 case 96: code96(p); break; 20348 case 97: code97(p); break; 20349 case 98: code98(p); break; 20350 case 99: code99(p); break; 20351 case 100: code100(p); break; 20352 case 101: code101(p); break; 20353 case 102: code102(p); break; 20354 case 103: code103(p); break; 20355 case 104: code104(p); break; 20356 case 105: code105(p); break; 20357 case 106: code106(p); break; 20358 case 107: code107(p); break; 20359 case 108: code108(p); break; 20360 case 109: code109(p); break; 20361 case 110: code110(p); break; 20362 case 111: code111(p); break; 20363 case 112: code112(p); break; 20364 case 113: code113(p); break; 20365 case 114: code114(p); break; 20366 case 115: code115(p); break; 20367 case 116: code116(p); break; 20368 case 117: code117(p); break; 20369 case 118: code118(p); break; 20370 case 119: code119(p); break; 20371 case 120: code120(p); break; 20372 case 121: code121(p); break; 20373 case 122: code122(p); break; 20374 case 123: code123(p); break; 20375 case 124: code124(p); break; 20376 case 125: code125(p); break; 20377 case 126: code126(p); break; 20378 case 127: code127(p); break; 20379 case 128: code128(p); break; 20380 case 129: code129(p); break; 20381 case 130: code130(p); break; 20382 case 131: code131(p); break; 20383 case 132: code132(p); break; 20384 case 133: code133(p); break; 20385 case 134: code134(p); break; 20386 case 135: code135(p); break; 20387 case 136: code136(p); break; 20388 case 137: code137(p); break; 20389 case 138: code138(p); break; 20390 case 139: code139(p); break; 20391 case 140: code140(p); break; 20392 case 141: code141(p); break; 20393 case 142: code142(p); break; 20394 case 143: code143(p); break; 20395 case 144: code144(p); break; 20396 case 145: code145(p); break; 20397 case 146: code146(p); break; 20398 case 147: code147(p); break; 20399 case 148: code148(p); break; 20400 case 149: code149(p); break; 20401 case 150: code150(p); break; 20402 case 151: code151(p); break; 20403 case 152: code152(p); break; 20404 case 153: code153(p); break; 20405 case 154: code154(p); break; 20406 case 155: code155(p); break; 20407 case 156: code156(p); break; 20408 case 157: code157(p); break; 20409 case 158: code158(p); break; 20410 case 159: code159(p); break; 20411 case 160: code160(p); break; 20412 case 161: code161(p); break; 20413 case 162: code162(p); break; 20414 case 163: code163(p); break; 20415 case 164: code164(p); break; 20416 case 165: code165(p); break; 20417 case 166: code166(p); break; 20418 case 167: code167(p); break; 20419 case 168: code168(p); break; 20420 case 169: code169(p); break; 20421 case 170: code170(p); break; 20422 case 171: code171(p); break; 20423 case 172: code172(p); break; 20424 case 173: code173(p); break; 20425 case 174: code174(p); break; 20426 case 176: code176(p); break; 20427 case 177: code177(p); break; 20428 case 178: code178(p); break; 20429 case 179: code179(p); break; 20430 case 180: code180(p); break; 20431 case 181: code181(p); break; 20432 case 182: code182(p); break; 20433 case 183: code183(p); break; 20434 case 184: code184(p); break; 20435 case 185: code185(p); break; 20436 case 186: code186(p); break; 20437 case 187: code187(p); break; 20438 case 188: code188(p); break; 20439 case 189: code189(p); break; 20440 case 190: code190(p); break; 20441 case 191: code191(p); break; 20442 case 192: code192(p); break; 20443 case 193: code193(p); break; 20444 case 194: code194(p); break; 20445 case 195: code195(p); break; 20446 case 196: code196(p); break; 20447 case 197: code197(p); break; 20448 case 198: code198(p); break; 20449 case 199: code199(p); break; 20450 case 200: code200(p); break; 20451 case 201: code201(p); break; 20452 case 202: code202(p); break; 20453 case 203: code203(p); break; 20454 case 204: code204(p); break; 20455 case 205: code205(p); break; 20456 case 206: code206(p); break; 20457 case 207: code207(p); break; 20458 case 208: code208(p); break; 20459 case 209: code209(p); break; 20460 case 210: code210(p); break; 20461 case 211: code211(p); break; 20462 case 212: code212(p); break; 20463 case 213: code213(p); break; 20464 case 214: code214(p); break; 20465 case 215: code215(p); break; 20466 case 216: code216(p); break; 20467 case 217: code217(p); break; 20468 case 218: code218(p); break; 20469 case 219: code219(p); break; 20470 case 220: code220(p); break; 20471 case 221: code221(p); break; 20472 case 222: code222(p); break; 20473 case 223: code223(p); break; 20474 case 224: code224(p); break; 20475 case 225: code225(p); break; 20476 case 226: code226(p); break; 20477 case 227: code227(p); break; 20478 case 228: code228(p); break; 20479 case 229: code229(p); break; 20480 case 230: code230(p); break; 20481 case 231: code231(p); break; 20482 case 232: code232(p); break; 20483 case 233: code233(p); break; 20484 case 234: code234(p); break; 20485 case 235: code235(p); break; 20486 case 236: code236(p); break; 20487 case 237: code237(p); break; 20488 case 238: code238(p); break; 20489 case 239: code239(p); break; 20490 case 240: code240(p); break; 20491 case 241: code241(p); break; 20492 case 242: code242(p); break; 20493 case 243: code243(p); break; 20494 case 244: code244(p); break; 20495 case 245: code245(p); break; 20496 case 246: code246(p); break; 20497 case 247: code247(p); break; 20498 case 248: code248(p); break; 20499 case 249: code249(p); break; 20500 case 250: code250(p); break; 20501 case 251: code251(p); break; 20502 case 252: code252(p); break; 20503 case 253: code253(p); break; 20504 case 254: code254(p); break; 20505 case 255: code255(p); break; 20506 case 256: code256(p); break; 20507 case 257: code257(p); break; 20508 case 258: code258(p); break; 20509 case 259: code259(p); break; 20510 case 260: code260(p); break; 20511 case 261: code261(p); break; 20512 case 262: code262(p); break; 20513 case 263: code263(p); break; 20514 case 264: code264(p); break; 20515 case 265: code265(p); break; 20516 case 266: code266(p); break; 20517 case 267: code267(p); break; 20518 case 268: code268(p); break; 20519 case 269: code269(p); break; 20520 case 270: code270(p); break; 20521 case 271: code271(p); break; 20522 case 272: code272(p); break; 20523 case 273: code273(p); break; 20524 case 274: code274(p); break; 20525 case 275: code275(p); break; 20526 case 276: code276(p); break; 20527 case 277: code277(p); break; 20528 case 278: code278(p); break; 20529 case 279: code279(p); break; 20530 case 280: code280(p); break; 20531 case 281: code281(p); break; 20532 case 282: code282(p); break; 20533 case 283: code283(p); break; 20534 case 284: code284(p); break; 20535 case 286: code286(p); break; 20536 case 295: code295(p); break; 20537 case 296: code296(p); break; 20538 case 297: code297(p); break; 20539 case 298: code298(p); break; 20540 case 299: code299(p); break; 20541 case 300: code300(p); break; 20542 case 301: code301(p); break; 20543 case 302: code302(p); break; 20544 case 303: code303(p); break; 20545 case 304: code304(p); break; 20546 case 305: code305(p); break; 20547 case 306: code306(p); break; 20548 case 307: code307(p); break; 20549 case 308: code308(p); break; 20550 case 309: code309(p); break; 20551 case 310: code310(p); break; 20552 case 311: code311(p); break; 20553 case 312: code312(p); break; 20554 case 313: code313(p); break; 20555 case 314: code314(p); break; 20556 case 315: code315(p); break; 20557 case 316: code316(p); break; 20558 case 317: code317(p); break; 20559 case 318: code318(p); break; 20560 case 319: code319(p); break; 20561 case 320: code320(p); break; 20562 case 321: code321(p); break; 20563 case 322: code322(p); break; 20564 case 323: code323(p); break; 20565 case 324: code324(p); break; 20566 case 325: code325(p); break; 20567 case 326: code326(p); break; 20568 case 327: code327(p); break; 20569 case 328: code328(p); break; 20570 case 329: code329(p); break; 20571 case 330: code330(p); break; 20572 case 331: code331(p); break; 20573 case 332: code332(p); break; 20574 case 333: code333(p); break; 20575 case 334: code334(p); break; 20576 case 335: code335(p); break; 20577 case 336: code336(p); break; 20578 case 337: code337(p); break; 20579 case 338: code338(p); break; 20580 case 339: code339(p); break; 20581 case 340: code340(p); break; 20582 case 341: code341(p); break; 20583 case 342: code342(p); break; 20584 case 343: code343(p); break; 20585 case 344: code344(p); break; 20586 case 345: code345(p); break; 20587 case 346: code346(p); break; 20588 case 347: code347(p); break; 20589 case 348: code348(p); break; 20590 case 349: code349(p); break; 20591 case 350: code350(p); break; 20592 case 351: code351(p); break; 20593 case 352: code352(p); break; 20594 case 353: code353(p); break; 20595 case 354: code354(p); break; 20596 case 355: code355(p); break; 20597 case 356: code356(p); break; 20598 case 357: code357(p); break; 20599 case 358: code358(p); break; 20600 case 359: code359(p); break; 20601 case 360: code360(p); break; 20602 case 361: code361(p); break; 20603 case 362: code362(p); break; 20604 case 363: code363(p); break; 20605 case 364: code364(p); break; 20606 case 365: code365(p); break; 20607 case 366: code366(p); break; 20608 case 367: code367(p); break; 20609 case 368: code368(p); break; 20610 case 369: code369(p); break; 20611 case 370: code370(p); break; 20612 case 371: code371(p); break; 20613 case 372: code372(p); break; 20614 case 373: code373(p); break; 20615 case 374: code374(p); break; 20616 case 375: code375(p); break; 20617 case 376: code376(p); break; 20618 case 377: code377(p); break; 20619 case 378: code378(p); break; 20620 case 379: code379(p); break; 20621 case 380: code380(p); break; 20622 case 381: code381(p); break; 20623 case 382: code382(p); break; 20624 case 383: code383(p); break; 20625 case 384: code384(p); break; 20626 case 385: code385(p); break; 20627 case 388: code388(p); break; 20628 case 389: code389(p); break; 20629 case 390: code390(p); break; 20630 case 391: code391(p); break; 20631 case 392: code392(p); break; 20632 case 393: code393(p); break; 20633 case 394: code394(p); break; 20634 case 395: code395(p); break; 20635 case 396: code396(p); break; 20636 case 397: code397(p); break; 20637 case 400: code400(p); break; 20638 case 401: code401(p); break; 20639 case 406: code406(p); break; 20640 case 407: code407(p); break; 20641 case 408: code408(p); break; 20642 case 411: code411(p); break; 20643 case 412: code412(p); break; 20644 case 413: code413(p); break; 20645 case 414: code414(p); break; 20646 case 415: code415(p); break; 20647 case 416: code416(p); break; 20648 case 417: code417(p); break; 20649 case 418: code418(p); break; 20650 case 419: code419(p); break; 20651 case 420: code420(p); break; 20652 case 421: code421(p); break; 20653 case 422: code422(p); break; 20654 case 423: code423(p); break; 20655 case 424: code424(p); break; 20656 case 425: code425(p); break; 20657 case 426: code426(p); break; 20658 case 427: code427(p); break; 20659 case 428: code428(p); break; 20660 case 429: code429(p); break; 20661 case 430: code430(p); break; 20662 case 431: code431(p); break; 20663 case 432: code432(p); break; 20664 case 433: code433(p); break; 20665 case 434: code434(p); break; 20666 case 435: code435(p); break; 20667 case 436: code436(p); break; 20668 case 437: code437(p); break; 20669 case 438: code438(p); break; 20670 case 439: code439(p); break; 20671 case 440: code440(p); break; 20672 case 441: code441(p); break; 20673 case 442: code442(p); break; 20674 case 443: code443(p); break; 20675 case 444: code444(p); break; 20676 case 445: code445(p); break; 20677 case 446: code446(p); break; 20678 case 447: code447(p); break; 20679 case 448: code448(p); break; 20680 case 449: code449(p); break; 20681 case 450: code450(p); break; 20682 case 451: code451(p); break; 20683 case 452: code452(p); break; 20684 case 453: code453(p); break; 20685 case 454: code454(p); break; 20686 case 455: code455(p); break; 20687 case 456: code456(p); break; 20688 case 457: code457(p); break; 20689 case 458: code458(p); break; 20690 case 459: code459(p); break; 20691 case 461: code461(p); break; 20692 case 462: code462(p); break; 20693 case 463: code463(p); break; 20694 case 464: code464(p); break; 20695 case 465: code465(p); break; 20696 case 466: code466(p); break; 20697 case 467: code467(p); break; 20698 case 468: code468(p); break; 20699 case 469: code469(p); break; 20700 case 470: code470(p); break; 20701 case 471: code471(p); break; 20702 case 472: code472(p); break; 20703 case 473: code473(p); break; 20704 case 474: code474(p); break; 20705 case 475: code475(p); break; 20706 case 476: code476(p); break; 20707 case 477: code477(p); break; 20708 case 478: code478(p); break; 20709 case 479: code479(p); break; 20710 case 480: code480(p); break; 20711 case 481: code481(p); break; 20712 case 482: code482(p); break; 20713 case 483: code483(p); break; 20714 case 484: code484(p); break; 20715 case 485: code485(p); break; 20716 case 486: code486(p); break; 20717 case 487: code487(p); break; 20718 case 488: code488(p); break; 20719 case 489: code489(p); break; 20720 case 490: code490(p); break; 20721 case 491: code491(p); break; 20722 case 492: code492(p); break; 20723 case 493: code493(p); break; 20724 case 494: code494(p); break; 20725 case 495: code495(p); break; 20726 case 496: code496(p); break; 20727 case 497: code497(p); break; 20728 case 498: code498(p); break; 20729 case 499: code499(p); break; 20730 case 500: code500(p); break; 20731 case 501: code501(p); break; 20732 case 502: code502(p); break; 20733 case 503: code503(p); break; 20734 case 504: code504(p); break; 20735 case 505: code505(p); break; 20736 case 506: code506(p); break; 20737 case 507: code507(p); break; 20738 case 508: code508(p); break; 20739 case 509: code509(p); break; 20740 case 510: code510(p); break; 20741 case 511: code511(p); break; 20742 case 512: code512(p); break; 20743 case 513: code513(p); break; 20744 case 514: code514(p); break; 20745 case 515: code515(p); break; 20746 case 516: code516(p); break; 20747 case 517: code517(p); break; 20748 case 518: code518(p); break; 20749 case 519: code519(p); break; 20750 case 520: code520(p); break; 20751 case 521: code521(p); break; 20752 case 522: code522(p); break; 20753 case 523: code523(p); break; 20754 case 524: code524(p); break; 20755 case 525: code525(p); break; 20756 case 526: code526(p); break; 20757 case 527: code527(p); break; 20758 case 528: code528(p); break; 20759 case 529: code529(p); break; 20760 case 530: code530(p); break; 20761 case 531: code531(p); break; 20762 case 532: code532(p); break; 20763 case 533: code533(p); break; 20764 case 534: code534(p); break; 20765 case 535: code535(p); break; 20766 case 536: code536(p); break; 20767 case 537: code537(p); break; 20768 case 538: code538(p); break; 20769 case 539: code539(p); break; 20770 case 540: code540(p); break; 20771 case 541: code541(p); break; 20772 case 542: code542(p); break; 20773 case 543: code543(p); break; 20774 case 544: code544(p); break; 20775 case 545: code545(p); break; 20776 case 546: code546(p); break; 20777 case 547: code547(p); break; 20778 case 548: code548(p); break; 20779 case 549: code549(p); break; 20780 case 550: code550(p); break; 20781 case 551: code551(p); break; 20782 case 552: code552(p); break; 20783 case 553: code553(p); break; 20784 case 554: code554(p); break; 20785 case 555: code555(p); break; 20786 case 556: code556(p); break; 20787 case 557: code557(p); break; 20788 case 558: code558(p); break; 20789 case 559: code559(p); break; 20790 case 560: code560(p); break; 20791 case 561: code561(p); break; 20792 case 562: code562(p); break; 20793 case 563: code563(p); break; 20794 case 564: code564(p); break; 20795 case 565: code565(p); break; 20796 case 566: code566(p); break; 20797 case 567: code567(p); break; 20798 case 568: code568(p); break; 20799 case 569: code569(p); break; 20800 case 570: code570(p); break; 20801 case 571: code571(p); break; 20802 case 572: code572(p); break; 20803 case 573: code573(p); break; 20804 case 574: code574(p); break; 20805 case 575: code575(p); break; 20806 case 576: code576(p); break; 20807 case 577: code577(p); break; 20808 case 578: code578(p); break; 20809 case 579: code579(p); break; 20810 case 580: code580(p); break; 20811 case 581: code581(p); break; 20812 case 582: code582(p); break; 20813 case 583: code583(p); break; 20814 case 584: code584(p); break; 20815 case 585: code585(p); break; 20816 case 586: code586(p); break; 20817 case 587: code587(p); break; 20818 case 588: code588(p); break; 20819 case 589: code589(p); break; 20820 case 590: code590(p); break; 20821 case 591: code591(p); break; 20822 case 592: code592(p); break; 20823 case 593: code593(p); break; 20824 case 594: code594(p); break; 20825 case 595: code595(p); break; 20826 case 596: code596(p); break; 20827 case 597: code597(p); break; 20828 case 598: code598(p); break; 20829 case 599: code599(p); break; 20830 case 600: code600(p); break; 20831 case 601: code601(p); break; 20832 case 602: code602(p); break; 20833 case 603: code603(p); break; 20834 case 605: code605(p); break; 20835 case 607: code607(p); break; 20836 case 609: code609(p); break; 20837 case 611: code611(p); break; 20838 case 612: code612(p); break; 20839 case 613: code613(p); break; 20840 case 614: code614(p); break; 20841 case 615: code615(p); break; 20842 case 616: code616(p); break; 20843 case 617: code617(p); break; 20844 case 618: code618(p); break; 20845 case 619: code619(p); break; 20846 case 620: code620(p); break; 20847 case 621: code621(p); break; 20848 case 622: code622(p); break; 20849 case 623: code623(p); break; 20850 case 624: code624(p); break; 20851 case 625: code625(p); break; 20852 case 626: code626(p); break; 20853 case 627: code627(p); break; 20854 case 628: code628(p); break; 20855 case 629: code629(p); break; 20856 case 630: code630(p); break; 20857 case 631: code631(p); break; 20858 case 632: code632(p); break; 20859 case 633: code633(p); break; 20860 case 634: code634(p); break; 20861 case 635: code635(p); break; 20862 case 636: code636(p); break; 20863 case 637: code637(p); break; 20864 case 638: code638(p); break; 20865 case 639: code639(p); break; 20866 case 640: code640(p); break; 20867 case 641: code641(p); break; 20868 case 642: code642(p); break; 20869 case 643: code643(p); break; 20870 case 644: code644(p); break; 20871 case 645: code645(p); break; 20872 case 646: code646(p); break; 20873 case 647: code647(p); break; 20874 case 648: code648(p); break; 20875 case 649: code649(p); break; 20876 case 650: code650(p); break; 20877 case 651: code651(p); break; 20878 case 652: code652(p); break; 20879 default: 20880 throw new OptimizingCompilerException("BURS", "rule " + ruleno + " without emit code:", 20881 BURS_Debug.string[unsortedErnMap[ruleno]]); 20882 } 20883 } 20884}