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_32; 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_32.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_32.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 - address: address1scaledreg */ 194 94, /* 10 - address1scaledreg: address1reg */ 195 345, /* 11 - load8: sload8 */ 196 346, /* 12 - load8: uload8 */ 197 355, /* 13 - load16: sload16 */ 198 356, /* 14 - load16: uload16 */ 199 359, /* 15 - load16_32: load16 */ 200 360, /* 16 - load16_32: load32 */ 201 361, /* 17 - load8_16_32: load16_32 */ 202 362, /* 18 - load8_16_32: load8 */ 203 2, /* 19 - r: REGISTER */ 204 8, /* 20 - riv: INT_CONSTANT */ 205 10, /* 21 - rlv: LONG_CONSTANT */ 206 11, /* 22 - any: NULL */ 207 13, /* 23 - any: ADDRESS_CONSTANT */ 208 14, /* 24 - any: LONG_CONSTANT */ 209 16, /* 25 - stm: IG_PATCH_POINT */ 210 17, /* 26 - stm: UNINT_BEGIN */ 211 18, /* 27 - stm: UNINT_END */ 212 19, /* 28 - stm: YIELDPOINT_PROLOGUE */ 213 20, /* 29 - stm: YIELDPOINT_EPILOGUE */ 214 21, /* 30 - stm: YIELDPOINT_BACKEDGE */ 215 23, /* 31 - stm: RESOLVE */ 216 24, /* 32 - stm: NOP */ 217 25, /* 33 - r: GUARD_MOVE */ 218 26, /* 34 - r: GUARD_COMBINE */ 219 28, /* 35 - stm: IR_PROLOGUE */ 220 29, /* 36 - r: GET_CAUGHT_EXCEPTION */ 221 31, /* 37 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) */ 222 32, /* 38 - stm: TRAP */ 223 62, /* 39 - stm: GOTO */ 224 64, /* 40 - stm: WRITE_FLOOR */ 225 65, /* 41 - stm: READ_CEILING */ 226 66, /* 42 - stm: FENCE */ 227 67, /* 43 - stm: PAUSE */ 228 68, /* 44 - stm: RETURN(NULL) */ 229 69, /* 45 - stm: RETURN(INT_CONSTANT) */ 230 71, /* 46 - stm: RETURN(LONG_CONSTANT) */ 231 80, /* 47 - r: GET_TIME_BASE */ 232 394, /* 48 - r: LONG_MOVE(LONG_CONSTANT) */ 233 520, /* 49 - stm: CLEAR_FLOATING_POINT_STATE */ 234 15, /* 50 - any: OTHER_OPERAND(any,any) */ 235 35, /* 51 - stm: TRAP_IF(r,r) */ 236 36, /* 52 - stm: TRAP_IF(load32,riv) */ 237 37, /* 53 - stm: TRAP_IF(riv,load32) */ 238 61, /* 54 - r: LONG_CMP(rlv,rlv) */ 239 72, /* 55 - r: CALL(r,any) */ 240 77, /* 56 - r: SYSCALL(r,any) */ 241 81, /* 57 - stm: YIELDPOINT_OSR(any,any) */ 242 84, /* 58 - address: INT_ADD(r,r) */ 243 85, /* 59 - address: INT_ADD(r,address1scaledreg) */ 244 86, /* 60 - address: INT_ADD(address1scaledreg,r) */ 245 88, /* 61 - address: INT_ADD(address1scaledreg,address1reg) */ 246 89, /* 62 - address: INT_ADD(address1reg,address1scaledreg) */ 247 134, /* 63 - r: BOOLEAN_CMP_INT(r,riv) */ 248 135, /* 64 - boolcmp: BOOLEAN_CMP_INT(r,riv) */ 249 152, /* 65 - r: BOOLEAN_CMP_INT(load32,riv) */ 250 153, /* 66 - boolcmp: BOOLEAN_CMP_INT(load32,riv) */ 251 154, /* 67 - r: BOOLEAN_CMP_INT(r,load32) */ 252 155, /* 68 - boolcmp: BOOLEAN_CMP_INT(riv,load32) */ 253 158, /* 69 - r: BOOLEAN_CMP_LONG(rlv,rlv) */ 254 159, /* 70 - boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) */ 255 204, /* 71 - czr: INT_ADD(r,riv) */ 256 205, /* 72 - r: INT_ADD(r,riv) */ 257 206, /* 73 - czr: INT_ADD(r,load32) */ 258 207, /* 74 - czr: INT_ADD(load32,riv) */ 259 212, /* 75 - szpr: INT_AND(r,riv) */ 260 213, /* 76 - szp: INT_AND(r,riv) */ 261 214, /* 77 - szpr: INT_AND(r,load32) */ 262 215, /* 78 - szpr: INT_AND(load32,riv) */ 263 216, /* 79 - szp: INT_AND(load8_16_32,riv) */ 264 217, /* 80 - szp: INT_AND(r,load8_16_32) */ 265 222, /* 81 - r: INT_DIV(riv,riv) */ 266 223, /* 82 - r: INT_DIV(riv,load32) */ 267 224, /* 83 - stm: INT_IFCMP(r,riv) */ 268 227, /* 84 - stm: INT_IFCMP(uload8,r) */ 269 228, /* 85 - stm: INT_IFCMP(r,uload8) */ 270 230, /* 86 - stm: INT_IFCMP(load32,riv) */ 271 231, /* 87 - stm: INT_IFCMP(r,load32) */ 272 237, /* 88 - stm: INT_IFCMP2(r,riv) */ 273 238, /* 89 - stm: INT_IFCMP2(load32,riv) */ 274 239, /* 90 - stm: INT_IFCMP2(riv,load32) */ 275 240, /* 91 - r: INT_LOAD(riv,riv) */ 276 241, /* 92 - r: INT_LOAD(riv,address1scaledreg) */ 277 242, /* 93 - r: INT_LOAD(address1scaledreg,riv) */ 278 243, /* 94 - r: INT_LOAD(address1scaledreg,address1reg) */ 279 244, /* 95 - r: INT_LOAD(address1reg,address1scaledreg) */ 280 246, /* 96 - r: INT_ALOAD(riv,riv) */ 281 259, /* 97 - r: INT_MUL(r,riv) */ 282 260, /* 98 - r: INT_MUL(r,load32) */ 283 261, /* 99 - r: INT_MUL(load32,riv) */ 284 268, /* 100 - szpr: INT_OR(r,riv) */ 285 269, /* 101 - szpr: INT_OR(r,load32) */ 286 270, /* 102 - szpr: INT_OR(load32,riv) */ 287 275, /* 103 - r: INT_REM(riv,riv) */ 288 276, /* 104 - r: INT_REM(riv,load32) */ 289 286, /* 105 - szpr: INT_SHL(riv,riv) */ 290 295, /* 106 - szpr: INT_SHR(riv,riv) */ 291 307, /* 107 - czr: INT_SUB(riv,r) */ 292 308, /* 108 - r: INT_SUB(riv,r) */ 293 309, /* 109 - r: INT_SUB(load32,r) */ 294 310, /* 110 - czr: INT_SUB(riv,load32) */ 295 311, /* 111 - czr: INT_SUB(load32,riv) */ 296 317, /* 112 - szpr: INT_USHR(riv,riv) */ 297 323, /* 113 - szpr: INT_XOR(r,riv) */ 298 324, /* 114 - szpr: INT_XOR(r,load32) */ 299 325, /* 115 - szpr: INT_XOR(load32,riv) */ 300 331, /* 116 - r: INT_ADD(address1scaledreg,r) */ 301 332, /* 117 - r: INT_ADD(r,address1scaledreg) */ 302 333, /* 118 - r: INT_ADD(address1scaledreg,address1reg) */ 303 334, /* 119 - r: INT_ADD(address1reg,address1scaledreg) */ 304 337, /* 120 - r: BYTE_LOAD(riv,riv) */ 305 338, /* 121 - sload8: BYTE_LOAD(riv,riv) */ 306 339, /* 122 - r: BYTE_ALOAD(riv,riv) */ 307 340, /* 123 - sload8: BYTE_ALOAD(riv,riv) */ 308 341, /* 124 - r: UBYTE_LOAD(riv,riv) */ 309 342, /* 125 - uload8: UBYTE_LOAD(riv,riv) */ 310 343, /* 126 - r: UBYTE_ALOAD(riv,riv) */ 311 344, /* 127 - uload8: UBYTE_ALOAD(riv,riv) */ 312 347, /* 128 - r: SHORT_LOAD(riv,riv) */ 313 348, /* 129 - sload16: SHORT_LOAD(riv,riv) */ 314 349, /* 130 - r: SHORT_ALOAD(riv,riv) */ 315 350, /* 131 - sload16: SHORT_ALOAD(riv,riv) */ 316 351, /* 132 - r: USHORT_LOAD(riv,riv) */ 317 352, /* 133 - uload16: USHORT_LOAD(riv,riv) */ 318 353, /* 134 - r: USHORT_ALOAD(riv,riv) */ 319 354, /* 135 - uload16: USHORT_ALOAD(riv,riv) */ 320 357, /* 136 - load32: INT_LOAD(riv,riv) */ 321 358, /* 137 - load32: INT_ALOAD(riv,riv) */ 322 363, /* 138 - load64: LONG_LOAD(riv,riv) */ 323 364, /* 139 - load64: LONG_ALOAD(riv,riv) */ 324 376, /* 140 - r: LONG_ADD(r,rlv) */ 325 377, /* 141 - r: LONG_ADD(r,load64) */ 326 378, /* 142 - r: LONG_ADD(load64,rlv) */ 327 383, /* 143 - r: LONG_AND(r,rlv) */ 328 384, /* 144 - r: LONG_AND(r,load64) */ 329 385, /* 145 - r: LONG_AND(load64,rlv) */ 330 390, /* 146 - stm: LONG_IFCMP(r,rlv) */ 331 391, /* 147 - r: LONG_LOAD(riv,riv) */ 332 392, /* 148 - r: LONG_ALOAD(riv,riv) */ 333 396, /* 149 - r: LONG_MUL(r,rlv) */ 334 406, /* 150 - r: LONG_OR(r,rlv) */ 335 407, /* 151 - r: LONG_OR(r,load64) */ 336 408, /* 152 - r: LONG_OR(load64,rlv) */ 337 413, /* 153 - r: LONG_SHL(rlv,riv) */ 338 415, /* 154 - r: LONG_SHR(rlv,riv) */ 339 419, /* 155 - r: LONG_SUB(rlv,rlv) */ 340 420, /* 156 - r: LONG_SUB(rlv,load64) */ 341 421, /* 157 - r: LONG_SUB(load64,rlv) */ 342 424, /* 158 - r: LONG_USHR(rlv,riv) */ 343 426, /* 159 - r: LONG_XOR(r,rlv) */ 344 427, /* 160 - r: LONG_XOR(r,load64) */ 345 428, /* 161 - r: LONG_XOR(load64,rlv) */ 346 433, /* 162 - r: FLOAT_ADD(r,r) */ 347 434, /* 163 - r: FLOAT_ADD(r,float_load) */ 348 435, /* 164 - r: FLOAT_ADD(float_load,r) */ 349 436, /* 165 - r: DOUBLE_ADD(r,r) */ 350 437, /* 166 - r: DOUBLE_ADD(r,double_load) */ 351 438, /* 167 - r: DOUBLE_ADD(double_load,r) */ 352 439, /* 168 - r: FLOAT_SUB(r,r) */ 353 440, /* 169 - r: FLOAT_SUB(r,float_load) */ 354 441, /* 170 - r: DOUBLE_SUB(r,r) */ 355 442, /* 171 - r: DOUBLE_SUB(r,double_load) */ 356 443, /* 172 - r: FLOAT_MUL(r,r) */ 357 444, /* 173 - r: FLOAT_MUL(r,float_load) */ 358 445, /* 174 - r: FLOAT_MUL(float_load,r) */ 359 446, /* 175 - r: DOUBLE_MUL(r,r) */ 360 447, /* 176 - r: DOUBLE_MUL(r,double_load) */ 361 448, /* 177 - r: DOUBLE_MUL(double_load,r) */ 362 449, /* 178 - r: FLOAT_DIV(r,r) */ 363 450, /* 179 - r: FLOAT_DIV(r,float_load) */ 364 451, /* 180 - r: DOUBLE_DIV(r,r) */ 365 452, /* 181 - r: DOUBLE_DIV(r,double_load) */ 366 457, /* 182 - r: FLOAT_REM(r,r) */ 367 458, /* 183 - r: DOUBLE_REM(r,r) */ 368 463, /* 184 - r: DOUBLE_LOAD(riv,riv) */ 369 464, /* 185 - r: DOUBLE_LOAD(riv,rlv) */ 370 465, /* 186 - r: DOUBLE_LOAD(rlv,rlv) */ 371 466, /* 187 - double_load: DOUBLE_LOAD(riv,riv) */ 372 467, /* 188 - r: DOUBLE_ALOAD(riv,riv) */ 373 468, /* 189 - double_load: DOUBLE_LOAD(rlv,rlv) */ 374 469, /* 190 - r: DOUBLE_ALOAD(riv,r) */ 375 470, /* 191 - r: DOUBLE_ALOAD(rlv,rlv) */ 376 471, /* 192 - double_load: DOUBLE_ALOAD(riv,riv) */ 377 472, /* 193 - r: FLOAT_LOAD(riv,riv) */ 378 473, /* 194 - r: FLOAT_LOAD(rlv,rlv) */ 379 474, /* 195 - float_load: FLOAT_LOAD(riv,riv) */ 380 475, /* 196 - r: FLOAT_ALOAD(riv,riv) */ 381 476, /* 197 - r: FLOAT_ALOAD(riv,r) */ 382 477, /* 198 - r: FLOAT_ALOAD(rlv,rlv) */ 383 478, /* 199 - float_load: FLOAT_ALOAD(riv,riv) */ 384 521, /* 200 - stm: FLOAT_IFCMP(r,r) */ 385 522, /* 201 - stm: FLOAT_IFCMP(r,float_load) */ 386 523, /* 202 - stm: FLOAT_IFCMP(float_load,r) */ 387 524, /* 203 - stm: DOUBLE_IFCMP(r,r) */ 388 525, /* 204 - stm: DOUBLE_IFCMP(r,double_load) */ 389 526, /* 205 - stm: DOUBLE_IFCMP(double_load,r) */ 390 22, /* 206 - stm: LOWTABLESWITCH(r) */ 391 27, /* 207 - stm: NULL_CHECK(riv) */ 392 30, /* 208 - stm: SET_CAUGHT_EXCEPTION(r) */ 393 33, /* 209 - stm: TRAP_IF(r,INT_CONSTANT) */ 394 34, /* 210 - stm: TRAP_IF(r,LONG_CONSTANT) */ 395 38, /* 211 - uload8: INT_AND(load8_16_32,INT_CONSTANT) */ 396 39, /* 212 - r: INT_AND(load8_16_32,INT_CONSTANT) */ 397 40, /* 213 - r: INT_2BYTE(load8_16_32) */ 398 42, /* 214 - r: INT_AND(load16_32,INT_CONSTANT) */ 399 63, /* 215 - stm: PREFETCH(r) */ 400 70, /* 216 - stm: RETURN(r) */ 401 83, /* 217 - address: INT_MOVE(address) */ 402 87, /* 218 - address: INT_ADD(address1scaledreg,INT_CONSTANT) */ 403 90, /* 219 - address1reg: INT_ADD(r,INT_CONSTANT) */ 404 91, /* 220 - address1reg: INT_MOVE(r) */ 405 92, /* 221 - address1reg: INT_MOVE(address1reg) */ 406 93, /* 222 - address1reg: INT_ADD(address1reg,INT_CONSTANT) */ 407 95, /* 223 - address1scaledreg: INT_MOVE(address1scaledreg) */ 408 96, /* 224 - address1scaledreg: INT_SHL(r,INT_CONSTANT) */ 409 97, /* 225 - address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) */ 410 98, /* 226 - r: ADDR_2LONG(r) */ 411 99, /* 227 - r: ADDR_2LONG(load32) */ 412 136, /* 228 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 413 137, /* 229 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 414 138, /* 230 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 415 139, /* 231 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) */ 416 140, /* 232 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 417 141, /* 233 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) */ 418 142, /* 234 - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) */ 419 143, /* 235 - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) */ 420 144, /* 236 - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) */ 421 145, /* 237 - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) */ 422 146, /* 238 - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) */ 423 147, /* 239 - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) */ 424 148, /* 240 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 425 149, /* 241 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 426 150, /* 242 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 427 151, /* 243 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 428 160, /* 244 - r: BOOLEAN_NOT(r) */ 429 169, /* 245 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 430 170, /* 246 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 431 171, /* 247 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 432 172, /* 248 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) */ 433 184, /* 249 - r: INT_2BYTE(r) */ 434 185, /* 250 - r: INT_2BYTE(load8_16_32) */ 435 188, /* 251 - r: INT_2LONG(r) */ 436 189, /* 252 - r: INT_2LONG(load32) */ 437 194, /* 253 - r: INT_2SHORT(r) */ 438 195, /* 254 - r: INT_2SHORT(load16_32) */ 439 196, /* 255 - sload16: INT_2SHORT(load16_32) */ 440 199, /* 256 - szpr: INT_2USHORT(r) */ 441 200, /* 257 - uload16: INT_2USHORT(load16_32) */ 442 201, /* 258 - r: INT_2USHORT(load16_32) */ 443 225, /* 259 - stm: INT_IFCMP(r,INT_CONSTANT) */ 444 226, /* 260 - stm: INT_IFCMP(load8,INT_CONSTANT) */ 445 229, /* 261 - stm: INT_IFCMP(sload16,INT_CONSTANT) */ 446 232, /* 262 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 447 233, /* 263 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 448 234, /* 264 - stm: INT_IFCMP(cz,INT_CONSTANT) */ 449 235, /* 265 - stm: INT_IFCMP(szp,INT_CONSTANT) */ 450 236, /* 266 - stm: INT_IFCMP(bittest,INT_CONSTANT) */ 451 245, /* 267 - r: INT_LOAD(address,INT_CONSTANT) */ 452 247, /* 268 - r: INT_MOVE(riv) */ 453 248, /* 269 - czr: INT_MOVE(czr) */ 454 249, /* 270 - cz: INT_MOVE(cz) */ 455 250, /* 271 - szpr: INT_MOVE(szpr) */ 456 251, /* 272 - szp: INT_MOVE(szp) */ 457 252, /* 273 - sload8: INT_MOVE(sload8) */ 458 253, /* 274 - uload8: INT_MOVE(uload8) */ 459 254, /* 275 - load8: INT_MOVE(load8) */ 460 255, /* 276 - sload16: INT_MOVE(sload16) */ 461 256, /* 277 - uload16: INT_MOVE(uload16) */ 462 257, /* 278 - load16: INT_MOVE(load16) */ 463 258, /* 279 - load32: INT_MOVE(load32) */ 464 262, /* 280 - szpr: INT_NEG(r) */ 465 265, /* 281 - r: INT_NOT(r) */ 466 287, /* 282 - szpr: INT_SHL(r,INT_CONSTANT) */ 467 288, /* 283 - r: INT_SHL(r,INT_CONSTANT) */ 468 296, /* 284 - szpr: INT_SHR(riv,INT_CONSTANT) */ 469 318, /* 285 - szpr: INT_USHR(riv,INT_CONSTANT) */ 470 335, /* 286 - r: INT_ADD(address,INT_CONSTANT) */ 471 336, /* 287 - r: INT_MOVE(address) */ 472 365, /* 288 - r: LONG_2INT(r) */ 473 368, /* 289 - r: LONG_2INT(load64) */ 474 369, /* 290 - load32: LONG_2INT(load64) */ 475 393, /* 291 - r: LONG_MOVE(r) */ 476 395, /* 292 - load64: LONG_MOVE(load64) */ 477 400, /* 293 - r: LONG_NEG(r) */ 478 403, /* 294 - r: LONG_NOT(r) */ 479 453, /* 295 - r: FLOAT_NEG(r) */ 480 454, /* 296 - r: DOUBLE_NEG(r) */ 481 455, /* 297 - r: FLOAT_SQRT(r) */ 482 456, /* 298 - r: DOUBLE_SQRT(r) */ 483 459, /* 299 - r: LONG_2FLOAT(r) */ 484 460, /* 300 - r: LONG_2DOUBLE(r) */ 485 461, /* 301 - r: FLOAT_MOVE(r) */ 486 462, /* 302 - r: DOUBLE_MOVE(r) */ 487 497, /* 303 - r: INT_2FLOAT(riv) */ 488 498, /* 304 - r: INT_2FLOAT(load32) */ 489 499, /* 305 - r: INT_2DOUBLE(riv) */ 490 500, /* 306 - r: INT_2DOUBLE(load32) */ 491 501, /* 307 - r: FLOAT_2DOUBLE(r) */ 492 502, /* 308 - r: FLOAT_2DOUBLE(float_load) */ 493 503, /* 309 - r: DOUBLE_2FLOAT(r) */ 494 504, /* 310 - r: DOUBLE_2FLOAT(double_load) */ 495 505, /* 311 - r: FLOAT_2INT(r) */ 496 506, /* 312 - r: FLOAT_2LONG(r) */ 497 507, /* 313 - r: DOUBLE_2INT(r) */ 498 508, /* 314 - r: DOUBLE_2LONG(r) */ 499 509, /* 315 - r: FLOAT_AS_INT_BITS(r) */ 500 510, /* 316 - load32: FLOAT_AS_INT_BITS(float_load) */ 501 511, /* 317 - r: DOUBLE_AS_LONG_BITS(r) */ 502 512, /* 318 - load64: DOUBLE_AS_LONG_BITS(double_load) */ 503 513, /* 319 - r: INT_BITS_AS_FLOAT(riv) */ 504 514, /* 320 - float_load: INT_BITS_AS_FLOAT(load32) */ 505 515, /* 321 - r: LONG_BITS_AS_DOUBLE(rlv) */ 506 516, /* 322 - double_load: LONG_BITS_AS_DOUBLE(load64) */ 507 517, /* 323 - r: MATERIALIZE_FP_CONSTANT(any) */ 508 518, /* 324 - float_load: MATERIALIZE_FP_CONSTANT(any) */ 509 519, /* 325 - double_load: MATERIALIZE_FP_CONSTANT(any) */ 510 41, /* 326 - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) */ 511 43, /* 327 - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) */ 512 126, /* 328 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 513 129, /* 329 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 514 190, /* 330 - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) */ 515 191, /* 331 - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) */ 516 192, /* 332 - r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) */ 517 193, /* 333 - r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) */ 518 289, /* 334 - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 519 370, /* 335 - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) */ 520 371, /* 336 - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) */ 521 372, /* 337 - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) */ 522 373, /* 338 - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) */ 523 374, /* 339 - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) */ 524 375, /* 340 - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) */ 525 398, /* 341 - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) */ 526 44, /* 342 - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) */ 527 45, /* 343 - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) */ 528 46, /* 344 - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) */ 529 47, /* 345 - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) */ 530 48, /* 346 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) */ 531 49, /* 347 - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) */ 532 50, /* 348 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) */ 533 51, /* 349 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) */ 534 52, /* 350 - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) */ 535 53, /* 351 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) */ 536 54, /* 352 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) */ 537 55, /* 353 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) */ 538 56, /* 354 - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 539 57, /* 355 - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 540 58, /* 356 - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) */ 541 156, /* 357 - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) */ 542 157, /* 358 - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) */ 543 163, /* 359 - stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) */ 544 164, /* 360 - stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) */ 545 165, /* 361 - stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) */ 546 166, /* 362 - stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) */ 547 167, /* 363 - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) */ 548 174, /* 364 - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) */ 549 175, /* 365 - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) */ 550 177, /* 366 - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) */ 551 178, /* 367 - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) */ 552 301, /* 368 - stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) */ 553 302, /* 369 - stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) */ 554 303, /* 370 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) */ 555 304, /* 371 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) */ 556 305, /* 372 - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) */ 557 330, /* 373 - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) */ 558 417, /* 374 - stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) */ 559 479, /* 375 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) */ 560 480, /* 376 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) */ 561 481, /* 377 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) */ 562 482, /* 378 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) */ 563 483, /* 379 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 564 484, /* 380 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) */ 565 485, /* 381 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) */ 566 486, /* 382 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 567 487, /* 383 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) */ 568 488, /* 384 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) */ 569 489, /* 385 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) */ 570 490, /* 386 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) */ 571 491, /* 387 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) */ 572 492, /* 388 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) */ 573 493, /* 389 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) */ 574 494, /* 390 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) */ 575 495, /* 391 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) */ 576 496, /* 392 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) */ 577 527, /* 393 - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) */ 578 528, /* 394 - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) */ 579 529, /* 395 - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) */ 580 530, /* 396 - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) */ 581 531, /* 397 - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) */ 582 532, /* 398 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) */ 583 537, /* 399 - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) */ 584 538, /* 400 - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) */ 585 555, /* 401 - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) */ 586 556, /* 402 - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) */ 587 557, /* 403 - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) */ 588 558, /* 404 - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) */ 589 59, /* 405 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) */ 590 60, /* 406 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) */ 591 418, /* 407 - stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) */ 592 73, /* 408 - r: CALL(BRANCH_TARGET,any) */ 593 75, /* 409 - r: CALL(INT_CONSTANT,any) */ 594 79, /* 410 - r: SYSCALL(INT_CONSTANT,any) */ 595 74, /* 411 - r: CALL(INT_LOAD(riv,riv),any) */ 596 76, /* 412 - r: CALL(LONG_LOAD(rlv,rlv),any) */ 597 78, /* 413 - r: SYSCALL(INT_LOAD(riv,riv),any) */ 598 100, /* 414 - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) */ 599 101, /* 415 - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) */ 600 102, /* 416 - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) */ 601 103, /* 417 - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) */ 602 104, /* 418 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) */ 603 105, /* 419 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) */ 604 106, /* 420 - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) */ 605 123, /* 421 - r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) */ 606 533, /* 422 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) */ 607 534, /* 423 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) */ 608 535, /* 424 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) */ 609 536, /* 425 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) */ 610 107, /* 426 - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) */ 611 108, /* 427 - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) */ 612 109, /* 428 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 613 110, /* 429 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 614 111, /* 430 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 615 112, /* 431 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 616 113, /* 432 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 617 116, /* 433 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 618 117, /* 434 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 619 118, /* 435 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 620 119, /* 436 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 621 120, /* 437 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 622 114, /* 438 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 623 121, /* 439 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 624 115, /* 440 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 625 122, /* 441 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) */ 626 124, /* 442 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 627 125, /* 443 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 628 127, /* 444 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 629 128, /* 445 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) */ 630 130, /* 446 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) */ 631 131, /* 447 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) */ 632 132, /* 448 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) */ 633 133, /* 449 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) */ 634 161, /* 450 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 635 162, /* 451 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 636 263, /* 452 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 637 264, /* 453 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 638 266, /* 454 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 639 267, /* 455 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 640 291, /* 456 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 641 293, /* 457 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 642 298, /* 458 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 643 300, /* 459 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 644 320, /* 460 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 645 322, /* 461 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) */ 646 401, /* 462 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 647 402, /* 463 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 648 404, /* 464 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 649 405, /* 465 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 650 168, /* 466 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) */ 651 173, /* 467 - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) */ 652 176, /* 468 - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) */ 653 179, /* 469 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) */ 654 180, /* 470 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) */ 655 181, /* 471 - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) */ 656 182, /* 472 - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) */ 657 183, /* 473 - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) */ 658 186, /* 474 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) */ 659 187, /* 475 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) */ 660 197, /* 476 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) */ 661 198, /* 477 - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) */ 662 202, /* 478 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) */ 663 203, /* 479 - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) */ 664 366, /* 480 - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) */ 665 367, /* 481 - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) */ 666 208, /* 482 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 667 210, /* 483 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 668 218, /* 484 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 669 220, /* 485 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 670 271, /* 486 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 671 273, /* 487 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 672 312, /* 488 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 673 314, /* 489 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 674 326, /* 490 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 675 328, /* 491 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) */ 676 379, /* 492 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 677 381, /* 493 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 678 386, /* 494 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 679 388, /* 495 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 680 409, /* 496 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 681 411, /* 497 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 682 422, /* 498 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 683 423, /* 499 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 684 429, /* 500 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 685 431, /* 501 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) */ 686 209, /* 502 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 687 211, /* 503 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 688 219, /* 504 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 689 221, /* 505 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 690 272, /* 506 - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 691 274, /* 507 - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 692 313, /* 508 - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 693 315, /* 509 - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 694 327, /* 510 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 695 329, /* 511 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) */ 696 380, /* 512 - stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 697 382, /* 513 - stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 698 387, /* 514 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 699 389, /* 515 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 700 410, /* 516 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 701 412, /* 517 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 702 430, /* 518 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 703 432, /* 519 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) */ 704 277, /* 520 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) */ 705 278, /* 521 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) */ 706 279, /* 522 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) */ 707 280, /* 523 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) */ 708 397, /* 524 - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) */ 709 399, /* 525 - r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) */ 710 281, /* 526 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) */ 711 284, /* 527 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) */ 712 282, /* 528 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) */ 713 283, /* 529 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) */ 714 285, /* 530 - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) */ 715 294, /* 531 - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) */ 716 306, /* 532 - stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) */ 717 316, /* 533 - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) */ 718 414, /* 534 - r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) */ 719 416, /* 535 - r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) */ 720 425, /* 536 - r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) */ 721 290, /* 537 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 722 292, /* 538 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 723 297, /* 539 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 724 299, /* 540 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 725 319, /* 541 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 726 321, /* 542 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) */ 727 539, /* 543 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 728 540, /* 544 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 729 547, /* 545 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 730 548, /* 546 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 731 541, /* 547 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) */ 732 542, /* 548 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) */ 733 549, /* 549 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 734 550, /* 550 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 735 543, /* 551 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) */ 736 544, /* 552 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) */ 737 551, /* 553 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 738 552, /* 554 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) */ 739 545, /* 555 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 740 546, /* 556 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) */ 741 553, /* 557 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) */ 742 }; 743 744 /** Ragged array for non-terminal leaves of r_NT, */ 745 private static final byte[] nts_0 = { r_NT, }; 746 /** Ragged array for non-terminal leaves of czr_NT, */ 747 private static final byte[] nts_1 = { czr_NT, }; 748 /** Ragged array for non-terminal leaves of szpr_NT, */ 749 private static final byte[] nts_2 = { szpr_NT, }; 750 /** Ragged array for non-terminal leaves of riv_NT, */ 751 private static final byte[] nts_3 = { riv_NT, }; 752 /** Ragged array for non-terminal leaves of address1scaledreg_NT, */ 753 private static final byte[] nts_4 = { address1scaledreg_NT, }; 754 /** Ragged array for non-terminal leaves of address1reg_NT, */ 755 private static final byte[] nts_5 = { address1reg_NT, }; 756 /** Ragged array for non-terminal leaves of sload8_NT, */ 757 private static final byte[] nts_6 = { sload8_NT, }; 758 /** Ragged array for non-terminal leaves of uload8_NT, */ 759 private static final byte[] nts_7 = { uload8_NT, }; 760 /** Ragged array for non-terminal leaves of sload16_NT, */ 761 private static final byte[] nts_8 = { sload16_NT, }; 762 /** Ragged array for non-terminal leaves of uload16_NT, */ 763 private static final byte[] nts_9 = { uload16_NT, }; 764 /** Ragged array for non-terminal leaves of load16_NT, */ 765 private static final byte[] nts_10 = { load16_NT, }; 766 /** Ragged array for non-terminal leaves of load32_NT, */ 767 private static final byte[] nts_11 = { load32_NT, }; 768 /** Ragged array for non-terminal leaves of load16_32_NT, */ 769 private static final byte[] nts_12 = { load16_32_NT, }; 770 /** Ragged array for non-terminal leaves of load8_NT, */ 771 private static final byte[] nts_13 = { load8_NT, }; 772 /** Ragged array for non-terminal leaves of */ 773 private static final byte[] nts_14 = { }; 774 /** Ragged array for non-terminal leaves of any_NT, any_NT, */ 775 private static final byte[] nts_15 = { any_NT, any_NT, }; 776 /** Ragged array for non-terminal leaves of r_NT, r_NT, */ 777 private static final byte[] nts_16 = { r_NT, r_NT, }; 778 /** Ragged array for non-terminal leaves of load32_NT, riv_NT, */ 779 private static final byte[] nts_17 = { load32_NT, riv_NT, }; 780 /** Ragged array for non-terminal leaves of riv_NT, load32_NT, */ 781 private static final byte[] nts_18 = { riv_NT, load32_NT, }; 782 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, */ 783 private static final byte[] nts_19 = { rlv_NT, rlv_NT, }; 784 /** Ragged array for non-terminal leaves of r_NT, any_NT, */ 785 private static final byte[] nts_20 = { r_NT, any_NT, }; 786 /** Ragged array for non-terminal leaves of r_NT, address1scaledreg_NT, */ 787 private static final byte[] nts_21 = { r_NT, address1scaledreg_NT, }; 788 /** Ragged array for non-terminal leaves of address1scaledreg_NT, r_NT, */ 789 private static final byte[] nts_22 = { address1scaledreg_NT, r_NT, }; 790 /** Ragged array for non-terminal leaves of address1scaledreg_NT, address1reg_NT, */ 791 private static final byte[] nts_23 = { address1scaledreg_NT, address1reg_NT, }; 792 /** Ragged array for non-terminal leaves of address1reg_NT, address1scaledreg_NT, */ 793 private static final byte[] nts_24 = { address1reg_NT, address1scaledreg_NT, }; 794 /** Ragged array for non-terminal leaves of r_NT, riv_NT, */ 795 private static final byte[] nts_25 = { r_NT, riv_NT, }; 796 /** Ragged array for non-terminal leaves of r_NT, load32_NT, */ 797 private static final byte[] nts_26 = { r_NT, load32_NT, }; 798 /** Ragged array for non-terminal leaves of load8_16_32_NT, riv_NT, */ 799 private static final byte[] nts_27 = { load8_16_32_NT, riv_NT, }; 800 /** Ragged array for non-terminal leaves of r_NT, load8_16_32_NT, */ 801 private static final byte[] nts_28 = { r_NT, load8_16_32_NT, }; 802 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, */ 803 private static final byte[] nts_29 = { riv_NT, riv_NT, }; 804 /** Ragged array for non-terminal leaves of uload8_NT, r_NT, */ 805 private static final byte[] nts_30 = { uload8_NT, r_NT, }; 806 /** Ragged array for non-terminal leaves of r_NT, uload8_NT, */ 807 private static final byte[] nts_31 = { r_NT, uload8_NT, }; 808 /** Ragged array for non-terminal leaves of riv_NT, address1scaledreg_NT, */ 809 private static final byte[] nts_32 = { riv_NT, address1scaledreg_NT, }; 810 /** Ragged array for non-terminal leaves of address1scaledreg_NT, riv_NT, */ 811 private static final byte[] nts_33 = { address1scaledreg_NT, riv_NT, }; 812 /** Ragged array for non-terminal leaves of riv_NT, r_NT, */ 813 private static final byte[] nts_34 = { riv_NT, r_NT, }; 814 /** Ragged array for non-terminal leaves of load32_NT, r_NT, */ 815 private static final byte[] nts_35 = { load32_NT, r_NT, }; 816 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, */ 817 private static final byte[] nts_36 = { r_NT, rlv_NT, }; 818 /** Ragged array for non-terminal leaves of r_NT, load64_NT, */ 819 private static final byte[] nts_37 = { r_NT, load64_NT, }; 820 /** Ragged array for non-terminal leaves of load64_NT, rlv_NT, */ 821 private static final byte[] nts_38 = { load64_NT, rlv_NT, }; 822 /** Ragged array for non-terminal leaves of rlv_NT, riv_NT, */ 823 private static final byte[] nts_39 = { rlv_NT, riv_NT, }; 824 /** Ragged array for non-terminal leaves of rlv_NT, load64_NT, */ 825 private static final byte[] nts_40 = { rlv_NT, load64_NT, }; 826 /** Ragged array for non-terminal leaves of r_NT, float_load_NT, */ 827 private static final byte[] nts_41 = { r_NT, float_load_NT, }; 828 /** Ragged array for non-terminal leaves of float_load_NT, r_NT, */ 829 private static final byte[] nts_42 = { float_load_NT, r_NT, }; 830 /** Ragged array for non-terminal leaves of r_NT, double_load_NT, */ 831 private static final byte[] nts_43 = { r_NT, double_load_NT, }; 832 /** Ragged array for non-terminal leaves of double_load_NT, r_NT, */ 833 private static final byte[] nts_44 = { double_load_NT, r_NT, }; 834 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, */ 835 private static final byte[] nts_45 = { riv_NT, rlv_NT, }; 836 /** Ragged array for non-terminal leaves of load8_16_32_NT, */ 837 private static final byte[] nts_46 = { load8_16_32_NT, }; 838 /** Ragged array for non-terminal leaves of address_NT, */ 839 private static final byte[] nts_47 = { address_NT, }; 840 /** Ragged array for non-terminal leaves of cz_NT, */ 841 private static final byte[] nts_48 = { cz_NT, }; 842 /** Ragged array for non-terminal leaves of szp_NT, */ 843 private static final byte[] nts_49 = { szp_NT, }; 844 /** Ragged array for non-terminal leaves of bittest_NT, */ 845 private static final byte[] nts_50 = { bittest_NT, }; 846 /** Ragged array for non-terminal leaves of boolcmp_NT, */ 847 private static final byte[] nts_51 = { boolcmp_NT, }; 848 /** Ragged array for non-terminal leaves of load64_NT, */ 849 private static final byte[] nts_52 = { load64_NT, }; 850 /** Ragged array for non-terminal leaves of float_load_NT, */ 851 private static final byte[] nts_53 = { float_load_NT, }; 852 /** Ragged array for non-terminal leaves of double_load_NT, */ 853 private static final byte[] nts_54 = { double_load_NT, }; 854 /** Ragged array for non-terminal leaves of rlv_NT, */ 855 private static final byte[] nts_55 = { rlv_NT, }; 856 /** Ragged array for non-terminal leaves of any_NT, */ 857 private static final byte[] nts_56 = { any_NT, }; 858 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, */ 859 private static final byte[] nts_57 = { riv_NT, riv_NT, riv_NT, }; 860 /** Ragged array for non-terminal leaves of load16_NT, riv_NT, riv_NT, */ 861 private static final byte[] nts_58 = { load16_NT, riv_NT, riv_NT, }; 862 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, rlv_NT, */ 863 private static final byte[] nts_59 = { rlv_NT, rlv_NT, rlv_NT, }; 864 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, rlv_NT, */ 865 private static final byte[] nts_60 = { riv_NT, rlv_NT, rlv_NT, }; 866 /** Ragged array for non-terminal leaves of riv_NT, r_NT, r_NT, */ 867 private static final byte[] nts_61 = { riv_NT, r_NT, r_NT, }; 868 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, riv_NT, */ 869 private static final byte[] nts_62 = { riv_NT, rlv_NT, riv_NT, }; 870 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, rlv_NT, */ 871 private static final byte[] nts_63 = { riv_NT, riv_NT, rlv_NT, }; 872 /** Ragged array for non-terminal leaves of r_NT, riv_NT, riv_NT, */ 873 private static final byte[] nts_64 = { r_NT, riv_NT, riv_NT, }; 874 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, rlv_NT, */ 875 private static final byte[] nts_65 = { r_NT, rlv_NT, rlv_NT, }; 876 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, */ 877 private static final byte[] nts_66 = { r_NT, r_NT, r_NT, }; 878 /** Ragged array for non-terminal leaves of boolcmp_NT, riv_NT, riv_NT, */ 879 private static final byte[] nts_67 = { boolcmp_NT, riv_NT, riv_NT, }; 880 /** Ragged array for non-terminal leaves of load8_NT, riv_NT, riv_NT, */ 881 private static final byte[] nts_68 = { load8_NT, riv_NT, riv_NT, }; 882 /** Ragged array for non-terminal leaves of r_NT, riv_NT, any_NT, */ 883 private static final byte[] nts_69 = { r_NT, riv_NT, any_NT, }; 884 /** Ragged array for non-terminal leaves of uload8_NT, riv_NT, any_NT, */ 885 private static final byte[] nts_70 = { uload8_NT, riv_NT, any_NT, }; 886 /** Ragged array for non-terminal leaves of riv_NT, uload8_NT, any_NT, */ 887 private static final byte[] nts_71 = { riv_NT, uload8_NT, any_NT, }; 888 /** Ragged array for non-terminal leaves of load32_NT, riv_NT, any_NT, */ 889 private static final byte[] nts_72 = { load32_NT, riv_NT, any_NT, }; 890 /** Ragged array for non-terminal leaves of riv_NT, load32_NT, any_NT, */ 891 private static final byte[] nts_73 = { riv_NT, load32_NT, any_NT, }; 892 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, address1scaledreg_NT, */ 893 private static final byte[] nts_74 = { riv_NT, riv_NT, address1scaledreg_NT, }; 894 /** Ragged array for non-terminal leaves of riv_NT, address1scaledreg_NT, riv_NT, */ 895 private static final byte[] nts_75 = { riv_NT, address1scaledreg_NT, riv_NT, }; 896 /** Ragged array for non-terminal leaves of riv_NT, address1scaledreg_NT, address1reg_NT, */ 897 private static final byte[] nts_76 = { riv_NT, address1scaledreg_NT, address1reg_NT, }; 898 /** Ragged array for non-terminal leaves of riv_NT, address1reg_NT, address1scaledreg_NT, */ 899 private static final byte[] nts_77 = { riv_NT, address1reg_NT, address1scaledreg_NT, }; 900 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, any_NT, */ 901 private static final byte[] nts_78 = { r_NT, rlv_NT, any_NT, }; 902 /** Ragged array for non-terminal leaves of r_NT, riv_NT, rlv_NT, */ 903 private static final byte[] nts_79 = { r_NT, riv_NT, rlv_NT, }; 904 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, riv_NT, */ 905 private static final byte[] nts_80 = { r_NT, rlv_NT, riv_NT, }; 906 /** Ragged array for non-terminal leaves of r_NT, r_NT, any_NT, */ 907 private static final byte[] nts_81 = { r_NT, r_NT, any_NT, }; 908 /** Ragged array for non-terminal leaves of r_NT, float_load_NT, any_NT, */ 909 private static final byte[] nts_82 = { r_NT, float_load_NT, any_NT, }; 910 /** Ragged array for non-terminal leaves of r_NT, double_load_NT, any_NT, */ 911 private static final byte[] nts_83 = { r_NT, double_load_NT, any_NT, }; 912 /** Ragged array for non-terminal leaves of float_load_NT, r_NT, any_NT, */ 913 private static final byte[] nts_84 = { float_load_NT, r_NT, any_NT, }; 914 /** Ragged array for non-terminal leaves of double_load_NT, r_NT, any_NT, */ 915 private static final byte[] nts_85 = { double_load_NT, r_NT, any_NT, }; 916 /** Ragged array for non-terminal leaves of load64_NT, riv_NT, riv_NT, */ 917 private static final byte[] nts_86 = { load64_NT, riv_NT, riv_NT, }; 918 /** Ragged array for non-terminal leaves of load64_NT, rlv_NT, riv_NT, */ 919 private static final byte[] nts_87 = { load64_NT, rlv_NT, riv_NT, }; 920 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, any_NT, */ 921 private static final byte[] nts_88 = { riv_NT, riv_NT, any_NT, }; 922 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, any_NT, */ 923 private static final byte[] nts_89 = { rlv_NT, rlv_NT, any_NT, }; 924 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, riv_NT, */ 925 private static final byte[] nts_90 = { riv_NT, riv_NT, riv_NT, riv_NT, }; 926 /** Ragged array for non-terminal leaves of riv_NT, rlv_NT, riv_NT, riv_NT, */ 927 private static final byte[] nts_91 = { riv_NT, rlv_NT, riv_NT, riv_NT, }; 928 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, riv_NT, riv_NT, */ 929 private static final byte[] nts_92 = { rlv_NT, rlv_NT, riv_NT, riv_NT, }; 930 /** Ragged array for non-terminal leaves of r_NT, address1scaledreg_NT, riv_NT, riv_NT, */ 931 private static final byte[] nts_93 = { r_NT, address1scaledreg_NT, riv_NT, riv_NT, }; 932 /** Ragged array for non-terminal leaves of address1scaledreg_NT, r_NT, riv_NT, riv_NT, */ 933 private static final byte[] nts_94 = { address1scaledreg_NT, r_NT, riv_NT, riv_NT, }; 934 /** Ragged array for non-terminal leaves of address1scaledreg_NT, address1reg_NT, riv_NT, riv_NT, */ 935 private static final byte[] nts_95 = { address1scaledreg_NT, address1reg_NT, riv_NT, riv_NT, }; 936 /** Ragged array for non-terminal leaves of address1reg_NT, address1scaledreg_NT, riv_NT, riv_NT, */ 937 private static final byte[] nts_96 = { address1reg_NT, address1scaledreg_NT, riv_NT, riv_NT, }; 938 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, rlv_NT, rlv_NT, */ 939 private static final byte[] nts_97 = { riv_NT, riv_NT, rlv_NT, rlv_NT, }; 940 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, float_load_NT, */ 941 private static final byte[] nts_98 = { r_NT, r_NT, r_NT, float_load_NT, }; 942 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, double_load_NT, */ 943 private static final byte[] nts_99 = { r_NT, r_NT, r_NT, double_load_NT, }; 944 /** Ragged array for non-terminal leaves of r_NT, r_NT, float_load_NT, r_NT, */ 945 private static final byte[] nts_100 = { r_NT, r_NT, float_load_NT, r_NT, }; 946 /** Ragged array for non-terminal leaves of r_NT, r_NT, double_load_NT, r_NT, */ 947 private static final byte[] nts_101 = { r_NT, r_NT, double_load_NT, r_NT, }; 948 /** Ragged array for non-terminal leaves of address_NT, riv_NT, riv_NT, */ 949 private static final byte[] nts_102 = { address_NT, riv_NT, riv_NT, }; 950 /** Ragged array for non-terminal leaves of load8_NT, any_NT, */ 951 private static final byte[] nts_103 = { load8_NT, any_NT, }; 952 /** Ragged array for non-terminal leaves of sload16_NT, any_NT, */ 953 private static final byte[] nts_104 = { sload16_NT, any_NT, }; 954 /** Ragged array for non-terminal leaves of boolcmp_NT, any_NT, */ 955 private static final byte[] nts_105 = { boolcmp_NT, any_NT, }; 956 /** Ragged array for non-terminal leaves of bittest_NT, any_NT, */ 957 private static final byte[] nts_106 = { bittest_NT, any_NT, }; 958 /** Ragged array for non-terminal leaves of cz_NT, any_NT, */ 959 private static final byte[] nts_107 = { cz_NT, any_NT, }; 960 /** Ragged array for non-terminal leaves of szp_NT, any_NT, */ 961 private static final byte[] nts_108 = { szp_NT, any_NT, }; 962 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, riv_NT, riv_NT, riv_NT, */ 963 private static final byte[] nts_109 = { riv_NT, riv_NT, riv_NT, riv_NT, riv_NT, }; 964 /** Ragged array for non-terminal leaves of rlv_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, */ 965 private static final byte[] nts_110 = { rlv_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, }; 966 /** Ragged array for non-terminal leaves of r_NT, riv_NT, riv_NT, riv_NT, riv_NT, */ 967 private static final byte[] nts_111 = { r_NT, riv_NT, riv_NT, riv_NT, riv_NT, }; 968 /** Ragged array for non-terminal leaves of r_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, */ 969 private static final byte[] nts_112 = { r_NT, rlv_NT, rlv_NT, rlv_NT, rlv_NT, }; 970 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, r_NT, */ 971 private static final byte[] nts_113 = { r_NT, r_NT, r_NT, r_NT, }; 972 /** Ragged array for non-terminal leaves of riv_NT, address_NT, */ 973 private static final byte[] nts_114 = { riv_NT, address_NT, }; 974 /** Ragged array for non-terminal leaves of riv_NT, riv_NT, r_NT, riv_NT, riv_NT, */ 975 private static final byte[] nts_115 = { riv_NT, riv_NT, r_NT, riv_NT, riv_NT, }; 976 977 /** Map non-terminal to non-terminal leaves */ 978 private static final byte[][] nts = { 979 null, /* 0 */ 980 nts_0, // 1 - stm: r 981 nts_1, // 2 - r: czr 982 nts_1, // 3 - cz: czr 983 nts_2, // 4 - r: szpr 984 nts_2, // 5 - szp: szpr 985 nts_0, // 6 - riv: r 986 nts_0, // 7 - rlv: r 987 nts_3, // 8 - any: riv 988 nts_4, // 9 - address: address1scaledreg 989 nts_5, // 10 - address1scaledreg: address1reg 990 nts_6, // 11 - load8: sload8 991 nts_7, // 12 - load8: uload8 992 nts_8, // 13 - load16: sload16 993 nts_9, // 14 - load16: uload16 994 nts_10, // 15 - load16_32: load16 995 nts_11, // 16 - load16_32: load32 996 nts_12, // 17 - load8_16_32: load16_32 997 nts_13, // 18 - load8_16_32: load8 998 nts_14, // 19 - r: REGISTER 999 nts_14, // 20 - riv: INT_CONSTANT 1000 nts_14, // 21 - rlv: LONG_CONSTANT 1001 nts_14, // 22 - any: NULL 1002 nts_14, // 23 - any: ADDRESS_CONSTANT 1003 nts_14, // 24 - any: LONG_CONSTANT 1004 nts_14, // 25 - stm: IG_PATCH_POINT 1005 nts_14, // 26 - stm: UNINT_BEGIN 1006 nts_14, // 27 - stm: UNINT_END 1007 nts_14, // 28 - stm: YIELDPOINT_PROLOGUE 1008 nts_14, // 29 - stm: YIELDPOINT_EPILOGUE 1009 nts_14, // 30 - stm: YIELDPOINT_BACKEDGE 1010 nts_14, // 31 - stm: RESOLVE 1011 nts_14, // 32 - stm: NOP 1012 nts_14, // 33 - r: GUARD_MOVE 1013 nts_14, // 34 - r: GUARD_COMBINE 1014 nts_14, // 35 - stm: IR_PROLOGUE 1015 nts_14, // 36 - r: GET_CAUGHT_EXCEPTION 1016 nts_14, // 37 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 1017 nts_14, // 38 - stm: TRAP 1018 nts_14, // 39 - stm: GOTO 1019 nts_14, // 40 - stm: WRITE_FLOOR 1020 nts_14, // 41 - stm: READ_CEILING 1021 nts_14, // 42 - stm: FENCE 1022 nts_14, // 43 - stm: PAUSE 1023 nts_14, // 44 - stm: RETURN(NULL) 1024 nts_14, // 45 - stm: RETURN(INT_CONSTANT) 1025 nts_14, // 46 - stm: RETURN(LONG_CONSTANT) 1026 nts_14, // 47 - r: GET_TIME_BASE 1027 nts_14, // 48 - r: LONG_MOVE(LONG_CONSTANT) 1028 nts_14, // 49 - stm: CLEAR_FLOATING_POINT_STATE 1029 nts_15, // 50 - any: OTHER_OPERAND(any,any) 1030 nts_16, // 51 - stm: TRAP_IF(r,r) 1031 nts_17, // 52 - stm: TRAP_IF(load32,riv) 1032 nts_18, // 53 - stm: TRAP_IF(riv,load32) 1033 nts_19, // 54 - r: LONG_CMP(rlv,rlv) 1034 nts_20, // 55 - r: CALL(r,any) 1035 nts_20, // 56 - r: SYSCALL(r,any) 1036 nts_15, // 57 - stm: YIELDPOINT_OSR(any,any) 1037 nts_16, // 58 - address: INT_ADD(r,r) 1038 nts_21, // 59 - address: INT_ADD(r,address1scaledreg) 1039 nts_22, // 60 - address: INT_ADD(address1scaledreg,r) 1040 nts_23, // 61 - address: INT_ADD(address1scaledreg,address1reg) 1041 nts_24, // 62 - address: INT_ADD(address1reg,address1scaledreg) 1042 nts_25, // 63 - r: BOOLEAN_CMP_INT(r,riv) 1043 nts_25, // 64 - boolcmp: BOOLEAN_CMP_INT(r,riv) 1044 nts_17, // 65 - r: BOOLEAN_CMP_INT(load32,riv) 1045 nts_17, // 66 - boolcmp: BOOLEAN_CMP_INT(load32,riv) 1046 nts_26, // 67 - r: BOOLEAN_CMP_INT(r,load32) 1047 nts_18, // 68 - boolcmp: BOOLEAN_CMP_INT(riv,load32) 1048 nts_19, // 69 - r: BOOLEAN_CMP_LONG(rlv,rlv) 1049 nts_19, // 70 - boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 1050 nts_25, // 71 - czr: INT_ADD(r,riv) 1051 nts_25, // 72 - r: INT_ADD(r,riv) 1052 nts_26, // 73 - czr: INT_ADD(r,load32) 1053 nts_17, // 74 - czr: INT_ADD(load32,riv) 1054 nts_25, // 75 - szpr: INT_AND(r,riv) 1055 nts_25, // 76 - szp: INT_AND(r,riv) 1056 nts_26, // 77 - szpr: INT_AND(r,load32) 1057 nts_17, // 78 - szpr: INT_AND(load32,riv) 1058 nts_27, // 79 - szp: INT_AND(load8_16_32,riv) 1059 nts_28, // 80 - szp: INT_AND(r,load8_16_32) 1060 nts_29, // 81 - r: INT_DIV(riv,riv) 1061 nts_18, // 82 - r: INT_DIV(riv,load32) 1062 nts_25, // 83 - stm: INT_IFCMP(r,riv) 1063 nts_30, // 84 - stm: INT_IFCMP(uload8,r) 1064 nts_31, // 85 - stm: INT_IFCMP(r,uload8) 1065 nts_17, // 86 - stm: INT_IFCMP(load32,riv) 1066 nts_26, // 87 - stm: INT_IFCMP(r,load32) 1067 nts_25, // 88 - stm: INT_IFCMP2(r,riv) 1068 nts_17, // 89 - stm: INT_IFCMP2(load32,riv) 1069 nts_18, // 90 - stm: INT_IFCMP2(riv,load32) 1070 nts_29, // 91 - r: INT_LOAD(riv,riv) 1071 nts_32, // 92 - r: INT_LOAD(riv,address1scaledreg) 1072 nts_33, // 93 - r: INT_LOAD(address1scaledreg,riv) 1073 nts_23, // 94 - r: INT_LOAD(address1scaledreg,address1reg) 1074 nts_24, // 95 - r: INT_LOAD(address1reg,address1scaledreg) 1075 nts_29, // 96 - r: INT_ALOAD(riv,riv) 1076 nts_25, // 97 - r: INT_MUL(r,riv) 1077 nts_26, // 98 - r: INT_MUL(r,load32) 1078 nts_17, // 99 - r: INT_MUL(load32,riv) 1079 nts_25, // 100 - szpr: INT_OR(r,riv) 1080 nts_26, // 101 - szpr: INT_OR(r,load32) 1081 nts_17, // 102 - szpr: INT_OR(load32,riv) 1082 nts_29, // 103 - r: INT_REM(riv,riv) 1083 nts_18, // 104 - r: INT_REM(riv,load32) 1084 nts_29, // 105 - szpr: INT_SHL(riv,riv) 1085 nts_29, // 106 - szpr: INT_SHR(riv,riv) 1086 nts_34, // 107 - czr: INT_SUB(riv,r) 1087 nts_34, // 108 - r: INT_SUB(riv,r) 1088 nts_35, // 109 - r: INT_SUB(load32,r) 1089 nts_18, // 110 - czr: INT_SUB(riv,load32) 1090 nts_17, // 111 - czr: INT_SUB(load32,riv) 1091 nts_29, // 112 - szpr: INT_USHR(riv,riv) 1092 nts_25, // 113 - szpr: INT_XOR(r,riv) 1093 nts_26, // 114 - szpr: INT_XOR(r,load32) 1094 nts_17, // 115 - szpr: INT_XOR(load32,riv) 1095 nts_22, // 116 - r: INT_ADD(address1scaledreg,r) 1096 nts_21, // 117 - r: INT_ADD(r,address1scaledreg) 1097 nts_23, // 118 - r: INT_ADD(address1scaledreg,address1reg) 1098 nts_24, // 119 - r: INT_ADD(address1reg,address1scaledreg) 1099 nts_29, // 120 - r: BYTE_LOAD(riv,riv) 1100 nts_29, // 121 - sload8: BYTE_LOAD(riv,riv) 1101 nts_29, // 122 - r: BYTE_ALOAD(riv,riv) 1102 nts_29, // 123 - sload8: BYTE_ALOAD(riv,riv) 1103 nts_29, // 124 - r: UBYTE_LOAD(riv,riv) 1104 nts_29, // 125 - uload8: UBYTE_LOAD(riv,riv) 1105 nts_29, // 126 - r: UBYTE_ALOAD(riv,riv) 1106 nts_29, // 127 - uload8: UBYTE_ALOAD(riv,riv) 1107 nts_29, // 128 - r: SHORT_LOAD(riv,riv) 1108 nts_29, // 129 - sload16: SHORT_LOAD(riv,riv) 1109 nts_29, // 130 - r: SHORT_ALOAD(riv,riv) 1110 nts_29, // 131 - sload16: SHORT_ALOAD(riv,riv) 1111 nts_29, // 132 - r: USHORT_LOAD(riv,riv) 1112 nts_29, // 133 - uload16: USHORT_LOAD(riv,riv) 1113 nts_29, // 134 - r: USHORT_ALOAD(riv,riv) 1114 nts_29, // 135 - uload16: USHORT_ALOAD(riv,riv) 1115 nts_29, // 136 - load32: INT_LOAD(riv,riv) 1116 nts_29, // 137 - load32: INT_ALOAD(riv,riv) 1117 nts_29, // 138 - load64: LONG_LOAD(riv,riv) 1118 nts_29, // 139 - load64: LONG_ALOAD(riv,riv) 1119 nts_36, // 140 - r: LONG_ADD(r,rlv) 1120 nts_37, // 141 - r: LONG_ADD(r,load64) 1121 nts_38, // 142 - r: LONG_ADD(load64,rlv) 1122 nts_36, // 143 - r: LONG_AND(r,rlv) 1123 nts_37, // 144 - r: LONG_AND(r,load64) 1124 nts_38, // 145 - r: LONG_AND(load64,rlv) 1125 nts_36, // 146 - stm: LONG_IFCMP(r,rlv) 1126 nts_29, // 147 - r: LONG_LOAD(riv,riv) 1127 nts_29, // 148 - r: LONG_ALOAD(riv,riv) 1128 nts_36, // 149 - r: LONG_MUL(r,rlv) 1129 nts_36, // 150 - r: LONG_OR(r,rlv) 1130 nts_37, // 151 - r: LONG_OR(r,load64) 1131 nts_38, // 152 - r: LONG_OR(load64,rlv) 1132 nts_39, // 153 - r: LONG_SHL(rlv,riv) 1133 nts_39, // 154 - r: LONG_SHR(rlv,riv) 1134 nts_19, // 155 - r: LONG_SUB(rlv,rlv) 1135 nts_40, // 156 - r: LONG_SUB(rlv,load64) 1136 nts_38, // 157 - r: LONG_SUB(load64,rlv) 1137 nts_39, // 158 - r: LONG_USHR(rlv,riv) 1138 nts_36, // 159 - r: LONG_XOR(r,rlv) 1139 nts_37, // 160 - r: LONG_XOR(r,load64) 1140 nts_38, // 161 - r: LONG_XOR(load64,rlv) 1141 nts_16, // 162 - r: FLOAT_ADD(r,r) 1142 nts_41, // 163 - r: FLOAT_ADD(r,float_load) 1143 nts_42, // 164 - r: FLOAT_ADD(float_load,r) 1144 nts_16, // 165 - r: DOUBLE_ADD(r,r) 1145 nts_43, // 166 - r: DOUBLE_ADD(r,double_load) 1146 nts_44, // 167 - r: DOUBLE_ADD(double_load,r) 1147 nts_16, // 168 - r: FLOAT_SUB(r,r) 1148 nts_41, // 169 - r: FLOAT_SUB(r,float_load) 1149 nts_16, // 170 - r: DOUBLE_SUB(r,r) 1150 nts_43, // 171 - r: DOUBLE_SUB(r,double_load) 1151 nts_16, // 172 - r: FLOAT_MUL(r,r) 1152 nts_41, // 173 - r: FLOAT_MUL(r,float_load) 1153 nts_42, // 174 - r: FLOAT_MUL(float_load,r) 1154 nts_16, // 175 - r: DOUBLE_MUL(r,r) 1155 nts_43, // 176 - r: DOUBLE_MUL(r,double_load) 1156 nts_44, // 177 - r: DOUBLE_MUL(double_load,r) 1157 nts_16, // 178 - r: FLOAT_DIV(r,r) 1158 nts_41, // 179 - r: FLOAT_DIV(r,float_load) 1159 nts_16, // 180 - r: DOUBLE_DIV(r,r) 1160 nts_43, // 181 - r: DOUBLE_DIV(r,double_load) 1161 nts_16, // 182 - r: FLOAT_REM(r,r) 1162 nts_16, // 183 - r: DOUBLE_REM(r,r) 1163 nts_29, // 184 - r: DOUBLE_LOAD(riv,riv) 1164 nts_45, // 185 - r: DOUBLE_LOAD(riv,rlv) 1165 nts_19, // 186 - r: DOUBLE_LOAD(rlv,rlv) 1166 nts_29, // 187 - double_load: DOUBLE_LOAD(riv,riv) 1167 nts_29, // 188 - r: DOUBLE_ALOAD(riv,riv) 1168 nts_19, // 189 - double_load: DOUBLE_LOAD(rlv,rlv) 1169 nts_34, // 190 - r: DOUBLE_ALOAD(riv,r) 1170 nts_19, // 191 - r: DOUBLE_ALOAD(rlv,rlv) 1171 nts_29, // 192 - double_load: DOUBLE_ALOAD(riv,riv) 1172 nts_29, // 193 - r: FLOAT_LOAD(riv,riv) 1173 nts_19, // 194 - r: FLOAT_LOAD(rlv,rlv) 1174 nts_29, // 195 - float_load: FLOAT_LOAD(riv,riv) 1175 nts_29, // 196 - r: FLOAT_ALOAD(riv,riv) 1176 nts_34, // 197 - r: FLOAT_ALOAD(riv,r) 1177 nts_19, // 198 - r: FLOAT_ALOAD(rlv,rlv) 1178 nts_29, // 199 - float_load: FLOAT_ALOAD(riv,riv) 1179 nts_16, // 200 - stm: FLOAT_IFCMP(r,r) 1180 nts_41, // 201 - stm: FLOAT_IFCMP(r,float_load) 1181 nts_42, // 202 - stm: FLOAT_IFCMP(float_load,r) 1182 nts_16, // 203 - stm: DOUBLE_IFCMP(r,r) 1183 nts_43, // 204 - stm: DOUBLE_IFCMP(r,double_load) 1184 nts_44, // 205 - stm: DOUBLE_IFCMP(double_load,r) 1185 nts_0, // 206 - stm: LOWTABLESWITCH(r) 1186 nts_3, // 207 - stm: NULL_CHECK(riv) 1187 nts_0, // 208 - stm: SET_CAUGHT_EXCEPTION(r) 1188 nts_0, // 209 - stm: TRAP_IF(r,INT_CONSTANT) 1189 nts_0, // 210 - stm: TRAP_IF(r,LONG_CONSTANT) 1190 nts_46, // 211 - uload8: INT_AND(load8_16_32,INT_CONSTANT) 1191 nts_46, // 212 - r: INT_AND(load8_16_32,INT_CONSTANT) 1192 nts_46, // 213 - r: INT_2BYTE(load8_16_32) 1193 nts_12, // 214 - r: INT_AND(load16_32,INT_CONSTANT) 1194 nts_0, // 215 - stm: PREFETCH(r) 1195 nts_0, // 216 - stm: RETURN(r) 1196 nts_47, // 217 - address: INT_MOVE(address) 1197 nts_4, // 218 - address: INT_ADD(address1scaledreg,INT_CONSTANT) 1198 nts_0, // 219 - address1reg: INT_ADD(r,INT_CONSTANT) 1199 nts_0, // 220 - address1reg: INT_MOVE(r) 1200 nts_5, // 221 - address1reg: INT_MOVE(address1reg) 1201 nts_5, // 222 - address1reg: INT_ADD(address1reg,INT_CONSTANT) 1202 nts_4, // 223 - address1scaledreg: INT_MOVE(address1scaledreg) 1203 nts_0, // 224 - address1scaledreg: INT_SHL(r,INT_CONSTANT) 1204 nts_4, // 225 - address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) 1205 nts_0, // 226 - r: ADDR_2LONG(r) 1206 nts_11, // 227 - r: ADDR_2LONG(load32) 1207 nts_0, // 228 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1208 nts_0, // 229 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1209 nts_0, // 230 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1210 nts_11, // 231 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 1211 nts_0, // 232 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1212 nts_11, // 233 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 1213 nts_48, // 234 - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 1214 nts_48, // 235 - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 1215 nts_49, // 236 - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 1216 nts_49, // 237 - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 1217 nts_50, // 238 - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 1218 nts_50, // 239 - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 1219 nts_51, // 240 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1220 nts_51, // 241 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1221 nts_51, // 242 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1222 nts_51, // 243 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1223 nts_0, // 244 - r: BOOLEAN_NOT(r) 1224 nts_0, // 245 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1225 nts_11, // 246 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1226 nts_0, // 247 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1227 nts_11, // 248 - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 1228 nts_0, // 249 - r: INT_2BYTE(r) 1229 nts_46, // 250 - r: INT_2BYTE(load8_16_32) 1230 nts_0, // 251 - r: INT_2LONG(r) 1231 nts_11, // 252 - r: INT_2LONG(load32) 1232 nts_0, // 253 - r: INT_2SHORT(r) 1233 nts_12, // 254 - r: INT_2SHORT(load16_32) 1234 nts_12, // 255 - sload16: INT_2SHORT(load16_32) 1235 nts_0, // 256 - szpr: INT_2USHORT(r) 1236 nts_12, // 257 - uload16: INT_2USHORT(load16_32) 1237 nts_12, // 258 - r: INT_2USHORT(load16_32) 1238 nts_0, // 259 - stm: INT_IFCMP(r,INT_CONSTANT) 1239 nts_13, // 260 - stm: INT_IFCMP(load8,INT_CONSTANT) 1240 nts_8, // 261 - stm: INT_IFCMP(sload16,INT_CONSTANT) 1241 nts_51, // 262 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1242 nts_51, // 263 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1243 nts_48, // 264 - stm: INT_IFCMP(cz,INT_CONSTANT) 1244 nts_49, // 265 - stm: INT_IFCMP(szp,INT_CONSTANT) 1245 nts_50, // 266 - stm: INT_IFCMP(bittest,INT_CONSTANT) 1246 nts_47, // 267 - r: INT_LOAD(address,INT_CONSTANT) 1247 nts_3, // 268 - r: INT_MOVE(riv) 1248 nts_1, // 269 - czr: INT_MOVE(czr) 1249 nts_48, // 270 - cz: INT_MOVE(cz) 1250 nts_2, // 271 - szpr: INT_MOVE(szpr) 1251 nts_49, // 272 - szp: INT_MOVE(szp) 1252 nts_6, // 273 - sload8: INT_MOVE(sload8) 1253 nts_7, // 274 - uload8: INT_MOVE(uload8) 1254 nts_13, // 275 - load8: INT_MOVE(load8) 1255 nts_8, // 276 - sload16: INT_MOVE(sload16) 1256 nts_9, // 277 - uload16: INT_MOVE(uload16) 1257 nts_10, // 278 - load16: INT_MOVE(load16) 1258 nts_11, // 279 - load32: INT_MOVE(load32) 1259 nts_0, // 280 - szpr: INT_NEG(r) 1260 nts_0, // 281 - r: INT_NOT(r) 1261 nts_0, // 282 - szpr: INT_SHL(r,INT_CONSTANT) 1262 nts_0, // 283 - r: INT_SHL(r,INT_CONSTANT) 1263 nts_3, // 284 - szpr: INT_SHR(riv,INT_CONSTANT) 1264 nts_3, // 285 - szpr: INT_USHR(riv,INT_CONSTANT) 1265 nts_47, // 286 - r: INT_ADD(address,INT_CONSTANT) 1266 nts_47, // 287 - r: INT_MOVE(address) 1267 nts_0, // 288 - r: LONG_2INT(r) 1268 nts_52, // 289 - r: LONG_2INT(load64) 1269 nts_52, // 290 - load32: LONG_2INT(load64) 1270 nts_0, // 291 - r: LONG_MOVE(r) 1271 nts_52, // 292 - load64: LONG_MOVE(load64) 1272 nts_0, // 293 - r: LONG_NEG(r) 1273 nts_0, // 294 - r: LONG_NOT(r) 1274 nts_0, // 295 - r: FLOAT_NEG(r) 1275 nts_0, // 296 - r: DOUBLE_NEG(r) 1276 nts_0, // 297 - r: FLOAT_SQRT(r) 1277 nts_0, // 298 - r: DOUBLE_SQRT(r) 1278 nts_0, // 299 - r: LONG_2FLOAT(r) 1279 nts_0, // 300 - r: LONG_2DOUBLE(r) 1280 nts_0, // 301 - r: FLOAT_MOVE(r) 1281 nts_0, // 302 - r: DOUBLE_MOVE(r) 1282 nts_3, // 303 - r: INT_2FLOAT(riv) 1283 nts_11, // 304 - r: INT_2FLOAT(load32) 1284 nts_3, // 305 - r: INT_2DOUBLE(riv) 1285 nts_11, // 306 - r: INT_2DOUBLE(load32) 1286 nts_0, // 307 - r: FLOAT_2DOUBLE(r) 1287 nts_53, // 308 - r: FLOAT_2DOUBLE(float_load) 1288 nts_0, // 309 - r: DOUBLE_2FLOAT(r) 1289 nts_54, // 310 - r: DOUBLE_2FLOAT(double_load) 1290 nts_0, // 311 - r: FLOAT_2INT(r) 1291 nts_0, // 312 - r: FLOAT_2LONG(r) 1292 nts_0, // 313 - r: DOUBLE_2INT(r) 1293 nts_0, // 314 - r: DOUBLE_2LONG(r) 1294 nts_0, // 315 - r: FLOAT_AS_INT_BITS(r) 1295 nts_53, // 316 - load32: FLOAT_AS_INT_BITS(float_load) 1296 nts_0, // 317 - r: DOUBLE_AS_LONG_BITS(r) 1297 nts_54, // 318 - load64: DOUBLE_AS_LONG_BITS(double_load) 1298 nts_3, // 319 - r: INT_BITS_AS_FLOAT(riv) 1299 nts_11, // 320 - float_load: INT_BITS_AS_FLOAT(load32) 1300 nts_55, // 321 - r: LONG_BITS_AS_DOUBLE(rlv) 1301 nts_52, // 322 - double_load: LONG_BITS_AS_DOUBLE(load64) 1302 nts_56, // 323 - r: MATERIALIZE_FP_CONSTANT(any) 1303 nts_56, // 324 - float_load: MATERIALIZE_FP_CONSTANT(any) 1304 nts_56, // 325 - double_load: MATERIALIZE_FP_CONSTANT(any) 1305 nts_46, // 326 - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 1306 nts_12, // 327 - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 1307 nts_0, // 328 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 1308 nts_0, // 329 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 1309 nts_0, // 330 - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 1310 nts_11, // 331 - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 1311 nts_0, // 332 - r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) 1312 nts_52, // 333 - r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) 1313 nts_0, // 334 - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 1314 nts_0, // 335 - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 1315 nts_0, // 336 - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 1316 nts_52, // 337 - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 1317 nts_52, // 338 - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 1318 nts_52, // 339 - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 1319 nts_52, // 340 - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 1320 nts_55, // 341 - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) 1321 nts_57, // 342 - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 1322 nts_58, // 343 - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 1323 nts_59, // 344 - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 1324 nts_60, // 345 - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 1325 nts_57, // 346 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 1326 nts_58, // 347 - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 1327 nts_61, // 348 - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 1328 nts_57, // 349 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 1329 nts_61, // 350 - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 1330 nts_60, // 351 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 1331 nts_62, // 352 - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 1332 nts_63, // 353 - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 1333 nts_64, // 354 - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 1334 nts_65, // 355 - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1335 nts_66, // 356 - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 1336 nts_67, // 357 - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 1337 nts_67, // 358 - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 1338 nts_57, // 359 - stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) 1339 nts_68, // 360 - stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) 1340 nts_57, // 361 - stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) 1341 nts_68, // 362 - stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) 1342 nts_69, // 363 - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 1343 nts_70, // 364 - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 1344 nts_71, // 365 - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 1345 nts_72, // 366 - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 1346 nts_73, // 367 - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 1347 nts_57, // 368 - stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) 1348 nts_74, // 369 - stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) 1349 nts_75, // 370 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) 1350 nts_76, // 371 - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 1351 nts_77, // 372 - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 1352 nts_78, // 373 - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 1353 nts_64, // 374 - stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) 1354 nts_64, // 375 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 1355 nts_79, // 376 - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 1356 nts_80, // 377 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 1357 nts_65, // 378 - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 1358 nts_64, // 379 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 1359 nts_80, // 380 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 1360 nts_79, // 381 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 1361 nts_65, // 382 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1362 nts_66, // 383 - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 1363 nts_64, // 384 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 1364 nts_65, // 385 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 1365 nts_80, // 386 - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 1366 nts_79, // 387 - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 1367 nts_64, // 388 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 1368 nts_80, // 389 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 1369 nts_79, // 390 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 1370 nts_65, // 391 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 1371 nts_66, // 392 - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 1372 nts_81, // 393 - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 1373 nts_82, // 394 - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 1374 nts_83, // 395 - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 1375 nts_84, // 396 - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 1376 nts_85, // 397 - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 1377 nts_81, // 398 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 1378 nts_82, // 399 - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 1379 nts_83, // 400 - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 1380 nts_86, // 401 - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 1381 nts_87, // 402 - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 1382 nts_86, // 403 - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 1383 nts_87, // 404 - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 1384 nts_29, // 405 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 1385 nts_39, // 406 - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 1386 nts_29, // 407 - stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 1387 nts_56, // 408 - r: CALL(BRANCH_TARGET,any) 1388 nts_56, // 409 - r: CALL(INT_CONSTANT,any) 1389 nts_56, // 410 - r: SYSCALL(INT_CONSTANT,any) 1390 nts_88, // 411 - r: CALL(INT_LOAD(riv,riv),any) 1391 nts_89, // 412 - r: CALL(LONG_LOAD(rlv,rlv),any) 1392 nts_88, // 413 - r: SYSCALL(INT_LOAD(riv,riv),any) 1393 nts_90, // 414 - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 1394 nts_91, // 415 - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 1395 nts_92, // 416 - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 1396 nts_93, // 417 - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 1397 nts_94, // 418 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 1398 nts_95, // 419 - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 1399 nts_96, // 420 - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 1400 nts_97, // 421 - r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) 1401 nts_98, // 422 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 1402 nts_99, // 423 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 1403 nts_100, // 424 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 1404 nts_101, // 425 - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 1405 nts_102, // 426 - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 1406 nts_102, // 427 - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 1407 nts_90, // 428 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1408 nts_93, // 429 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1409 nts_94, // 430 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1410 nts_95, // 431 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1411 nts_96, // 432 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1412 nts_90, // 433 - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1413 nts_93, // 434 - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1414 nts_94, // 435 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1415 nts_95, // 436 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1416 nts_96, // 437 - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1417 nts_102, // 438 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1418 nts_102, // 439 - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1419 nts_102, // 440 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1420 nts_102, // 441 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 1421 nts_16, // 442 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1422 nts_35, // 443 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1423 nts_16, // 444 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1424 nts_35, // 445 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 1425 nts_34, // 446 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 1426 nts_26, // 447 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 1427 nts_16, // 448 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 1428 nts_35, // 449 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 1429 nts_90, // 450 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1430 nts_90, // 451 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1431 nts_90, // 452 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1432 nts_90, // 453 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1433 nts_90, // 454 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1434 nts_90, // 455 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1435 nts_90, // 456 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1436 nts_90, // 457 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1437 nts_90, // 458 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1438 nts_90, // 459 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1439 nts_90, // 460 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1440 nts_90, // 461 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 1441 nts_90, // 462 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1442 nts_90, // 463 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1443 nts_90, // 464 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1444 nts_90, // 465 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1445 nts_20, // 466 - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 1446 nts_103, // 467 - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 1447 nts_104, // 468 - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 1448 nts_105, // 469 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 1449 nts_105, // 470 - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 1450 nts_106, // 471 - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 1451 nts_107, // 472 - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 1452 nts_108, // 473 - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 1453 nts_64, // 474 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 1454 nts_64, // 475 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 1455 nts_64, // 476 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 1456 nts_64, // 477 - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 1457 nts_64, // 478 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 1458 nts_64, // 479 - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 1459 nts_64, // 480 - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 1460 nts_64, // 481 - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 1461 nts_109, // 482 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1462 nts_109, // 483 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1463 nts_109, // 484 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1464 nts_109, // 485 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1465 nts_109, // 486 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1466 nts_109, // 487 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1467 nts_109, // 488 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1468 nts_109, // 489 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1469 nts_109, // 490 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1470 nts_109, // 491 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 1471 nts_110, // 492 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1472 nts_110, // 493 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1473 nts_110, // 494 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1474 nts_110, // 495 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1475 nts_110, // 496 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1476 nts_110, // 497 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1477 nts_110, // 498 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1478 nts_110, // 499 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1479 nts_110, // 500 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1480 nts_110, // 501 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 1481 nts_109, // 502 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1482 nts_109, // 503 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1483 nts_111, // 504 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1484 nts_111, // 505 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1485 nts_111, // 506 - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1486 nts_111, // 507 - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1487 nts_109, // 508 - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1488 nts_109, // 509 - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1489 nts_111, // 510 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1490 nts_111, // 511 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 1491 nts_112, // 512 - stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1492 nts_112, // 513 - stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1493 nts_112, // 514 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1494 nts_112, // 515 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1495 nts_112, // 516 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1496 nts_112, // 517 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1497 nts_112, // 518 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1498 nts_112, // 519 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 1499 nts_16, // 520 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 1500 nts_16, // 521 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 1501 nts_16, // 522 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 1502 nts_16, // 523 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 1503 nts_19, // 524 - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) 1504 nts_29, // 525 - r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) 1505 nts_113, // 526 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 1506 nts_113, // 527 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 1507 nts_113, // 528 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 1508 nts_113, // 529 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 1509 nts_34, // 530 - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 1510 nts_34, // 531 - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 1511 nts_114, // 532 - stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) 1512 nts_34, // 533 - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 1513 nts_39, // 534 - r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) 1514 nts_39, // 535 - r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) 1515 nts_39, // 536 - r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) 1516 nts_115, // 537 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1517 nts_115, // 538 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1518 nts_115, // 539 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1519 nts_115, // 540 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1520 nts_115, // 541 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1521 nts_115, // 542 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 1522 nts_66, // 543 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 1523 nts_66, // 544 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 1524 nts_66, // 545 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1525 nts_66, // 546 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1526 nts_66, // 547 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 1527 nts_66, // 548 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 1528 nts_66, // 549 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 1529 nts_66, // 550 - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 1530 nts_66, // 551 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 1531 nts_66, // 552 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 1532 nts_66, // 553 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 1533 nts_66, // 554 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 1534 nts_66, // 555 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 1535 nts_66, // 556 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 1536 nts_66, // 557 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1537 nts_66, // 558 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 1538 }; 1539 1540 /* private static final byte arity[] = { 1541 0, // 0 - GET_CAUGHT_EXCEPTION 1542 1, // 1 - SET_CAUGHT_EXCEPTION 1543 -1, // 2 - NEW 1544 -1, // 3 - NEW_UNRESOLVED 1545 -1, // 4 - NEWARRAY 1546 -1, // 5 - NEWARRAY_UNRESOLVED 1547 -1, // 6 - ATHROW 1548 -1, // 7 - CHECKCAST 1549 -1, // 8 - CHECKCAST_NOTNULL 1550 -1, // 9 - CHECKCAST_UNRESOLVED 1551 -1, // 10 - MUST_IMPLEMENT_INTERFACE 1552 -1, // 11 - INSTANCEOF 1553 -1, // 12 - INSTANCEOF_NOTNULL 1554 -1, // 13 - INSTANCEOF_UNRESOLVED 1555 -1, // 14 - MONITORENTER 1556 -1, // 15 - MONITOREXIT 1557 -1, // 16 - NEWOBJMULTIARRAY 1558 -1, // 17 - GETSTATIC 1559 -1, // 18 - PUTSTATIC 1560 -1, // 19 - GETFIELD 1561 -1, // 20 - PUTFIELD 1562 -1, // 21 - INT_ZERO_CHECK 1563 -1, // 22 - LONG_ZERO_CHECK 1564 -1, // 23 - BOUNDS_CHECK 1565 -1, // 24 - OBJARRAY_STORE_CHECK 1566 -1, // 25 - OBJARRAY_STORE_CHECK_NOTNULL 1567 0, // 26 - IG_PATCH_POINT 1568 -1, // 27 - IG_CLASS_TEST 1569 -1, // 28 - IG_METHOD_TEST 1570 -1, // 29 - TABLESWITCH 1571 -1, // 30 - LOOKUPSWITCH 1572 2, // 31 - INT_ALOAD 1573 2, // 32 - LONG_ALOAD 1574 2, // 33 - FLOAT_ALOAD 1575 2, // 34 - DOUBLE_ALOAD 1576 -1, // 35 - REF_ALOAD 1577 2, // 36 - UBYTE_ALOAD 1578 2, // 37 - BYTE_ALOAD 1579 2, // 38 - USHORT_ALOAD 1580 2, // 39 - SHORT_ALOAD 1581 2, // 40 - INT_ASTORE 1582 2, // 41 - LONG_ASTORE 1583 2, // 42 - FLOAT_ASTORE 1584 2, // 43 - DOUBLE_ASTORE 1585 -1, // 44 - REF_ASTORE 1586 2, // 45 - BYTE_ASTORE 1587 2, // 46 - SHORT_ASTORE 1588 2, // 47 - INT_IFCMP 1589 2, // 48 - INT_IFCMP2 1590 2, // 49 - LONG_IFCMP 1591 2, // 50 - FLOAT_IFCMP 1592 2, // 51 - DOUBLE_IFCMP 1593 -1, // 52 - REF_IFCMP 1594 -1, // 53 - LABEL 1595 -1, // 54 - BBEND 1596 0, // 55 - UNINT_BEGIN 1597 0, // 56 - UNINT_END 1598 0, // 57 - FENCE 1599 0, // 58 - READ_CEILING 1600 0, // 59 - WRITE_FLOOR 1601 -1, // 60 - PHI 1602 -1, // 61 - SPLIT 1603 -1, // 62 - PI 1604 0, // 63 - NOP 1605 1, // 64 - INT_MOVE 1606 1, // 65 - LONG_MOVE 1607 1, // 66 - FLOAT_MOVE 1608 1, // 67 - DOUBLE_MOVE 1609 -1, // 68 - REF_MOVE 1610 0, // 69 - GUARD_MOVE 1611 -1, // 70 - INT_COND_MOVE 1612 -1, // 71 - LONG_COND_MOVE 1613 -1, // 72 - FLOAT_COND_MOVE 1614 -1, // 73 - DOUBLE_COND_MOVE 1615 -1, // 74 - REF_COND_MOVE 1616 -1, // 75 - GUARD_COND_MOVE 1617 0, // 76 - GUARD_COMBINE 1618 -1, // 77 - REF_ADD 1619 2, // 78 - INT_ADD 1620 2, // 79 - LONG_ADD 1621 2, // 80 - FLOAT_ADD 1622 2, // 81 - DOUBLE_ADD 1623 -1, // 82 - REF_SUB 1624 2, // 83 - INT_SUB 1625 2, // 84 - LONG_SUB 1626 2, // 85 - FLOAT_SUB 1627 2, // 86 - DOUBLE_SUB 1628 2, // 87 - INT_MUL 1629 2, // 88 - LONG_MUL 1630 2, // 89 - FLOAT_MUL 1631 2, // 90 - DOUBLE_MUL 1632 2, // 91 - INT_DIV 1633 -1, // 92 - LONG_DIV 1634 2, // 93 - FLOAT_DIV 1635 2, // 94 - DOUBLE_DIV 1636 2, // 95 - INT_REM 1637 -1, // 96 - LONG_REM 1638 2, // 97 - FLOAT_REM 1639 2, // 98 - DOUBLE_REM 1640 -1, // 99 - REF_NEG 1641 1, // 100 - INT_NEG 1642 1, // 101 - LONG_NEG 1643 1, // 102 - FLOAT_NEG 1644 1, // 103 - DOUBLE_NEG 1645 1, // 104 - FLOAT_SQRT 1646 1, // 105 - DOUBLE_SQRT 1647 -1, // 106 - REF_SHL 1648 2, // 107 - INT_SHL 1649 2, // 108 - LONG_SHL 1650 -1, // 109 - REF_SHR 1651 2, // 110 - INT_SHR 1652 2, // 111 - LONG_SHR 1653 -1, // 112 - REF_USHR 1654 2, // 113 - INT_USHR 1655 2, // 114 - LONG_USHR 1656 -1, // 115 - REF_AND 1657 2, // 116 - INT_AND 1658 2, // 117 - LONG_AND 1659 -1, // 118 - REF_OR 1660 2, // 119 - INT_OR 1661 2, // 120 - LONG_OR 1662 -1, // 121 - REF_XOR 1663 2, // 122 - INT_XOR 1664 -1, // 123 - REF_NOT 1665 1, // 124 - INT_NOT 1666 1, // 125 - LONG_NOT 1667 2, // 126 - LONG_XOR 1668 -1, // 127 - INT_2ADDRSigExt 1669 -1, // 128 - INT_2ADDRZerExt 1670 -1, // 129 - LONG_2ADDR 1671 -1, // 130 - ADDR_2INT 1672 1, // 131 - ADDR_2LONG 1673 1, // 132 - INT_2LONG 1674 1, // 133 - INT_2FLOAT 1675 1, // 134 - INT_2DOUBLE 1676 1, // 135 - LONG_2INT 1677 1, // 136 - LONG_2FLOAT 1678 1, // 137 - LONG_2DOUBLE 1679 1, // 138 - FLOAT_2INT 1680 1, // 139 - FLOAT_2LONG 1681 1, // 140 - FLOAT_2DOUBLE 1682 1, // 141 - DOUBLE_2INT 1683 1, // 142 - DOUBLE_2LONG 1684 1, // 143 - DOUBLE_2FLOAT 1685 1, // 144 - INT_2BYTE 1686 1, // 145 - INT_2USHORT 1687 1, // 146 - INT_2SHORT 1688 2, // 147 - LONG_CMP 1689 -1, // 148 - FLOAT_CMPL 1690 -1, // 149 - FLOAT_CMPG 1691 -1, // 150 - DOUBLE_CMPL 1692 -1, // 151 - DOUBLE_CMPG 1693 1, // 152 - RETURN 1694 1, // 153 - NULL_CHECK 1695 0, // 154 - GOTO 1696 1, // 155 - BOOLEAN_NOT 1697 2, // 156 - BOOLEAN_CMP_INT 1698 -1, // 157 - BOOLEAN_CMP_ADDR 1699 2, // 158 - BOOLEAN_CMP_LONG 1700 -1, // 159 - BOOLEAN_CMP_FLOAT 1701 -1, // 160 - BOOLEAN_CMP_DOUBLE 1702 2, // 161 - BYTE_LOAD 1703 2, // 162 - UBYTE_LOAD 1704 2, // 163 - SHORT_LOAD 1705 2, // 164 - USHORT_LOAD 1706 -1, // 165 - REF_LOAD 1707 -1, // 166 - REF_STORE 1708 2, // 167 - INT_LOAD 1709 2, // 168 - LONG_LOAD 1710 2, // 169 - FLOAT_LOAD 1711 2, // 170 - DOUBLE_LOAD 1712 2, // 171 - BYTE_STORE 1713 2, // 172 - SHORT_STORE 1714 2, // 173 - INT_STORE 1715 2, // 174 - LONG_STORE 1716 2, // 175 - FLOAT_STORE 1717 2, // 176 - DOUBLE_STORE 1718 -1, // 177 - PREPARE_INT 1719 -1, // 178 - PREPARE_ADDR 1720 -1, // 179 - PREPARE_LONG 1721 2, // 180 - ATTEMPT_INT 1722 -1, // 181 - ATTEMPT_ADDR 1723 2, // 182 - ATTEMPT_LONG 1724 2, // 183 - CALL 1725 2, // 184 - SYSCALL 1726 0, // 185 - YIELDPOINT_PROLOGUE 1727 0, // 186 - YIELDPOINT_EPILOGUE 1728 0, // 187 - YIELDPOINT_BACKEDGE 1729 2, // 188 - YIELDPOINT_OSR 1730 -1, // 189 - OSR_BARRIER 1731 0, // 190 - IR_PROLOGUE 1732 0, // 191 - RESOLVE 1733 -1, // 192 - RESOLVE_MEMBER 1734 0, // 193 - GET_TIME_BASE 1735 -1, // 194 - INSTRUMENTED_EVENT_COUNTER 1736 2, // 195 - TRAP_IF 1737 0, // 196 - TRAP 1738 1, // 197 - FLOAT_AS_INT_BITS 1739 1, // 198 - INT_BITS_AS_FLOAT 1740 1, // 199 - DOUBLE_AS_LONG_BITS 1741 1, // 200 - LONG_BITS_AS_DOUBLE 1742 -1, // 201 - ARRAYLENGTH 1743 -1, // 202 - GET_OBJ_TIB 1744 -1, // 203 - GET_CLASS_TIB 1745 -1, // 204 - GET_TYPE_FROM_TIB 1746 -1, // 205 - GET_SUPERCLASS_IDS_FROM_TIB 1747 -1, // 206 - GET_DOES_IMPLEMENT_FROM_TIB 1748 -1, // 207 - GET_ARRAY_ELEMENT_TIB_FROM_TIB 1749 1, // 208 - LOWTABLESWITCH 1750 0, // 209 - ADDRESS_CONSTANT 1751 0, // 210 - INT_CONSTANT 1752 0, // 211 - LONG_CONSTANT 1753 0, // 212 - REGISTER 1754 2, // 213 - OTHER_OPERAND 1755 0, // 214 - NULL 1756 0, // 215 - BRANCH_TARGET 1757 1, // 216 - MATERIALIZE_FP_CONSTANT 1758 -1, // 217 - ROUND_TO_ZERO 1759 0, // 218 - CLEAR_FLOATING_POINT_STATE 1760 1, // 219 - PREFETCH 1761 0, // 220 - PAUSE 1762 -1, // 221 - FP_ADD 1763 -1, // 222 - FP_SUB 1764 -1, // 223 - FP_MUL 1765 -1, // 224 - FP_DIV 1766 -1, // 225 - FP_NEG 1767 -1, // 226 - FP_REM 1768 -1, // 227 - INT_2FP 1769 -1, // 228 - LONG_2FP 1770 2, // 229 - CMP_CMOV 1771 2, // 230 - FCMP_CMOV 1772 2, // 231 - LCMP_CMOV 1773 -1, // 232 - CMP_FCMOV 1774 2, // 233 - FCMP_FCMOV 1775 -1, // 234 - CALL_SAVE_VOLATILE 1776 -1, // 235 - MIR_START 1777 -1, // 236 - REQUIRE_ESP 1778 -1, // 237 - ADVISE_ESP 1779 -1, // 238 - MIR_LOWTABLESWITCH 1780 -1, // 239 - IA32_METHODSTART 1781 -1, // 240 - IA32_FCLEAR 1782 -1, // 241 - DUMMY_DEF 1783 -1, // 242 - DUMMY_USE 1784 -1, // 243 - IMMQ_MOV 1785 -1, // 244 - IA32_FMOV_ENDING_LIVE_RANGE 1786 -1, // 245 - IA32_FMOV 1787 -1, // 246 - IA32_TRAPIF 1788 -1, // 247 - IA32_OFFSET 1789 -1, // 248 - IA32_LOCK_CMPXCHG 1790 -1, // 249 - IA32_LOCK_CMPXCHG8B 1791 -1, // 250 - IA32_ADC 1792 -1, // 251 - IA32_ADD 1793 -1, // 252 - IA32_AND 1794 -1, // 253 - IA32_BSWAP 1795 -1, // 254 - IA32_BT 1796 -1, // 255 - IA32_BTC 1797 -1, // 256 - IA32_BTR 1798 -1, // 257 - IA32_BTS 1799 -1, // 258 - IA32_SYSCALL 1800 -1, // 259 - IA32_CALL 1801 -1, // 260 - IA32_CDQ 1802 -1, // 261 - IA32_CDO 1803 -1, // 262 - IA32_CDQE 1804 -1, // 263 - IA32_CMOV 1805 -1, // 264 - IA32_CMP 1806 -1, // 265 - IA32_CMPXCHG 1807 -1, // 266 - IA32_CMPXCHG8B 1808 -1, // 267 - IA32_DEC 1809 -1, // 268 - IA32_DIV 1810 -1, // 269 - IA32_FADD 1811 -1, // 270 - IA32_FADDP 1812 -1, // 271 - IA32_FCHS 1813 -1, // 272 - IA32_FCMOV 1814 -1, // 273 - IA32_FCOMI 1815 -1, // 274 - IA32_FCOMIP 1816 -1, // 275 - IA32_FDIV 1817 -1, // 276 - IA32_FDIVP 1818 -1, // 277 - IA32_FDIVR 1819 -1, // 278 - IA32_FDIVRP 1820 -1, // 279 - IA32_FEXAM 1821 -1, // 280 - IA32_FXCH 1822 -1, // 281 - IA32_FFREE 1823 -1, // 282 - IA32_FFREEP 1824 -1, // 283 - IA32_FIADD 1825 -1, // 284 - IA32_FIDIV 1826 -1, // 285 - IA32_FIDIVR 1827 -1, // 286 - IA32_FILD 1828 -1, // 287 - IA32_FIMUL 1829 -1, // 288 - IA32_FINIT 1830 -1, // 289 - IA32_FIST 1831 -1, // 290 - IA32_FISTP 1832 -1, // 291 - IA32_FISUB 1833 -1, // 292 - IA32_FISUBR 1834 -1, // 293 - IA32_FLD 1835 -1, // 294 - IA32_FLDCW 1836 -1, // 295 - IA32_FLD1 1837 -1, // 296 - IA32_FLDL2T 1838 -1, // 297 - IA32_FLDL2E 1839 -1, // 298 - IA32_FLDPI 1840 -1, // 299 - IA32_FLDLG2 1841 -1, // 300 - IA32_FLDLN2 1842 -1, // 301 - IA32_FLDZ 1843 -1, // 302 - IA32_FMUL 1844 -1, // 303 - IA32_FMULP 1845 -1, // 304 - IA32_FNSTCW 1846 -1, // 305 - IA32_FNSTSW 1847 -1, // 306 - IA32_FNINIT 1848 -1, // 307 - IA32_FNSAVE 1849 -1, // 308 - IA32_FPREM 1850 -1, // 309 - IA32_FRSTOR 1851 -1, // 310 - IA32_FST 1852 -1, // 311 - IA32_FSTCW 1853 -1, // 312 - IA32_FSTSW 1854 -1, // 313 - IA32_FSTP 1855 -1, // 314 - IA32_FSUB 1856 -1, // 315 - IA32_FSUBP 1857 -1, // 316 - IA32_FSUBR 1858 -1, // 317 - IA32_FSUBRP 1859 -1, // 318 - IA32_FUCOMI 1860 -1, // 319 - IA32_FUCOMIP 1861 -1, // 320 - IA32_IDIV 1862 -1, // 321 - IA32_IMUL1 1863 -1, // 322 - IA32_IMUL2 1864 -1, // 323 - IA32_INC 1865 -1, // 324 - IA32_INT 1866 -1, // 325 - IA32_JCC 1867 -1, // 326 - IA32_JCC2 1868 -1, // 327 - IA32_JMP 1869 -1, // 328 - IA32_LEA 1870 -1, // 329 - IA32_LOCK 1871 -1, // 330 - IA32_MOV 1872 -1, // 331 - IA32_MOVZX__B 1873 -1, // 332 - IA32_MOVSX__B 1874 -1, // 333 - IA32_MOVZX__W 1875 -1, // 334 - IA32_MOVSX__W 1876 -1, // 335 - IA32_MOVZXQ__B 1877 -1, // 336 - IA32_MOVSXQ__B 1878 -1, // 337 - IA32_MOVZXQ__W 1879 -1, // 338 - IA32_MOVSXQ__W 1880 -1, // 339 - IA32_MOVSXDQ 1881 -1, // 340 - IA32_MUL 1882 -1, // 341 - IA32_NEG 1883 -1, // 342 - IA32_NOT 1884 -1, // 343 - IA32_OR 1885 -1, // 344 - IA32_MFENCE 1886 -1, // 345 - IA32_PAUSE 1887 -1, // 346 - IA32_PREFETCHNTA 1888 -1, // 347 - IA32_POP 1889 -1, // 348 - IA32_PUSH 1890 -1, // 349 - IA32_RCL 1891 -1, // 350 - IA32_RCR 1892 -1, // 351 - IA32_ROL 1893 -1, // 352 - IA32_ROR 1894 -1, // 353 - IA32_RET 1895 -1, // 354 - IA32_SAL 1896 -1, // 355 - IA32_SAR 1897 -1, // 356 - IA32_SHL 1898 -1, // 357 - IA32_SHR 1899 -1, // 358 - IA32_SBB 1900 -1, // 359 - IA32_SET__B 1901 -1, // 360 - IA32_SHLD 1902 -1, // 361 - IA32_SHRD 1903 -1, // 362 - IA32_SUB 1904 -1, // 363 - IA32_TEST 1905 -1, // 364 - IA32_XOR 1906 -1, // 365 - IA32_RDTSC 1907 -1, // 366 - IA32_ADDSS 1908 -1, // 367 - IA32_SUBSS 1909 -1, // 368 - IA32_MULSS 1910 -1, // 369 - IA32_DIVSS 1911 -1, // 370 - IA32_ADDSD 1912 -1, // 371 - IA32_SUBSD 1913 -1, // 372 - IA32_MULSD 1914 -1, // 373 - IA32_DIVSD 1915 -1, // 374 - IA32_ANDPS 1916 -1, // 375 - IA32_ANDPD 1917 -1, // 376 - IA32_ANDNPS 1918 -1, // 377 - IA32_ANDNPD 1919 -1, // 378 - IA32_ORPS 1920 -1, // 379 - IA32_ORPD 1921 -1, // 380 - IA32_XORPS 1922 -1, // 381 - IA32_XORPD 1923 -1, // 382 - IA32_UCOMISS 1924 -1, // 383 - IA32_UCOMISD 1925 -1, // 384 - IA32_CMPEQSS 1926 -1, // 385 - IA32_CMPLTSS 1927 -1, // 386 - IA32_CMPLESS 1928 -1, // 387 - IA32_CMPUNORDSS 1929 -1, // 388 - IA32_CMPNESS 1930 -1, // 389 - IA32_CMPNLTSS 1931 -1, // 390 - IA32_CMPNLESS 1932 -1, // 391 - IA32_CMPORDSS 1933 -1, // 392 - IA32_CMPEQSD 1934 -1, // 393 - IA32_CMPLTSD 1935 -1, // 394 - IA32_CMPLESD 1936 -1, // 395 - IA32_CMPUNORDSD 1937 -1, // 396 - IA32_CMPNESD 1938 -1, // 397 - IA32_CMPNLTSD 1939 -1, // 398 - IA32_CMPNLESD 1940 -1, // 399 - IA32_CMPORDSD 1941 -1, // 400 - IA32_MOVAPD 1942 -1, // 401 - IA32_MOVAPS 1943 -1, // 402 - IA32_MOVLPD 1944 -1, // 403 - IA32_MOVLPS 1945 -1, // 404 - IA32_MOVSS 1946 -1, // 405 - IA32_MOVSD 1947 -1, // 406 - IA32_MOVD 1948 -1, // 407 - IA32_MOVQ 1949 -1, // 408 - IA32_PSLLQ 1950 -1, // 409 - IA32_PSRLQ 1951 -1, // 410 - IA32_SQRTSS 1952 -1, // 411 - IA32_SQRTSD 1953 -1, // 412 - IA32_CVTSI2SS 1954 -1, // 413 - IA32_CVTSS2SD 1955 -1, // 414 - IA32_CVTSS2SI 1956 -1, // 415 - IA32_CVTTSS2SI 1957 -1, // 416 - IA32_CVTSI2SD 1958 -1, // 417 - IA32_CVTSD2SS 1959 -1, // 418 - IA32_CVTSD2SI 1960 -1, // 419 - IA32_CVTTSD2SI 1961 -1, // 420 - IA32_CVTSI2SDQ 1962 -1, // 421 - IA32_CVTSD2SIQ 1963 -1, // 422 - IA32_CVTTSD2SIQ 1964 -1, // 423 - MIR_END 1965 };*/ 1966 1967 /** 1968 * Decoding table. Translate the target non-terminal and minimal cost covering state encoding 1969 * non-terminal into the rule that produces the non-terminal. 1970 * The first index is the non-terminal that we wish to produce. 1971 * The second index is the state non-terminal associated with covering a tree 1972 * with minimal cost and is computed by jburg based on the non-terminal to be produced. 1973 * The value in the array is the rule number 1974 */ 1975 private static final char[][] decode = { 1976 null, // [0][0] 1977 { // stm_NT 1978 0, // [1][0] 1979 1, // [1][1] - stm: r 1980 25, // [1][2] - stm: IG_PATCH_POINT 1981 26, // [1][3] - stm: UNINT_BEGIN 1982 27, // [1][4] - stm: UNINT_END 1983 28, // [1][5] - stm: YIELDPOINT_PROLOGUE 1984 29, // [1][6] - stm: YIELDPOINT_EPILOGUE 1985 30, // [1][7] - stm: YIELDPOINT_BACKEDGE 1986 206, // [1][8] - stm: LOWTABLESWITCH(r) 1987 31, // [1][9] - stm: RESOLVE 1988 32, // [1][10] - stm: NOP 1989 207, // [1][11] - stm: NULL_CHECK(riv) 1990 35, // [1][12] - stm: IR_PROLOGUE 1991 208, // [1][13] - stm: SET_CAUGHT_EXCEPTION(r) 1992 37, // [1][14] - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 1993 38, // [1][15] - stm: TRAP 1994 209, // [1][16] - stm: TRAP_IF(r,INT_CONSTANT) 1995 210, // [1][17] - stm: TRAP_IF(r,LONG_CONSTANT) 1996 51, // [1][18] - stm: TRAP_IF(r,r) 1997 52, // [1][19] - stm: TRAP_IF(load32,riv) 1998 53, // [1][20] - stm: TRAP_IF(riv,load32) 1999 342, // [1][21] - stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 2000 343, // [1][22] - stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 2001 344, // [1][23] - stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 2002 345, // [1][24] - stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 2003 346, // [1][25] - stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 2004 347, // [1][26] - stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 2005 348, // [1][27] - stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 2006 349, // [1][28] - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 2007 350, // [1][29] - stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 2008 351, // [1][30] - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 2009 352, // [1][31] - stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 2010 353, // [1][32] - stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 2011 354, // [1][33] - stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 2012 355, // [1][34] - stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2013 356, // [1][35] - stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 2014 405, // [1][36] - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 2015 406, // [1][37] - stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 2016 39, // [1][38] - stm: GOTO 2017 215, // [1][39] - stm: PREFETCH(r) 2018 40, // [1][40] - stm: WRITE_FLOOR 2019 41, // [1][41] - stm: READ_CEILING 2020 42, // [1][42] - stm: FENCE 2021 43, // [1][43] - stm: PAUSE 2022 44, // [1][44] - stm: RETURN(NULL) 2023 45, // [1][45] - stm: RETURN(INT_CONSTANT) 2024 216, // [1][46] - stm: RETURN(r) 2025 46, // [1][47] - stm: RETURN(LONG_CONSTANT) 2026 57, // [1][48] - stm: YIELDPOINT_OSR(any,any) 2027 428, // [1][49] - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2028 429, // [1][50] - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2029 430, // [1][51] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2030 431, // [1][52] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2031 432, // [1][53] - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2032 438, // [1][54] - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2033 440, // [1][55] - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2034 433, // [1][56] - stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2035 434, // [1][57] - stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2036 435, // [1][58] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2037 436, // [1][59] - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2038 437, // [1][60] - stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2039 439, // [1][61] - stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2040 441, // [1][62] - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 2041 357, // [1][63] - stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 2042 358, // [1][64] - stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 2043 450, // [1][65] - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2044 451, // [1][66] - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2045 359, // [1][67] - stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) 2046 360, // [1][68] - stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) 2047 361, // [1][69] - stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) 2048 362, // [1][70] - stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) 2049 474, // [1][71] - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 2050 475, // [1][72] - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 2051 476, // [1][73] - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 2052 477, // [1][74] - stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 2053 478, // [1][75] - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 2054 479, // [1][76] - stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 2055 482, // [1][77] - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2056 502, // [1][78] - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2057 483, // [1][79] - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2058 503, // [1][80] - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2059 484, // [1][81] - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2060 504, // [1][82] - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2061 485, // [1][83] - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2062 505, // [1][84] - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2063 83, // [1][85] - stm: INT_IFCMP(r,riv) 2064 259, // [1][86] - stm: INT_IFCMP(r,INT_CONSTANT) 2065 260, // [1][87] - stm: INT_IFCMP(load8,INT_CONSTANT) 2066 84, // [1][88] - stm: INT_IFCMP(uload8,r) 2067 85, // [1][89] - stm: INT_IFCMP(r,uload8) 2068 261, // [1][90] - stm: INT_IFCMP(sload16,INT_CONSTANT) 2069 86, // [1][91] - stm: INT_IFCMP(load32,riv) 2070 87, // [1][92] - stm: INT_IFCMP(r,load32) 2071 262, // [1][93] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2072 263, // [1][94] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2073 264, // [1][95] - stm: INT_IFCMP(cz,INT_CONSTANT) 2074 265, // [1][96] - stm: INT_IFCMP(szp,INT_CONSTANT) 2075 266, // [1][97] - stm: INT_IFCMP(bittest,INT_CONSTANT) 2076 88, // [1][98] - stm: INT_IFCMP2(r,riv) 2077 89, // [1][99] - stm: INT_IFCMP2(load32,riv) 2078 90, // [1][100] - stm: INT_IFCMP2(riv,load32) 2079 452, // [1][101] - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2080 453, // [1][102] - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2081 454, // [1][103] - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2082 455, // [1][104] - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2083 486, // [1][105] - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2084 506, // [1][106] - stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2085 487, // [1][107] - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2086 507, // [1][108] - stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2087 537, // [1][109] - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2088 456, // [1][110] - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2089 538, // [1][111] - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2090 457, // [1][112] - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2091 539, // [1][113] - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2092 458, // [1][114] - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2093 540, // [1][115] - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2094 459, // [1][116] - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2095 368, // [1][117] - stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) 2096 369, // [1][118] - stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) 2097 370, // [1][119] - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) 2098 371, // [1][120] - stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 2099 372, // [1][121] - stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 2100 532, // [1][122] - stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) 2101 488, // [1][123] - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2102 508, // [1][124] - stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2103 489, // [1][125] - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2104 509, // [1][126] - stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2105 541, // [1][127] - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2106 460, // [1][128] - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2107 542, // [1][129] - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 2108 461, // [1][130] - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 2109 490, // [1][131] - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2110 510, // [1][132] - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2111 491, // [1][133] - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 2112 511, // [1][134] - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2113 480, // [1][135] - stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 2114 481, // [1][136] - stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 2115 492, // [1][137] - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2116 512, // [1][138] - stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2117 493, // [1][139] - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2118 513, // [1][140] - stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2119 494, // [1][141] - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2120 514, // [1][142] - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2121 495, // [1][143] - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2122 515, // [1][144] - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2123 146, // [1][145] - stm: LONG_IFCMP(r,rlv) 2124 462, // [1][146] - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2125 463, // [1][147] - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2126 464, // [1][148] - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2127 465, // [1][149] - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 2128 496, // [1][150] - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2129 516, // [1][151] - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2130 497, // [1][152] - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2131 517, // [1][153] - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2132 374, // [1][154] - stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) 2133 407, // [1][155] - stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 2134 498, // [1][156] - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2135 499, // [1][157] - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2136 500, // [1][158] - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2137 518, // [1][159] - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2138 501, // [1][160] - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 2139 519, // [1][161] - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 2140 375, // [1][162] - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 2141 376, // [1][163] - stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 2142 377, // [1][164] - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 2143 378, // [1][165] - stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 2144 379, // [1][166] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 2145 380, // [1][167] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 2146 381, // [1][168] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 2147 382, // [1][169] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2148 383, // [1][170] - stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 2149 384, // [1][171] - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 2150 385, // [1][172] - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 2151 386, // [1][173] - stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 2152 387, // [1][174] - stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 2153 388, // [1][175] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 2154 389, // [1][176] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 2155 390, // [1][177] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 2156 391, // [1][178] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 2157 392, // [1][179] - stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 2158 49, // [1][180] - stm: CLEAR_FLOATING_POINT_STATE 2159 200, // [1][181] - stm: FLOAT_IFCMP(r,r) 2160 201, // [1][182] - stm: FLOAT_IFCMP(r,float_load) 2161 202, // [1][183] - stm: FLOAT_IFCMP(float_load,r) 2162 203, // [1][184] - stm: DOUBLE_IFCMP(r,r) 2163 204, // [1][185] - stm: DOUBLE_IFCMP(r,double_load) 2164 205, // [1][186] - stm: DOUBLE_IFCMP(double_load,r) 2165 401, // [1][187] - stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 2166 402, // [1][188] - stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 2167 403, // [1][189] - stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 2168 404, // [1][190] - stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 2169 }, 2170 { // r_NT 2171 0, // [2][0] 2172 19, // [2][1] - r: REGISTER 2173 2, // [2][2] - r: czr 2174 4, // [2][3] - r: szpr 2175 33, // [2][4] - r: GUARD_MOVE 2176 34, // [2][5] - r: GUARD_COMBINE 2177 36, // [2][6] - r: GET_CAUGHT_EXCEPTION 2178 212, // [2][7] - r: INT_AND(load8_16_32,INT_CONSTANT) 2179 213, // [2][8] - r: INT_2BYTE(load8_16_32) 2180 326, // [2][9] - r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 2181 214, // [2][10] - r: INT_AND(load16_32,INT_CONSTANT) 2182 327, // [2][11] - r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 2183 54, // [2][12] - r: LONG_CMP(rlv,rlv) 2184 55, // [2][13] - r: CALL(r,any) 2185 408, // [2][14] - r: CALL(BRANCH_TARGET,any) 2186 411, // [2][15] - r: CALL(INT_LOAD(riv,riv),any) 2187 409, // [2][16] - r: CALL(INT_CONSTANT,any) 2188 412, // [2][17] - r: CALL(LONG_LOAD(rlv,rlv),any) 2189 56, // [2][18] - r: SYSCALL(r,any) 2190 413, // [2][19] - r: SYSCALL(INT_LOAD(riv,riv),any) 2191 410, // [2][20] - r: SYSCALL(INT_CONSTANT,any) 2192 47, // [2][21] - r: GET_TIME_BASE 2193 226, // [2][22] - r: ADDR_2LONG(r) 2194 227, // [2][23] - r: ADDR_2LONG(load32) 2195 414, // [2][24] - r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 2196 415, // [2][25] - r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 2197 416, // [2][26] - r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 2198 417, // [2][27] - r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 2199 418, // [2][28] - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 2200 419, // [2][29] - r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 2201 420, // [2][30] - r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 2202 426, // [2][31] - r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 2203 427, // [2][32] - r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 2204 421, // [2][33] - r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) 2205 63, // [2][34] - r: BOOLEAN_CMP_INT(r,riv) 2206 228, // [2][35] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2207 230, // [2][36] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2208 231, // [2][37] - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 2209 232, // [2][38] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2210 233, // [2][39] - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 2211 234, // [2][40] - r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 2212 236, // [2][41] - r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 2213 238, // [2][42] - r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 2214 240, // [2][43] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2215 242, // [2][44] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2216 65, // [2][45] - r: BOOLEAN_CMP_INT(load32,riv) 2217 67, // [2][46] - r: BOOLEAN_CMP_INT(r,load32) 2218 69, // [2][47] - r: BOOLEAN_CMP_LONG(rlv,rlv) 2219 244, // [2][48] - r: BOOLEAN_NOT(r) 2220 363, // [2][49] - r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 2221 466, // [2][50] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 2222 245, // [2][51] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2223 246, // [2][52] - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2224 247, // [2][53] - r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2225 248, // [2][54] - r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 2226 467, // [2][55] - r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 2227 364, // [2][56] - r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 2228 365, // [2][57] - r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 2229 468, // [2][58] - r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 2230 366, // [2][59] - r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 2231 367, // [2][60] - r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 2232 469, // [2][61] - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 2233 470, // [2][62] - r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 2234 471, // [2][63] - r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 2235 472, // [2][64] - r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 2236 473, // [2][65] - r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 2237 249, // [2][66] - r: INT_2BYTE(r) 2238 250, // [2][67] - r: INT_2BYTE(load8_16_32) 2239 251, // [2][68] - r: INT_2LONG(r) 2240 252, // [2][69] - r: INT_2LONG(load32) 2241 330, // [2][70] - r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 2242 331, // [2][71] - r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 2243 332, // [2][72] - r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) 2244 333, // [2][73] - r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) 2245 253, // [2][74] - r: INT_2SHORT(r) 2246 254, // [2][75] - r: INT_2SHORT(load16_32) 2247 258, // [2][76] - r: INT_2USHORT(load16_32) 2248 72, // [2][77] - r: INT_ADD(r,riv) 2249 81, // [2][78] - r: INT_DIV(riv,riv) 2250 82, // [2][79] - r: INT_DIV(riv,load32) 2251 91, // [2][80] - r: INT_LOAD(riv,riv) 2252 92, // [2][81] - r: INT_LOAD(riv,address1scaledreg) 2253 93, // [2][82] - r: INT_LOAD(address1scaledreg,riv) 2254 94, // [2][83] - r: INT_LOAD(address1scaledreg,address1reg) 2255 95, // [2][84] - r: INT_LOAD(address1reg,address1scaledreg) 2256 267, // [2][85] - r: INT_LOAD(address,INT_CONSTANT) 2257 96, // [2][86] - r: INT_ALOAD(riv,riv) 2258 268, // [2][87] - r: INT_MOVE(riv) 2259 97, // [2][88] - r: INT_MUL(r,riv) 2260 98, // [2][89] - r: INT_MUL(r,load32) 2261 99, // [2][90] - r: INT_MUL(load32,riv) 2262 281, // [2][91] - r: INT_NOT(r) 2263 103, // [2][92] - r: INT_REM(riv,riv) 2264 104, // [2][93] - r: INT_REM(riv,load32) 2265 520, // [2][94] - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 2266 521, // [2][95] - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 2267 522, // [2][96] - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 2268 523, // [2][97] - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 2269 526, // [2][98] - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 2270 528, // [2][99] - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 2271 529, // [2][100] - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 2272 527, // [2][101] - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 2273 283, // [2][102] - r: INT_SHL(r,INT_CONSTANT) 2274 108, // [2][103] - r: INT_SUB(riv,r) 2275 109, // [2][104] - r: INT_SUB(load32,r) 2276 373, // [2][105] - r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 2277 116, // [2][106] - r: INT_ADD(address1scaledreg,r) 2278 117, // [2][107] - r: INT_ADD(r,address1scaledreg) 2279 118, // [2][108] - r: INT_ADD(address1scaledreg,address1reg) 2280 119, // [2][109] - r: INT_ADD(address1reg,address1scaledreg) 2281 286, // [2][110] - r: INT_ADD(address,INT_CONSTANT) 2282 287, // [2][111] - r: INT_MOVE(address) 2283 120, // [2][112] - r: BYTE_LOAD(riv,riv) 2284 122, // [2][113] - r: BYTE_ALOAD(riv,riv) 2285 124, // [2][114] - r: UBYTE_LOAD(riv,riv) 2286 126, // [2][115] - r: UBYTE_ALOAD(riv,riv) 2287 128, // [2][116] - r: SHORT_LOAD(riv,riv) 2288 130, // [2][117] - r: SHORT_ALOAD(riv,riv) 2289 132, // [2][118] - r: USHORT_LOAD(riv,riv) 2290 134, // [2][119] - r: USHORT_ALOAD(riv,riv) 2291 288, // [2][120] - r: LONG_2INT(r) 2292 289, // [2][121] - r: LONG_2INT(load64) 2293 335, // [2][122] - r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 2294 336, // [2][123] - r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 2295 337, // [2][124] - r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 2296 338, // [2][125] - r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 2297 140, // [2][126] - r: LONG_ADD(r,rlv) 2298 141, // [2][127] - r: LONG_ADD(r,load64) 2299 142, // [2][128] - r: LONG_ADD(load64,rlv) 2300 143, // [2][129] - r: LONG_AND(r,rlv) 2301 144, // [2][130] - r: LONG_AND(r,load64) 2302 145, // [2][131] - r: LONG_AND(load64,rlv) 2303 147, // [2][132] - r: LONG_LOAD(riv,riv) 2304 148, // [2][133] - r: LONG_ALOAD(riv,riv) 2305 291, // [2][134] - r: LONG_MOVE(r) 2306 48, // [2][135] - r: LONG_MOVE(LONG_CONSTANT) 2307 149, // [2][136] - r: LONG_MUL(r,rlv) 2308 524, // [2][137] - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) 2309 341, // [2][138] - r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) 2310 525, // [2][139] - r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) 2311 293, // [2][140] - r: LONG_NEG(r) 2312 294, // [2][141] - r: LONG_NOT(r) 2313 150, // [2][142] - r: LONG_OR(r,rlv) 2314 151, // [2][143] - r: LONG_OR(r,load64) 2315 152, // [2][144] - r: LONG_OR(load64,rlv) 2316 153, // [2][145] - r: LONG_SHL(rlv,riv) 2317 534, // [2][146] - r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) 2318 154, // [2][147] - r: LONG_SHR(rlv,riv) 2319 535, // [2][148] - r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) 2320 155, // [2][149] - r: LONG_SUB(rlv,rlv) 2321 156, // [2][150] - r: LONG_SUB(rlv,load64) 2322 157, // [2][151] - r: LONG_SUB(load64,rlv) 2323 158, // [2][152] - r: LONG_USHR(rlv,riv) 2324 536, // [2][153] - r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) 2325 159, // [2][154] - r: LONG_XOR(r,rlv) 2326 160, // [2][155] - r: LONG_XOR(r,load64) 2327 161, // [2][156] - r: LONG_XOR(load64,rlv) 2328 162, // [2][157] - r: FLOAT_ADD(r,r) 2329 163, // [2][158] - r: FLOAT_ADD(r,float_load) 2330 164, // [2][159] - r: FLOAT_ADD(float_load,r) 2331 165, // [2][160] - r: DOUBLE_ADD(r,r) 2332 166, // [2][161] - r: DOUBLE_ADD(r,double_load) 2333 167, // [2][162] - r: DOUBLE_ADD(double_load,r) 2334 168, // [2][163] - r: FLOAT_SUB(r,r) 2335 169, // [2][164] - r: FLOAT_SUB(r,float_load) 2336 170, // [2][165] - r: DOUBLE_SUB(r,r) 2337 171, // [2][166] - r: DOUBLE_SUB(r,double_load) 2338 172, // [2][167] - r: FLOAT_MUL(r,r) 2339 173, // [2][168] - r: FLOAT_MUL(r,float_load) 2340 174, // [2][169] - r: FLOAT_MUL(float_load,r) 2341 175, // [2][170] - r: DOUBLE_MUL(r,r) 2342 176, // [2][171] - r: DOUBLE_MUL(r,double_load) 2343 177, // [2][172] - r: DOUBLE_MUL(double_load,r) 2344 178, // [2][173] - r: FLOAT_DIV(r,r) 2345 179, // [2][174] - r: FLOAT_DIV(r,float_load) 2346 180, // [2][175] - r: DOUBLE_DIV(r,r) 2347 181, // [2][176] - r: DOUBLE_DIV(r,double_load) 2348 295, // [2][177] - r: FLOAT_NEG(r) 2349 296, // [2][178] - r: DOUBLE_NEG(r) 2350 297, // [2][179] - r: FLOAT_SQRT(r) 2351 298, // [2][180] - r: DOUBLE_SQRT(r) 2352 182, // [2][181] - r: FLOAT_REM(r,r) 2353 183, // [2][182] - r: DOUBLE_REM(r,r) 2354 299, // [2][183] - r: LONG_2FLOAT(r) 2355 300, // [2][184] - r: LONG_2DOUBLE(r) 2356 301, // [2][185] - r: FLOAT_MOVE(r) 2357 302, // [2][186] - r: DOUBLE_MOVE(r) 2358 184, // [2][187] - r: DOUBLE_LOAD(riv,riv) 2359 185, // [2][188] - r: DOUBLE_LOAD(riv,rlv) 2360 186, // [2][189] - r: DOUBLE_LOAD(rlv,rlv) 2361 188, // [2][190] - r: DOUBLE_ALOAD(riv,riv) 2362 190, // [2][191] - r: DOUBLE_ALOAD(riv,r) 2363 191, // [2][192] - r: DOUBLE_ALOAD(rlv,rlv) 2364 193, // [2][193] - r: FLOAT_LOAD(riv,riv) 2365 194, // [2][194] - r: FLOAT_LOAD(rlv,rlv) 2366 196, // [2][195] - r: FLOAT_ALOAD(riv,riv) 2367 197, // [2][196] - r: FLOAT_ALOAD(riv,r) 2368 198, // [2][197] - r: FLOAT_ALOAD(rlv,rlv) 2369 303, // [2][198] - r: INT_2FLOAT(riv) 2370 304, // [2][199] - r: INT_2FLOAT(load32) 2371 305, // [2][200] - r: INT_2DOUBLE(riv) 2372 306, // [2][201] - r: INT_2DOUBLE(load32) 2373 307, // [2][202] - r: FLOAT_2DOUBLE(r) 2374 308, // [2][203] - r: FLOAT_2DOUBLE(float_load) 2375 309, // [2][204] - r: DOUBLE_2FLOAT(r) 2376 310, // [2][205] - r: DOUBLE_2FLOAT(double_load) 2377 311, // [2][206] - r: FLOAT_2INT(r) 2378 312, // [2][207] - r: FLOAT_2LONG(r) 2379 313, // [2][208] - r: DOUBLE_2INT(r) 2380 314, // [2][209] - r: DOUBLE_2LONG(r) 2381 315, // [2][210] - r: FLOAT_AS_INT_BITS(r) 2382 317, // [2][211] - r: DOUBLE_AS_LONG_BITS(r) 2383 319, // [2][212] - r: INT_BITS_AS_FLOAT(riv) 2384 321, // [2][213] - r: LONG_BITS_AS_DOUBLE(rlv) 2385 323, // [2][214] - r: MATERIALIZE_FP_CONSTANT(any) 2386 393, // [2][215] - r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 2387 394, // [2][216] - r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 2388 395, // [2][217] - r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 2389 396, // [2][218] - r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 2390 397, // [2][219] - r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 2391 398, // [2][220] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 2392 422, // [2][221] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 2393 423, // [2][222] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 2394 424, // [2][223] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 2395 425, // [2][224] - r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 2396 399, // [2][225] - r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 2397 400, // [2][226] - r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 2398 543, // [2][227] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 2399 544, // [2][228] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 2400 547, // [2][229] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 2401 548, // [2][230] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 2402 551, // [2][231] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 2403 552, // [2][232] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 2404 555, // [2][233] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 2405 556, // [2][234] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 2406 545, // [2][235] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2407 546, // [2][236] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2408 549, // [2][237] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 2409 550, // [2][238] - r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 2410 553, // [2][239] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 2411 554, // [2][240] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 2412 557, // [2][241] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2413 558, // [2][242] - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 2414 }, 2415 { // czr_NT 2416 0, // [3][0] 2417 71, // [3][1] - czr: INT_ADD(r,riv) 2418 73, // [3][2] - czr: INT_ADD(r,load32) 2419 74, // [3][3] - czr: INT_ADD(load32,riv) 2420 269, // [3][4] - czr: INT_MOVE(czr) 2421 107, // [3][5] - czr: INT_SUB(riv,r) 2422 110, // [3][6] - czr: INT_SUB(riv,load32) 2423 111, // [3][7] - czr: INT_SUB(load32,riv) 2424 }, 2425 { // cz_NT 2426 0, // [4][0] 2427 3, // [4][1] - cz: czr 2428 270, // [4][2] - cz: INT_MOVE(cz) 2429 }, 2430 { // szpr_NT 2431 0, // [5][0] 2432 256, // [5][1] - szpr: INT_2USHORT(r) 2433 75, // [5][2] - szpr: INT_AND(r,riv) 2434 77, // [5][3] - szpr: INT_AND(r,load32) 2435 78, // [5][4] - szpr: INT_AND(load32,riv) 2436 271, // [5][5] - szpr: INT_MOVE(szpr) 2437 280, // [5][6] - szpr: INT_NEG(r) 2438 100, // [5][7] - szpr: INT_OR(r,riv) 2439 101, // [5][8] - szpr: INT_OR(r,load32) 2440 102, // [5][9] - szpr: INT_OR(load32,riv) 2441 530, // [5][10] - szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 2442 105, // [5][11] - szpr: INT_SHL(riv,riv) 2443 282, // [5][12] - szpr: INT_SHL(r,INT_CONSTANT) 2444 334, // [5][13] - szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 2445 531, // [5][14] - szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 2446 106, // [5][15] - szpr: INT_SHR(riv,riv) 2447 284, // [5][16] - szpr: INT_SHR(riv,INT_CONSTANT) 2448 533, // [5][17] - szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 2449 112, // [5][18] - szpr: INT_USHR(riv,riv) 2450 285, // [5][19] - szpr: INT_USHR(riv,INT_CONSTANT) 2451 113, // [5][20] - szpr: INT_XOR(r,riv) 2452 114, // [5][21] - szpr: INT_XOR(r,load32) 2453 115, // [5][22] - szpr: INT_XOR(load32,riv) 2454 }, 2455 { // szp_NT 2456 0, // [6][0] 2457 5, // [6][1] - szp: szpr 2458 76, // [6][2] - szp: INT_AND(r,riv) 2459 79, // [6][3] - szp: INT_AND(load8_16_32,riv) 2460 80, // [6][4] - szp: INT_AND(r,load8_16_32) 2461 272, // [6][5] - szp: INT_MOVE(szp) 2462 }, 2463 { // riv_NT 2464 0, // [7][0] 2465 6, // [7][1] - riv: r 2466 20, // [7][2] - riv: INT_CONSTANT 2467 }, 2468 { // rlv_NT 2469 0, // [8][0] 2470 7, // [8][1] - rlv: r 2471 21, // [8][2] - rlv: LONG_CONSTANT 2472 }, 2473 { // any_NT 2474 0, // [9][0] 2475 22, // [9][1] - any: NULL 2476 8, // [9][2] - any: riv 2477 23, // [9][3] - any: ADDRESS_CONSTANT 2478 24, // [9][4] - any: LONG_CONSTANT 2479 50, // [9][5] - any: OTHER_OPERAND(any,any) 2480 }, 2481 { // load32_NT 2482 0, // [10][0] 2483 279, // [10][1] - load32: INT_MOVE(load32) 2484 136, // [10][2] - load32: INT_LOAD(riv,riv) 2485 137, // [10][3] - load32: INT_ALOAD(riv,riv) 2486 290, // [10][4] - load32: LONG_2INT(load64) 2487 339, // [10][5] - load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 2488 340, // [10][6] - load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 2489 316, // [10][7] - load32: FLOAT_AS_INT_BITS(float_load) 2490 }, 2491 { // uload8_NT 2492 0, // [11][0] 2493 211, // [11][1] - uload8: INT_AND(load8_16_32,INT_CONSTANT) 2494 274, // [11][2] - uload8: INT_MOVE(uload8) 2495 125, // [11][3] - uload8: UBYTE_LOAD(riv,riv) 2496 127, // [11][4] - uload8: UBYTE_ALOAD(riv,riv) 2497 }, 2498 { // load8_16_32_NT 2499 0, // [12][0] 2500 17, // [12][1] - load8_16_32: load16_32 2501 18, // [12][2] - load8_16_32: load8 2502 }, 2503 { // load16_32_NT 2504 0, // [13][0] 2505 15, // [13][1] - load16_32: load16 2506 16, // [13][2] - load16_32: load32 2507 }, 2508 { // load16_NT 2509 0, // [14][0] 2510 278, // [14][1] - load16: INT_MOVE(load16) 2511 13, // [14][2] - load16: sload16 2512 14, // [14][3] - load16: uload16 2513 }, 2514 { // address_NT 2515 0, // [15][0] 2516 9, // [15][1] - address: address1scaledreg 2517 217, // [15][2] - address: INT_MOVE(address) 2518 58, // [15][3] - address: INT_ADD(r,r) 2519 59, // [15][4] - address: INT_ADD(r,address1scaledreg) 2520 60, // [15][5] - address: INT_ADD(address1scaledreg,r) 2521 218, // [15][6] - address: INT_ADD(address1scaledreg,INT_CONSTANT) 2522 61, // [15][7] - address: INT_ADD(address1scaledreg,address1reg) 2523 62, // [15][8] - address: INT_ADD(address1reg,address1scaledreg) 2524 }, 2525 { // address1scaledreg_NT 2526 0, // [16][0] 2527 10, // [16][1] - address1scaledreg: address1reg 2528 223, // [16][2] - address1scaledreg: INT_MOVE(address1scaledreg) 2529 224, // [16][3] - address1scaledreg: INT_SHL(r,INT_CONSTANT) 2530 225, // [16][4] - address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) 2531 }, 2532 { // address1reg_NT 2533 0, // [17][0] 2534 219, // [17][1] - address1reg: INT_ADD(r,INT_CONSTANT) 2535 220, // [17][2] - address1reg: INT_MOVE(r) 2536 221, // [17][3] - address1reg: INT_MOVE(address1reg) 2537 222, // [17][4] - address1reg: INT_ADD(address1reg,INT_CONSTANT) 2538 }, 2539 { // bittest_NT 2540 0, // [18][0] 2541 442, // [18][1] - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2542 443, // [18][2] - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2543 328, // [18][3] - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 2544 444, // [18][4] - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2545 445, // [18][5] - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 2546 329, // [18][6] - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 2547 446, // [18][7] - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 2548 447, // [18][8] - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 2549 448, // [18][9] - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 2550 449, // [18][10] - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 2551 }, 2552 { // boolcmp_NT 2553 0, // [19][0] 2554 64, // [19][1] - boolcmp: BOOLEAN_CMP_INT(r,riv) 2555 229, // [19][2] - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 2556 235, // [19][3] - boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 2557 237, // [19][4] - boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 2558 239, // [19][5] - boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 2559 241, // [19][6] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2560 243, // [19][7] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 2561 66, // [19][8] - boolcmp: BOOLEAN_CMP_INT(load32,riv) 2562 68, // [19][9] - boolcmp: BOOLEAN_CMP_INT(riv,load32) 2563 70, // [19][10] - boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 2564 }, 2565 { // load8_NT 2566 0, // [20][0] 2567 275, // [20][1] - load8: INT_MOVE(load8) 2568 11, // [20][2] - load8: sload8 2569 12, // [20][3] - load8: uload8 2570 }, 2571 { // sload16_NT 2572 0, // [21][0] 2573 255, // [21][1] - sload16: INT_2SHORT(load16_32) 2574 276, // [21][2] - sload16: INT_MOVE(sload16) 2575 129, // [21][3] - sload16: SHORT_LOAD(riv,riv) 2576 131, // [21][4] - sload16: SHORT_ALOAD(riv,riv) 2577 }, 2578 { // load64_NT 2579 0, // [22][0] 2580 138, // [22][1] - load64: LONG_LOAD(riv,riv) 2581 139, // [22][2] - load64: LONG_ALOAD(riv,riv) 2582 292, // [22][3] - load64: LONG_MOVE(load64) 2583 318, // [22][4] - load64: DOUBLE_AS_LONG_BITS(double_load) 2584 }, 2585 { // uload16_NT 2586 0, // [23][0] 2587 257, // [23][1] - uload16: INT_2USHORT(load16_32) 2588 277, // [23][2] - uload16: INT_MOVE(uload16) 2589 133, // [23][3] - uload16: USHORT_LOAD(riv,riv) 2590 135, // [23][4] - uload16: USHORT_ALOAD(riv,riv) 2591 }, 2592 { // sload8_NT 2593 0, // [24][0] 2594 273, // [24][1] - sload8: INT_MOVE(sload8) 2595 121, // [24][2] - sload8: BYTE_LOAD(riv,riv) 2596 123, // [24][3] - sload8: BYTE_ALOAD(riv,riv) 2597 }, 2598 { // float_load_NT 2599 0, // [25][0] 2600 195, // [25][1] - float_load: FLOAT_LOAD(riv,riv) 2601 199, // [25][2] - float_load: FLOAT_ALOAD(riv,riv) 2602 320, // [25][3] - float_load: INT_BITS_AS_FLOAT(load32) 2603 324, // [25][4] - float_load: MATERIALIZE_FP_CONSTANT(any) 2604 }, 2605 { // double_load_NT 2606 0, // [26][0] 2607 187, // [26][1] - double_load: DOUBLE_LOAD(riv,riv) 2608 189, // [26][2] - double_load: DOUBLE_LOAD(rlv,rlv) 2609 192, // [26][3] - double_load: DOUBLE_ALOAD(riv,riv) 2610 322, // [26][4] - double_load: LONG_BITS_AS_DOUBLE(load64) 2611 325, // [26][5] - double_load: MATERIALIZE_FP_CONSTANT(any) 2612 }, 2613 }; 2614 2615 /** 2616 * Create closure for r 2617 * @param p the node 2618 * @param c the cost 2619 */ 2620 @Inline 2621 private static void closure_r(AbstractBURS_TreeNode p, int c) { 2622 if(BURS.DEBUG) trace(p, 7, c + 0, p.getCost(8) /* rlv */); 2623 if (c < p.getCost(8) /* rlv */) { 2624 p.setCost(8 /* rlv */, (char)(c)); 2625 p.writePacked(1, 0xFFFFFFFC, 0x1); // p.rlv = 1 2626 } 2627 if(BURS.DEBUG) trace(p, 6, c + 0, p.getCost(7) /* riv */); 2628 if (c < p.getCost(7) /* riv */) { 2629 p.setCost(7 /* riv */, (char)(c)); 2630 p.writePacked(0, 0x9FFFFFFF, 0x20000000); // p.riv = 1 2631 closure_riv(p, c); 2632 } 2633 if(BURS.DEBUG) trace(p, 1, c + 0, p.getCost(1) /* stm */); 2634 if (c < p.getCost(1) /* stm */) { 2635 p.setCost(1 /* stm */, (char)(c)); 2636 p.writePacked(0, 0xFFFFFF00, 0x1); // p.stm = 1 2637 } 2638 } 2639 2640 /** 2641 * Create closure for czr 2642 * @param p the node 2643 * @param c the cost 2644 */ 2645 @Inline 2646 private static void closure_czr(AbstractBURS_TreeNode p, int c) { 2647 if(BURS.DEBUG) trace(p, 3, c + 0, p.getCost(4) /* cz */); 2648 if (c < p.getCost(4) /* cz */) { 2649 p.setCost(4 /* cz */, (char)(c)); 2650 p.writePacked(0, 0xFFE7FFFF, 0x80000); // p.cz = 1 2651 } 2652 if(BURS.DEBUG) trace(p, 2, c + 0, p.getCost(2) /* r */); 2653 if (c < p.getCost(2) /* r */) { 2654 p.setCost(2 /* r */, (char)(c)); 2655 p.writePacked(0, 0xFFFF00FF, 0x200); // p.r = 2 2656 closure_r(p, c); 2657 } 2658 } 2659 2660 /** 2661 * Create closure for szpr 2662 * @param p the node 2663 * @param c the cost 2664 */ 2665 @Inline 2666 private static void closure_szpr(AbstractBURS_TreeNode p, int c) { 2667 if(BURS.DEBUG) trace(p, 5, c + 0, p.getCost(6) /* szp */); 2668 if (c < p.getCost(6) /* szp */) { 2669 p.setCost(6 /* szp */, (char)(c)); 2670 p.writePacked(0, 0xE3FFFFFF, 0x4000000); // p.szp = 1 2671 } 2672 if(BURS.DEBUG) trace(p, 4, c + 0, p.getCost(2) /* r */); 2673 if (c < p.getCost(2) /* r */) { 2674 p.setCost(2 /* r */, (char)(c)); 2675 p.writePacked(0, 0xFFFF00FF, 0x300); // p.r = 3 2676 closure_r(p, c); 2677 } 2678 } 2679 2680 /** 2681 * Create closure for riv 2682 * @param p the node 2683 * @param c the cost 2684 */ 2685 @Inline 2686 private static void closure_riv(AbstractBURS_TreeNode p, int c) { 2687 if(BURS.DEBUG) trace(p, 8, c + 0, p.getCost(9) /* any */); 2688 if (c < p.getCost(9) /* any */) { 2689 p.setCost(9 /* any */, (char)(c)); 2690 p.writePacked(1, 0xFFFFFFE3, 0x8); // p.any = 2 2691 } 2692 } 2693 2694 /** 2695 * Create closure for load32 2696 * @param p the node 2697 * @param c the cost 2698 */ 2699 @Inline 2700 private static void closure_load32(AbstractBURS_TreeNode p, int c) { 2701 if(BURS.DEBUG) trace(p, 16, c + 0, p.getCost(13) /* load16_32 */); 2702 if (c < p.getCost(13) /* load16_32 */) { 2703 p.setCost(13 /* load16_32 */, (char)(c)); 2704 p.writePacked(1, 0xFFFF9FFF, 0x4000); // p.load16_32 = 2 2705 closure_load16_32(p, c); 2706 } 2707 } 2708 2709 /** 2710 * Create closure for uload8 2711 * @param p the node 2712 * @param c the cost 2713 */ 2714 @Inline 2715 private static void closure_uload8(AbstractBURS_TreeNode p, int c) { 2716 if(BURS.DEBUG) trace(p, 12, c + 0, p.getCost(20) /* load8 */); 2717 if (c < p.getCost(20) /* load8 */) { 2718 p.setCost(20 /* load8 */, (char)(c)); 2719 p.writePacked(2, 0xFFFFFFCF, 0x30); // p.load8 = 3 2720 closure_load8(p, c); 2721 } 2722 } 2723 2724 /** 2725 * Create closure for load16_32 2726 * @param p the node 2727 * @param c the cost 2728 */ 2729 @Inline 2730 private static void closure_load16_32(AbstractBURS_TreeNode p, int c) { 2731 if(BURS.DEBUG) trace(p, 17, c + 0, p.getCost(12) /* load8_16_32 */); 2732 if (c < p.getCost(12) /* load8_16_32 */) { 2733 p.setCost(12 /* load8_16_32 */, (char)(c)); 2734 p.writePacked(1, 0xFFFFE7FF, 0x800); // p.load8_16_32 = 1 2735 } 2736 } 2737 2738 /** 2739 * Create closure for load16 2740 * @param p the node 2741 * @param c the cost 2742 */ 2743 @Inline 2744 private static void closure_load16(AbstractBURS_TreeNode p, int c) { 2745 if(BURS.DEBUG) trace(p, 15, c + 0, p.getCost(13) /* load16_32 */); 2746 if (c < p.getCost(13) /* load16_32 */) { 2747 p.setCost(13 /* load16_32 */, (char)(c)); 2748 p.writePacked(1, 0xFFFF9FFF, 0x2000); // p.load16_32 = 1 2749 closure_load16_32(p, c); 2750 } 2751 } 2752 2753 /** 2754 * Create closure for address1scaledreg 2755 * @param p the node 2756 * @param c the cost 2757 */ 2758 @Inline 2759 private static void closure_address1scaledreg(AbstractBURS_TreeNode p, int c) { 2760 if(BURS.DEBUG) trace(p, 9, c + 0, p.getCost(15) /* address */); 2761 if (c < p.getCost(15) /* address */) { 2762 p.setCost(15 /* address */, (char)(c)); 2763 p.writePacked(1, 0xFFE1FFFF, 0x20000); // p.address = 1 2764 } 2765 } 2766 2767 /** 2768 * Create closure for address1reg 2769 * @param p the node 2770 * @param c the cost 2771 */ 2772 @Inline 2773 private static void closure_address1reg(AbstractBURS_TreeNode p, int c) { 2774 if(BURS.DEBUG) trace(p, 10, c + 0, p.getCost(16) /* address1scaledreg */); 2775 if (c < p.getCost(16) /* address1scaledreg */) { 2776 p.setCost(16 /* address1scaledreg */, (char)(c)); 2777 p.writePacked(1, 0xFF1FFFFF, 0x200000); // p.address1scaledreg = 1 2778 closure_address1scaledreg(p, c); 2779 } 2780 } 2781 2782 /** 2783 * Create closure for load8 2784 * @param p the node 2785 * @param c the cost 2786 */ 2787 @Inline 2788 private static void closure_load8(AbstractBURS_TreeNode p, int c) { 2789 if(BURS.DEBUG) trace(p, 18, c + 0, p.getCost(12) /* load8_16_32 */); 2790 if (c < p.getCost(12) /* load8_16_32 */) { 2791 p.setCost(12 /* load8_16_32 */, (char)(c)); 2792 p.writePacked(1, 0xFFFFE7FF, 0x1000); // p.load8_16_32 = 2 2793 } 2794 } 2795 2796 /** 2797 * Create closure for sload16 2798 * @param p the node 2799 * @param c the cost 2800 */ 2801 @Inline 2802 private static void closure_sload16(AbstractBURS_TreeNode p, int c) { 2803 if(BURS.DEBUG) trace(p, 13, c + 0, p.getCost(14) /* load16 */); 2804 if (c < p.getCost(14) /* load16 */) { 2805 p.setCost(14 /* load16 */, (char)(c)); 2806 p.writePacked(1, 0xFFFE7FFF, 0x10000); // p.load16 = 2 2807 closure_load16(p, c); 2808 } 2809 } 2810 2811 /** 2812 * Create closure for uload16 2813 * @param p the node 2814 * @param c the cost 2815 */ 2816 @Inline 2817 private static void closure_uload16(AbstractBURS_TreeNode p, int c) { 2818 if(BURS.DEBUG) trace(p, 14, c + 0, p.getCost(14) /* load16 */); 2819 if (c < p.getCost(14) /* load16 */) { 2820 p.setCost(14 /* load16 */, (char)(c)); 2821 p.writePacked(1, 0xFFFE7FFF, 0x18000); // p.load16 = 3 2822 closure_load16(p, c); 2823 } 2824 } 2825 2826 /** 2827 * Create closure for sload8 2828 * @param p the node 2829 * @param c the cost 2830 */ 2831 @Inline 2832 private static void closure_sload8(AbstractBURS_TreeNode p, int c) { 2833 if(BURS.DEBUG) trace(p, 11, c + 0, p.getCost(20) /* load8 */); 2834 if (c < p.getCost(20) /* load8 */) { 2835 p.setCost(20 /* load8 */, (char)(c)); 2836 p.writePacked(2, 0xFFFFFFCF, 0x20); // p.load8 = 2 2837 closure_load8(p, c); 2838 } 2839 } 2840 2841 /** 2842 /** Recursively labels the tree/ 2843 * @param p node to label 2844 */ 2845 public static void label(AbstractBURS_TreeNode p) { 2846 switch (p.getOpcode()) { 2847 case GET_CAUGHT_EXCEPTION_opcode: 2848 label_GET_CAUGHT_EXCEPTION(p); 2849 break; 2850 case SET_CAUGHT_EXCEPTION_opcode: 2851 label_SET_CAUGHT_EXCEPTION(p); 2852 break; 2853 case IG_PATCH_POINT_opcode: 2854 label_IG_PATCH_POINT(p); 2855 break; 2856 case INT_ALOAD_opcode: 2857 label_INT_ALOAD(p); 2858 break; 2859 case LONG_ALOAD_opcode: 2860 label_LONG_ALOAD(p); 2861 break; 2862 case FLOAT_ALOAD_opcode: 2863 label_FLOAT_ALOAD(p); 2864 break; 2865 case DOUBLE_ALOAD_opcode: 2866 label_DOUBLE_ALOAD(p); 2867 break; 2868 case UBYTE_ALOAD_opcode: 2869 label_UBYTE_ALOAD(p); 2870 break; 2871 case BYTE_ALOAD_opcode: 2872 label_BYTE_ALOAD(p); 2873 break; 2874 case USHORT_ALOAD_opcode: 2875 label_USHORT_ALOAD(p); 2876 break; 2877 case SHORT_ALOAD_opcode: 2878 label_SHORT_ALOAD(p); 2879 break; 2880 case INT_ASTORE_opcode: 2881 label_INT_ASTORE(p); 2882 break; 2883 case LONG_ASTORE_opcode: 2884 label_LONG_ASTORE(p); 2885 break; 2886 case FLOAT_ASTORE_opcode: 2887 label_FLOAT_ASTORE(p); 2888 break; 2889 case DOUBLE_ASTORE_opcode: 2890 label_DOUBLE_ASTORE(p); 2891 break; 2892 case BYTE_ASTORE_opcode: 2893 label_BYTE_ASTORE(p); 2894 break; 2895 case SHORT_ASTORE_opcode: 2896 label_SHORT_ASTORE(p); 2897 break; 2898 case INT_IFCMP_opcode: 2899 label_INT_IFCMP(p); 2900 break; 2901 case INT_IFCMP2_opcode: 2902 label_INT_IFCMP2(p); 2903 break; 2904 case LONG_IFCMP_opcode: 2905 label_LONG_IFCMP(p); 2906 break; 2907 case FLOAT_IFCMP_opcode: 2908 label_FLOAT_IFCMP(p); 2909 break; 2910 case DOUBLE_IFCMP_opcode: 2911 label_DOUBLE_IFCMP(p); 2912 break; 2913 case UNINT_BEGIN_opcode: 2914 label_UNINT_BEGIN(p); 2915 break; 2916 case UNINT_END_opcode: 2917 label_UNINT_END(p); 2918 break; 2919 case FENCE_opcode: 2920 label_FENCE(p); 2921 break; 2922 case READ_CEILING_opcode: 2923 label_READ_CEILING(p); 2924 break; 2925 case WRITE_FLOOR_opcode: 2926 label_WRITE_FLOOR(p); 2927 break; 2928 case NOP_opcode: 2929 label_NOP(p); 2930 break; 2931 case INT_MOVE_opcode: 2932 label_INT_MOVE(p); 2933 break; 2934 case LONG_MOVE_opcode: 2935 label_LONG_MOVE(p); 2936 break; 2937 case FLOAT_MOVE_opcode: 2938 label_FLOAT_MOVE(p); 2939 break; 2940 case DOUBLE_MOVE_opcode: 2941 label_DOUBLE_MOVE(p); 2942 break; 2943 case GUARD_MOVE_opcode: 2944 label_GUARD_MOVE(p); 2945 break; 2946 case GUARD_COMBINE_opcode: 2947 label_GUARD_COMBINE(p); 2948 break; 2949 case INT_ADD_opcode: 2950 label_INT_ADD(p); 2951 break; 2952 case LONG_ADD_opcode: 2953 label_LONG_ADD(p); 2954 break; 2955 case FLOAT_ADD_opcode: 2956 label_FLOAT_ADD(p); 2957 break; 2958 case DOUBLE_ADD_opcode: 2959 label_DOUBLE_ADD(p); 2960 break; 2961 case INT_SUB_opcode: 2962 label_INT_SUB(p); 2963 break; 2964 case LONG_SUB_opcode: 2965 label_LONG_SUB(p); 2966 break; 2967 case FLOAT_SUB_opcode: 2968 label_FLOAT_SUB(p); 2969 break; 2970 case DOUBLE_SUB_opcode: 2971 label_DOUBLE_SUB(p); 2972 break; 2973 case INT_MUL_opcode: 2974 label_INT_MUL(p); 2975 break; 2976 case LONG_MUL_opcode: 2977 label_LONG_MUL(p); 2978 break; 2979 case FLOAT_MUL_opcode: 2980 label_FLOAT_MUL(p); 2981 break; 2982 case DOUBLE_MUL_opcode: 2983 label_DOUBLE_MUL(p); 2984 break; 2985 case INT_DIV_opcode: 2986 label_INT_DIV(p); 2987 break; 2988 case FLOAT_DIV_opcode: 2989 label_FLOAT_DIV(p); 2990 break; 2991 case DOUBLE_DIV_opcode: 2992 label_DOUBLE_DIV(p); 2993 break; 2994 case INT_REM_opcode: 2995 label_INT_REM(p); 2996 break; 2997 case FLOAT_REM_opcode: 2998 label_FLOAT_REM(p); 2999 break; 3000 case DOUBLE_REM_opcode: 3001 label_DOUBLE_REM(p); 3002 break; 3003 case INT_NEG_opcode: 3004 label_INT_NEG(p); 3005 break; 3006 case LONG_NEG_opcode: 3007 label_LONG_NEG(p); 3008 break; 3009 case FLOAT_NEG_opcode: 3010 label_FLOAT_NEG(p); 3011 break; 3012 case DOUBLE_NEG_opcode: 3013 label_DOUBLE_NEG(p); 3014 break; 3015 case FLOAT_SQRT_opcode: 3016 label_FLOAT_SQRT(p); 3017 break; 3018 case DOUBLE_SQRT_opcode: 3019 label_DOUBLE_SQRT(p); 3020 break; 3021 case INT_SHL_opcode: 3022 label_INT_SHL(p); 3023 break; 3024 case LONG_SHL_opcode: 3025 label_LONG_SHL(p); 3026 break; 3027 case INT_SHR_opcode: 3028 label_INT_SHR(p); 3029 break; 3030 case LONG_SHR_opcode: 3031 label_LONG_SHR(p); 3032 break; 3033 case INT_USHR_opcode: 3034 label_INT_USHR(p); 3035 break; 3036 case LONG_USHR_opcode: 3037 label_LONG_USHR(p); 3038 break; 3039 case INT_AND_opcode: 3040 label_INT_AND(p); 3041 break; 3042 case LONG_AND_opcode: 3043 label_LONG_AND(p); 3044 break; 3045 case INT_OR_opcode: 3046 label_INT_OR(p); 3047 break; 3048 case LONG_OR_opcode: 3049 label_LONG_OR(p); 3050 break; 3051 case INT_XOR_opcode: 3052 label_INT_XOR(p); 3053 break; 3054 case INT_NOT_opcode: 3055 label_INT_NOT(p); 3056 break; 3057 case LONG_NOT_opcode: 3058 label_LONG_NOT(p); 3059 break; 3060 case LONG_XOR_opcode: 3061 label_LONG_XOR(p); 3062 break; 3063 case ADDR_2LONG_opcode: 3064 label_ADDR_2LONG(p); 3065 break; 3066 case INT_2LONG_opcode: 3067 label_INT_2LONG(p); 3068 break; 3069 case INT_2FLOAT_opcode: 3070 label_INT_2FLOAT(p); 3071 break; 3072 case INT_2DOUBLE_opcode: 3073 label_INT_2DOUBLE(p); 3074 break; 3075 case LONG_2INT_opcode: 3076 label_LONG_2INT(p); 3077 break; 3078 case LONG_2FLOAT_opcode: 3079 label_LONG_2FLOAT(p); 3080 break; 3081 case LONG_2DOUBLE_opcode: 3082 label_LONG_2DOUBLE(p); 3083 break; 3084 case FLOAT_2INT_opcode: 3085 label_FLOAT_2INT(p); 3086 break; 3087 case FLOAT_2LONG_opcode: 3088 label_FLOAT_2LONG(p); 3089 break; 3090 case FLOAT_2DOUBLE_opcode: 3091 label_FLOAT_2DOUBLE(p); 3092 break; 3093 case DOUBLE_2INT_opcode: 3094 label_DOUBLE_2INT(p); 3095 break; 3096 case DOUBLE_2LONG_opcode: 3097 label_DOUBLE_2LONG(p); 3098 break; 3099 case DOUBLE_2FLOAT_opcode: 3100 label_DOUBLE_2FLOAT(p); 3101 break; 3102 case INT_2BYTE_opcode: 3103 label_INT_2BYTE(p); 3104 break; 3105 case INT_2USHORT_opcode: 3106 label_INT_2USHORT(p); 3107 break; 3108 case INT_2SHORT_opcode: 3109 label_INT_2SHORT(p); 3110 break; 3111 case LONG_CMP_opcode: 3112 label_LONG_CMP(p); 3113 break; 3114 case RETURN_opcode: 3115 label_RETURN(p); 3116 break; 3117 case NULL_CHECK_opcode: 3118 label_NULL_CHECK(p); 3119 break; 3120 case GOTO_opcode: 3121 label_GOTO(p); 3122 break; 3123 case BOOLEAN_NOT_opcode: 3124 label_BOOLEAN_NOT(p); 3125 break; 3126 case BOOLEAN_CMP_INT_opcode: 3127 label_BOOLEAN_CMP_INT(p); 3128 break; 3129 case BOOLEAN_CMP_LONG_opcode: 3130 label_BOOLEAN_CMP_LONG(p); 3131 break; 3132 case BYTE_LOAD_opcode: 3133 label_BYTE_LOAD(p); 3134 break; 3135 case UBYTE_LOAD_opcode: 3136 label_UBYTE_LOAD(p); 3137 break; 3138 case SHORT_LOAD_opcode: 3139 label_SHORT_LOAD(p); 3140 break; 3141 case USHORT_LOAD_opcode: 3142 label_USHORT_LOAD(p); 3143 break; 3144 case INT_LOAD_opcode: 3145 label_INT_LOAD(p); 3146 break; 3147 case LONG_LOAD_opcode: 3148 label_LONG_LOAD(p); 3149 break; 3150 case FLOAT_LOAD_opcode: 3151 label_FLOAT_LOAD(p); 3152 break; 3153 case DOUBLE_LOAD_opcode: 3154 label_DOUBLE_LOAD(p); 3155 break; 3156 case BYTE_STORE_opcode: 3157 label_BYTE_STORE(p); 3158 break; 3159 case SHORT_STORE_opcode: 3160 label_SHORT_STORE(p); 3161 break; 3162 case INT_STORE_opcode: 3163 label_INT_STORE(p); 3164 break; 3165 case LONG_STORE_opcode: 3166 label_LONG_STORE(p); 3167 break; 3168 case FLOAT_STORE_opcode: 3169 label_FLOAT_STORE(p); 3170 break; 3171 case DOUBLE_STORE_opcode: 3172 label_DOUBLE_STORE(p); 3173 break; 3174 case ATTEMPT_INT_opcode: 3175 label_ATTEMPT_INT(p); 3176 break; 3177 case ATTEMPT_LONG_opcode: 3178 label_ATTEMPT_LONG(p); 3179 break; 3180 case CALL_opcode: 3181 label_CALL(p); 3182 break; 3183 case SYSCALL_opcode: 3184 label_SYSCALL(p); 3185 break; 3186 case YIELDPOINT_PROLOGUE_opcode: 3187 label_YIELDPOINT_PROLOGUE(p); 3188 break; 3189 case YIELDPOINT_EPILOGUE_opcode: 3190 label_YIELDPOINT_EPILOGUE(p); 3191 break; 3192 case YIELDPOINT_BACKEDGE_opcode: 3193 label_YIELDPOINT_BACKEDGE(p); 3194 break; 3195 case YIELDPOINT_OSR_opcode: 3196 label_YIELDPOINT_OSR(p); 3197 break; 3198 case IR_PROLOGUE_opcode: 3199 label_IR_PROLOGUE(p); 3200 break; 3201 case RESOLVE_opcode: 3202 label_RESOLVE(p); 3203 break; 3204 case GET_TIME_BASE_opcode: 3205 label_GET_TIME_BASE(p); 3206 break; 3207 case TRAP_IF_opcode: 3208 label_TRAP_IF(p); 3209 break; 3210 case TRAP_opcode: 3211 label_TRAP(p); 3212 break; 3213 case FLOAT_AS_INT_BITS_opcode: 3214 label_FLOAT_AS_INT_BITS(p); 3215 break; 3216 case INT_BITS_AS_FLOAT_opcode: 3217 label_INT_BITS_AS_FLOAT(p); 3218 break; 3219 case DOUBLE_AS_LONG_BITS_opcode: 3220 label_DOUBLE_AS_LONG_BITS(p); 3221 break; 3222 case LONG_BITS_AS_DOUBLE_opcode: 3223 label_LONG_BITS_AS_DOUBLE(p); 3224 break; 3225 case LOWTABLESWITCH_opcode: 3226 label_LOWTABLESWITCH(p); 3227 break; 3228 case ADDRESS_CONSTANT_opcode: 3229 label_ADDRESS_CONSTANT(p); 3230 break; 3231 case INT_CONSTANT_opcode: 3232 label_INT_CONSTANT(p); 3233 break; 3234 case LONG_CONSTANT_opcode: 3235 label_LONG_CONSTANT(p); 3236 break; 3237 case REGISTER_opcode: 3238 label_REGISTER(p); 3239 break; 3240 case OTHER_OPERAND_opcode: 3241 label_OTHER_OPERAND(p); 3242 break; 3243 case NULL_opcode: 3244 label_NULL(p); 3245 break; 3246 case BRANCH_TARGET_opcode: 3247 label_BRANCH_TARGET(p); 3248 break; 3249 case MATERIALIZE_FP_CONSTANT_opcode: 3250 label_MATERIALIZE_FP_CONSTANT(p); 3251 break; 3252 case CLEAR_FLOATING_POINT_STATE_opcode: 3253 label_CLEAR_FLOATING_POINT_STATE(p); 3254 break; 3255 case PREFETCH_opcode: 3256 label_PREFETCH(p); 3257 break; 3258 case PAUSE_opcode: 3259 label_PAUSE(p); 3260 break; 3261 case CMP_CMOV_opcode: 3262 label_CMP_CMOV(p); 3263 break; 3264 case FCMP_CMOV_opcode: 3265 label_FCMP_CMOV(p); 3266 break; 3267 case LCMP_CMOV_opcode: 3268 label_LCMP_CMOV(p); 3269 break; 3270 case FCMP_FCMOV_opcode: 3271 label_FCMP_FCMOV(p); 3272 break; 3273 default: 3274 throw new OptimizingCompilerException("BURS","terminal not in grammar:", 3275 p.toString()); 3276 } 3277 } 3278 3279 /** 3280 * Labels GET_CAUGHT_EXCEPTION tree node 3281 * @param p node to label 3282 */ 3283 private static void label_GET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 3284 p.initCost(); 3285 // r: GET_CAUGHT_EXCEPTION 3286 if(BURS.DEBUG) trace(p, 36, 11 + 0, p.getCost(2) /* r */); 3287 if (11 < p.getCost(2) /* r */) { 3288 p.setCost(2 /* r */, (char)(11)); 3289 p.writePacked(0, 0xFFFF00FF, 0x600); // p.r = 6 3290 closure_r(p, 11); 3291 } 3292 } 3293 3294 /** 3295 * Labels SET_CAUGHT_EXCEPTION tree node 3296 * @param p node to label 3297 */ 3298 private static void label_SET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 3299 p.initCost(); 3300 AbstractBURS_TreeNode lchild; 3301 lchild = p.getChild1(); 3302 label(lchild); 3303 int c; 3304 // stm: SET_CAUGHT_EXCEPTION(r) 3305 c = STATE(lchild).getCost(2 /* r */) + 11; 3306 if(BURS.DEBUG) trace(p, 208, c + 0, p.getCost(1) /* stm */); 3307 if (c < p.getCost(1) /* stm */) { 3308 p.setCost(1 /* stm */, (char)(c)); 3309 p.writePacked(0, 0xFFFFFF00, 0xD); // p.stm = 13 3310 } 3311 if ( // stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 3312 lchild.getOpcode() == INT_CONSTANT_opcode 3313 ) { 3314 c = 20; 3315 if(BURS.DEBUG) trace(p, 37, c + 0, p.getCost(1) /* stm */); 3316 if (c < p.getCost(1) /* stm */) { 3317 p.setCost(1 /* stm */, (char)(c)); 3318 p.writePacked(0, 0xFFFFFF00, 0xE); // p.stm = 14 3319 } 3320 } 3321 } 3322 3323 /** 3324 * Labels IG_PATCH_POINT tree node 3325 * @param p node to label 3326 */ 3327 private static void label_IG_PATCH_POINT(AbstractBURS_TreeNode p) { 3328 p.initCost(); 3329 // stm: IG_PATCH_POINT 3330 if(BURS.DEBUG) trace(p, 25, 10 + 0, p.getCost(1) /* stm */); 3331 if (10 < p.getCost(1) /* stm */) { 3332 p.setCost(1 /* stm */, (char)(10)); 3333 p.writePacked(0, 0xFFFFFF00, 0x2); // p.stm = 2 3334 } 3335 } 3336 3337 /** 3338 * Labels INT_ALOAD tree node 3339 * @param p node to label 3340 */ 3341 private static void label_INT_ALOAD(AbstractBURS_TreeNode p) { 3342 p.initCost(); 3343 AbstractBURS_TreeNode lchild, rchild; 3344 lchild = p.getChild1(); 3345 rchild = p.getChild2(); 3346 label(lchild); 3347 label(rchild); 3348 int c; 3349 // r: INT_ALOAD(riv,riv) 3350 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3351 if(BURS.DEBUG) trace(p, 96, c + 0, p.getCost(2) /* r */); 3352 if (c < p.getCost(2) /* r */) { 3353 p.setCost(2 /* r */, (char)(c)); 3354 p.writePacked(0, 0xFFFF00FF, 0x5600); // p.r = 86 3355 closure_r(p, c); 3356 } 3357 // load32: INT_ALOAD(riv,riv) 3358 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3359 if(BURS.DEBUG) trace(p, 137, c + 0, p.getCost(10) /* load32 */); 3360 if (c < p.getCost(10) /* load32 */) { 3361 p.setCost(10 /* load32 */, (char)(c)); 3362 p.writePacked(1, 0xFFFFFF1F, 0x60); // p.load32 = 3 3363 closure_load32(p, c); 3364 } 3365 } 3366 3367 /** 3368 * Labels LONG_ALOAD tree node 3369 * @param p node to label 3370 */ 3371 private static void label_LONG_ALOAD(AbstractBURS_TreeNode p) { 3372 p.initCost(); 3373 AbstractBURS_TreeNode lchild, rchild; 3374 lchild = p.getChild1(); 3375 rchild = p.getChild2(); 3376 label(lchild); 3377 label(rchild); 3378 int c; 3379 // load64: LONG_ALOAD(riv,riv) 3380 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3381 if(BURS.DEBUG) trace(p, 139, c + 0, p.getCost(22) /* load64 */); 3382 if (c < p.getCost(22) /* load64 */) { 3383 p.setCost(22 /* load64 */, (char)(c)); 3384 p.writePacked(2, 0xFFFFF1FF, 0x400); // p.load64 = 2 3385 } 3386 // r: LONG_ALOAD(riv,riv) 3387 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 30; 3388 if(BURS.DEBUG) trace(p, 148, c + 0, p.getCost(2) /* r */); 3389 if (c < p.getCost(2) /* r */) { 3390 p.setCost(2 /* r */, (char)(c)); 3391 p.writePacked(0, 0xFFFF00FF, 0x8500); // p.r = 133 3392 closure_r(p, c); 3393 } 3394 } 3395 3396 /** 3397 * Labels FLOAT_ALOAD tree node 3398 * @param p node to label 3399 */ 3400 private static void label_FLOAT_ALOAD(AbstractBURS_TreeNode p) { 3401 p.initCost(); 3402 AbstractBURS_TreeNode lchild, rchild; 3403 lchild = p.getChild1(); 3404 rchild = p.getChild2(); 3405 label(lchild); 3406 label(rchild); 3407 int c; 3408 // r: FLOAT_ALOAD(riv,riv) 3409 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3410 if(BURS.DEBUG) trace(p, 196, c + 0, p.getCost(2) /* r */); 3411 if (c < p.getCost(2) /* r */) { 3412 p.setCost(2 /* r */, (char)(c)); 3413 p.writePacked(0, 0xFFFF00FF, 0xC300); // p.r = 195 3414 closure_r(p, c); 3415 } 3416 // r: FLOAT_ALOAD(riv,r) 3417 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 10; 3418 if(BURS.DEBUG) trace(p, 197, c + 0, p.getCost(2) /* r */); 3419 if (c < p.getCost(2) /* r */) { 3420 p.setCost(2 /* r */, (char)(c)); 3421 p.writePacked(0, 0xFFFF00FF, 0xC400); // p.r = 196 3422 closure_r(p, c); 3423 } 3424 // r: FLOAT_ALOAD(rlv,rlv) 3425 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 3426 if(BURS.DEBUG) trace(p, 198, c + 0, p.getCost(2) /* r */); 3427 if (c < p.getCost(2) /* r */) { 3428 p.setCost(2 /* r */, (char)(c)); 3429 p.writePacked(0, 0xFFFF00FF, 0xC500); // p.r = 197 3430 closure_r(p, c); 3431 } 3432 // float_load: FLOAT_ALOAD(riv,riv) 3433 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3434 if(BURS.DEBUG) trace(p, 199, c + 0, p.getCost(25) /* float_load */); 3435 if (c < p.getCost(25) /* float_load */) { 3436 p.setCost(25 /* float_load */, (char)(c)); 3437 p.writePacked(2, 0xFFF1FFFF, 0x40000); // p.float_load = 2 3438 } 3439 } 3440 3441 /** 3442 * Labels DOUBLE_ALOAD tree node 3443 * @param p node to label 3444 */ 3445 private static void label_DOUBLE_ALOAD(AbstractBURS_TreeNode p) { 3446 p.initCost(); 3447 AbstractBURS_TreeNode lchild, rchild; 3448 lchild = p.getChild1(); 3449 rchild = p.getChild2(); 3450 label(lchild); 3451 label(rchild); 3452 int c; 3453 // r: DOUBLE_ALOAD(riv,riv) 3454 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3455 if(BURS.DEBUG) trace(p, 188, c + 0, p.getCost(2) /* r */); 3456 if (c < p.getCost(2) /* r */) { 3457 p.setCost(2 /* r */, (char)(c)); 3458 p.writePacked(0, 0xFFFF00FF, 0xBE00); // p.r = 190 3459 closure_r(p, c); 3460 } 3461 // r: DOUBLE_ALOAD(riv,r) 3462 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 10; 3463 if(BURS.DEBUG) trace(p, 190, c + 0, p.getCost(2) /* r */); 3464 if (c < p.getCost(2) /* r */) { 3465 p.setCost(2 /* r */, (char)(c)); 3466 p.writePacked(0, 0xFFFF00FF, 0xBF00); // p.r = 191 3467 closure_r(p, c); 3468 } 3469 // r: DOUBLE_ALOAD(rlv,rlv) 3470 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 10; 3471 if(BURS.DEBUG) trace(p, 191, c + 0, p.getCost(2) /* r */); 3472 if (c < p.getCost(2) /* r */) { 3473 p.setCost(2 /* r */, (char)(c)); 3474 p.writePacked(0, 0xFFFF00FF, 0xC000); // p.r = 192 3475 closure_r(p, c); 3476 } 3477 // double_load: DOUBLE_ALOAD(riv,riv) 3478 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3479 if(BURS.DEBUG) trace(p, 192, c + 0, p.getCost(26) /* double_load */); 3480 if (c < p.getCost(26) /* double_load */) { 3481 p.setCost(26 /* double_load */, (char)(c)); 3482 p.writePacked(2, 0xFF8FFFFF, 0x300000); // p.double_load = 3 3483 } 3484 } 3485 3486 /** 3487 * Labels UBYTE_ALOAD tree node 3488 * @param p node to label 3489 */ 3490 private static void label_UBYTE_ALOAD(AbstractBURS_TreeNode p) { 3491 p.initCost(); 3492 AbstractBURS_TreeNode lchild, rchild; 3493 lchild = p.getChild1(); 3494 rchild = p.getChild2(); 3495 label(lchild); 3496 label(rchild); 3497 int c; 3498 // r: UBYTE_ALOAD(riv,riv) 3499 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3500 if(BURS.DEBUG) trace(p, 126, c + 0, p.getCost(2) /* r */); 3501 if (c < p.getCost(2) /* r */) { 3502 p.setCost(2 /* r */, (char)(c)); 3503 p.writePacked(0, 0xFFFF00FF, 0x7300); // p.r = 115 3504 closure_r(p, c); 3505 } 3506 // uload8: UBYTE_ALOAD(riv,riv) 3507 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3508 if(BURS.DEBUG) trace(p, 127, c + 0, p.getCost(11) /* uload8 */); 3509 if (c < p.getCost(11) /* uload8 */) { 3510 p.setCost(11 /* uload8 */, (char)(c)); 3511 p.writePacked(1, 0xFFFFF8FF, 0x400); // p.uload8 = 4 3512 closure_uload8(p, c); 3513 } 3514 } 3515 3516 /** 3517 * Labels BYTE_ALOAD tree node 3518 * @param p node to label 3519 */ 3520 private static void label_BYTE_ALOAD(AbstractBURS_TreeNode p) { 3521 p.initCost(); 3522 AbstractBURS_TreeNode lchild, rchild; 3523 lchild = p.getChild1(); 3524 rchild = p.getChild2(); 3525 label(lchild); 3526 label(rchild); 3527 int c; 3528 // r: BYTE_ALOAD(riv,riv) 3529 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 20; 3530 if(BURS.DEBUG) trace(p, 122, c + 0, p.getCost(2) /* r */); 3531 if (c < p.getCost(2) /* r */) { 3532 p.setCost(2 /* r */, (char)(c)); 3533 p.writePacked(0, 0xFFFF00FF, 0x7100); // p.r = 113 3534 closure_r(p, c); 3535 } 3536 // sload8: BYTE_ALOAD(riv,riv) 3537 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3538 if(BURS.DEBUG) trace(p, 123, c + 0, p.getCost(24) /* sload8 */); 3539 if (c < p.getCost(24) /* sload8 */) { 3540 p.setCost(24 /* sload8 */, (char)(c)); 3541 p.writePacked(2, 0xFFFE7FFF, 0x18000); // p.sload8 = 3 3542 closure_sload8(p, c); 3543 } 3544 } 3545 3546 /** 3547 * Labels USHORT_ALOAD tree node 3548 * @param p node to label 3549 */ 3550 private static void label_USHORT_ALOAD(AbstractBURS_TreeNode p) { 3551 p.initCost(); 3552 AbstractBURS_TreeNode lchild, rchild; 3553 lchild = p.getChild1(); 3554 rchild = p.getChild2(); 3555 label(lchild); 3556 label(rchild); 3557 int c; 3558 // r: USHORT_ALOAD(riv,riv) 3559 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 3560 if(BURS.DEBUG) trace(p, 134, c + 0, p.getCost(2) /* r */); 3561 if (c < p.getCost(2) /* r */) { 3562 p.setCost(2 /* r */, (char)(c)); 3563 p.writePacked(0, 0xFFFF00FF, 0x7700); // p.r = 119 3564 closure_r(p, c); 3565 } 3566 // uload16: USHORT_ALOAD(riv,riv) 3567 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3568 if(BURS.DEBUG) trace(p, 135, c + 0, p.getCost(23) /* uload16 */); 3569 if (c < p.getCost(23) /* uload16 */) { 3570 p.setCost(23 /* uload16 */, (char)(c)); 3571 p.writePacked(2, 0xFFFF8FFF, 0x4000); // p.uload16 = 4 3572 closure_uload16(p, c); 3573 } 3574 } 3575 3576 /** 3577 * Labels SHORT_ALOAD tree node 3578 * @param p node to label 3579 */ 3580 private static void label_SHORT_ALOAD(AbstractBURS_TreeNode p) { 3581 p.initCost(); 3582 AbstractBURS_TreeNode lchild, rchild; 3583 lchild = p.getChild1(); 3584 rchild = p.getChild2(); 3585 label(lchild); 3586 label(rchild); 3587 int c; 3588 // r: SHORT_ALOAD(riv,riv) 3589 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 20; 3590 if(BURS.DEBUG) trace(p, 130, c + 0, p.getCost(2) /* r */); 3591 if (c < p.getCost(2) /* r */) { 3592 p.setCost(2 /* r */, (char)(c)); 3593 p.writePacked(0, 0xFFFF00FF, 0x7500); // p.r = 117 3594 closure_r(p, c); 3595 } 3596 // sload16: SHORT_ALOAD(riv,riv) 3597 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 3598 if(BURS.DEBUG) trace(p, 131, c + 0, p.getCost(21) /* sload16 */); 3599 if (c < p.getCost(21) /* sload16 */) { 3600 p.setCost(21 /* sload16 */, (char)(c)); 3601 p.writePacked(2, 0xFFFFFE3F, 0x100); // p.sload16 = 4 3602 closure_sload16(p, c); 3603 } 3604 } 3605 3606 /** 3607 * Labels INT_ASTORE tree node 3608 * @param p node to label 3609 */ 3610 private static void label_INT_ASTORE(AbstractBURS_TreeNode p) { 3611 p.initCost(); 3612 AbstractBURS_TreeNode lchild, rchild; 3613 lchild = p.getChild1(); 3614 rchild = p.getChild2(); 3615 label(lchild); 3616 label(rchild); 3617 int c; 3618 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 3619 rchild.getOpcode() == OTHER_OPERAND_opcode 3620 ) { 3621 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 3622 if(BURS.DEBUG) trace(p, 349, c + 0, p.getCost(1) /* stm */); 3623 if (c < p.getCost(1) /* stm */) { 3624 p.setCost(1 /* stm */, (char)(c)); 3625 p.writePacked(0, 0xFFFFFF00, 0x1C); // p.stm = 28 3626 } 3627 } 3628 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 3629 rchild.getOpcode() == OTHER_OPERAND_opcode 3630 ) { 3631 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 3632 if(BURS.DEBUG) trace(p, 350, c + 0, p.getCost(1) /* stm */); 3633 if (c < p.getCost(1) /* stm */) { 3634 p.setCost(1 /* stm */, (char)(c)); 3635 p.writePacked(0, 0xFFFFFF00, 0x1D); // p.stm = 29 3636 } 3637 } 3638 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 3639 rchild.getOpcode() == OTHER_OPERAND_opcode 3640 ) { 3641 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 3642 if(BURS.DEBUG) trace(p, 351, c + 0, p.getCost(1) /* stm */); 3643 if (c < p.getCost(1) /* stm */) { 3644 p.setCost(1 /* stm */, (char)(c)); 3645 p.writePacked(0, 0xFFFFFF00, 0x1E); // p.stm = 30 3646 } 3647 } 3648 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 3649 rchild.getOpcode() == OTHER_OPERAND_opcode 3650 ) { 3651 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 3652 if(BURS.DEBUG) trace(p, 352, c + 0, p.getCost(1) /* stm */); 3653 if (c < p.getCost(1) /* stm */) { 3654 p.setCost(1 /* stm */, (char)(c)); 3655 p.writePacked(0, 0xFFFFFF00, 0x1F); // p.stm = 31 3656 } 3657 } 3658 if ( // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 3659 rchild.getOpcode() == OTHER_OPERAND_opcode 3660 ) { 3661 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 3662 if(BURS.DEBUG) trace(p, 353, c + 0, p.getCost(1) /* stm */); 3663 if (c < p.getCost(1) /* stm */) { 3664 p.setCost(1 /* stm */, (char)(c)); 3665 p.writePacked(0, 0xFFFFFF00, 0x20); // p.stm = 32 3666 } 3667 } 3668 if ( // stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 3669 lchild.getOpcode() == INT_ADD_opcode && 3670 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3671 rchild.getOpcode() == OTHER_OPERAND_opcode 3672 ) { 3673 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); 3674 if(BURS.DEBUG) trace(p, 483, c + 0, p.getCost(1) /* stm */); 3675 if (c < p.getCost(1) /* stm */) { 3676 p.setCost(1 /* stm */, (char)(c)); 3677 p.writePacked(0, 0xFFFFFF00, 0x4F); // p.stm = 79 3678 } 3679 } 3680 if ( // stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3681 lchild.getOpcode() == INT_ADD_opcode && 3682 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 3683 rchild.getOpcode() == OTHER_OPERAND_opcode 3684 ) { 3685 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); 3686 if(BURS.DEBUG) trace(p, 503, c + 0, p.getCost(1) /* stm */); 3687 if (c < p.getCost(1) /* stm */) { 3688 p.setCost(1 /* stm */, (char)(c)); 3689 p.writePacked(0, 0xFFFFFF00, 0x50); // p.stm = 80 3690 } 3691 } 3692 if ( // stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 3693 lchild.getOpcode() == INT_AND_opcode && 3694 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3695 rchild.getOpcode() == OTHER_OPERAND_opcode 3696 ) { 3697 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); 3698 if(BURS.DEBUG) trace(p, 485, c + 0, p.getCost(1) /* stm */); 3699 if (c < p.getCost(1) /* stm */) { 3700 p.setCost(1 /* stm */, (char)(c)); 3701 p.writePacked(0, 0xFFFFFF00, 0x53); // p.stm = 83 3702 } 3703 } 3704 if ( // stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3705 lchild.getOpcode() == INT_AND_opcode && 3706 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 3707 rchild.getOpcode() == OTHER_OPERAND_opcode 3708 ) { 3709 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); 3710 if(BURS.DEBUG) trace(p, 505, c + 0, p.getCost(1) /* stm */); 3711 if (c < p.getCost(1) /* stm */) { 3712 p.setCost(1 /* stm */, (char)(c)); 3713 p.writePacked(0, 0xFFFFFF00, 0x54); // p.stm = 84 3714 } 3715 } 3716 if ( // stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3717 lchild.getOpcode() == INT_NEG_opcode && 3718 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3719 rchild.getOpcode() == OTHER_OPERAND_opcode 3720 ) { 3721 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); 3722 if(BURS.DEBUG) trace(p, 453, c + 0, p.getCost(1) /* stm */); 3723 if (c < p.getCost(1) /* stm */) { 3724 p.setCost(1 /* stm */, (char)(c)); 3725 p.writePacked(0, 0xFFFFFF00, 0x66); // p.stm = 102 3726 } 3727 } 3728 if ( // stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3729 lchild.getOpcode() == INT_NOT_opcode && 3730 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3731 rchild.getOpcode() == OTHER_OPERAND_opcode 3732 ) { 3733 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); 3734 if(BURS.DEBUG) trace(p, 455, c + 0, p.getCost(1) /* stm */); 3735 if (c < p.getCost(1) /* stm */) { 3736 p.setCost(1 /* stm */, (char)(c)); 3737 p.writePacked(0, 0xFFFFFF00, 0x68); // p.stm = 104 3738 } 3739 } 3740 if ( // stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 3741 lchild.getOpcode() == INT_OR_opcode && 3742 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3743 rchild.getOpcode() == OTHER_OPERAND_opcode 3744 ) { 3745 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); 3746 if(BURS.DEBUG) trace(p, 487, c + 0, p.getCost(1) /* stm */); 3747 if (c < p.getCost(1) /* stm */) { 3748 p.setCost(1 /* stm */, (char)(c)); 3749 p.writePacked(0, 0xFFFFFF00, 0x6B); // p.stm = 107 3750 } 3751 } 3752 if ( // stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3753 lchild.getOpcode() == INT_OR_opcode && 3754 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 3755 rchild.getOpcode() == OTHER_OPERAND_opcode 3756 ) { 3757 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); 3758 if(BURS.DEBUG) trace(p, 507, c + 0, p.getCost(1) /* stm */); 3759 if (c < p.getCost(1) /* stm */) { 3760 p.setCost(1 /* stm */, (char)(c)); 3761 p.writePacked(0, 0xFFFFFF00, 0x6C); // p.stm = 108 3762 } 3763 } 3764 if ( // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 3765 lchild.getOpcode() == INT_SHL_opcode && 3766 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3767 lchild.getChild2().getOpcode() == INT_AND_opcode && 3768 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 3769 rchild.getOpcode() == OTHER_OPERAND_opcode 3770 ) { 3771 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)); 3772 if(BURS.DEBUG) trace(p, 538, c + 0, p.getCost(1) /* stm */); 3773 if (c < p.getCost(1) /* stm */) { 3774 p.setCost(1 /* stm */, (char)(c)); 3775 p.writePacked(0, 0xFFFFFF00, 0x6F); // p.stm = 111 3776 } 3777 } 3778 if ( // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 3779 lchild.getOpcode() == INT_SHL_opcode && 3780 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3781 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3782 rchild.getOpcode() == OTHER_OPERAND_opcode 3783 ) { 3784 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)); 3785 if(BURS.DEBUG) trace(p, 457, c + 0, p.getCost(1) /* stm */); 3786 if (c < p.getCost(1) /* stm */) { 3787 p.setCost(1 /* stm */, (char)(c)); 3788 p.writePacked(0, 0xFFFFFF00, 0x70); // p.stm = 112 3789 } 3790 } 3791 if ( // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 3792 lchild.getOpcode() == INT_SHR_opcode && 3793 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3794 lchild.getChild2().getOpcode() == INT_AND_opcode && 3795 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 3796 rchild.getOpcode() == OTHER_OPERAND_opcode 3797 ) { 3798 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)); 3799 if(BURS.DEBUG) trace(p, 540, c + 0, p.getCost(1) /* stm */); 3800 if (c < p.getCost(1) /* stm */) { 3801 p.setCost(1 /* stm */, (char)(c)); 3802 p.writePacked(0, 0xFFFFFF00, 0x73); // p.stm = 115 3803 } 3804 } 3805 if ( // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 3806 lchild.getOpcode() == INT_SHR_opcode && 3807 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3808 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3809 rchild.getOpcode() == OTHER_OPERAND_opcode 3810 ) { 3811 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)); 3812 if(BURS.DEBUG) trace(p, 459, c + 0, p.getCost(1) /* stm */); 3813 if (c < p.getCost(1) /* stm */) { 3814 p.setCost(1 /* stm */, (char)(c)); 3815 p.writePacked(0, 0xFFFFFF00, 0x74); // p.stm = 116 3816 } 3817 } 3818 if ( // stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 3819 lchild.getOpcode() == INT_SUB_opcode && 3820 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3821 rchild.getOpcode() == OTHER_OPERAND_opcode 3822 ) { 3823 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); 3824 if(BURS.DEBUG) trace(p, 489, c + 0, p.getCost(1) /* stm */); 3825 if (c < p.getCost(1) /* stm */) { 3826 p.setCost(1 /* stm */, (char)(c)); 3827 p.writePacked(0, 0xFFFFFF00, 0x7D); // p.stm = 125 3828 } 3829 } 3830 if ( // stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3831 lchild.getOpcode() == INT_SUB_opcode && 3832 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 3833 rchild.getOpcode() == OTHER_OPERAND_opcode 3834 ) { 3835 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); 3836 if(BURS.DEBUG) trace(p, 509, c + 0, p.getCost(1) /* stm */); 3837 if (c < p.getCost(1) /* stm */) { 3838 p.setCost(1 /* stm */, (char)(c)); 3839 p.writePacked(0, 0xFFFFFF00, 0x7E); // p.stm = 126 3840 } 3841 } 3842 if ( // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 3843 lchild.getOpcode() == INT_USHR_opcode && 3844 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3845 lchild.getChild2().getOpcode() == INT_AND_opcode && 3846 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 3847 rchild.getOpcode() == OTHER_OPERAND_opcode 3848 ) { 3849 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)); 3850 if(BURS.DEBUG) trace(p, 542, c + 0, p.getCost(1) /* stm */); 3851 if (c < p.getCost(1) /* stm */) { 3852 p.setCost(1 /* stm */, (char)(c)); 3853 p.writePacked(0, 0xFFFFFF00, 0x81); // p.stm = 129 3854 } 3855 } 3856 if ( // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 3857 lchild.getOpcode() == INT_USHR_opcode && 3858 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3859 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3860 rchild.getOpcode() == OTHER_OPERAND_opcode 3861 ) { 3862 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)); 3863 if(BURS.DEBUG) trace(p, 461, c + 0, p.getCost(1) /* stm */); 3864 if (c < p.getCost(1) /* stm */) { 3865 p.setCost(1 /* stm */, (char)(c)); 3866 p.writePacked(0, 0xFFFFFF00, 0x82); // p.stm = 130 3867 } 3868 } 3869 if ( // stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 3870 lchild.getOpcode() == INT_XOR_opcode && 3871 lchild.getChild1().getOpcode() == INT_ALOAD_opcode && 3872 rchild.getOpcode() == OTHER_OPERAND_opcode 3873 ) { 3874 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); 3875 if(BURS.DEBUG) trace(p, 491, c + 0, p.getCost(1) /* stm */); 3876 if (c < p.getCost(1) /* stm */) { 3877 p.setCost(1 /* stm */, (char)(c)); 3878 p.writePacked(0, 0xFFFFFF00, 0x85); // p.stm = 133 3879 } 3880 } 3881 if ( // stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 3882 lchild.getOpcode() == INT_XOR_opcode && 3883 lchild.getChild2().getOpcode() == INT_ALOAD_opcode && 3884 rchild.getOpcode() == OTHER_OPERAND_opcode 3885 ) { 3886 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); 3887 if(BURS.DEBUG) trace(p, 511, c + 0, p.getCost(1) /* stm */); 3888 if (c < p.getCost(1) /* stm */) { 3889 p.setCost(1 /* stm */, (char)(c)); 3890 p.writePacked(0, 0xFFFFFF00, 0x86); // p.stm = 134 3891 } 3892 } 3893 if ( // stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 3894 lchild.getOpcode() == LONG_2INT_opcode && 3895 rchild.getOpcode() == OTHER_OPERAND_opcode 3896 ) { 3897 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 3898 if(BURS.DEBUG) trace(p, 481, c + 0, p.getCost(1) /* stm */); 3899 if (c < p.getCost(1) /* stm */) { 3900 p.setCost(1 /* stm */, (char)(c)); 3901 p.writePacked(0, 0xFFFFFF00, 0x88); // p.stm = 136 3902 } 3903 } 3904 } 3905 3906 /** 3907 * Labels LONG_ASTORE tree node 3908 * @param p node to label 3909 */ 3910 private static void label_LONG_ASTORE(AbstractBURS_TreeNode p) { 3911 p.initCost(); 3912 AbstractBURS_TreeNode lchild, rchild; 3913 lchild = p.getChild1(); 3914 rchild = p.getChild2(); 3915 label(lchild); 3916 label(rchild); 3917 int c; 3918 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 3919 rchild.getOpcode() == OTHER_OPERAND_opcode 3920 ) { 3921 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 30; 3922 if(BURS.DEBUG) trace(p, 354, c + 0, p.getCost(1) /* stm */); 3923 if (c < p.getCost(1) /* stm */) { 3924 p.setCost(1 /* stm */, (char)(c)); 3925 p.writePacked(0, 0xFFFFFF00, 0x21); // p.stm = 33 3926 } 3927 } 3928 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 3929 rchild.getOpcode() == OTHER_OPERAND_opcode 3930 ) { 3931 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 3932 if(BURS.DEBUG) trace(p, 355, c + 0, p.getCost(1) /* stm */); 3933 if (c < p.getCost(1) /* stm */) { 3934 p.setCost(1 /* stm */, (char)(c)); 3935 p.writePacked(0, 0xFFFFFF00, 0x22); // p.stm = 34 3936 } 3937 } 3938 if ( // stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 3939 rchild.getOpcode() == OTHER_OPERAND_opcode 3940 ) { 3941 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 3942 if(BURS.DEBUG) trace(p, 356, c + 0, p.getCost(1) /* stm */); 3943 if (c < p.getCost(1) /* stm */) { 3944 p.setCost(1 /* stm */, (char)(c)); 3945 p.writePacked(0, 0xFFFFFF00, 0x23); // p.stm = 35 3946 } 3947 } 3948 if ( // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 3949 lchild.getOpcode() == LONG_CONSTANT_opcode && 3950 rchild.getOpcode() == OTHER_OPERAND_opcode 3951 ) { 3952 c = STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 26; 3953 if(BURS.DEBUG) trace(p, 405, c + 0, p.getCost(1) /* stm */); 3954 if (c < p.getCost(1) /* stm */) { 3955 p.setCost(1 /* stm */, (char)(c)); 3956 p.writePacked(0, 0xFFFFFF00, 0x24); // p.stm = 36 3957 } 3958 } 3959 if ( // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 3960 lchild.getOpcode() == LONG_CONSTANT_opcode && 3961 rchild.getOpcode() == OTHER_OPERAND_opcode 3962 ) { 3963 c = STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 26; 3964 if(BURS.DEBUG) trace(p, 406, c + 0, p.getCost(1) /* stm */); 3965 if (c < p.getCost(1) /* stm */) { 3966 p.setCost(1 /* stm */, (char)(c)); 3967 p.writePacked(0, 0xFFFFFF00, 0x25); // p.stm = 37 3968 } 3969 } 3970 if ( // stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 3971 lchild.getOpcode() == LONG_ADD_opcode && 3972 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 3973 rchild.getOpcode() == OTHER_OPERAND_opcode 3974 ) { 3975 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), 34); 3976 if(BURS.DEBUG) trace(p, 493, c + 0, p.getCost(1) /* stm */); 3977 if (c < p.getCost(1) /* stm */) { 3978 p.setCost(1 /* stm */, (char)(c)); 3979 p.writePacked(0, 0xFFFFFF00, 0x8B); // p.stm = 139 3980 } 3981 } 3982 if ( // stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 3983 lchild.getOpcode() == LONG_ADD_opcode && 3984 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 3985 rchild.getOpcode() == OTHER_OPERAND_opcode 3986 ) { 3987 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), 34); 3988 if(BURS.DEBUG) trace(p, 513, c + 0, p.getCost(1) /* stm */); 3989 if (c < p.getCost(1) /* stm */) { 3990 p.setCost(1 /* stm */, (char)(c)); 3991 p.writePacked(0, 0xFFFFFF00, 0x8C); // p.stm = 140 3992 } 3993 } 3994 if ( // stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 3995 lchild.getOpcode() == LONG_AND_opcode && 3996 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 3997 rchild.getOpcode() == OTHER_OPERAND_opcode 3998 ) { 3999 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), 34); 4000 if(BURS.DEBUG) trace(p, 495, c + 0, p.getCost(1) /* stm */); 4001 if (c < p.getCost(1) /* stm */) { 4002 p.setCost(1 /* stm */, (char)(c)); 4003 p.writePacked(0, 0xFFFFFF00, 0x8F); // p.stm = 143 4004 } 4005 } 4006 if ( // stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4007 lchild.getOpcode() == LONG_AND_opcode && 4008 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4009 rchild.getOpcode() == OTHER_OPERAND_opcode 4010 ) { 4011 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), 34); 4012 if(BURS.DEBUG) trace(p, 515, c + 0, p.getCost(1) /* stm */); 4013 if (c < p.getCost(1) /* stm */) { 4014 p.setCost(1 /* stm */, (char)(c)); 4015 p.writePacked(0, 0xFFFFFF00, 0x90); // p.stm = 144 4016 } 4017 } 4018 if ( // stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4019 lchild.getOpcode() == LONG_NEG_opcode && 4020 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4021 rchild.getOpcode() == OTHER_OPERAND_opcode 4022 ) { 4023 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), 34); 4024 if(BURS.DEBUG) trace(p, 463, c + 0, p.getCost(1) /* stm */); 4025 if (c < p.getCost(1) /* stm */) { 4026 p.setCost(1 /* stm */, (char)(c)); 4027 p.writePacked(0, 0xFFFFFF00, 0x93); // p.stm = 147 4028 } 4029 } 4030 if ( // stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4031 lchild.getOpcode() == LONG_NOT_opcode && 4032 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4033 rchild.getOpcode() == OTHER_OPERAND_opcode 4034 ) { 4035 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), 34); 4036 if(BURS.DEBUG) trace(p, 465, c + 0, p.getCost(1) /* stm */); 4037 if (c < p.getCost(1) /* stm */) { 4038 p.setCost(1 /* stm */, (char)(c)); 4039 p.writePacked(0, 0xFFFFFF00, 0x95); // p.stm = 149 4040 } 4041 } 4042 if ( // stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4043 lchild.getOpcode() == LONG_OR_opcode && 4044 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4045 rchild.getOpcode() == OTHER_OPERAND_opcode 4046 ) { 4047 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), 34); 4048 if(BURS.DEBUG) trace(p, 497, 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, 0x98); // p.stm = 152 4052 } 4053 } 4054 if ( // stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4055 lchild.getOpcode() == LONG_OR_opcode && 4056 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4057 rchild.getOpcode() == OTHER_OPERAND_opcode 4058 ) { 4059 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), 34); 4060 if(BURS.DEBUG) trace(p, 517, c + 0, p.getCost(1) /* stm */); 4061 if (c < p.getCost(1) /* stm */) { 4062 p.setCost(1 /* stm */, (char)(c)); 4063 p.writePacked(0, 0xFFFFFF00, 0x99); // p.stm = 153 4064 } 4065 } 4066 if ( // stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4067 lchild.getOpcode() == LONG_SUB_opcode && 4068 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4069 rchild.getOpcode() == OTHER_OPERAND_opcode 4070 ) { 4071 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), 34); 4072 if(BURS.DEBUG) trace(p, 499, c + 0, p.getCost(1) /* stm */); 4073 if (c < p.getCost(1) /* stm */) { 4074 p.setCost(1 /* stm */, (char)(c)); 4075 p.writePacked(0, 0xFFFFFF00, 0x9D); // p.stm = 157 4076 } 4077 } 4078 if ( // stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 4079 lchild.getOpcode() == LONG_XOR_opcode && 4080 lchild.getChild1().getOpcode() == LONG_ALOAD_opcode && 4081 rchild.getOpcode() == OTHER_OPERAND_opcode 4082 ) { 4083 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), 34); 4084 if(BURS.DEBUG) trace(p, 501, c + 0, p.getCost(1) /* stm */); 4085 if (c < p.getCost(1) /* stm */) { 4086 p.setCost(1 /* stm */, (char)(c)); 4087 p.writePacked(0, 0xFFFFFF00, 0xA0); // p.stm = 160 4088 } 4089 } 4090 if ( // stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 4091 lchild.getOpcode() == LONG_XOR_opcode && 4092 lchild.getChild2().getOpcode() == LONG_ALOAD_opcode && 4093 rchild.getOpcode() == OTHER_OPERAND_opcode 4094 ) { 4095 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), 34); 4096 if(BURS.DEBUG) trace(p, 519, c + 0, p.getCost(1) /* stm */); 4097 if (c < p.getCost(1) /* stm */) { 4098 p.setCost(1 /* stm */, (char)(c)); 4099 p.writePacked(0, 0xFFFFFF00, 0xA1); // p.stm = 161 4100 } 4101 } 4102 if ( // stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 4103 rchild.getOpcode() == OTHER_OPERAND_opcode 4104 ) { 4105 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 4106 if(BURS.DEBUG) trace(p, 401, c + 0, p.getCost(1) /* stm */); 4107 if (c < p.getCost(1) /* stm */) { 4108 p.setCost(1 /* stm */, (char)(c)); 4109 p.writePacked(0, 0xFFFFFF00, 0xBB); // p.stm = 187 4110 } 4111 } 4112 if ( // stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 4113 rchild.getOpcode() == OTHER_OPERAND_opcode 4114 ) { 4115 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 4116 if(BURS.DEBUG) trace(p, 402, 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, 0xBC); // p.stm = 188 4120 } 4121 } 4122 } 4123 4124 /** 4125 * Labels FLOAT_ASTORE tree node 4126 * @param p node to label 4127 */ 4128 private static void label_FLOAT_ASTORE(AbstractBURS_TreeNode p) { 4129 p.initCost(); 4130 AbstractBURS_TreeNode lchild, rchild; 4131 lchild = p.getChild1(); 4132 rchild = p.getChild2(); 4133 label(lchild); 4134 label(rchild); 4135 int c; 4136 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 4137 rchild.getOpcode() == OTHER_OPERAND_opcode 4138 ) { 4139 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4140 if(BURS.DEBUG) trace(p, 388, 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, 0xAF); // p.stm = 175 4144 } 4145 } 4146 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 4147 rchild.getOpcode() == OTHER_OPERAND_opcode 4148 ) { 4149 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4150 if(BURS.DEBUG) trace(p, 389, c + 0, p.getCost(1) /* stm */); 4151 if (c < p.getCost(1) /* stm */) { 4152 p.setCost(1 /* stm */, (char)(c)); 4153 p.writePacked(0, 0xFFFFFF00, 0xB0); // p.stm = 176 4154 } 4155 } 4156 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 4157 rchild.getOpcode() == OTHER_OPERAND_opcode 4158 ) { 4159 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4160 if(BURS.DEBUG) trace(p, 390, c + 0, p.getCost(1) /* stm */); 4161 if (c < p.getCost(1) /* stm */) { 4162 p.setCost(1 /* stm */, (char)(c)); 4163 p.writePacked(0, 0xFFFFFF00, 0xB1); // p.stm = 177 4164 } 4165 } 4166 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 4167 rchild.getOpcode() == OTHER_OPERAND_opcode 4168 ) { 4169 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4170 if(BURS.DEBUG) trace(p, 391, c + 0, p.getCost(1) /* stm */); 4171 if (c < p.getCost(1) /* stm */) { 4172 p.setCost(1 /* stm */, (char)(c)); 4173 p.writePacked(0, 0xFFFFFF00, 0xB2); // p.stm = 178 4174 } 4175 } 4176 if ( // stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 4177 rchild.getOpcode() == OTHER_OPERAND_opcode 4178 ) { 4179 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 12; 4180 if(BURS.DEBUG) trace(p, 392, c + 0, p.getCost(1) /* stm */); 4181 if (c < p.getCost(1) /* stm */) { 4182 p.setCost(1 /* stm */, (char)(c)); 4183 p.writePacked(0, 0xFFFFFF00, 0xB3); // p.stm = 179 4184 } 4185 } 4186 } 4187 4188 /** 4189 * Labels DOUBLE_ASTORE tree node 4190 * @param p node to label 4191 */ 4192 private static void label_DOUBLE_ASTORE(AbstractBURS_TreeNode p) { 4193 p.initCost(); 4194 AbstractBURS_TreeNode lchild, rchild; 4195 lchild = p.getChild1(); 4196 rchild = p.getChild2(); 4197 label(lchild); 4198 label(rchild); 4199 int c; 4200 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 4201 rchild.getOpcode() == OTHER_OPERAND_opcode 4202 ) { 4203 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4204 if(BURS.DEBUG) trace(p, 379, c + 0, p.getCost(1) /* stm */); 4205 if (c < p.getCost(1) /* stm */) { 4206 p.setCost(1 /* stm */, (char)(c)); 4207 p.writePacked(0, 0xFFFFFF00, 0xA6); // p.stm = 166 4208 } 4209 } 4210 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 4211 rchild.getOpcode() == OTHER_OPERAND_opcode 4212 ) { 4213 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 4214 if(BURS.DEBUG) trace(p, 380, c + 0, p.getCost(1) /* stm */); 4215 if (c < p.getCost(1) /* stm */) { 4216 p.setCost(1 /* stm */, (char)(c)); 4217 p.writePacked(0, 0xFFFFFF00, 0xA7); // p.stm = 167 4218 } 4219 } 4220 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 4221 rchild.getOpcode() == OTHER_OPERAND_opcode 4222 ) { 4223 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4224 if(BURS.DEBUG) trace(p, 381, c + 0, p.getCost(1) /* stm */); 4225 if (c < p.getCost(1) /* stm */) { 4226 p.setCost(1 /* stm */, (char)(c)); 4227 p.writePacked(0, 0xFFFFFF00, 0xA8); // p.stm = 168 4228 } 4229 } 4230 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 4231 rchild.getOpcode() == OTHER_OPERAND_opcode 4232 ) { 4233 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 4234 if(BURS.DEBUG) trace(p, 382, c + 0, p.getCost(1) /* stm */); 4235 if (c < p.getCost(1) /* stm */) { 4236 p.setCost(1 /* stm */, (char)(c)); 4237 p.writePacked(0, 0xFFFFFF00, 0xA9); // p.stm = 169 4238 } 4239 } 4240 if ( // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 4241 rchild.getOpcode() == OTHER_OPERAND_opcode 4242 ) { 4243 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 12; 4244 if(BURS.DEBUG) trace(p, 383, c + 0, p.getCost(1) /* stm */); 4245 if (c < p.getCost(1) /* stm */) { 4246 p.setCost(1 /* stm */, (char)(c)); 4247 p.writePacked(0, 0xFFFFFF00, 0xAA); // p.stm = 170 4248 } 4249 } 4250 } 4251 4252 /** 4253 * Labels BYTE_ASTORE tree node 4254 * @param p node to label 4255 */ 4256 private static void label_BYTE_ASTORE(AbstractBURS_TreeNode p) { 4257 p.initCost(); 4258 AbstractBURS_TreeNode lchild, rchild; 4259 lchild = p.getChild1(); 4260 rchild = p.getChild2(); 4261 label(lchild); 4262 label(rchild); 4263 int c; 4264 if ( // stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 4265 rchild.getOpcode() == OTHER_OPERAND_opcode 4266 ) { 4267 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4268 if(BURS.DEBUG) trace(p, 358, c + 0, p.getCost(1) /* stm */); 4269 if (c < p.getCost(1) /* stm */) { 4270 p.setCost(1 /* stm */, (char)(c)); 4271 p.writePacked(0, 0xFFFFFF00, 0x40); // p.stm = 64 4272 } 4273 } 4274 if ( // stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 4275 lchild.getOpcode() == BOOLEAN_NOT_opcode && 4276 lchild.getChild1().getOpcode() == UBYTE_ALOAD_opcode && 4277 rchild.getOpcode() == OTHER_OPERAND_opcode 4278 ) { 4279 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); 4280 if(BURS.DEBUG) trace(p, 451, c + 0, p.getCost(1) /* stm */); 4281 if (c < p.getCost(1) /* stm */) { 4282 p.setCost(1 /* stm */, (char)(c)); 4283 p.writePacked(0, 0xFFFFFF00, 0x42); // p.stm = 66 4284 } 4285 } 4286 if ( // stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) 4287 rchild.getOpcode() == OTHER_OPERAND_opcode 4288 ) { 4289 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4290 if(BURS.DEBUG) trace(p, 361, c + 0, p.getCost(1) /* stm */); 4291 if (c < p.getCost(1) /* stm */) { 4292 p.setCost(1 /* stm */, (char)(c)); 4293 p.writePacked(0, 0xFFFFFF00, 0x45); // p.stm = 69 4294 } 4295 } 4296 if ( // stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) 4297 rchild.getOpcode() == OTHER_OPERAND_opcode 4298 ) { 4299 c = STATE(lchild).getCost(20 /* load8 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 4300 if(BURS.DEBUG) trace(p, 362, c + 0, p.getCost(1) /* stm */); 4301 if (c < p.getCost(1) /* stm */) { 4302 p.setCost(1 /* stm */, (char)(c)); 4303 p.writePacked(0, 0xFFFFFF00, 0x46); // p.stm = 70 4304 } 4305 } 4306 if ( // stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 4307 lchild.getOpcode() == INT_2BYTE_opcode && 4308 rchild.getOpcode() == OTHER_OPERAND_opcode 4309 ) { 4310 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4311 if(BURS.DEBUG) trace(p, 475, c + 0, p.getCost(1) /* stm */); 4312 if (c < p.getCost(1) /* stm */) { 4313 p.setCost(1 /* stm */, (char)(c)); 4314 p.writePacked(0, 0xFFFFFF00, 0x48); // p.stm = 72 4315 } 4316 } 4317 } 4318 4319 /** 4320 * Labels SHORT_ASTORE tree node 4321 * @param p node to label 4322 */ 4323 private static void label_SHORT_ASTORE(AbstractBURS_TreeNode p) { 4324 p.initCost(); 4325 AbstractBURS_TreeNode lchild, rchild; 4326 lchild = p.getChild1(); 4327 rchild = p.getChild2(); 4328 label(lchild); 4329 label(rchild); 4330 int c; 4331 if ( // stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 4332 rchild.getOpcode() == OTHER_OPERAND_opcode 4333 ) { 4334 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4335 if(BURS.DEBUG) trace(p, 346, c + 0, p.getCost(1) /* stm */); 4336 if (c < p.getCost(1) /* stm */) { 4337 p.setCost(1 /* stm */, (char)(c)); 4338 p.writePacked(0, 0xFFFFFF00, 0x19); // p.stm = 25 4339 } 4340 } 4341 if ( // stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 4342 rchild.getOpcode() == OTHER_OPERAND_opcode 4343 ) { 4344 c = STATE(lchild).getCost(14 /* load16 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 4345 if(BURS.DEBUG) trace(p, 347, c + 0, p.getCost(1) /* stm */); 4346 if (c < p.getCost(1) /* stm */) { 4347 p.setCost(1 /* stm */, (char)(c)); 4348 p.writePacked(0, 0xFFFFFF00, 0x1A); // p.stm = 26 4349 } 4350 } 4351 if ( // stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 4352 rchild.getOpcode() == OTHER_OPERAND_opcode 4353 ) { 4354 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 10; 4355 if(BURS.DEBUG) trace(p, 348, c + 0, p.getCost(1) /* stm */); 4356 if (c < p.getCost(1) /* stm */) { 4357 p.setCost(1 /* stm */, (char)(c)); 4358 p.writePacked(0, 0xFFFFFF00, 0x1B); // p.stm = 27 4359 } 4360 } 4361 if ( // stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 4362 lchild.getOpcode() == INT_2SHORT_opcode && 4363 rchild.getOpcode() == OTHER_OPERAND_opcode 4364 ) { 4365 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4366 if(BURS.DEBUG) trace(p, 477, c + 0, p.getCost(1) /* stm */); 4367 if (c < p.getCost(1) /* stm */) { 4368 p.setCost(1 /* stm */, (char)(c)); 4369 p.writePacked(0, 0xFFFFFF00, 0x4A); // p.stm = 74 4370 } 4371 } 4372 if ( // stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 4373 lchild.getOpcode() == INT_2USHORT_opcode && 4374 rchild.getOpcode() == OTHER_OPERAND_opcode 4375 ) { 4376 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 4377 if(BURS.DEBUG) trace(p, 479, c + 0, p.getCost(1) /* stm */); 4378 if (c < p.getCost(1) /* stm */) { 4379 p.setCost(1 /* stm */, (char)(c)); 4380 p.writePacked(0, 0xFFFFFF00, 0x4C); // p.stm = 76 4381 } 4382 } 4383 } 4384 4385 /** 4386 * Labels INT_IFCMP tree node 4387 * @param p node to label 4388 */ 4389 private static void label_INT_IFCMP(AbstractBURS_TreeNode p) { 4390 p.initCost(); 4391 AbstractBURS_TreeNode lchild, rchild; 4392 lchild = p.getChild1(); 4393 rchild = p.getChild2(); 4394 label(lchild); 4395 label(rchild); 4396 int c; 4397 if ( // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4398 lchild.getOpcode() == ATTEMPT_INT_opcode && 4399 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4400 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4401 rchild.getOpcode() == INT_CONSTANT_opcode 4402 ) { 4403 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); 4404 if(BURS.DEBUG) trace(p, 428, c + 0, p.getCost(1) /* stm */); 4405 if (c < p.getCost(1) /* stm */) { 4406 p.setCost(1 /* stm */, (char)(c)); 4407 p.writePacked(0, 0xFFFFFF00, 0x31); // p.stm = 49 4408 } 4409 } 4410 if ( // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4411 lchild.getOpcode() == ATTEMPT_INT_opcode && 4412 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4413 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4414 rchild.getOpcode() == INT_CONSTANT_opcode 4415 ) { 4416 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4417 if(BURS.DEBUG) trace(p, 429, c + 0, p.getCost(1) /* stm */); 4418 if (c < p.getCost(1) /* stm */) { 4419 p.setCost(1 /* stm */, (char)(c)); 4420 p.writePacked(0, 0xFFFFFF00, 0x32); // p.stm = 50 4421 } 4422 } 4423 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4424 lchild.getOpcode() == ATTEMPT_INT_opcode && 4425 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4426 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4427 rchild.getOpcode() == INT_CONSTANT_opcode 4428 ) { 4429 c = STATE(lchild.getChild1()).getCost(16 /* 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); 4430 if(BURS.DEBUG) trace(p, 430, 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, 0x33); // p.stm = 51 4434 } 4435 } 4436 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4437 lchild.getOpcode() == ATTEMPT_INT_opcode && 4438 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4439 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4440 rchild.getOpcode() == INT_CONSTANT_opcode 4441 ) { 4442 c = STATE(lchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(17 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4443 if(BURS.DEBUG) trace(p, 431, c + 0, p.getCost(1) /* stm */); 4444 if (c < p.getCost(1) /* stm */) { 4445 p.setCost(1 /* stm */, (char)(c)); 4446 p.writePacked(0, 0xFFFFFF00, 0x34); // p.stm = 52 4447 } 4448 } 4449 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4450 lchild.getOpcode() == ATTEMPT_INT_opcode && 4451 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4452 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4453 rchild.getOpcode() == INT_CONSTANT_opcode 4454 ) { 4455 c = STATE(lchild.getChild1()).getCost(17 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4456 if(BURS.DEBUG) trace(p, 432, c + 0, p.getCost(1) /* stm */); 4457 if (c < p.getCost(1) /* stm */) { 4458 p.setCost(1 /* stm */, (char)(c)); 4459 p.writePacked(0, 0xFFFFFF00, 0x35); // p.stm = 53 4460 } 4461 } 4462 if ( // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4463 lchild.getOpcode() == ATTEMPT_INT_opcode && 4464 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4465 lchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 4466 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4467 rchild.getOpcode() == INT_CONSTANT_opcode 4468 ) { 4469 c = STATE(lchild.getChild1()).getCost(15 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p), 54); 4470 if(BURS.DEBUG) trace(p, 438, c + 0, p.getCost(1) /* stm */); 4471 if (c < p.getCost(1) /* stm */) { 4472 p.setCost(1 /* stm */, (char)(c)); 4473 p.writePacked(0, 0xFFFFFF00, 0x36); // p.stm = 54 4474 } 4475 } 4476 if ( // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4477 lchild.getOpcode() == ATTEMPT_INT_opcode && 4478 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 4479 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4480 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4481 rchild.getOpcode() == INT_CONSTANT_opcode 4482 ) { 4483 c = STATE(lchild.getChild2().getChild1()).getCost(15 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isZERO(VR(p),54); 4484 if(BURS.DEBUG) trace(p, 440, c + 0, p.getCost(1) /* stm */); 4485 if (c < p.getCost(1) /* stm */) { 4486 p.setCost(1 /* stm */, (char)(c)); 4487 p.writePacked(0, 0xFFFFFF00, 0x37); // p.stm = 55 4488 } 4489 } 4490 if ( // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4491 lchild.getOpcode() == ATTEMPT_INT_opcode && 4492 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4493 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4494 rchild.getOpcode() == INT_CONSTANT_opcode 4495 ) { 4496 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); 4497 if(BURS.DEBUG) trace(p, 433, c + 0, p.getCost(1) /* stm */); 4498 if (c < p.getCost(1) /* stm */) { 4499 p.setCost(1 /* stm */, (char)(c)); 4500 p.writePacked(0, 0xFFFFFF00, 0x38); // p.stm = 56 4501 } 4502 } 4503 if ( // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4504 lchild.getOpcode() == ATTEMPT_INT_opcode && 4505 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4506 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4507 rchild.getOpcode() == INT_CONSTANT_opcode 4508 ) { 4509 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4510 if(BURS.DEBUG) trace(p, 434, c + 0, p.getCost(1) /* stm */); 4511 if (c < p.getCost(1) /* stm */) { 4512 p.setCost(1 /* stm */, (char)(c)); 4513 p.writePacked(0, 0xFFFFFF00, 0x39); // p.stm = 57 4514 } 4515 } 4516 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4517 lchild.getOpcode() == ATTEMPT_INT_opcode && 4518 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4519 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4520 rchild.getOpcode() == INT_CONSTANT_opcode 4521 ) { 4522 c = STATE(lchild.getChild1()).getCost(16 /* 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); 4523 if(BURS.DEBUG) trace(p, 435, c + 0, p.getCost(1) /* stm */); 4524 if (c < p.getCost(1) /* stm */) { 4525 p.setCost(1 /* stm */, (char)(c)); 4526 p.writePacked(0, 0xFFFFFF00, 0x3A); // p.stm = 58 4527 } 4528 } 4529 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4530 lchild.getOpcode() == ATTEMPT_INT_opcode && 4531 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4532 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4533 rchild.getOpcode() == INT_CONSTANT_opcode 4534 ) { 4535 c = STATE(lchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild1()).getCost(17 /* address1reg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4536 if(BURS.DEBUG) trace(p, 436, c + 0, p.getCost(1) /* stm */); 4537 if (c < p.getCost(1) /* stm */) { 4538 p.setCost(1 /* stm */, (char)(c)); 4539 p.writePacked(0, 0xFFFFFF00, 0x3B); // p.stm = 59 4540 } 4541 } 4542 if ( // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4543 lchild.getOpcode() == ATTEMPT_INT_opcode && 4544 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4545 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4546 rchild.getOpcode() == INT_CONSTANT_opcode 4547 ) { 4548 c = STATE(lchild.getChild1()).getCost(17 /* address1reg */) + STATE(lchild.getChild2().getChild1()).getCost(16 /* address1scaledreg */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4549 if(BURS.DEBUG) trace(p, 437, c + 0, p.getCost(1) /* stm */); 4550 if (c < p.getCost(1) /* stm */) { 4551 p.setCost(1 /* stm */, (char)(c)); 4552 p.writePacked(0, 0xFFFFFF00, 0x3C); // p.stm = 60 4553 } 4554 } 4555 if ( // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4556 lchild.getOpcode() == ATTEMPT_INT_opcode && 4557 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4558 lchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 4559 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4560 rchild.getOpcode() == INT_CONSTANT_opcode 4561 ) { 4562 c = STATE(lchild.getChild1()).getCost(15 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4563 if(BURS.DEBUG) trace(p, 439, c + 0, p.getCost(1) /* stm */); 4564 if (c < p.getCost(1) /* stm */) { 4565 p.setCost(1 /* stm */, (char)(c)); 4566 p.writePacked(0, 0xFFFFFF00, 0x3D); // p.stm = 61 4567 } 4568 } 4569 if ( // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 4570 lchild.getOpcode() == ATTEMPT_INT_opcode && 4571 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 4572 lchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 4573 lchild.getChild2().getChild2().getOpcode() == OTHER_OPERAND_opcode && 4574 rchild.getOpcode() == INT_CONSTANT_opcode 4575 ) { 4576 c = STATE(lchild.getChild2().getChild1()).getCost(15 /* address */) + STATE(lchild.getChild2().getChild2().getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2().getChild2().getChild2()).getCost(7 /* riv */) + isONE(VR(p), 54); 4577 if(BURS.DEBUG) trace(p, 441, c + 0, p.getCost(1) /* stm */); 4578 if (c < p.getCost(1) /* stm */) { 4579 p.setCost(1 /* stm */, (char)(c)); 4580 p.writePacked(0, 0xFFFFFF00, 0x3E); // p.stm = 62 4581 } 4582 } 4583 // stm: INT_IFCMP(r,riv) 4584 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 26; 4585 if(BURS.DEBUG) trace(p, 83, c + 0, p.getCost(1) /* stm */); 4586 if (c < p.getCost(1) /* stm */) { 4587 p.setCost(1 /* stm */, (char)(c)); 4588 p.writePacked(0, 0xFFFFFF00, 0x55); // p.stm = 85 4589 } 4590 if ( // stm: INT_IFCMP(r,INT_CONSTANT) 4591 rchild.getOpcode() == INT_CONSTANT_opcode 4592 ) { 4593 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(IfCmp.getCond(P(p))) ? 24:INFINITE); 4594 if(BURS.DEBUG) trace(p, 259, c + 0, p.getCost(1) /* stm */); 4595 if (c < p.getCost(1) /* stm */) { 4596 p.setCost(1 /* stm */, (char)(c)); 4597 p.writePacked(0, 0xFFFFFF00, 0x56); // p.stm = 86 4598 } 4599 } 4600 if ( // stm: INT_IFCMP(load8,INT_CONSTANT) 4601 rchild.getOpcode() == INT_CONSTANT_opcode 4602 ) { 4603 c = STATE(lchild).getCost(20 /* load8 */) + FITS(IfCmp.getVal2(P(p)), 8, 28); 4604 if(BURS.DEBUG) trace(p, 260, c + 0, p.getCost(1) /* stm */); 4605 if (c < p.getCost(1) /* stm */) { 4606 p.setCost(1 /* stm */, (char)(c)); 4607 p.writePacked(0, 0xFFFFFF00, 0x57); // p.stm = 87 4608 } 4609 } 4610 // stm: INT_IFCMP(uload8,r) 4611 c = STATE(lchild).getCost(11 /* uload8 */) + STATE(rchild).getCost(2 /* r */) + 28; 4612 if(BURS.DEBUG) trace(p, 84, c + 0, p.getCost(1) /* stm */); 4613 if (c < p.getCost(1) /* stm */) { 4614 p.setCost(1 /* stm */, (char)(c)); 4615 p.writePacked(0, 0xFFFFFF00, 0x58); // p.stm = 88 4616 } 4617 // stm: INT_IFCMP(r,uload8) 4618 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(11 /* uload8 */) + 28; 4619 if(BURS.DEBUG) trace(p, 85, c + 0, p.getCost(1) /* stm */); 4620 if (c < p.getCost(1) /* stm */) { 4621 p.setCost(1 /* stm */, (char)(c)); 4622 p.writePacked(0, 0xFFFFFF00, 0x59); // p.stm = 89 4623 } 4624 if ( // stm: INT_IFCMP(sload16,INT_CONSTANT) 4625 rchild.getOpcode() == INT_CONSTANT_opcode 4626 ) { 4627 c = STATE(lchild).getCost(21 /* sload16 */) + FITS(IfCmp.getVal2(P(p)), 8, 28); 4628 if(BURS.DEBUG) trace(p, 261, c + 0, p.getCost(1) /* stm */); 4629 if (c < p.getCost(1) /* stm */) { 4630 p.setCost(1 /* stm */, (char)(c)); 4631 p.writePacked(0, 0xFFFFFF00, 0x5A); // p.stm = 90 4632 } 4633 } 4634 // stm: INT_IFCMP(load32,riv) 4635 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 28; 4636 if(BURS.DEBUG) trace(p, 86, c + 0, p.getCost(1) /* stm */); 4637 if (c < p.getCost(1) /* stm */) { 4638 p.setCost(1 /* stm */, (char)(c)); 4639 p.writePacked(0, 0xFFFFFF00, 0x5B); // p.stm = 91 4640 } 4641 // stm: INT_IFCMP(r,load32) 4642 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 28; 4643 if(BURS.DEBUG) trace(p, 87, c + 0, p.getCost(1) /* stm */); 4644 if (c < p.getCost(1) /* stm */) { 4645 p.setCost(1 /* stm */, (char)(c)); 4646 p.writePacked(0, 0xFFFFFF00, 0x5C); // p.stm = 92 4647 } 4648 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 4649 rchild.getOpcode() == INT_CONSTANT_opcode 4650 ) { 4651 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); 4652 if(BURS.DEBUG) trace(p, 262, c + 0, p.getCost(1) /* stm */); 4653 if (c < p.getCost(1) /* stm */) { 4654 p.setCost(1 /* stm */, (char)(c)); 4655 p.writePacked(0, 0xFFFFFF00, 0x5D); // p.stm = 93 4656 } 4657 } 4658 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 4659 rchild.getOpcode() == INT_CONSTANT_opcode 4660 ) { 4661 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); 4662 if(BURS.DEBUG) trace(p, 263, c + 0, p.getCost(1) /* stm */); 4663 if (c < p.getCost(1) /* stm */) { 4664 p.setCost(1 /* stm */, (char)(c)); 4665 p.writePacked(0, 0xFFFFFF00, 0x5E); // p.stm = 94 4666 } 4667 } 4668 if ( // stm: INT_IFCMP(cz,INT_CONSTANT) 4669 rchild.getOpcode() == INT_CONSTANT_opcode 4670 ) { 4671 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 11); 4672 if(BURS.DEBUG) trace(p, 264, c + 0, p.getCost(1) /* stm */); 4673 if (c < p.getCost(1) /* stm */) { 4674 p.setCost(1 /* stm */, (char)(c)); 4675 p.writePacked(0, 0xFFFFFF00, 0x5F); // p.stm = 95 4676 } 4677 } 4678 if ( // stm: INT_IFCMP(szp,INT_CONSTANT) 4679 rchild.getOpcode() == INT_CONSTANT_opcode 4680 ) { 4681 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(IfCmp.getCond(P(p)))?11:INFINITE); 4682 if(BURS.DEBUG) trace(p, 265, c + 0, p.getCost(1) /* stm */); 4683 if (c < p.getCost(1) /* stm */) { 4684 p.setCost(1 /* stm */, (char)(c)); 4685 p.writePacked(0, 0xFFFFFF00, 0x60); // p.stm = 96 4686 } 4687 } 4688 if ( // stm: INT_IFCMP(bittest,INT_CONSTANT) 4689 rchild.getOpcode() == INT_CONSTANT_opcode 4690 ) { 4691 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(IfCmp.getCond(P(p))) ? 11 : INFINITE); 4692 if(BURS.DEBUG) trace(p, 266, c + 0, p.getCost(1) /* stm */); 4693 if (c < p.getCost(1) /* stm */) { 4694 p.setCost(1 /* stm */, (char)(c)); 4695 p.writePacked(0, 0xFFFFFF00, 0x61); // p.stm = 97 4696 } 4697 } 4698 } 4699 4700 /** 4701 * Labels INT_IFCMP2 tree node 4702 * @param p node to label 4703 */ 4704 private static void label_INT_IFCMP2(AbstractBURS_TreeNode p) { 4705 p.initCost(); 4706 AbstractBURS_TreeNode lchild, rchild; 4707 lchild = p.getChild1(); 4708 rchild = p.getChild2(); 4709 label(lchild); 4710 label(rchild); 4711 int c; 4712 // stm: INT_IFCMP2(r,riv) 4713 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 26; 4714 if(BURS.DEBUG) trace(p, 88, c + 0, p.getCost(1) /* stm */); 4715 if (c < p.getCost(1) /* stm */) { 4716 p.setCost(1 /* stm */, (char)(c)); 4717 p.writePacked(0, 0xFFFFFF00, 0x62); // p.stm = 98 4718 } 4719 // stm: INT_IFCMP2(load32,riv) 4720 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 28; 4721 if(BURS.DEBUG) trace(p, 89, c + 0, p.getCost(1) /* stm */); 4722 if (c < p.getCost(1) /* stm */) { 4723 p.setCost(1 /* stm */, (char)(c)); 4724 p.writePacked(0, 0xFFFFFF00, 0x63); // p.stm = 99 4725 } 4726 // stm: INT_IFCMP2(riv,load32) 4727 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 28; 4728 if(BURS.DEBUG) trace(p, 90, c + 0, p.getCost(1) /* stm */); 4729 if (c < p.getCost(1) /* stm */) { 4730 p.setCost(1 /* stm */, (char)(c)); 4731 p.writePacked(0, 0xFFFFFF00, 0x64); // p.stm = 100 4732 } 4733 } 4734 4735 /** 4736 * Labels LONG_IFCMP tree node 4737 * @param p node to label 4738 */ 4739 private static void label_LONG_IFCMP(AbstractBURS_TreeNode p) { 4740 p.initCost(); 4741 AbstractBURS_TreeNode lchild, rchild; 4742 lchild = p.getChild1(); 4743 rchild = p.getChild2(); 4744 label(lchild); 4745 label(rchild); 4746 int c; 4747 // stm: LONG_IFCMP(r,rlv) 4748 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 30; 4749 if(BURS.DEBUG) trace(p, 146, c + 0, p.getCost(1) /* stm */); 4750 if (c < p.getCost(1) /* stm */) { 4751 p.setCost(1 /* stm */, (char)(c)); 4752 p.writePacked(0, 0xFFFFFF00, 0x91); // p.stm = 145 4753 } 4754 } 4755 4756 /** 4757 * Labels FLOAT_IFCMP tree node 4758 * @param p node to label 4759 */ 4760 private static void label_FLOAT_IFCMP(AbstractBURS_TreeNode p) { 4761 p.initCost(); 4762 AbstractBURS_TreeNode lchild, rchild; 4763 lchild = p.getChild1(); 4764 rchild = p.getChild2(); 4765 label(lchild); 4766 label(rchild); 4767 int c; 4768 // stm: FLOAT_IFCMP(r,r) 4769 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 4770 if(BURS.DEBUG) trace(p, 200, c + 0, p.getCost(1) /* stm */); 4771 if (c < p.getCost(1) /* stm */) { 4772 p.setCost(1 /* stm */, (char)(c)); 4773 p.writePacked(0, 0xFFFFFF00, 0xB5); // p.stm = 181 4774 } 4775 // stm: FLOAT_IFCMP(r,float_load) 4776 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* float_load */) + 15; 4777 if(BURS.DEBUG) trace(p, 201, c + 0, p.getCost(1) /* stm */); 4778 if (c < p.getCost(1) /* stm */) { 4779 p.setCost(1 /* stm */, (char)(c)); 4780 p.writePacked(0, 0xFFFFFF00, 0xB6); // p.stm = 182 4781 } 4782 // stm: FLOAT_IFCMP(float_load,r) 4783 c = STATE(lchild).getCost(25 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 4784 if(BURS.DEBUG) trace(p, 202, c + 0, p.getCost(1) /* stm */); 4785 if (c < p.getCost(1) /* stm */) { 4786 p.setCost(1 /* stm */, (char)(c)); 4787 p.writePacked(0, 0xFFFFFF00, 0xB7); // p.stm = 183 4788 } 4789 } 4790 4791 /** 4792 * Labels DOUBLE_IFCMP tree node 4793 * @param p node to label 4794 */ 4795 private static void label_DOUBLE_IFCMP(AbstractBURS_TreeNode p) { 4796 p.initCost(); 4797 AbstractBURS_TreeNode lchild, rchild; 4798 lchild = p.getChild1(); 4799 rchild = p.getChild2(); 4800 label(lchild); 4801 label(rchild); 4802 int c; 4803 // stm: DOUBLE_IFCMP(r,r) 4804 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 4805 if(BURS.DEBUG) trace(p, 203, c + 0, p.getCost(1) /* stm */); 4806 if (c < p.getCost(1) /* stm */) { 4807 p.setCost(1 /* stm */, (char)(c)); 4808 p.writePacked(0, 0xFFFFFF00, 0xB8); // p.stm = 184 4809 } 4810 // stm: DOUBLE_IFCMP(r,double_load) 4811 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* double_load */) + 15; 4812 if(BURS.DEBUG) trace(p, 204, c + 0, p.getCost(1) /* stm */); 4813 if (c < p.getCost(1) /* stm */) { 4814 p.setCost(1 /* stm */, (char)(c)); 4815 p.writePacked(0, 0xFFFFFF00, 0xB9); // p.stm = 185 4816 } 4817 // stm: DOUBLE_IFCMP(double_load,r) 4818 c = STATE(lchild).getCost(26 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 4819 if(BURS.DEBUG) trace(p, 205, c + 0, p.getCost(1) /* stm */); 4820 if (c < p.getCost(1) /* stm */) { 4821 p.setCost(1 /* stm */, (char)(c)); 4822 p.writePacked(0, 0xFFFFFF00, 0xBA); // p.stm = 186 4823 } 4824 } 4825 4826 /** 4827 * Labels UNINT_BEGIN tree node 4828 * @param p node to label 4829 */ 4830 private static void label_UNINT_BEGIN(AbstractBURS_TreeNode p) { 4831 p.initCost(); 4832 // stm: UNINT_BEGIN 4833 if(BURS.DEBUG) trace(p, 26, 10 + 0, p.getCost(1) /* stm */); 4834 if (10 < p.getCost(1) /* stm */) { 4835 p.setCost(1 /* stm */, (char)(10)); 4836 p.writePacked(0, 0xFFFFFF00, 0x3); // p.stm = 3 4837 } 4838 } 4839 4840 /** 4841 * Labels UNINT_END tree node 4842 * @param p node to label 4843 */ 4844 private static void label_UNINT_END(AbstractBURS_TreeNode p) { 4845 p.initCost(); 4846 // stm: UNINT_END 4847 if(BURS.DEBUG) trace(p, 27, 10 + 0, p.getCost(1) /* stm */); 4848 if (10 < p.getCost(1) /* stm */) { 4849 p.setCost(1 /* stm */, (char)(10)); 4850 p.writePacked(0, 0xFFFFFF00, 0x4); // p.stm = 4 4851 } 4852 } 4853 4854 /** 4855 * Labels FENCE tree node 4856 * @param p node to label 4857 */ 4858 private static void label_FENCE(AbstractBURS_TreeNode p) { 4859 p.initCost(); 4860 // stm: FENCE 4861 if(BURS.DEBUG) trace(p, 42, 11 + 0, p.getCost(1) /* stm */); 4862 if (11 < p.getCost(1) /* stm */) { 4863 p.setCost(1 /* stm */, (char)(11)); 4864 p.writePacked(0, 0xFFFFFF00, 0x2A); // p.stm = 42 4865 } 4866 } 4867 4868 /** 4869 * Labels READ_CEILING tree node 4870 * @param p node to label 4871 */ 4872 private static void label_READ_CEILING(AbstractBURS_TreeNode p) { 4873 p.initCost(); 4874 // stm: READ_CEILING 4875 if(BURS.DEBUG) trace(p, 41, 11 + 0, p.getCost(1) /* stm */); 4876 if (11 < p.getCost(1) /* stm */) { 4877 p.setCost(1 /* stm */, (char)(11)); 4878 p.writePacked(0, 0xFFFFFF00, 0x29); // p.stm = 41 4879 } 4880 } 4881 4882 /** 4883 * Labels WRITE_FLOOR tree node 4884 * @param p node to label 4885 */ 4886 private static void label_WRITE_FLOOR(AbstractBURS_TreeNode p) { 4887 p.initCost(); 4888 // stm: WRITE_FLOOR 4889 if(BURS.DEBUG) trace(p, 40, 11 + 0, p.getCost(1) /* stm */); 4890 if (11 < p.getCost(1) /* stm */) { 4891 p.setCost(1 /* stm */, (char)(11)); 4892 p.writePacked(0, 0xFFFFFF00, 0x28); // p.stm = 40 4893 } 4894 } 4895 4896 /** 4897 * Labels NOP tree node 4898 * @param p node to label 4899 */ 4900 private static void label_NOP(AbstractBURS_TreeNode p) { 4901 p.initCost(); 4902 // stm: NOP 4903 if(BURS.DEBUG) trace(p, 32, 10 + 0, p.getCost(1) /* stm */); 4904 if (10 < p.getCost(1) /* stm */) { 4905 p.setCost(1 /* stm */, (char)(10)); 4906 p.writePacked(0, 0xFFFFFF00, 0xA); // p.stm = 10 4907 } 4908 } 4909 4910 /** 4911 * Labels INT_MOVE tree node 4912 * @param p node to label 4913 */ 4914 private static void label_INT_MOVE(AbstractBURS_TreeNode p) { 4915 p.initCost(); 4916 AbstractBURS_TreeNode lchild; 4917 lchild = p.getChild1(); 4918 label(lchild); 4919 int c; 4920 // address: INT_MOVE(address) 4921 c = STATE(lchild).getCost(15 /* address */) + 0; 4922 if(BURS.DEBUG) trace(p, 217, c + 0, p.getCost(15) /* address */); 4923 if (c < p.getCost(15) /* address */) { 4924 p.setCost(15 /* address */, (char)(c)); 4925 p.writePacked(1, 0xFFE1FFFF, 0x40000); // p.address = 2 4926 } 4927 // address1reg: INT_MOVE(r) 4928 c = STATE(lchild).getCost(2 /* r */) + 0; 4929 if(BURS.DEBUG) trace(p, 220, c + 0, p.getCost(17) /* address1reg */); 4930 if (c < p.getCost(17) /* address1reg */) { 4931 p.setCost(17 /* address1reg */, (char)(c)); 4932 p.writePacked(1, 0xF8FFFFFF, 0x2000000); // p.address1reg = 2 4933 closure_address1reg(p, c); 4934 } 4935 // address1reg: INT_MOVE(address1reg) 4936 c = STATE(lchild).getCost(17 /* address1reg */) + 0; 4937 if(BURS.DEBUG) trace(p, 221, c + 0, p.getCost(17) /* address1reg */); 4938 if (c < p.getCost(17) /* address1reg */) { 4939 p.setCost(17 /* address1reg */, (char)(c)); 4940 p.writePacked(1, 0xF8FFFFFF, 0x3000000); // p.address1reg = 3 4941 closure_address1reg(p, c); 4942 } 4943 // address1scaledreg: INT_MOVE(address1scaledreg) 4944 c = STATE(lchild).getCost(16 /* address1scaledreg */) + 0; 4945 if(BURS.DEBUG) trace(p, 223, c + 0, p.getCost(16) /* address1scaledreg */); 4946 if (c < p.getCost(16) /* address1scaledreg */) { 4947 p.setCost(16 /* address1scaledreg */, (char)(c)); 4948 p.writePacked(1, 0xFF1FFFFF, 0x400000); // p.address1scaledreg = 2 4949 closure_address1scaledreg(p, c); 4950 } 4951 // r: INT_MOVE(riv) 4952 c = STATE(lchild).getCost(7 /* riv */) + 13; 4953 if(BURS.DEBUG) trace(p, 268, c + 0, p.getCost(2) /* r */); 4954 if (c < p.getCost(2) /* r */) { 4955 p.setCost(2 /* r */, (char)(c)); 4956 p.writePacked(0, 0xFFFF00FF, 0x5700); // p.r = 87 4957 closure_r(p, c); 4958 } 4959 // czr: INT_MOVE(czr) 4960 c = STATE(lchild).getCost(3 /* czr */) + 11; 4961 if(BURS.DEBUG) trace(p, 269, c + 0, p.getCost(3) /* czr */); 4962 if (c < p.getCost(3) /* czr */) { 4963 p.setCost(3 /* czr */, (char)(c)); 4964 p.writePacked(0, 0xFFF8FFFF, 0x40000); // p.czr = 4 4965 closure_czr(p, c); 4966 } 4967 // cz: INT_MOVE(cz) 4968 c = STATE(lchild).getCost(4 /* cz */) + 0; 4969 if(BURS.DEBUG) trace(p, 270, c + 0, p.getCost(4) /* cz */); 4970 if (c < p.getCost(4) /* cz */) { 4971 p.setCost(4 /* cz */, (char)(c)); 4972 p.writePacked(0, 0xFFE7FFFF, 0x100000); // p.cz = 2 4973 } 4974 // szpr: INT_MOVE(szpr) 4975 c = STATE(lchild).getCost(5 /* szpr */) + 11; 4976 if(BURS.DEBUG) trace(p, 271, c + 0, p.getCost(5) /* szpr */); 4977 if (c < p.getCost(5) /* szpr */) { 4978 p.setCost(5 /* szpr */, (char)(c)); 4979 p.writePacked(0, 0xFC1FFFFF, 0xA00000); // p.szpr = 5 4980 closure_szpr(p, c); 4981 } 4982 // szp: INT_MOVE(szp) 4983 c = STATE(lchild).getCost(6 /* szp */) + 0; 4984 if(BURS.DEBUG) trace(p, 272, c + 0, p.getCost(6) /* szp */); 4985 if (c < p.getCost(6) /* szp */) { 4986 p.setCost(6 /* szp */, (char)(c)); 4987 p.writePacked(0, 0xE3FFFFFF, 0x14000000); // p.szp = 5 4988 } 4989 // sload8: INT_MOVE(sload8) 4990 c = STATE(lchild).getCost(24 /* sload8 */) + 0; 4991 if(BURS.DEBUG) trace(p, 273, c + 0, p.getCost(24) /* sload8 */); 4992 if (c < p.getCost(24) /* sload8 */) { 4993 p.setCost(24 /* sload8 */, (char)(c)); 4994 p.writePacked(2, 0xFFFE7FFF, 0x8000); // p.sload8 = 1 4995 closure_sload8(p, c); 4996 } 4997 // uload8: INT_MOVE(uload8) 4998 c = STATE(lchild).getCost(11 /* uload8 */) + 0; 4999 if(BURS.DEBUG) trace(p, 274, c + 0, p.getCost(11) /* uload8 */); 5000 if (c < p.getCost(11) /* uload8 */) { 5001 p.setCost(11 /* uload8 */, (char)(c)); 5002 p.writePacked(1, 0xFFFFF8FF, 0x200); // p.uload8 = 2 5003 closure_uload8(p, c); 5004 } 5005 // load8: INT_MOVE(load8) 5006 c = STATE(lchild).getCost(20 /* load8 */) + 0; 5007 if(BURS.DEBUG) trace(p, 275, c + 0, p.getCost(20) /* load8 */); 5008 if (c < p.getCost(20) /* load8 */) { 5009 p.setCost(20 /* load8 */, (char)(c)); 5010 p.writePacked(2, 0xFFFFFFCF, 0x10); // p.load8 = 1 5011 closure_load8(p, c); 5012 } 5013 // sload16: INT_MOVE(sload16) 5014 c = STATE(lchild).getCost(21 /* sload16 */) + 0; 5015 if(BURS.DEBUG) trace(p, 276, c + 0, p.getCost(21) /* sload16 */); 5016 if (c < p.getCost(21) /* sload16 */) { 5017 p.setCost(21 /* sload16 */, (char)(c)); 5018 p.writePacked(2, 0xFFFFFE3F, 0x80); // p.sload16 = 2 5019 closure_sload16(p, c); 5020 } 5021 // uload16: INT_MOVE(uload16) 5022 c = STATE(lchild).getCost(23 /* uload16 */) + 0; 5023 if(BURS.DEBUG) trace(p, 277, c + 0, p.getCost(23) /* uload16 */); 5024 if (c < p.getCost(23) /* uload16 */) { 5025 p.setCost(23 /* uload16 */, (char)(c)); 5026 p.writePacked(2, 0xFFFF8FFF, 0x2000); // p.uload16 = 2 5027 closure_uload16(p, c); 5028 } 5029 // load16: INT_MOVE(load16) 5030 c = STATE(lchild).getCost(14 /* load16 */) + 0; 5031 if(BURS.DEBUG) trace(p, 278, c + 0, p.getCost(14) /* load16 */); 5032 if (c < p.getCost(14) /* load16 */) { 5033 p.setCost(14 /* load16 */, (char)(c)); 5034 p.writePacked(1, 0xFFFE7FFF, 0x8000); // p.load16 = 1 5035 closure_load16(p, c); 5036 } 5037 // load32: INT_MOVE(load32) 5038 c = STATE(lchild).getCost(10 /* load32 */) + 0; 5039 if(BURS.DEBUG) trace(p, 279, c + 0, p.getCost(10) /* load32 */); 5040 if (c < p.getCost(10) /* load32 */) { 5041 p.setCost(10 /* load32 */, (char)(c)); 5042 p.writePacked(1, 0xFFFFFF1F, 0x20); // p.load32 = 1 5043 closure_load32(p, c); 5044 } 5045 // r: INT_MOVE(address) 5046 c = STATE(lchild).getCost(15 /* address */) + 20; 5047 if(BURS.DEBUG) trace(p, 287, c + 0, p.getCost(2) /* r */); 5048 if (c < p.getCost(2) /* r */) { 5049 p.setCost(2 /* r */, (char)(c)); 5050 p.writePacked(0, 0xFFFF00FF, 0x6F00); // p.r = 111 5051 closure_r(p, c); 5052 } 5053 } 5054 5055 /** 5056 * Labels LONG_MOVE tree node 5057 * @param p node to label 5058 */ 5059 private static void label_LONG_MOVE(AbstractBURS_TreeNode p) { 5060 p.initCost(); 5061 AbstractBURS_TreeNode lchild; 5062 lchild = p.getChild1(); 5063 label(lchild); 5064 int c; 5065 // r: LONG_MOVE(r) 5066 c = STATE(lchild).getCost(2 /* r */) + 23; 5067 if(BURS.DEBUG) trace(p, 291, c + 0, p.getCost(2) /* r */); 5068 if (c < p.getCost(2) /* r */) { 5069 p.setCost(2 /* r */, (char)(c)); 5070 p.writePacked(0, 0xFFFF00FF, 0x8600); // p.r = 134 5071 closure_r(p, c); 5072 } 5073 if ( // r: LONG_MOVE(LONG_CONSTANT) 5074 lchild.getOpcode() == LONG_CONSTANT_opcode 5075 ) { 5076 c = 21; 5077 if(BURS.DEBUG) trace(p, 48, c + 0, p.getCost(2) /* r */); 5078 if (c < p.getCost(2) /* r */) { 5079 p.setCost(2 /* r */, (char)(c)); 5080 p.writePacked(0, 0xFFFF00FF, 0x8700); // p.r = 135 5081 closure_r(p, c); 5082 } 5083 } 5084 // load64: LONG_MOVE(load64) 5085 c = STATE(lchild).getCost(22 /* load64 */) + 0; 5086 if(BURS.DEBUG) trace(p, 292, c + 0, p.getCost(22) /* load64 */); 5087 if (c < p.getCost(22) /* load64 */) { 5088 p.setCost(22 /* load64 */, (char)(c)); 5089 p.writePacked(2, 0xFFFFF1FF, 0x600); // p.load64 = 3 5090 } 5091 } 5092 5093 /** 5094 * Labels FLOAT_MOVE tree node 5095 * @param p node to label 5096 */ 5097 private static void label_FLOAT_MOVE(AbstractBURS_TreeNode p) { 5098 p.initCost(); 5099 AbstractBURS_TreeNode lchild; 5100 lchild = p.getChild1(); 5101 label(lchild); 5102 int c; 5103 // r: FLOAT_MOVE(r) 5104 c = STATE(lchild).getCost(2 /* r */) + 13; 5105 if(BURS.DEBUG) trace(p, 301, c + 0, p.getCost(2) /* r */); 5106 if (c < p.getCost(2) /* r */) { 5107 p.setCost(2 /* r */, (char)(c)); 5108 p.writePacked(0, 0xFFFF00FF, 0xB900); // p.r = 185 5109 closure_r(p, c); 5110 } 5111 } 5112 5113 /** 5114 * Labels DOUBLE_MOVE tree node 5115 * @param p node to label 5116 */ 5117 private static void label_DOUBLE_MOVE(AbstractBURS_TreeNode p) { 5118 p.initCost(); 5119 AbstractBURS_TreeNode lchild; 5120 lchild = p.getChild1(); 5121 label(lchild); 5122 int c; 5123 // r: DOUBLE_MOVE(r) 5124 c = STATE(lchild).getCost(2 /* r */) + 13; 5125 if(BURS.DEBUG) trace(p, 302, c + 0, p.getCost(2) /* r */); 5126 if (c < p.getCost(2) /* r */) { 5127 p.setCost(2 /* r */, (char)(c)); 5128 p.writePacked(0, 0xFFFF00FF, 0xBA00); // p.r = 186 5129 closure_r(p, c); 5130 } 5131 } 5132 5133 /** 5134 * Labels GUARD_MOVE tree node 5135 * @param p node to label 5136 */ 5137 private static void label_GUARD_MOVE(AbstractBURS_TreeNode p) { 5138 p.initCost(); 5139 // r: GUARD_MOVE 5140 if(BURS.DEBUG) trace(p, 33, 11 + 0, p.getCost(2) /* r */); 5141 if (11 < p.getCost(2) /* r */) { 5142 p.setCost(2 /* r */, (char)(11)); 5143 p.writePacked(0, 0xFFFF00FF, 0x400); // p.r = 4 5144 closure_r(p, 11); 5145 } 5146 } 5147 5148 /** 5149 * Labels GUARD_COMBINE tree node 5150 * @param p node to label 5151 */ 5152 private static void label_GUARD_COMBINE(AbstractBURS_TreeNode p) { 5153 p.initCost(); 5154 // r: GUARD_COMBINE 5155 if(BURS.DEBUG) trace(p, 34, 11 + 0, p.getCost(2) /* r */); 5156 if (11 < p.getCost(2) /* r */) { 5157 p.setCost(2 /* r */, (char)(11)); 5158 p.writePacked(0, 0xFFFF00FF, 0x500); // p.r = 5 5159 closure_r(p, 11); 5160 } 5161 } 5162 5163 /** 5164 * Labels INT_ADD tree node 5165 * @param p node to label 5166 */ 5167 private static void label_INT_ADD(AbstractBURS_TreeNode p) { 5168 p.initCost(); 5169 AbstractBURS_TreeNode lchild, rchild; 5170 lchild = p.getChild1(); 5171 rchild = p.getChild2(); 5172 label(lchild); 5173 label(rchild); 5174 int c; 5175 // address: INT_ADD(r,r) 5176 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 5177 if(BURS.DEBUG) trace(p, 58, c + 0, p.getCost(15) /* address */); 5178 if (c < p.getCost(15) /* address */) { 5179 p.setCost(15 /* address */, (char)(c)); 5180 p.writePacked(1, 0xFFE1FFFF, 0x60000); // p.address = 3 5181 } 5182 // address: INT_ADD(r,address1scaledreg) 5183 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 0; 5184 if(BURS.DEBUG) trace(p, 59, c + 0, p.getCost(15) /* address */); 5185 if (c < p.getCost(15) /* address */) { 5186 p.setCost(15 /* address */, (char)(c)); 5187 p.writePacked(1, 0xFFE1FFFF, 0x80000); // p.address = 4 5188 } 5189 // address: INT_ADD(address1scaledreg,r) 5190 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(2 /* r */) + 0; 5191 if(BURS.DEBUG) trace(p, 60, c + 0, p.getCost(15) /* address */); 5192 if (c < p.getCost(15) /* address */) { 5193 p.setCost(15 /* address */, (char)(c)); 5194 p.writePacked(1, 0xFFE1FFFF, 0xA0000); // p.address = 5 5195 } 5196 if ( // address: INT_ADD(address1scaledreg,INT_CONSTANT) 5197 rchild.getOpcode() == INT_CONSTANT_opcode 5198 ) { 5199 c = STATE(lchild).getCost(16 /* address1scaledreg */) + 0; 5200 if(BURS.DEBUG) trace(p, 218, c + 0, p.getCost(15) /* address */); 5201 if (c < p.getCost(15) /* address */) { 5202 p.setCost(15 /* address */, (char)(c)); 5203 p.writePacked(1, 0xFFE1FFFF, 0xC0000); // p.address = 6 5204 } 5205 } 5206 // address: INT_ADD(address1scaledreg,address1reg) 5207 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(17 /* address1reg */) + 0; 5208 if(BURS.DEBUG) trace(p, 61, c + 0, p.getCost(15) /* address */); 5209 if (c < p.getCost(15) /* address */) { 5210 p.setCost(15 /* address */, (char)(c)); 5211 p.writePacked(1, 0xFFE1FFFF, 0xE0000); // p.address = 7 5212 } 5213 // address: INT_ADD(address1reg,address1scaledreg) 5214 c = STATE(lchild).getCost(17 /* address1reg */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 0; 5215 if(BURS.DEBUG) trace(p, 62, c + 0, p.getCost(15) /* address */); 5216 if (c < p.getCost(15) /* address */) { 5217 p.setCost(15 /* address */, (char)(c)); 5218 p.writePacked(1, 0xFFE1FFFF, 0x100000); // p.address = 8 5219 } 5220 if ( // address1reg: INT_ADD(r,INT_CONSTANT) 5221 rchild.getOpcode() == INT_CONSTANT_opcode 5222 ) { 5223 c = STATE(lchild).getCost(2 /* r */) + 0; 5224 if(BURS.DEBUG) trace(p, 219, c + 0, p.getCost(17) /* address1reg */); 5225 if (c < p.getCost(17) /* address1reg */) { 5226 p.setCost(17 /* address1reg */, (char)(c)); 5227 p.writePacked(1, 0xF8FFFFFF, 0x1000000); // p.address1reg = 1 5228 closure_address1reg(p, c); 5229 } 5230 } 5231 if ( // address1reg: INT_ADD(address1reg,INT_CONSTANT) 5232 rchild.getOpcode() == INT_CONSTANT_opcode 5233 ) { 5234 c = STATE(lchild).getCost(17 /* address1reg */) + 0; 5235 if(BURS.DEBUG) trace(p, 222, c + 0, p.getCost(17) /* address1reg */); 5236 if (c < p.getCost(17) /* address1reg */) { 5237 p.setCost(17 /* address1reg */, (char)(c)); 5238 p.writePacked(1, 0xF8FFFFFF, 0x4000000); // p.address1reg = 4 5239 closure_address1reg(p, c); 5240 } 5241 } 5242 if ( // address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) 5243 rchild.getOpcode() == INT_CONSTANT_opcode 5244 ) { 5245 c = STATE(lchild).getCost(16 /* address1scaledreg */) + 0; 5246 if(BURS.DEBUG) trace(p, 225, c + 0, p.getCost(16) /* address1scaledreg */); 5247 if (c < p.getCost(16) /* address1scaledreg */) { 5248 p.setCost(16 /* address1scaledreg */, (char)(c)); 5249 p.writePacked(1, 0xFF1FFFFF, 0x800000); // p.address1scaledreg = 4 5250 closure_address1scaledreg(p, c); 5251 } 5252 } 5253 // czr: INT_ADD(r,riv) 5254 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 5255 if(BURS.DEBUG) trace(p, 71, c + 0, p.getCost(3) /* czr */); 5256 if (c < p.getCost(3) /* czr */) { 5257 p.setCost(3 /* czr */, (char)(c)); 5258 p.writePacked(0, 0xFFF8FFFF, 0x10000); // p.czr = 1 5259 closure_czr(p, c); 5260 } 5261 // r: INT_ADD(r,riv) 5262 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 11; 5263 if(BURS.DEBUG) trace(p, 72, c + 0, p.getCost(2) /* r */); 5264 if (c < p.getCost(2) /* r */) { 5265 p.setCost(2 /* r */, (char)(c)); 5266 p.writePacked(0, 0xFFFF00FF, 0x4D00); // p.r = 77 5267 closure_r(p, c); 5268 } 5269 // czr: INT_ADD(r,load32) 5270 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 5271 if(BURS.DEBUG) trace(p, 73, c + 0, p.getCost(3) /* czr */); 5272 if (c < p.getCost(3) /* czr */) { 5273 p.setCost(3 /* czr */, (char)(c)); 5274 p.writePacked(0, 0xFFF8FFFF, 0x20000); // p.czr = 2 5275 closure_czr(p, c); 5276 } 5277 // czr: INT_ADD(load32,riv) 5278 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 5279 if(BURS.DEBUG) trace(p, 74, c + 0, p.getCost(3) /* czr */); 5280 if (c < p.getCost(3) /* czr */) { 5281 p.setCost(3 /* czr */, (char)(c)); 5282 p.writePacked(0, 0xFFF8FFFF, 0x30000); // p.czr = 3 5283 closure_czr(p, c); 5284 } 5285 // r: INT_ADD(address1scaledreg,r) 5286 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(2 /* r */) + 11; 5287 if(BURS.DEBUG) trace(p, 116, c + 0, p.getCost(2) /* r */); 5288 if (c < p.getCost(2) /* r */) { 5289 p.setCost(2 /* r */, (char)(c)); 5290 p.writePacked(0, 0xFFFF00FF, 0x6A00); // p.r = 106 5291 closure_r(p, c); 5292 } 5293 // r: INT_ADD(r,address1scaledreg) 5294 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 11; 5295 if(BURS.DEBUG) trace(p, 117, c + 0, p.getCost(2) /* r */); 5296 if (c < p.getCost(2) /* r */) { 5297 p.setCost(2 /* r */, (char)(c)); 5298 p.writePacked(0, 0xFFFF00FF, 0x6B00); // p.r = 107 5299 closure_r(p, c); 5300 } 5301 // r: INT_ADD(address1scaledreg,address1reg) 5302 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(17 /* address1reg */) + 11; 5303 if(BURS.DEBUG) trace(p, 118, c + 0, p.getCost(2) /* r */); 5304 if (c < p.getCost(2) /* r */) { 5305 p.setCost(2 /* r */, (char)(c)); 5306 p.writePacked(0, 0xFFFF00FF, 0x6C00); // p.r = 108 5307 closure_r(p, c); 5308 } 5309 // r: INT_ADD(address1reg,address1scaledreg) 5310 c = STATE(lchild).getCost(17 /* address1reg */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 11; 5311 if(BURS.DEBUG) trace(p, 119, c + 0, p.getCost(2) /* r */); 5312 if (c < p.getCost(2) /* r */) { 5313 p.setCost(2 /* r */, (char)(c)); 5314 p.writePacked(0, 0xFFFF00FF, 0x6D00); // p.r = 109 5315 closure_r(p, c); 5316 } 5317 if ( // r: INT_ADD(address,INT_CONSTANT) 5318 rchild.getOpcode() == INT_CONSTANT_opcode 5319 ) { 5320 c = STATE(lchild).getCost(15 /* address */) + 11; 5321 if(BURS.DEBUG) trace(p, 286, c + 0, p.getCost(2) /* r */); 5322 if (c < p.getCost(2) /* r */) { 5323 p.setCost(2 /* r */, (char)(c)); 5324 p.writePacked(0, 0xFFFF00FF, 0x6E00); // p.r = 110 5325 closure_r(p, c); 5326 } 5327 } 5328 } 5329 5330 /** 5331 * Labels LONG_ADD tree node 5332 * @param p node to label 5333 */ 5334 private static void label_LONG_ADD(AbstractBURS_TreeNode p) { 5335 p.initCost(); 5336 AbstractBURS_TreeNode lchild, rchild; 5337 lchild = p.getChild1(); 5338 rchild = p.getChild2(); 5339 label(lchild); 5340 label(rchild); 5341 int c; 5342 // r: LONG_ADD(r,rlv) 5343 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 26; 5344 if(BURS.DEBUG) trace(p, 140, c + 0, p.getCost(2) /* r */); 5345 if (c < p.getCost(2) /* r */) { 5346 p.setCost(2 /* r */, (char)(c)); 5347 p.writePacked(0, 0xFFFF00FF, 0x7E00); // p.r = 126 5348 closure_r(p, c); 5349 } 5350 // r: LONG_ADD(r,load64) 5351 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(22 /* load64 */) + 30; 5352 if(BURS.DEBUG) trace(p, 141, c + 0, p.getCost(2) /* r */); 5353 if (c < p.getCost(2) /* r */) { 5354 p.setCost(2 /* r */, (char)(c)); 5355 p.writePacked(0, 0xFFFF00FF, 0x7F00); // p.r = 127 5356 closure_r(p, c); 5357 } 5358 // r: LONG_ADD(load64,rlv) 5359 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 30; 5360 if(BURS.DEBUG) trace(p, 142, c + 0, p.getCost(2) /* r */); 5361 if (c < p.getCost(2) /* r */) { 5362 p.setCost(2 /* r */, (char)(c)); 5363 p.writePacked(0, 0xFFFF00FF, 0x8000); // p.r = 128 5364 closure_r(p, c); 5365 } 5366 } 5367 5368 /** 5369 * Labels FLOAT_ADD tree node 5370 * @param p node to label 5371 */ 5372 private static void label_FLOAT_ADD(AbstractBURS_TreeNode p) { 5373 p.initCost(); 5374 AbstractBURS_TreeNode lchild, rchild; 5375 lchild = p.getChild1(); 5376 rchild = p.getChild2(); 5377 label(lchild); 5378 label(rchild); 5379 int c; 5380 // r: FLOAT_ADD(r,r) 5381 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5382 if(BURS.DEBUG) trace(p, 162, c + 0, p.getCost(2) /* r */); 5383 if (c < p.getCost(2) /* r */) { 5384 p.setCost(2 /* r */, (char)(c)); 5385 p.writePacked(0, 0xFFFF00FF, 0x9D00); // p.r = 157 5386 closure_r(p, c); 5387 } 5388 // r: FLOAT_ADD(r,float_load) 5389 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* float_load */) + 15; 5390 if(BURS.DEBUG) trace(p, 163, c + 0, p.getCost(2) /* r */); 5391 if (c < p.getCost(2) /* r */) { 5392 p.setCost(2 /* r */, (char)(c)); 5393 p.writePacked(0, 0xFFFF00FF, 0x9E00); // p.r = 158 5394 closure_r(p, c); 5395 } 5396 // r: FLOAT_ADD(float_load,r) 5397 c = STATE(lchild).getCost(25 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5398 if(BURS.DEBUG) trace(p, 164, c + 0, p.getCost(2) /* r */); 5399 if (c < p.getCost(2) /* r */) { 5400 p.setCost(2 /* r */, (char)(c)); 5401 p.writePacked(0, 0xFFFF00FF, 0x9F00); // p.r = 159 5402 closure_r(p, c); 5403 } 5404 } 5405 5406 /** 5407 * Labels DOUBLE_ADD tree node 5408 * @param p node to label 5409 */ 5410 private static void label_DOUBLE_ADD(AbstractBURS_TreeNode p) { 5411 p.initCost(); 5412 AbstractBURS_TreeNode lchild, rchild; 5413 lchild = p.getChild1(); 5414 rchild = p.getChild2(); 5415 label(lchild); 5416 label(rchild); 5417 int c; 5418 // r: DOUBLE_ADD(r,r) 5419 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5420 if(BURS.DEBUG) trace(p, 165, c + 0, p.getCost(2) /* r */); 5421 if (c < p.getCost(2) /* r */) { 5422 p.setCost(2 /* r */, (char)(c)); 5423 p.writePacked(0, 0xFFFF00FF, 0xA000); // p.r = 160 5424 closure_r(p, c); 5425 } 5426 // r: DOUBLE_ADD(r,double_load) 5427 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* double_load */) + 15; 5428 if(BURS.DEBUG) trace(p, 166, c + 0, p.getCost(2) /* r */); 5429 if (c < p.getCost(2) /* r */) { 5430 p.setCost(2 /* r */, (char)(c)); 5431 p.writePacked(0, 0xFFFF00FF, 0xA100); // p.r = 161 5432 closure_r(p, c); 5433 } 5434 // r: DOUBLE_ADD(double_load,r) 5435 c = STATE(lchild).getCost(26 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5436 if(BURS.DEBUG) trace(p, 167, c + 0, p.getCost(2) /* r */); 5437 if (c < p.getCost(2) /* r */) { 5438 p.setCost(2 /* r */, (char)(c)); 5439 p.writePacked(0, 0xFFFF00FF, 0xA200); // p.r = 162 5440 closure_r(p, c); 5441 } 5442 } 5443 5444 /** 5445 * Labels INT_SUB tree node 5446 * @param p node to label 5447 */ 5448 private static void label_INT_SUB(AbstractBURS_TreeNode p) { 5449 p.initCost(); 5450 AbstractBURS_TreeNode lchild, rchild; 5451 lchild = p.getChild1(); 5452 rchild = p.getChild2(); 5453 label(lchild); 5454 label(rchild); 5455 int c; 5456 // czr: INT_SUB(riv,r) 5457 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + 13; 5458 if(BURS.DEBUG) trace(p, 107, c + 0, p.getCost(3) /* czr */); 5459 if (c < p.getCost(3) /* czr */) { 5460 p.setCost(3 /* czr */, (char)(c)); 5461 p.writePacked(0, 0xFFF8FFFF, 0x50000); // p.czr = 5 5462 closure_czr(p, c); 5463 } 5464 // r: INT_SUB(riv,r) 5465 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 13-2 : INFINITE); 5466 if(BURS.DEBUG) trace(p, 108, c + 0, p.getCost(2) /* r */); 5467 if (c < p.getCost(2) /* r */) { 5468 p.setCost(2 /* r */, (char)(c)); 5469 p.writePacked(0, 0xFFFF00FF, 0x6700); // p.r = 103 5470 closure_r(p, c); 5471 } 5472 // r: INT_SUB(load32,r) 5473 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(2 /* r */) + (Binary.getResult(P(p)).similar(Binary.getVal2(P(p))) ? 15-2 : INFINITE); 5474 if(BURS.DEBUG) trace(p, 109, c + 0, p.getCost(2) /* r */); 5475 if (c < p.getCost(2) /* r */) { 5476 p.setCost(2 /* r */, (char)(c)); 5477 p.writePacked(0, 0xFFFF00FF, 0x6800); // p.r = 104 5478 closure_r(p, c); 5479 } 5480 // czr: INT_SUB(riv,load32) 5481 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 5482 if(BURS.DEBUG) trace(p, 110, c + 0, p.getCost(3) /* czr */); 5483 if (c < p.getCost(3) /* czr */) { 5484 p.setCost(3 /* czr */, (char)(c)); 5485 p.writePacked(0, 0xFFF8FFFF, 0x60000); // p.czr = 6 5486 closure_czr(p, c); 5487 } 5488 // czr: INT_SUB(load32,riv) 5489 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 5490 if(BURS.DEBUG) trace(p, 111, c + 0, p.getCost(3) /* czr */); 5491 if (c < p.getCost(3) /* czr */) { 5492 p.setCost(3 /* czr */, (char)(c)); 5493 p.writePacked(0, 0xFFF8FFFF, 0x70000); // p.czr = 7 5494 closure_czr(p, c); 5495 } 5496 } 5497 5498 /** 5499 * Labels LONG_SUB tree node 5500 * @param p node to label 5501 */ 5502 private static void label_LONG_SUB(AbstractBURS_TreeNode p) { 5503 p.initCost(); 5504 AbstractBURS_TreeNode lchild, rchild; 5505 lchild = p.getChild1(); 5506 rchild = p.getChild2(); 5507 label(lchild); 5508 label(rchild); 5509 int c; 5510 // r: LONG_SUB(rlv,rlv) 5511 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 23; 5512 if(BURS.DEBUG) trace(p, 155, c + 0, p.getCost(2) /* r */); 5513 if (c < p.getCost(2) /* r */) { 5514 p.setCost(2 /* r */, (char)(c)); 5515 p.writePacked(0, 0xFFFF00FF, 0x9500); // p.r = 149 5516 closure_r(p, c); 5517 } 5518 // r: LONG_SUB(rlv,load64) 5519 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(22 /* load64 */) + 30; 5520 if(BURS.DEBUG) trace(p, 156, c + 0, p.getCost(2) /* r */); 5521 if (c < p.getCost(2) /* r */) { 5522 p.setCost(2 /* r */, (char)(c)); 5523 p.writePacked(0, 0xFFFF00FF, 0x9600); // p.r = 150 5524 closure_r(p, c); 5525 } 5526 // r: LONG_SUB(load64,rlv) 5527 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 30; 5528 if(BURS.DEBUG) trace(p, 157, c + 0, p.getCost(2) /* r */); 5529 if (c < p.getCost(2) /* r */) { 5530 p.setCost(2 /* r */, (char)(c)); 5531 p.writePacked(0, 0xFFFF00FF, 0x9700); // p.r = 151 5532 closure_r(p, c); 5533 } 5534 } 5535 5536 /** 5537 * Labels FLOAT_SUB tree node 5538 * @param p node to label 5539 */ 5540 private static void label_FLOAT_SUB(AbstractBURS_TreeNode p) { 5541 p.initCost(); 5542 AbstractBURS_TreeNode lchild, rchild; 5543 lchild = p.getChild1(); 5544 rchild = p.getChild2(); 5545 label(lchild); 5546 label(rchild); 5547 int c; 5548 // r: FLOAT_SUB(r,r) 5549 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5550 if(BURS.DEBUG) trace(p, 168, c + 0, p.getCost(2) /* r */); 5551 if (c < p.getCost(2) /* r */) { 5552 p.setCost(2 /* r */, (char)(c)); 5553 p.writePacked(0, 0xFFFF00FF, 0xA300); // p.r = 163 5554 closure_r(p, c); 5555 } 5556 // r: FLOAT_SUB(r,float_load) 5557 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* float_load */) + 15; 5558 if(BURS.DEBUG) trace(p, 169, c + 0, p.getCost(2) /* r */); 5559 if (c < p.getCost(2) /* r */) { 5560 p.setCost(2 /* r */, (char)(c)); 5561 p.writePacked(0, 0xFFFF00FF, 0xA400); // p.r = 164 5562 closure_r(p, c); 5563 } 5564 } 5565 5566 /** 5567 * Labels DOUBLE_SUB tree node 5568 * @param p node to label 5569 */ 5570 private static void label_DOUBLE_SUB(AbstractBURS_TreeNode p) { 5571 p.initCost(); 5572 AbstractBURS_TreeNode lchild, rchild; 5573 lchild = p.getChild1(); 5574 rchild = p.getChild2(); 5575 label(lchild); 5576 label(rchild); 5577 int c; 5578 // r: DOUBLE_SUB(r,r) 5579 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5580 if(BURS.DEBUG) trace(p, 170, c + 0, p.getCost(2) /* r */); 5581 if (c < p.getCost(2) /* r */) { 5582 p.setCost(2 /* r */, (char)(c)); 5583 p.writePacked(0, 0xFFFF00FF, 0xA500); // p.r = 165 5584 closure_r(p, c); 5585 } 5586 // r: DOUBLE_SUB(r,double_load) 5587 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* double_load */) + 15; 5588 if(BURS.DEBUG) trace(p, 171, c + 0, p.getCost(2) /* r */); 5589 if (c < p.getCost(2) /* r */) { 5590 p.setCost(2 /* r */, (char)(c)); 5591 p.writePacked(0, 0xFFFF00FF, 0xA600); // p.r = 166 5592 closure_r(p, c); 5593 } 5594 } 5595 5596 /** 5597 * Labels INT_MUL tree node 5598 * @param p node to label 5599 */ 5600 private static void label_INT_MUL(AbstractBURS_TreeNode p) { 5601 p.initCost(); 5602 AbstractBURS_TreeNode lchild, rchild; 5603 lchild = p.getChild1(); 5604 rchild = p.getChild2(); 5605 label(lchild); 5606 label(rchild); 5607 int c; 5608 // r: INT_MUL(r,riv) 5609 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 5610 if(BURS.DEBUG) trace(p, 97, c + 0, p.getCost(2) /* r */); 5611 if (c < p.getCost(2) /* r */) { 5612 p.setCost(2 /* r */, (char)(c)); 5613 p.writePacked(0, 0xFFFF00FF, 0x5800); // p.r = 88 5614 closure_r(p, c); 5615 } 5616 // r: INT_MUL(r,load32) 5617 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 5618 if(BURS.DEBUG) trace(p, 98, c + 0, p.getCost(2) /* r */); 5619 if (c < p.getCost(2) /* r */) { 5620 p.setCost(2 /* r */, (char)(c)); 5621 p.writePacked(0, 0xFFFF00FF, 0x5900); // p.r = 89 5622 closure_r(p, c); 5623 } 5624 // r: INT_MUL(load32,riv) 5625 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 5626 if(BURS.DEBUG) trace(p, 99, c + 0, p.getCost(2) /* r */); 5627 if (c < p.getCost(2) /* r */) { 5628 p.setCost(2 /* r */, (char)(c)); 5629 p.writePacked(0, 0xFFFF00FF, 0x5A00); // p.r = 90 5630 closure_r(p, c); 5631 } 5632 } 5633 5634 /** 5635 * Labels LONG_MUL tree node 5636 * @param p node to label 5637 */ 5638 private static void label_LONG_MUL(AbstractBURS_TreeNode p) { 5639 p.initCost(); 5640 AbstractBURS_TreeNode lchild, rchild; 5641 lchild = p.getChild1(); 5642 rchild = p.getChild2(); 5643 label(lchild); 5644 label(rchild); 5645 int c; 5646 // r: LONG_MUL(r,rlv) 5647 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 5*13; 5648 if(BURS.DEBUG) trace(p, 149, c + 0, p.getCost(2) /* r */); 5649 if (c < p.getCost(2) /* r */) { 5650 p.setCost(2 /* r */, (char)(c)); 5651 p.writePacked(0, 0xFFFF00FF, 0x8800); // p.r = 136 5652 closure_r(p, c); 5653 } 5654 if ( // r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) 5655 lchild.getOpcode() == LONG_AND_opcode && 5656 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 5657 rchild.getOpcode() == LONG_AND_opcode && 5658 rchild.getChild2().getOpcode() == LONG_CONSTANT_opcode 5659 ) { 5660 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + ((Binary.getVal2(PL(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(PL(p)).asLongConstant().lower32() == -1)&& (Binary.getVal2(PR(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(PR(p)).asLongConstant().lower32() == -1) ? (4*11) : INFINITE); 5661 if(BURS.DEBUG) trace(p, 524, c + 0, p.getCost(2) /* r */); 5662 if (c < p.getCost(2) /* r */) { 5663 p.setCost(2 /* r */, (char)(c)); 5664 p.writePacked(0, 0xFFFF00FF, 0x8900); // p.r = 137 5665 closure_r(p, c); 5666 } 5667 } 5668 if ( // r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) 5669 lchild.getOpcode() == LONG_AND_opcode && 5670 lchild.getChild2().getOpcode() == LONG_CONSTANT_opcode && 5671 rchild.getOpcode() == LONG_CONSTANT_opcode 5672 ) { 5673 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + ((Binary.getVal2(P(p)).asLongConstant().upper32() == 0) ? (4*11) : INFINITE); 5674 if(BURS.DEBUG) trace(p, 341, c + 0, p.getCost(2) /* r */); 5675 if (c < p.getCost(2) /* r */) { 5676 p.setCost(2 /* r */, (char)(c)); 5677 p.writePacked(0, 0xFFFF00FF, 0x8A00); // p.r = 138 5678 closure_r(p, c); 5679 } 5680 } 5681 if ( // r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) 5682 lchild.getOpcode() == INT_2LONG_opcode && 5683 rchild.getOpcode() == INT_2LONG_opcode 5684 ) { 5685 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + 4*11; 5686 if(BURS.DEBUG) trace(p, 525, c + 0, p.getCost(2) /* r */); 5687 if (c < p.getCost(2) /* r */) { 5688 p.setCost(2 /* r */, (char)(c)); 5689 p.writePacked(0, 0xFFFF00FF, 0x8B00); // p.r = 139 5690 closure_r(p, c); 5691 } 5692 } 5693 } 5694 5695 /** 5696 * Labels FLOAT_MUL tree node 5697 * @param p node to label 5698 */ 5699 private static void label_FLOAT_MUL(AbstractBURS_TreeNode p) { 5700 p.initCost(); 5701 AbstractBURS_TreeNode lchild, rchild; 5702 lchild = p.getChild1(); 5703 rchild = p.getChild2(); 5704 label(lchild); 5705 label(rchild); 5706 int c; 5707 // r: FLOAT_MUL(r,r) 5708 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5709 if(BURS.DEBUG) trace(p, 172, c + 0, p.getCost(2) /* r */); 5710 if (c < p.getCost(2) /* r */) { 5711 p.setCost(2 /* r */, (char)(c)); 5712 p.writePacked(0, 0xFFFF00FF, 0xA700); // p.r = 167 5713 closure_r(p, c); 5714 } 5715 // r: FLOAT_MUL(r,float_load) 5716 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* float_load */) + 15; 5717 if(BURS.DEBUG) trace(p, 173, c + 0, p.getCost(2) /* r */); 5718 if (c < p.getCost(2) /* r */) { 5719 p.setCost(2 /* r */, (char)(c)); 5720 p.writePacked(0, 0xFFFF00FF, 0xA800); // p.r = 168 5721 closure_r(p, c); 5722 } 5723 // r: FLOAT_MUL(float_load,r) 5724 c = STATE(lchild).getCost(25 /* float_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5725 if(BURS.DEBUG) trace(p, 174, c + 0, p.getCost(2) /* r */); 5726 if (c < p.getCost(2) /* r */) { 5727 p.setCost(2 /* r */, (char)(c)); 5728 p.writePacked(0, 0xFFFF00FF, 0xA900); // p.r = 169 5729 closure_r(p, c); 5730 } 5731 } 5732 5733 /** 5734 * Labels DOUBLE_MUL tree node 5735 * @param p node to label 5736 */ 5737 private static void label_DOUBLE_MUL(AbstractBURS_TreeNode p) { 5738 p.initCost(); 5739 AbstractBURS_TreeNode lchild, rchild; 5740 lchild = p.getChild1(); 5741 rchild = p.getChild2(); 5742 label(lchild); 5743 label(rchild); 5744 int c; 5745 // r: DOUBLE_MUL(r,r) 5746 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5747 if(BURS.DEBUG) trace(p, 175, c + 0, p.getCost(2) /* r */); 5748 if (c < p.getCost(2) /* r */) { 5749 p.setCost(2 /* r */, (char)(c)); 5750 p.writePacked(0, 0xFFFF00FF, 0xAA00); // p.r = 170 5751 closure_r(p, c); 5752 } 5753 // r: DOUBLE_MUL(r,double_load) 5754 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* double_load */) + 15; 5755 if(BURS.DEBUG) trace(p, 176, c + 0, p.getCost(2) /* r */); 5756 if (c < p.getCost(2) /* r */) { 5757 p.setCost(2 /* r */, (char)(c)); 5758 p.writePacked(0, 0xFFFF00FF, 0xAB00); // p.r = 171 5759 closure_r(p, c); 5760 } 5761 // r: DOUBLE_MUL(double_load,r) 5762 c = STATE(lchild).getCost(26 /* double_load */) + STATE(rchild).getCost(2 /* r */) + 15; 5763 if(BURS.DEBUG) trace(p, 177, c + 0, p.getCost(2) /* r */); 5764 if (c < p.getCost(2) /* r */) { 5765 p.setCost(2 /* r */, (char)(c)); 5766 p.writePacked(0, 0xFFFF00FF, 0xAC00); // p.r = 172 5767 closure_r(p, c); 5768 } 5769 } 5770 5771 /** 5772 * Labels INT_DIV tree node 5773 * @param p node to label 5774 */ 5775 private static void label_INT_DIV(AbstractBURS_TreeNode p) { 5776 p.initCost(); 5777 AbstractBURS_TreeNode lchild, rchild; 5778 lchild = p.getChild1(); 5779 rchild = p.getChild2(); 5780 label(lchild); 5781 label(rchild); 5782 int c; 5783 // r: INT_DIV(riv,riv) 5784 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 52; 5785 if(BURS.DEBUG) trace(p, 81, c + 0, p.getCost(2) /* r */); 5786 if (c < p.getCost(2) /* r */) { 5787 p.setCost(2 /* r */, (char)(c)); 5788 p.writePacked(0, 0xFFFF00FF, 0x4E00); // p.r = 78 5789 closure_r(p, c); 5790 } 5791 // r: INT_DIV(riv,load32) 5792 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 55; 5793 if(BURS.DEBUG) trace(p, 82, c + 0, p.getCost(2) /* r */); 5794 if (c < p.getCost(2) /* r */) { 5795 p.setCost(2 /* r */, (char)(c)); 5796 p.writePacked(0, 0xFFFF00FF, 0x4F00); // p.r = 79 5797 closure_r(p, c); 5798 } 5799 } 5800 5801 /** 5802 * Labels FLOAT_DIV tree node 5803 * @param p node to label 5804 */ 5805 private static void label_FLOAT_DIV(AbstractBURS_TreeNode p) { 5806 p.initCost(); 5807 AbstractBURS_TreeNode lchild, rchild; 5808 lchild = p.getChild1(); 5809 rchild = p.getChild2(); 5810 label(lchild); 5811 label(rchild); 5812 int c; 5813 // r: FLOAT_DIV(r,r) 5814 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5815 if(BURS.DEBUG) trace(p, 178, c + 0, p.getCost(2) /* r */); 5816 if (c < p.getCost(2) /* r */) { 5817 p.setCost(2 /* r */, (char)(c)); 5818 p.writePacked(0, 0xFFFF00FF, 0xAD00); // p.r = 173 5819 closure_r(p, c); 5820 } 5821 // r: FLOAT_DIV(r,float_load) 5822 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(25 /* float_load */) + 15; 5823 if(BURS.DEBUG) trace(p, 179, c + 0, p.getCost(2) /* r */); 5824 if (c < p.getCost(2) /* r */) { 5825 p.setCost(2 /* r */, (char)(c)); 5826 p.writePacked(0, 0xFFFF00FF, 0xAE00); // p.r = 174 5827 closure_r(p, c); 5828 } 5829 } 5830 5831 /** 5832 * Labels DOUBLE_DIV tree node 5833 * @param p node to label 5834 */ 5835 private static void label_DOUBLE_DIV(AbstractBURS_TreeNode p) { 5836 p.initCost(); 5837 AbstractBURS_TreeNode lchild, rchild; 5838 lchild = p.getChild1(); 5839 rchild = p.getChild2(); 5840 label(lchild); 5841 label(rchild); 5842 int c; 5843 // r: DOUBLE_DIV(r,r) 5844 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5845 if(BURS.DEBUG) trace(p, 180, c + 0, p.getCost(2) /* r */); 5846 if (c < p.getCost(2) /* r */) { 5847 p.setCost(2 /* r */, (char)(c)); 5848 p.writePacked(0, 0xFFFF00FF, 0xAF00); // p.r = 175 5849 closure_r(p, c); 5850 } 5851 // r: DOUBLE_DIV(r,double_load) 5852 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(26 /* double_load */) + 15; 5853 if(BURS.DEBUG) trace(p, 181, c + 0, p.getCost(2) /* r */); 5854 if (c < p.getCost(2) /* r */) { 5855 p.setCost(2 /* r */, (char)(c)); 5856 p.writePacked(0, 0xFFFF00FF, 0xB000); // p.r = 176 5857 closure_r(p, c); 5858 } 5859 } 5860 5861 /** 5862 * Labels INT_REM tree node 5863 * @param p node to label 5864 */ 5865 private static void label_INT_REM(AbstractBURS_TreeNode p) { 5866 p.initCost(); 5867 AbstractBURS_TreeNode lchild, rchild; 5868 lchild = p.getChild1(); 5869 rchild = p.getChild2(); 5870 label(lchild); 5871 label(rchild); 5872 int c; 5873 // r: INT_REM(riv,riv) 5874 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 52; 5875 if(BURS.DEBUG) trace(p, 103, c + 0, p.getCost(2) /* r */); 5876 if (c < p.getCost(2) /* r */) { 5877 p.setCost(2 /* r */, (char)(c)); 5878 p.writePacked(0, 0xFFFF00FF, 0x5C00); // p.r = 92 5879 closure_r(p, c); 5880 } 5881 // r: INT_REM(riv,load32) 5882 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 55; 5883 if(BURS.DEBUG) trace(p, 104, c + 0, p.getCost(2) /* r */); 5884 if (c < p.getCost(2) /* r */) { 5885 p.setCost(2 /* r */, (char)(c)); 5886 p.writePacked(0, 0xFFFF00FF, 0x5D00); // p.r = 93 5887 closure_r(p, c); 5888 } 5889 } 5890 5891 /** 5892 * Labels FLOAT_REM tree node 5893 * @param p node to label 5894 */ 5895 private static void label_FLOAT_REM(AbstractBURS_TreeNode p) { 5896 p.initCost(); 5897 AbstractBURS_TreeNode lchild, rchild; 5898 lchild = p.getChild1(); 5899 rchild = p.getChild2(); 5900 label(lchild); 5901 label(rchild); 5902 int c; 5903 // r: FLOAT_REM(r,r) 5904 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5905 if(BURS.DEBUG) trace(p, 182, c + 0, p.getCost(2) /* r */); 5906 if (c < p.getCost(2) /* r */) { 5907 p.setCost(2 /* r */, (char)(c)); 5908 p.writePacked(0, 0xFFFF00FF, 0xB500); // p.r = 181 5909 closure_r(p, c); 5910 } 5911 } 5912 5913 /** 5914 * Labels DOUBLE_REM tree node 5915 * @param p node to label 5916 */ 5917 private static void label_DOUBLE_REM(AbstractBURS_TreeNode p) { 5918 p.initCost(); 5919 AbstractBURS_TreeNode lchild, rchild; 5920 lchild = p.getChild1(); 5921 rchild = p.getChild2(); 5922 label(lchild); 5923 label(rchild); 5924 int c; 5925 // r: DOUBLE_REM(r,r) 5926 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 13; 5927 if(BURS.DEBUG) trace(p, 183, c + 0, p.getCost(2) /* r */); 5928 if (c < p.getCost(2) /* r */) { 5929 p.setCost(2 /* r */, (char)(c)); 5930 p.writePacked(0, 0xFFFF00FF, 0xB600); // p.r = 182 5931 closure_r(p, c); 5932 } 5933 } 5934 5935 /** 5936 * Labels INT_NEG tree node 5937 * @param p node to label 5938 */ 5939 private static void label_INT_NEG(AbstractBURS_TreeNode p) { 5940 p.initCost(); 5941 AbstractBURS_TreeNode lchild; 5942 lchild = p.getChild1(); 5943 label(lchild); 5944 int c; 5945 // szpr: INT_NEG(r) 5946 c = STATE(lchild).getCost(2 /* r */) + 13; 5947 if(BURS.DEBUG) trace(p, 280, c + 0, p.getCost(5) /* szpr */); 5948 if (c < p.getCost(5) /* szpr */) { 5949 p.setCost(5 /* szpr */, (char)(c)); 5950 p.writePacked(0, 0xFC1FFFFF, 0xC00000); // p.szpr = 6 5951 closure_szpr(p, c); 5952 } 5953 } 5954 5955 /** 5956 * Labels LONG_NEG tree node 5957 * @param p node to label 5958 */ 5959 private static void label_LONG_NEG(AbstractBURS_TreeNode p) { 5960 p.initCost(); 5961 AbstractBURS_TreeNode lchild; 5962 lchild = p.getChild1(); 5963 label(lchild); 5964 int c; 5965 // r: LONG_NEG(r) 5966 c = STATE(lchild).getCost(2 /* r */) + 26; 5967 if(BURS.DEBUG) trace(p, 293, c + 0, p.getCost(2) /* r */); 5968 if (c < p.getCost(2) /* r */) { 5969 p.setCost(2 /* r */, (char)(c)); 5970 p.writePacked(0, 0xFFFF00FF, 0x8C00); // p.r = 140 5971 closure_r(p, c); 5972 } 5973 } 5974 5975 /** 5976 * Labels FLOAT_NEG tree node 5977 * @param p node to label 5978 */ 5979 private static void label_FLOAT_NEG(AbstractBURS_TreeNode p) { 5980 p.initCost(); 5981 AbstractBURS_TreeNode lchild; 5982 lchild = p.getChild1(); 5983 label(lchild); 5984 int c; 5985 // r: FLOAT_NEG(r) 5986 c = STATE(lchild).getCost(2 /* r */) + 26; 5987 if(BURS.DEBUG) trace(p, 295, c + 0, p.getCost(2) /* r */); 5988 if (c < p.getCost(2) /* r */) { 5989 p.setCost(2 /* r */, (char)(c)); 5990 p.writePacked(0, 0xFFFF00FF, 0xB100); // p.r = 177 5991 closure_r(p, c); 5992 } 5993 } 5994 5995 /** 5996 * Labels DOUBLE_NEG tree node 5997 * @param p node to label 5998 */ 5999 private static void label_DOUBLE_NEG(AbstractBURS_TreeNode p) { 6000 p.initCost(); 6001 AbstractBURS_TreeNode lchild; 6002 lchild = p.getChild1(); 6003 label(lchild); 6004 int c; 6005 // r: DOUBLE_NEG(r) 6006 c = STATE(lchild).getCost(2 /* r */) + 26; 6007 if(BURS.DEBUG) trace(p, 296, c + 0, p.getCost(2) /* r */); 6008 if (c < p.getCost(2) /* r */) { 6009 p.setCost(2 /* r */, (char)(c)); 6010 p.writePacked(0, 0xFFFF00FF, 0xB200); // p.r = 178 6011 closure_r(p, c); 6012 } 6013 } 6014 6015 /** 6016 * Labels FLOAT_SQRT tree node 6017 * @param p node to label 6018 */ 6019 private static void label_FLOAT_SQRT(AbstractBURS_TreeNode p) { 6020 p.initCost(); 6021 AbstractBURS_TreeNode lchild; 6022 lchild = p.getChild1(); 6023 label(lchild); 6024 int c; 6025 // r: FLOAT_SQRT(r) 6026 c = STATE(lchild).getCost(2 /* r */) + 13; 6027 if(BURS.DEBUG) trace(p, 297, c + 0, p.getCost(2) /* r */); 6028 if (c < p.getCost(2) /* r */) { 6029 p.setCost(2 /* r */, (char)(c)); 6030 p.writePacked(0, 0xFFFF00FF, 0xB300); // p.r = 179 6031 closure_r(p, c); 6032 } 6033 } 6034 6035 /** 6036 * Labels DOUBLE_SQRT tree node 6037 * @param p node to label 6038 */ 6039 private static void label_DOUBLE_SQRT(AbstractBURS_TreeNode p) { 6040 p.initCost(); 6041 AbstractBURS_TreeNode lchild; 6042 lchild = p.getChild1(); 6043 label(lchild); 6044 int c; 6045 // r: DOUBLE_SQRT(r) 6046 c = STATE(lchild).getCost(2 /* r */) + 13; 6047 if(BURS.DEBUG) trace(p, 298, c + 0, p.getCost(2) /* r */); 6048 if (c < p.getCost(2) /* r */) { 6049 p.setCost(2 /* r */, (char)(c)); 6050 p.writePacked(0, 0xFFFF00FF, 0xB400); // p.r = 180 6051 closure_r(p, c); 6052 } 6053 } 6054 6055 /** 6056 * Labels INT_SHL tree node 6057 * @param p node to label 6058 */ 6059 private static void label_INT_SHL(AbstractBURS_TreeNode p) { 6060 p.initCost(); 6061 AbstractBURS_TreeNode lchild, rchild; 6062 lchild = p.getChild1(); 6063 rchild = p.getChild2(); 6064 label(lchild); 6065 label(rchild); 6066 int c; 6067 if ( // address1scaledreg: INT_SHL(r,INT_CONSTANT) 6068 rchild.getOpcode() == INT_CONSTANT_opcode 6069 ) { 6070 c = STATE(lchild).getCost(2 /* r */) + LEA_SHIFT(Binary.getVal2(P(p)), 0); 6071 if(BURS.DEBUG) trace(p, 224, c + 0, p.getCost(16) /* address1scaledreg */); 6072 if (c < p.getCost(16) /* address1scaledreg */) { 6073 p.setCost(16 /* address1scaledreg */, (char)(c)); 6074 p.writePacked(1, 0xFF1FFFFF, 0x600000); // p.address1scaledreg = 3 6075 closure_address1scaledreg(p, c); 6076 } 6077 } 6078 if ( // szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 6079 rchild.getOpcode() == INT_AND_opcode && 6080 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6081 ) { 6082 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 6083 if(BURS.DEBUG) trace(p, 530, c + 0, p.getCost(5) /* szpr */); 6084 if (c < p.getCost(5) /* szpr */) { 6085 p.setCost(5 /* szpr */, (char)(c)); 6086 p.writePacked(0, 0xFC1FFFFF, 0x1400000); // p.szpr = 10 6087 closure_szpr(p, c); 6088 } 6089 } 6090 // szpr: INT_SHL(riv,riv) 6091 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 6092 if(BURS.DEBUG) trace(p, 105, c + 0, p.getCost(5) /* szpr */); 6093 if (c < p.getCost(5) /* szpr */) { 6094 p.setCost(5 /* szpr */, (char)(c)); 6095 p.writePacked(0, 0xFC1FFFFF, 0x1600000); // p.szpr = 11 6096 closure_szpr(p, c); 6097 } 6098 if ( // szpr: INT_SHL(r,INT_CONSTANT) 6099 rchild.getOpcode() == INT_CONSTANT_opcode 6100 ) { 6101 c = STATE(lchild).getCost(2 /* r */) + 13; 6102 if(BURS.DEBUG) trace(p, 282, c + 0, p.getCost(5) /* szpr */); 6103 if (c < p.getCost(5) /* szpr */) { 6104 p.setCost(5 /* szpr */, (char)(c)); 6105 p.writePacked(0, 0xFC1FFFFF, 0x1800000); // p.szpr = 12 6106 closure_szpr(p, c); 6107 } 6108 } 6109 if ( // r: INT_SHL(r,INT_CONSTANT) 6110 rchild.getOpcode() == INT_CONSTANT_opcode 6111 ) { 6112 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); 6113 if(BURS.DEBUG) trace(p, 283, c + 0, p.getCost(2) /* r */); 6114 if (c < p.getCost(2) /* r */) { 6115 p.setCost(2 /* r */, (char)(c)); 6116 p.writePacked(0, 0xFFFF00FF, 0x6600); // p.r = 102 6117 closure_r(p, c); 6118 } 6119 } 6120 if ( // szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 6121 lchild.getOpcode() == INT_SHR_opcode && 6122 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6123 rchild.getOpcode() == INT_CONSTANT_opcode 6124 ) { 6125 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == VLR(p)) ? 23 : INFINITE); 6126 if(BURS.DEBUG) trace(p, 334, c + 0, p.getCost(5) /* szpr */); 6127 if (c < p.getCost(5) /* szpr */) { 6128 p.setCost(5 /* szpr */, (char)(c)); 6129 p.writePacked(0, 0xFC1FFFFF, 0x1A00000); // p.szpr = 13 6130 closure_szpr(p, c); 6131 } 6132 } 6133 } 6134 6135 /** 6136 * Labels LONG_SHL tree node 6137 * @param p node to label 6138 */ 6139 private static void label_LONG_SHL(AbstractBURS_TreeNode p) { 6140 p.initCost(); 6141 AbstractBURS_TreeNode lchild, rchild; 6142 lchild = p.getChild1(); 6143 rchild = p.getChild2(); 6144 label(lchild); 6145 label(rchild); 6146 int c; 6147 if ( // r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) 6148 lchild.getOpcode() == INT_2LONG_opcode && 6149 rchild.getOpcode() == INT_CONSTANT_opcode 6150 ) { 6151 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VR(p) == 32 ? 23 : INFINITE); 6152 if(BURS.DEBUG) trace(p, 332, c + 0, p.getCost(2) /* r */); 6153 if (c < p.getCost(2) /* r */) { 6154 p.setCost(2 /* r */, (char)(c)); 6155 p.writePacked(0, 0xFFFF00FF, 0x4800); // p.r = 72 6156 closure_r(p, c); 6157 } 6158 } 6159 if ( // r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) 6160 lchild.getOpcode() == INT_2LONG_opcode && 6161 rchild.getOpcode() == INT_CONSTANT_opcode 6162 ) { 6163 c = STATE(lchild.getChild1()).getCost(22 /* load64 */) + (VR(p) == 32 ? 23 : INFINITE); 6164 if(BURS.DEBUG) trace(p, 333, c + 0, p.getCost(2) /* r */); 6165 if (c < p.getCost(2) /* r */) { 6166 p.setCost(2 /* r */, (char)(c)); 6167 p.writePacked(0, 0xFFFF00FF, 0x4900); // p.r = 73 6168 closure_r(p, c); 6169 } 6170 } 6171 // r: LONG_SHL(rlv,riv) 6172 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 20; 6173 if(BURS.DEBUG) trace(p, 153, c + 0, p.getCost(2) /* r */); 6174 if (c < p.getCost(2) /* r */) { 6175 p.setCost(2 /* r */, (char)(c)); 6176 p.writePacked(0, 0xFFFF00FF, 0x9100); // p.r = 145 6177 closure_r(p, c); 6178 } 6179 if ( // r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) 6180 rchild.getOpcode() == INT_AND_opcode && 6181 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6182 ) { 6183 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + 20; 6184 if(BURS.DEBUG) trace(p, 534, c + 0, p.getCost(2) /* r */); 6185 if (c < p.getCost(2) /* r */) { 6186 p.setCost(2 /* r */, (char)(c)); 6187 p.writePacked(0, 0xFFFF00FF, 0x9200); // p.r = 146 6188 closure_r(p, c); 6189 } 6190 } 6191 } 6192 6193 /** 6194 * Labels INT_SHR tree node 6195 * @param p node to label 6196 */ 6197 private static void label_INT_SHR(AbstractBURS_TreeNode p) { 6198 p.initCost(); 6199 AbstractBURS_TreeNode lchild, rchild; 6200 lchild = p.getChild1(); 6201 rchild = p.getChild2(); 6202 label(lchild); 6203 label(rchild); 6204 int c; 6205 if ( // szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 6206 rchild.getOpcode() == INT_AND_opcode && 6207 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6208 ) { 6209 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 6210 if(BURS.DEBUG) trace(p, 531, c + 0, p.getCost(5) /* szpr */); 6211 if (c < p.getCost(5) /* szpr */) { 6212 p.setCost(5 /* szpr */, (char)(c)); 6213 p.writePacked(0, 0xFC1FFFFF, 0x1C00000); // p.szpr = 14 6214 closure_szpr(p, c); 6215 } 6216 } 6217 // szpr: INT_SHR(riv,riv) 6218 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 6219 if(BURS.DEBUG) trace(p, 106, c + 0, p.getCost(5) /* szpr */); 6220 if (c < p.getCost(5) /* szpr */) { 6221 p.setCost(5 /* szpr */, (char)(c)); 6222 p.writePacked(0, 0xFC1FFFFF, 0x1E00000); // p.szpr = 15 6223 closure_szpr(p, c); 6224 } 6225 if ( // szpr: INT_SHR(riv,INT_CONSTANT) 6226 rchild.getOpcode() == INT_CONSTANT_opcode 6227 ) { 6228 c = STATE(lchild).getCost(7 /* riv */) + 13; 6229 if(BURS.DEBUG) trace(p, 284, c + 0, p.getCost(5) /* szpr */); 6230 if (c < p.getCost(5) /* szpr */) { 6231 p.setCost(5 /* szpr */, (char)(c)); 6232 p.writePacked(0, 0xFC1FFFFF, 0x2000000); // p.szpr = 16 6233 closure_szpr(p, c); 6234 } 6235 } 6236 } 6237 6238 /** 6239 * Labels LONG_SHR tree node 6240 * @param p node to label 6241 */ 6242 private static void label_LONG_SHR(AbstractBURS_TreeNode p) { 6243 p.initCost(); 6244 AbstractBURS_TreeNode lchild, rchild; 6245 lchild = p.getChild1(); 6246 rchild = p.getChild2(); 6247 label(lchild); 6248 label(rchild); 6249 int c; 6250 // r: LONG_SHR(rlv,riv) 6251 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 20; 6252 if(BURS.DEBUG) trace(p, 154, c + 0, p.getCost(2) /* r */); 6253 if (c < p.getCost(2) /* r */) { 6254 p.setCost(2 /* r */, (char)(c)); 6255 p.writePacked(0, 0xFFFF00FF, 0x9300); // p.r = 147 6256 closure_r(p, c); 6257 } 6258 if ( // r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) 6259 rchild.getOpcode() == INT_AND_opcode && 6260 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6261 ) { 6262 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + 20; 6263 if(BURS.DEBUG) trace(p, 535, c + 0, p.getCost(2) /* r */); 6264 if (c < p.getCost(2) /* r */) { 6265 p.setCost(2 /* r */, (char)(c)); 6266 p.writePacked(0, 0xFFFF00FF, 0x9400); // p.r = 148 6267 closure_r(p, c); 6268 } 6269 } 6270 } 6271 6272 /** 6273 * Labels INT_USHR tree node 6274 * @param p node to label 6275 */ 6276 private static void label_INT_USHR(AbstractBURS_TreeNode p) { 6277 p.initCost(); 6278 AbstractBURS_TreeNode lchild, rchild; 6279 lchild = p.getChild1(); 6280 rchild = p.getChild2(); 6281 label(lchild); 6282 label(rchild); 6283 int c; 6284 if ( // r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 6285 lchild.getOpcode() == INT_SHL_opcode && 6286 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6287 rchild.getOpcode() == INT_CONSTANT_opcode 6288 ) { 6289 c = STATE(lchild.getChild1()).getCost(12 /* load8_16_32 */) + (VR(p) == 24 && VLLR(p) == 24 ? 15 : INFINITE); 6290 if(BURS.DEBUG) trace(p, 326, c + 0, p.getCost(2) /* r */); 6291 if (c < p.getCost(2) /* r */) { 6292 p.setCost(2 /* r */, (char)(c)); 6293 p.writePacked(0, 0xFFFF00FF, 0x900); // p.r = 9 6294 closure_r(p, c); 6295 } 6296 } 6297 if ( // r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 6298 lchild.getOpcode() == INT_SHL_opcode && 6299 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6300 rchild.getOpcode() == INT_CONSTANT_opcode 6301 ) { 6302 c = STATE(lchild.getChild1()).getCost(13 /* load16_32 */) + (VR(p) == 16 && VLR(p) == 16 ? 15 : INFINITE); 6303 if(BURS.DEBUG) trace(p, 327, c + 0, p.getCost(2) /* r */); 6304 if (c < p.getCost(2) /* r */) { 6305 p.setCost(2 /* r */, (char)(c)); 6306 p.writePacked(0, 0xFFFF00FF, 0xB00); // p.r = 11 6307 closure_r(p, c); 6308 } 6309 } 6310 if ( // szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 6311 rchild.getOpcode() == INT_AND_opcode && 6312 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6313 ) { 6314 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(2 /* r */) + (VRR(p) == 31 ? 23 : INFINITE); 6315 if(BURS.DEBUG) trace(p, 533, c + 0, p.getCost(5) /* szpr */); 6316 if (c < p.getCost(5) /* szpr */) { 6317 p.setCost(5 /* szpr */, (char)(c)); 6318 p.writePacked(0, 0xFC1FFFFF, 0x2200000); // p.szpr = 17 6319 closure_szpr(p, c); 6320 } 6321 } 6322 // szpr: INT_USHR(riv,riv) 6323 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 23; 6324 if(BURS.DEBUG) trace(p, 112, c + 0, p.getCost(5) /* szpr */); 6325 if (c < p.getCost(5) /* szpr */) { 6326 p.setCost(5 /* szpr */, (char)(c)); 6327 p.writePacked(0, 0xFC1FFFFF, 0x2400000); // p.szpr = 18 6328 closure_szpr(p, c); 6329 } 6330 if ( // szpr: INT_USHR(riv,INT_CONSTANT) 6331 rchild.getOpcode() == INT_CONSTANT_opcode 6332 ) { 6333 c = STATE(lchild).getCost(7 /* riv */) + 13; 6334 if(BURS.DEBUG) trace(p, 285, c + 0, p.getCost(5) /* szpr */); 6335 if (c < p.getCost(5) /* szpr */) { 6336 p.setCost(5 /* szpr */, (char)(c)); 6337 p.writePacked(0, 0xFC1FFFFF, 0x2600000); // p.szpr = 19 6338 closure_szpr(p, c); 6339 } 6340 } 6341 } 6342 6343 /** 6344 * Labels LONG_USHR tree node 6345 * @param p node to label 6346 */ 6347 private static void label_LONG_USHR(AbstractBURS_TreeNode p) { 6348 p.initCost(); 6349 AbstractBURS_TreeNode lchild, rchild; 6350 lchild = p.getChild1(); 6351 rchild = p.getChild2(); 6352 label(lchild); 6353 label(rchild); 6354 int c; 6355 // r: LONG_USHR(rlv,riv) 6356 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(7 /* riv */) + 20; 6357 if(BURS.DEBUG) trace(p, 158, c + 0, p.getCost(2) /* r */); 6358 if (c < p.getCost(2) /* r */) { 6359 p.setCost(2 /* r */, (char)(c)); 6360 p.writePacked(0, 0xFFFF00FF, 0x9800); // p.r = 152 6361 closure_r(p, c); 6362 } 6363 if ( // r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) 6364 rchild.getOpcode() == INT_AND_opcode && 6365 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6366 ) { 6367 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + 20; 6368 if(BURS.DEBUG) trace(p, 536, c + 0, p.getCost(2) /* r */); 6369 if (c < p.getCost(2) /* r */) { 6370 p.setCost(2 /* r */, (char)(c)); 6371 p.writePacked(0, 0xFFFF00FF, 0x9900); // p.r = 153 6372 closure_r(p, c); 6373 } 6374 } 6375 } 6376 6377 /** 6378 * Labels INT_AND tree node 6379 * @param p node to label 6380 */ 6381 private static void label_INT_AND(AbstractBURS_TreeNode p) { 6382 p.initCost(); 6383 AbstractBURS_TreeNode lchild, rchild; 6384 lchild = p.getChild1(); 6385 rchild = p.getChild2(); 6386 label(lchild); 6387 label(rchild); 6388 int c; 6389 if ( // uload8: INT_AND(load8_16_32,INT_CONSTANT) 6390 rchild.getOpcode() == INT_CONSTANT_opcode 6391 ) { 6392 c = STATE(lchild).getCost(12 /* load8_16_32 */) + (VR(p) == 0xff ? 0 : INFINITE); 6393 if(BURS.DEBUG) trace(p, 211, c + 0, p.getCost(11) /* uload8 */); 6394 if (c < p.getCost(11) /* uload8 */) { 6395 p.setCost(11 /* uload8 */, (char)(c)); 6396 p.writePacked(1, 0xFFFFF8FF, 0x100); // p.uload8 = 1 6397 closure_uload8(p, c); 6398 } 6399 } 6400 if ( // r: INT_AND(load8_16_32,INT_CONSTANT) 6401 rchild.getOpcode() == INT_CONSTANT_opcode 6402 ) { 6403 c = STATE(lchild).getCost(12 /* load8_16_32 */) + (VR(p) == 0xff ? 15 : INFINITE); 6404 if(BURS.DEBUG) trace(p, 212, c + 0, p.getCost(2) /* r */); 6405 if (c < p.getCost(2) /* r */) { 6406 p.setCost(2 /* r */, (char)(c)); 6407 p.writePacked(0, 0xFFFF00FF, 0x700); // p.r = 7 6408 closure_r(p, c); 6409 } 6410 } 6411 if ( // r: INT_AND(load16_32,INT_CONSTANT) 6412 rchild.getOpcode() == INT_CONSTANT_opcode 6413 ) { 6414 c = STATE(lchild).getCost(13 /* load16_32 */) + (VR(p) == 0xffff ? 15 : INFINITE); 6415 if(BURS.DEBUG) trace(p, 214, c + 0, p.getCost(2) /* r */); 6416 if (c < p.getCost(2) /* r */) { 6417 p.setCost(2 /* r */, (char)(c)); 6418 p.writePacked(0, 0xFFFF00FF, 0xA00); // p.r = 10 6419 closure_r(p, c); 6420 } 6421 } 6422 if ( // bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 6423 lchild.getOpcode() == INT_USHR_opcode && 6424 lchild.getChild2().getOpcode() == INT_AND_opcode && 6425 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6426 rchild.getOpcode() == INT_CONSTANT_opcode 6427 ) { 6428 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLRR(p) == 31) ? 13:INFINITE); 6429 if(BURS.DEBUG) trace(p, 442, c + 0, p.getCost(18) /* bittest */); 6430 if (c < p.getCost(18) /* bittest */) { 6431 p.setCost(18 /* bittest */, (char)(c)); 6432 p.writePacked(1, 0x87FFFFFF, 0x8000000); // p.bittest = 1 6433 } 6434 } 6435 if ( // bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 6436 lchild.getOpcode() == INT_USHR_opcode && 6437 lchild.getChild2().getOpcode() == INT_AND_opcode && 6438 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6439 rchild.getOpcode() == INT_CONSTANT_opcode 6440 ) { 6441 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + (VR(p) == 1 ? 31:INFINITE); 6442 if(BURS.DEBUG) trace(p, 443, c + 0, p.getCost(18) /* bittest */); 6443 if (c < p.getCost(18) /* bittest */) { 6444 p.setCost(18 /* bittest */, (char)(c)); 6445 p.writePacked(1, 0x87FFFFFF, 0x10000000); // p.bittest = 2 6446 } 6447 } 6448 if ( // bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6449 lchild.getOpcode() == INT_USHR_opcode && 6450 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6451 rchild.getOpcode() == INT_CONSTANT_opcode 6452 ) { 6453 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLR(p) <= 31) ? 13:INFINITE); 6454 if(BURS.DEBUG) trace(p, 328, c + 0, p.getCost(18) /* bittest */); 6455 if (c < p.getCost(18) /* bittest */) { 6456 p.setCost(18 /* bittest */, (char)(c)); 6457 p.writePacked(1, 0x87FFFFFF, 0x18000000); // p.bittest = 3 6458 } 6459 } 6460 if ( // bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 6461 lchild.getOpcode() == INT_SHR_opcode && 6462 lchild.getChild2().getOpcode() == INT_AND_opcode && 6463 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6464 rchild.getOpcode() == INT_CONSTANT_opcode 6465 ) { 6466 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLRR(p) == 31) ? 13:INFINITE); 6467 if(BURS.DEBUG) trace(p, 444, c + 0, p.getCost(18) /* bittest */); 6468 if (c < p.getCost(18) /* bittest */) { 6469 p.setCost(18 /* bittest */, (char)(c)); 6470 p.writePacked(1, 0x87FFFFFF, 0x20000000); // p.bittest = 4 6471 } 6472 } 6473 if ( // bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 6474 lchild.getOpcode() == INT_SHR_opcode && 6475 lchild.getChild2().getOpcode() == INT_AND_opcode && 6476 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6477 rchild.getOpcode() == INT_CONSTANT_opcode 6478 ) { 6479 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + (VR(p) == 1 ? 31:INFINITE); 6480 if(BURS.DEBUG) trace(p, 445, c + 0, p.getCost(18) /* bittest */); 6481 if (c < p.getCost(18) /* bittest */) { 6482 p.setCost(18 /* bittest */, (char)(c)); 6483 p.writePacked(1, 0x87FFFFFF, 0x28000000); // p.bittest = 5 6484 } 6485 } 6486 if ( // bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 6487 lchild.getOpcode() == INT_SHR_opcode && 6488 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6489 rchild.getOpcode() == INT_CONSTANT_opcode 6490 ) { 6491 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VR(p) == 1) && (VLR(p) <= 31) ? 13:INFINITE); 6492 if(BURS.DEBUG) trace(p, 329, c + 0, p.getCost(18) /* bittest */); 6493 if (c < p.getCost(18) /* bittest */) { 6494 p.setCost(18 /* bittest */, (char)(c)); 6495 p.writePacked(1, 0x87FFFFFF, 0x30000000); // p.bittest = 6 6496 } 6497 } 6498 if ( // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 6499 lchild.getOpcode() == INT_SHL_opcode && 6500 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 6501 lchild.getChild2().getOpcode() == INT_AND_opcode && 6502 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6503 ) { 6504 c = STATE(lchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild).getCost(2 /* r */) + ((VLL(p) == 1) && (VLRR(p) == 31)? 13:INFINITE); 6505 if(BURS.DEBUG) trace(p, 446, c + 0, p.getCost(18) /* bittest */); 6506 if (c < p.getCost(18) /* bittest */) { 6507 p.setCost(18 /* bittest */, (char)(c)); 6508 p.writePacked(1, 0x87FFFFFF, 0x38000000); // p.bittest = 7 6509 } 6510 } 6511 if ( // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 6512 lchild.getOpcode() == INT_SHL_opcode && 6513 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 6514 lchild.getChild2().getOpcode() == INT_AND_opcode && 6515 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6516 ) { 6517 c = STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + (VLL(p) == 1 ? 31:INFINITE); 6518 if(BURS.DEBUG) trace(p, 447, c + 0, p.getCost(18) /* bittest */); 6519 if (c < p.getCost(18) /* bittest */) { 6520 p.setCost(18 /* bittest */, (char)(c)); 6521 p.writePacked(1, 0x87FFFFFF, 0x40000000); // p.bittest = 8 6522 } 6523 } 6524 if ( // bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 6525 rchild.getOpcode() == INT_SHL_opcode && 6526 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 6527 rchild.getChild2().getOpcode() == INT_AND_opcode && 6528 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6529 ) { 6530 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + ((VRL(p) == 1) && (VRRR(p) == 31) ? 13:INFINITE); 6531 if(BURS.DEBUG) trace(p, 448, c + 0, p.getCost(18) /* bittest */); 6532 if (c < p.getCost(18) /* bittest */) { 6533 p.setCost(18 /* bittest */, (char)(c)); 6534 p.writePacked(1, 0x87FFFFFF, 0x48000000); // p.bittest = 9 6535 } 6536 } 6537 if ( // bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 6538 rchild.getOpcode() == INT_SHL_opcode && 6539 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 6540 rchild.getChild2().getOpcode() == INT_AND_opcode && 6541 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6542 ) { 6543 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + (VRL(p) == 1 ? 31:INFINITE); 6544 if(BURS.DEBUG) trace(p, 449, c + 0, p.getCost(18) /* bittest */); 6545 if (c < p.getCost(18) /* bittest */) { 6546 p.setCost(18 /* bittest */, (char)(c)); 6547 p.writePacked(1, 0x87FFFFFF, 0x50000000); // p.bittest = 10 6548 } 6549 } 6550 // szpr: INT_AND(r,riv) 6551 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 6552 if(BURS.DEBUG) trace(p, 75, c + 0, p.getCost(5) /* szpr */); 6553 if (c < p.getCost(5) /* szpr */) { 6554 p.setCost(5 /* szpr */, (char)(c)); 6555 p.writePacked(0, 0xFC1FFFFF, 0x400000); // p.szpr = 2 6556 closure_szpr(p, c); 6557 } 6558 // szp: INT_AND(r,riv) 6559 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 11; 6560 if(BURS.DEBUG) trace(p, 76, c + 0, p.getCost(6) /* szp */); 6561 if (c < p.getCost(6) /* szp */) { 6562 p.setCost(6 /* szp */, (char)(c)); 6563 p.writePacked(0, 0xE3FFFFFF, 0x8000000); // p.szp = 2 6564 } 6565 // szpr: INT_AND(r,load32) 6566 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 6567 if(BURS.DEBUG) trace(p, 77, c + 0, p.getCost(5) /* szpr */); 6568 if (c < p.getCost(5) /* szpr */) { 6569 p.setCost(5 /* szpr */, (char)(c)); 6570 p.writePacked(0, 0xFC1FFFFF, 0x600000); // p.szpr = 3 6571 closure_szpr(p, c); 6572 } 6573 // szpr: INT_AND(load32,riv) 6574 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 6575 if(BURS.DEBUG) trace(p, 78, c + 0, p.getCost(5) /* szpr */); 6576 if (c < p.getCost(5) /* szpr */) { 6577 p.setCost(5 /* szpr */, (char)(c)); 6578 p.writePacked(0, 0xFC1FFFFF, 0x800000); // p.szpr = 4 6579 closure_szpr(p, c); 6580 } 6581 // szp: INT_AND(load8_16_32,riv) 6582 c = STATE(lchild).getCost(12 /* load8_16_32 */) + STATE(rchild).getCost(7 /* riv */) + 11; 6583 if(BURS.DEBUG) trace(p, 79, c + 0, p.getCost(6) /* szp */); 6584 if (c < p.getCost(6) /* szp */) { 6585 p.setCost(6 /* szp */, (char)(c)); 6586 p.writePacked(0, 0xE3FFFFFF, 0xC000000); // p.szp = 3 6587 } 6588 // szp: INT_AND(r,load8_16_32) 6589 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(12 /* load8_16_32 */) + 11; 6590 if(BURS.DEBUG) trace(p, 80, c + 0, p.getCost(6) /* szp */); 6591 if (c < p.getCost(6) /* szp */) { 6592 p.setCost(6 /* szp */, (char)(c)); 6593 p.writePacked(0, 0xE3FFFFFF, 0x10000000); // p.szp = 4 6594 } 6595 } 6596 6597 /** 6598 * Labels LONG_AND tree node 6599 * @param p node to label 6600 */ 6601 private static void label_LONG_AND(AbstractBURS_TreeNode p) { 6602 p.initCost(); 6603 AbstractBURS_TreeNode lchild, rchild; 6604 lchild = p.getChild1(); 6605 rchild = p.getChild2(); 6606 label(lchild); 6607 label(rchild); 6608 int c; 6609 if ( // r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 6610 lchild.getOpcode() == INT_2LONG_opcode && 6611 rchild.getOpcode() == LONG_CONSTANT_opcode 6612 ) { 6613 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((Binary.getVal2(P(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(P(p)).asLongConstant().lower32() == -1)? 23 : INFINITE); 6614 if(BURS.DEBUG) trace(p, 330, c + 0, p.getCost(2) /* r */); 6615 if (c < p.getCost(2) /* r */) { 6616 p.setCost(2 /* r */, (char)(c)); 6617 p.writePacked(0, 0xFFFF00FF, 0x4600); // p.r = 70 6618 closure_r(p, c); 6619 } 6620 } 6621 if ( // r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 6622 lchild.getOpcode() == INT_2LONG_opcode && 6623 rchild.getOpcode() == LONG_CONSTANT_opcode 6624 ) { 6625 c = STATE(lchild.getChild1()).getCost(10 /* load32 */) + ((Binary.getVal2(P(p)).asLongConstant().upper32() == 0) && (Binary.getVal2(P(p)).asLongConstant().lower32() == -1)? 28 : INFINITE); 6626 if(BURS.DEBUG) trace(p, 331, c + 0, p.getCost(2) /* r */); 6627 if (c < p.getCost(2) /* r */) { 6628 p.setCost(2 /* r */, (char)(c)); 6629 p.writePacked(0, 0xFFFF00FF, 0x4700); // p.r = 71 6630 closure_r(p, c); 6631 } 6632 } 6633 // r: LONG_AND(r,rlv) 6634 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 26; 6635 if(BURS.DEBUG) trace(p, 143, c + 0, p.getCost(2) /* r */); 6636 if (c < p.getCost(2) /* r */) { 6637 p.setCost(2 /* r */, (char)(c)); 6638 p.writePacked(0, 0xFFFF00FF, 0x8100); // p.r = 129 6639 closure_r(p, c); 6640 } 6641 // r: LONG_AND(r,load64) 6642 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(22 /* load64 */) + 30; 6643 if(BURS.DEBUG) trace(p, 144, c + 0, p.getCost(2) /* r */); 6644 if (c < p.getCost(2) /* r */) { 6645 p.setCost(2 /* r */, (char)(c)); 6646 p.writePacked(0, 0xFFFF00FF, 0x8200); // p.r = 130 6647 closure_r(p, c); 6648 } 6649 // r: LONG_AND(load64,rlv) 6650 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 30; 6651 if(BURS.DEBUG) trace(p, 145, c + 0, p.getCost(2) /* r */); 6652 if (c < p.getCost(2) /* r */) { 6653 p.setCost(2 /* r */, (char)(c)); 6654 p.writePacked(0, 0xFFFF00FF, 0x8300); // p.r = 131 6655 closure_r(p, c); 6656 } 6657 } 6658 6659 /** 6660 * Labels INT_OR tree node 6661 * @param p node to label 6662 */ 6663 private static void label_INT_OR(AbstractBURS_TreeNode p) { 6664 p.initCost(); 6665 AbstractBURS_TreeNode lchild, rchild; 6666 lchild = p.getChild1(); 6667 rchild = p.getChild2(); 6668 label(lchild); 6669 label(rchild); 6670 int c; 6671 // szpr: INT_OR(r,riv) 6672 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 6673 if(BURS.DEBUG) trace(p, 100, c + 0, p.getCost(5) /* szpr */); 6674 if (c < p.getCost(5) /* szpr */) { 6675 p.setCost(5 /* szpr */, (char)(c)); 6676 p.writePacked(0, 0xFC1FFFFF, 0xE00000); // p.szpr = 7 6677 closure_szpr(p, c); 6678 } 6679 // szpr: INT_OR(r,load32) 6680 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 6681 if(BURS.DEBUG) trace(p, 101, c + 0, p.getCost(5) /* szpr */); 6682 if (c < p.getCost(5) /* szpr */) { 6683 p.setCost(5 /* szpr */, (char)(c)); 6684 p.writePacked(0, 0xFC1FFFFF, 0x1000000); // p.szpr = 8 6685 closure_szpr(p, c); 6686 } 6687 // szpr: INT_OR(load32,riv) 6688 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 6689 if(BURS.DEBUG) trace(p, 102, c + 0, p.getCost(5) /* szpr */); 6690 if (c < p.getCost(5) /* szpr */) { 6691 p.setCost(5 /* szpr */, (char)(c)); 6692 p.writePacked(0, 0xFC1FFFFF, 0x1200000); // p.szpr = 9 6693 closure_szpr(p, c); 6694 } 6695 if ( // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 6696 lchild.getOpcode() == INT_SHL_opcode && 6697 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6698 rchild.getOpcode() == INT_USHR_opcode && 6699 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6700 ) { 6701 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); 6702 if(BURS.DEBUG) trace(p, 520, c + 0, p.getCost(2) /* r */); 6703 if (c < p.getCost(2) /* r */) { 6704 p.setCost(2 /* r */, (char)(c)); 6705 p.writePacked(0, 0xFFFF00FF, 0x5E00); // p.r = 94 6706 closure_r(p, c); 6707 } 6708 } 6709 if ( // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 6710 lchild.getOpcode() == INT_USHR_opcode && 6711 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6712 rchild.getOpcode() == INT_SHL_opcode && 6713 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6714 ) { 6715 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); 6716 if(BURS.DEBUG) trace(p, 521, c + 0, p.getCost(2) /* r */); 6717 if (c < p.getCost(2) /* r */) { 6718 p.setCost(2 /* r */, (char)(c)); 6719 p.writePacked(0, 0xFFFF00FF, 0x5F00); // p.r = 95 6720 closure_r(p, c); 6721 } 6722 } 6723 if ( // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 6724 lchild.getOpcode() == INT_SHL_opcode && 6725 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6726 rchild.getOpcode() == INT_USHR_opcode && 6727 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6728 ) { 6729 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); 6730 if(BURS.DEBUG) trace(p, 522, c + 0, p.getCost(2) /* r */); 6731 if (c < p.getCost(2) /* r */) { 6732 p.setCost(2 /* r */, (char)(c)); 6733 p.writePacked(0, 0xFFFF00FF, 0x6000); // p.r = 96 6734 closure_r(p, c); 6735 } 6736 } 6737 if ( // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 6738 lchild.getOpcode() == INT_USHR_opcode && 6739 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 6740 rchild.getOpcode() == INT_SHL_opcode && 6741 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 6742 ) { 6743 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); 6744 if(BURS.DEBUG) trace(p, 523, c + 0, p.getCost(2) /* r */); 6745 if (c < p.getCost(2) /* r */) { 6746 p.setCost(2 /* r */, (char)(c)); 6747 p.writePacked(0, 0xFFFF00FF, 0x6100); // p.r = 97 6748 closure_r(p, c); 6749 } 6750 } 6751 if ( // r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 6752 lchild.getOpcode() == INT_SHL_opcode && 6753 lchild.getChild2().getOpcode() == INT_AND_opcode && 6754 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6755 rchild.getOpcode() == INT_USHR_opcode && 6756 rchild.getChild2().getOpcode() == INT_AND_opcode && 6757 rchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 6758 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6759 ) { 6760 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); 6761 if(BURS.DEBUG) trace(p, 526, c + 0, p.getCost(2) /* r */); 6762 if (c < p.getCost(2) /* r */) { 6763 p.setCost(2 /* r */, (char)(c)); 6764 p.writePacked(0, 0xFFFF00FF, 0x6200); // p.r = 98 6765 closure_r(p, c); 6766 } 6767 } 6768 if ( // r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 6769 lchild.getOpcode() == INT_USHR_opcode && 6770 lchild.getChild2().getOpcode() == INT_AND_opcode && 6771 lchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 6772 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6773 rchild.getOpcode() == INT_SHL_opcode && 6774 rchild.getChild2().getOpcode() == INT_AND_opcode && 6775 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6776 ) { 6777 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); 6778 if(BURS.DEBUG) trace(p, 528, c + 0, p.getCost(2) /* r */); 6779 if (c < p.getCost(2) /* r */) { 6780 p.setCost(2 /* r */, (char)(c)); 6781 p.writePacked(0, 0xFFFF00FF, 0x6300); // p.r = 99 6782 closure_r(p, c); 6783 } 6784 } 6785 if ( // r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 6786 lchild.getOpcode() == INT_SHL_opcode && 6787 lchild.getChild2().getOpcode() == INT_AND_opcode && 6788 lchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 6789 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6790 rchild.getOpcode() == INT_USHR_opcode && 6791 rchild.getChild2().getOpcode() == INT_AND_opcode && 6792 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6793 ) { 6794 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); 6795 if(BURS.DEBUG) trace(p, 529, c + 0, p.getCost(2) /* r */); 6796 if (c < p.getCost(2) /* r */) { 6797 p.setCost(2 /* r */, (char)(c)); 6798 p.writePacked(0, 0xFFFF00FF, 0x6400); // p.r = 100 6799 closure_r(p, c); 6800 } 6801 } 6802 if ( // r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 6803 lchild.getOpcode() == INT_USHR_opcode && 6804 lchild.getChild2().getOpcode() == INT_AND_opcode && 6805 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 6806 rchild.getOpcode() == INT_SHL_opcode && 6807 rchild.getChild2().getOpcode() == INT_AND_opcode && 6808 rchild.getChild2().getChild1().getOpcode() == INT_NEG_opcode && 6809 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 6810 ) { 6811 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); 6812 if(BURS.DEBUG) trace(p, 527, c + 0, p.getCost(2) /* r */); 6813 if (c < p.getCost(2) /* r */) { 6814 p.setCost(2 /* r */, (char)(c)); 6815 p.writePacked(0, 0xFFFF00FF, 0x6500); // p.r = 101 6816 closure_r(p, c); 6817 } 6818 } 6819 } 6820 6821 /** 6822 * Labels LONG_OR tree node 6823 * @param p node to label 6824 */ 6825 private static void label_LONG_OR(AbstractBURS_TreeNode p) { 6826 p.initCost(); 6827 AbstractBURS_TreeNode lchild, rchild; 6828 lchild = p.getChild1(); 6829 rchild = p.getChild2(); 6830 label(lchild); 6831 label(rchild); 6832 int c; 6833 // r: LONG_OR(r,rlv) 6834 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 26; 6835 if(BURS.DEBUG) trace(p, 150, c + 0, p.getCost(2) /* r */); 6836 if (c < p.getCost(2) /* r */) { 6837 p.setCost(2 /* r */, (char)(c)); 6838 p.writePacked(0, 0xFFFF00FF, 0x8E00); // p.r = 142 6839 closure_r(p, c); 6840 } 6841 // r: LONG_OR(r,load64) 6842 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(22 /* load64 */) + 30; 6843 if(BURS.DEBUG) trace(p, 151, c + 0, p.getCost(2) /* r */); 6844 if (c < p.getCost(2) /* r */) { 6845 p.setCost(2 /* r */, (char)(c)); 6846 p.writePacked(0, 0xFFFF00FF, 0x8F00); // p.r = 143 6847 closure_r(p, c); 6848 } 6849 // r: LONG_OR(load64,rlv) 6850 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 30; 6851 if(BURS.DEBUG) trace(p, 152, c + 0, p.getCost(2) /* r */); 6852 if (c < p.getCost(2) /* r */) { 6853 p.setCost(2 /* r */, (char)(c)); 6854 p.writePacked(0, 0xFFFF00FF, 0x9000); // p.r = 144 6855 closure_r(p, c); 6856 } 6857 } 6858 6859 /** 6860 * Labels INT_XOR tree node 6861 * @param p node to label 6862 */ 6863 private static void label_INT_XOR(AbstractBURS_TreeNode p) { 6864 p.initCost(); 6865 AbstractBURS_TreeNode lchild, rchild; 6866 lchild = p.getChild1(); 6867 rchild = p.getChild2(); 6868 label(lchild); 6869 label(rchild); 6870 int c; 6871 // szpr: INT_XOR(r,riv) 6872 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 6873 if(BURS.DEBUG) trace(p, 113, c + 0, p.getCost(5) /* szpr */); 6874 if (c < p.getCost(5) /* szpr */) { 6875 p.setCost(5 /* szpr */, (char)(c)); 6876 p.writePacked(0, 0xFC1FFFFF, 0x2800000); // p.szpr = 20 6877 closure_szpr(p, c); 6878 } 6879 // szpr: INT_XOR(r,load32) 6880 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 15; 6881 if(BURS.DEBUG) trace(p, 114, c + 0, p.getCost(5) /* szpr */); 6882 if (c < p.getCost(5) /* szpr */) { 6883 p.setCost(5 /* szpr */, (char)(c)); 6884 p.writePacked(0, 0xFC1FFFFF, 0x2A00000); // p.szpr = 21 6885 closure_szpr(p, c); 6886 } 6887 // szpr: INT_XOR(load32,riv) 6888 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 6889 if(BURS.DEBUG) trace(p, 115, c + 0, p.getCost(5) /* szpr */); 6890 if (c < p.getCost(5) /* szpr */) { 6891 p.setCost(5 /* szpr */, (char)(c)); 6892 p.writePacked(0, 0xFC1FFFFF, 0x2C00000); // p.szpr = 22 6893 closure_szpr(p, c); 6894 } 6895 } 6896 6897 /** 6898 * Labels INT_NOT tree node 6899 * @param p node to label 6900 */ 6901 private static void label_INT_NOT(AbstractBURS_TreeNode p) { 6902 p.initCost(); 6903 AbstractBURS_TreeNode lchild; 6904 lchild = p.getChild1(); 6905 label(lchild); 6906 int c; 6907 // r: INT_NOT(r) 6908 c = STATE(lchild).getCost(2 /* r */) + 13; 6909 if(BURS.DEBUG) trace(p, 281, c + 0, p.getCost(2) /* r */); 6910 if (c < p.getCost(2) /* r */) { 6911 p.setCost(2 /* r */, (char)(c)); 6912 p.writePacked(0, 0xFFFF00FF, 0x5B00); // p.r = 91 6913 closure_r(p, c); 6914 } 6915 } 6916 6917 /** 6918 * Labels LONG_NOT tree node 6919 * @param p node to label 6920 */ 6921 private static void label_LONG_NOT(AbstractBURS_TreeNode p) { 6922 p.initCost(); 6923 AbstractBURS_TreeNode lchild; 6924 lchild = p.getChild1(); 6925 label(lchild); 6926 int c; 6927 // r: LONG_NOT(r) 6928 c = STATE(lchild).getCost(2 /* r */) + 26; 6929 if(BURS.DEBUG) trace(p, 294, c + 0, p.getCost(2) /* r */); 6930 if (c < p.getCost(2) /* r */) { 6931 p.setCost(2 /* r */, (char)(c)); 6932 p.writePacked(0, 0xFFFF00FF, 0x8D00); // p.r = 141 6933 closure_r(p, c); 6934 } 6935 } 6936 6937 /** 6938 * Labels LONG_XOR tree node 6939 * @param p node to label 6940 */ 6941 private static void label_LONG_XOR(AbstractBURS_TreeNode p) { 6942 p.initCost(); 6943 AbstractBURS_TreeNode lchild, rchild; 6944 lchild = p.getChild1(); 6945 rchild = p.getChild2(); 6946 label(lchild); 6947 label(rchild); 6948 int c; 6949 // r: LONG_XOR(r,rlv) 6950 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(8 /* rlv */) + 26; 6951 if(BURS.DEBUG) trace(p, 159, c + 0, p.getCost(2) /* r */); 6952 if (c < p.getCost(2) /* r */) { 6953 p.setCost(2 /* r */, (char)(c)); 6954 p.writePacked(0, 0xFFFF00FF, 0x9A00); // p.r = 154 6955 closure_r(p, c); 6956 } 6957 // r: LONG_XOR(r,load64) 6958 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(22 /* load64 */) + 30; 6959 if(BURS.DEBUG) trace(p, 160, c + 0, p.getCost(2) /* r */); 6960 if (c < p.getCost(2) /* r */) { 6961 p.setCost(2 /* r */, (char)(c)); 6962 p.writePacked(0, 0xFFFF00FF, 0x9B00); // p.r = 155 6963 closure_r(p, c); 6964 } 6965 // r: LONG_XOR(load64,rlv) 6966 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild).getCost(8 /* rlv */) + 30; 6967 if(BURS.DEBUG) trace(p, 161, c + 0, p.getCost(2) /* r */); 6968 if (c < p.getCost(2) /* r */) { 6969 p.setCost(2 /* r */, (char)(c)); 6970 p.writePacked(0, 0xFFFF00FF, 0x9C00); // p.r = 156 6971 closure_r(p, c); 6972 } 6973 } 6974 6975 /** 6976 * Labels ADDR_2LONG tree node 6977 * @param p node to label 6978 */ 6979 private static void label_ADDR_2LONG(AbstractBURS_TreeNode p) { 6980 p.initCost(); 6981 AbstractBURS_TreeNode lchild; 6982 lchild = p.getChild1(); 6983 label(lchild); 6984 int c; 6985 // r: ADDR_2LONG(r) 6986 c = STATE(lchild).getCost(2 /* r */) + 33; 6987 if(BURS.DEBUG) trace(p, 226, c + 0, p.getCost(2) /* r */); 6988 if (c < p.getCost(2) /* r */) { 6989 p.setCost(2 /* r */, (char)(c)); 6990 p.writePacked(0, 0xFFFF00FF, 0x1600); // p.r = 22 6991 closure_r(p, c); 6992 } 6993 // r: ADDR_2LONG(load32) 6994 c = STATE(lchild).getCost(10 /* load32 */) + 38; 6995 if(BURS.DEBUG) trace(p, 227, c + 0, p.getCost(2) /* r */); 6996 if (c < p.getCost(2) /* r */) { 6997 p.setCost(2 /* r */, (char)(c)); 6998 p.writePacked(0, 0xFFFF00FF, 0x1700); // p.r = 23 6999 closure_r(p, c); 7000 } 7001 } 7002 7003 /** 7004 * Labels INT_2LONG tree node 7005 * @param p node to label 7006 */ 7007 private static void label_INT_2LONG(AbstractBURS_TreeNode p) { 7008 p.initCost(); 7009 AbstractBURS_TreeNode lchild; 7010 lchild = p.getChild1(); 7011 label(lchild); 7012 int c; 7013 // r: INT_2LONG(r) 7014 c = STATE(lchild).getCost(2 /* r */) + 33; 7015 if(BURS.DEBUG) trace(p, 251, c + 0, p.getCost(2) /* r */); 7016 if (c < p.getCost(2) /* r */) { 7017 p.setCost(2 /* r */, (char)(c)); 7018 p.writePacked(0, 0xFFFF00FF, 0x4400); // p.r = 68 7019 closure_r(p, c); 7020 } 7021 // r: INT_2LONG(load32) 7022 c = STATE(lchild).getCost(10 /* load32 */) + 38; 7023 if(BURS.DEBUG) trace(p, 252, c + 0, p.getCost(2) /* r */); 7024 if (c < p.getCost(2) /* r */) { 7025 p.setCost(2 /* r */, (char)(c)); 7026 p.writePacked(0, 0xFFFF00FF, 0x4500); // p.r = 69 7027 closure_r(p, c); 7028 } 7029 } 7030 7031 /** 7032 * Labels INT_2FLOAT tree node 7033 * @param p node to label 7034 */ 7035 private static void label_INT_2FLOAT(AbstractBURS_TreeNode p) { 7036 p.initCost(); 7037 AbstractBURS_TreeNode lchild; 7038 lchild = p.getChild1(); 7039 label(lchild); 7040 int c; 7041 // r: INT_2FLOAT(riv) 7042 c = STATE(lchild).getCost(7 /* riv */) + 13; 7043 if(BURS.DEBUG) trace(p, 303, c + 0, p.getCost(2) /* r */); 7044 if (c < p.getCost(2) /* r */) { 7045 p.setCost(2 /* r */, (char)(c)); 7046 p.writePacked(0, 0xFFFF00FF, 0xC600); // p.r = 198 7047 closure_r(p, c); 7048 } 7049 // r: INT_2FLOAT(load32) 7050 c = STATE(lchild).getCost(10 /* load32 */) + 15; 7051 if(BURS.DEBUG) trace(p, 304, c + 0, p.getCost(2) /* r */); 7052 if (c < p.getCost(2) /* r */) { 7053 p.setCost(2 /* r */, (char)(c)); 7054 p.writePacked(0, 0xFFFF00FF, 0xC700); // p.r = 199 7055 closure_r(p, c); 7056 } 7057 } 7058 7059 /** 7060 * Labels INT_2DOUBLE tree node 7061 * @param p node to label 7062 */ 7063 private static void label_INT_2DOUBLE(AbstractBURS_TreeNode p) { 7064 p.initCost(); 7065 AbstractBURS_TreeNode lchild; 7066 lchild = p.getChild1(); 7067 label(lchild); 7068 int c; 7069 // r: INT_2DOUBLE(riv) 7070 c = STATE(lchild).getCost(7 /* riv */) + 13; 7071 if(BURS.DEBUG) trace(p, 305, c + 0, p.getCost(2) /* r */); 7072 if (c < p.getCost(2) /* r */) { 7073 p.setCost(2 /* r */, (char)(c)); 7074 p.writePacked(0, 0xFFFF00FF, 0xC800); // p.r = 200 7075 closure_r(p, c); 7076 } 7077 // r: INT_2DOUBLE(load32) 7078 c = STATE(lchild).getCost(10 /* load32 */) + 15; 7079 if(BURS.DEBUG) trace(p, 306, c + 0, p.getCost(2) /* r */); 7080 if (c < p.getCost(2) /* r */) { 7081 p.setCost(2 /* r */, (char)(c)); 7082 p.writePacked(0, 0xFFFF00FF, 0xC900); // p.r = 201 7083 closure_r(p, c); 7084 } 7085 } 7086 7087 /** 7088 * Labels LONG_2INT tree node 7089 * @param p node to label 7090 */ 7091 private static void label_LONG_2INT(AbstractBURS_TreeNode p) { 7092 p.initCost(); 7093 AbstractBURS_TreeNode lchild; 7094 lchild = p.getChild1(); 7095 label(lchild); 7096 int c; 7097 // r: LONG_2INT(r) 7098 c = STATE(lchild).getCost(2 /* r */) + 13; 7099 if(BURS.DEBUG) trace(p, 288, c + 0, p.getCost(2) /* r */); 7100 if (c < p.getCost(2) /* r */) { 7101 p.setCost(2 /* r */, (char)(c)); 7102 p.writePacked(0, 0xFFFF00FF, 0x7800); // p.r = 120 7103 closure_r(p, c); 7104 } 7105 // r: LONG_2INT(load64) 7106 c = STATE(lchild).getCost(22 /* load64 */) + 15; 7107 if(BURS.DEBUG) trace(p, 289, c + 0, p.getCost(2) /* r */); 7108 if (c < p.getCost(2) /* r */) { 7109 p.setCost(2 /* r */, (char)(c)); 7110 p.writePacked(0, 0xFFFF00FF, 0x7900); // p.r = 121 7111 closure_r(p, c); 7112 } 7113 // load32: LONG_2INT(load64) 7114 c = STATE(lchild).getCost(22 /* load64 */) + 0; 7115 if(BURS.DEBUG) trace(p, 290, c + 0, p.getCost(10) /* load32 */); 7116 if (c < p.getCost(10) /* load32 */) { 7117 p.setCost(10 /* load32 */, (char)(c)); 7118 p.writePacked(1, 0xFFFFFF1F, 0x80); // p.load32 = 4 7119 closure_load32(p, c); 7120 } 7121 if ( // r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 7122 lchild.getOpcode() == LONG_USHR_opcode && 7123 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7124 ) { 7125 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VLR(p) == 32 ? 13 : INFINITE); 7126 if(BURS.DEBUG) trace(p, 335, c + 0, p.getCost(2) /* r */); 7127 if (c < p.getCost(2) /* r */) { 7128 p.setCost(2 /* r */, (char)(c)); 7129 p.writePacked(0, 0xFFFF00FF, 0x7A00); // p.r = 122 7130 closure_r(p, c); 7131 } 7132 } 7133 if ( // r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 7134 lchild.getOpcode() == LONG_SHR_opcode && 7135 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7136 ) { 7137 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VLR(p) == 32 ? 13 : INFINITE); 7138 if(BURS.DEBUG) trace(p, 336, c + 0, p.getCost(2) /* r */); 7139 if (c < p.getCost(2) /* r */) { 7140 p.setCost(2 /* r */, (char)(c)); 7141 p.writePacked(0, 0xFFFF00FF, 0x7B00); // p.r = 123 7142 closure_r(p, c); 7143 } 7144 } 7145 if ( // r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 7146 lchild.getOpcode() == LONG_USHR_opcode && 7147 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7148 ) { 7149 c = STATE(lchild.getChild1()).getCost(22 /* load64 */) + (VLR(p) == 32 ? 15 : INFINITE); 7150 if(BURS.DEBUG) trace(p, 337, c + 0, p.getCost(2) /* r */); 7151 if (c < p.getCost(2) /* r */) { 7152 p.setCost(2 /* r */, (char)(c)); 7153 p.writePacked(0, 0xFFFF00FF, 0x7C00); // p.r = 124 7154 closure_r(p, c); 7155 } 7156 } 7157 if ( // r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 7158 lchild.getOpcode() == LONG_SHR_opcode && 7159 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7160 ) { 7161 c = STATE(lchild.getChild1()).getCost(22 /* load64 */) + (VLR(p) == 32 ? 15 : INFINITE); 7162 if(BURS.DEBUG) trace(p, 338, c + 0, p.getCost(2) /* r */); 7163 if (c < p.getCost(2) /* r */) { 7164 p.setCost(2 /* r */, (char)(c)); 7165 p.writePacked(0, 0xFFFF00FF, 0x7D00); // p.r = 125 7166 closure_r(p, c); 7167 } 7168 } 7169 if ( // load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 7170 lchild.getOpcode() == LONG_USHR_opcode && 7171 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7172 ) { 7173 c = STATE(lchild.getChild1()).getCost(22 /* load64 */) + (VLR(p) == 32 ? 0 : INFINITE); 7174 if(BURS.DEBUG) trace(p, 339, c + 0, p.getCost(10) /* load32 */); 7175 if (c < p.getCost(10) /* load32 */) { 7176 p.setCost(10 /* load32 */, (char)(c)); 7177 p.writePacked(1, 0xFFFFFF1F, 0xA0); // p.load32 = 5 7178 closure_load32(p, c); 7179 } 7180 } 7181 if ( // load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 7182 lchild.getOpcode() == LONG_SHR_opcode && 7183 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 7184 ) { 7185 c = STATE(lchild.getChild1()).getCost(22 /* load64 */) + (VLR(p) == 32 ? 0 : INFINITE); 7186 if(BURS.DEBUG) trace(p, 340, c + 0, p.getCost(10) /* load32 */); 7187 if (c < p.getCost(10) /* load32 */) { 7188 p.setCost(10 /* load32 */, (char)(c)); 7189 p.writePacked(1, 0xFFFFFF1F, 0xC0); // p.load32 = 6 7190 closure_load32(p, c); 7191 } 7192 } 7193 } 7194 7195 /** 7196 * Labels LONG_2FLOAT tree node 7197 * @param p node to label 7198 */ 7199 private static void label_LONG_2FLOAT(AbstractBURS_TreeNode p) { 7200 p.initCost(); 7201 AbstractBURS_TreeNode lchild; 7202 lchild = p.getChild1(); 7203 label(lchild); 7204 int c; 7205 // r: LONG_2FLOAT(r) 7206 c = STATE(lchild).getCost(2 /* r */) + 13; 7207 if(BURS.DEBUG) trace(p, 299, c + 0, p.getCost(2) /* r */); 7208 if (c < p.getCost(2) /* r */) { 7209 p.setCost(2 /* r */, (char)(c)); 7210 p.writePacked(0, 0xFFFF00FF, 0xB700); // p.r = 183 7211 closure_r(p, c); 7212 } 7213 } 7214 7215 /** 7216 * Labels LONG_2DOUBLE tree node 7217 * @param p node to label 7218 */ 7219 private static void label_LONG_2DOUBLE(AbstractBURS_TreeNode p) { 7220 p.initCost(); 7221 AbstractBURS_TreeNode lchild; 7222 lchild = p.getChild1(); 7223 label(lchild); 7224 int c; 7225 // r: LONG_2DOUBLE(r) 7226 c = STATE(lchild).getCost(2 /* r */) + 13; 7227 if(BURS.DEBUG) trace(p, 300, c + 0, p.getCost(2) /* r */); 7228 if (c < p.getCost(2) /* r */) { 7229 p.setCost(2 /* r */, (char)(c)); 7230 p.writePacked(0, 0xFFFF00FF, 0xB800); // p.r = 184 7231 closure_r(p, c); 7232 } 7233 } 7234 7235 /** 7236 * Labels FLOAT_2INT tree node 7237 * @param p node to label 7238 */ 7239 private static void label_FLOAT_2INT(AbstractBURS_TreeNode p) { 7240 p.initCost(); 7241 AbstractBURS_TreeNode lchild; 7242 lchild = p.getChild1(); 7243 label(lchild); 7244 int c; 7245 // r: FLOAT_2INT(r) 7246 c = STATE(lchild).getCost(2 /* r */) + 13; 7247 if(BURS.DEBUG) trace(p, 311, c + 0, p.getCost(2) /* r */); 7248 if (c < p.getCost(2) /* r */) { 7249 p.setCost(2 /* r */, (char)(c)); 7250 p.writePacked(0, 0xFFFF00FF, 0xCE00); // p.r = 206 7251 closure_r(p, c); 7252 } 7253 } 7254 7255 /** 7256 * Labels FLOAT_2LONG tree node 7257 * @param p node to label 7258 */ 7259 private static void label_FLOAT_2LONG(AbstractBURS_TreeNode p) { 7260 p.initCost(); 7261 AbstractBURS_TreeNode lchild; 7262 lchild = p.getChild1(); 7263 label(lchild); 7264 int c; 7265 // r: FLOAT_2LONG(r) 7266 c = STATE(lchild).getCost(2 /* r */) + 13; 7267 if(BURS.DEBUG) trace(p, 312, c + 0, p.getCost(2) /* r */); 7268 if (c < p.getCost(2) /* r */) { 7269 p.setCost(2 /* r */, (char)(c)); 7270 p.writePacked(0, 0xFFFF00FF, 0xCF00); // p.r = 207 7271 closure_r(p, c); 7272 } 7273 } 7274 7275 /** 7276 * Labels FLOAT_2DOUBLE tree node 7277 * @param p node to label 7278 */ 7279 private static void label_FLOAT_2DOUBLE(AbstractBURS_TreeNode p) { 7280 p.initCost(); 7281 AbstractBURS_TreeNode lchild; 7282 lchild = p.getChild1(); 7283 label(lchild); 7284 int c; 7285 // r: FLOAT_2DOUBLE(r) 7286 c = STATE(lchild).getCost(2 /* r */) + 13; 7287 if(BURS.DEBUG) trace(p, 307, c + 0, p.getCost(2) /* r */); 7288 if (c < p.getCost(2) /* r */) { 7289 p.setCost(2 /* r */, (char)(c)); 7290 p.writePacked(0, 0xFFFF00FF, 0xCA00); // p.r = 202 7291 closure_r(p, c); 7292 } 7293 // r: FLOAT_2DOUBLE(float_load) 7294 c = STATE(lchild).getCost(25 /* float_load */) + 15; 7295 if(BURS.DEBUG) trace(p, 308, c + 0, p.getCost(2) /* r */); 7296 if (c < p.getCost(2) /* r */) { 7297 p.setCost(2 /* r */, (char)(c)); 7298 p.writePacked(0, 0xFFFF00FF, 0xCB00); // p.r = 203 7299 closure_r(p, c); 7300 } 7301 } 7302 7303 /** 7304 * Labels DOUBLE_2INT tree node 7305 * @param p node to label 7306 */ 7307 private static void label_DOUBLE_2INT(AbstractBURS_TreeNode p) { 7308 p.initCost(); 7309 AbstractBURS_TreeNode lchild; 7310 lchild = p.getChild1(); 7311 label(lchild); 7312 int c; 7313 // r: DOUBLE_2INT(r) 7314 c = STATE(lchild).getCost(2 /* r */) + 13; 7315 if(BURS.DEBUG) trace(p, 313, c + 0, p.getCost(2) /* r */); 7316 if (c < p.getCost(2) /* r */) { 7317 p.setCost(2 /* r */, (char)(c)); 7318 p.writePacked(0, 0xFFFF00FF, 0xD000); // p.r = 208 7319 closure_r(p, c); 7320 } 7321 } 7322 7323 /** 7324 * Labels DOUBLE_2LONG tree node 7325 * @param p node to label 7326 */ 7327 private static void label_DOUBLE_2LONG(AbstractBURS_TreeNode p) { 7328 p.initCost(); 7329 AbstractBURS_TreeNode lchild; 7330 lchild = p.getChild1(); 7331 label(lchild); 7332 int c; 7333 // r: DOUBLE_2LONG(r) 7334 c = STATE(lchild).getCost(2 /* r */) + 13; 7335 if(BURS.DEBUG) trace(p, 314, c + 0, p.getCost(2) /* r */); 7336 if (c < p.getCost(2) /* r */) { 7337 p.setCost(2 /* r */, (char)(c)); 7338 p.writePacked(0, 0xFFFF00FF, 0xD100); // p.r = 209 7339 closure_r(p, c); 7340 } 7341 } 7342 7343 /** 7344 * Labels DOUBLE_2FLOAT tree node 7345 * @param p node to label 7346 */ 7347 private static void label_DOUBLE_2FLOAT(AbstractBURS_TreeNode p) { 7348 p.initCost(); 7349 AbstractBURS_TreeNode lchild; 7350 lchild = p.getChild1(); 7351 label(lchild); 7352 int c; 7353 // r: DOUBLE_2FLOAT(r) 7354 c = STATE(lchild).getCost(2 /* r */) + 13; 7355 if(BURS.DEBUG) trace(p, 309, c + 0, p.getCost(2) /* r */); 7356 if (c < p.getCost(2) /* r */) { 7357 p.setCost(2 /* r */, (char)(c)); 7358 p.writePacked(0, 0xFFFF00FF, 0xCC00); // p.r = 204 7359 closure_r(p, c); 7360 } 7361 // r: DOUBLE_2FLOAT(double_load) 7362 c = STATE(lchild).getCost(26 /* double_load */) + 15; 7363 if(BURS.DEBUG) trace(p, 310, c + 0, p.getCost(2) /* r */); 7364 if (c < p.getCost(2) /* r */) { 7365 p.setCost(2 /* r */, (char)(c)); 7366 p.writePacked(0, 0xFFFF00FF, 0xCD00); // p.r = 205 7367 closure_r(p, c); 7368 } 7369 } 7370 7371 /** 7372 * Labels INT_2BYTE tree node 7373 * @param p node to label 7374 */ 7375 private static void label_INT_2BYTE(AbstractBURS_TreeNode p) { 7376 p.initCost(); 7377 AbstractBURS_TreeNode lchild; 7378 lchild = p.getChild1(); 7379 label(lchild); 7380 int c; 7381 // r: INT_2BYTE(load8_16_32) 7382 c = STATE(lchild).getCost(12 /* load8_16_32 */) + 20; 7383 if(BURS.DEBUG) trace(p, 213, c + 0, p.getCost(2) /* r */); 7384 if (c < p.getCost(2) /* r */) { 7385 p.setCost(2 /* r */, (char)(c)); 7386 p.writePacked(0, 0xFFFF00FF, 0x800); // p.r = 8 7387 closure_r(p, c); 7388 } 7389 // r: INT_2BYTE(r) 7390 c = STATE(lchild).getCost(2 /* r */) + 15; 7391 if(BURS.DEBUG) trace(p, 249, c + 0, p.getCost(2) /* r */); 7392 if (c < p.getCost(2) /* r */) { 7393 p.setCost(2 /* r */, (char)(c)); 7394 p.writePacked(0, 0xFFFF00FF, 0x4200); // p.r = 66 7395 closure_r(p, c); 7396 } 7397 // r: INT_2BYTE(load8_16_32) 7398 c = STATE(lchild).getCost(12 /* load8_16_32 */) + 17; 7399 if(BURS.DEBUG) trace(p, 250, c + 0, p.getCost(2) /* r */); 7400 if (c < p.getCost(2) /* r */) { 7401 p.setCost(2 /* r */, (char)(c)); 7402 p.writePacked(0, 0xFFFF00FF, 0x4300); // p.r = 67 7403 closure_r(p, c); 7404 } 7405 } 7406 7407 /** 7408 * Labels INT_2USHORT tree node 7409 * @param p node to label 7410 */ 7411 private static void label_INT_2USHORT(AbstractBURS_TreeNode p) { 7412 p.initCost(); 7413 AbstractBURS_TreeNode lchild; 7414 lchild = p.getChild1(); 7415 label(lchild); 7416 int c; 7417 // szpr: INT_2USHORT(r) 7418 c = STATE(lchild).getCost(2 /* r */) + 23; 7419 if(BURS.DEBUG) trace(p, 256, c + 0, p.getCost(5) /* szpr */); 7420 if (c < p.getCost(5) /* szpr */) { 7421 p.setCost(5 /* szpr */, (char)(c)); 7422 p.writePacked(0, 0xFC1FFFFF, 0x200000); // p.szpr = 1 7423 closure_szpr(p, c); 7424 } 7425 // uload16: INT_2USHORT(load16_32) 7426 c = STATE(lchild).getCost(13 /* load16_32 */) + 0; 7427 if(BURS.DEBUG) trace(p, 257, c + 0, p.getCost(23) /* uload16 */); 7428 if (c < p.getCost(23) /* uload16 */) { 7429 p.setCost(23 /* uload16 */, (char)(c)); 7430 p.writePacked(2, 0xFFFF8FFF, 0x1000); // p.uload16 = 1 7431 closure_uload16(p, c); 7432 } 7433 // r: INT_2USHORT(load16_32) 7434 c = STATE(lchild).getCost(13 /* load16_32 */) + 15; 7435 if(BURS.DEBUG) trace(p, 258, c + 0, p.getCost(2) /* r */); 7436 if (c < p.getCost(2) /* r */) { 7437 p.setCost(2 /* r */, (char)(c)); 7438 p.writePacked(0, 0xFFFF00FF, 0x4C00); // p.r = 76 7439 closure_r(p, c); 7440 } 7441 } 7442 7443 /** 7444 * Labels INT_2SHORT tree node 7445 * @param p node to label 7446 */ 7447 private static void label_INT_2SHORT(AbstractBURS_TreeNode p) { 7448 p.initCost(); 7449 AbstractBURS_TreeNode lchild; 7450 lchild = p.getChild1(); 7451 label(lchild); 7452 int c; 7453 // r: INT_2SHORT(r) 7454 c = STATE(lchild).getCost(2 /* r */) + 15; 7455 if(BURS.DEBUG) trace(p, 253, c + 0, p.getCost(2) /* r */); 7456 if (c < p.getCost(2) /* r */) { 7457 p.setCost(2 /* r */, (char)(c)); 7458 p.writePacked(0, 0xFFFF00FF, 0x4A00); // p.r = 74 7459 closure_r(p, c); 7460 } 7461 // r: INT_2SHORT(load16_32) 7462 c = STATE(lchild).getCost(13 /* load16_32 */) + 17; 7463 if(BURS.DEBUG) trace(p, 254, c + 0, p.getCost(2) /* r */); 7464 if (c < p.getCost(2) /* r */) { 7465 p.setCost(2 /* r */, (char)(c)); 7466 p.writePacked(0, 0xFFFF00FF, 0x4B00); // p.r = 75 7467 closure_r(p, c); 7468 } 7469 // sload16: INT_2SHORT(load16_32) 7470 c = STATE(lchild).getCost(13 /* load16_32 */) + 0; 7471 if(BURS.DEBUG) trace(p, 255, c + 0, p.getCost(21) /* sload16 */); 7472 if (c < p.getCost(21) /* sload16 */) { 7473 p.setCost(21 /* sload16 */, (char)(c)); 7474 p.writePacked(2, 0xFFFFFE3F, 0x40); // p.sload16 = 1 7475 closure_sload16(p, c); 7476 } 7477 } 7478 7479 /** 7480 * Labels LONG_CMP tree node 7481 * @param p node to label 7482 */ 7483 private static void label_LONG_CMP(AbstractBURS_TreeNode p) { 7484 p.initCost(); 7485 AbstractBURS_TreeNode lchild, rchild; 7486 lchild = p.getChild1(); 7487 rchild = p.getChild2(); 7488 label(lchild); 7489 label(rchild); 7490 int c; 7491 // r: LONG_CMP(rlv,rlv) 7492 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 10*13; 7493 if(BURS.DEBUG) trace(p, 54, c + 0, p.getCost(2) /* r */); 7494 if (c < p.getCost(2) /* r */) { 7495 p.setCost(2 /* r */, (char)(c)); 7496 p.writePacked(0, 0xFFFF00FF, 0xC00); // p.r = 12 7497 closure_r(p, c); 7498 } 7499 } 7500 7501 /** 7502 * Labels RETURN tree node 7503 * @param p node to label 7504 */ 7505 private static void label_RETURN(AbstractBURS_TreeNode p) { 7506 p.initCost(); 7507 AbstractBURS_TreeNode lchild; 7508 lchild = p.getChild1(); 7509 label(lchild); 7510 int c; 7511 if ( // stm: RETURN(NULL) 7512 lchild.getOpcode() == NULL_opcode 7513 ) { 7514 c = 13; 7515 if(BURS.DEBUG) trace(p, 44, c + 0, p.getCost(1) /* stm */); 7516 if (c < p.getCost(1) /* stm */) { 7517 p.setCost(1 /* stm */, (char)(c)); 7518 p.writePacked(0, 0xFFFFFF00, 0x2C); // p.stm = 44 7519 } 7520 } 7521 if ( // stm: RETURN(INT_CONSTANT) 7522 lchild.getOpcode() == INT_CONSTANT_opcode 7523 ) { 7524 c = 11; 7525 if(BURS.DEBUG) trace(p, 45, c + 0, p.getCost(1) /* stm */); 7526 if (c < p.getCost(1) /* stm */) { 7527 p.setCost(1 /* stm */, (char)(c)); 7528 p.writePacked(0, 0xFFFFFF00, 0x2D); // p.stm = 45 7529 } 7530 } 7531 // stm: RETURN(r) 7532 c = STATE(lchild).getCost(2 /* r */) + 13; 7533 if(BURS.DEBUG) trace(p, 216, c + 0, p.getCost(1) /* stm */); 7534 if (c < p.getCost(1) /* stm */) { 7535 p.setCost(1 /* stm */, (char)(c)); 7536 p.writePacked(0, 0xFFFFFF00, 0x2E); // p.stm = 46 7537 } 7538 if ( // stm: RETURN(LONG_CONSTANT) 7539 lchild.getOpcode() == LONG_CONSTANT_opcode 7540 ) { 7541 c = 11; 7542 if(BURS.DEBUG) trace(p, 46, c + 0, p.getCost(1) /* stm */); 7543 if (c < p.getCost(1) /* stm */) { 7544 p.setCost(1 /* stm */, (char)(c)); 7545 p.writePacked(0, 0xFFFFFF00, 0x2F); // p.stm = 47 7546 } 7547 } 7548 } 7549 7550 /** 7551 * Labels NULL_CHECK tree node 7552 * @param p node to label 7553 */ 7554 private static void label_NULL_CHECK(AbstractBURS_TreeNode p) { 7555 p.initCost(); 7556 AbstractBURS_TreeNode lchild; 7557 lchild = p.getChild1(); 7558 label(lchild); 7559 int c; 7560 // stm: NULL_CHECK(riv) 7561 c = STATE(lchild).getCost(7 /* riv */) + 11; 7562 if(BURS.DEBUG) trace(p, 207, c + 0, p.getCost(1) /* stm */); 7563 if (c < p.getCost(1) /* stm */) { 7564 p.setCost(1 /* stm */, (char)(c)); 7565 p.writePacked(0, 0xFFFFFF00, 0xB); // p.stm = 11 7566 } 7567 } 7568 7569 /** 7570 * Labels GOTO tree node 7571 * @param p node to label 7572 */ 7573 private static void label_GOTO(AbstractBURS_TreeNode p) { 7574 p.initCost(); 7575 // stm: GOTO 7576 if(BURS.DEBUG) trace(p, 39, 11 + 0, p.getCost(1) /* stm */); 7577 if (11 < p.getCost(1) /* stm */) { 7578 p.setCost(1 /* stm */, (char)(11)); 7579 p.writePacked(0, 0xFFFFFF00, 0x26); // p.stm = 38 7580 } 7581 } 7582 7583 /** 7584 * Labels BOOLEAN_NOT tree node 7585 * @param p node to label 7586 */ 7587 private static void label_BOOLEAN_NOT(AbstractBURS_TreeNode p) { 7588 p.initCost(); 7589 AbstractBURS_TreeNode lchild; 7590 lchild = p.getChild1(); 7591 label(lchild); 7592 int c; 7593 // r: BOOLEAN_NOT(r) 7594 c = STATE(lchild).getCost(2 /* r */) + 13; 7595 if(BURS.DEBUG) trace(p, 244, c + 0, p.getCost(2) /* r */); 7596 if (c < p.getCost(2) /* r */) { 7597 p.setCost(2 /* r */, (char)(c)); 7598 p.writePacked(0, 0xFFFF00FF, 0x3000); // p.r = 48 7599 closure_r(p, c); 7600 } 7601 } 7602 7603 /** 7604 * Labels BOOLEAN_CMP_INT tree node 7605 * @param p node to label 7606 */ 7607 private static void label_BOOLEAN_CMP_INT(AbstractBURS_TreeNode p) { 7608 p.initCost(); 7609 AbstractBURS_TreeNode lchild, rchild; 7610 lchild = p.getChild1(); 7611 rchild = p.getChild2(); 7612 label(lchild); 7613 label(rchild); 7614 int c; 7615 // r: BOOLEAN_CMP_INT(r,riv) 7616 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 39; 7617 if(BURS.DEBUG) trace(p, 63, c + 0, p.getCost(2) /* r */); 7618 if (c < p.getCost(2) /* r */) { 7619 p.setCost(2 /* r */, (char)(c)); 7620 p.writePacked(0, 0xFFFF00FF, 0x2200); // p.r = 34 7621 closure_r(p, c); 7622 } 7623 // boolcmp: BOOLEAN_CMP_INT(r,riv) 7624 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* riv */) + 13; 7625 if(BURS.DEBUG) trace(p, 64, c + 0, p.getCost(19) /* boolcmp */); 7626 if (c < p.getCost(19) /* boolcmp */) { 7627 p.setCost(19 /* boolcmp */, (char)(c)); 7628 p.writePacked(2, 0xFFFFFFF0, 0x1); // p.boolcmp = 1 7629 } 7630 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7631 rchild.getOpcode() == INT_CONSTANT_opcode 7632 ) { 7633 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 37:INFINITE); 7634 if(BURS.DEBUG) trace(p, 228, c + 0, p.getCost(2) /* r */); 7635 if (c < p.getCost(2) /* r */) { 7636 p.setCost(2 /* r */, (char)(c)); 7637 p.writePacked(0, 0xFFFF00FF, 0x2300); // p.r = 35 7638 closure_r(p, c); 7639 } 7640 } 7641 if ( // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7642 rchild.getOpcode() == INT_CONSTANT_opcode 7643 ) { 7644 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && CMP_TO_TEST(BooleanCmp.getCond(P(p))) ? 11:INFINITE); 7645 if(BURS.DEBUG) trace(p, 229, c + 0, p.getCost(19) /* boolcmp */); 7646 if (c < p.getCost(19) /* boolcmp */) { 7647 p.setCost(19 /* boolcmp */, (char)(c)); 7648 p.writePacked(2, 0xFFFFFFF0, 0x2); // p.boolcmp = 2 7649 } 7650 } 7651 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7652 rchild.getOpcode() == INT_CONSTANT_opcode 7653 ) { 7654 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isLESS() ? 11 : INFINITE); 7655 if(BURS.DEBUG) trace(p, 230, c + 0, p.getCost(2) /* r */); 7656 if (c < p.getCost(2) /* r */) { 7657 p.setCost(2 /* r */, (char)(c)); 7658 p.writePacked(0, 0xFFFF00FF, 0x2400); // p.r = 36 7659 closure_r(p, c); 7660 } 7661 } 7662 if ( // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 7663 rchild.getOpcode() == INT_CONSTANT_opcode 7664 ) { 7665 c = STATE(lchild).getCost(10 /* load32 */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isLESS() ? 16 : INFINITE); 7666 if(BURS.DEBUG) trace(p, 231, c + 0, p.getCost(2) /* r */); 7667 if (c < p.getCost(2) /* r */) { 7668 p.setCost(2 /* r */, (char)(c)); 7669 p.writePacked(0, 0xFFFF00FF, 0x2500); // p.r = 37 7670 closure_r(p, c); 7671 } 7672 } 7673 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7674 rchild.getOpcode() == INT_CONSTANT_opcode 7675 ) { 7676 c = STATE(lchild).getCost(2 /* r */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 22 : INFINITE); 7677 if(BURS.DEBUG) trace(p, 232, c + 0, p.getCost(2) /* r */); 7678 if (c < p.getCost(2) /* r */) { 7679 p.setCost(2 /* r */, (char)(c)); 7680 p.writePacked(0, 0xFFFF00FF, 0x2600); // p.r = 38 7681 closure_r(p, c); 7682 } 7683 } 7684 if ( // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 7685 rchild.getOpcode() == INT_CONSTANT_opcode 7686 ) { 7687 c = STATE(lchild).getCost(10 /* load32 */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isGREATER_EQUAL() ? 27 : INFINITE); 7688 if(BURS.DEBUG) trace(p, 233, c + 0, p.getCost(2) /* r */); 7689 if (c < p.getCost(2) /* r */) { 7690 p.setCost(2 /* r */, (char)(c)); 7691 p.writePacked(0, 0xFFFF00FF, 0x2700); // p.r = 39 7692 closure_r(p, c); 7693 } 7694 } 7695 if ( // r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 7696 rchild.getOpcode() == INT_CONSTANT_opcode 7697 ) { 7698 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 26); 7699 if(BURS.DEBUG) trace(p, 234, c + 0, p.getCost(2) /* r */); 7700 if (c < p.getCost(2) /* r */) { 7701 p.setCost(2 /* r */, (char)(c)); 7702 p.writePacked(0, 0xFFFF00FF, 0x2800); // p.r = 40 7703 closure_r(p, c); 7704 } 7705 } 7706 if ( // boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 7707 rchild.getOpcode() == INT_CONSTANT_opcode 7708 ) { 7709 c = STATE(lchild).getCost(4 /* cz */) + isZERO(VR(p), 0); 7710 if(BURS.DEBUG) trace(p, 235, c + 0, p.getCost(19) /* boolcmp */); 7711 if (c < p.getCost(19) /* boolcmp */) { 7712 p.setCost(19 /* boolcmp */, (char)(c)); 7713 p.writePacked(2, 0xFFFFFFF0, 0x3); // p.boolcmp = 3 7714 } 7715 } 7716 if ( // r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 7717 rchild.getOpcode() == INT_CONSTANT_opcode 7718 ) { 7719 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(BooleanCmp.getCond(P(p)))?26:INFINITE); 7720 if(BURS.DEBUG) trace(p, 236, c + 0, p.getCost(2) /* r */); 7721 if (c < p.getCost(2) /* r */) { 7722 p.setCost(2 /* r */, (char)(c)); 7723 p.writePacked(0, 0xFFFF00FF, 0x2900); // p.r = 41 7724 closure_r(p, c); 7725 } 7726 } 7727 if ( // boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 7728 rchild.getOpcode() == INT_CONSTANT_opcode 7729 ) { 7730 c = STATE(lchild).getCost(6 /* szp */) + (VR(p) == 0 && EQ_NE(BooleanCmp.getCond(P(p)))?0:INFINITE); 7731 if(BURS.DEBUG) trace(p, 237, c + 0, p.getCost(19) /* boolcmp */); 7732 if (c < p.getCost(19) /* boolcmp */) { 7733 p.setCost(19 /* boolcmp */, (char)(c)); 7734 p.writePacked(2, 0xFFFFFFF0, 0x4); // p.boolcmp = 4 7735 } 7736 } 7737 if ( // r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 7738 rchild.getOpcode() == INT_CONSTANT_opcode 7739 ) { 7740 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(BooleanCmp.getCond(P(p))) ? 26 : INFINITE); 7741 if(BURS.DEBUG) trace(p, 238, c + 0, p.getCost(2) /* r */); 7742 if (c < p.getCost(2) /* r */) { 7743 p.setCost(2 /* r */, (char)(c)); 7744 p.writePacked(0, 0xFFFF00FF, 0x2A00); // p.r = 42 7745 closure_r(p, c); 7746 } 7747 } 7748 if ( // boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 7749 rchild.getOpcode() == INT_CONSTANT_opcode 7750 ) { 7751 c = STATE(lchild).getCost(18 /* bittest */) + ((VR(p) == 0 || VR(p) == 1) && EQ_NE(BooleanCmp.getCond(P(p))) ? 0 : INFINITE); 7752 if(BURS.DEBUG) trace(p, 239, c + 0, p.getCost(19) /* boolcmp */); 7753 if (c < p.getCost(19) /* boolcmp */) { 7754 p.setCost(19 /* boolcmp */, (char)(c)); 7755 p.writePacked(2, 0xFFFFFFF0, 0x5); // p.boolcmp = 5 7756 } 7757 } 7758 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 7759 rchild.getOpcode() == INT_CONSTANT_opcode 7760 ) { 7761 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); 7762 if(BURS.DEBUG) trace(p, 240, c + 0, p.getCost(2) /* r */); 7763 if (c < p.getCost(2) /* r */) { 7764 p.setCost(2 /* r */, (char)(c)); 7765 p.writePacked(0, 0xFFFF00FF, 0x2B00); // p.r = 43 7766 closure_r(p, c); 7767 } 7768 } 7769 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 7770 rchild.getOpcode() == INT_CONSTANT_opcode 7771 ) { 7772 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); 7773 if(BURS.DEBUG) trace(p, 241, c + 0, p.getCost(19) /* boolcmp */); 7774 if (c < p.getCost(19) /* boolcmp */) { 7775 p.setCost(19 /* boolcmp */, (char)(c)); 7776 p.writePacked(2, 0xFFFFFFF0, 0x6); // p.boolcmp = 6 7777 } 7778 } 7779 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 7780 rchild.getOpcode() == INT_CONSTANT_opcode 7781 ) { 7782 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); 7783 if(BURS.DEBUG) trace(p, 242, c + 0, p.getCost(2) /* r */); 7784 if (c < p.getCost(2) /* r */) { 7785 p.setCost(2 /* r */, (char)(c)); 7786 p.writePacked(0, 0xFFFF00FF, 0x2C00); // p.r = 44 7787 closure_r(p, c); 7788 } 7789 } 7790 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 7791 rchild.getOpcode() == INT_CONSTANT_opcode 7792 ) { 7793 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); 7794 if(BURS.DEBUG) trace(p, 243, c + 0, p.getCost(19) /* boolcmp */); 7795 if (c < p.getCost(19) /* boolcmp */) { 7796 p.setCost(19 /* boolcmp */, (char)(c)); 7797 p.writePacked(2, 0xFFFFFFF0, 0x7); // p.boolcmp = 7 7798 } 7799 } 7800 // r: BOOLEAN_CMP_INT(load32,riv) 7801 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 41; 7802 if(BURS.DEBUG) trace(p, 65, c + 0, p.getCost(2) /* r */); 7803 if (c < p.getCost(2) /* r */) { 7804 p.setCost(2 /* r */, (char)(c)); 7805 p.writePacked(0, 0xFFFF00FF, 0x2D00); // p.r = 45 7806 closure_r(p, c); 7807 } 7808 // boolcmp: BOOLEAN_CMP_INT(load32,riv) 7809 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 7810 if(BURS.DEBUG) trace(p, 66, c + 0, p.getCost(19) /* boolcmp */); 7811 if (c < p.getCost(19) /* boolcmp */) { 7812 p.setCost(19 /* boolcmp */, (char)(c)); 7813 p.writePacked(2, 0xFFFFFFF0, 0x8); // p.boolcmp = 8 7814 } 7815 // r: BOOLEAN_CMP_INT(r,load32) 7816 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(10 /* load32 */) + 41; 7817 if(BURS.DEBUG) trace(p, 67, c + 0, p.getCost(2) /* r */); 7818 if (c < p.getCost(2) /* r */) { 7819 p.setCost(2 /* r */, (char)(c)); 7820 p.writePacked(0, 0xFFFF00FF, 0x2E00); // p.r = 46 7821 closure_r(p, c); 7822 } 7823 // boolcmp: BOOLEAN_CMP_INT(riv,load32) 7824 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 7825 if(BURS.DEBUG) trace(p, 68, c + 0, p.getCost(19) /* boolcmp */); 7826 if (c < p.getCost(19) /* boolcmp */) { 7827 p.setCost(19 /* boolcmp */, (char)(c)); 7828 p.writePacked(2, 0xFFFFFFF0, 0x9); // p.boolcmp = 9 7829 } 7830 } 7831 7832 /** 7833 * Labels BOOLEAN_CMP_LONG tree node 7834 * @param p node to label 7835 */ 7836 private static void label_BOOLEAN_CMP_LONG(AbstractBURS_TreeNode p) { 7837 p.initCost(); 7838 AbstractBURS_TreeNode lchild, rchild; 7839 lchild = p.getChild1(); 7840 rchild = p.getChild2(); 7841 label(lchild); 7842 label(rchild); 7843 int c; 7844 // r: BOOLEAN_CMP_LONG(rlv,rlv) 7845 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 8*13; 7846 if(BURS.DEBUG) trace(p, 69, c + 0, p.getCost(2) /* r */); 7847 if (c < p.getCost(2) /* r */) { 7848 p.setCost(2 /* r */, (char)(c)); 7849 p.writePacked(0, 0xFFFF00FF, 0x2F00); // p.r = 47 7850 closure_r(p, c); 7851 } 7852 // boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 7853 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 11*13; 7854 if(BURS.DEBUG) trace(p, 70, c + 0, p.getCost(19) /* boolcmp */); 7855 if (c < p.getCost(19) /* boolcmp */) { 7856 p.setCost(19 /* boolcmp */, (char)(c)); 7857 p.writePacked(2, 0xFFFFFFF0, 0xA); // p.boolcmp = 10 7858 } 7859 } 7860 7861 /** 7862 * Labels BYTE_LOAD tree node 7863 * @param p node to label 7864 */ 7865 private static void label_BYTE_LOAD(AbstractBURS_TreeNode p) { 7866 p.initCost(); 7867 AbstractBURS_TreeNode lchild, rchild; 7868 lchild = p.getChild1(); 7869 rchild = p.getChild2(); 7870 label(lchild); 7871 label(rchild); 7872 int c; 7873 // r: BYTE_LOAD(riv,riv) 7874 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 20; 7875 if(BURS.DEBUG) trace(p, 120, c + 0, p.getCost(2) /* r */); 7876 if (c < p.getCost(2) /* r */) { 7877 p.setCost(2 /* r */, (char)(c)); 7878 p.writePacked(0, 0xFFFF00FF, 0x7000); // p.r = 112 7879 closure_r(p, c); 7880 } 7881 // sload8: BYTE_LOAD(riv,riv) 7882 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 7883 if(BURS.DEBUG) trace(p, 121, c + 0, p.getCost(24) /* sload8 */); 7884 if (c < p.getCost(24) /* sload8 */) { 7885 p.setCost(24 /* sload8 */, (char)(c)); 7886 p.writePacked(2, 0xFFFE7FFF, 0x10000); // p.sload8 = 2 7887 closure_sload8(p, c); 7888 } 7889 } 7890 7891 /** 7892 * Labels UBYTE_LOAD tree node 7893 * @param p node to label 7894 */ 7895 private static void label_UBYTE_LOAD(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 // r: UBYTE_LOAD(riv,riv) 7904 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 7905 if(BURS.DEBUG) trace(p, 124, c + 0, p.getCost(2) /* r */); 7906 if (c < p.getCost(2) /* r */) { 7907 p.setCost(2 /* r */, (char)(c)); 7908 p.writePacked(0, 0xFFFF00FF, 0x7200); // p.r = 114 7909 closure_r(p, c); 7910 } 7911 // uload8: UBYTE_LOAD(riv,riv) 7912 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 7913 if(BURS.DEBUG) trace(p, 125, c + 0, p.getCost(11) /* uload8 */); 7914 if (c < p.getCost(11) /* uload8 */) { 7915 p.setCost(11 /* uload8 */, (char)(c)); 7916 p.writePacked(1, 0xFFFFF8FF, 0x300); // p.uload8 = 3 7917 closure_uload8(p, c); 7918 } 7919 } 7920 7921 /** 7922 * Labels SHORT_LOAD tree node 7923 * @param p node to label 7924 */ 7925 private static void label_SHORT_LOAD(AbstractBURS_TreeNode p) { 7926 p.initCost(); 7927 AbstractBURS_TreeNode lchild, rchild; 7928 lchild = p.getChild1(); 7929 rchild = p.getChild2(); 7930 label(lchild); 7931 label(rchild); 7932 int c; 7933 // r: SHORT_LOAD(riv,riv) 7934 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 20; 7935 if(BURS.DEBUG) trace(p, 128, c + 0, p.getCost(2) /* r */); 7936 if (c < p.getCost(2) /* r */) { 7937 p.setCost(2 /* r */, (char)(c)); 7938 p.writePacked(0, 0xFFFF00FF, 0x7400); // p.r = 116 7939 closure_r(p, c); 7940 } 7941 // sload16: SHORT_LOAD(riv,riv) 7942 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 7943 if(BURS.DEBUG) trace(p, 129, c + 0, p.getCost(21) /* sload16 */); 7944 if (c < p.getCost(21) /* sload16 */) { 7945 p.setCost(21 /* sload16 */, (char)(c)); 7946 p.writePacked(2, 0xFFFFFE3F, 0xC0); // p.sload16 = 3 7947 closure_sload16(p, c); 7948 } 7949 } 7950 7951 /** 7952 * Labels USHORT_LOAD tree node 7953 * @param p node to label 7954 */ 7955 private static void label_USHORT_LOAD(AbstractBURS_TreeNode p) { 7956 p.initCost(); 7957 AbstractBURS_TreeNode lchild, rchild; 7958 lchild = p.getChild1(); 7959 rchild = p.getChild2(); 7960 label(lchild); 7961 label(rchild); 7962 int c; 7963 // r: USHORT_LOAD(riv,riv) 7964 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 7965 if(BURS.DEBUG) trace(p, 132, c + 0, p.getCost(2) /* r */); 7966 if (c < p.getCost(2) /* r */) { 7967 p.setCost(2 /* r */, (char)(c)); 7968 p.writePacked(0, 0xFFFF00FF, 0x7600); // p.r = 118 7969 closure_r(p, c); 7970 } 7971 // uload16: USHORT_LOAD(riv,riv) 7972 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 7973 if(BURS.DEBUG) trace(p, 133, c + 0, p.getCost(23) /* uload16 */); 7974 if (c < p.getCost(23) /* uload16 */) { 7975 p.setCost(23 /* uload16 */, (char)(c)); 7976 p.writePacked(2, 0xFFFF8FFF, 0x3000); // p.uload16 = 3 7977 closure_uload16(p, c); 7978 } 7979 } 7980 7981 /** 7982 * Labels INT_LOAD tree node 7983 * @param p node to label 7984 */ 7985 private static void label_INT_LOAD(AbstractBURS_TreeNode p) { 7986 p.initCost(); 7987 AbstractBURS_TreeNode lchild, rchild; 7988 lchild = p.getChild1(); 7989 rchild = p.getChild2(); 7990 label(lchild); 7991 label(rchild); 7992 int c; 7993 // r: INT_LOAD(riv,riv) 7994 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 7995 if(BURS.DEBUG) trace(p, 91, c + 0, p.getCost(2) /* r */); 7996 if (c < p.getCost(2) /* r */) { 7997 p.setCost(2 /* r */, (char)(c)); 7998 p.writePacked(0, 0xFFFF00FF, 0x5000); // p.r = 80 7999 closure_r(p, c); 8000 } 8001 // r: INT_LOAD(riv,address1scaledreg) 8002 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 15; 8003 if(BURS.DEBUG) trace(p, 92, c + 0, p.getCost(2) /* r */); 8004 if (c < p.getCost(2) /* r */) { 8005 p.setCost(2 /* r */, (char)(c)); 8006 p.writePacked(0, 0xFFFF00FF, 0x5100); // p.r = 81 8007 closure_r(p, c); 8008 } 8009 // r: INT_LOAD(address1scaledreg,riv) 8010 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(7 /* riv */) + 15; 8011 if(BURS.DEBUG) trace(p, 93, c + 0, p.getCost(2) /* r */); 8012 if (c < p.getCost(2) /* r */) { 8013 p.setCost(2 /* r */, (char)(c)); 8014 p.writePacked(0, 0xFFFF00FF, 0x5200); // p.r = 82 8015 closure_r(p, c); 8016 } 8017 // r: INT_LOAD(address1scaledreg,address1reg) 8018 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild).getCost(17 /* address1reg */) + 15; 8019 if(BURS.DEBUG) trace(p, 94, c + 0, p.getCost(2) /* r */); 8020 if (c < p.getCost(2) /* r */) { 8021 p.setCost(2 /* r */, (char)(c)); 8022 p.writePacked(0, 0xFFFF00FF, 0x5300); // p.r = 83 8023 closure_r(p, c); 8024 } 8025 // r: INT_LOAD(address1reg,address1scaledreg) 8026 c = STATE(lchild).getCost(17 /* address1reg */) + STATE(rchild).getCost(16 /* address1scaledreg */) + 15; 8027 if(BURS.DEBUG) trace(p, 95, c + 0, p.getCost(2) /* r */); 8028 if (c < p.getCost(2) /* r */) { 8029 p.setCost(2 /* r */, (char)(c)); 8030 p.writePacked(0, 0xFFFF00FF, 0x5400); // p.r = 84 8031 closure_r(p, c); 8032 } 8033 if ( // r: INT_LOAD(address,INT_CONSTANT) 8034 rchild.getOpcode() == INT_CONSTANT_opcode 8035 ) { 8036 c = STATE(lchild).getCost(15 /* address */) + 15; 8037 if(BURS.DEBUG) trace(p, 267, c + 0, p.getCost(2) /* r */); 8038 if (c < p.getCost(2) /* r */) { 8039 p.setCost(2 /* r */, (char)(c)); 8040 p.writePacked(0, 0xFFFF00FF, 0x5500); // p.r = 85 8041 closure_r(p, c); 8042 } 8043 } 8044 // load32: INT_LOAD(riv,riv) 8045 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 8046 if(BURS.DEBUG) trace(p, 136, c + 0, p.getCost(10) /* load32 */); 8047 if (c < p.getCost(10) /* load32 */) { 8048 p.setCost(10 /* load32 */, (char)(c)); 8049 p.writePacked(1, 0xFFFFFF1F, 0x40); // p.load32 = 2 8050 closure_load32(p, c); 8051 } 8052 } 8053 8054 /** 8055 * Labels LONG_LOAD tree node 8056 * @param p node to label 8057 */ 8058 private static void label_LONG_LOAD(AbstractBURS_TreeNode p) { 8059 p.initCost(); 8060 AbstractBURS_TreeNode lchild, rchild; 8061 lchild = p.getChild1(); 8062 rchild = p.getChild2(); 8063 label(lchild); 8064 label(rchild); 8065 int c; 8066 // load64: LONG_LOAD(riv,riv) 8067 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 8068 if(BURS.DEBUG) trace(p, 138, c + 0, p.getCost(22) /* load64 */); 8069 if (c < p.getCost(22) /* load64 */) { 8070 p.setCost(22 /* load64 */, (char)(c)); 8071 p.writePacked(2, 0xFFFFF1FF, 0x200); // p.load64 = 1 8072 } 8073 // r: LONG_LOAD(riv,riv) 8074 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 30; 8075 if(BURS.DEBUG) trace(p, 147, c + 0, p.getCost(2) /* r */); 8076 if (c < p.getCost(2) /* r */) { 8077 p.setCost(2 /* r */, (char)(c)); 8078 p.writePacked(0, 0xFFFF00FF, 0x8400); // p.r = 132 8079 closure_r(p, c); 8080 } 8081 } 8082 8083 /** 8084 * Labels FLOAT_LOAD tree node 8085 * @param p node to label 8086 */ 8087 private static void label_FLOAT_LOAD(AbstractBURS_TreeNode p) { 8088 p.initCost(); 8089 AbstractBURS_TreeNode lchild, rchild; 8090 lchild = p.getChild1(); 8091 rchild = p.getChild2(); 8092 label(lchild); 8093 label(rchild); 8094 int c; 8095 // r: FLOAT_LOAD(riv,riv) 8096 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 8097 if(BURS.DEBUG) trace(p, 193, c + 0, p.getCost(2) /* r */); 8098 if (c < p.getCost(2) /* r */) { 8099 p.setCost(2 /* r */, (char)(c)); 8100 p.writePacked(0, 0xFFFF00FF, 0xC100); // p.r = 193 8101 closure_r(p, c); 8102 } 8103 // r: FLOAT_LOAD(rlv,rlv) 8104 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 8105 if(BURS.DEBUG) trace(p, 194, c + 0, p.getCost(2) /* r */); 8106 if (c < p.getCost(2) /* r */) { 8107 p.setCost(2 /* r */, (char)(c)); 8108 p.writePacked(0, 0xFFFF00FF, 0xC200); // p.r = 194 8109 closure_r(p, c); 8110 } 8111 // float_load: FLOAT_LOAD(riv,riv) 8112 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 8113 if(BURS.DEBUG) trace(p, 195, c + 0, p.getCost(25) /* float_load */); 8114 if (c < p.getCost(25) /* float_load */) { 8115 p.setCost(25 /* float_load */, (char)(c)); 8116 p.writePacked(2, 0xFFF1FFFF, 0x20000); // p.float_load = 1 8117 } 8118 } 8119 8120 /** 8121 * Labels DOUBLE_LOAD tree node 8122 * @param p node to label 8123 */ 8124 private static void label_DOUBLE_LOAD(AbstractBURS_TreeNode p) { 8125 p.initCost(); 8126 AbstractBURS_TreeNode lchild, rchild; 8127 lchild = p.getChild1(); 8128 rchild = p.getChild2(); 8129 label(lchild); 8130 label(rchild); 8131 int c; 8132 // r: DOUBLE_LOAD(riv,riv) 8133 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 15; 8134 if(BURS.DEBUG) trace(p, 184, c + 0, p.getCost(2) /* r */); 8135 if (c < p.getCost(2) /* r */) { 8136 p.setCost(2 /* r */, (char)(c)); 8137 p.writePacked(0, 0xFFFF00FF, 0xBB00); // p.r = 187 8138 closure_r(p, c); 8139 } 8140 // r: DOUBLE_LOAD(riv,rlv) 8141 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 8142 if(BURS.DEBUG) trace(p, 185, c + 0, p.getCost(2) /* r */); 8143 if (c < p.getCost(2) /* r */) { 8144 p.setCost(2 /* r */, (char)(c)); 8145 p.writePacked(0, 0xFFFF00FF, 0xBC00); // p.r = 188 8146 closure_r(p, c); 8147 } 8148 // r: DOUBLE_LOAD(rlv,rlv) 8149 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 15; 8150 if(BURS.DEBUG) trace(p, 186, c + 0, p.getCost(2) /* r */); 8151 if (c < p.getCost(2) /* r */) { 8152 p.setCost(2 /* r */, (char)(c)); 8153 p.writePacked(0, 0xFFFF00FF, 0xBD00); // p.r = 189 8154 closure_r(p, c); 8155 } 8156 // double_load: DOUBLE_LOAD(riv,riv) 8157 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(7 /* riv */) + 0; 8158 if(BURS.DEBUG) trace(p, 187, c + 0, p.getCost(26) /* double_load */); 8159 if (c < p.getCost(26) /* double_load */) { 8160 p.setCost(26 /* double_load */, (char)(c)); 8161 p.writePacked(2, 0xFF8FFFFF, 0x100000); // p.double_load = 1 8162 } 8163 // double_load: DOUBLE_LOAD(rlv,rlv) 8164 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild).getCost(8 /* rlv */) + 0; 8165 if(BURS.DEBUG) trace(p, 189, c + 0, p.getCost(26) /* double_load */); 8166 if (c < p.getCost(26) /* double_load */) { 8167 p.setCost(26 /* double_load */, (char)(c)); 8168 p.writePacked(2, 0xFF8FFFFF, 0x200000); // p.double_load = 2 8169 } 8170 } 8171 8172 /** 8173 * Labels BYTE_STORE tree node 8174 * @param p node to label 8175 */ 8176 private static void label_BYTE_STORE(AbstractBURS_TreeNode p) { 8177 p.initCost(); 8178 AbstractBURS_TreeNode lchild, rchild; 8179 lchild = p.getChild1(); 8180 rchild = p.getChild2(); 8181 label(lchild); 8182 label(rchild); 8183 int c; 8184 if ( // stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 8185 rchild.getOpcode() == OTHER_OPERAND_opcode 8186 ) { 8187 c = STATE(lchild).getCost(19 /* boolcmp */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8188 if(BURS.DEBUG) trace(p, 357, c + 0, p.getCost(1) /* stm */); 8189 if (c < p.getCost(1) /* stm */) { 8190 p.setCost(1 /* stm */, (char)(c)); 8191 p.writePacked(0, 0xFFFFFF00, 0x3F); // p.stm = 63 8192 } 8193 } 8194 if ( // stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8195 lchild.getOpcode() == BOOLEAN_NOT_opcode && 8196 lchild.getChild1().getOpcode() == UBYTE_LOAD_opcode && 8197 rchild.getOpcode() == OTHER_OPERAND_opcode 8198 ) { 8199 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); 8200 if(BURS.DEBUG) trace(p, 450, c + 0, p.getCost(1) /* stm */); 8201 if (c < p.getCost(1) /* stm */) { 8202 p.setCost(1 /* stm */, (char)(c)); 8203 p.writePacked(0, 0xFFFFFF00, 0x41); // p.stm = 65 8204 } 8205 } 8206 if ( // stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) 8207 rchild.getOpcode() == OTHER_OPERAND_opcode 8208 ) { 8209 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8210 if(BURS.DEBUG) trace(p, 359, c + 0, p.getCost(1) /* stm */); 8211 if (c < p.getCost(1) /* stm */) { 8212 p.setCost(1 /* stm */, (char)(c)); 8213 p.writePacked(0, 0xFFFFFF00, 0x43); // p.stm = 67 8214 } 8215 } 8216 if ( // stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) 8217 rchild.getOpcode() == OTHER_OPERAND_opcode 8218 ) { 8219 c = STATE(lchild).getCost(20 /* load8 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 8220 if(BURS.DEBUG) trace(p, 360, c + 0, p.getCost(1) /* stm */); 8221 if (c < p.getCost(1) /* stm */) { 8222 p.setCost(1 /* stm */, (char)(c)); 8223 p.writePacked(0, 0xFFFFFF00, 0x44); // p.stm = 68 8224 } 8225 } 8226 if ( // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 8227 lchild.getOpcode() == INT_2BYTE_opcode && 8228 rchild.getOpcode() == OTHER_OPERAND_opcode 8229 ) { 8230 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8231 if(BURS.DEBUG) trace(p, 474, c + 0, p.getCost(1) /* stm */); 8232 if (c < p.getCost(1) /* stm */) { 8233 p.setCost(1 /* stm */, (char)(c)); 8234 p.writePacked(0, 0xFFFFFF00, 0x47); // p.stm = 71 8235 } 8236 } 8237 } 8238 8239 /** 8240 * Labels SHORT_STORE tree node 8241 * @param p node to label 8242 */ 8243 private static void label_SHORT_STORE(AbstractBURS_TreeNode p) { 8244 p.initCost(); 8245 AbstractBURS_TreeNode lchild, rchild; 8246 lchild = p.getChild1(); 8247 rchild = p.getChild2(); 8248 label(lchild); 8249 label(rchild); 8250 int c; 8251 if ( // stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 8252 rchild.getOpcode() == OTHER_OPERAND_opcode 8253 ) { 8254 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8255 if(BURS.DEBUG) trace(p, 342, c + 0, p.getCost(1) /* stm */); 8256 if (c < p.getCost(1) /* stm */) { 8257 p.setCost(1 /* stm */, (char)(c)); 8258 p.writePacked(0, 0xFFFFFF00, 0x15); // p.stm = 21 8259 } 8260 } 8261 if ( // stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 8262 rchild.getOpcode() == OTHER_OPERAND_opcode 8263 ) { 8264 c = STATE(lchild).getCost(14 /* load16 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 25; 8265 if(BURS.DEBUG) trace(p, 343, c + 0, p.getCost(1) /* stm */); 8266 if (c < p.getCost(1) /* stm */) { 8267 p.setCost(1 /* stm */, (char)(c)); 8268 p.writePacked(0, 0xFFFFFF00, 0x16); // p.stm = 22 8269 } 8270 } 8271 if ( // stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 8272 rchild.getOpcode() == OTHER_OPERAND_opcode 8273 ) { 8274 c = STATE(lchild).getCost(8 /* rlv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 8275 if(BURS.DEBUG) trace(p, 344, c + 0, p.getCost(1) /* stm */); 8276 if (c < p.getCost(1) /* stm */) { 8277 p.setCost(1 /* stm */, (char)(c)); 8278 p.writePacked(0, 0xFFFFFF00, 0x17); // p.stm = 23 8279 } 8280 } 8281 if ( // stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 8282 rchild.getOpcode() == OTHER_OPERAND_opcode 8283 ) { 8284 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 15; 8285 if(BURS.DEBUG) trace(p, 345, c + 0, p.getCost(1) /* stm */); 8286 if (c < p.getCost(1) /* stm */) { 8287 p.setCost(1 /* stm */, (char)(c)); 8288 p.writePacked(0, 0xFFFFFF00, 0x18); // p.stm = 24 8289 } 8290 } 8291 if ( // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 8292 lchild.getOpcode() == INT_2SHORT_opcode && 8293 rchild.getOpcode() == OTHER_OPERAND_opcode 8294 ) { 8295 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8296 if(BURS.DEBUG) trace(p, 476, c + 0, p.getCost(1) /* stm */); 8297 if (c < p.getCost(1) /* stm */) { 8298 p.setCost(1 /* stm */, (char)(c)); 8299 p.writePacked(0, 0xFFFFFF00, 0x49); // p.stm = 73 8300 } 8301 } 8302 if ( // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 8303 lchild.getOpcode() == INT_2USHORT_opcode && 8304 rchild.getOpcode() == OTHER_OPERAND_opcode 8305 ) { 8306 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8307 if(BURS.DEBUG) trace(p, 478, c + 0, p.getCost(1) /* stm */); 8308 if (c < p.getCost(1) /* stm */) { 8309 p.setCost(1 /* stm */, (char)(c)); 8310 p.writePacked(0, 0xFFFFFF00, 0x4B); // p.stm = 75 8311 } 8312 } 8313 } 8314 8315 /** 8316 * Labels INT_STORE tree node 8317 * @param p node to label 8318 */ 8319 private static void label_INT_STORE(AbstractBURS_TreeNode p) { 8320 p.initCost(); 8321 AbstractBURS_TreeNode lchild, rchild; 8322 lchild = p.getChild1(); 8323 rchild = p.getChild2(); 8324 label(lchild); 8325 label(rchild); 8326 int c; 8327 if ( // stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 8328 lchild.getOpcode() == INT_ADD_opcode && 8329 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8330 rchild.getOpcode() == OTHER_OPERAND_opcode 8331 ) { 8332 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); 8333 if(BURS.DEBUG) trace(p, 482, c + 0, p.getCost(1) /* stm */); 8334 if (c < p.getCost(1) /* stm */) { 8335 p.setCost(1 /* stm */, (char)(c)); 8336 p.writePacked(0, 0xFFFFFF00, 0x4D); // p.stm = 77 8337 } 8338 } 8339 if ( // stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8340 lchild.getOpcode() == INT_ADD_opcode && 8341 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 8342 rchild.getOpcode() == OTHER_OPERAND_opcode 8343 ) { 8344 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); 8345 if(BURS.DEBUG) trace(p, 502, c + 0, p.getCost(1) /* stm */); 8346 if (c < p.getCost(1) /* stm */) { 8347 p.setCost(1 /* stm */, (char)(c)); 8348 p.writePacked(0, 0xFFFFFF00, 0x4E); // p.stm = 78 8349 } 8350 } 8351 if ( // stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 8352 lchild.getOpcode() == INT_AND_opcode && 8353 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8354 rchild.getOpcode() == OTHER_OPERAND_opcode 8355 ) { 8356 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); 8357 if(BURS.DEBUG) trace(p, 484, c + 0, p.getCost(1) /* stm */); 8358 if (c < p.getCost(1) /* stm */) { 8359 p.setCost(1 /* stm */, (char)(c)); 8360 p.writePacked(0, 0xFFFFFF00, 0x51); // p.stm = 81 8361 } 8362 } 8363 if ( // stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8364 lchild.getOpcode() == INT_AND_opcode && 8365 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 8366 rchild.getOpcode() == OTHER_OPERAND_opcode 8367 ) { 8368 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); 8369 if(BURS.DEBUG) trace(p, 504, c + 0, p.getCost(1) /* stm */); 8370 if (c < p.getCost(1) /* stm */) { 8371 p.setCost(1 /* stm */, (char)(c)); 8372 p.writePacked(0, 0xFFFFFF00, 0x52); // p.stm = 82 8373 } 8374 } 8375 if ( // stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8376 lchild.getOpcode() == INT_NEG_opcode && 8377 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8378 rchild.getOpcode() == OTHER_OPERAND_opcode 8379 ) { 8380 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); 8381 if(BURS.DEBUG) trace(p, 452, c + 0, p.getCost(1) /* stm */); 8382 if (c < p.getCost(1) /* stm */) { 8383 p.setCost(1 /* stm */, (char)(c)); 8384 p.writePacked(0, 0xFFFFFF00, 0x65); // p.stm = 101 8385 } 8386 } 8387 if ( // stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8388 lchild.getOpcode() == INT_NOT_opcode && 8389 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8390 rchild.getOpcode() == OTHER_OPERAND_opcode 8391 ) { 8392 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); 8393 if(BURS.DEBUG) trace(p, 454, c + 0, p.getCost(1) /* stm */); 8394 if (c < p.getCost(1) /* stm */) { 8395 p.setCost(1 /* stm */, (char)(c)); 8396 p.writePacked(0, 0xFFFFFF00, 0x67); // p.stm = 103 8397 } 8398 } 8399 if ( // stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 8400 lchild.getOpcode() == INT_OR_opcode && 8401 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8402 rchild.getOpcode() == OTHER_OPERAND_opcode 8403 ) { 8404 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); 8405 if(BURS.DEBUG) trace(p, 486, c + 0, p.getCost(1) /* stm */); 8406 if (c < p.getCost(1) /* stm */) { 8407 p.setCost(1 /* stm */, (char)(c)); 8408 p.writePacked(0, 0xFFFFFF00, 0x69); // p.stm = 105 8409 } 8410 } 8411 if ( // stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8412 lchild.getOpcode() == INT_OR_opcode && 8413 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 8414 rchild.getOpcode() == OTHER_OPERAND_opcode 8415 ) { 8416 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); 8417 if(BURS.DEBUG) trace(p, 506, c + 0, p.getCost(1) /* stm */); 8418 if (c < p.getCost(1) /* stm */) { 8419 p.setCost(1 /* stm */, (char)(c)); 8420 p.writePacked(0, 0xFFFFFF00, 0x6A); // p.stm = 106 8421 } 8422 } 8423 if ( // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 8424 lchild.getOpcode() == INT_SHL_opcode && 8425 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8426 lchild.getChild2().getOpcode() == INT_AND_opcode && 8427 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 8428 rchild.getOpcode() == OTHER_OPERAND_opcode 8429 ) { 8430 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)); 8431 if(BURS.DEBUG) trace(p, 537, c + 0, p.getCost(1) /* stm */); 8432 if (c < p.getCost(1) /* stm */) { 8433 p.setCost(1 /* stm */, (char)(c)); 8434 p.writePacked(0, 0xFFFFFF00, 0x6D); // p.stm = 109 8435 } 8436 } 8437 if ( // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 8438 lchild.getOpcode() == INT_SHL_opcode && 8439 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8440 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 8441 rchild.getOpcode() == OTHER_OPERAND_opcode 8442 ) { 8443 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); 8444 if(BURS.DEBUG) trace(p, 456, c + 0, p.getCost(1) /* stm */); 8445 if (c < p.getCost(1) /* stm */) { 8446 p.setCost(1 /* stm */, (char)(c)); 8447 p.writePacked(0, 0xFFFFFF00, 0x6E); // p.stm = 110 8448 } 8449 } 8450 if ( // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 8451 lchild.getOpcode() == INT_SHR_opcode && 8452 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8453 lchild.getChild2().getOpcode() == INT_AND_opcode && 8454 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 8455 rchild.getOpcode() == OTHER_OPERAND_opcode 8456 ) { 8457 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)); 8458 if(BURS.DEBUG) trace(p, 539, c + 0, p.getCost(1) /* stm */); 8459 if (c < p.getCost(1) /* stm */) { 8460 p.setCost(1 /* stm */, (char)(c)); 8461 p.writePacked(0, 0xFFFFFF00, 0x71); // p.stm = 113 8462 } 8463 } 8464 if ( // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 8465 lchild.getOpcode() == INT_SHR_opcode && 8466 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8467 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 8468 rchild.getOpcode() == OTHER_OPERAND_opcode 8469 ) { 8470 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); 8471 if(BURS.DEBUG) trace(p, 458, 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, 0x72); // p.stm = 114 8475 } 8476 } 8477 if ( // stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) 8478 rchild.getOpcode() == OTHER_OPERAND_opcode 8479 ) { 8480 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8481 if(BURS.DEBUG) trace(p, 368, c + 0, p.getCost(1) /* stm */); 8482 if (c < p.getCost(1) /* stm */) { 8483 p.setCost(1 /* stm */, (char)(c)); 8484 p.writePacked(0, 0xFFFFFF00, 0x75); // p.stm = 117 8485 } 8486 } 8487 if ( // stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) 8488 rchild.getOpcode() == OTHER_OPERAND_opcode 8489 ) { 8490 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(16 /* address1scaledreg */) + 15; 8491 if(BURS.DEBUG) trace(p, 369, c + 0, p.getCost(1) /* stm */); 8492 if (c < p.getCost(1) /* stm */) { 8493 p.setCost(1 /* stm */, (char)(c)); 8494 p.writePacked(0, 0xFFFFFF00, 0x76); // p.stm = 118 8495 } 8496 } 8497 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) 8498 rchild.getOpcode() == OTHER_OPERAND_opcode 8499 ) { 8500 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8501 if(BURS.DEBUG) trace(p, 370, c + 0, p.getCost(1) /* stm */); 8502 if (c < p.getCost(1) /* stm */) { 8503 p.setCost(1 /* stm */, (char)(c)); 8504 p.writePacked(0, 0xFFFFFF00, 0x77); // p.stm = 119 8505 } 8506 } 8507 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 8508 rchild.getOpcode() == OTHER_OPERAND_opcode 8509 ) { 8510 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild2()).getCost(17 /* address1reg */) + 15; 8511 if(BURS.DEBUG) trace(p, 371, c + 0, p.getCost(1) /* stm */); 8512 if (c < p.getCost(1) /* stm */) { 8513 p.setCost(1 /* stm */, (char)(c)); 8514 p.writePacked(0, 0xFFFFFF00, 0x78); // p.stm = 120 8515 } 8516 } 8517 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 8518 rchild.getOpcode() == OTHER_OPERAND_opcode 8519 ) { 8520 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(17 /* address1reg */) + STATE(rchild.getChild2()).getCost(16 /* address1scaledreg */) + 15; 8521 if(BURS.DEBUG) trace(p, 372, c + 0, p.getCost(1) /* stm */); 8522 if (c < p.getCost(1) /* stm */) { 8523 p.setCost(1 /* stm */, (char)(c)); 8524 p.writePacked(0, 0xFFFFFF00, 0x79); // p.stm = 121 8525 } 8526 } 8527 if ( // stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) 8528 rchild.getOpcode() == OTHER_OPERAND_opcode && 8529 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 8530 ) { 8531 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(15 /* address */) + 15; 8532 if(BURS.DEBUG) trace(p, 532, c + 0, p.getCost(1) /* stm */); 8533 if (c < p.getCost(1) /* stm */) { 8534 p.setCost(1 /* stm */, (char)(c)); 8535 p.writePacked(0, 0xFFFFFF00, 0x7A); // p.stm = 122 8536 } 8537 } 8538 if ( // stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 8539 lchild.getOpcode() == INT_SUB_opcode && 8540 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8541 rchild.getOpcode() == OTHER_OPERAND_opcode 8542 ) { 8543 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); 8544 if(BURS.DEBUG) trace(p, 488, c + 0, p.getCost(1) /* stm */); 8545 if (c < p.getCost(1) /* stm */) { 8546 p.setCost(1 /* stm */, (char)(c)); 8547 p.writePacked(0, 0xFFFFFF00, 0x7B); // p.stm = 123 8548 } 8549 } 8550 if ( // stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8551 lchild.getOpcode() == INT_SUB_opcode && 8552 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 8553 rchild.getOpcode() == OTHER_OPERAND_opcode 8554 ) { 8555 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); 8556 if(BURS.DEBUG) trace(p, 508, c + 0, p.getCost(1) /* stm */); 8557 if (c < p.getCost(1) /* stm */) { 8558 p.setCost(1 /* stm */, (char)(c)); 8559 p.writePacked(0, 0xFFFFFF00, 0x7C); // p.stm = 124 8560 } 8561 } 8562 if ( // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 8563 lchild.getOpcode() == INT_USHR_opcode && 8564 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8565 lchild.getChild2().getOpcode() == INT_AND_opcode && 8566 lchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode && 8567 rchild.getOpcode() == OTHER_OPERAND_opcode 8568 ) { 8569 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)); 8570 if(BURS.DEBUG) trace(p, 541, c + 0, p.getCost(1) /* stm */); 8571 if (c < p.getCost(1) /* stm */) { 8572 p.setCost(1 /* stm */, (char)(c)); 8573 p.writePacked(0, 0xFFFFFF00, 0x7F); // p.stm = 127 8574 } 8575 } 8576 if ( // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 8577 lchild.getOpcode() == INT_USHR_opcode && 8578 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8579 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 8580 rchild.getOpcode() == OTHER_OPERAND_opcode 8581 ) { 8582 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); 8583 if(BURS.DEBUG) trace(p, 460, c + 0, p.getCost(1) /* stm */); 8584 if (c < p.getCost(1) /* stm */) { 8585 p.setCost(1 /* stm */, (char)(c)); 8586 p.writePacked(0, 0xFFFFFF00, 0x80); // p.stm = 128 8587 } 8588 } 8589 if ( // stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 8590 lchild.getOpcode() == INT_XOR_opcode && 8591 lchild.getChild1().getOpcode() == INT_LOAD_opcode && 8592 rchild.getOpcode() == OTHER_OPERAND_opcode 8593 ) { 8594 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); 8595 if(BURS.DEBUG) trace(p, 490, c + 0, p.getCost(1) /* stm */); 8596 if (c < p.getCost(1) /* stm */) { 8597 p.setCost(1 /* stm */, (char)(c)); 8598 p.writePacked(0, 0xFFFFFF00, 0x83); // p.stm = 131 8599 } 8600 } 8601 if ( // stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8602 lchild.getOpcode() == INT_XOR_opcode && 8603 lchild.getChild2().getOpcode() == INT_LOAD_opcode && 8604 rchild.getOpcode() == OTHER_OPERAND_opcode 8605 ) { 8606 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); 8607 if(BURS.DEBUG) trace(p, 510, c + 0, p.getCost(1) /* stm */); 8608 if (c < p.getCost(1) /* stm */) { 8609 p.setCost(1 /* stm */, (char)(c)); 8610 p.writePacked(0, 0xFFFFFF00, 0x84); // p.stm = 132 8611 } 8612 } 8613 if ( // stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 8614 lchild.getOpcode() == LONG_2INT_opcode && 8615 rchild.getOpcode() == OTHER_OPERAND_opcode 8616 ) { 8617 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 15; 8618 if(BURS.DEBUG) trace(p, 480, c + 0, p.getCost(1) /* stm */); 8619 if (c < p.getCost(1) /* stm */) { 8620 p.setCost(1 /* stm */, (char)(c)); 8621 p.writePacked(0, 0xFFFFFF00, 0x87); // p.stm = 135 8622 } 8623 } 8624 } 8625 8626 /** 8627 * Labels LONG_STORE tree node 8628 * @param p node to label 8629 */ 8630 private static void label_LONG_STORE(AbstractBURS_TreeNode p) { 8631 p.initCost(); 8632 AbstractBURS_TreeNode lchild, rchild; 8633 lchild = p.getChild1(); 8634 rchild = p.getChild2(); 8635 label(lchild); 8636 label(rchild); 8637 int c; 8638 if ( // stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 8639 lchild.getOpcode() == LONG_ADD_opcode && 8640 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8641 rchild.getOpcode() == OTHER_OPERAND_opcode 8642 ) { 8643 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), 34); 8644 if(BURS.DEBUG) trace(p, 492, c + 0, p.getCost(1) /* stm */); 8645 if (c < p.getCost(1) /* stm */) { 8646 p.setCost(1 /* stm */, (char)(c)); 8647 p.writePacked(0, 0xFFFFFF00, 0x89); // p.stm = 137 8648 } 8649 } 8650 if ( // stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 8651 lchild.getOpcode() == LONG_ADD_opcode && 8652 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 8653 rchild.getOpcode() == OTHER_OPERAND_opcode 8654 ) { 8655 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), 34); 8656 if(BURS.DEBUG) trace(p, 512, c + 0, p.getCost(1) /* stm */); 8657 if (c < p.getCost(1) /* stm */) { 8658 p.setCost(1 /* stm */, (char)(c)); 8659 p.writePacked(0, 0xFFFFFF00, 0x8A); // p.stm = 138 8660 } 8661 } 8662 if ( // stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 8663 lchild.getOpcode() == LONG_AND_opcode && 8664 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8665 rchild.getOpcode() == OTHER_OPERAND_opcode 8666 ) { 8667 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), 34); 8668 if(BURS.DEBUG) trace(p, 494, c + 0, p.getCost(1) /* stm */); 8669 if (c < p.getCost(1) /* stm */) { 8670 p.setCost(1 /* stm */, (char)(c)); 8671 p.writePacked(0, 0xFFFFFF00, 0x8D); // p.stm = 141 8672 } 8673 } 8674 if ( // stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 8675 lchild.getOpcode() == LONG_AND_opcode && 8676 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 8677 rchild.getOpcode() == OTHER_OPERAND_opcode 8678 ) { 8679 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), 34); 8680 if(BURS.DEBUG) trace(p, 514, c + 0, p.getCost(1) /* stm */); 8681 if (c < p.getCost(1) /* stm */) { 8682 p.setCost(1 /* stm */, (char)(c)); 8683 p.writePacked(0, 0xFFFFFF00, 0x8E); // p.stm = 142 8684 } 8685 } 8686 if ( // stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8687 lchild.getOpcode() == LONG_NEG_opcode && 8688 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8689 rchild.getOpcode() == OTHER_OPERAND_opcode 8690 ) { 8691 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), 34); 8692 if(BURS.DEBUG) trace(p, 462, c + 0, p.getCost(1) /* stm */); 8693 if (c < p.getCost(1) /* stm */) { 8694 p.setCost(1 /* stm */, (char)(c)); 8695 p.writePacked(0, 0xFFFFFF00, 0x92); // p.stm = 146 8696 } 8697 } 8698 if ( // stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 8699 lchild.getOpcode() == LONG_NOT_opcode && 8700 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8701 rchild.getOpcode() == OTHER_OPERAND_opcode 8702 ) { 8703 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), 34); 8704 if(BURS.DEBUG) trace(p, 464, c + 0, p.getCost(1) /* stm */); 8705 if (c < p.getCost(1) /* stm */) { 8706 p.setCost(1 /* stm */, (char)(c)); 8707 p.writePacked(0, 0xFFFFFF00, 0x94); // p.stm = 148 8708 } 8709 } 8710 if ( // stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 8711 lchild.getOpcode() == LONG_OR_opcode && 8712 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8713 rchild.getOpcode() == OTHER_OPERAND_opcode 8714 ) { 8715 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), 34); 8716 if(BURS.DEBUG) trace(p, 496, c + 0, p.getCost(1) /* stm */); 8717 if (c < p.getCost(1) /* stm */) { 8718 p.setCost(1 /* stm */, (char)(c)); 8719 p.writePacked(0, 0xFFFFFF00, 0x96); // p.stm = 150 8720 } 8721 } 8722 if ( // stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 8723 lchild.getOpcode() == LONG_OR_opcode && 8724 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 8725 rchild.getOpcode() == OTHER_OPERAND_opcode 8726 ) { 8727 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), 34); 8728 if(BURS.DEBUG) trace(p, 516, c + 0, p.getCost(1) /* stm */); 8729 if (c < p.getCost(1) /* stm */) { 8730 p.setCost(1 /* stm */, (char)(c)); 8731 p.writePacked(0, 0xFFFFFF00, 0x97); // p.stm = 151 8732 } 8733 } 8734 if ( // stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) 8735 rchild.getOpcode() == OTHER_OPERAND_opcode 8736 ) { 8737 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 30; 8738 if(BURS.DEBUG) trace(p, 374, c + 0, p.getCost(1) /* stm */); 8739 if (c < p.getCost(1) /* stm */) { 8740 p.setCost(1 /* stm */, (char)(c)); 8741 p.writePacked(0, 0xFFFFFF00, 0x9A); // p.stm = 154 8742 } 8743 } 8744 if ( // stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 8745 lchild.getOpcode() == LONG_CONSTANT_opcode && 8746 rchild.getOpcode() == OTHER_OPERAND_opcode 8747 ) { 8748 c = STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 26; 8749 if(BURS.DEBUG) trace(p, 407, c + 0, p.getCost(1) /* stm */); 8750 if (c < p.getCost(1) /* stm */) { 8751 p.setCost(1 /* stm */, (char)(c)); 8752 p.writePacked(0, 0xFFFFFF00, 0x9B); // p.stm = 155 8753 } 8754 } 8755 if ( // stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 8756 lchild.getOpcode() == LONG_SUB_opcode && 8757 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8758 rchild.getOpcode() == OTHER_OPERAND_opcode 8759 ) { 8760 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), 34); 8761 if(BURS.DEBUG) trace(p, 498, c + 0, p.getCost(1) /* stm */); 8762 if (c < p.getCost(1) /* stm */) { 8763 p.setCost(1 /* stm */, (char)(c)); 8764 p.writePacked(0, 0xFFFFFF00, 0x9C); // p.stm = 156 8765 } 8766 } 8767 if ( // stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 8768 lchild.getOpcode() == LONG_XOR_opcode && 8769 lchild.getChild1().getOpcode() == LONG_LOAD_opcode && 8770 rchild.getOpcode() == OTHER_OPERAND_opcode 8771 ) { 8772 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), 34); 8773 if(BURS.DEBUG) trace(p, 500, c + 0, p.getCost(1) /* stm */); 8774 if (c < p.getCost(1) /* stm */) { 8775 p.setCost(1 /* stm */, (char)(c)); 8776 p.writePacked(0, 0xFFFFFF00, 0x9E); // p.stm = 158 8777 } 8778 } 8779 if ( // stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 8780 lchild.getOpcode() == LONG_XOR_opcode && 8781 lchild.getChild2().getOpcode() == LONG_LOAD_opcode && 8782 rchild.getOpcode() == OTHER_OPERAND_opcode 8783 ) { 8784 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), 34); 8785 if(BURS.DEBUG) trace(p, 518, c + 0, p.getCost(1) /* stm */); 8786 if (c < p.getCost(1) /* stm */) { 8787 p.setCost(1 /* stm */, (char)(c)); 8788 p.writePacked(0, 0xFFFFFF00, 0x9F); // p.stm = 159 8789 } 8790 } 8791 if ( // stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 8792 rchild.getOpcode() == OTHER_OPERAND_opcode 8793 ) { 8794 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 8795 if(BURS.DEBUG) trace(p, 403, c + 0, p.getCost(1) /* stm */); 8796 if (c < p.getCost(1) /* stm */) { 8797 p.setCost(1 /* stm */, (char)(c)); 8798 p.writePacked(0, 0xFFFFFF00, 0xBD); // p.stm = 189 8799 } 8800 } 8801 if ( // stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 8802 rchild.getOpcode() == OTHER_OPERAND_opcode 8803 ) { 8804 c = STATE(lchild).getCost(22 /* load64 */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 32; 8805 if(BURS.DEBUG) trace(p, 404, c + 0, p.getCost(1) /* stm */); 8806 if (c < p.getCost(1) /* stm */) { 8807 p.setCost(1 /* stm */, (char)(c)); 8808 p.writePacked(0, 0xFFFFFF00, 0xBE); // p.stm = 190 8809 } 8810 } 8811 } 8812 8813 /** 8814 * Labels FLOAT_STORE tree node 8815 * @param p node to label 8816 */ 8817 private static void label_FLOAT_STORE(AbstractBURS_TreeNode p) { 8818 p.initCost(); 8819 AbstractBURS_TreeNode lchild, rchild; 8820 lchild = p.getChild1(); 8821 rchild = p.getChild2(); 8822 label(lchild); 8823 label(rchild); 8824 int c; 8825 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 8826 rchild.getOpcode() == OTHER_OPERAND_opcode 8827 ) { 8828 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 8829 if(BURS.DEBUG) trace(p, 384, c + 0, p.getCost(1) /* stm */); 8830 if (c < p.getCost(1) /* stm */) { 8831 p.setCost(1 /* stm */, (char)(c)); 8832 p.writePacked(0, 0xFFFFFF00, 0xAB); // p.stm = 171 8833 } 8834 } 8835 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 8836 rchild.getOpcode() == OTHER_OPERAND_opcode 8837 ) { 8838 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 8839 if(BURS.DEBUG) trace(p, 385, c + 0, p.getCost(1) /* stm */); 8840 if (c < p.getCost(1) /* stm */) { 8841 p.setCost(1 /* stm */, (char)(c)); 8842 p.writePacked(0, 0xFFFFFF00, 0xAC); // p.stm = 172 8843 } 8844 } 8845 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 8846 rchild.getOpcode() == OTHER_OPERAND_opcode 8847 ) { 8848 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 8849 if(BURS.DEBUG) trace(p, 386, c + 0, p.getCost(1) /* stm */); 8850 if (c < p.getCost(1) /* stm */) { 8851 p.setCost(1 /* stm */, (char)(c)); 8852 p.writePacked(0, 0xFFFFFF00, 0xAD); // p.stm = 173 8853 } 8854 } 8855 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 8856 rchild.getOpcode() == OTHER_OPERAND_opcode 8857 ) { 8858 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 8859 if(BURS.DEBUG) trace(p, 387, c + 0, p.getCost(1) /* stm */); 8860 if (c < p.getCost(1) /* stm */) { 8861 p.setCost(1 /* stm */, (char)(c)); 8862 p.writePacked(0, 0xFFFFFF00, 0xAE); // p.stm = 174 8863 } 8864 } 8865 } 8866 8867 /** 8868 * Labels DOUBLE_STORE tree node 8869 * @param p node to label 8870 */ 8871 private static void label_DOUBLE_STORE(AbstractBURS_TreeNode p) { 8872 p.initCost(); 8873 AbstractBURS_TreeNode lchild, rchild; 8874 lchild = p.getChild1(); 8875 rchild = p.getChild2(); 8876 label(lchild); 8877 label(rchild); 8878 int c; 8879 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 8880 rchild.getOpcode() == OTHER_OPERAND_opcode 8881 ) { 8882 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 8883 if(BURS.DEBUG) trace(p, 375, c + 0, p.getCost(1) /* stm */); 8884 if (c < p.getCost(1) /* stm */) { 8885 p.setCost(1 /* stm */, (char)(c)); 8886 p.writePacked(0, 0xFFFFFF00, 0xA2); // p.stm = 162 8887 } 8888 } 8889 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 8890 rchild.getOpcode() == OTHER_OPERAND_opcode 8891 ) { 8892 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 8893 if(BURS.DEBUG) trace(p, 376, c + 0, p.getCost(1) /* stm */); 8894 if (c < p.getCost(1) /* stm */) { 8895 p.setCost(1 /* stm */, (char)(c)); 8896 p.writePacked(0, 0xFFFFFF00, 0xA3); // p.stm = 163 8897 } 8898 } 8899 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 8900 rchild.getOpcode() == OTHER_OPERAND_opcode 8901 ) { 8902 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(7 /* riv */) + 17; 8903 if(BURS.DEBUG) trace(p, 377, c + 0, p.getCost(1) /* stm */); 8904 if (c < p.getCost(1) /* stm */) { 8905 p.setCost(1 /* stm */, (char)(c)); 8906 p.writePacked(0, 0xFFFFFF00, 0xA4); // p.stm = 164 8907 } 8908 } 8909 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 8910 rchild.getOpcode() == OTHER_OPERAND_opcode 8911 ) { 8912 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(8 /* rlv */) + 17; 8913 if(BURS.DEBUG) trace(p, 378, c + 0, p.getCost(1) /* stm */); 8914 if (c < p.getCost(1) /* stm */) { 8915 p.setCost(1 /* stm */, (char)(c)); 8916 p.writePacked(0, 0xFFFFFF00, 0xA5); // p.stm = 165 8917 } 8918 } 8919 } 8920 8921 /** 8922 * Labels ATTEMPT_INT tree node 8923 * @param p node to label 8924 */ 8925 private static void label_ATTEMPT_INT(AbstractBURS_TreeNode p) { 8926 p.initCost(); 8927 AbstractBURS_TreeNode lchild, rchild; 8928 lchild = p.getChild1(); 8929 rchild = p.getChild2(); 8930 label(lchild); 8931 label(rchild); 8932 int c; 8933 if ( // r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 8934 rchild.getOpcode() == OTHER_OPERAND_opcode && 8935 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8936 ) { 8937 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; 8938 if(BURS.DEBUG) trace(p, 414, c + 0, p.getCost(2) /* r */); 8939 if (c < p.getCost(2) /* r */) { 8940 p.setCost(2 /* r */, (char)(c)); 8941 p.writePacked(0, 0xFFFF00FF, 0x1800); // p.r = 24 8942 closure_r(p, c); 8943 } 8944 } 8945 if ( // r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 8946 rchild.getOpcode() == OTHER_OPERAND_opcode && 8947 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8948 ) { 8949 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; 8950 if(BURS.DEBUG) trace(p, 415, c + 0, p.getCost(2) /* r */); 8951 if (c < p.getCost(2) /* r */) { 8952 p.setCost(2 /* r */, (char)(c)); 8953 p.writePacked(0, 0xFFFF00FF, 0x1900); // p.r = 25 8954 closure_r(p, c); 8955 } 8956 } 8957 if ( // r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 8958 rchild.getOpcode() == OTHER_OPERAND_opcode && 8959 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8960 ) { 8961 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; 8962 if(BURS.DEBUG) trace(p, 416, c + 0, p.getCost(2) /* r */); 8963 if (c < p.getCost(2) /* r */) { 8964 p.setCost(2 /* r */, (char)(c)); 8965 p.writePacked(0, 0xFFFF00FF, 0x1A00); // p.r = 26 8966 closure_r(p, c); 8967 } 8968 } 8969 if ( // r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 8970 rchild.getOpcode() == OTHER_OPERAND_opcode && 8971 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8972 ) { 8973 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 8974 if(BURS.DEBUG) trace(p, 417, c + 0, p.getCost(2) /* r */); 8975 if (c < p.getCost(2) /* r */) { 8976 p.setCost(2 /* r */, (char)(c)); 8977 p.writePacked(0, 0xFFFF00FF, 0x1B00); // p.r = 27 8978 closure_r(p, c); 8979 } 8980 } 8981 if ( // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 8982 rchild.getOpcode() == OTHER_OPERAND_opcode && 8983 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8984 ) { 8985 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 8986 if(BURS.DEBUG) trace(p, 418, c + 0, p.getCost(2) /* r */); 8987 if (c < p.getCost(2) /* r */) { 8988 p.setCost(2 /* r */, (char)(c)); 8989 p.writePacked(0, 0xFFFF00FF, 0x1C00); // p.r = 28 8990 closure_r(p, c); 8991 } 8992 } 8993 if ( // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 8994 rchild.getOpcode() == OTHER_OPERAND_opcode && 8995 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 8996 ) { 8997 c = STATE(lchild).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild1()).getCost(17 /* address1reg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 8998 if(BURS.DEBUG) trace(p, 419, c + 0, p.getCost(2) /* r */); 8999 if (c < p.getCost(2) /* r */) { 9000 p.setCost(2 /* r */, (char)(c)); 9001 p.writePacked(0, 0xFFFF00FF, 0x1D00); // p.r = 29 9002 closure_r(p, c); 9003 } 9004 } 9005 if ( // r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 9006 rchild.getOpcode() == OTHER_OPERAND_opcode && 9007 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 9008 ) { 9009 c = STATE(lchild).getCost(17 /* address1reg */) + STATE(rchild.getChild1()).getCost(16 /* address1scaledreg */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 9010 if(BURS.DEBUG) trace(p, 420, c + 0, p.getCost(2) /* r */); 9011 if (c < p.getCost(2) /* r */) { 9012 p.setCost(2 /* r */, (char)(c)); 9013 p.writePacked(0, 0xFFFF00FF, 0x1E00); // p.r = 30 9014 closure_r(p, c); 9015 } 9016 } 9017 if ( // r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 9018 rchild.getOpcode() == OTHER_OPERAND_opcode && 9019 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 9020 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 9021 ) { 9022 c = STATE(lchild).getCost(15 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 9023 if(BURS.DEBUG) trace(p, 426, c + 0, p.getCost(2) /* r */); 9024 if (c < p.getCost(2) /* r */) { 9025 p.setCost(2 /* r */, (char)(c)); 9026 p.writePacked(0, 0xFFFF00FF, 0x1F00); // p.r = 31 9027 closure_r(p, c); 9028 } 9029 } 9030 if ( // r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 9031 lchild.getOpcode() == INT_CONSTANT_opcode && 9032 rchild.getOpcode() == OTHER_OPERAND_opcode && 9033 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 9034 ) { 9035 c = STATE(rchild.getChild1()).getCost(15 /* address */) + STATE(rchild.getChild2().getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild2()).getCost(7 /* riv */) + 67; 9036 if(BURS.DEBUG) trace(p, 427, c + 0, p.getCost(2) /* r */); 9037 if (c < p.getCost(2) /* r */) { 9038 p.setCost(2 /* r */, (char)(c)); 9039 p.writePacked(0, 0xFFFF00FF, 0x2000); // p.r = 32 9040 closure_r(p, c); 9041 } 9042 } 9043 } 9044 9045 /** 9046 * Labels ATTEMPT_LONG tree node 9047 * @param p node to label 9048 */ 9049 private static void label_ATTEMPT_LONG(AbstractBURS_TreeNode p) { 9050 p.initCost(); 9051 AbstractBURS_TreeNode lchild, rchild; 9052 lchild = p.getChild1(); 9053 rchild = p.getChild2(); 9054 label(lchild); 9055 label(rchild); 9056 int c; 9057 if ( // r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) 9058 rchild.getOpcode() == OTHER_OPERAND_opcode && 9059 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 9060 ) { 9061 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2().getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2().getChild2()).getCost(8 /* rlv */) + 67; 9062 if(BURS.DEBUG) trace(p, 421, c + 0, p.getCost(2) /* r */); 9063 if (c < p.getCost(2) /* r */) { 9064 p.setCost(2 /* r */, (char)(c)); 9065 p.writePacked(0, 0xFFFF00FF, 0x2100); // p.r = 33 9066 closure_r(p, c); 9067 } 9068 } 9069 } 9070 9071 /** 9072 * Labels CALL tree node 9073 * @param p node to label 9074 */ 9075 private static void label_CALL(AbstractBURS_TreeNode p) { 9076 p.initCost(); 9077 AbstractBURS_TreeNode lchild, rchild; 9078 lchild = p.getChild1(); 9079 rchild = p.getChild2(); 9080 label(lchild); 9081 label(rchild); 9082 int c; 9083 // r: CALL(r,any) 9084 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(9 /* any */) + 13; 9085 if(BURS.DEBUG) trace(p, 55, c + 0, p.getCost(2) /* r */); 9086 if (c < p.getCost(2) /* r */) { 9087 p.setCost(2 /* r */, (char)(c)); 9088 p.writePacked(0, 0xFFFF00FF, 0xD00); // p.r = 13 9089 closure_r(p, c); 9090 } 9091 if ( // r: CALL(BRANCH_TARGET,any) 9092 lchild.getOpcode() == BRANCH_TARGET_opcode 9093 ) { 9094 c = STATE(rchild).getCost(9 /* any */) + 13; 9095 if(BURS.DEBUG) trace(p, 408, c + 0, p.getCost(2) /* r */); 9096 if (c < p.getCost(2) /* r */) { 9097 p.setCost(2 /* r */, (char)(c)); 9098 p.writePacked(0, 0xFFFF00FF, 0xE00); // p.r = 14 9099 closure_r(p, c); 9100 } 9101 } 9102 if ( // r: CALL(INT_LOAD(riv,riv),any) 9103 lchild.getOpcode() == INT_LOAD_opcode 9104 ) { 9105 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild).getCost(9 /* any */) + 11; 9106 if(BURS.DEBUG) trace(p, 411, c + 0, p.getCost(2) /* r */); 9107 if (c < p.getCost(2) /* r */) { 9108 p.setCost(2 /* r */, (char)(c)); 9109 p.writePacked(0, 0xFFFF00FF, 0xF00); // p.r = 15 9110 closure_r(p, c); 9111 } 9112 } 9113 if ( // r: CALL(INT_CONSTANT,any) 9114 lchild.getOpcode() == INT_CONSTANT_opcode 9115 ) { 9116 c = STATE(rchild).getCost(9 /* any */) + 23; 9117 if(BURS.DEBUG) trace(p, 409, c + 0, p.getCost(2) /* r */); 9118 if (c < p.getCost(2) /* r */) { 9119 p.setCost(2 /* r */, (char)(c)); 9120 p.writePacked(0, 0xFFFF00FF, 0x1000); // p.r = 16 9121 closure_r(p, c); 9122 } 9123 } 9124 if ( // r: CALL(LONG_LOAD(rlv,rlv),any) 9125 lchild.getOpcode() == LONG_LOAD_opcode 9126 ) { 9127 c = STATE(lchild.getChild1()).getCost(8 /* rlv */) + STATE(lchild.getChild2()).getCost(8 /* rlv */) + STATE(rchild).getCost(9 /* any */) + 11; 9128 if(BURS.DEBUG) trace(p, 412, c + 0, p.getCost(2) /* r */); 9129 if (c < p.getCost(2) /* r */) { 9130 p.setCost(2 /* r */, (char)(c)); 9131 p.writePacked(0, 0xFFFF00FF, 0x1100); // p.r = 17 9132 closure_r(p, c); 9133 } 9134 } 9135 } 9136 9137 /** 9138 * Labels SYSCALL tree node 9139 * @param p node to label 9140 */ 9141 private static void label_SYSCALL(AbstractBURS_TreeNode p) { 9142 p.initCost(); 9143 AbstractBURS_TreeNode lchild, rchild; 9144 lchild = p.getChild1(); 9145 rchild = p.getChild2(); 9146 label(lchild); 9147 label(rchild); 9148 int c; 9149 // r: SYSCALL(r,any) 9150 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(9 /* any */) + 13; 9151 if(BURS.DEBUG) trace(p, 56, c + 0, p.getCost(2) /* r */); 9152 if (c < p.getCost(2) /* r */) { 9153 p.setCost(2 /* r */, (char)(c)); 9154 p.writePacked(0, 0xFFFF00FF, 0x1200); // p.r = 18 9155 closure_r(p, c); 9156 } 9157 if ( // r: SYSCALL(INT_LOAD(riv,riv),any) 9158 lchild.getOpcode() == INT_LOAD_opcode 9159 ) { 9160 c = STATE(lchild.getChild1()).getCost(7 /* riv */) + STATE(lchild.getChild2()).getCost(7 /* riv */) + STATE(rchild).getCost(9 /* any */) + 11; 9161 if(BURS.DEBUG) trace(p, 413, c + 0, p.getCost(2) /* r */); 9162 if (c < p.getCost(2) /* r */) { 9163 p.setCost(2 /* r */, (char)(c)); 9164 p.writePacked(0, 0xFFFF00FF, 0x1300); // p.r = 19 9165 closure_r(p, c); 9166 } 9167 } 9168 if ( // r: SYSCALL(INT_CONSTANT,any) 9169 lchild.getOpcode() == INT_CONSTANT_opcode 9170 ) { 9171 c = STATE(rchild).getCost(9 /* any */) + 23; 9172 if(BURS.DEBUG) trace(p, 410, c + 0, p.getCost(2) /* r */); 9173 if (c < p.getCost(2) /* r */) { 9174 p.setCost(2 /* r */, (char)(c)); 9175 p.writePacked(0, 0xFFFF00FF, 0x1400); // p.r = 20 9176 closure_r(p, c); 9177 } 9178 } 9179 } 9180 9181 /** 9182 * Labels YIELDPOINT_PROLOGUE tree node 9183 * @param p node to label 9184 */ 9185 private static void label_YIELDPOINT_PROLOGUE(AbstractBURS_TreeNode p) { 9186 p.initCost(); 9187 // stm: YIELDPOINT_PROLOGUE 9188 if(BURS.DEBUG) trace(p, 28, 10 + 0, p.getCost(1) /* stm */); 9189 if (10 < p.getCost(1) /* stm */) { 9190 p.setCost(1 /* stm */, (char)(10)); 9191 p.writePacked(0, 0xFFFFFF00, 0x5); // p.stm = 5 9192 } 9193 } 9194 9195 /** 9196 * Labels YIELDPOINT_EPILOGUE tree node 9197 * @param p node to label 9198 */ 9199 private static void label_YIELDPOINT_EPILOGUE(AbstractBURS_TreeNode p) { 9200 p.initCost(); 9201 // stm: YIELDPOINT_EPILOGUE 9202 if(BURS.DEBUG) trace(p, 29, 10 + 0, p.getCost(1) /* stm */); 9203 if (10 < p.getCost(1) /* stm */) { 9204 p.setCost(1 /* stm */, (char)(10)); 9205 p.writePacked(0, 0xFFFFFF00, 0x6); // p.stm = 6 9206 } 9207 } 9208 9209 /** 9210 * Labels YIELDPOINT_BACKEDGE tree node 9211 * @param p node to label 9212 */ 9213 private static void label_YIELDPOINT_BACKEDGE(AbstractBURS_TreeNode p) { 9214 p.initCost(); 9215 // stm: YIELDPOINT_BACKEDGE 9216 if(BURS.DEBUG) trace(p, 30, 10 + 0, p.getCost(1) /* stm */); 9217 if (10 < p.getCost(1) /* stm */) { 9218 p.setCost(1 /* stm */, (char)(10)); 9219 p.writePacked(0, 0xFFFFFF00, 0x7); // p.stm = 7 9220 } 9221 } 9222 9223 /** 9224 * Labels YIELDPOINT_OSR tree node 9225 * @param p node to label 9226 */ 9227 private static void label_YIELDPOINT_OSR(AbstractBURS_TreeNode p) { 9228 p.initCost(); 9229 AbstractBURS_TreeNode lchild, rchild; 9230 lchild = p.getChild1(); 9231 rchild = p.getChild2(); 9232 label(lchild); 9233 label(rchild); 9234 int c; 9235 // stm: YIELDPOINT_OSR(any,any) 9236 c = STATE(lchild).getCost(9 /* any */) + STATE(rchild).getCost(9 /* any */) + 10; 9237 if(BURS.DEBUG) trace(p, 57, c + 0, p.getCost(1) /* stm */); 9238 if (c < p.getCost(1) /* stm */) { 9239 p.setCost(1 /* stm */, (char)(c)); 9240 p.writePacked(0, 0xFFFFFF00, 0x30); // p.stm = 48 9241 } 9242 } 9243 9244 /** 9245 * Labels IR_PROLOGUE tree node 9246 * @param p node to label 9247 */ 9248 private static void label_IR_PROLOGUE(AbstractBURS_TreeNode p) { 9249 p.initCost(); 9250 // stm: IR_PROLOGUE 9251 if(BURS.DEBUG) trace(p, 35, 11 + 0, p.getCost(1) /* stm */); 9252 if (11 < p.getCost(1) /* stm */) { 9253 p.setCost(1 /* stm */, (char)(11)); 9254 p.writePacked(0, 0xFFFFFF00, 0xC); // p.stm = 12 9255 } 9256 } 9257 9258 /** 9259 * Labels RESOLVE tree node 9260 * @param p node to label 9261 */ 9262 private static void label_RESOLVE(AbstractBURS_TreeNode p) { 9263 p.initCost(); 9264 // stm: RESOLVE 9265 if(BURS.DEBUG) trace(p, 31, 10 + 0, p.getCost(1) /* stm */); 9266 if (10 < p.getCost(1) /* stm */) { 9267 p.setCost(1 /* stm */, (char)(10)); 9268 p.writePacked(0, 0xFFFFFF00, 0x9); // p.stm = 9 9269 } 9270 } 9271 9272 /** 9273 * Labels GET_TIME_BASE tree node 9274 * @param p node to label 9275 */ 9276 private static void label_GET_TIME_BASE(AbstractBURS_TreeNode p) { 9277 p.initCost(); 9278 // r: GET_TIME_BASE 9279 if(BURS.DEBUG) trace(p, 47, 15 + 0, p.getCost(2) /* r */); 9280 if (15 < p.getCost(2) /* r */) { 9281 p.setCost(2 /* r */, (char)(15)); 9282 p.writePacked(0, 0xFFFF00FF, 0x1500); // p.r = 21 9283 closure_r(p, 15); 9284 } 9285 } 9286 9287 /** 9288 * Labels TRAP_IF tree node 9289 * @param p node to label 9290 */ 9291 private static void label_TRAP_IF(AbstractBURS_TreeNode p) { 9292 p.initCost(); 9293 AbstractBURS_TreeNode lchild, rchild; 9294 lchild = p.getChild1(); 9295 rchild = p.getChild2(); 9296 label(lchild); 9297 label(rchild); 9298 int c; 9299 if ( // stm: TRAP_IF(r,INT_CONSTANT) 9300 rchild.getOpcode() == INT_CONSTANT_opcode 9301 ) { 9302 c = STATE(lchild).getCost(2 /* r */) + 10; 9303 if(BURS.DEBUG) trace(p, 209, c + 0, p.getCost(1) /* stm */); 9304 if (c < p.getCost(1) /* stm */) { 9305 p.setCost(1 /* stm */, (char)(c)); 9306 p.writePacked(0, 0xFFFFFF00, 0x10); // p.stm = 16 9307 } 9308 } 9309 if ( // stm: TRAP_IF(r,LONG_CONSTANT) 9310 rchild.getOpcode() == LONG_CONSTANT_opcode 9311 ) { 9312 c = STATE(lchild).getCost(2 /* r */) + 10; 9313 if(BURS.DEBUG) trace(p, 210, c + 0, p.getCost(1) /* stm */); 9314 if (c < p.getCost(1) /* stm */) { 9315 p.setCost(1 /* stm */, (char)(c)); 9316 p.writePacked(0, 0xFFFFFF00, 0x11); // p.stm = 17 9317 } 9318 } 9319 // stm: TRAP_IF(r,r) 9320 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 9321 if(BURS.DEBUG) trace(p, 51, c + 0, p.getCost(1) /* stm */); 9322 if (c < p.getCost(1) /* stm */) { 9323 p.setCost(1 /* stm */, (char)(c)); 9324 p.writePacked(0, 0xFFFFFF00, 0x12); // p.stm = 18 9325 } 9326 // stm: TRAP_IF(load32,riv) 9327 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild).getCost(7 /* riv */) + 15; 9328 if(BURS.DEBUG) trace(p, 52, c + 0, p.getCost(1) /* stm */); 9329 if (c < p.getCost(1) /* stm */) { 9330 p.setCost(1 /* stm */, (char)(c)); 9331 p.writePacked(0, 0xFFFFFF00, 0x13); // p.stm = 19 9332 } 9333 // stm: TRAP_IF(riv,load32) 9334 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild).getCost(10 /* load32 */) + 15; 9335 if(BURS.DEBUG) trace(p, 53, c + 0, p.getCost(1) /* stm */); 9336 if (c < p.getCost(1) /* stm */) { 9337 p.setCost(1 /* stm */, (char)(c)); 9338 p.writePacked(0, 0xFFFFFF00, 0x14); // p.stm = 20 9339 } 9340 } 9341 9342 /** 9343 * Labels TRAP tree node 9344 * @param p node to label 9345 */ 9346 private static void label_TRAP(AbstractBURS_TreeNode p) { 9347 p.initCost(); 9348 // stm: TRAP 9349 if(BURS.DEBUG) trace(p, 38, 10 + 0, p.getCost(1) /* stm */); 9350 if (10 < p.getCost(1) /* stm */) { 9351 p.setCost(1 /* stm */, (char)(10)); 9352 p.writePacked(0, 0xFFFFFF00, 0xF); // p.stm = 15 9353 } 9354 } 9355 9356 /** 9357 * Labels FLOAT_AS_INT_BITS tree node 9358 * @param p node to label 9359 */ 9360 private static void label_FLOAT_AS_INT_BITS(AbstractBURS_TreeNode p) { 9361 p.initCost(); 9362 AbstractBURS_TreeNode lchild; 9363 lchild = p.getChild1(); 9364 label(lchild); 9365 int c; 9366 // r: FLOAT_AS_INT_BITS(r) 9367 c = STATE(lchild).getCost(2 /* r */) + 13; 9368 if(BURS.DEBUG) trace(p, 315, c + 0, p.getCost(2) /* r */); 9369 if (c < p.getCost(2) /* r */) { 9370 p.setCost(2 /* r */, (char)(c)); 9371 p.writePacked(0, 0xFFFF00FF, 0xD200); // p.r = 210 9372 closure_r(p, c); 9373 } 9374 // load32: FLOAT_AS_INT_BITS(float_load) 9375 c = STATE(lchild).getCost(25 /* float_load */) + 0; 9376 if(BURS.DEBUG) trace(p, 316, c + 0, p.getCost(10) /* load32 */); 9377 if (c < p.getCost(10) /* load32 */) { 9378 p.setCost(10 /* load32 */, (char)(c)); 9379 p.writePacked(1, 0xFFFFFF1F, 0xE0); // p.load32 = 7 9380 closure_load32(p, c); 9381 } 9382 } 9383 9384 /** 9385 * Labels INT_BITS_AS_FLOAT tree node 9386 * @param p node to label 9387 */ 9388 private static void label_INT_BITS_AS_FLOAT(AbstractBURS_TreeNode p) { 9389 p.initCost(); 9390 AbstractBURS_TreeNode lchild; 9391 lchild = p.getChild1(); 9392 label(lchild); 9393 int c; 9394 // r: INT_BITS_AS_FLOAT(riv) 9395 c = STATE(lchild).getCost(7 /* riv */) + 13; 9396 if(BURS.DEBUG) trace(p, 319, c + 0, p.getCost(2) /* r */); 9397 if (c < p.getCost(2) /* r */) { 9398 p.setCost(2 /* r */, (char)(c)); 9399 p.writePacked(0, 0xFFFF00FF, 0xD400); // p.r = 212 9400 closure_r(p, c); 9401 } 9402 // float_load: INT_BITS_AS_FLOAT(load32) 9403 c = STATE(lchild).getCost(10 /* load32 */) + 0; 9404 if(BURS.DEBUG) trace(p, 320, c + 0, p.getCost(25) /* float_load */); 9405 if (c < p.getCost(25) /* float_load */) { 9406 p.setCost(25 /* float_load */, (char)(c)); 9407 p.writePacked(2, 0xFFF1FFFF, 0x60000); // p.float_load = 3 9408 } 9409 } 9410 9411 /** 9412 * Labels DOUBLE_AS_LONG_BITS tree node 9413 * @param p node to label 9414 */ 9415 private static void label_DOUBLE_AS_LONG_BITS(AbstractBURS_TreeNode p) { 9416 p.initCost(); 9417 AbstractBURS_TreeNode lchild; 9418 lchild = p.getChild1(); 9419 label(lchild); 9420 int c; 9421 // r: DOUBLE_AS_LONG_BITS(r) 9422 c = STATE(lchild).getCost(2 /* r */) + 13; 9423 if(BURS.DEBUG) trace(p, 317, c + 0, p.getCost(2) /* r */); 9424 if (c < p.getCost(2) /* r */) { 9425 p.setCost(2 /* r */, (char)(c)); 9426 p.writePacked(0, 0xFFFF00FF, 0xD300); // p.r = 211 9427 closure_r(p, c); 9428 } 9429 // load64: DOUBLE_AS_LONG_BITS(double_load) 9430 c = STATE(lchild).getCost(26 /* double_load */) + 0; 9431 if(BURS.DEBUG) trace(p, 318, c + 0, p.getCost(22) /* load64 */); 9432 if (c < p.getCost(22) /* load64 */) { 9433 p.setCost(22 /* load64 */, (char)(c)); 9434 p.writePacked(2, 0xFFFFF1FF, 0x800); // p.load64 = 4 9435 } 9436 } 9437 9438 /** 9439 * Labels LONG_BITS_AS_DOUBLE tree node 9440 * @param p node to label 9441 */ 9442 private static void label_LONG_BITS_AS_DOUBLE(AbstractBURS_TreeNode p) { 9443 p.initCost(); 9444 AbstractBURS_TreeNode lchild; 9445 lchild = p.getChild1(); 9446 label(lchild); 9447 int c; 9448 // r: LONG_BITS_AS_DOUBLE(rlv) 9449 c = STATE(lchild).getCost(8 /* rlv */) + 13; 9450 if(BURS.DEBUG) trace(p, 321, c + 0, p.getCost(2) /* r */); 9451 if (c < p.getCost(2) /* r */) { 9452 p.setCost(2 /* r */, (char)(c)); 9453 p.writePacked(0, 0xFFFF00FF, 0xD500); // p.r = 213 9454 closure_r(p, c); 9455 } 9456 // double_load: LONG_BITS_AS_DOUBLE(load64) 9457 c = STATE(lchild).getCost(22 /* load64 */) + 0; 9458 if(BURS.DEBUG) trace(p, 322, c + 0, p.getCost(26) /* double_load */); 9459 if (c < p.getCost(26) /* double_load */) { 9460 p.setCost(26 /* double_load */, (char)(c)); 9461 p.writePacked(2, 0xFF8FFFFF, 0x400000); // p.double_load = 4 9462 } 9463 } 9464 9465 /** 9466 * Labels LOWTABLESWITCH tree node 9467 * @param p node to label 9468 */ 9469 private static void label_LOWTABLESWITCH(AbstractBURS_TreeNode p) { 9470 p.initCost(); 9471 AbstractBURS_TreeNode lchild; 9472 lchild = p.getChild1(); 9473 label(lchild); 9474 int c; 9475 // stm: LOWTABLESWITCH(r) 9476 c = STATE(lchild).getCost(2 /* r */) + 10; 9477 if(BURS.DEBUG) trace(p, 206, 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, 0x8); // p.stm = 8 9481 } 9482 } 9483 9484 /** 9485 * Labels ADDRESS_CONSTANT tree node 9486 * @param p node to label 9487 */ 9488 private static void label_ADDRESS_CONSTANT(AbstractBURS_TreeNode p) { 9489 p.initCost(); 9490 // any: ADDRESS_CONSTANT 9491 if(BURS.DEBUG) trace(p, 23, 0 + 0, p.getCost(9) /* any */); 9492 if (0 < p.getCost(9) /* any */) { 9493 p.setCost(9 /* any */, (char)(0)); 9494 p.writePacked(1, 0xFFFFFFE3, 0xC); // p.any = 3 9495 } 9496 } 9497 9498 /** 9499 * Labels INT_CONSTANT tree node 9500 * @param p node to label 9501 */ 9502 private static void label_INT_CONSTANT(AbstractBURS_TreeNode p) { 9503 p.initCost(); 9504 // riv: INT_CONSTANT 9505 if(BURS.DEBUG) trace(p, 20, 0 + 0, p.getCost(7) /* riv */); 9506 if (0 < p.getCost(7) /* riv */) { 9507 p.setCost(7 /* riv */, (char)(0)); 9508 p.writePacked(0, 0x9FFFFFFF, 0x40000000); // p.riv = 2 9509 closure_riv(p, 0); 9510 } 9511 } 9512 9513 /** 9514 * Labels LONG_CONSTANT tree node 9515 * @param p node to label 9516 */ 9517 private static void label_LONG_CONSTANT(AbstractBURS_TreeNode p) { 9518 p.initCost(); 9519 // rlv: LONG_CONSTANT 9520 if(BURS.DEBUG) trace(p, 21, 0 + 0, p.getCost(8) /* rlv */); 9521 if (0 < p.getCost(8) /* rlv */) { 9522 p.setCost(8 /* rlv */, (char)(0)); 9523 p.writePacked(1, 0xFFFFFFFC, 0x2); // p.rlv = 2 9524 } 9525 // any: LONG_CONSTANT 9526 if(BURS.DEBUG) trace(p, 24, 0 + 0, p.getCost(9) /* any */); 9527 if (0 < p.getCost(9) /* any */) { 9528 p.setCost(9 /* any */, (char)(0)); 9529 p.writePacked(1, 0xFFFFFFE3, 0x10); // p.any = 4 9530 } 9531 } 9532 9533 /** 9534 * Labels REGISTER tree node 9535 * @param p node to label 9536 */ 9537 private static void label_REGISTER(AbstractBURS_TreeNode p) { 9538 p.initCost(); 9539 // r: REGISTER 9540 if(BURS.DEBUG) trace(p, 19, 0 + 0, p.getCost(2) /* r */); 9541 if (0 < p.getCost(2) /* r */) { 9542 p.setCost(2 /* r */, (char)(0)); 9543 p.writePacked(0, 0xFFFF00FF, 0x100); // p.r = 1 9544 closure_r(p, 0); 9545 } 9546 } 9547 9548 /** 9549 * Labels OTHER_OPERAND tree node 9550 * @param p node to label 9551 */ 9552 private static void label_OTHER_OPERAND(AbstractBURS_TreeNode p) { 9553 p.initCost(); 9554 AbstractBURS_TreeNode lchild, rchild; 9555 lchild = p.getChild1(); 9556 rchild = p.getChild2(); 9557 label(lchild); 9558 label(rchild); 9559 int c; 9560 // any: OTHER_OPERAND(any,any) 9561 c = STATE(lchild).getCost(9 /* any */) + STATE(rchild).getCost(9 /* any */) + 0; 9562 if(BURS.DEBUG) trace(p, 50, c + 0, p.getCost(9) /* any */); 9563 if (c < p.getCost(9) /* any */) { 9564 p.setCost(9 /* any */, (char)(c)); 9565 p.writePacked(1, 0xFFFFFFE3, 0x14); // p.any = 5 9566 } 9567 } 9568 9569 /** 9570 * Labels NULL tree node 9571 * @param p node to label 9572 */ 9573 private static void label_NULL(AbstractBURS_TreeNode p) { 9574 p.initCost(); 9575 // any: NULL 9576 if(BURS.DEBUG) trace(p, 22, 0 + 0, p.getCost(9) /* any */); 9577 if (0 < p.getCost(9) /* any */) { 9578 p.setCost(9 /* any */, (char)(0)); 9579 p.writePacked(1, 0xFFFFFFE3, 0x4); // p.any = 1 9580 } 9581 } 9582 9583 /** 9584 * Labels BRANCH_TARGET tree node 9585 * @param p node to label 9586 */ 9587 private static void label_BRANCH_TARGET(AbstractBURS_TreeNode p) { 9588 p.initCost(); 9589 } 9590 9591 /** 9592 * Labels MATERIALIZE_FP_CONSTANT tree node 9593 * @param p node to label 9594 */ 9595 private static void label_MATERIALIZE_FP_CONSTANT(AbstractBURS_TreeNode p) { 9596 p.initCost(); 9597 AbstractBURS_TreeNode lchild; 9598 lchild = p.getChild1(); 9599 label(lchild); 9600 int c; 9601 // r: MATERIALIZE_FP_CONSTANT(any) 9602 c = STATE(lchild).getCost(9 /* any */) + 15; 9603 if(BURS.DEBUG) trace(p, 323, c + 0, p.getCost(2) /* r */); 9604 if (c < p.getCost(2) /* r */) { 9605 p.setCost(2 /* r */, (char)(c)); 9606 p.writePacked(0, 0xFFFF00FF, 0xD600); // p.r = 214 9607 closure_r(p, c); 9608 } 9609 // float_load: MATERIALIZE_FP_CONSTANT(any) 9610 c = STATE(lchild).getCost(9 /* any */) + (Binary.getResult(P(p)).isFloat() ? 0 : INFINITE); 9611 if(BURS.DEBUG) trace(p, 324, c + 0, p.getCost(25) /* float_load */); 9612 if (c < p.getCost(25) /* float_load */) { 9613 p.setCost(25 /* float_load */, (char)(c)); 9614 p.writePacked(2, 0xFFF1FFFF, 0x80000); // p.float_load = 4 9615 } 9616 // double_load: MATERIALIZE_FP_CONSTANT(any) 9617 c = STATE(lchild).getCost(9 /* any */) + (Binary.getResult(P(p)).isDouble() ? 0 : INFINITE); 9618 if(BURS.DEBUG) trace(p, 325, c + 0, p.getCost(26) /* double_load */); 9619 if (c < p.getCost(26) /* double_load */) { 9620 p.setCost(26 /* double_load */, (char)(c)); 9621 p.writePacked(2, 0xFF8FFFFF, 0x500000); // p.double_load = 5 9622 } 9623 } 9624 9625 /** 9626 * Labels CLEAR_FLOATING_POINT_STATE tree node 9627 * @param p node to label 9628 */ 9629 private static void label_CLEAR_FLOATING_POINT_STATE(AbstractBURS_TreeNode p) { 9630 p.initCost(); 9631 // stm: CLEAR_FLOATING_POINT_STATE 9632 if(BURS.DEBUG) trace(p, 49, 0 + 0, p.getCost(1) /* stm */); 9633 if (0 < p.getCost(1) /* stm */) { 9634 p.setCost(1 /* stm */, (char)(0)); 9635 p.writePacked(0, 0xFFFFFF00, 0xB4); // p.stm = 180 9636 } 9637 } 9638 9639 /** 9640 * Labels PREFETCH tree node 9641 * @param p node to label 9642 */ 9643 private static void label_PREFETCH(AbstractBURS_TreeNode p) { 9644 p.initCost(); 9645 AbstractBURS_TreeNode lchild; 9646 lchild = p.getChild1(); 9647 label(lchild); 9648 int c; 9649 // stm: PREFETCH(r) 9650 c = STATE(lchild).getCost(2 /* r */) + 11; 9651 if(BURS.DEBUG) trace(p, 215, c + 0, p.getCost(1) /* stm */); 9652 if (c < p.getCost(1) /* stm */) { 9653 p.setCost(1 /* stm */, (char)(c)); 9654 p.writePacked(0, 0xFFFFFF00, 0x27); // p.stm = 39 9655 } 9656 } 9657 9658 /** 9659 * Labels PAUSE tree node 9660 * @param p node to label 9661 */ 9662 private static void label_PAUSE(AbstractBURS_TreeNode p) { 9663 p.initCost(); 9664 // stm: PAUSE 9665 if(BURS.DEBUG) trace(p, 43, 11 + 0, p.getCost(1) /* stm */); 9666 if (11 < p.getCost(1) /* stm */) { 9667 p.setCost(1 /* stm */, (char)(11)); 9668 p.writePacked(0, 0xFFFFFF00, 0x2B); // p.stm = 43 9669 } 9670 } 9671 9672 /** 9673 * Labels CMP_CMOV tree node 9674 * @param p node to label 9675 */ 9676 private static void label_CMP_CMOV(AbstractBURS_TreeNode p) { 9677 p.initCost(); 9678 AbstractBURS_TreeNode lchild, rchild; 9679 lchild = p.getChild1(); 9680 rchild = p.getChild2(); 9681 label(lchild); 9682 label(rchild); 9683 int c; 9684 if ( // r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 9685 rchild.getOpcode() == OTHER_OPERAND_opcode 9686 ) { 9687 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (13 + 30); 9688 if(BURS.DEBUG) trace(p, 363, c + 0, p.getCost(2) /* r */); 9689 if (c < p.getCost(2) /* r */) { 9690 p.setCost(2 /* r */, (char)(c)); 9691 p.writePacked(0, 0xFFFF00FF, 0x3100); // p.r = 49 9692 closure_r(p, c); 9693 } 9694 } 9695 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 9696 rchild.getOpcode() == OTHER_OPERAND_opcode && 9697 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9698 ) { 9699 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); 9700 if(BURS.DEBUG) trace(p, 466, c + 0, p.getCost(2) /* r */); 9701 if (c < p.getCost(2) /* r */) { 9702 p.setCost(2 /* r */, (char)(c)); 9703 p.writePacked(0, 0xFFFF00FF, 0x3200); // p.r = 50 9704 closure_r(p, c); 9705 } 9706 } 9707 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 9708 rchild.getOpcode() == OTHER_OPERAND_opcode && 9709 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 9710 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 9711 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 9712 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 9713 ) { 9714 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); 9715 if(BURS.DEBUG) trace(p, 245, c + 0, p.getCost(2) /* r */); 9716 if (c < p.getCost(2) /* r */) { 9717 p.setCost(2 /* r */, (char)(c)); 9718 p.writePacked(0, 0xFFFF00FF, 0x3300); // p.r = 51 9719 closure_r(p, c); 9720 } 9721 } 9722 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 9723 rchild.getOpcode() == OTHER_OPERAND_opcode && 9724 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 9725 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 9726 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 9727 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 9728 ) { 9729 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); 9730 if(BURS.DEBUG) trace(p, 246, c + 0, p.getCost(2) /* r */); 9731 if (c < p.getCost(2) /* r */) { 9732 p.setCost(2 /* r */, (char)(c)); 9733 p.writePacked(0, 0xFFFF00FF, 0x3400); // p.r = 52 9734 closure_r(p, c); 9735 } 9736 } 9737 if ( // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 9738 rchild.getOpcode() == OTHER_OPERAND_opcode && 9739 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 9740 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 9741 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 9742 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 9743 ) { 9744 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); 9745 if(BURS.DEBUG) trace(p, 247, c + 0, p.getCost(2) /* r */); 9746 if (c < p.getCost(2) /* r */) { 9747 p.setCost(2 /* r */, (char)(c)); 9748 p.writePacked(0, 0xFFFF00FF, 0x3500); // p.r = 53 9749 closure_r(p, c); 9750 } 9751 } 9752 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 9753 rchild.getOpcode() == OTHER_OPERAND_opcode && 9754 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 9755 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 9756 rchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 9757 rchild.getChild2().getChild2().getOpcode() == INT_CONSTANT_opcode 9758 ) { 9759 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); 9760 if(BURS.DEBUG) trace(p, 248, c + 0, p.getCost(2) /* r */); 9761 if (c < p.getCost(2) /* r */) { 9762 p.setCost(2 /* r */, (char)(c)); 9763 p.writePacked(0, 0xFFFF00FF, 0x3600); // p.r = 54 9764 closure_r(p, c); 9765 } 9766 } 9767 if ( // r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 9768 rchild.getOpcode() == OTHER_OPERAND_opcode && 9769 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9770 ) { 9771 c = STATE(lchild).getCost(20 /* load8 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + FITS(CondMove.getVal2(P(p)), 8, (15 + 30)); 9772 if(BURS.DEBUG) trace(p, 467, c + 0, p.getCost(2) /* r */); 9773 if (c < p.getCost(2) /* r */) { 9774 p.setCost(2 /* r */, (char)(c)); 9775 p.writePacked(0, 0xFFFF00FF, 0x3700); // p.r = 55 9776 closure_r(p, c); 9777 } 9778 } 9779 if ( // r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 9780 rchild.getOpcode() == OTHER_OPERAND_opcode 9781 ) { 9782 c = STATE(lchild).getCost(11 /* uload8 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 9783 if(BURS.DEBUG) trace(p, 364, c + 0, p.getCost(2) /* r */); 9784 if (c < p.getCost(2) /* r */) { 9785 p.setCost(2 /* r */, (char)(c)); 9786 p.writePacked(0, 0xFFFF00FF, 0x3800); // p.r = 56 9787 closure_r(p, c); 9788 } 9789 } 9790 if ( // r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 9791 rchild.getOpcode() == OTHER_OPERAND_opcode 9792 ) { 9793 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(11 /* uload8 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 9794 if(BURS.DEBUG) trace(p, 365, c + 0, p.getCost(2) /* r */); 9795 if (c < p.getCost(2) /* r */) { 9796 p.setCost(2 /* r */, (char)(c)); 9797 p.writePacked(0, 0xFFFF00FF, 0x3900); // p.r = 57 9798 closure_r(p, c); 9799 } 9800 } 9801 if ( // r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 9802 rchild.getOpcode() == OTHER_OPERAND_opcode && 9803 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9804 ) { 9805 c = STATE(lchild).getCost(21 /* sload16 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + FITS(CondMove.getVal2(P(p)), 8, (15 + 30)); 9806 if(BURS.DEBUG) trace(p, 468, c + 0, p.getCost(2) /* r */); 9807 if (c < p.getCost(2) /* r */) { 9808 p.setCost(2 /* r */, (char)(c)); 9809 p.writePacked(0, 0xFFFF00FF, 0x3A00); // p.r = 58 9810 closure_r(p, c); 9811 } 9812 } 9813 if ( // r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 9814 rchild.getOpcode() == OTHER_OPERAND_opcode 9815 ) { 9816 c = STATE(lchild).getCost(10 /* load32 */) + STATE(rchild.getChild1()).getCost(7 /* riv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 9817 if(BURS.DEBUG) trace(p, 366, c + 0, p.getCost(2) /* r */); 9818 if (c < p.getCost(2) /* r */) { 9819 p.setCost(2 /* r */, (char)(c)); 9820 p.writePacked(0, 0xFFFF00FF, 0x3B00); // p.r = 59 9821 closure_r(p, c); 9822 } 9823 } 9824 if ( // r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 9825 rchild.getOpcode() == OTHER_OPERAND_opcode 9826 ) { 9827 c = STATE(lchild).getCost(7 /* riv */) + STATE(rchild.getChild1()).getCost(10 /* load32 */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (15 + 30); 9828 if(BURS.DEBUG) trace(p, 367, c + 0, p.getCost(2) /* r */); 9829 if (c < p.getCost(2) /* r */) { 9830 p.setCost(2 /* r */, (char)(c)); 9831 p.writePacked(0, 0xFFFF00FF, 0x3C00); // p.r = 60 9832 closure_r(p, c); 9833 } 9834 } 9835 if ( // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 9836 rchild.getOpcode() == OTHER_OPERAND_opcode && 9837 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9838 ) { 9839 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); 9840 if(BURS.DEBUG) trace(p, 469, c + 0, p.getCost(2) /* r */); 9841 if (c < p.getCost(2) /* r */) { 9842 p.setCost(2 /* r */, (char)(c)); 9843 p.writePacked(0, 0xFFFF00FF, 0x3D00); // p.r = 61 9844 closure_r(p, c); 9845 } 9846 } 9847 if ( // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 9848 rchild.getOpcode() == OTHER_OPERAND_opcode && 9849 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9850 ) { 9851 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); 9852 if(BURS.DEBUG) trace(p, 470, c + 0, p.getCost(2) /* r */); 9853 if (c < p.getCost(2) /* r */) { 9854 p.setCost(2 /* r */, (char)(c)); 9855 p.writePacked(0, 0xFFFF00FF, 0x3E00); // p.r = 62 9856 closure_r(p, c); 9857 } 9858 } 9859 if ( // r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 9860 rchild.getOpcode() == OTHER_OPERAND_opcode && 9861 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9862 ) { 9863 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); 9864 if(BURS.DEBUG) trace(p, 471, c + 0, p.getCost(2) /* r */); 9865 if (c < p.getCost(2) /* r */) { 9866 p.setCost(2 /* r */, (char)(c)); 9867 p.writePacked(0, 0xFFFF00FF, 0x3F00); // p.r = 63 9868 closure_r(p, c); 9869 } 9870 } 9871 if ( // r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 9872 rchild.getOpcode() == OTHER_OPERAND_opcode && 9873 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9874 ) { 9875 c = STATE(lchild).getCost(4 /* cz */) + STATE(rchild.getChild2()).getCost(9 /* any */) + isZERO(VRL(p), 30); 9876 if(BURS.DEBUG) trace(p, 472, c + 0, p.getCost(2) /* r */); 9877 if (c < p.getCost(2) /* r */) { 9878 p.setCost(2 /* r */, (char)(c)); 9879 p.writePacked(0, 0xFFFF00FF, 0x4000); // p.r = 64 9880 closure_r(p, c); 9881 } 9882 } 9883 if ( // r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 9884 rchild.getOpcode() == OTHER_OPERAND_opcode && 9885 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 9886 ) { 9887 c = STATE(lchild).getCost(6 /* szp */) + STATE(rchild.getChild2()).getCost(9 /* any */) + isZERO(VRL(p), 30); 9888 if(BURS.DEBUG) trace(p, 473, c + 0, p.getCost(2) /* r */); 9889 if (c < p.getCost(2) /* r */) { 9890 p.setCost(2 /* r */, (char)(c)); 9891 p.writePacked(0, 0xFFFF00FF, 0x4100); // p.r = 65 9892 closure_r(p, c); 9893 } 9894 } 9895 } 9896 9897 /** 9898 * Labels FCMP_CMOV tree node 9899 * @param p node to label 9900 */ 9901 private static void label_FCMP_CMOV(AbstractBURS_TreeNode p) { 9902 p.initCost(); 9903 AbstractBURS_TreeNode lchild, rchild; 9904 lchild = p.getChild1(); 9905 rchild = p.getChild2(); 9906 label(lchild); 9907 label(rchild); 9908 int c; 9909 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 9910 rchild.getOpcode() == OTHER_OPERAND_opcode 9911 ) { 9912 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13*2; 9913 if(BURS.DEBUG) trace(p, 393, c + 0, p.getCost(2) /* r */); 9914 if (c < p.getCost(2) /* r */) { 9915 p.setCost(2 /* r */, (char)(c)); 9916 p.writePacked(0, 0xFFFF00FF, 0xD700); // p.r = 215 9917 closure_r(p, c); 9918 } 9919 } 9920 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 9921 rchild.getOpcode() == OTHER_OPERAND_opcode 9922 ) { 9923 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(25 /* float_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 9924 if(BURS.DEBUG) trace(p, 394, c + 0, p.getCost(2) /* r */); 9925 if (c < p.getCost(2) /* r */) { 9926 p.setCost(2 /* r */, (char)(c)); 9927 p.writePacked(0, 0xFFFF00FF, 0xD800); // p.r = 216 9928 closure_r(p, c); 9929 } 9930 } 9931 if ( // r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 9932 rchild.getOpcode() == OTHER_OPERAND_opcode 9933 ) { 9934 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(26 /* double_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 9935 if(BURS.DEBUG) trace(p, 395, c + 0, p.getCost(2) /* r */); 9936 if (c < p.getCost(2) /* r */) { 9937 p.setCost(2 /* r */, (char)(c)); 9938 p.writePacked(0, 0xFFFF00FF, 0xD900); // p.r = 217 9939 closure_r(p, c); 9940 } 9941 } 9942 if ( // r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 9943 rchild.getOpcode() == OTHER_OPERAND_opcode 9944 ) { 9945 c = STATE(lchild).getCost(25 /* float_load */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 9946 if(BURS.DEBUG) trace(p, 396, c + 0, p.getCost(2) /* r */); 9947 if (c < p.getCost(2) /* r */) { 9948 p.setCost(2 /* r */, (char)(c)); 9949 p.writePacked(0, 0xFFFF00FF, 0xDA00); // p.r = 218 9950 closure_r(p, c); 9951 } 9952 } 9953 if ( // r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 9954 rchild.getOpcode() == OTHER_OPERAND_opcode 9955 ) { 9956 c = STATE(lchild).getCost(26 /* double_load */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13+15; 9957 if(BURS.DEBUG) trace(p, 397, c + 0, p.getCost(2) /* r */); 9958 if (c < p.getCost(2) /* r */) { 9959 p.setCost(2 /* r */, (char)(c)); 9960 p.writePacked(0, 0xFFFF00FF, 0xDB00); // p.r = 219 9961 closure_r(p, c); 9962 } 9963 } 9964 } 9965 9966 /** 9967 * Labels LCMP_CMOV tree node 9968 * @param p node to label 9969 */ 9970 private static void label_LCMP_CMOV(AbstractBURS_TreeNode p) { 9971 p.initCost(); 9972 AbstractBURS_TreeNode lchild, rchild; 9973 lchild = p.getChild1(); 9974 rchild = p.getChild2(); 9975 label(lchild); 9976 label(rchild); 9977 int c; 9978 if ( // r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 9979 rchild.getOpcode() == OTHER_OPERAND_opcode 9980 ) { 9981 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(8 /* rlv */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (8*13 + 30); 9982 if(BURS.DEBUG) trace(p, 373, c + 0, p.getCost(2) /* r */); 9983 if (c < p.getCost(2) /* r */) { 9984 p.setCost(2 /* r */, (char)(c)); 9985 p.writePacked(0, 0xFFFF00FF, 0x6900); // p.r = 105 9986 closure_r(p, c); 9987 } 9988 } 9989 } 9990 9991 /** 9992 * Labels FCMP_FCMOV tree node 9993 * @param p node to label 9994 */ 9995 private static void label_FCMP_FCMOV(AbstractBURS_TreeNode p) { 9996 p.initCost(); 9997 AbstractBURS_TreeNode lchild, rchild; 9998 lchild = p.getChild1(); 9999 rchild = p.getChild2(); 10000 label(lchild); 10001 label(rchild); 10002 int c; 10003 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 10004 rchild.getOpcode() == OTHER_OPERAND_opcode 10005 ) { 10006 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(9 /* any */) + 13*4; 10007 if(BURS.DEBUG) trace(p, 398, c + 0, p.getCost(2) /* r */); 10008 if (c < p.getCost(2) /* r */) { 10009 p.setCost(2 /* r */, (char)(c)); 10010 p.writePacked(0, 0xFFFF00FF, 0xDC00); // p.r = 220 10011 closure_r(p, c); 10012 } 10013 } 10014 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 10015 rchild.getOpcode() == OTHER_OPERAND_opcode && 10016 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10017 ) { 10018 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild2()).getCost(25 /* float_load */) + 15+13*3; 10019 if(BURS.DEBUG) trace(p, 422, c + 0, p.getCost(2) /* r */); 10020 if (c < p.getCost(2) /* r */) { 10021 p.setCost(2 /* r */, (char)(c)); 10022 p.writePacked(0, 0xFFFF00FF, 0xDD00); // p.r = 221 10023 closure_r(p, c); 10024 } 10025 } 10026 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 10027 rchild.getOpcode() == OTHER_OPERAND_opcode && 10028 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10029 ) { 10030 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 /* double_load */) + 15+13*3; 10031 if(BURS.DEBUG) trace(p, 423, c + 0, p.getCost(2) /* r */); 10032 if (c < p.getCost(2) /* r */) { 10033 p.setCost(2 /* r */, (char)(c)); 10034 p.writePacked(0, 0xFFFF00FF, 0xDE00); // p.r = 222 10035 closure_r(p, c); 10036 } 10037 } 10038 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 10039 rchild.getOpcode() == OTHER_OPERAND_opcode && 10040 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10041 ) { 10042 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(25 /* float_load */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + 15+13*3; 10043 if(BURS.DEBUG) trace(p, 424, c + 0, p.getCost(2) /* r */); 10044 if (c < p.getCost(2) /* r */) { 10045 p.setCost(2 /* r */, (char)(c)); 10046 p.writePacked(0, 0xFFFF00FF, 0xDF00); // p.r = 223 10047 closure_r(p, c); 10048 } 10049 } 10050 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 10051 rchild.getOpcode() == OTHER_OPERAND_opcode && 10052 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode 10053 ) { 10054 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2().getChild1()).getCost(26 /* double_load */) + STATE(rchild.getChild2().getChild2()).getCost(2 /* r */) + 15+13*3; 10055 if(BURS.DEBUG) trace(p, 425, c + 0, p.getCost(2) /* r */); 10056 if (c < p.getCost(2) /* r */) { 10057 p.setCost(2 /* r */, (char)(c)); 10058 p.writePacked(0, 0xFFFF00FF, 0xE000); // p.r = 224 10059 closure_r(p, c); 10060 } 10061 } 10062 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 10063 rchild.getOpcode() == OTHER_OPERAND_opcode 10064 ) { 10065 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(25 /* float_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (SSE2_CMP_OP(CondMove.getCond(P(p)), true) != null ? 15+13*3 : INFINITE); 10066 if(BURS.DEBUG) trace(p, 399, c + 0, p.getCost(2) /* r */); 10067 if (c < p.getCost(2) /* r */) { 10068 p.setCost(2 /* r */, (char)(c)); 10069 p.writePacked(0, 0xFFFF00FF, 0xE100); // p.r = 225 10070 closure_r(p, c); 10071 } 10072 } 10073 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 10074 rchild.getOpcode() == OTHER_OPERAND_opcode 10075 ) { 10076 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(26 /* double_load */) + STATE(rchild.getChild2()).getCost(9 /* any */) + (SSE2_CMP_OP(CondMove.getCond(P(p)), false) != null ? 15+13*3 : INFINITE); 10077 if(BURS.DEBUG) trace(p, 400, c + 0, p.getCost(2) /* r */); 10078 if (c < p.getCost(2) /* r */) { 10079 p.setCost(2 /* r */, (char)(c)); 10080 p.writePacked(0, 0xFFFF00FF, 0xE200); // p.r = 226 10081 closure_r(p, c); 10082 } 10083 } 10084 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 10085 rchild.getOpcode() == OTHER_OPERAND_opcode && 10086 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10087 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 10088 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10089 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 10090 ) { 10091 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 ); 10092 if(BURS.DEBUG) trace(p, 543, c + 0, p.getCost(2) /* r */); 10093 if (c < p.getCost(2) /* r */) { 10094 p.setCost(2 /* r */, (char)(c)); 10095 p.writePacked(0, 0xFFFF00FF, 0xE300); // p.r = 227 10096 closure_r(p, c); 10097 } 10098 } 10099 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 10100 rchild.getOpcode() == OTHER_OPERAND_opcode && 10101 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10102 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 10103 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10104 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 10105 ) { 10106 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 ); 10107 if(BURS.DEBUG) trace(p, 544, c + 0, p.getCost(2) /* r */); 10108 if (c < p.getCost(2) /* r */) { 10109 p.setCost(2 /* r */, (char)(c)); 10110 p.writePacked(0, 0xFFFF00FF, 0xE400); // p.r = 228 10111 closure_r(p, c); 10112 } 10113 } 10114 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 10115 rchild.getOpcode() == OTHER_OPERAND_opcode && 10116 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10117 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 10118 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10119 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 10120 ) { 10121 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 ); 10122 if(BURS.DEBUG) trace(p, 547, c + 0, p.getCost(2) /* r */); 10123 if (c < p.getCost(2) /* r */) { 10124 p.setCost(2 /* r */, (char)(c)); 10125 p.writePacked(0, 0xFFFF00FF, 0xE500); // p.r = 229 10126 closure_r(p, c); 10127 } 10128 } 10129 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 10130 rchild.getOpcode() == OTHER_OPERAND_opcode && 10131 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10132 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 10133 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10134 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 10135 ) { 10136 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 ); 10137 if(BURS.DEBUG) trace(p, 548, c + 0, p.getCost(2) /* r */); 10138 if (c < p.getCost(2) /* r */) { 10139 p.setCost(2 /* r */, (char)(c)); 10140 p.writePacked(0, 0xFFFF00FF, 0xE600); // p.r = 230 10141 closure_r(p, c); 10142 } 10143 } 10144 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 10145 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10146 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 10147 rchild.getOpcode() == OTHER_OPERAND_opcode && 10148 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10149 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 10150 ) { 10151 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 ); 10152 if(BURS.DEBUG) trace(p, 551, c + 0, p.getCost(2) /* r */); 10153 if (c < p.getCost(2) /* r */) { 10154 p.setCost(2 /* r */, (char)(c)); 10155 p.writePacked(0, 0xFFFF00FF, 0xE700); // p.r = 231 10156 closure_r(p, c); 10157 } 10158 } 10159 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 10160 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10161 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 10162 rchild.getOpcode() == OTHER_OPERAND_opcode && 10163 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10164 rchild.getChild2().getChild1().getOpcode() == FLOAT_NEG_opcode 10165 ) { 10166 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 ); 10167 if(BURS.DEBUG) trace(p, 552, c + 0, p.getCost(2) /* r */); 10168 if (c < p.getCost(2) /* r */) { 10169 p.setCost(2 /* r */, (char)(c)); 10170 p.writePacked(0, 0xFFFF00FF, 0xE800); // p.r = 232 10171 closure_r(p, c); 10172 } 10173 } 10174 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 10175 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10176 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 10177 rchild.getOpcode() == OTHER_OPERAND_opcode && 10178 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10179 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 10180 ) { 10181 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 ); 10182 if(BURS.DEBUG) trace(p, 555, c + 0, p.getCost(2) /* r */); 10183 if (c < p.getCost(2) /* r */) { 10184 p.setCost(2 /* r */, (char)(c)); 10185 p.writePacked(0, 0xFFFF00FF, 0xE900); // p.r = 233 10186 closure_r(p, c); 10187 } 10188 } 10189 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 10190 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10191 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 10192 rchild.getOpcode() == OTHER_OPERAND_opcode && 10193 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10194 rchild.getChild2().getChild2().getOpcode() == FLOAT_NEG_opcode 10195 ) { 10196 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 ); 10197 if(BURS.DEBUG) trace(p, 556, c + 0, p.getCost(2) /* r */); 10198 if (c < p.getCost(2) /* r */) { 10199 p.setCost(2 /* r */, (char)(c)); 10200 p.writePacked(0, 0xFFFF00FF, 0xEA00); // p.r = 234 10201 closure_r(p, c); 10202 } 10203 } 10204 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 10205 rchild.getOpcode() == OTHER_OPERAND_opcode && 10206 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10207 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 10208 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10209 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 10210 ) { 10211 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 ); 10212 if(BURS.DEBUG) trace(p, 545, c + 0, p.getCost(2) /* r */); 10213 if (c < p.getCost(2) /* r */) { 10214 p.setCost(2 /* r */, (char)(c)); 10215 p.writePacked(0, 0xFFFF00FF, 0xEB00); // p.r = 235 10216 closure_r(p, c); 10217 } 10218 } 10219 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 10220 rchild.getOpcode() == OTHER_OPERAND_opcode && 10221 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10222 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 10223 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10224 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 10225 ) { 10226 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 ); 10227 if(BURS.DEBUG) trace(p, 546, c + 0, p.getCost(2) /* r */); 10228 if (c < p.getCost(2) /* r */) { 10229 p.setCost(2 /* r */, (char)(c)); 10230 p.writePacked(0, 0xFFFF00FF, 0xEC00); // p.r = 236 10231 closure_r(p, c); 10232 } 10233 } 10234 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 10235 rchild.getOpcode() == OTHER_OPERAND_opcode && 10236 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10237 rchild.getChild1().getChild1().getOpcode() == INT_CONSTANT_opcode && 10238 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10239 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 10240 ) { 10241 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 ); 10242 if(BURS.DEBUG) trace(p, 549, c + 0, p.getCost(2) /* r */); 10243 if (c < p.getCost(2) /* r */) { 10244 p.setCost(2 /* r */, (char)(c)); 10245 p.writePacked(0, 0xFFFF00FF, 0xED00); // p.r = 237 10246 closure_r(p, c); 10247 } 10248 } 10249 if ( // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 10250 rchild.getOpcode() == OTHER_OPERAND_opcode && 10251 rchild.getChild1().getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10252 rchild.getChild1().getChild1().getOpcode() == LONG_CONSTANT_opcode && 10253 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10254 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 10255 ) { 10256 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 ); 10257 if(BURS.DEBUG) trace(p, 550, c + 0, p.getCost(2) /* r */); 10258 if (c < p.getCost(2) /* r */) { 10259 p.setCost(2 /* r */, (char)(c)); 10260 p.writePacked(0, 0xFFFF00FF, 0xEE00); // p.r = 238 10261 closure_r(p, c); 10262 } 10263 } 10264 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 10265 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10266 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 10267 rchild.getOpcode() == OTHER_OPERAND_opcode && 10268 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10269 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 10270 ) { 10271 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 ); 10272 if(BURS.DEBUG) trace(p, 553, c + 0, p.getCost(2) /* r */); 10273 if (c < p.getCost(2) /* r */) { 10274 p.setCost(2 /* r */, (char)(c)); 10275 p.writePacked(0, 0xFFFF00FF, 0xEF00); // p.r = 239 10276 closure_r(p, c); 10277 } 10278 } 10279 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 10280 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10281 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 10282 rchild.getOpcode() == OTHER_OPERAND_opcode && 10283 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10284 rchild.getChild2().getChild1().getOpcode() == DOUBLE_NEG_opcode 10285 ) { 10286 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 ); 10287 if(BURS.DEBUG) trace(p, 554, c + 0, p.getCost(2) /* r */); 10288 if (c < p.getCost(2) /* r */) { 10289 p.setCost(2 /* r */, (char)(c)); 10290 p.writePacked(0, 0xFFFF00FF, 0xF000); // p.r = 240 10291 closure_r(p, c); 10292 } 10293 } 10294 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 10295 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10296 lchild.getChild1().getOpcode() == INT_CONSTANT_opcode && 10297 rchild.getOpcode() == OTHER_OPERAND_opcode && 10298 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10299 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 10300 ) { 10301 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 ); 10302 if(BURS.DEBUG) trace(p, 557, c + 0, p.getCost(2) /* r */); 10303 if (c < p.getCost(2) /* r */) { 10304 p.setCost(2 /* r */, (char)(c)); 10305 p.writePacked(0, 0xFFFF00FF, 0xF100); // p.r = 241 10306 closure_r(p, c); 10307 } 10308 } 10309 if ( // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 10310 lchild.getOpcode() == MATERIALIZE_FP_CONSTANT_opcode && 10311 lchild.getChild1().getOpcode() == LONG_CONSTANT_opcode && 10312 rchild.getOpcode() == OTHER_OPERAND_opcode && 10313 rchild.getChild2().getOpcode() == OTHER_OPERAND_opcode && 10314 rchild.getChild2().getChild2().getOpcode() == DOUBLE_NEG_opcode 10315 ) { 10316 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 ); 10317 if(BURS.DEBUG) trace(p, 558, c + 0, p.getCost(2) /* r */); 10318 if (c < p.getCost(2) /* r */) { 10319 p.setCost(2 /* r */, (char)(c)); 10320 p.writePacked(0, 0xFFFF00FF, 0xF200); // p.r = 242 10321 closure_r(p, c); 10322 } 10323 } 10324 } 10325 10326 /** 10327 * Give leaf child corresponding to external rule and child number. 10328 * e.g. . 10329 * 10330 * @param p tree node to get child for 10331 * @param eruleno external rule number 10332 * @param kidnumber the child to return 10333 * @return the requested child 10334 */ 10335 private static AbstractBURS_TreeNode kids(AbstractBURS_TreeNode p, int eruleno, int kidnumber) { 10336 if (BURS.DEBUG) { 10337 switch (eruleno) { 10338 case 18: // load8_16_32: load8 10339 case 17: // load8_16_32: load16_32 10340 case 16: // load16_32: load32 10341 case 15: // load16_32: load16 10342 case 14: // load16: uload16 10343 case 13: // load16: sload16 10344 case 12: // load8: uload8 10345 case 11: // load8: sload8 10346 case 10: // address1scaledreg: address1reg 10347 case 9: // address: address1scaledreg 10348 case 8: // any: riv 10349 case 7: // rlv: r 10350 case 6: // riv: r 10351 case 5: // szp: szpr 10352 case 4: // r: szpr 10353 case 3: // cz: czr 10354 case 2: // r: czr 10355 case 1: // stm: r 10356 if (kidnumber == 0) { 10357 return p; 10358 } 10359 break; 10360 case 49: // stm: CLEAR_FLOATING_POINT_STATE 10361 case 48: // r: LONG_MOVE(LONG_CONSTANT) 10362 case 47: // r: GET_TIME_BASE 10363 case 46: // stm: RETURN(LONG_CONSTANT) 10364 case 45: // stm: RETURN(INT_CONSTANT) 10365 case 44: // stm: RETURN(NULL) 10366 case 43: // stm: PAUSE 10367 case 42: // stm: FENCE 10368 case 41: // stm: READ_CEILING 10369 case 40: // stm: WRITE_FLOOR 10370 case 39: // stm: GOTO 10371 case 38: // stm: TRAP 10372 case 37: // stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 10373 case 36: // r: GET_CAUGHT_EXCEPTION 10374 case 35: // stm: IR_PROLOGUE 10375 case 34: // r: GUARD_COMBINE 10376 case 33: // r: GUARD_MOVE 10377 case 32: // stm: NOP 10378 case 31: // stm: RESOLVE 10379 case 30: // stm: YIELDPOINT_BACKEDGE 10380 case 29: // stm: YIELDPOINT_EPILOGUE 10381 case 28: // stm: YIELDPOINT_PROLOGUE 10382 case 27: // stm: UNINT_END 10383 case 26: // stm: UNINT_BEGIN 10384 case 25: // stm: IG_PATCH_POINT 10385 case 24: // any: LONG_CONSTANT 10386 case 23: // any: ADDRESS_CONSTANT 10387 case 22: // any: NULL 10388 case 21: // rlv: LONG_CONSTANT 10389 case 20: // riv: INT_CONSTANT 10390 case 19: // r: REGISTER 10391 break; 10392 case 205: // stm: DOUBLE_IFCMP(double_load,r) 10393 case 204: // stm: DOUBLE_IFCMP(r,double_load) 10394 case 203: // stm: DOUBLE_IFCMP(r,r) 10395 case 202: // stm: FLOAT_IFCMP(float_load,r) 10396 case 201: // stm: FLOAT_IFCMP(r,float_load) 10397 case 200: // stm: FLOAT_IFCMP(r,r) 10398 case 199: // float_load: FLOAT_ALOAD(riv,riv) 10399 case 198: // r: FLOAT_ALOAD(rlv,rlv) 10400 case 197: // r: FLOAT_ALOAD(riv,r) 10401 case 196: // r: FLOAT_ALOAD(riv,riv) 10402 case 195: // float_load: FLOAT_LOAD(riv,riv) 10403 case 194: // r: FLOAT_LOAD(rlv,rlv) 10404 case 193: // r: FLOAT_LOAD(riv,riv) 10405 case 192: // double_load: DOUBLE_ALOAD(riv,riv) 10406 case 191: // r: DOUBLE_ALOAD(rlv,rlv) 10407 case 190: // r: DOUBLE_ALOAD(riv,r) 10408 case 189: // double_load: DOUBLE_LOAD(rlv,rlv) 10409 case 188: // r: DOUBLE_ALOAD(riv,riv) 10410 case 187: // double_load: DOUBLE_LOAD(riv,riv) 10411 case 186: // r: DOUBLE_LOAD(rlv,rlv) 10412 case 185: // r: DOUBLE_LOAD(riv,rlv) 10413 case 184: // r: DOUBLE_LOAD(riv,riv) 10414 case 183: // r: DOUBLE_REM(r,r) 10415 case 182: // r: FLOAT_REM(r,r) 10416 case 181: // r: DOUBLE_DIV(r,double_load) 10417 case 180: // r: DOUBLE_DIV(r,r) 10418 case 179: // r: FLOAT_DIV(r,float_load) 10419 case 178: // r: FLOAT_DIV(r,r) 10420 case 177: // r: DOUBLE_MUL(double_load,r) 10421 case 176: // r: DOUBLE_MUL(r,double_load) 10422 case 175: // r: DOUBLE_MUL(r,r) 10423 case 174: // r: FLOAT_MUL(float_load,r) 10424 case 173: // r: FLOAT_MUL(r,float_load) 10425 case 172: // r: FLOAT_MUL(r,r) 10426 case 171: // r: DOUBLE_SUB(r,double_load) 10427 case 170: // r: DOUBLE_SUB(r,r) 10428 case 169: // r: FLOAT_SUB(r,float_load) 10429 case 168: // r: FLOAT_SUB(r,r) 10430 case 167: // r: DOUBLE_ADD(double_load,r) 10431 case 166: // r: DOUBLE_ADD(r,double_load) 10432 case 165: // r: DOUBLE_ADD(r,r) 10433 case 164: // r: FLOAT_ADD(float_load,r) 10434 case 163: // r: FLOAT_ADD(r,float_load) 10435 case 162: // r: FLOAT_ADD(r,r) 10436 case 161: // r: LONG_XOR(load64,rlv) 10437 case 160: // r: LONG_XOR(r,load64) 10438 case 159: // r: LONG_XOR(r,rlv) 10439 case 158: // r: LONG_USHR(rlv,riv) 10440 case 157: // r: LONG_SUB(load64,rlv) 10441 case 156: // r: LONG_SUB(rlv,load64) 10442 case 155: // r: LONG_SUB(rlv,rlv) 10443 case 154: // r: LONG_SHR(rlv,riv) 10444 case 153: // r: LONG_SHL(rlv,riv) 10445 case 152: // r: LONG_OR(load64,rlv) 10446 case 151: // r: LONG_OR(r,load64) 10447 case 150: // r: LONG_OR(r,rlv) 10448 case 149: // r: LONG_MUL(r,rlv) 10449 case 148: // r: LONG_ALOAD(riv,riv) 10450 case 147: // r: LONG_LOAD(riv,riv) 10451 case 146: // stm: LONG_IFCMP(r,rlv) 10452 case 145: // r: LONG_AND(load64,rlv) 10453 case 144: // r: LONG_AND(r,load64) 10454 case 143: // r: LONG_AND(r,rlv) 10455 case 142: // r: LONG_ADD(load64,rlv) 10456 case 141: // r: LONG_ADD(r,load64) 10457 case 140: // r: LONG_ADD(r,rlv) 10458 case 139: // load64: LONG_ALOAD(riv,riv) 10459 case 138: // load64: LONG_LOAD(riv,riv) 10460 case 137: // load32: INT_ALOAD(riv,riv) 10461 case 136: // load32: INT_LOAD(riv,riv) 10462 case 135: // uload16: USHORT_ALOAD(riv,riv) 10463 case 134: // r: USHORT_ALOAD(riv,riv) 10464 case 133: // uload16: USHORT_LOAD(riv,riv) 10465 case 132: // r: USHORT_LOAD(riv,riv) 10466 case 131: // sload16: SHORT_ALOAD(riv,riv) 10467 case 130: // r: SHORT_ALOAD(riv,riv) 10468 case 129: // sload16: SHORT_LOAD(riv,riv) 10469 case 128: // r: SHORT_LOAD(riv,riv) 10470 case 127: // uload8: UBYTE_ALOAD(riv,riv) 10471 case 126: // r: UBYTE_ALOAD(riv,riv) 10472 case 125: // uload8: UBYTE_LOAD(riv,riv) 10473 case 124: // r: UBYTE_LOAD(riv,riv) 10474 case 123: // sload8: BYTE_ALOAD(riv,riv) 10475 case 122: // r: BYTE_ALOAD(riv,riv) 10476 case 121: // sload8: BYTE_LOAD(riv,riv) 10477 case 120: // r: BYTE_LOAD(riv,riv) 10478 case 119: // r: INT_ADD(address1reg,address1scaledreg) 10479 case 118: // r: INT_ADD(address1scaledreg,address1reg) 10480 case 117: // r: INT_ADD(r,address1scaledreg) 10481 case 116: // r: INT_ADD(address1scaledreg,r) 10482 case 115: // szpr: INT_XOR(load32,riv) 10483 case 114: // szpr: INT_XOR(r,load32) 10484 case 113: // szpr: INT_XOR(r,riv) 10485 case 112: // szpr: INT_USHR(riv,riv) 10486 case 111: // czr: INT_SUB(load32,riv) 10487 case 110: // czr: INT_SUB(riv,load32) 10488 case 109: // r: INT_SUB(load32,r) 10489 case 108: // r: INT_SUB(riv,r) 10490 case 107: // czr: INT_SUB(riv,r) 10491 case 106: // szpr: INT_SHR(riv,riv) 10492 case 105: // szpr: INT_SHL(riv,riv) 10493 case 104: // r: INT_REM(riv,load32) 10494 case 103: // r: INT_REM(riv,riv) 10495 case 102: // szpr: INT_OR(load32,riv) 10496 case 101: // szpr: INT_OR(r,load32) 10497 case 100: // szpr: INT_OR(r,riv) 10498 case 99: // r: INT_MUL(load32,riv) 10499 case 98: // r: INT_MUL(r,load32) 10500 case 97: // r: INT_MUL(r,riv) 10501 case 96: // r: INT_ALOAD(riv,riv) 10502 case 95: // r: INT_LOAD(address1reg,address1scaledreg) 10503 case 94: // r: INT_LOAD(address1scaledreg,address1reg) 10504 case 93: // r: INT_LOAD(address1scaledreg,riv) 10505 case 92: // r: INT_LOAD(riv,address1scaledreg) 10506 case 91: // r: INT_LOAD(riv,riv) 10507 case 90: // stm: INT_IFCMP2(riv,load32) 10508 case 89: // stm: INT_IFCMP2(load32,riv) 10509 case 88: // stm: INT_IFCMP2(r,riv) 10510 case 87: // stm: INT_IFCMP(r,load32) 10511 case 86: // stm: INT_IFCMP(load32,riv) 10512 case 85: // stm: INT_IFCMP(r,uload8) 10513 case 84: // stm: INT_IFCMP(uload8,r) 10514 case 83: // stm: INT_IFCMP(r,riv) 10515 case 82: // r: INT_DIV(riv,load32) 10516 case 81: // r: INT_DIV(riv,riv) 10517 case 80: // szp: INT_AND(r,load8_16_32) 10518 case 79: // szp: INT_AND(load8_16_32,riv) 10519 case 78: // szpr: INT_AND(load32,riv) 10520 case 77: // szpr: INT_AND(r,load32) 10521 case 76: // szp: INT_AND(r,riv) 10522 case 75: // szpr: INT_AND(r,riv) 10523 case 74: // czr: INT_ADD(load32,riv) 10524 case 73: // czr: INT_ADD(r,load32) 10525 case 72: // r: INT_ADD(r,riv) 10526 case 71: // czr: INT_ADD(r,riv) 10527 case 70: // boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 10528 case 69: // r: BOOLEAN_CMP_LONG(rlv,rlv) 10529 case 68: // boolcmp: BOOLEAN_CMP_INT(riv,load32) 10530 case 67: // r: BOOLEAN_CMP_INT(r,load32) 10531 case 66: // boolcmp: BOOLEAN_CMP_INT(load32,riv) 10532 case 65: // r: BOOLEAN_CMP_INT(load32,riv) 10533 case 64: // boolcmp: BOOLEAN_CMP_INT(r,riv) 10534 case 63: // r: BOOLEAN_CMP_INT(r,riv) 10535 case 62: // address: INT_ADD(address1reg,address1scaledreg) 10536 case 61: // address: INT_ADD(address1scaledreg,address1reg) 10537 case 60: // address: INT_ADD(address1scaledreg,r) 10538 case 59: // address: INT_ADD(r,address1scaledreg) 10539 case 58: // address: INT_ADD(r,r) 10540 case 57: // stm: YIELDPOINT_OSR(any,any) 10541 case 56: // r: SYSCALL(r,any) 10542 case 55: // r: CALL(r,any) 10543 case 54: // r: LONG_CMP(rlv,rlv) 10544 case 53: // stm: TRAP_IF(riv,load32) 10545 case 52: // stm: TRAP_IF(load32,riv) 10546 case 51: // stm: TRAP_IF(r,r) 10547 case 50: // any: OTHER_OPERAND(any,any) 10548 if (kidnumber == 0) { 10549 return p.getChild1(); 10550 } 10551 if (kidnumber == 1) { 10552 return p.getChild2(); 10553 } 10554 break; 10555 case 325: // double_load: MATERIALIZE_FP_CONSTANT(any) 10556 case 324: // float_load: MATERIALIZE_FP_CONSTANT(any) 10557 case 323: // r: MATERIALIZE_FP_CONSTANT(any) 10558 case 322: // double_load: LONG_BITS_AS_DOUBLE(load64) 10559 case 321: // r: LONG_BITS_AS_DOUBLE(rlv) 10560 case 320: // float_load: INT_BITS_AS_FLOAT(load32) 10561 case 319: // r: INT_BITS_AS_FLOAT(riv) 10562 case 318: // load64: DOUBLE_AS_LONG_BITS(double_load) 10563 case 317: // r: DOUBLE_AS_LONG_BITS(r) 10564 case 316: // load32: FLOAT_AS_INT_BITS(float_load) 10565 case 315: // r: FLOAT_AS_INT_BITS(r) 10566 case 314: // r: DOUBLE_2LONG(r) 10567 case 313: // r: DOUBLE_2INT(r) 10568 case 312: // r: FLOAT_2LONG(r) 10569 case 311: // r: FLOAT_2INT(r) 10570 case 310: // r: DOUBLE_2FLOAT(double_load) 10571 case 309: // r: DOUBLE_2FLOAT(r) 10572 case 308: // r: FLOAT_2DOUBLE(float_load) 10573 case 307: // r: FLOAT_2DOUBLE(r) 10574 case 306: // r: INT_2DOUBLE(load32) 10575 case 305: // r: INT_2DOUBLE(riv) 10576 case 304: // r: INT_2FLOAT(load32) 10577 case 303: // r: INT_2FLOAT(riv) 10578 case 302: // r: DOUBLE_MOVE(r) 10579 case 301: // r: FLOAT_MOVE(r) 10580 case 300: // r: LONG_2DOUBLE(r) 10581 case 299: // r: LONG_2FLOAT(r) 10582 case 298: // r: DOUBLE_SQRT(r) 10583 case 297: // r: FLOAT_SQRT(r) 10584 case 296: // r: DOUBLE_NEG(r) 10585 case 295: // r: FLOAT_NEG(r) 10586 case 294: // r: LONG_NOT(r) 10587 case 293: // r: LONG_NEG(r) 10588 case 292: // load64: LONG_MOVE(load64) 10589 case 291: // r: LONG_MOVE(r) 10590 case 290: // load32: LONG_2INT(load64) 10591 case 289: // r: LONG_2INT(load64) 10592 case 288: // r: LONG_2INT(r) 10593 case 287: // r: INT_MOVE(address) 10594 case 286: // r: INT_ADD(address,INT_CONSTANT) 10595 case 285: // szpr: INT_USHR(riv,INT_CONSTANT) 10596 case 284: // szpr: INT_SHR(riv,INT_CONSTANT) 10597 case 283: // r: INT_SHL(r,INT_CONSTANT) 10598 case 282: // szpr: INT_SHL(r,INT_CONSTANT) 10599 case 281: // r: INT_NOT(r) 10600 case 280: // szpr: INT_NEG(r) 10601 case 279: // load32: INT_MOVE(load32) 10602 case 278: // load16: INT_MOVE(load16) 10603 case 277: // uload16: INT_MOVE(uload16) 10604 case 276: // sload16: INT_MOVE(sload16) 10605 case 275: // load8: INT_MOVE(load8) 10606 case 274: // uload8: INT_MOVE(uload8) 10607 case 273: // sload8: INT_MOVE(sload8) 10608 case 272: // szp: INT_MOVE(szp) 10609 case 271: // szpr: INT_MOVE(szpr) 10610 case 270: // cz: INT_MOVE(cz) 10611 case 269: // czr: INT_MOVE(czr) 10612 case 268: // r: INT_MOVE(riv) 10613 case 267: // r: INT_LOAD(address,INT_CONSTANT) 10614 case 266: // stm: INT_IFCMP(bittest,INT_CONSTANT) 10615 case 265: // stm: INT_IFCMP(szp,INT_CONSTANT) 10616 case 264: // stm: INT_IFCMP(cz,INT_CONSTANT) 10617 case 263: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 10618 case 262: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 10619 case 261: // stm: INT_IFCMP(sload16,INT_CONSTANT) 10620 case 260: // stm: INT_IFCMP(load8,INT_CONSTANT) 10621 case 259: // stm: INT_IFCMP(r,INT_CONSTANT) 10622 case 258: // r: INT_2USHORT(load16_32) 10623 case 257: // uload16: INT_2USHORT(load16_32) 10624 case 256: // szpr: INT_2USHORT(r) 10625 case 255: // sload16: INT_2SHORT(load16_32) 10626 case 254: // r: INT_2SHORT(load16_32) 10627 case 253: // r: INT_2SHORT(r) 10628 case 252: // r: INT_2LONG(load32) 10629 case 251: // r: INT_2LONG(r) 10630 case 250: // r: INT_2BYTE(load8_16_32) 10631 case 249: // r: INT_2BYTE(r) 10632 case 248: // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 10633 case 247: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 10634 case 246: // r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 10635 case 245: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 10636 case 244: // r: BOOLEAN_NOT(r) 10637 case 243: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 10638 case 242: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 10639 case 241: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 10640 case 240: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 10641 case 239: // boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 10642 case 238: // r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 10643 case 237: // boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 10644 case 236: // r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 10645 case 235: // boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 10646 case 234: // r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 10647 case 233: // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 10648 case 232: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 10649 case 231: // r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 10650 case 230: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 10651 case 229: // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 10652 case 228: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 10653 case 227: // r: ADDR_2LONG(load32) 10654 case 226: // r: ADDR_2LONG(r) 10655 case 225: // address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) 10656 case 224: // address1scaledreg: INT_SHL(r,INT_CONSTANT) 10657 case 223: // address1scaledreg: INT_MOVE(address1scaledreg) 10658 case 222: // address1reg: INT_ADD(address1reg,INT_CONSTANT) 10659 case 221: // address1reg: INT_MOVE(address1reg) 10660 case 220: // address1reg: INT_MOVE(r) 10661 case 219: // address1reg: INT_ADD(r,INT_CONSTANT) 10662 case 218: // address: INT_ADD(address1scaledreg,INT_CONSTANT) 10663 case 217: // address: INT_MOVE(address) 10664 case 216: // stm: RETURN(r) 10665 case 215: // stm: PREFETCH(r) 10666 case 214: // r: INT_AND(load16_32,INT_CONSTANT) 10667 case 213: // r: INT_2BYTE(load8_16_32) 10668 case 212: // r: INT_AND(load8_16_32,INT_CONSTANT) 10669 case 211: // uload8: INT_AND(load8_16_32,INT_CONSTANT) 10670 case 210: // stm: TRAP_IF(r,LONG_CONSTANT) 10671 case 209: // stm: TRAP_IF(r,INT_CONSTANT) 10672 case 208: // stm: SET_CAUGHT_EXCEPTION(r) 10673 case 207: // stm: NULL_CHECK(riv) 10674 case 206: // stm: LOWTABLESWITCH(r) 10675 if (kidnumber == 0) { 10676 return p.getChild1(); 10677 } 10678 break; 10679 case 341: // r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) 10680 case 340: // load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 10681 case 339: // load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 10682 case 338: // r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 10683 case 337: // r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 10684 case 336: // r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 10685 case 335: // r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 10686 case 334: // szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 10687 case 333: // r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) 10688 case 332: // r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) 10689 case 331: // r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 10690 case 330: // r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 10691 case 329: // bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 10692 case 328: // bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 10693 case 327: // r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 10694 case 326: // r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 10695 if (kidnumber == 0) { 10696 return p.getChild1().getChild1(); 10697 } 10698 break; 10699 case 404: // stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 10700 case 403: // stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 10701 case 402: // stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 10702 case 401: // stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 10703 case 400: // r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 10704 case 399: // r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 10705 case 398: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 10706 case 397: // r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 10707 case 396: // r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 10708 case 395: // r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 10709 case 394: // r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 10710 case 393: // r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 10711 case 392: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 10712 case 391: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 10713 case 390: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 10714 case 389: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 10715 case 388: // stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 10716 case 387: // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 10717 case 386: // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 10718 case 385: // stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 10719 case 384: // stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 10720 case 383: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 10721 case 382: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 10722 case 381: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 10723 case 380: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 10724 case 379: // stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 10725 case 378: // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 10726 case 377: // stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 10727 case 376: // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 10728 case 375: // stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 10729 case 374: // stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) 10730 case 373: // r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 10731 case 372: // stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 10732 case 371: // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 10733 case 370: // stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) 10734 case 369: // stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) 10735 case 368: // stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) 10736 case 367: // r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 10737 case 366: // r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 10738 case 365: // r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 10739 case 364: // r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 10740 case 363: // r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 10741 case 362: // stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) 10742 case 361: // stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) 10743 case 360: // stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) 10744 case 359: // stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) 10745 case 358: // stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 10746 case 357: // stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 10747 case 356: // stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 10748 case 355: // stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 10749 case 354: // stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 10750 case 353: // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 10751 case 352: // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 10752 case 351: // stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 10753 case 350: // stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 10754 case 349: // stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 10755 case 348: // stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 10756 case 347: // stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 10757 case 346: // stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 10758 case 345: // stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 10759 case 344: // stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 10760 case 343: // stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 10761 case 342: // stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 10762 if (kidnumber == 0) { 10763 return p.getChild1(); 10764 } 10765 if (kidnumber == 1) { 10766 return p.getChild2().getChild1(); 10767 } 10768 if (kidnumber == 2) { 10769 return p.getChild2().getChild2(); 10770 } 10771 break; 10772 case 407: // stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 10773 case 406: // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 10774 case 405: // stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 10775 if (kidnumber == 0) { 10776 return p.getChild2().getChild1(); 10777 } 10778 if (kidnumber == 1) { 10779 return p.getChild2().getChild2(); 10780 } 10781 break; 10782 case 410: // r: SYSCALL(INT_CONSTANT,any) 10783 case 409: // r: CALL(INT_CONSTANT,any) 10784 case 408: // r: CALL(BRANCH_TARGET,any) 10785 if (kidnumber == 0) { 10786 return p.getChild2(); 10787 } 10788 break; 10789 case 413: // r: SYSCALL(INT_LOAD(riv,riv),any) 10790 case 412: // r: CALL(LONG_LOAD(rlv,rlv),any) 10791 case 411: // r: CALL(INT_LOAD(riv,riv),any) 10792 if (kidnumber == 0) { 10793 return p.getChild1().getChild1(); 10794 } 10795 if (kidnumber == 1) { 10796 return p.getChild1().getChild2(); 10797 } 10798 if (kidnumber == 2) { 10799 return p.getChild2(); 10800 } 10801 break; 10802 case 425: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 10803 case 424: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 10804 case 423: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 10805 case 422: // r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 10806 case 421: // r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) 10807 case 420: // r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 10808 case 419: // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 10809 case 418: // r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 10810 case 417: // r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 10811 case 416: // r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 10812 case 415: // r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 10813 case 414: // r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 10814 if (kidnumber == 0) { 10815 return p.getChild1(); 10816 } 10817 if (kidnumber == 1) { 10818 return p.getChild2().getChild1(); 10819 } 10820 if (kidnumber == 2) { 10821 return p.getChild2().getChild2().getChild1(); 10822 } 10823 if (kidnumber == 3) { 10824 return p.getChild2().getChild2().getChild2(); 10825 } 10826 break; 10827 case 426: // r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 10828 if (kidnumber == 0) { 10829 return p.getChild1(); 10830 } 10831 if (kidnumber == 1) { 10832 return p.getChild2().getChild2().getChild1(); 10833 } 10834 if (kidnumber == 2) { 10835 return p.getChild2().getChild2().getChild2(); 10836 } 10837 break; 10838 case 427: // r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 10839 if (kidnumber == 0) { 10840 return p.getChild2().getChild1(); 10841 } 10842 if (kidnumber == 1) { 10843 return p.getChild2().getChild2().getChild1(); 10844 } 10845 if (kidnumber == 2) { 10846 return p.getChild2().getChild2().getChild2(); 10847 } 10848 break; 10849 case 437: // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10850 case 436: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10851 case 435: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10852 case 434: // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10853 case 433: // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10854 case 432: // stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10855 case 431: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10856 case 430: // stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10857 case 429: // stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10858 case 428: // stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10859 if (kidnumber == 0) { 10860 return p.getChild1().getChild1(); 10861 } 10862 if (kidnumber == 1) { 10863 return p.getChild1().getChild2().getChild1(); 10864 } 10865 if (kidnumber == 2) { 10866 return p.getChild1().getChild2().getChild2().getChild1(); 10867 } 10868 if (kidnumber == 3) { 10869 return p.getChild1().getChild2().getChild2().getChild2(); 10870 } 10871 break; 10872 case 439: // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10873 case 438: // stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10874 if (kidnumber == 0) { 10875 return p.getChild1().getChild1(); 10876 } 10877 if (kidnumber == 1) { 10878 return p.getChild1().getChild2().getChild2().getChild1(); 10879 } 10880 if (kidnumber == 2) { 10881 return p.getChild1().getChild2().getChild2().getChild2(); 10882 } 10883 break; 10884 case 441: // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10885 case 440: // stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 10886 if (kidnumber == 0) { 10887 return p.getChild1().getChild2().getChild1(); 10888 } 10889 if (kidnumber == 1) { 10890 return p.getChild1().getChild2().getChild2().getChild1(); 10891 } 10892 if (kidnumber == 2) { 10893 return p.getChild1().getChild2().getChild2().getChild2(); 10894 } 10895 break; 10896 case 445: // bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 10897 case 444: // bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 10898 case 443: // bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 10899 case 442: // bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 10900 if (kidnumber == 0) { 10901 return p.getChild1().getChild1(); 10902 } 10903 if (kidnumber == 1) { 10904 return p.getChild1().getChild2().getChild1(); 10905 } 10906 break; 10907 case 447: // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 10908 case 446: // bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 10909 if (kidnumber == 0) { 10910 return p.getChild1().getChild2().getChild1(); 10911 } 10912 if (kidnumber == 1) { 10913 return p.getChild2(); 10914 } 10915 break; 10916 case 449: // bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 10917 case 448: // bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 10918 if (kidnumber == 0) { 10919 return p.getChild1(); 10920 } 10921 if (kidnumber == 1) { 10922 return p.getChild2().getChild2().getChild1(); 10923 } 10924 break; 10925 case 465: // stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10926 case 464: // stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10927 case 463: // stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10928 case 462: // stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10929 case 461: // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10930 case 460: // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10931 case 459: // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10932 case 458: // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10933 case 457: // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10934 case 456: // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 10935 case 455: // stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10936 case 454: // stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10937 case 453: // stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10938 case 452: // stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10939 case 451: // stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10940 case 450: // stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 10941 if (kidnumber == 0) { 10942 return p.getChild1().getChild1().getChild1(); 10943 } 10944 if (kidnumber == 1) { 10945 return p.getChild1().getChild1().getChild2(); 10946 } 10947 if (kidnumber == 2) { 10948 return p.getChild2().getChild1(); 10949 } 10950 if (kidnumber == 3) { 10951 return p.getChild2().getChild2(); 10952 } 10953 break; 10954 case 473: // r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 10955 case 472: // r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 10956 case 471: // r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 10957 case 470: // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 10958 case 469: // r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 10959 case 468: // r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 10960 case 467: // r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 10961 case 466: // r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 10962 if (kidnumber == 0) { 10963 return p.getChild1(); 10964 } 10965 if (kidnumber == 1) { 10966 return p.getChild2().getChild2(); 10967 } 10968 break; 10969 case 481: // stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 10970 case 480: // stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 10971 case 479: // stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 10972 case 478: // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 10973 case 477: // stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 10974 case 476: // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 10975 case 475: // stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 10976 case 474: // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 10977 if (kidnumber == 0) { 10978 return p.getChild1().getChild1(); 10979 } 10980 if (kidnumber == 1) { 10981 return p.getChild2().getChild1(); 10982 } 10983 if (kidnumber == 2) { 10984 return p.getChild2().getChild2(); 10985 } 10986 break; 10987 case 501: // stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10988 case 500: // stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10989 case 499: // stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10990 case 498: // stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10991 case 497: // stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10992 case 496: // stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10993 case 495: // stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10994 case 494: // stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10995 case 493: // stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10996 case 492: // stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 10997 case 491: // stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 10998 case 490: // stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 10999 case 489: // stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11000 case 488: // stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11001 case 487: // stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11002 case 486: // stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11003 case 485: // stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11004 case 484: // stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11005 case 483: // stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11006 case 482: // stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11007 if (kidnumber == 0) { 11008 return p.getChild1().getChild1().getChild1(); 11009 } 11010 if (kidnumber == 1) { 11011 return p.getChild1().getChild1().getChild2(); 11012 } 11013 if (kidnumber == 2) { 11014 return p.getChild1().getChild2(); 11015 } 11016 if (kidnumber == 3) { 11017 return p.getChild2().getChild1(); 11018 } 11019 if (kidnumber == 4) { 11020 return p.getChild2().getChild2(); 11021 } 11022 break; 11023 case 519: // stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11024 case 518: // stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11025 case 517: // stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11026 case 516: // stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11027 case 515: // stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11028 case 514: // stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11029 case 513: // stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11030 case 512: // stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11031 case 511: // stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11032 case 510: // stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11033 case 509: // stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11034 case 508: // stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11035 case 507: // stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11036 case 506: // stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11037 case 505: // stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11038 case 504: // stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11039 case 503: // stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11040 case 502: // stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11041 if (kidnumber == 0) { 11042 return p.getChild1().getChild1(); 11043 } 11044 if (kidnumber == 1) { 11045 return p.getChild1().getChild2().getChild1(); 11046 } 11047 if (kidnumber == 2) { 11048 return p.getChild1().getChild2().getChild2(); 11049 } 11050 if (kidnumber == 3) { 11051 return p.getChild2().getChild1(); 11052 } 11053 if (kidnumber == 4) { 11054 return p.getChild2().getChild2(); 11055 } 11056 break; 11057 case 525: // r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) 11058 case 524: // r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) 11059 case 523: // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 11060 case 522: // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 11061 case 521: // r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 11062 case 520: // r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 11063 if (kidnumber == 0) { 11064 return p.getChild1().getChild1(); 11065 } 11066 if (kidnumber == 1) { 11067 return p.getChild2().getChild1(); 11068 } 11069 break; 11070 case 527: // r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 11071 case 526: // r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 11072 if (kidnumber == 0) { 11073 return p.getChild1().getChild1(); 11074 } 11075 if (kidnumber == 1) { 11076 return p.getChild1().getChild2().getChild1(); 11077 } 11078 if (kidnumber == 2) { 11079 return p.getChild2().getChild1(); 11080 } 11081 if (kidnumber == 3) { 11082 return p.getChild2().getChild2().getChild1().getChild1(); 11083 } 11084 break; 11085 case 529: // r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 11086 case 528: // r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 11087 if (kidnumber == 0) { 11088 return p.getChild1().getChild1(); 11089 } 11090 if (kidnumber == 1) { 11091 return p.getChild1().getChild2().getChild1().getChild1(); 11092 } 11093 if (kidnumber == 2) { 11094 return p.getChild2().getChild1(); 11095 } 11096 if (kidnumber == 3) { 11097 return p.getChild2().getChild2().getChild1(); 11098 } 11099 break; 11100 case 536: // r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) 11101 case 535: // r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) 11102 case 534: // r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) 11103 case 533: // szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 11104 case 532: // stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) 11105 case 531: // szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 11106 case 530: // szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 11107 if (kidnumber == 0) { 11108 return p.getChild1(); 11109 } 11110 if (kidnumber == 1) { 11111 return p.getChild2().getChild1(); 11112 } 11113 break; 11114 case 542: // stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11115 case 541: // stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11116 case 540: // stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11117 case 539: // stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11118 case 538: // stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11119 case 537: // stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11120 if (kidnumber == 0) { 11121 return p.getChild1().getChild1().getChild1(); 11122 } 11123 if (kidnumber == 1) { 11124 return p.getChild1().getChild1().getChild2(); 11125 } 11126 if (kidnumber == 2) { 11127 return p.getChild1().getChild2().getChild1(); 11128 } 11129 if (kidnumber == 3) { 11130 return p.getChild2().getChild1(); 11131 } 11132 if (kidnumber == 4) { 11133 return p.getChild2().getChild2(); 11134 } 11135 break; 11136 case 546: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11137 case 545: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11138 case 544: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11139 case 543: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11140 if (kidnumber == 0) { 11141 return p.getChild1(); 11142 } 11143 if (kidnumber == 1) { 11144 return p.getChild2().getChild2().getChild1(); 11145 } 11146 if (kidnumber == 2) { 11147 return p.getChild2().getChild2().getChild2().getChild1(); 11148 } 11149 break; 11150 case 550: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11151 case 549: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11152 case 548: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11153 case 547: // r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11154 if (kidnumber == 0) { 11155 return p.getChild1(); 11156 } 11157 if (kidnumber == 1) { 11158 return p.getChild2().getChild2().getChild1().getChild1(); 11159 } 11160 if (kidnumber == 2) { 11161 return p.getChild2().getChild2().getChild2(); 11162 } 11163 break; 11164 case 554: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11165 case 553: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11166 case 552: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11167 case 551: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11168 if (kidnumber == 0) { 11169 return p.getChild2().getChild1(); 11170 } 11171 if (kidnumber == 1) { 11172 return p.getChild2().getChild2().getChild1().getChild1(); 11173 } 11174 if (kidnumber == 2) { 11175 return p.getChild2().getChild2().getChild2(); 11176 } 11177 break; 11178 case 558: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11179 case 557: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11180 case 556: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11181 case 555: // r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11182 if (kidnumber == 0) { 11183 return p.getChild2().getChild1(); 11184 } 11185 if (kidnumber == 1) { 11186 return p.getChild2().getChild2().getChild1(); 11187 } 11188 if (kidnumber == 2) { 11189 return p.getChild2().getChild2().getChild2().getChild1(); 11190 } 11191 break; 11192 } 11193 throw new OptimizingCompilerException("BURS","Bad rule number ", 11194 Integer.toString(eruleno)); 11195 } else { 11196 return null; 11197 } 11198 } 11199 11200 /** 11201 * @param p node whose kids will be marked 11202 * @param eruleno rule number 11203 */ 11204 private static void mark_kids(AbstractBURS_TreeNode p, int eruleno) 11205 { 11206 byte[] ntsrule = nts[eruleno]; 11207 // 18: load8_16_32: load8 11208 // 17: load8_16_32: load16_32 11209 // 16: load16_32: load32 11210 // 15: load16_32: load16 11211 // 14: load16: uload16 11212 // 13: load16: sload16 11213 // 12: load8: uload8 11214 // 11: load8: sload8 11215 // 10: address1scaledreg: address1reg 11216 // 9: address: address1scaledreg 11217 // 8: any: riv 11218 // 7: rlv: r 11219 // 6: riv: r 11220 // 5: szp: szpr 11221 // 4: r: szpr 11222 // 3: cz: czr 11223 // 2: r: czr 11224 // 1: stm: r 11225 if (eruleno <= 18) { 11226 if (VM.VerifyAssertions) VM._assert(eruleno > 0); 11227 mark(p, ntsrule[0]); 11228 } 11229 // 49: stm: CLEAR_FLOATING_POINT_STATE 11230 // 48: r: LONG_MOVE(LONG_CONSTANT) 11231 // 47: r: GET_TIME_BASE 11232 // 46: stm: RETURN(LONG_CONSTANT) 11233 // 45: stm: RETURN(INT_CONSTANT) 11234 // 44: stm: RETURN(NULL) 11235 // 43: stm: PAUSE 11236 // 42: stm: FENCE 11237 // 41: stm: READ_CEILING 11238 // 40: stm: WRITE_FLOOR 11239 // 39: stm: GOTO 11240 // 38: stm: TRAP 11241 // 37: stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 11242 // 36: r: GET_CAUGHT_EXCEPTION 11243 // 35: stm: IR_PROLOGUE 11244 // 34: r: GUARD_COMBINE 11245 // 33: r: GUARD_MOVE 11246 // 32: stm: NOP 11247 // 31: stm: RESOLVE 11248 // 30: stm: YIELDPOINT_BACKEDGE 11249 // 29: stm: YIELDPOINT_EPILOGUE 11250 // 28: stm: YIELDPOINT_PROLOGUE 11251 // 27: stm: UNINT_END 11252 // 26: stm: UNINT_BEGIN 11253 // 25: stm: IG_PATCH_POINT 11254 // 24: any: LONG_CONSTANT 11255 // 23: any: ADDRESS_CONSTANT 11256 // 22: any: NULL 11257 // 21: rlv: LONG_CONSTANT 11258 // 20: riv: INT_CONSTANT 11259 // 19: r: REGISTER 11260 else if (eruleno <= 49) { 11261 } 11262 // 205: stm: DOUBLE_IFCMP(double_load,r) 11263 // 204: stm: DOUBLE_IFCMP(r,double_load) 11264 // 203: stm: DOUBLE_IFCMP(r,r) 11265 // 202: stm: FLOAT_IFCMP(float_load,r) 11266 // 201: stm: FLOAT_IFCMP(r,float_load) 11267 // 200: stm: FLOAT_IFCMP(r,r) 11268 // 199: float_load: FLOAT_ALOAD(riv,riv) 11269 // 198: r: FLOAT_ALOAD(rlv,rlv) 11270 // 197: r: FLOAT_ALOAD(riv,r) 11271 // 196: r: FLOAT_ALOAD(riv,riv) 11272 // 195: float_load: FLOAT_LOAD(riv,riv) 11273 // 194: r: FLOAT_LOAD(rlv,rlv) 11274 // 193: r: FLOAT_LOAD(riv,riv) 11275 // 192: double_load: DOUBLE_ALOAD(riv,riv) 11276 // 191: r: DOUBLE_ALOAD(rlv,rlv) 11277 // 190: r: DOUBLE_ALOAD(riv,r) 11278 // 189: double_load: DOUBLE_LOAD(rlv,rlv) 11279 // 188: r: DOUBLE_ALOAD(riv,riv) 11280 // 187: double_load: DOUBLE_LOAD(riv,riv) 11281 // 186: r: DOUBLE_LOAD(rlv,rlv) 11282 // 185: r: DOUBLE_LOAD(riv,rlv) 11283 // 184: r: DOUBLE_LOAD(riv,riv) 11284 // 183: r: DOUBLE_REM(r,r) 11285 // 182: r: FLOAT_REM(r,r) 11286 // 181: r: DOUBLE_DIV(r,double_load) 11287 // 180: r: DOUBLE_DIV(r,r) 11288 // 179: r: FLOAT_DIV(r,float_load) 11289 // 178: r: FLOAT_DIV(r,r) 11290 // 177: r: DOUBLE_MUL(double_load,r) 11291 // 176: r: DOUBLE_MUL(r,double_load) 11292 // 175: r: DOUBLE_MUL(r,r) 11293 // 174: r: FLOAT_MUL(float_load,r) 11294 // 173: r: FLOAT_MUL(r,float_load) 11295 // 172: r: FLOAT_MUL(r,r) 11296 // 171: r: DOUBLE_SUB(r,double_load) 11297 // 170: r: DOUBLE_SUB(r,r) 11298 // 169: r: FLOAT_SUB(r,float_load) 11299 // 168: r: FLOAT_SUB(r,r) 11300 // 167: r: DOUBLE_ADD(double_load,r) 11301 // 166: r: DOUBLE_ADD(r,double_load) 11302 // 165: r: DOUBLE_ADD(r,r) 11303 // 164: r: FLOAT_ADD(float_load,r) 11304 // 163: r: FLOAT_ADD(r,float_load) 11305 // 162: r: FLOAT_ADD(r,r) 11306 // 161: r: LONG_XOR(load64,rlv) 11307 // 160: r: LONG_XOR(r,load64) 11308 // 159: r: LONG_XOR(r,rlv) 11309 // 158: r: LONG_USHR(rlv,riv) 11310 // 157: r: LONG_SUB(load64,rlv) 11311 // 156: r: LONG_SUB(rlv,load64) 11312 // 155: r: LONG_SUB(rlv,rlv) 11313 // 154: r: LONG_SHR(rlv,riv) 11314 // 153: r: LONG_SHL(rlv,riv) 11315 // 152: r: LONG_OR(load64,rlv) 11316 // 151: r: LONG_OR(r,load64) 11317 // 150: r: LONG_OR(r,rlv) 11318 // 149: r: LONG_MUL(r,rlv) 11319 // 148: r: LONG_ALOAD(riv,riv) 11320 // 147: r: LONG_LOAD(riv,riv) 11321 // 146: stm: LONG_IFCMP(r,rlv) 11322 // 145: r: LONG_AND(load64,rlv) 11323 // 144: r: LONG_AND(r,load64) 11324 // 143: r: LONG_AND(r,rlv) 11325 // 142: r: LONG_ADD(load64,rlv) 11326 // 141: r: LONG_ADD(r,load64) 11327 // 140: r: LONG_ADD(r,rlv) 11328 // 139: load64: LONG_ALOAD(riv,riv) 11329 // 138: load64: LONG_LOAD(riv,riv) 11330 // 137: load32: INT_ALOAD(riv,riv) 11331 // 136: load32: INT_LOAD(riv,riv) 11332 // 135: uload16: USHORT_ALOAD(riv,riv) 11333 // 134: r: USHORT_ALOAD(riv,riv) 11334 // 133: uload16: USHORT_LOAD(riv,riv) 11335 // 132: r: USHORT_LOAD(riv,riv) 11336 // 131: sload16: SHORT_ALOAD(riv,riv) 11337 // 130: r: SHORT_ALOAD(riv,riv) 11338 // 129: sload16: SHORT_LOAD(riv,riv) 11339 // 128: r: SHORT_LOAD(riv,riv) 11340 // 127: uload8: UBYTE_ALOAD(riv,riv) 11341 // 126: r: UBYTE_ALOAD(riv,riv) 11342 // 125: uload8: UBYTE_LOAD(riv,riv) 11343 // 124: r: UBYTE_LOAD(riv,riv) 11344 // 123: sload8: BYTE_ALOAD(riv,riv) 11345 // 122: r: BYTE_ALOAD(riv,riv) 11346 // 121: sload8: BYTE_LOAD(riv,riv) 11347 // 120: r: BYTE_LOAD(riv,riv) 11348 // 119: r: INT_ADD(address1reg,address1scaledreg) 11349 // 118: r: INT_ADD(address1scaledreg,address1reg) 11350 // 117: r: INT_ADD(r,address1scaledreg) 11351 // 116: r: INT_ADD(address1scaledreg,r) 11352 // 115: szpr: INT_XOR(load32,riv) 11353 // 114: szpr: INT_XOR(r,load32) 11354 // 113: szpr: INT_XOR(r,riv) 11355 // 112: szpr: INT_USHR(riv,riv) 11356 // 111: czr: INT_SUB(load32,riv) 11357 // 110: czr: INT_SUB(riv,load32) 11358 // 109: r: INT_SUB(load32,r) 11359 // 108: r: INT_SUB(riv,r) 11360 // 107: czr: INT_SUB(riv,r) 11361 // 106: szpr: INT_SHR(riv,riv) 11362 // 105: szpr: INT_SHL(riv,riv) 11363 // 104: r: INT_REM(riv,load32) 11364 // 103: r: INT_REM(riv,riv) 11365 // 102: szpr: INT_OR(load32,riv) 11366 // 101: szpr: INT_OR(r,load32) 11367 // 100: szpr: INT_OR(r,riv) 11368 // 99: r: INT_MUL(load32,riv) 11369 // 98: r: INT_MUL(r,load32) 11370 // 97: r: INT_MUL(r,riv) 11371 // 96: r: INT_ALOAD(riv,riv) 11372 // 95: r: INT_LOAD(address1reg,address1scaledreg) 11373 // 94: r: INT_LOAD(address1scaledreg,address1reg) 11374 // 93: r: INT_LOAD(address1scaledreg,riv) 11375 // 92: r: INT_LOAD(riv,address1scaledreg) 11376 // 91: r: INT_LOAD(riv,riv) 11377 // 90: stm: INT_IFCMP2(riv,load32) 11378 // 89: stm: INT_IFCMP2(load32,riv) 11379 // 88: stm: INT_IFCMP2(r,riv) 11380 // 87: stm: INT_IFCMP(r,load32) 11381 // 86: stm: INT_IFCMP(load32,riv) 11382 // 85: stm: INT_IFCMP(r,uload8) 11383 // 84: stm: INT_IFCMP(uload8,r) 11384 // 83: stm: INT_IFCMP(r,riv) 11385 // 82: r: INT_DIV(riv,load32) 11386 // 81: r: INT_DIV(riv,riv) 11387 // 80: szp: INT_AND(r,load8_16_32) 11388 // 79: szp: INT_AND(load8_16_32,riv) 11389 // 78: szpr: INT_AND(load32,riv) 11390 // 77: szpr: INT_AND(r,load32) 11391 // 76: szp: INT_AND(r,riv) 11392 // 75: szpr: INT_AND(r,riv) 11393 // 74: czr: INT_ADD(load32,riv) 11394 // 73: czr: INT_ADD(r,load32) 11395 // 72: r: INT_ADD(r,riv) 11396 // 71: czr: INT_ADD(r,riv) 11397 // 70: boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 11398 // 69: r: BOOLEAN_CMP_LONG(rlv,rlv) 11399 // 68: boolcmp: BOOLEAN_CMP_INT(riv,load32) 11400 // 67: r: BOOLEAN_CMP_INT(r,load32) 11401 // 66: boolcmp: BOOLEAN_CMP_INT(load32,riv) 11402 // 65: r: BOOLEAN_CMP_INT(load32,riv) 11403 // 64: boolcmp: BOOLEAN_CMP_INT(r,riv) 11404 // 63: r: BOOLEAN_CMP_INT(r,riv) 11405 // 62: address: INT_ADD(address1reg,address1scaledreg) 11406 // 61: address: INT_ADD(address1scaledreg,address1reg) 11407 // 60: address: INT_ADD(address1scaledreg,r) 11408 // 59: address: INT_ADD(r,address1scaledreg) 11409 // 58: address: INT_ADD(r,r) 11410 // 57: stm: YIELDPOINT_OSR(any,any) 11411 // 56: r: SYSCALL(r,any) 11412 // 55: r: CALL(r,any) 11413 // 54: r: LONG_CMP(rlv,rlv) 11414 // 53: stm: TRAP_IF(riv,load32) 11415 // 52: stm: TRAP_IF(load32,riv) 11416 // 51: stm: TRAP_IF(r,r) 11417 // 50: any: OTHER_OPERAND(any,any) 11418 else if (eruleno <= 205) { 11419 mark(p.getChild1(), ntsrule[0]); 11420 mark(p.getChild2(), ntsrule[1]); 11421 } 11422 // 325: double_load: MATERIALIZE_FP_CONSTANT(any) 11423 // 324: float_load: MATERIALIZE_FP_CONSTANT(any) 11424 // 323: r: MATERIALIZE_FP_CONSTANT(any) 11425 // 322: double_load: LONG_BITS_AS_DOUBLE(load64) 11426 // 321: r: LONG_BITS_AS_DOUBLE(rlv) 11427 // 320: float_load: INT_BITS_AS_FLOAT(load32) 11428 // 319: r: INT_BITS_AS_FLOAT(riv) 11429 // 318: load64: DOUBLE_AS_LONG_BITS(double_load) 11430 // 317: r: DOUBLE_AS_LONG_BITS(r) 11431 // 316: load32: FLOAT_AS_INT_BITS(float_load) 11432 // 315: r: FLOAT_AS_INT_BITS(r) 11433 // 314: r: DOUBLE_2LONG(r) 11434 // 313: r: DOUBLE_2INT(r) 11435 // 312: r: FLOAT_2LONG(r) 11436 // 311: r: FLOAT_2INT(r) 11437 // 310: r: DOUBLE_2FLOAT(double_load) 11438 // 309: r: DOUBLE_2FLOAT(r) 11439 // 308: r: FLOAT_2DOUBLE(float_load) 11440 // 307: r: FLOAT_2DOUBLE(r) 11441 // 306: r: INT_2DOUBLE(load32) 11442 // 305: r: INT_2DOUBLE(riv) 11443 // 304: r: INT_2FLOAT(load32) 11444 // 303: r: INT_2FLOAT(riv) 11445 // 302: r: DOUBLE_MOVE(r) 11446 // 301: r: FLOAT_MOVE(r) 11447 // 300: r: LONG_2DOUBLE(r) 11448 // 299: r: LONG_2FLOAT(r) 11449 // 298: r: DOUBLE_SQRT(r) 11450 // 297: r: FLOAT_SQRT(r) 11451 // 296: r: DOUBLE_NEG(r) 11452 // 295: r: FLOAT_NEG(r) 11453 // 294: r: LONG_NOT(r) 11454 // 293: r: LONG_NEG(r) 11455 // 292: load64: LONG_MOVE(load64) 11456 // 291: r: LONG_MOVE(r) 11457 // 290: load32: LONG_2INT(load64) 11458 // 289: r: LONG_2INT(load64) 11459 // 288: r: LONG_2INT(r) 11460 // 287: r: INT_MOVE(address) 11461 // 286: r: INT_ADD(address,INT_CONSTANT) 11462 // 285: szpr: INT_USHR(riv,INT_CONSTANT) 11463 // 284: szpr: INT_SHR(riv,INT_CONSTANT) 11464 // 283: r: INT_SHL(r,INT_CONSTANT) 11465 // 282: szpr: INT_SHL(r,INT_CONSTANT) 11466 // 281: r: INT_NOT(r) 11467 // 280: szpr: INT_NEG(r) 11468 // 279: load32: INT_MOVE(load32) 11469 // 278: load16: INT_MOVE(load16) 11470 // 277: uload16: INT_MOVE(uload16) 11471 // 276: sload16: INT_MOVE(sload16) 11472 // 275: load8: INT_MOVE(load8) 11473 // 274: uload8: INT_MOVE(uload8) 11474 // 273: sload8: INT_MOVE(sload8) 11475 // 272: szp: INT_MOVE(szp) 11476 // 271: szpr: INT_MOVE(szpr) 11477 // 270: cz: INT_MOVE(cz) 11478 // 269: czr: INT_MOVE(czr) 11479 // 268: r: INT_MOVE(riv) 11480 // 267: r: INT_LOAD(address,INT_CONSTANT) 11481 // 266: stm: INT_IFCMP(bittest,INT_CONSTANT) 11482 // 265: stm: INT_IFCMP(szp,INT_CONSTANT) 11483 // 264: stm: INT_IFCMP(cz,INT_CONSTANT) 11484 // 263: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 11485 // 262: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 11486 // 261: stm: INT_IFCMP(sload16,INT_CONSTANT) 11487 // 260: stm: INT_IFCMP(load8,INT_CONSTANT) 11488 // 259: stm: INT_IFCMP(r,INT_CONSTANT) 11489 // 258: r: INT_2USHORT(load16_32) 11490 // 257: uload16: INT_2USHORT(load16_32) 11491 // 256: szpr: INT_2USHORT(r) 11492 // 255: sload16: INT_2SHORT(load16_32) 11493 // 254: r: INT_2SHORT(load16_32) 11494 // 253: r: INT_2SHORT(r) 11495 // 252: r: INT_2LONG(load32) 11496 // 251: r: INT_2LONG(r) 11497 // 250: r: INT_2BYTE(load8_16_32) 11498 // 249: r: INT_2BYTE(r) 11499 // 248: r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11500 // 247: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11501 // 246: r: CMP_CMOV(load32,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11502 // 245: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(INT_CONSTANT,INT_CONSTANT))) 11503 // 244: r: BOOLEAN_NOT(r) 11504 // 243: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 11505 // 242: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 11506 // 241: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 11507 // 240: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 11508 // 239: boolcmp: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 11509 // 238: r: BOOLEAN_CMP_INT(bittest,INT_CONSTANT) 11510 // 237: boolcmp: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 11511 // 236: r: BOOLEAN_CMP_INT(szp,INT_CONSTANT) 11512 // 235: boolcmp: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 11513 // 234: r: BOOLEAN_CMP_INT(cz,INT_CONSTANT) 11514 // 233: r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 11515 // 232: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 11516 // 231: r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 11517 // 230: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 11518 // 229: boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 11519 // 228: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 11520 // 227: r: ADDR_2LONG(load32) 11521 // 226: r: ADDR_2LONG(r) 11522 // 225: address1scaledreg: INT_ADD(address1scaledreg,INT_CONSTANT) 11523 // 224: address1scaledreg: INT_SHL(r,INT_CONSTANT) 11524 // 223: address1scaledreg: INT_MOVE(address1scaledreg) 11525 // 222: address1reg: INT_ADD(address1reg,INT_CONSTANT) 11526 // 221: address1reg: INT_MOVE(address1reg) 11527 // 220: address1reg: INT_MOVE(r) 11528 // 219: address1reg: INT_ADD(r,INT_CONSTANT) 11529 // 218: address: INT_ADD(address1scaledreg,INT_CONSTANT) 11530 // 217: address: INT_MOVE(address) 11531 // 216: stm: RETURN(r) 11532 // 215: stm: PREFETCH(r) 11533 // 214: r: INT_AND(load16_32,INT_CONSTANT) 11534 // 213: r: INT_2BYTE(load8_16_32) 11535 // 212: r: INT_AND(load8_16_32,INT_CONSTANT) 11536 // 211: uload8: INT_AND(load8_16_32,INT_CONSTANT) 11537 // 210: stm: TRAP_IF(r,LONG_CONSTANT) 11538 // 209: stm: TRAP_IF(r,INT_CONSTANT) 11539 // 208: stm: SET_CAUGHT_EXCEPTION(r) 11540 // 207: stm: NULL_CHECK(riv) 11541 // 206: stm: LOWTABLESWITCH(r) 11542 else if (eruleno <= 325) { 11543 mark(p.getChild1(), ntsrule[0]); 11544 } 11545 // 341: r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_CONSTANT) 11546 // 340: load32: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 11547 // 339: load32: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 11548 // 338: r: LONG_2INT(LONG_SHR(load64,INT_CONSTANT)) 11549 // 337: r: LONG_2INT(LONG_USHR(load64,INT_CONSTANT)) 11550 // 336: r: LONG_2INT(LONG_SHR(r,INT_CONSTANT)) 11551 // 335: r: LONG_2INT(LONG_USHR(r,INT_CONSTANT)) 11552 // 334: szpr: INT_SHL(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 11553 // 333: r: LONG_SHL(INT_2LONG(load64),INT_CONSTANT) 11554 // 332: r: LONG_SHL(INT_2LONG(r),INT_CONSTANT) 11555 // 331: r: LONG_AND(INT_2LONG(load32),LONG_CONSTANT) 11556 // 330: r: LONG_AND(INT_2LONG(r),LONG_CONSTANT) 11557 // 329: bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 11558 // 328: bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 11559 // 327: r: INT_USHR(INT_SHL(load16_32,INT_CONSTANT),INT_CONSTANT) 11560 // 326: r: INT_USHR(INT_SHL(load8_16_32,INT_CONSTANT),INT_CONSTANT) 11561 else if (eruleno <= 341) { 11562 mark(p.getChild1().getChild1(), ntsrule[0]); 11563 } 11564 // 404: stm: LONG_STORE(load64,OTHER_OPERAND(rlv,riv)) 11565 // 403: stm: LONG_STORE(load64,OTHER_OPERAND(riv,riv)) 11566 // 402: stm: LONG_ASTORE(load64,OTHER_OPERAND(rlv,riv)) 11567 // 401: stm: LONG_ASTORE(load64,OTHER_OPERAND(riv,riv)) 11568 // 400: r: FCMP_FCMOV(r,OTHER_OPERAND(double_load,any)) 11569 // 399: r: FCMP_FCMOV(r,OTHER_OPERAND(float_load,any)) 11570 // 398: r: FCMP_FCMOV(r,OTHER_OPERAND(r,any)) 11571 // 397: r: FCMP_CMOV(double_load,OTHER_OPERAND(r,any)) 11572 // 396: r: FCMP_CMOV(float_load,OTHER_OPERAND(r,any)) 11573 // 395: r: FCMP_CMOV(r,OTHER_OPERAND(double_load,any)) 11574 // 394: r: FCMP_CMOV(r,OTHER_OPERAND(float_load,any)) 11575 // 393: r: FCMP_CMOV(r,OTHER_OPERAND(r,any)) 11576 // 392: stm: FLOAT_ASTORE(r,OTHER_OPERAND(r,r)) 11577 // 391: stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 11578 // 390: stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,rlv)) 11579 // 389: stm: FLOAT_ASTORE(r,OTHER_OPERAND(rlv,riv)) 11580 // 388: stm: FLOAT_ASTORE(r,OTHER_OPERAND(riv,riv)) 11581 // 387: stm: FLOAT_STORE(r,OTHER_OPERAND(riv,rlv)) 11582 // 386: stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,riv)) 11583 // 385: stm: FLOAT_STORE(r,OTHER_OPERAND(rlv,rlv)) 11584 // 384: stm: FLOAT_STORE(r,OTHER_OPERAND(riv,riv)) 11585 // 383: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(r,r)) 11586 // 382: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 11587 // 381: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,rlv)) 11588 // 380: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(rlv,riv)) 11589 // 379: stm: DOUBLE_ASTORE(r,OTHER_OPERAND(riv,riv)) 11590 // 378: stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,rlv)) 11591 // 377: stm: DOUBLE_STORE(r,OTHER_OPERAND(rlv,riv)) 11592 // 376: stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,rlv)) 11593 // 375: stm: DOUBLE_STORE(r,OTHER_OPERAND(riv,riv)) 11594 // 374: stm: LONG_STORE(r,OTHER_OPERAND(riv,riv)) 11595 // 373: r: LCMP_CMOV(r,OTHER_OPERAND(rlv,any)) 11596 // 372: stm: INT_STORE(riv,OTHER_OPERAND(address1reg,address1scaledreg)) 11597 // 371: stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,address1reg)) 11598 // 370: stm: INT_STORE(riv,OTHER_OPERAND(address1scaledreg,riv)) 11599 // 369: stm: INT_STORE(riv,OTHER_OPERAND(riv,address1scaledreg)) 11600 // 368: stm: INT_STORE(riv,OTHER_OPERAND(riv,riv)) 11601 // 367: r: CMP_CMOV(riv,OTHER_OPERAND(load32,any)) 11602 // 366: r: CMP_CMOV(load32,OTHER_OPERAND(riv,any)) 11603 // 365: r: CMP_CMOV(riv,OTHER_OPERAND(uload8,any)) 11604 // 364: r: CMP_CMOV(uload8,OTHER_OPERAND(riv,any)) 11605 // 363: r: CMP_CMOV(r,OTHER_OPERAND(riv,any)) 11606 // 362: stm: BYTE_ASTORE(load8,OTHER_OPERAND(riv,riv)) 11607 // 361: stm: BYTE_ASTORE(riv,OTHER_OPERAND(riv,riv)) 11608 // 360: stm: BYTE_STORE(load8,OTHER_OPERAND(riv,riv)) 11609 // 359: stm: BYTE_STORE(riv,OTHER_OPERAND(riv,riv)) 11610 // 358: stm: BYTE_ASTORE(boolcmp,OTHER_OPERAND(riv,riv)) 11611 // 357: stm: BYTE_STORE(boolcmp,OTHER_OPERAND(riv,riv)) 11612 // 356: stm: LONG_ASTORE(r,OTHER_OPERAND(r,r)) 11613 // 355: stm: LONG_ASTORE(r,OTHER_OPERAND(rlv,rlv)) 11614 // 354: stm: LONG_ASTORE(r,OTHER_OPERAND(riv,riv)) 11615 // 353: stm: INT_ASTORE(riv,OTHER_OPERAND(riv,rlv)) 11616 // 352: stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,riv)) 11617 // 351: stm: INT_ASTORE(riv,OTHER_OPERAND(rlv,rlv)) 11618 // 350: stm: INT_ASTORE(riv,OTHER_OPERAND(r,r)) 11619 // 349: stm: INT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 11620 // 348: stm: SHORT_ASTORE(riv,OTHER_OPERAND(r,r)) 11621 // 347: stm: SHORT_ASTORE(load16,OTHER_OPERAND(riv,riv)) 11622 // 346: stm: SHORT_ASTORE(riv,OTHER_OPERAND(riv,riv)) 11623 // 345: stm: SHORT_STORE(riv,OTHER_OPERAND(rlv,rlv)) 11624 // 344: stm: SHORT_STORE(rlv,OTHER_OPERAND(rlv,rlv)) 11625 // 343: stm: SHORT_STORE(load16,OTHER_OPERAND(riv,riv)) 11626 // 342: stm: SHORT_STORE(riv,OTHER_OPERAND(riv,riv)) 11627 else if (eruleno <= 404) { 11628 mark(p.getChild1(), ntsrule[0]); 11629 mark(p.getChild2().getChild1(), ntsrule[1]); 11630 mark(p.getChild2().getChild2(), ntsrule[2]); 11631 } 11632 // 407: stm: LONG_STORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 11633 // 406: stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(rlv,riv)) 11634 // 405: stm: LONG_ASTORE(LONG_CONSTANT,OTHER_OPERAND(riv,riv)) 11635 else if (eruleno <= 407) { 11636 mark(p.getChild2().getChild1(), ntsrule[0]); 11637 mark(p.getChild2().getChild2(), ntsrule[1]); 11638 } 11639 // 410: r: SYSCALL(INT_CONSTANT,any) 11640 // 409: r: CALL(INT_CONSTANT,any) 11641 // 408: r: CALL(BRANCH_TARGET,any) 11642 else if (eruleno <= 410) { 11643 mark(p.getChild2(), ntsrule[0]); 11644 } 11645 // 413: r: SYSCALL(INT_LOAD(riv,riv),any) 11646 // 412: r: CALL(LONG_LOAD(rlv,rlv),any) 11647 // 411: r: CALL(INT_LOAD(riv,riv),any) 11648 else if (eruleno <= 413) { 11649 mark(p.getChild1().getChild1(), ntsrule[0]); 11650 mark(p.getChild1().getChild2(), ntsrule[1]); 11651 mark(p.getChild2(), ntsrule[2]); 11652 } 11653 // 425: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(double_load,r))) 11654 // 424: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(float_load,r))) 11655 // 423: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,double_load))) 11656 // 422: r: FCMP_FCMOV(r,OTHER_OPERAND(r,OTHER_OPERAND(r,float_load))) 11657 // 421: r: ATTEMPT_LONG(riv,OTHER_OPERAND(riv,OTHER_OPERAND(rlv,rlv))) 11658 // 420: r: ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 11659 // 419: r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))) 11660 // 418: r: ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))) 11661 // 417: r: ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))) 11662 // 416: r: ATTEMPT_INT(rlv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 11663 // 415: r: ATTEMPT_INT(riv,OTHER_OPERAND(rlv,OTHER_OPERAND(riv,riv))) 11664 // 414: r: ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))) 11665 else if (eruleno <= 425) { 11666 mark(p.getChild1(), ntsrule[0]); 11667 mark(p.getChild2().getChild1(), ntsrule[1]); 11668 mark(p.getChild2().getChild2().getChild1(), ntsrule[2]); 11669 mark(p.getChild2().getChild2().getChild2(), ntsrule[3]); 11670 } 11671 // 426: r: ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))) 11672 else if (eruleno <= 426) { 11673 mark(p.getChild1(), ntsrule[0]); 11674 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 11675 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 11676 } 11677 // 427: r: ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))) 11678 else if (eruleno <= 427) { 11679 mark(p.getChild2().getChild1(), ntsrule[0]); 11680 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 11681 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 11682 } 11683 // 437: stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11684 // 436: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11685 // 435: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11686 // 434: stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11687 // 433: stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11688 // 432: stm: INT_IFCMP(ATTEMPT_INT(address1reg,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11689 // 431: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(address1reg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11690 // 430: stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg,OTHER_OPERAND(r,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11691 // 429: stm: INT_IFCMP(ATTEMPT_INT(r,OTHER_OPERAND(address1scaledreg,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11692 // 428: stm: INT_IFCMP(ATTEMPT_INT(riv,OTHER_OPERAND(riv,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11693 else if (eruleno <= 437) { 11694 mark(p.getChild1().getChild1(), ntsrule[0]); 11695 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 11696 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[2]); 11697 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[3]); 11698 } 11699 // 439: stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11700 // 438: stm: INT_IFCMP(ATTEMPT_INT(address,OTHER_OPERAND(INT_CONSTANT,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11701 else if (eruleno <= 439) { 11702 mark(p.getChild1().getChild1(), ntsrule[0]); 11703 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[1]); 11704 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[2]); 11705 } 11706 // 441: stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11707 // 440: stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT,OTHER_OPERAND(address,OTHER_OPERAND(riv,riv))),INT_CONSTANT) 11708 else if (eruleno <= 441) { 11709 mark(p.getChild1().getChild2().getChild1(), ntsrule[0]); 11710 mark(p.getChild1().getChild2().getChild2().getChild1(), ntsrule[1]); 11711 mark(p.getChild1().getChild2().getChild2().getChild2(), ntsrule[2]); 11712 } 11713 // 445: bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 11714 // 444: bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 11715 // 443: bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 11716 // 442: bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 11717 else if (eruleno <= 445) { 11718 mark(p.getChild1().getChild1(), ntsrule[0]); 11719 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 11720 } 11721 // 447: bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT)),load32) 11722 // 446: bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 11723 else if (eruleno <= 447) { 11724 mark(p.getChild1().getChild2().getChild1(), ntsrule[0]); 11725 mark(p.getChild2(), ntsrule[1]); 11726 } 11727 // 449: bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 11728 // 448: bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r,INT_CONSTANT))) 11729 else if (eruleno <= 449) { 11730 mark(p.getChild1(), ntsrule[0]); 11731 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 11732 } 11733 // 465: stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11734 // 464: stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11735 // 463: stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11736 // 462: stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11737 // 461: stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11738 // 460: stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11739 // 459: stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11740 // 458: stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11741 // 457: stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11742 // 456: stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_CONSTANT),OTHER_OPERAND(riv,riv)) 11743 // 455: stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11744 // 454: stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11745 // 453: stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11746 // 452: stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11747 // 451: stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11748 // 450: stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11749 else if (eruleno <= 465) { 11750 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 11751 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 11752 mark(p.getChild2().getChild1(), ntsrule[2]); 11753 mark(p.getChild2().getChild2(), ntsrule[3]); 11754 } 11755 // 473: r: CMP_CMOV(szp,OTHER_OPERAND(INT_CONSTANT,any)) 11756 // 472: r: CMP_CMOV(cz,OTHER_OPERAND(INT_CONSTANT,any)) 11757 // 471: r: CMP_CMOV(bittest,OTHER_OPERAND(INT_CONSTANT,any)) 11758 // 470: r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 11759 // 469: r: CMP_CMOV(boolcmp,OTHER_OPERAND(INT_CONSTANT,any)) 11760 // 468: r: CMP_CMOV(sload16,OTHER_OPERAND(INT_CONSTANT,any)) 11761 // 467: r: CMP_CMOV(load8,OTHER_OPERAND(INT_CONSTANT,any)) 11762 // 466: r: CMP_CMOV(r,OTHER_OPERAND(INT_CONSTANT,any)) 11763 else if (eruleno <= 473) { 11764 mark(p.getChild1(), ntsrule[0]); 11765 mark(p.getChild2().getChild2(), ntsrule[1]); 11766 } 11767 // 481: stm: INT_ASTORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 11768 // 480: stm: INT_STORE(LONG_2INT(r),OTHER_OPERAND(riv,riv)) 11769 // 479: stm: SHORT_ASTORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 11770 // 478: stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(riv,riv)) 11771 // 477: stm: SHORT_ASTORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 11772 // 476: stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(riv,riv)) 11773 // 475: stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 11774 // 474: stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv,riv)) 11775 else if (eruleno <= 481) { 11776 mark(p.getChild1().getChild1(), ntsrule[0]); 11777 mark(p.getChild2().getChild1(), ntsrule[1]); 11778 mark(p.getChild2().getChild2(), ntsrule[2]); 11779 } 11780 // 501: stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11781 // 500: stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11782 // 499: stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11783 // 498: stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11784 // 497: stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11785 // 496: stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11786 // 495: stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11787 // 494: stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11788 // 493: stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11789 // 492: stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv,rlv)) 11790 // 491: stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11791 // 490: stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11792 // 489: stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11793 // 488: stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11794 // 487: stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11795 // 486: stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11796 // 485: stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11797 // 484: stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11798 // 483: stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11799 // 482: stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv,riv)) 11800 else if (eruleno <= 501) { 11801 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 11802 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 11803 mark(p.getChild1().getChild2(), ntsrule[2]); 11804 mark(p.getChild2().getChild1(), ntsrule[3]); 11805 mark(p.getChild2().getChild2(), ntsrule[4]); 11806 } 11807 // 519: stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11808 // 518: stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11809 // 517: stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11810 // 516: stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11811 // 515: stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11812 // 514: stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11813 // 513: stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11814 // 512: stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv,rlv)) 11815 // 511: stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11816 // 510: stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11817 // 509: stm: INT_ASTORE(INT_SUB(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11818 // 508: stm: INT_STORE(INT_SUB(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11819 // 507: stm: INT_ASTORE(INT_OR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11820 // 506: stm: INT_STORE(INT_OR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11821 // 505: stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11822 // 504: stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11823 // 503: stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11824 // 502: stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv,riv)) 11825 else if (eruleno <= 519) { 11826 mark(p.getChild1().getChild1(), ntsrule[0]); 11827 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 11828 mark(p.getChild1().getChild2().getChild2(), ntsrule[2]); 11829 mark(p.getChild2().getChild1(), ntsrule[3]); 11830 mark(p.getChild2().getChild2(), ntsrule[4]); 11831 } 11832 // 525: r: LONG_MUL(INT_2LONG(riv),INT_2LONG(riv)) 11833 // 524: r: LONG_MUL(LONG_AND(rlv,LONG_CONSTANT),LONG_AND(rlv,LONG_CONSTANT)) 11834 // 523: r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 11835 // 522: r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 11836 // 521: r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 11837 // 520: r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 11838 else if (eruleno <= 525) { 11839 mark(p.getChild1().getChild1(), ntsrule[0]); 11840 mark(p.getChild2().getChild1(), ntsrule[1]); 11841 } 11842 // 527: r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 11843 // 526: r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 11844 else if (eruleno <= 527) { 11845 mark(p.getChild1().getChild1(), ntsrule[0]); 11846 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 11847 mark(p.getChild2().getChild1(), ntsrule[2]); 11848 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[3]); 11849 } 11850 // 529: r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 11851 // 528: r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 11852 else if (eruleno <= 529) { 11853 mark(p.getChild1().getChild1(), ntsrule[0]); 11854 mark(p.getChild1().getChild2().getChild1().getChild1(), ntsrule[1]); 11855 mark(p.getChild2().getChild1(), ntsrule[2]); 11856 mark(p.getChild2().getChild2().getChild1(), ntsrule[3]); 11857 } 11858 // 536: r: LONG_USHR(rlv,INT_AND(riv,INT_CONSTANT)) 11859 // 535: r: LONG_SHR(rlv,INT_AND(riv,INT_CONSTANT)) 11860 // 534: r: LONG_SHL(rlv,INT_AND(riv,INT_CONSTANT)) 11861 // 533: szpr: INT_USHR(riv,INT_AND(r,INT_CONSTANT)) 11862 // 532: stm: INT_STORE(riv,OTHER_OPERAND(address,INT_CONSTANT)) 11863 // 531: szpr: INT_SHR(riv,INT_AND(r,INT_CONSTANT)) 11864 // 530: szpr: INT_SHL(riv,INT_AND(r,INT_CONSTANT)) 11865 else if (eruleno <= 536) { 11866 mark(p.getChild1(), ntsrule[0]); 11867 mark(p.getChild2().getChild1(), ntsrule[1]); 11868 } 11869 // 542: stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11870 // 541: stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11871 // 540: stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11872 // 539: stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11873 // 538: stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11874 // 537: stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv,riv)) 11875 else if (eruleno <= 542) { 11876 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 11877 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 11878 mark(p.getChild1().getChild2().getChild1(), ntsrule[2]); 11879 mark(p.getChild2().getChild1(), ntsrule[3]); 11880 mark(p.getChild2().getChild2(), ntsrule[4]); 11881 } 11882 // 546: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11883 // 545: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11884 // 544: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11885 // 543: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,FLOAT_NEG(r)))) 11886 else if (eruleno <= 546) { 11887 mark(p.getChild1(), ntsrule[0]); 11888 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 11889 mark(p.getChild2().getChild2().getChild2().getChild1(), ntsrule[2]); 11890 } 11891 // 550: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11892 // 549: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(DOUBLE_NEG(r),r))) 11893 // 548: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11894 // 547: r: FCMP_FCMOV(r,OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(FLOAT_NEG(r),r))) 11895 else if (eruleno <= 550) { 11896 mark(p.getChild1(), ntsrule[0]); 11897 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[1]); 11898 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 11899 } 11900 // 554: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11901 // 553: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(DOUBLE_NEG(r),r))) 11902 // 552: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11903 // 551: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(FLOAT_NEG(r),r))) 11904 else if (eruleno <= 554) { 11905 mark(p.getChild2().getChild1(), ntsrule[0]); 11906 mark(p.getChild2().getChild2().getChild1().getChild1(), ntsrule[1]); 11907 mark(p.getChild2().getChild2().getChild2(), ntsrule[2]); 11908 } 11909 // 558: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11910 // 557: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,DOUBLE_NEG(r)))) 11911 // 556: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11912 // 555: r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT),OTHER_OPERAND(r,OTHER_OPERAND(r,FLOAT_NEG(r)))) 11913 else { 11914 if (VM.VerifyAssertions) VM._assert(eruleno <= 558); 11915 mark(p.getChild2().getChild1(), ntsrule[0]); 11916 mark(p.getChild2().getChild2().getChild1(), ntsrule[1]); 11917 mark(p.getChild2().getChild2().getChild2().getChild1(), ntsrule[2]); 11918 } 11919 } 11920 11921 /** 11922 * For each BURS rule (the number of which provides the index) give its flags byte 11923 */ 11924 private static final byte[] action={ 11925 0, 11926 NOFLAGS, // 1 - stm: r 11927 NOFLAGS, // 2 - r: REGISTER 11928 NOFLAGS, // 3 - r: czr 11929 NOFLAGS, // 4 - cz: czr 11930 NOFLAGS, // 5 - r: szpr 11931 NOFLAGS, // 6 - szp: szpr 11932 NOFLAGS, // 7 - riv: r 11933 NOFLAGS, // 8 - riv: INT_CONSTANT 11934 NOFLAGS, // 9 - rlv: r 11935 NOFLAGS, // 10 - rlv: LONG_CONSTANT 11936 NOFLAGS, // 11 - any: NULL 11937 NOFLAGS, // 12 - any: riv 11938 NOFLAGS, // 13 - any: ADDRESS_CONSTANT 11939 NOFLAGS, // 14 - any: LONG_CONSTANT 11940 NOFLAGS, // 15 - any: OTHER_OPERAND(any, any) 11941 EMIT_INSTRUCTION, // 16 - stm: IG_PATCH_POINT 11942 EMIT_INSTRUCTION, // 17 - stm: UNINT_BEGIN 11943 EMIT_INSTRUCTION, // 18 - stm: UNINT_END 11944 EMIT_INSTRUCTION, // 19 - stm: YIELDPOINT_PROLOGUE 11945 EMIT_INSTRUCTION, // 20 - stm: YIELDPOINT_EPILOGUE 11946 EMIT_INSTRUCTION, // 21 - stm: YIELDPOINT_BACKEDGE 11947 EMIT_INSTRUCTION, // 22 - stm: LOWTABLESWITCH(r) 11948 EMIT_INSTRUCTION, // 23 - stm: RESOLVE 11949 NOFLAGS, // 24 - stm: NOP 11950 EMIT_INSTRUCTION, // 25 - r: GUARD_MOVE 11951 EMIT_INSTRUCTION, // 26 - r: GUARD_COMBINE 11952 EMIT_INSTRUCTION, // 27 - stm: NULL_CHECK(riv) 11953 EMIT_INSTRUCTION, // 28 - stm: IR_PROLOGUE 11954 EMIT_INSTRUCTION, // 29 - r: GET_CAUGHT_EXCEPTION 11955 EMIT_INSTRUCTION, // 30 - stm: SET_CAUGHT_EXCEPTION(r) 11956 EMIT_INSTRUCTION, // 31 - stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 11957 EMIT_INSTRUCTION, // 32 - stm: TRAP 11958 EMIT_INSTRUCTION, // 33 - stm: TRAP_IF(r, INT_CONSTANT) 11959 EMIT_INSTRUCTION, // 34 - stm: TRAP_IF(r, LONG_CONSTANT) 11960 EMIT_INSTRUCTION, // 35 - stm: TRAP_IF(r, r) 11961 EMIT_INSTRUCTION, // 36 - stm: TRAP_IF(load32, riv) 11962 EMIT_INSTRUCTION, // 37 - stm: TRAP_IF(riv, load32) 11963 EMIT_INSTRUCTION, // 38 - uload8: INT_AND(load8_16_32, INT_CONSTANT) 11964 EMIT_INSTRUCTION, // 39 - r: INT_AND(load8_16_32, INT_CONSTANT) 11965 EMIT_INSTRUCTION, // 40 - r: INT_2BYTE(load8_16_32) 11966 EMIT_INSTRUCTION, // 41 - r: INT_USHR(INT_SHL(load8_16_32, INT_CONSTANT), INT_CONSTANT) 11967 EMIT_INSTRUCTION, // 42 - r: INT_AND(load16_32, INT_CONSTANT) 11968 EMIT_INSTRUCTION, // 43 - r: INT_USHR(INT_SHL(load16_32, INT_CONSTANT), INT_CONSTANT) 11969 EMIT_INSTRUCTION, // 44 - stm: SHORT_STORE(riv, OTHER_OPERAND(riv, riv)) 11970 EMIT_INSTRUCTION, // 45 - stm: SHORT_STORE(load16, OTHER_OPERAND(riv, riv)) 11971 EMIT_INSTRUCTION, // 46 - stm: SHORT_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 11972 EMIT_INSTRUCTION, // 47 - stm: SHORT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 11973 EMIT_INSTRUCTION, // 48 - stm: SHORT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 11974 EMIT_INSTRUCTION, // 49 - stm: SHORT_ASTORE(load16, OTHER_OPERAND(riv, riv)) 11975 EMIT_INSTRUCTION, // 50 - stm: SHORT_ASTORE(riv, OTHER_OPERAND(r, r)) 11976 EMIT_INSTRUCTION, // 51 - stm: INT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 11977 EMIT_INSTRUCTION, // 52 - stm: INT_ASTORE(riv, OTHER_OPERAND(r, r)) 11978 EMIT_INSTRUCTION, // 53 - stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, rlv)) 11979 EMIT_INSTRUCTION, // 54 - stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 11980 EMIT_INSTRUCTION, // 55 - stm: INT_ASTORE(riv, OTHER_OPERAND(riv, rlv)) 11981 EMIT_INSTRUCTION, // 56 - stm: LONG_ASTORE(r, OTHER_OPERAND(riv, riv)) 11982 EMIT_INSTRUCTION, // 57 - stm: LONG_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 11983 EMIT_INSTRUCTION, // 58 - stm: LONG_ASTORE(r, OTHER_OPERAND(r, r)) 11984 EMIT_INSTRUCTION, // 59 - stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 11985 EMIT_INSTRUCTION, // 60 - stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(rlv, riv)) 11986 EMIT_INSTRUCTION, // 61 - r: LONG_CMP(rlv,rlv) 11987 EMIT_INSTRUCTION, // 62 - stm: GOTO 11988 EMIT_INSTRUCTION, // 63 - stm: PREFETCH(r) 11989 EMIT_INSTRUCTION, // 64 - stm: WRITE_FLOOR 11990 EMIT_INSTRUCTION, // 65 - stm: READ_CEILING 11991 EMIT_INSTRUCTION, // 66 - stm: FENCE 11992 EMIT_INSTRUCTION, // 67 - stm: PAUSE 11993 EMIT_INSTRUCTION, // 68 - stm: RETURN(NULL) 11994 EMIT_INSTRUCTION, // 69 - stm: RETURN(INT_CONSTANT) 11995 EMIT_INSTRUCTION, // 70 - stm: RETURN(r) 11996 EMIT_INSTRUCTION, // 71 - stm: RETURN(LONG_CONSTANT) 11997 EMIT_INSTRUCTION, // 72 - r: CALL(r, any) 11998 EMIT_INSTRUCTION, // 73 - r: CALL(BRANCH_TARGET, any) 11999 EMIT_INSTRUCTION, // 74 - r: CALL(INT_LOAD(riv, riv), any) 12000 EMIT_INSTRUCTION, // 75 - r: CALL(INT_CONSTANT, any) 12001 EMIT_INSTRUCTION, // 76 - r: CALL(LONG_LOAD(rlv, rlv), any) 12002 EMIT_INSTRUCTION, // 77 - r: SYSCALL(r, any) 12003 EMIT_INSTRUCTION, // 78 - r: SYSCALL(INT_LOAD(riv, riv), any) 12004 EMIT_INSTRUCTION, // 79 - r: SYSCALL(INT_CONSTANT, any) 12005 EMIT_INSTRUCTION, // 80 - r: GET_TIME_BASE 12006 EMIT_INSTRUCTION, // 81 - stm: YIELDPOINT_OSR(any, any) 12007 NOFLAGS, // 82 - address: address1scaledreg 12008 NOFLAGS, // 83 - address: INT_MOVE(address) 12009 EMIT_INSTRUCTION, // 84 - address: INT_ADD(r, r) 12010 EMIT_INSTRUCTION, // 85 - address: INT_ADD(r, address1scaledreg) 12011 EMIT_INSTRUCTION, // 86 - address: INT_ADD(address1scaledreg, r) 12012 EMIT_INSTRUCTION, // 87 - address: INT_ADD(address1scaledreg, INT_CONSTANT) 12013 EMIT_INSTRUCTION, // 88 - address: INT_ADD(address1scaledreg, address1reg) 12014 EMIT_INSTRUCTION, // 89 - address: INT_ADD(address1reg, address1scaledreg) 12015 EMIT_INSTRUCTION, // 90 - address1reg: INT_ADD(r, INT_CONSTANT) 12016 EMIT_INSTRUCTION, // 91 - address1reg: INT_MOVE(r) 12017 NOFLAGS, // 92 - address1reg: INT_MOVE(address1reg) 12018 EMIT_INSTRUCTION, // 93 - address1reg: INT_ADD(address1reg, INT_CONSTANT) 12019 NOFLAGS, // 94 - address1scaledreg: address1reg 12020 NOFLAGS, // 95 - address1scaledreg: INT_MOVE(address1scaledreg) 12021 EMIT_INSTRUCTION, // 96 - address1scaledreg: INT_SHL(r, INT_CONSTANT) 12022 EMIT_INSTRUCTION, // 97 - address1scaledreg: INT_ADD(address1scaledreg, INT_CONSTANT) 12023 EMIT_INSTRUCTION, // 98 - r: ADDR_2LONG(r) 12024 EMIT_INSTRUCTION, // 99 - r: ADDR_2LONG(load32) 12025 EMIT_INSTRUCTION, // 100 - r: ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv, riv))) 12026 EMIT_INSTRUCTION, // 101 - r: ATTEMPT_INT(riv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 12027 EMIT_INSTRUCTION, // 102 - r: ATTEMPT_INT(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 12028 EMIT_INSTRUCTION, // 103 - r: ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 12029 EMIT_INSTRUCTION, // 104 - r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv, riv))) 12030 EMIT_INSTRUCTION, // 105 - r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv, riv))) 12031 EMIT_INSTRUCTION, // 106 - r: ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 12032 EMIT_INSTRUCTION, // 107 - r: ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv, riv))) 12033 EMIT_INSTRUCTION, // 108 - r: ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv, riv))) 12034 EMIT_INSTRUCTION, // 109 - stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12035 EMIT_INSTRUCTION, // 110 - stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12036 EMIT_INSTRUCTION, // 111 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12037 EMIT_INSTRUCTION, // 112 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12038 EMIT_INSTRUCTION, // 113 - stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12039 EMIT_INSTRUCTION, // 114 - stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12040 EMIT_INSTRUCTION, // 115 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12041 EMIT_INSTRUCTION, // 116 - stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))), INT_CONSTANT) 12042 EMIT_INSTRUCTION, // 117 - stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12043 EMIT_INSTRUCTION, // 118 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12044 EMIT_INSTRUCTION, // 119 - stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12045 EMIT_INSTRUCTION, // 120 - stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12046 EMIT_INSTRUCTION, // 121 - stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12047 EMIT_INSTRUCTION, // 122 - stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 12048 EMIT_INSTRUCTION, // 123 - r: ATTEMPT_LONG(riv, OTHER_OPERAND(riv, OTHER_OPERAND(rlv, rlv))) 12049 EMIT_INSTRUCTION, // 124 - bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12050 EMIT_INSTRUCTION, // 125 - bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12051 EMIT_INSTRUCTION, // 126 - bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 12052 EMIT_INSTRUCTION, // 127 - bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12053 EMIT_INSTRUCTION, // 128 - bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 12054 EMIT_INSTRUCTION, // 129 - bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 12055 EMIT_INSTRUCTION, // 130 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 12056 EMIT_INSTRUCTION, // 131 - bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT)),load32) 12057 EMIT_INSTRUCTION, // 132 - bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 12058 EMIT_INSTRUCTION, // 133 - bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 12059 EMIT_INSTRUCTION, // 134 - r: BOOLEAN_CMP_INT(r,riv) 12060 EMIT_INSTRUCTION, // 135 - boolcmp: BOOLEAN_CMP_INT(r,riv) 12061 EMIT_INSTRUCTION, // 136 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12062 EMIT_INSTRUCTION, // 137 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12063 EMIT_INSTRUCTION, // 138 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12064 EMIT_INSTRUCTION, // 139 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 12065 EMIT_INSTRUCTION, // 140 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 12066 EMIT_INSTRUCTION, // 141 - r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 12067 EMIT_INSTRUCTION, // 142 - r: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 12068 EMIT_INSTRUCTION, // 143 - boolcmp: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 12069 EMIT_INSTRUCTION, // 144 - r: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 12070 EMIT_INSTRUCTION, // 145 - boolcmp: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 12071 EMIT_INSTRUCTION, // 146 - r: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 12072 EMIT_INSTRUCTION, // 147 - boolcmp: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 12073 EMIT_INSTRUCTION, // 148 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 12074 NOFLAGS, // 149 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 12075 EMIT_INSTRUCTION, // 150 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 12076 EMIT_INSTRUCTION, // 151 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 12077 EMIT_INSTRUCTION, // 152 - r: BOOLEAN_CMP_INT(load32,riv) 12078 EMIT_INSTRUCTION, // 153 - boolcmp: BOOLEAN_CMP_INT(load32,riv) 12079 EMIT_INSTRUCTION, // 154 - r: BOOLEAN_CMP_INT(r,load32) 12080 EMIT_INSTRUCTION, // 155 - boolcmp: BOOLEAN_CMP_INT(riv,load32) 12081 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 156 - stm: BYTE_STORE(boolcmp, OTHER_OPERAND(riv,riv)) 12082 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 157 - stm: BYTE_ASTORE(boolcmp, OTHER_OPERAND(riv, riv)) 12083 EMIT_INSTRUCTION, // 158 - r: BOOLEAN_CMP_LONG(rlv,rlv) 12084 EMIT_INSTRUCTION, // 159 - boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 12085 EMIT_INSTRUCTION, // 160 - r: BOOLEAN_NOT(r) 12086 EMIT_INSTRUCTION, // 161 - stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12087 EMIT_INSTRUCTION, // 162 - stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12088 EMIT_INSTRUCTION, // 163 - stm: BYTE_STORE(riv, OTHER_OPERAND(riv, riv)) 12089 EMIT_INSTRUCTION, // 164 - stm: BYTE_STORE(load8, OTHER_OPERAND(riv, riv)) 12090 EMIT_INSTRUCTION, // 165 - stm: BYTE_ASTORE(riv, OTHER_OPERAND(riv, riv)) 12091 EMIT_INSTRUCTION, // 166 - stm: BYTE_ASTORE(load8, OTHER_OPERAND(riv, riv)) 12092 EMIT_INSTRUCTION, // 167 - r: CMP_CMOV(r, OTHER_OPERAND(riv, any)) 12093 EMIT_INSTRUCTION, // 168 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 12094 EMIT_INSTRUCTION, // 169 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 12095 EMIT_INSTRUCTION, // 170 - r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 12096 EMIT_INSTRUCTION, // 171 - r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 12097 EMIT_INSTRUCTION, // 172 - r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 12098 EMIT_INSTRUCTION, // 173 - r: CMP_CMOV(load8, OTHER_OPERAND(INT_CONSTANT, any)) 12099 EMIT_INSTRUCTION, // 174 - r: CMP_CMOV(uload8, OTHER_OPERAND(riv, any)) 12100 EMIT_INSTRUCTION, // 175 - r: CMP_CMOV(riv, OTHER_OPERAND(uload8, any)) 12101 EMIT_INSTRUCTION, // 176 - r: CMP_CMOV(sload16, OTHER_OPERAND(INT_CONSTANT, any)) 12102 EMIT_INSTRUCTION, // 177 - r: CMP_CMOV(load32, OTHER_OPERAND(riv, any)) 12103 EMIT_INSTRUCTION, // 178 - r: CMP_CMOV(riv, OTHER_OPERAND(load32, any)) 12104 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 179 - r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 12105 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 180 - r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 12106 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 181 - r: CMP_CMOV(bittest, OTHER_OPERAND(INT_CONSTANT, any)) 12107 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 182 - r: CMP_CMOV(cz, OTHER_OPERAND(INT_CONSTANT, any)) 12108 EMIT_INSTRUCTION | RIGHT_CHILD_FIRST, // 183 - r: CMP_CMOV(szp, OTHER_OPERAND(INT_CONSTANT, any)) 12109 EMIT_INSTRUCTION, // 184 - r: INT_2BYTE(r) 12110 EMIT_INSTRUCTION, // 185 - r: INT_2BYTE(load8_16_32) 12111 EMIT_INSTRUCTION, // 186 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 12112 EMIT_INSTRUCTION, // 187 - stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 12113 EMIT_INSTRUCTION, // 188 - r: INT_2LONG(r) 12114 EMIT_INSTRUCTION, // 189 - r: INT_2LONG(load32) 12115 EMIT_INSTRUCTION, // 190 - r: LONG_AND(INT_2LONG(r), LONG_CONSTANT) 12116 EMIT_INSTRUCTION, // 191 - r: LONG_AND(INT_2LONG(load32), LONG_CONSTANT) 12117 EMIT_INSTRUCTION, // 192 - r: LONG_SHL(INT_2LONG(r), INT_CONSTANT) 12118 EMIT_INSTRUCTION, // 193 - r: LONG_SHL(INT_2LONG(load64), INT_CONSTANT) 12119 EMIT_INSTRUCTION, // 194 - r: INT_2SHORT(r) 12120 EMIT_INSTRUCTION, // 195 - r: INT_2SHORT(load16_32) 12121 EMIT_INSTRUCTION, // 196 - sload16: INT_2SHORT(load16_32) 12122 EMIT_INSTRUCTION, // 197 - stm: SHORT_STORE(INT_2SHORT(r), OTHER_OPERAND(riv,riv)) 12123 EMIT_INSTRUCTION, // 198 - stm: SHORT_ASTORE(INT_2SHORT(r), OTHER_OPERAND(riv, riv)) 12124 EMIT_INSTRUCTION, // 199 - szpr: INT_2USHORT(r) 12125 EMIT_INSTRUCTION, // 200 - uload16: INT_2USHORT(load16_32) 12126 EMIT_INSTRUCTION, // 201 - r: INT_2USHORT(load16_32) 12127 EMIT_INSTRUCTION, // 202 - stm: SHORT_STORE(INT_2USHORT(r), OTHER_OPERAND(riv,riv)) 12128 EMIT_INSTRUCTION, // 203 - stm: SHORT_ASTORE(INT_2USHORT(r), OTHER_OPERAND(riv, riv)) 12129 EMIT_INSTRUCTION, // 204 - czr: INT_ADD(r, riv) 12130 EMIT_INSTRUCTION, // 205 - r: INT_ADD(r, riv) 12131 EMIT_INSTRUCTION, // 206 - czr: INT_ADD(r, load32) 12132 EMIT_INSTRUCTION, // 207 - czr: INT_ADD(load32, riv) 12133 EMIT_INSTRUCTION, // 208 - stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12134 EMIT_INSTRUCTION, // 209 - stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12135 EMIT_INSTRUCTION, // 210 - stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12136 EMIT_INSTRUCTION, // 211 - stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12137 EMIT_INSTRUCTION, // 212 - szpr: INT_AND(r, riv) 12138 EMIT_INSTRUCTION, // 213 - szp: INT_AND(r, riv) 12139 EMIT_INSTRUCTION, // 214 - szpr: INT_AND(r, load32) 12140 EMIT_INSTRUCTION, // 215 - szpr: INT_AND(load32, riv) 12141 EMIT_INSTRUCTION, // 216 - szp: INT_AND(load8_16_32, riv) 12142 EMIT_INSTRUCTION, // 217 - szp: INT_AND(r, load8_16_32) 12143 EMIT_INSTRUCTION, // 218 - stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12144 EMIT_INSTRUCTION, // 219 - stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12145 EMIT_INSTRUCTION, // 220 - stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12146 EMIT_INSTRUCTION, // 221 - stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12147 EMIT_INSTRUCTION, // 222 - r: INT_DIV(riv, riv) 12148 EMIT_INSTRUCTION, // 223 - r: INT_DIV(riv, load32) 12149 EMIT_INSTRUCTION, // 224 - stm: INT_IFCMP(r,riv) 12150 EMIT_INSTRUCTION, // 225 - stm: INT_IFCMP(r, INT_CONSTANT) 12151 EMIT_INSTRUCTION, // 226 - stm: INT_IFCMP(load8, INT_CONSTANT) 12152 EMIT_INSTRUCTION, // 227 - stm: INT_IFCMP(uload8, r) 12153 EMIT_INSTRUCTION, // 228 - stm: INT_IFCMP(r, uload8) 12154 EMIT_INSTRUCTION, // 229 - stm: INT_IFCMP(sload16, INT_CONSTANT) 12155 EMIT_INSTRUCTION, // 230 - stm: INT_IFCMP(load32, riv) 12156 EMIT_INSTRUCTION, // 231 - stm: INT_IFCMP(r, load32) 12157 EMIT_INSTRUCTION, // 232 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 12158 EMIT_INSTRUCTION, // 233 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 12159 EMIT_INSTRUCTION, // 234 - stm: INT_IFCMP(cz, INT_CONSTANT) 12160 EMIT_INSTRUCTION, // 235 - stm: INT_IFCMP(szp, INT_CONSTANT) 12161 EMIT_INSTRUCTION, // 236 - stm: INT_IFCMP(bittest, INT_CONSTANT) 12162 EMIT_INSTRUCTION, // 237 - stm: INT_IFCMP2(r,riv) 12163 EMIT_INSTRUCTION, // 238 - stm: INT_IFCMP2(load32,riv) 12164 EMIT_INSTRUCTION, // 239 - stm: INT_IFCMP2(riv,load32) 12165 EMIT_INSTRUCTION, // 240 - r: INT_LOAD(riv, riv) 12166 EMIT_INSTRUCTION, // 241 - r: INT_LOAD(riv, address1scaledreg) 12167 EMIT_INSTRUCTION, // 242 - r: INT_LOAD(address1scaledreg, riv) 12168 EMIT_INSTRUCTION, // 243 - r: INT_LOAD(address1scaledreg, address1reg) 12169 EMIT_INSTRUCTION, // 244 - r: INT_LOAD(address1reg, address1scaledreg) 12170 EMIT_INSTRUCTION, // 245 - r: INT_LOAD(address, INT_CONSTANT) 12171 EMIT_INSTRUCTION, // 246 - r: INT_ALOAD(riv, riv) 12172 EMIT_INSTRUCTION, // 247 - r: INT_MOVE(riv) 12173 EMIT_INSTRUCTION, // 248 - czr: INT_MOVE(czr) 12174 NOFLAGS, // 249 - cz: INT_MOVE(cz) 12175 EMIT_INSTRUCTION, // 250 - szpr: INT_MOVE(szpr) 12176 NOFLAGS, // 251 - szp: INT_MOVE(szp) 12177 NOFLAGS, // 252 - sload8: INT_MOVE(sload8) 12178 NOFLAGS, // 253 - uload8: INT_MOVE(uload8) 12179 NOFLAGS, // 254 - load8: INT_MOVE(load8) 12180 NOFLAGS, // 255 - sload16: INT_MOVE(sload16) 12181 NOFLAGS, // 256 - uload16: INT_MOVE(uload16) 12182 NOFLAGS, // 257 - load16: INT_MOVE(load16) 12183 NOFLAGS, // 258 - load32: INT_MOVE(load32) 12184 EMIT_INSTRUCTION, // 259 - r: INT_MUL(r, riv) 12185 EMIT_INSTRUCTION, // 260 - r: INT_MUL(r, load32) 12186 EMIT_INSTRUCTION, // 261 - r: INT_MUL(load32, riv) 12187 EMIT_INSTRUCTION, // 262 - szpr: INT_NEG(r) 12188 EMIT_INSTRUCTION, // 263 - stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12189 EMIT_INSTRUCTION, // 264 - stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12190 EMIT_INSTRUCTION, // 265 - r: INT_NOT(r) 12191 EMIT_INSTRUCTION, // 266 - stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12192 EMIT_INSTRUCTION, // 267 - stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12193 EMIT_INSTRUCTION, // 268 - szpr: INT_OR(r, riv) 12194 EMIT_INSTRUCTION, // 269 - szpr: INT_OR(r, load32) 12195 EMIT_INSTRUCTION, // 270 - szpr: INT_OR(load32, riv) 12196 EMIT_INSTRUCTION, // 271 - stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12197 EMIT_INSTRUCTION, // 272 - stm: INT_STORE(INT_OR(r, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12198 EMIT_INSTRUCTION, // 273 - stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12199 EMIT_INSTRUCTION, // 274 - stm: INT_ASTORE(INT_OR(r, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12200 EMIT_INSTRUCTION, // 275 - r: INT_REM(riv, riv) 12201 EMIT_INSTRUCTION, // 276 - r: INT_REM(riv, load32) 12202 EMIT_INSTRUCTION, // 277 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 12203 EMIT_INSTRUCTION, // 278 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 12204 EMIT_INSTRUCTION, // 279 - r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 12205 EMIT_INSTRUCTION, // 280 - r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 12206 EMIT_INSTRUCTION, // 281 - r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 12207 EMIT_INSTRUCTION, // 282 - r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 12208 EMIT_INSTRUCTION, // 283 - r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 12209 EMIT_INSTRUCTION, // 284 - r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 12210 EMIT_INSTRUCTION, // 285 - szpr: INT_SHL(riv, INT_AND(r, INT_CONSTANT)) 12211 EMIT_INSTRUCTION, // 286 - szpr: INT_SHL(riv, riv) 12212 EMIT_INSTRUCTION, // 287 - szpr: INT_SHL(r, INT_CONSTANT) 12213 EMIT_INSTRUCTION, // 288 - r: INT_SHL(r, INT_CONSTANT) 12214 EMIT_INSTRUCTION, // 289 - szpr: INT_SHL(INT_SHR(r, INT_CONSTANT), INT_CONSTANT) 12215 EMIT_INSTRUCTION, // 290 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12216 EMIT_INSTRUCTION, // 291 - stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12217 EMIT_INSTRUCTION, // 292 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12218 EMIT_INSTRUCTION, // 293 - stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12219 EMIT_INSTRUCTION, // 294 - szpr: INT_SHR(riv, INT_AND(r, INT_CONSTANT)) 12220 EMIT_INSTRUCTION, // 295 - szpr: INT_SHR(riv, riv) 12221 EMIT_INSTRUCTION, // 296 - szpr: INT_SHR(riv, INT_CONSTANT) 12222 EMIT_INSTRUCTION, // 297 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12223 EMIT_INSTRUCTION, // 298 - stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12224 EMIT_INSTRUCTION, // 299 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12225 EMIT_INSTRUCTION, // 300 - stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12226 EMIT_INSTRUCTION, // 301 - stm: INT_STORE(riv, OTHER_OPERAND(riv, riv)) 12227 EMIT_INSTRUCTION, // 302 - stm: INT_STORE(riv, OTHER_OPERAND(riv, address1scaledreg)) 12228 EMIT_INSTRUCTION, // 303 - stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, riv)) 12229 EMIT_INSTRUCTION, // 304 - stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, address1reg)) 12230 EMIT_INSTRUCTION, // 305 - stm: INT_STORE(riv, OTHER_OPERAND(address1reg, address1scaledreg)) 12231 EMIT_INSTRUCTION, // 306 - stm: INT_STORE(riv, OTHER_OPERAND(address, INT_CONSTANT)) 12232 EMIT_INSTRUCTION, // 307 - czr: INT_SUB(riv, r) 12233 EMIT_INSTRUCTION, // 308 - r: INT_SUB(riv, r) 12234 EMIT_INSTRUCTION, // 309 - r: INT_SUB(load32, r) 12235 EMIT_INSTRUCTION, // 310 - czr: INT_SUB(riv, load32) 12236 EMIT_INSTRUCTION, // 311 - czr: INT_SUB(load32, riv) 12237 EMIT_INSTRUCTION, // 312 - stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12238 EMIT_INSTRUCTION, // 313 - stm: INT_STORE(INT_SUB(riv, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12239 EMIT_INSTRUCTION, // 314 - stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12240 EMIT_INSTRUCTION, // 315 - stm: INT_ASTORE(INT_SUB(riv, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12241 EMIT_INSTRUCTION, // 316 - szpr: INT_USHR(riv, INT_AND(r, INT_CONSTANT)) 12242 EMIT_INSTRUCTION, // 317 - szpr: INT_USHR(riv, riv) 12243 EMIT_INSTRUCTION, // 318 - szpr: INT_USHR(riv, INT_CONSTANT) 12244 EMIT_INSTRUCTION, // 319 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12245 EMIT_INSTRUCTION, // 320 - stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12246 EMIT_INSTRUCTION, // 321 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 12247 EMIT_INSTRUCTION, // 322 - stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 12248 EMIT_INSTRUCTION, // 323 - szpr: INT_XOR(r, riv) 12249 EMIT_INSTRUCTION, // 324 - szpr: INT_XOR(r, load32) 12250 EMIT_INSTRUCTION, // 325 - szpr: INT_XOR(load32, riv) 12251 EMIT_INSTRUCTION, // 326 - stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12252 EMIT_INSTRUCTION, // 327 - stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12253 EMIT_INSTRUCTION, // 328 - stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 12254 EMIT_INSTRUCTION, // 329 - stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12255 EMIT_INSTRUCTION, // 330 - r: LCMP_CMOV(r, OTHER_OPERAND(rlv, any)) 12256 EMIT_INSTRUCTION, // 331 - r: INT_ADD(address1scaledreg, r) 12257 EMIT_INSTRUCTION, // 332 - r: INT_ADD(r, address1scaledreg) 12258 EMIT_INSTRUCTION, // 333 - r: INT_ADD(address1scaledreg, address1reg) 12259 EMIT_INSTRUCTION, // 334 - r: INT_ADD(address1reg, address1scaledreg) 12260 EMIT_INSTRUCTION, // 335 - r: INT_ADD(address, INT_CONSTANT) 12261 EMIT_INSTRUCTION, // 336 - r: INT_MOVE(address) 12262 EMIT_INSTRUCTION, // 337 - r: BYTE_LOAD(riv, riv) 12263 EMIT_INSTRUCTION, // 338 - sload8: BYTE_LOAD(riv, riv) 12264 EMIT_INSTRUCTION, // 339 - r: BYTE_ALOAD(riv, riv) 12265 EMIT_INSTRUCTION, // 340 - sload8: BYTE_ALOAD(riv, riv) 12266 EMIT_INSTRUCTION, // 341 - r: UBYTE_LOAD(riv, riv) 12267 EMIT_INSTRUCTION, // 342 - uload8: UBYTE_LOAD(riv, riv) 12268 EMIT_INSTRUCTION, // 343 - r: UBYTE_ALOAD(riv, riv) 12269 EMIT_INSTRUCTION, // 344 - uload8: UBYTE_ALOAD(riv, riv) 12270 NOFLAGS, // 345 - load8: sload8 12271 NOFLAGS, // 346 - load8: uload8 12272 EMIT_INSTRUCTION, // 347 - r: SHORT_LOAD(riv, riv) 12273 EMIT_INSTRUCTION, // 348 - sload16: SHORT_LOAD(riv, riv) 12274 EMIT_INSTRUCTION, // 349 - r: SHORT_ALOAD(riv, riv) 12275 EMIT_INSTRUCTION, // 350 - sload16: SHORT_ALOAD(riv, riv) 12276 EMIT_INSTRUCTION, // 351 - r: USHORT_LOAD(riv, riv) 12277 EMIT_INSTRUCTION, // 352 - uload16: USHORT_LOAD(riv, riv) 12278 EMIT_INSTRUCTION, // 353 - r: USHORT_ALOAD(riv, riv) 12279 EMIT_INSTRUCTION, // 354 - uload16: USHORT_ALOAD(riv, riv) 12280 NOFLAGS, // 355 - load16: sload16 12281 NOFLAGS, // 356 - load16: uload16 12282 EMIT_INSTRUCTION, // 357 - load32: INT_LOAD(riv, riv) 12283 EMIT_INSTRUCTION, // 358 - load32: INT_ALOAD(riv, riv) 12284 NOFLAGS, // 359 - load16_32: load16 12285 NOFLAGS, // 360 - load16_32: load32 12286 NOFLAGS, // 361 - load8_16_32: load16_32 12287 NOFLAGS, // 362 - load8_16_32: load8 12288 EMIT_INSTRUCTION, // 363 - load64: LONG_LOAD(riv, riv) 12289 EMIT_INSTRUCTION, // 364 - load64: LONG_ALOAD(riv, riv) 12290 EMIT_INSTRUCTION, // 365 - r: LONG_2INT(r) 12291 EMIT_INSTRUCTION, // 366 - stm: INT_STORE(LONG_2INT(r), OTHER_OPERAND(riv,riv)) 12292 EMIT_INSTRUCTION, // 367 - stm: INT_ASTORE(LONG_2INT(r), OTHER_OPERAND(riv, riv)) 12293 EMIT_INSTRUCTION, // 368 - r: LONG_2INT(load64) 12294 EMIT_INSTRUCTION, // 369 - load32: LONG_2INT(load64) 12295 EMIT_INSTRUCTION, // 370 - r: LONG_2INT(LONG_USHR(r, INT_CONSTANT)) 12296 EMIT_INSTRUCTION, // 371 - r: LONG_2INT(LONG_SHR(r, INT_CONSTANT)) 12297 EMIT_INSTRUCTION, // 372 - r: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 12298 EMIT_INSTRUCTION, // 373 - r: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 12299 EMIT_INSTRUCTION, // 374 - load32: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 12300 EMIT_INSTRUCTION, // 375 - load32: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 12301 EMIT_INSTRUCTION, // 376 - r: LONG_ADD(r, rlv) 12302 EMIT_INSTRUCTION, // 377 - r: LONG_ADD(r, load64) 12303 EMIT_INSTRUCTION, // 378 - r: LONG_ADD(load64, rlv) 12304 EMIT_INSTRUCTION, // 379 - stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12305 EMIT_INSTRUCTION, // 380 - stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12306 EMIT_INSTRUCTION, // 381 - stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12307 EMIT_INSTRUCTION, // 382 - stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12308 EMIT_INSTRUCTION, // 383 - r: LONG_AND(r, rlv) 12309 EMIT_INSTRUCTION, // 384 - r: LONG_AND(r, load64) 12310 EMIT_INSTRUCTION, // 385 - r: LONG_AND(load64, rlv) 12311 EMIT_INSTRUCTION, // 386 - stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12312 EMIT_INSTRUCTION, // 387 - stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12313 EMIT_INSTRUCTION, // 388 - stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12314 EMIT_INSTRUCTION, // 389 - stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12315 EMIT_INSTRUCTION, // 390 - stm: LONG_IFCMP(r,rlv) 12316 EMIT_INSTRUCTION, // 391 - r: LONG_LOAD(riv, riv) 12317 EMIT_INSTRUCTION, // 392 - r: LONG_ALOAD(riv, riv) 12318 EMIT_INSTRUCTION, // 393 - r: LONG_MOVE(r) 12319 EMIT_INSTRUCTION, // 394 - r: LONG_MOVE(LONG_CONSTANT) 12320 NOFLAGS, // 395 - load64: LONG_MOVE(load64) 12321 EMIT_INSTRUCTION, // 396 - r: LONG_MUL(r, rlv) 12322 EMIT_INSTRUCTION, // 397 - r: LONG_MUL(LONG_AND(rlv, LONG_CONSTANT), LONG_AND(rlv, LONG_CONSTANT)) 12323 EMIT_INSTRUCTION, // 398 - r: LONG_MUL(LONG_AND(rlv, LONG_CONSTANT), LONG_CONSTANT) 12324 EMIT_INSTRUCTION, // 399 - r: LONG_MUL(INT_2LONG(riv), INT_2LONG(riv)) 12325 EMIT_INSTRUCTION, // 400 - r: LONG_NEG(r) 12326 EMIT_INSTRUCTION, // 401 - stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12327 EMIT_INSTRUCTION, // 402 - stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12328 EMIT_INSTRUCTION, // 403 - r: LONG_NOT(r) 12329 EMIT_INSTRUCTION, // 404 - stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12330 EMIT_INSTRUCTION, // 405 - stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 12331 EMIT_INSTRUCTION, // 406 - r: LONG_OR(r, rlv) 12332 EMIT_INSTRUCTION, // 407 - r: LONG_OR(r, load64) 12333 EMIT_INSTRUCTION, // 408 - r: LONG_OR(load64, rlv) 12334 EMIT_INSTRUCTION, // 409 - stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12335 EMIT_INSTRUCTION, // 410 - stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12336 EMIT_INSTRUCTION, // 411 - stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12337 EMIT_INSTRUCTION, // 412 - stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12338 EMIT_INSTRUCTION, // 413 - r: LONG_SHL(rlv, riv) 12339 EMIT_INSTRUCTION, // 414 - r: LONG_SHL(rlv, INT_AND(riv, INT_CONSTANT)) 12340 EMIT_INSTRUCTION, // 415 - r: LONG_SHR(rlv, riv) 12341 EMIT_INSTRUCTION, // 416 - r: LONG_SHR(rlv, INT_AND(riv, INT_CONSTANT)) 12342 EMIT_INSTRUCTION, // 417 - stm: LONG_STORE(r, OTHER_OPERAND(riv, riv)) 12343 EMIT_INSTRUCTION, // 418 - stm: LONG_STORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 12344 EMIT_INSTRUCTION, // 419 - r: LONG_SUB(rlv, rlv) 12345 EMIT_INSTRUCTION, // 420 - r: LONG_SUB(rlv, load64) 12346 EMIT_INSTRUCTION, // 421 - r: LONG_SUB(load64, rlv) 12347 EMIT_INSTRUCTION, // 422 - stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12348 EMIT_INSTRUCTION, // 423 - stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12349 EMIT_INSTRUCTION, // 424 - r: LONG_USHR(rlv, riv) 12350 EMIT_INSTRUCTION, // 425 - r: LONG_USHR(rlv, INT_AND(riv, INT_CONSTANT)) 12351 EMIT_INSTRUCTION, // 426 - r: LONG_XOR(r, rlv) 12352 EMIT_INSTRUCTION, // 427 - r: LONG_XOR(r, load64) 12353 EMIT_INSTRUCTION, // 428 - r: LONG_XOR(load64, rlv) 12354 EMIT_INSTRUCTION, // 429 - stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12355 EMIT_INSTRUCTION, // 430 - stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12356 EMIT_INSTRUCTION, // 431 - stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 12357 EMIT_INSTRUCTION, // 432 - stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 12358 EMIT_INSTRUCTION, // 433 - r: FLOAT_ADD(r, r) 12359 EMIT_INSTRUCTION, // 434 - r: FLOAT_ADD(r, float_load) 12360 EMIT_INSTRUCTION, // 435 - r: FLOAT_ADD(float_load,r) 12361 EMIT_INSTRUCTION, // 436 - r: DOUBLE_ADD(r, r) 12362 EMIT_INSTRUCTION, // 437 - r: DOUBLE_ADD(r, double_load) 12363 EMIT_INSTRUCTION, // 438 - r: DOUBLE_ADD(double_load,r) 12364 EMIT_INSTRUCTION, // 439 - r: FLOAT_SUB(r, r) 12365 EMIT_INSTRUCTION, // 440 - r: FLOAT_SUB(r, float_load) 12366 EMIT_INSTRUCTION, // 441 - r: DOUBLE_SUB(r, r) 12367 EMIT_INSTRUCTION, // 442 - r: DOUBLE_SUB(r, double_load) 12368 EMIT_INSTRUCTION, // 443 - r: FLOAT_MUL(r, r) 12369 EMIT_INSTRUCTION, // 444 - r: FLOAT_MUL(r, float_load) 12370 EMIT_INSTRUCTION, // 445 - r: FLOAT_MUL(float_load, r) 12371 EMIT_INSTRUCTION, // 446 - r: DOUBLE_MUL(r, r) 12372 EMIT_INSTRUCTION, // 447 - r: DOUBLE_MUL(r, double_load) 12373 EMIT_INSTRUCTION, // 448 - r: DOUBLE_MUL(double_load, r) 12374 EMIT_INSTRUCTION, // 449 - r: FLOAT_DIV(r, r) 12375 EMIT_INSTRUCTION, // 450 - r: FLOAT_DIV(r, float_load) 12376 EMIT_INSTRUCTION, // 451 - r: DOUBLE_DIV(r, r) 12377 EMIT_INSTRUCTION, // 452 - r: DOUBLE_DIV(r, double_load) 12378 EMIT_INSTRUCTION, // 453 - r: FLOAT_NEG(r) 12379 EMIT_INSTRUCTION, // 454 - r: DOUBLE_NEG(r) 12380 EMIT_INSTRUCTION, // 455 - r: FLOAT_SQRT(r) 12381 EMIT_INSTRUCTION, // 456 - r: DOUBLE_SQRT(r) 12382 EMIT_INSTRUCTION, // 457 - r: FLOAT_REM(r, r) 12383 EMIT_INSTRUCTION, // 458 - r: DOUBLE_REM(r, r) 12384 EMIT_INSTRUCTION, // 459 - r: LONG_2FLOAT(r) 12385 EMIT_INSTRUCTION, // 460 - r: LONG_2DOUBLE(r) 12386 EMIT_INSTRUCTION, // 461 - r: FLOAT_MOVE(r) 12387 EMIT_INSTRUCTION, // 462 - r: DOUBLE_MOVE(r) 12388 EMIT_INSTRUCTION, // 463 - r: DOUBLE_LOAD(riv, riv) 12389 EMIT_INSTRUCTION, // 464 - r: DOUBLE_LOAD(riv, rlv) 12390 EMIT_INSTRUCTION, // 465 - r: DOUBLE_LOAD(rlv, rlv) 12391 EMIT_INSTRUCTION, // 466 - double_load: DOUBLE_LOAD(riv, riv) 12392 EMIT_INSTRUCTION, // 467 - r: DOUBLE_ALOAD(riv, riv) 12393 EMIT_INSTRUCTION, // 468 - double_load: DOUBLE_LOAD(rlv, rlv) 12394 EMIT_INSTRUCTION, // 469 - r: DOUBLE_ALOAD(riv, r) 12395 EMIT_INSTRUCTION, // 470 - r: DOUBLE_ALOAD(rlv, rlv) 12396 EMIT_INSTRUCTION, // 471 - double_load: DOUBLE_ALOAD(riv, riv) 12397 EMIT_INSTRUCTION, // 472 - r: FLOAT_LOAD(riv, riv) 12398 EMIT_INSTRUCTION, // 473 - r: FLOAT_LOAD(rlv, rlv) 12399 EMIT_INSTRUCTION, // 474 - float_load: FLOAT_LOAD(riv, riv) 12400 EMIT_INSTRUCTION, // 475 - r: FLOAT_ALOAD(riv, riv) 12401 EMIT_INSTRUCTION, // 476 - r: FLOAT_ALOAD(riv, r) 12402 EMIT_INSTRUCTION, // 477 - r: FLOAT_ALOAD(rlv, rlv) 12403 EMIT_INSTRUCTION, // 478 - float_load: FLOAT_ALOAD(riv, riv) 12404 EMIT_INSTRUCTION, // 479 - stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, riv)) 12405 EMIT_INSTRUCTION, // 480 - stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, rlv)) 12406 EMIT_INSTRUCTION, // 481 - stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, riv)) 12407 EMIT_INSTRUCTION, // 482 - stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, rlv)) 12408 EMIT_INSTRUCTION, // 483 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, riv)) 12409 EMIT_INSTRUCTION, // 484 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, riv)) 12410 EMIT_INSTRUCTION, // 485 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, rlv)) 12411 EMIT_INSTRUCTION, // 486 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 12412 EMIT_INSTRUCTION, // 487 - stm: DOUBLE_ASTORE(r, OTHER_OPERAND(r, r)) 12413 EMIT_INSTRUCTION, // 488 - stm: FLOAT_STORE(r, OTHER_OPERAND(riv, riv)) 12414 EMIT_INSTRUCTION, // 489 - stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, rlv)) 12415 EMIT_INSTRUCTION, // 490 - stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, riv)) 12416 EMIT_INSTRUCTION, // 491 - stm: FLOAT_STORE(r, OTHER_OPERAND(riv, rlv)) 12417 EMIT_INSTRUCTION, // 492 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, riv)) 12418 EMIT_INSTRUCTION, // 493 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, riv)) 12419 EMIT_INSTRUCTION, // 494 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, rlv)) 12420 EMIT_INSTRUCTION, // 495 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 12421 EMIT_INSTRUCTION, // 496 - stm: FLOAT_ASTORE(r, OTHER_OPERAND(r, r)) 12422 EMIT_INSTRUCTION, // 497 - r: INT_2FLOAT(riv) 12423 EMIT_INSTRUCTION, // 498 - r: INT_2FLOAT(load32) 12424 EMIT_INSTRUCTION, // 499 - r: INT_2DOUBLE(riv) 12425 EMIT_INSTRUCTION, // 500 - r: INT_2DOUBLE(load32) 12426 EMIT_INSTRUCTION, // 501 - r: FLOAT_2DOUBLE(r) 12427 EMIT_INSTRUCTION, // 502 - r: FLOAT_2DOUBLE(float_load) 12428 EMIT_INSTRUCTION, // 503 - r: DOUBLE_2FLOAT(r) 12429 EMIT_INSTRUCTION, // 504 - r: DOUBLE_2FLOAT(double_load) 12430 EMIT_INSTRUCTION, // 505 - r: FLOAT_2INT(r) 12431 EMIT_INSTRUCTION, // 506 - r: FLOAT_2LONG(r) 12432 EMIT_INSTRUCTION, // 507 - r: DOUBLE_2INT(r) 12433 EMIT_INSTRUCTION, // 508 - r: DOUBLE_2LONG(r) 12434 EMIT_INSTRUCTION, // 509 - r: FLOAT_AS_INT_BITS(r) 12435 NOFLAGS, // 510 - load32: FLOAT_AS_INT_BITS(float_load) 12436 EMIT_INSTRUCTION, // 511 - r: DOUBLE_AS_LONG_BITS(r) 12437 NOFLAGS, // 512 - load64: DOUBLE_AS_LONG_BITS(double_load) 12438 EMIT_INSTRUCTION, // 513 - r: INT_BITS_AS_FLOAT(riv) 12439 NOFLAGS, // 514 - float_load: INT_BITS_AS_FLOAT(load32) 12440 EMIT_INSTRUCTION, // 515 - r: LONG_BITS_AS_DOUBLE(rlv) 12441 NOFLAGS, // 516 - double_load: LONG_BITS_AS_DOUBLE(load64) 12442 EMIT_INSTRUCTION, // 517 - r: MATERIALIZE_FP_CONSTANT(any) 12443 EMIT_INSTRUCTION, // 518 - float_load: MATERIALIZE_FP_CONSTANT(any) 12444 EMIT_INSTRUCTION, // 519 - double_load: MATERIALIZE_FP_CONSTANT(any) 12445 EMIT_INSTRUCTION, // 520 - stm: CLEAR_FLOATING_POINT_STATE 12446 EMIT_INSTRUCTION, // 521 - stm: FLOAT_IFCMP(r,r) 12447 EMIT_INSTRUCTION, // 522 - stm: FLOAT_IFCMP(r,float_load) 12448 EMIT_INSTRUCTION, // 523 - stm: FLOAT_IFCMP(float_load,r) 12449 EMIT_INSTRUCTION, // 524 - stm: DOUBLE_IFCMP(r,r) 12450 EMIT_INSTRUCTION, // 525 - stm: DOUBLE_IFCMP(r,double_load) 12451 EMIT_INSTRUCTION, // 526 - stm: DOUBLE_IFCMP(double_load,r) 12452 EMIT_INSTRUCTION, // 527 - r: FCMP_CMOV(r, OTHER_OPERAND(r, any)) 12453 EMIT_INSTRUCTION, // 528 - r: FCMP_CMOV(r, OTHER_OPERAND(float_load, any)) 12454 EMIT_INSTRUCTION, // 529 - r: FCMP_CMOV(r, OTHER_OPERAND(double_load, any)) 12455 EMIT_INSTRUCTION, // 530 - r: FCMP_CMOV(float_load, OTHER_OPERAND(r, any)) 12456 EMIT_INSTRUCTION, // 531 - r: FCMP_CMOV(double_load, OTHER_OPERAND(r, any)) 12457 EMIT_INSTRUCTION, // 532 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, any)) 12458 EMIT_INSTRUCTION, // 533 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, float_load))) 12459 EMIT_INSTRUCTION, // 534 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, double_load))) 12460 EMIT_INSTRUCTION, // 535 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(float_load, r))) 12461 EMIT_INSTRUCTION, // 536 - r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(double_load, r))) 12462 EMIT_INSTRUCTION, // 537 - r: FCMP_FCMOV(r, OTHER_OPERAND(float_load, any)) 12463 EMIT_INSTRUCTION, // 538 - r: FCMP_FCMOV(r, OTHER_OPERAND(double_load, any)) 12464 EMIT_INSTRUCTION, // 539 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 12465 EMIT_INSTRUCTION, // 540 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 12466 EMIT_INSTRUCTION, // 541 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 12467 EMIT_INSTRUCTION, // 542 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 12468 EMIT_INSTRUCTION, // 543 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 12469 EMIT_INSTRUCTION, // 544 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 12470 EMIT_INSTRUCTION, // 545 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 12471 EMIT_INSTRUCTION, // 546 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 12472 EMIT_INSTRUCTION, // 547 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 12473 EMIT_INSTRUCTION, // 548 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 12474 EMIT_INSTRUCTION, // 549 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 12475 EMIT_INSTRUCTION, // 550 - r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 12476 EMIT_INSTRUCTION, // 551 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 12477 EMIT_INSTRUCTION, // 552 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 12478 EMIT_INSTRUCTION, // 553 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 12479 EMIT_INSTRUCTION, // 554 - r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 12480 EMIT_INSTRUCTION, // 555 - stm: LONG_ASTORE(load64, OTHER_OPERAND(riv, riv)) 12481 EMIT_INSTRUCTION, // 556 - stm: LONG_ASTORE(load64, OTHER_OPERAND(rlv, riv)) 12482 EMIT_INSTRUCTION, // 557 - stm: LONG_STORE(load64, OTHER_OPERAND(riv, riv)) 12483 EMIT_INSTRUCTION, // 558 - stm: LONG_STORE(load64, OTHER_OPERAND(rlv, riv)) 12484 }; 12485 12486 /** 12487 * Gets the action flags (such as EMIT_INSTRUCTION) associated with the given 12488 * rule number. 12489 * 12490 * @param ruleno the rule number we want the action flags for 12491 * @return the action byte for the rule 12492 */ 12493 @Pure 12494 public static byte action(int ruleno) { 12495 return action[unsortedErnMap[ruleno]]; 12496 } 12497 12498 /** 12499 * Decode the target non-terminal and minimal cost covering statement 12500 * into the rule that produces the non-terminal 12501 * 12502 * @param goalnt the non-terminal that we wish to produce. 12503 * @param stateNT the state encoding the non-terminals associated associated 12504 * with covering a tree with minimal cost (computed by at compile time 12505 * by jburg). 12506 * @return the rule number 12507 */ 12508 @Pure 12509 public static char decode(int goalnt, int stateNT) { 12510 return decode[goalnt][stateNT]; 12511 } 12512 12513 12514 /** 12515 * Emit code for rule number 16: 12516 * stm: IG_PATCH_POINT 12517 * @param p BURS node to apply the rule to 12518 */ 12519 private void code16(AbstractBURS_TreeNode p) { 12520 EMIT(InlineGuard.mutate(P(p), IG_PATCH_POINT, null, null, null, InlineGuard.getTarget(P(p)), InlineGuard.getBranchProfile(P(p)))); 12521 } 12522 12523 /** 12524 * Emit code for rule number 17: 12525 * stm: UNINT_BEGIN 12526 * @param p BURS node to apply the rule to 12527 */ 12528 private void code17(AbstractBURS_TreeNode p) { 12529 EMIT(P(p)); 12530 } 12531 12532 /** 12533 * Emit code for rule number 18: 12534 * stm: UNINT_END 12535 * @param p BURS node to apply the rule to 12536 */ 12537 private void code18(AbstractBURS_TreeNode p) { 12538 EMIT(P(p)); 12539 } 12540 12541 /** 12542 * Emit code for rule number 19: 12543 * stm: YIELDPOINT_PROLOGUE 12544 * @param p BURS node to apply the rule to 12545 */ 12546 private void code19(AbstractBURS_TreeNode p) { 12547 EMIT(P(p)); 12548 } 12549 12550 /** 12551 * Emit code for rule number 20: 12552 * stm: YIELDPOINT_EPILOGUE 12553 * @param p BURS node to apply the rule to 12554 */ 12555 private void code20(AbstractBURS_TreeNode p) { 12556 EMIT(P(p)); 12557 } 12558 12559 /** 12560 * Emit code for rule number 21: 12561 * stm: YIELDPOINT_BACKEDGE 12562 * @param p BURS node to apply the rule to 12563 */ 12564 private void code21(AbstractBURS_TreeNode p) { 12565 EMIT(P(p)); 12566 } 12567 12568 /** 12569 * Emit code for rule number 22: 12570 * stm: LOWTABLESWITCH(r) 12571 * @param p BURS node to apply the rule to 12572 */ 12573 private void code22(AbstractBURS_TreeNode p) { 12574 LOWTABLESWITCH(P(p)); 12575 } 12576 12577 /** 12578 * Emit code for rule number 23: 12579 * stm: RESOLVE 12580 * @param p BURS node to apply the rule to 12581 */ 12582 private void code23(AbstractBURS_TreeNode p) { 12583 RESOLVE(P(p)); 12584 } 12585 12586 /** 12587 * Emit code for rule number 25: 12588 * r: GUARD_MOVE 12589 * @param p BURS node to apply the rule to 12590 */ 12591 private void code25(AbstractBURS_TreeNode p) { 12592 EMIT(P(p)); 12593 } 12594 12595 /** 12596 * Emit code for rule number 26: 12597 * r: GUARD_COMBINE 12598 * @param p BURS node to apply the rule to 12599 */ 12600 private void code26(AbstractBURS_TreeNode p) { 12601 EMIT(P(p)); 12602 } 12603 12604 /** 12605 * Emit code for rule number 27: 12606 * stm: NULL_CHECK(riv) 12607 * @param p BURS node to apply the rule to 12608 */ 12609 private void code27(AbstractBURS_TreeNode p) { 12610 EMIT(P(p)); 12611 } 12612 12613 /** 12614 * Emit code for rule number 28: 12615 * stm: IR_PROLOGUE 12616 * @param p BURS node to apply the rule to 12617 */ 12618 private void code28(AbstractBURS_TreeNode p) { 12619 PROLOGUE(P(p)); 12620 } 12621 12622 /** 12623 * Emit code for rule number 29: 12624 * r: GET_CAUGHT_EXCEPTION 12625 * @param p BURS node to apply the rule to 12626 */ 12627 private void code29(AbstractBURS_TreeNode p) { 12628 GET_EXCEPTION_OBJECT(P(p)); 12629 } 12630 12631 /** 12632 * Emit code for rule number 30: 12633 * stm: SET_CAUGHT_EXCEPTION(r) 12634 * @param p BURS node to apply the rule to 12635 */ 12636 private void code30(AbstractBURS_TreeNode p) { 12637 SET_EXCEPTION_OBJECT(P(p)); 12638 } 12639 12640 /** 12641 * Emit code for rule number 31: 12642 * stm: SET_CAUGHT_EXCEPTION(INT_CONSTANT) 12643 * @param p BURS node to apply the rule to 12644 */ 12645 private void code31(AbstractBURS_TreeNode p) { 12646 SET_EXCEPTION_OBJECT(P(p)); 12647 } 12648 12649 /** 12650 * Emit code for rule number 32: 12651 * stm: TRAP 12652 * @param p BURS node to apply the rule to 12653 */ 12654 private void code32(AbstractBURS_TreeNode p) { 12655 EMIT(MIR_Trap.mutate(P(p), IA32_INT, Trap.getGuardResult(P(p)), Trap.getTCode(P(p)))); 12656 } 12657 12658 /** 12659 * Emit code for rule number 33: 12660 * stm: TRAP_IF(r, INT_CONSTANT) 12661 * @param p BURS node to apply the rule to 12662 */ 12663 private void code33(AbstractBURS_TreeNode p) { 12664 TRAP_IF_IMM(P(p), false); 12665 } 12666 12667 /** 12668 * Emit code for rule number 34: 12669 * stm: TRAP_IF(r, LONG_CONSTANT) 12670 * @param p BURS node to apply the rule to 12671 */ 12672 private void code34(AbstractBURS_TreeNode p) { 12673 TRAP_IF_IMM(P(p), true); 12674 } 12675 12676 /** 12677 * Emit code for rule number 35: 12678 * stm: TRAP_IF(r, r) 12679 * @param p BURS node to apply the rule to 12680 */ 12681 private void code35(AbstractBURS_TreeNode p) { 12682 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 12683 TrapIf.getGuardResult(P(p)), 12684 TrapIf.getVal1(P(p)), 12685 TrapIf.getVal2(P(p)), 12686 COND(TrapIf.getCond(P(p))), 12687 TrapIf.getTCode(P(p)))); 12688 } 12689 12690 /** 12691 * Emit code for rule number 36: 12692 * stm: TRAP_IF(load32, riv) 12693 * @param p BURS node to apply the rule to 12694 */ 12695 private void code36(AbstractBURS_TreeNode p) { 12696 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 12697 TrapIf.getGuardResult(P(p)), 12698 consumeMO(), 12699 TrapIf.getVal2(P(p)), 12700 COND(TrapIf.getCond(P(p))), 12701 TrapIf.getTCode(P(p)))); 12702 } 12703 12704 /** 12705 * Emit code for rule number 37: 12706 * stm: TRAP_IF(riv, load32) 12707 * @param p BURS node to apply the rule to 12708 */ 12709 private void code37(AbstractBURS_TreeNode p) { 12710 EMIT(MIR_TrapIf.mutate(P(p), IA32_TRAPIF, 12711 TrapIf.getGuardResult(P(p)), 12712 TrapIf.getVal1(P(p)), 12713 consumeMO(), 12714 COND(TrapIf.getCond(P(p))), 12715 TrapIf.getTCode(P(p)))); 12716 } 12717 12718 /** 12719 * Emit code for rule number 38: 12720 * uload8: INT_AND(load8_16_32, INT_CONSTANT) 12721 * @param p BURS node to apply the rule to 12722 */ 12723 private void code38(AbstractBURS_TreeNode p) { 12724 pushMO(setSize(consumeMO(),1)); 12725 } 12726 12727 /** 12728 * Emit code for rule number 39: 12729 * r: INT_AND(load8_16_32, INT_CONSTANT) 12730 * @param p BURS node to apply the rule to 12731 */ 12732 private void code39(AbstractBURS_TreeNode p) { 12733 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Binary.getResult(P(p)), setSize(consumeMO(),1))); 12734 } 12735 12736 /** 12737 * Emit code for rule number 40: 12738 * r: INT_2BYTE(load8_16_32) 12739 * @param p BURS node to apply the rule to 12740 */ 12741 private void code40(AbstractBURS_TreeNode p) { 12742 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), setSize(consumeMO(),1))); 12743 } 12744 12745 /** 12746 * Emit code for rule number 41: 12747 * r: INT_USHR(INT_SHL(load8_16_32, INT_CONSTANT), INT_CONSTANT) 12748 * @param p BURS node to apply the rule to 12749 */ 12750 private void code41(AbstractBURS_TreeNode p) { 12751 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Binary.getResult(P(p)), setSize(consumeMO(),1))); 12752 } 12753 12754 /** 12755 * Emit code for rule number 42: 12756 * r: INT_AND(load16_32, INT_CONSTANT) 12757 * @param p BURS node to apply the rule to 12758 */ 12759 private void code42(AbstractBURS_TreeNode p) { 12760 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Binary.getResult(P(p)), setSize(consumeMO(),2))); 12761 } 12762 12763 /** 12764 * Emit code for rule number 43: 12765 * r: INT_USHR(INT_SHL(load16_32, INT_CONSTANT), INT_CONSTANT) 12766 * @param p BURS node to apply the rule to 12767 */ 12768 private void code43(AbstractBURS_TreeNode p) { 12769 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Binary.getResult(P(p)), setSize(consumeMO(),2))); 12770 } 12771 12772 /** 12773 * Emit code for rule number 44: 12774 * stm: SHORT_STORE(riv, OTHER_OPERAND(riv, riv)) 12775 * @param p BURS node to apply the rule to 12776 */ 12777 private void code44(AbstractBURS_TreeNode p) { 12778 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 12779 } 12780 12781 /** 12782 * Emit code for rule number 45: 12783 * stm: SHORT_STORE(load16, OTHER_OPERAND(riv, riv)) 12784 * @param p BURS node to apply the rule to 12785 */ 12786 private void code45(AbstractBURS_TreeNode p) { 12787 Register tmp = regpool.getInteger(); 12788EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 12789EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), new RegisterOperand(tmp, TypeReference.Int))); 12790 } 12791 12792 /** 12793 * Emit code for rule number 46: 12794 * stm: SHORT_STORE(rlv, OTHER_OPERAND(rlv, rlv)) 12795 * @param p BURS node to apply the rule to 12796 */ 12797 private void code46(AbstractBURS_TreeNode p) { 12798 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 12799 } 12800 12801 /** 12802 * Emit code for rule number 47: 12803 * stm: SHORT_STORE(riv, OTHER_OPERAND(rlv, rlv)) 12804 * @param p BURS node to apply the rule to 12805 */ 12806 private void code47(AbstractBURS_TreeNode p) { 12807 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Store.getValue(P(p)))); 12808 } 12809 12810 /** 12811 * Emit code for rule number 48: 12812 * stm: SHORT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 12813 * @param p BURS node to apply the rule to 12814 */ 12815 private void code48(AbstractBURS_TreeNode p) { 12816 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 12817 } 12818 12819 /** 12820 * Emit code for rule number 49: 12821 * stm: SHORT_ASTORE(load16, OTHER_OPERAND(riv, riv)) 12822 * @param p BURS node to apply the rule to 12823 */ 12824 private void code49(AbstractBURS_TreeNode p) { 12825 Register tmp = regpool.getInteger(); 12826EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 12827EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), new RegisterOperand(tmp, TypeReference.Int))); 12828 } 12829 12830 /** 12831 * Emit code for rule number 50: 12832 * stm: SHORT_ASTORE(riv, OTHER_OPERAND(r, r)) 12833 * @param p BURS node to apply the rule to 12834 */ 12835 private void code50(AbstractBURS_TreeNode p) { 12836 RegisterOperand index = AStore.getIndex(P(p)).asRegister(); 12837if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 12838 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 12839 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 12840} else { 12841 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), AStore.getValue(P(p)))); 12842} 12843 } 12844 12845 /** 12846 * Emit code for rule number 51: 12847 * stm: INT_ASTORE(riv, OTHER_OPERAND(riv, riv)) 12848 * @param p BURS node to apply the rule to 12849 */ 12850 private void code51(AbstractBURS_TreeNode p) { 12851 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12852 } 12853 12854 /** 12855 * Emit code for rule number 52: 12856 * stm: INT_ASTORE(riv, OTHER_OPERAND(r, r)) 12857 * @param p BURS node to apply the rule to 12858 */ 12859 private void code52(AbstractBURS_TreeNode p) { 12860 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 12861if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 12862 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 12863 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12864} else { 12865 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12866} 12867 } 12868 12869 /** 12870 * Emit code for rule number 53: 12871 * stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, rlv)) 12872 * @param p BURS node to apply the rule to 12873 */ 12874 private void code53(AbstractBURS_TreeNode p) { 12875 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12876 } 12877 12878 /** 12879 * Emit code for rule number 54: 12880 * stm: INT_ASTORE(riv, OTHER_OPERAND(rlv, riv)) 12881 * @param p BURS node to apply the rule to 12882 */ 12883 private void code54(AbstractBURS_TreeNode p) { 12884 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12885 } 12886 12887 /** 12888 * Emit code for rule number 55: 12889 * stm: INT_ASTORE(riv, OTHER_OPERAND(riv, rlv)) 12890 * @param p BURS node to apply the rule to 12891 */ 12892 private void code55(AbstractBURS_TreeNode p) { 12893 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 12894 } 12895 12896 /** 12897 * Emit code for rule number 56: 12898 * stm: LONG_ASTORE(r, OTHER_OPERAND(riv, riv)) 12899 * @param p BURS node to apply the rule to 12900 */ 12901 private void code56(AbstractBURS_TreeNode p) { 12902 if (VM.BuildFor32Addr){ 12903 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 12904 hval.setType(TypeReference.Int); 12905 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 12906 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 12907 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 12908} else { 12909 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 12910} 12911 } 12912 12913 /** 12914 * Emit code for rule number 57: 12915 * stm: LONG_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 12916 * @param p BURS node to apply the rule to 12917 */ 12918 private void code57(AbstractBURS_TreeNode p) { 12919 if (VM.BuildFor32Addr) { 12920 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 12921 hval.setType(TypeReference.Int); 12922 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 12923 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 12924 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 12925} else { 12926 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 12927} 12928 } 12929 12930 /** 12931 * Emit code for rule number 58: 12932 * stm: LONG_ASTORE(r, OTHER_OPERAND(r, r)) 12933 * @param p BURS node to apply the rule to 12934 */ 12935 private void code58(AbstractBURS_TreeNode p) { 12936 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 12937if (VM.BuildFor64Addr && index.getRegister().isInteger()) { 12938 EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 12939} 12940if (VM.BuildFor32Addr) { 12941 RegisterOperand hval = (RegisterOperand)AStore.getValue(P(p)); 12942 hval.setType(TypeReference.Int); 12943 RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 12944 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), hval))); 12945 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), lval)); 12946} else { 12947 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 12948} 12949 } 12950 12951 /** 12952 * Emit code for rule number 59: 12953 * stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 12954 * @param p BURS node to apply the rule to 12955 */ 12956 private void code59(AbstractBURS_TreeNode p) { 12957 if (VM.BuildFor32Addr) { 12958 LongConstantOperand val = LC(AStore.getValue(P(p))); 12959 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), IC(val.upper32())))); 12960 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), IC(val.lower32()))); 12961} else { 12962 LongConstantOperand val = LC(AStore.getValue(P(p))); 12963 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), LC(val))); 12964} 12965 } 12966 12967 /** 12968 * Emit code for rule number 60: 12969 * stm: LONG_ASTORE(LONG_CONSTANT, OTHER_OPERAND(rlv, riv)) 12970 * @param p BURS node to apply the rule to 12971 */ 12972 private void code60(AbstractBURS_TreeNode p) { 12973 if (VM.BuildFor32Addr) { 12974 LongConstantOperand val = LC(AStore.getValue(P(p))); 12975 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_AS(P(p), QW_S, DW, DW).copy(), IC(val.upper32())))); 12976 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, DW), IC(val.lower32()))); 12977} else { 12978 LongConstantOperand val = LC(AStore.getValue(P(p))); 12979 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), QW_S, QW), LC(val))); 12980} 12981 } 12982 12983 /** 12984 * Emit code for rule number 61: 12985 * r: LONG_CMP(rlv,rlv) 12986 * @param p BURS node to apply the rule to 12987 */ 12988 private void code61(AbstractBURS_TreeNode p) { 12989 LONG_CMP(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 12990 } 12991 12992 /** 12993 * Emit code for rule number 62: 12994 * stm: GOTO 12995 * @param p BURS node to apply the rule to 12996 */ 12997 private void code62(AbstractBURS_TreeNode p) { 12998 EMIT(MIR_Branch.mutate(P(p), IA32_JMP, Goto.getTarget(P(p)))); 12999 } 13000 13001 /** 13002 * Emit code for rule number 63: 13003 * stm: PREFETCH(r) 13004 * @param p BURS node to apply the rule to 13005 */ 13006 private void code63(AbstractBURS_TreeNode p) { 13007 EMIT(MIR_CacheOp.mutate(P(p), IA32_PREFETCHNTA, R(CacheOp.getRef(P(p))))); 13008 } 13009 13010 /** 13011 * Emit code for rule number 64: 13012 * stm: WRITE_FLOOR 13013 * @param p BURS node to apply the rule to 13014 */ 13015 private void code64(AbstractBURS_TreeNode p) { 13016 EMIT(P(p)); // Pass through to maintain barrier semantics for code motion 13017 } 13018 13019 /** 13020 * Emit code for rule number 65: 13021 * stm: READ_CEILING 13022 * @param p BURS node to apply the rule to 13023 */ 13024 private void code65(AbstractBURS_TreeNode p) { 13025 EMIT(P(p)); // Pass through to maintain barrier semantics for code motion 13026 } 13027 13028 /** 13029 * Emit code for rule number 66: 13030 * stm: FENCE 13031 * @param p BURS node to apply the rule to 13032 */ 13033 private void code66(AbstractBURS_TreeNode p) { 13034 EMIT(MIR_Empty.mutate(P(p), IA32_MFENCE)); 13035 } 13036 13037 /** 13038 * Emit code for rule number 67: 13039 * stm: PAUSE 13040 * @param p BURS node to apply the rule to 13041 */ 13042 private void code67(AbstractBURS_TreeNode p) { 13043 EMIT(MIR_Empty.mutate(P(p), IA32_PAUSE)); 13044 } 13045 13046 /** 13047 * Emit code for rule number 68: 13048 * stm: RETURN(NULL) 13049 * @param p BURS node to apply the rule to 13050 */ 13051 private void code68(AbstractBURS_TreeNode p) { 13052 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, null, null)); 13053 } 13054 13055 /** 13056 * Emit code for rule number 69: 13057 * stm: RETURN(INT_CONSTANT) 13058 * @param p BURS node to apply the rule to 13059 */ 13060 private void code69(AbstractBURS_TreeNode p) { 13061 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, Return.getVal(P(p)), null)); 13062 } 13063 13064 /** 13065 * Emit code for rule number 70: 13066 * stm: RETURN(r) 13067 * @param p BURS node to apply the rule to 13068 */ 13069 private void code70(AbstractBURS_TreeNode p) { 13070 RegisterOperand ret = R(Return.getVal(P(p))); 13071RegisterOperand ret2 = null; 13072if (VM.BuildFor32Addr && ret.getType().isLongType()) { 13073 ret.setType(TypeReference.Int); 13074 ret2 = new RegisterOperand(regpool.getSecondReg(ret.getRegister()), TypeReference.Int); 13075} 13076EMIT(MIR_Return.mutate(P(p), IA32_RET, null, ret, ret2)); 13077 } 13078 13079 /** 13080 * Emit code for rule number 71: 13081 * stm: RETURN(LONG_CONSTANT) 13082 * @param p BURS node to apply the rule to 13083 */ 13084 private void code71(AbstractBURS_TreeNode p) { 13085 LongConstantOperand val = LC(Return.getVal(P(p))); 13086if (VM.BuildFor32Addr) { 13087 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, IC(val.upper32()), IC(val.lower32()))); 13088} else { 13089 EMIT(MIR_Return.mutate(P(p), IA32_RET, null, val, null)); 13090} 13091 } 13092 13093 /** 13094 * Emit code for rule number 72: 13095 * r: CALL(r, any) 13096 * @param p BURS node to apply the rule to 13097 */ 13098 private void code72(AbstractBURS_TreeNode p) { 13099 CALL(P(p), Call.getAddress(P(p))); 13100 } 13101 13102 /** 13103 * Emit code for rule number 73: 13104 * r: CALL(BRANCH_TARGET, any) 13105 * @param p BURS node to apply the rule to 13106 */ 13107 private void code73(AbstractBURS_TreeNode p) { 13108 CALL(P(p), Call.getAddress(P(p))); 13109 } 13110 13111 /** 13112 * Emit code for rule number 74: 13113 * r: CALL(INT_LOAD(riv, riv), any) 13114 * @param p BURS node to apply the rule to 13115 */ 13116 private void code74(AbstractBURS_TreeNode p) { 13117 CALL(P(p), MO_L(PL(p), DW)); 13118 } 13119 13120 /** 13121 * Emit code for rule number 75: 13122 * r: CALL(INT_CONSTANT, any) 13123 * @param p BURS node to apply the rule to 13124 */ 13125 private void code75(AbstractBURS_TreeNode p) { 13126 RegisterOperand temp = regpool.makeTemp(TypeReference.Int); 13127EMIT(MIR_Move.create(IA32_MOV, temp, Call.getAddress(P(p)))); 13128CALL(P(p), temp.copyRO()); 13129 } 13130 13131 /** 13132 * Emit code for rule number 76: 13133 * r: CALL(LONG_LOAD(rlv, rlv), any) 13134 * @param p BURS node to apply the rule to 13135 */ 13136 private void code76(AbstractBURS_TreeNode p) { 13137 CALL(P(p), MO_L(PL(p), QW)); 13138 } 13139 13140 /** 13141 * Emit code for rule number 77: 13142 * r: SYSCALL(r, any) 13143 * @param p BURS node to apply the rule to 13144 */ 13145 private void code77(AbstractBURS_TreeNode p) { 13146 SYSCALL(P(p), Call.getAddress(P(p))); 13147 } 13148 13149 /** 13150 * Emit code for rule number 78: 13151 * r: SYSCALL(INT_LOAD(riv, riv), any) 13152 * @param p BURS node to apply the rule to 13153 */ 13154 private void code78(AbstractBURS_TreeNode p) { 13155 SYSCALL(P(p), MO_L(PL(p), DW)); 13156 } 13157 13158 /** 13159 * Emit code for rule number 79: 13160 * r: SYSCALL(INT_CONSTANT, any) 13161 * @param p BURS node to apply the rule to 13162 */ 13163 private void code79(AbstractBURS_TreeNode p) { 13164 RegisterOperand temp = regpool.makeTemp(TypeReference.Int); 13165EMIT(MIR_Move.create(IA32_MOV, temp, Call.getAddress(P(p)))); 13166SYSCALL(P(p), temp.copyRO()); 13167 } 13168 13169 /** 13170 * Emit code for rule number 80: 13171 * r: GET_TIME_BASE 13172 * @param p BURS node to apply the rule to 13173 */ 13174 private void code80(AbstractBURS_TreeNode p) { 13175 GET_TIME_BASE(P(p), Nullary.getResult(P(p))); 13176 } 13177 13178 /** 13179 * Emit code for rule number 81: 13180 * stm: YIELDPOINT_OSR(any, any) 13181 * @param p BURS node to apply the rule to 13182 */ 13183 private void code81(AbstractBURS_TreeNode p) { 13184 OSR(burs, P(p)); 13185 } 13186 13187 /** 13188 * Emit code for rule number 84: 13189 * address: INT_ADD(r, r) 13190 * @param p BURS node to apply the rule to 13191 */ 13192 private void code84(AbstractBURS_TreeNode p) { 13193 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 13194 } 13195 13196 /** 13197 * Emit code for rule number 85: 13198 * address: INT_ADD(r, address1scaledreg) 13199 * @param p BURS node to apply the rule to 13200 */ 13201 private void code85(AbstractBURS_TreeNode p) { 13202 augmentAddress(Binary.getVal1(P(p))); 13203 } 13204 13205 /** 13206 * Emit code for rule number 86: 13207 * address: INT_ADD(address1scaledreg, r) 13208 * @param p BURS node to apply the rule to 13209 */ 13210 private void code86(AbstractBURS_TreeNode p) { 13211 augmentAddress(Binary.getVal2(P(p))); 13212 } 13213 13214 /** 13215 * Emit code for rule number 87: 13216 * address: INT_ADD(address1scaledreg, INT_CONSTANT) 13217 * @param p BURS node to apply the rule to 13218 */ 13219 private void code87(AbstractBURS_TreeNode p) { 13220 augmentAddress(Binary.getVal2(P(p))); 13221 } 13222 13223 /** 13224 * Emit code for rule number 88: 13225 * address: INT_ADD(address1scaledreg, address1reg) 13226 * @param p BURS node to apply the rule to 13227 */ 13228 private void code88(AbstractBURS_TreeNode p) { 13229 combineAddresses(); 13230 } 13231 13232 /** 13233 * Emit code for rule number 89: 13234 * address: INT_ADD(address1reg, address1scaledreg) 13235 * @param p BURS node to apply the rule to 13236 */ 13237 private void code89(AbstractBURS_TreeNode p) { 13238 combineAddresses(); 13239 } 13240 13241 /** 13242 * Emit code for rule number 90: 13243 * address1reg: INT_ADD(r, INT_CONSTANT) 13244 * @param p BURS node to apply the rule to 13245 */ 13246 private void code90(AbstractBURS_TreeNode p) { 13247 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromIntSignExtend(VR(p))); 13248 } 13249 13250 /** 13251 * Emit code for rule number 91: 13252 * address1reg: INT_MOVE(r) 13253 * @param p BURS node to apply the rule to 13254 */ 13255 private void code91(AbstractBURS_TreeNode p) { 13256 pushAddress(R(Move.getVal(P(p))), null, B_S, Offset.zero()); 13257 } 13258 13259 /** 13260 * Emit code for rule number 93: 13261 * address1reg: INT_ADD(address1reg, INT_CONSTANT) 13262 * @param p BURS node to apply the rule to 13263 */ 13264 private void code93(AbstractBURS_TreeNode p) { 13265 augmentAddress(Binary.getVal2(P(p))); 13266 } 13267 13268 /** 13269 * Emit code for rule number 96: 13270 * address1scaledreg: INT_SHL(r, INT_CONSTANT) 13271 * @param p BURS node to apply the rule to 13272 */ 13273 private void code96(AbstractBURS_TreeNode p) { 13274 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 13275 } 13276 13277 /** 13278 * Emit code for rule number 97: 13279 * address1scaledreg: INT_ADD(address1scaledreg, INT_CONSTANT) 13280 * @param p BURS node to apply the rule to 13281 */ 13282 private void code97(AbstractBURS_TreeNode p) { 13283 augmentAddress(Binary.getVal2(P(p))); 13284 } 13285 13286 /** 13287 * Emit code for rule number 98: 13288 * r: ADDR_2LONG(r) 13289 * @param p BURS node to apply the rule to 13290 */ 13291 private void code98(AbstractBURS_TreeNode p) { 13292 INT_2LONG(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), false); 13293 } 13294 13295 /** 13296 * Emit code for rule number 99: 13297 * r: ADDR_2LONG(load32) 13298 * @param p BURS node to apply the rule to 13299 */ 13300 private void code99(AbstractBURS_TreeNode p) { 13301 INT_2LONG(P(p), Unary.getResult(P(p)), consumeMO(), false); 13302 } 13303 13304 /** 13305 * Emit code for rule number 100: 13306 * r: ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv, riv))) 13307 * @param p BURS node to apply the rule to 13308 */ 13309 private void code100(AbstractBURS_TreeNode p) { 13310 ATTEMPT(Attempt.getResult(P(p)), 13311 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13312 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13313 } 13314 13315 /** 13316 * Emit code for rule number 101: 13317 * r: ATTEMPT_INT(riv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 13318 * @param p BURS node to apply the rule to 13319 */ 13320 private void code101(AbstractBURS_TreeNode p) { 13321 ATTEMPT(Attempt.getResult(P(p)), 13322 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13323 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13324 } 13325 13326 /** 13327 * Emit code for rule number 102: 13328 * r: ATTEMPT_INT(rlv, OTHER_OPERAND(rlv, OTHER_OPERAND(riv, riv))) 13329 * @param p BURS node to apply the rule to 13330 */ 13331 private void code102(AbstractBURS_TreeNode p) { 13332 ATTEMPT(Attempt.getResult(P(p)), 13333 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13334 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13335 } 13336 13337 /** 13338 * Emit code for rule number 103: 13339 * r: ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 13340 * @param p BURS node to apply the rule to 13341 */ 13342 private void code103(AbstractBURS_TreeNode p) { 13343 augmentAddress(Attempt.getAddress(P(p))); 13344ATTEMPT(Attempt.getResult(P(p)), 13345 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13346 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13347 } 13348 13349 /** 13350 * Emit code for rule number 104: 13351 * r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv, riv))) 13352 * @param p BURS node to apply the rule to 13353 */ 13354 private void code104(AbstractBURS_TreeNode p) { 13355 augmentAddress(Attempt.getOffset(P(p))); 13356ATTEMPT(Attempt.getResult(P(p)), 13357 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13358 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13359 } 13360 13361 /** 13362 * Emit code for rule number 105: 13363 * r: ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv, riv))) 13364 * @param p BURS node to apply the rule to 13365 */ 13366 private void code105(AbstractBURS_TreeNode p) { 13367 combineAddresses(); 13368ATTEMPT(Attempt.getResult(P(p)), 13369 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13370 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13371 } 13372 13373 /** 13374 * Emit code for rule number 106: 13375 * r: ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv, riv))) 13376 * @param p BURS node to apply the rule to 13377 */ 13378 private void code106(AbstractBURS_TreeNode p) { 13379 combineAddresses(); 13380ATTEMPT(Attempt.getResult(P(p)), 13381 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13382 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13383 } 13384 13385 /** 13386 * Emit code for rule number 107: 13387 * r: ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv, riv))) 13388 * @param p BURS node to apply the rule to 13389 */ 13390 private void code107(AbstractBURS_TreeNode p) { 13391 augmentAddress(Attempt.getOffset(P(p))); 13392ATTEMPT(Attempt.getResult(P(p)), 13393 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13394 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13395 } 13396 13397 /** 13398 * Emit code for rule number 108: 13399 * r: ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv, riv))) 13400 * @param p BURS node to apply the rule to 13401 */ 13402 private void code108(AbstractBURS_TreeNode p) { 13403 augmentAddress(Attempt.getAddress(P(p))); 13404ATTEMPT(Attempt.getResult(P(p)), 13405 consumeAddress(DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13406 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13407 } 13408 13409 /** 13410 * Emit code for rule number 109: 13411 * stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13412 * @param p BURS node to apply the rule to 13413 */ 13414 private void code109(AbstractBURS_TreeNode p) { 13415 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13416 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13417 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13418 } 13419 13420 /** 13421 * Emit code for rule number 110: 13422 * stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13423 * @param p BURS node to apply the rule to 13424 */ 13425 private void code110(AbstractBURS_TreeNode p) { 13426 augmentAddress(Attempt.getAddress(PL(p))); 13427ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13428 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13429 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13430 } 13431 13432 /** 13433 * Emit code for rule number 111: 13434 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13435 * @param p BURS node to apply the rule to 13436 */ 13437 private void code111(AbstractBURS_TreeNode p) { 13438 augmentAddress(Attempt.getOffset(PL(p))); 13439ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13440 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13441 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13442 } 13443 13444 /** 13445 * Emit code for rule number 112: 13446 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13447 * @param p BURS node to apply the rule to 13448 */ 13449 private void code112(AbstractBURS_TreeNode p) { 13450 combineAddresses(); 13451ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13452 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13453 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13454 } 13455 13456 /** 13457 * Emit code for rule number 113: 13458 * stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13459 * @param p BURS node to apply the rule to 13460 */ 13461 private void code113(AbstractBURS_TreeNode p) { 13462 combineAddresses(); 13463ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13464 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13465 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13466 } 13467 13468 /** 13469 * Emit code for rule number 114: 13470 * stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13471 * @param p BURS node to apply the rule to 13472 */ 13473 private void code114(AbstractBURS_TreeNode p) { 13474 augmentAddress(Attempt.getOffset(PL(p))); 13475ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13476 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13477 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13478 } 13479 13480 /** 13481 * Emit code for rule number 115: 13482 * stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13483 * @param p BURS node to apply the rule to 13484 */ 13485 private void code115(AbstractBURS_TreeNode p) { 13486 augmentAddress(Attempt.getAddress(PL(p))); 13487ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13488 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13489 IfCmp.getCond(P(p)).flipCode(), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13490 } 13491 13492 /** 13493 * Emit code for rule number 116: 13494 * stm: INT_IFCMP(ATTEMPT_INT(riv, OTHER_OPERAND(riv, OTHER_OPERAND(riv,riv))), INT_CONSTANT) 13495 * @param p BURS node to apply the rule to 13496 */ 13497 private void code116(AbstractBURS_TreeNode p) { 13498 ATTEMPT_IFCMP(MO(Attempt.getAddress(PL(p)), Attempt.getOffset(PL(p)), DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13499 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13500 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13501 } 13502 13503 /** 13504 * Emit code for rule number 117: 13505 * stm: INT_IFCMP(ATTEMPT_INT(r, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13506 * @param p BURS node to apply the rule to 13507 */ 13508 private void code117(AbstractBURS_TreeNode p) { 13509 augmentAddress(Attempt.getAddress(PL(p))); 13510ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13511 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13512 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13513 } 13514 13515 /** 13516 * Emit code for rule number 118: 13517 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(r, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13518 * @param p BURS node to apply the rule to 13519 */ 13520 private void code118(AbstractBURS_TreeNode p) { 13521 augmentAddress(Attempt.getOffset(PL(p))); 13522ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13523 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13524 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13525 } 13526 13527 /** 13528 * Emit code for rule number 119: 13529 * stm: INT_IFCMP(ATTEMPT_INT(address1scaledreg, OTHER_OPERAND(address1reg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13530 * @param p BURS node to apply the rule to 13531 */ 13532 private void code119(AbstractBURS_TreeNode p) { 13533 combineAddresses(); 13534ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13535 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13536 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13537 } 13538 13539 /** 13540 * Emit code for rule number 120: 13541 * stm: INT_IFCMP(ATTEMPT_INT(address1reg, OTHER_OPERAND(address1scaledreg, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13542 * @param p BURS node to apply the rule to 13543 */ 13544 private void code120(AbstractBURS_TreeNode p) { 13545 combineAddresses(); 13546ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13547 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13548 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13549 } 13550 13551 /** 13552 * Emit code for rule number 121: 13553 * stm: INT_IFCMP(ATTEMPT_INT(address, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13554 * @param p BURS node to apply the rule to 13555 */ 13556 private void code121(AbstractBURS_TreeNode p) { 13557 augmentAddress(Attempt.getOffset(PL(p))); 13558ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13559 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13560 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13561 } 13562 13563 /** 13564 * Emit code for rule number 122: 13565 * stm: INT_IFCMP(ATTEMPT_INT(INT_CONSTANT, OTHER_OPERAND(address, OTHER_OPERAND(riv,riv))),INT_CONSTANT) 13566 * @param p BURS node to apply the rule to 13567 */ 13568 private void code122(AbstractBURS_TreeNode p) { 13569 augmentAddress(Attempt.getAddress(PL(p))); 13570ATTEMPT_IFCMP(consumeAddress(DW, Attempt.getLocation(PL(p)), Attempt.getGuard(PL(p))), 13571 Attempt.getOldValue(PL(p)), Attempt.getNewValue(PL(p)), 13572 IfCmp.getCond(P(p)), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 13573 } 13574 13575 /** 13576 * Emit code for rule number 123: 13577 * r: ATTEMPT_LONG(riv, OTHER_OPERAND(riv, OTHER_OPERAND(rlv, rlv))) 13578 * @param p BURS node to apply the rule to 13579 */ 13580 private void code123(AbstractBURS_TreeNode p) { 13581 ATTEMPT_LONG(Attempt.getResult(P(p)), 13582 MO(Attempt.getAddress(P(p)), Attempt.getOffset(P(p)), DW, Attempt.getLocation(P(p)), Attempt.getGuard(P(p))), 13583 Attempt.getOldValue(P(p)), Attempt.getNewValue(P(p))); 13584 } 13585 13586 /** 13587 * Emit code for rule number 124: 13588 * bittest: INT_AND(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13589 * @param p BURS node to apply the rule to 13590 */ 13591 private void code124(AbstractBURS_TreeNode p) { 13592 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), Binary.getVal1(PLR(p)).copy())); 13593 } 13594 13595 /** 13596 * Emit code for rule number 125: 13597 * bittest: INT_AND(INT_USHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13598 * @param p BURS node to apply the rule to 13599 */ 13600 private void code125(AbstractBURS_TreeNode p) { 13601 Register tmp = regpool.getInteger(); 13602if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 13603EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 13604EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 13605EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 13606 } 13607 13608 /** 13609 * Emit code for rule number 126: 13610 * bittest: INT_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 13611 * @param p BURS node to apply the rule to 13612 */ 13613 private void code126(AbstractBURS_TreeNode p) { 13614 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), IC(VLR(p)))); 13615 } 13616 13617 /** 13618 * Emit code for rule number 127: 13619 * bittest: INT_AND(INT_SHR(r,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13620 * @param p BURS node to apply the rule to 13621 */ 13622 private void code127(AbstractBURS_TreeNode p) { 13623 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), Binary.getVal1(PLR(p)).copy())); 13624 } 13625 13626 /** 13627 * Emit code for rule number 128: 13628 * bittest: INT_AND(INT_SHR(load32,INT_AND(r,INT_CONSTANT)),INT_CONSTANT) 13629 * @param p BURS node to apply the rule to 13630 */ 13631 private void code128(AbstractBURS_TreeNode p) { 13632 Register tmp = regpool.getInteger(); 13633if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 13634EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 13635EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 13636EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 13637 } 13638 13639 /** 13640 * Emit code for rule number 129: 13641 * bittest: INT_AND(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 13642 * @param p BURS node to apply the rule to 13643 */ 13644 private void code129(AbstractBURS_TreeNode p) { 13645 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(PL(p)).copy(), IC(VLR(p)))); 13646 } 13647 13648 /** 13649 * Emit code for rule number 130: 13650 * bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(riv,INT_CONSTANT)),r) 13651 * @param p BURS node to apply the rule to 13652 */ 13653 private void code130(AbstractBURS_TreeNode p) { 13654 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal2(P(p)), Binary.getVal1(PLR(p)).copy())); 13655 } 13656 13657 /** 13658 * Emit code for rule number 131: 13659 * bittest: INT_AND(INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT)),load32) 13660 * @param p BURS node to apply the rule to 13661 */ 13662 private void code131(AbstractBURS_TreeNode p) { 13663 Register tmp = regpool.getInteger(); 13664if (VM.VerifyAssertions) VM._assert((VLRR(p) & 0x7FFFFFFF) <= 31); 13665EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PLR(p))))); 13666EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VLRR(p))))); 13667EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 13668 } 13669 13670 /** 13671 * Emit code for rule number 132: 13672 * bittest: INT_AND(r,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 13673 * @param p BURS node to apply the rule to 13674 */ 13675 private void code132(AbstractBURS_TreeNode p) { 13676 EMIT(MIR_Test.mutate(P(p), IA32_BT, Binary.getVal1(P(p)), Binary.getVal1(PRR(p)).copy())); 13677 } 13678 13679 /** 13680 * Emit code for rule number 133: 13681 * bittest: INT_AND(load32,INT_SHL(INT_CONSTANT,INT_AND(r, INT_CONSTANT))) 13682 * @param p BURS node to apply the rule to 13683 */ 13684 private void code133(AbstractBURS_TreeNode p) { 13685 Register tmp = regpool.getInteger(); 13686if (VM.VerifyAssertions) VM._assert((VRRR(p) & 0x7FFFFFFF) <= 31); 13687EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), Binary.getVal1(PRR(p))))); 13688EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_AND, new RegisterOperand(tmp, TypeReference.Int), IC(VRRR(p))))); 13689EMIT(MIR_Test.mutate(P(p), IA32_BT, consumeMO(), new RegisterOperand(tmp, TypeReference.Int))); 13690 } 13691 13692 /** 13693 * Emit code for rule number 134: 13694 * r: BOOLEAN_CMP_INT(r,riv) 13695 * @param p BURS node to apply the rule to 13696 */ 13697 private void code134(AbstractBURS_TreeNode p) { 13698 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), 13699 BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), 13700 BooleanCmp.getCond(P(p))); 13701 } 13702 13703 /** 13704 * Emit code for rule number 135: 13705 * boolcmp: BOOLEAN_CMP_INT(r,riv) 13706 * @param p BURS node to apply the rule to 13707 */ 13708 private void code135(AbstractBURS_TreeNode p) { 13709 ConditionOperand cond = BooleanCmp.getCond(P(p)); 13710pushCOND(cond); 13711EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p))); 13712 } 13713 13714 /** 13715 * Emit code for rule number 136: 13716 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13717 * @param p BURS node to apply the rule to 13718 */ 13719 private void code136(AbstractBURS_TreeNode p) { 13720 EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 13721BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 13722 } 13723 13724 /** 13725 * Emit code for rule number 137: 13726 * boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13727 * @param p BURS node to apply the rule to 13728 */ 13729 private void code137(AbstractBURS_TreeNode p) { 13730 pushCOND(BooleanCmp.getCond(P(p))); 13731EMIT(CPOS(P(p),MIR_Test.create(IA32_TEST, BooleanCmp.getVal1(P(p)), BooleanCmp.getVal1(P(p)).copy()))); 13732 } 13733 13734 /** 13735 * Emit code for rule number 138: 13736 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13737 * @param p BURS node to apply the rule to 13738 */ 13739 private void code138(AbstractBURS_TreeNode p) { 13740 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getVal1(P(p)), IC(31)); 13741 } 13742 13743 /** 13744 * Emit code for rule number 139: 13745 * r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13746 * @param p BURS node to apply the rule to 13747 */ 13748 private void code139(AbstractBURS_TreeNode p) { 13749 EMIT_Commutative(IA32_SHR, P(p), BooleanCmp.getResult(P(p)), consumeMO(), IC(31)); 13750 } 13751 13752 /** 13753 * Emit code for rule number 140: 13754 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 13755 * @param p BURS node to apply the rule to 13756 */ 13757 private void code140(AbstractBURS_TreeNode p) { 13758 RegisterOperand result = BooleanCmp.getResult(P(p)); 13759EMIT_Commutative(IA32_SHR, P(p), result, BooleanCmp.getVal1(P(p)), IC(31)); 13760EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 13761 } 13762 13763 /** 13764 * Emit code for rule number 141: 13765 * r: BOOLEAN_CMP_INT(load32,INT_CONSTANT) 13766 * @param p BURS node to apply the rule to 13767 */ 13768 private void code141(AbstractBURS_TreeNode p) { 13769 RegisterOperand result = BooleanCmp.getResult(P(p)); 13770EMIT_Commutative(IA32_SHR, P(p), result, consumeMO(), IC(31)); 13771EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_XOR, result.copyRO(), IC(1)))); 13772 } 13773 13774 /** 13775 * Emit code for rule number 142: 13776 * r: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 13777 * @param p BURS node to apply the rule to 13778 */ 13779 private void code142(AbstractBURS_TreeNode p) { 13780 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 13781 } 13782 13783 /** 13784 * Emit code for rule number 143: 13785 * boolcmp: BOOLEAN_CMP_INT(cz, INT_CONSTANT) 13786 * @param p BURS node to apply the rule to 13787 */ 13788 private void code143(AbstractBURS_TreeNode p) { 13789 pushCOND(BooleanCmp.getCond(P(p))); 13790 } 13791 13792 /** 13793 * Emit code for rule number 144: 13794 * r: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 13795 * @param p BURS node to apply the rule to 13796 */ 13797 private void code144(AbstractBURS_TreeNode p) { 13798 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p))); 13799 } 13800 13801 /** 13802 * Emit code for rule number 145: 13803 * boolcmp: BOOLEAN_CMP_INT(szp, INT_CONSTANT) 13804 * @param p BURS node to apply the rule to 13805 */ 13806 private void code145(AbstractBURS_TreeNode p) { 13807 pushCOND(BooleanCmp.getCond(P(p))); 13808 } 13809 13810 /** 13811 * Emit code for rule number 146: 13812 * r: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 13813 * @param p BURS node to apply the rule to 13814 */ 13815 private void code146(AbstractBURS_TreeNode p) { 13816 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), BIT_TEST(VR(p),BooleanCmp.getCond(P(p)))); 13817 } 13818 13819 /** 13820 * Emit code for rule number 147: 13821 * boolcmp: BOOLEAN_CMP_INT(bittest, INT_CONSTANT) 13822 * @param p BURS node to apply the rule to 13823 */ 13824 private void code147(AbstractBURS_TreeNode p) { 13825 pushCOND(BIT_TEST(VR(p),BooleanCmp.getCond(P(p)))); 13826 } 13827 13828 /** 13829 * Emit code for rule number 148: 13830 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13831 * @param p BURS node to apply the rule to 13832 */ 13833 private void code148(AbstractBURS_TreeNode p) { 13834 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), consumeCOND()); 13835 } 13836 13837 /** 13838 * Emit code for rule number 150: 13839 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13840 * @param p BURS node to apply the rule to 13841 */ 13842 private void code150(AbstractBURS_TreeNode p) { 13843 BOOLEAN_CMP_INT(P(p), BooleanCmp.getResult(P(p)), consumeCOND().flipCode()); 13844 } 13845 13846 /** 13847 * Emit code for rule number 151: 13848 * boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 13849 * @param p BURS node to apply the rule to 13850 */ 13851 private void code151(AbstractBURS_TreeNode p) { 13852 pushCOND(consumeCOND().flipCode()); // invert already pushed condition 13853 } 13854 13855 /** 13856 * Emit code for rule number 152: 13857 * r: BOOLEAN_CMP_INT(load32,riv) 13858 * @param p BURS node to apply the rule to 13859 */ 13860 private void code152(AbstractBURS_TreeNode p) { 13861 BOOLEAN_CMP_INT(PL(p), BooleanCmp.getResult(P(p)), 13862 consumeMO(), BooleanCmp.getVal2(P(p)), 13863 BooleanCmp.getCond(P(p))); 13864 } 13865 13866 /** 13867 * Emit code for rule number 153: 13868 * boolcmp: BOOLEAN_CMP_INT(load32,riv) 13869 * @param p BURS node to apply the rule to 13870 */ 13871 private void code153(AbstractBURS_TreeNode p) { 13872 ConditionOperand cond = BooleanCmp.getCond(P(p)); 13873pushCOND(cond); 13874EMIT_Compare(P(p), cond, consumeMO(), BooleanCmp.getVal2(P(p))); 13875 } 13876 13877 /** 13878 * Emit code for rule number 154: 13879 * r: BOOLEAN_CMP_INT(r,load32) 13880 * @param p BURS node to apply the rule to 13881 */ 13882 private void code154(AbstractBURS_TreeNode p) { 13883 BOOLEAN_CMP_INT(PR(p), BooleanCmp.getResult(P(p)), 13884 BooleanCmp.getVal1(P(p)), consumeMO(), 13885 BooleanCmp.getCond(P(p))); 13886 } 13887 13888 /** 13889 * Emit code for rule number 155: 13890 * boolcmp: BOOLEAN_CMP_INT(riv,load32) 13891 * @param p BURS node to apply the rule to 13892 */ 13893 private void code155(AbstractBURS_TreeNode p) { 13894 ConditionOperand cond = BooleanCmp.getCond(P(p)); 13895pushCOND(cond); 13896EMIT_Compare(P(p), cond, BooleanCmp.getVal1(P(p)), consumeMO()); 13897 } 13898 13899 /** 13900 * Emit code for rule number 156: 13901 * stm: BYTE_STORE(boolcmp, OTHER_OPERAND(riv,riv)) 13902 * @param p BURS node to apply the rule to 13903 */ 13904 private void code156(AbstractBURS_TreeNode p) { 13905 EMIT(MIR_Set.mutate(P(p), IA32_SET__B, MO_S(P(p),B), COND(consumeCOND()))); 13906 } 13907 13908 /** 13909 * Emit code for rule number 157: 13910 * stm: BYTE_ASTORE(boolcmp, OTHER_OPERAND(riv, riv)) 13911 * @param p BURS node to apply the rule to 13912 */ 13913 private void code157(AbstractBURS_TreeNode p) { 13914 EMIT(MIR_Set.mutate(P(p), IA32_SET__B, MO_AS(P(p),B_S,B), COND(consumeCOND()))); 13915 } 13916 13917 /** 13918 * Emit code for rule number 158: 13919 * r: BOOLEAN_CMP_LONG(rlv,rlv) 13920 * @param p BURS node to apply the rule to 13921 */ 13922 private void code158(AbstractBURS_TreeNode p) { 13923 BOOLEAN_CMP_LONG(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), BooleanCmp.getCond(P(p))); 13924 } 13925 13926 /** 13927 * Emit code for rule number 159: 13928 * boolcmp: BOOLEAN_CMP_LONG(rlv,rlv) 13929 * @param p BURS node to apply the rule to 13930 */ 13931 private void code159(AbstractBURS_TreeNode p) { 13932 pushCOND(BooleanCmp.getCond(P(p))); 13933LONG_CMP(P(p), BooleanCmp.getResult(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p))); 13934EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, BooleanCmp.getResult(P(p)), IC(0)))); 13935 } 13936 13937 /** 13938 * Emit code for rule number 160: 13939 * r: BOOLEAN_NOT(r) 13940 * @param p BURS node to apply the rule to 13941 */ 13942 private void code160(AbstractBURS_TreeNode p) { 13943 EMIT_Commutative(IA32_XOR, P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), IC(1)); 13944 } 13945 13946 /** 13947 * Emit code for rule number 161: 13948 * stm: BYTE_STORE(BOOLEAN_NOT(UBYTE_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13949 * @param p BURS node to apply the rule to 13950 */ 13951 private void code161(AbstractBURS_TreeNode p) { 13952 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), B), MO_S(P(p), B), IC(1)); 13953 } 13954 13955 /** 13956 * Emit code for rule number 162: 13957 * stm: BYTE_ASTORE(BOOLEAN_NOT(UBYTE_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 13958 * @param p BURS node to apply the rule to 13959 */ 13960 private void code162(AbstractBURS_TreeNode p) { 13961 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), B_S, B), MO_AS(P(p), B_S, B), IC(1)); 13962 } 13963 13964 /** 13965 * Emit code for rule number 163: 13966 * stm: BYTE_STORE(riv, OTHER_OPERAND(riv, riv)) 13967 * @param p BURS node to apply the rule to 13968 */ 13969 private void code163(AbstractBURS_TreeNode p) { 13970 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), Store.getValue(P(p)))); 13971 } 13972 13973 /** 13974 * Emit code for rule number 164: 13975 * stm: BYTE_STORE(load8, OTHER_OPERAND(riv, riv)) 13976 * @param p BURS node to apply the rule to 13977 */ 13978 private void code164(AbstractBURS_TreeNode p) { 13979 Register tmp = regpool.getInteger(); 13980EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 13981EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), new RegisterOperand(tmp, TypeReference.Int))); 13982 } 13983 13984 /** 13985 * Emit code for rule number 165: 13986 * stm: BYTE_ASTORE(riv, OTHER_OPERAND(riv, riv)) 13987 * @param p BURS node to apply the rule to 13988 */ 13989 private void code165(AbstractBURS_TreeNode p) { 13990 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), AStore.getValue(P(p)))); 13991 } 13992 13993 /** 13994 * Emit code for rule number 166: 13995 * stm: BYTE_ASTORE(load8, OTHER_OPERAND(riv, riv)) 13996 * @param p BURS node to apply the rule to 13997 */ 13998 private void code166(AbstractBURS_TreeNode p) { 13999 Register tmp = regpool.getInteger(); 14000EMIT(CPOS(PL(p), MIR_Move.create(IA32_MOV, new RegisterOperand(tmp, TypeReference.Int), consumeMO()))); 14001EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), new RegisterOperand(tmp, TypeReference.Int))); 14002 } 14003 14004 /** 14005 * Emit code for rule number 167: 14006 * r: CMP_CMOV(r, OTHER_OPERAND(riv, any)) 14007 * @param p BURS node to apply the rule to 14008 */ 14009 private void code167(AbstractBURS_TreeNode p) { 14010 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, CondMove.getVal1(P(p)), CondMove.getVal2(P(p))))); 14011CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14012 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14013 } 14014 14015 /** 14016 * Emit code for rule number 168: 14017 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, any)) 14018 * @param p BURS node to apply the rule to 14019 */ 14020 private void code168(AbstractBURS_TreeNode p) { 14021 EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, CondMove.getVal1(P(p)), CondMove.getVal1(P(p)).copy()))); 14022CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14023 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14024 } 14025 14026 /** 14027 * Emit code for rule number 169: 14028 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 14029 * @param p BURS node to apply the rule to 14030 */ 14031 private void code169(AbstractBURS_TreeNode p) { 14032 EMIT_Commutative(IA32_SAR, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), IC(31)); 14033 } 14034 14035 /** 14036 * Emit code for rule number 170: 14037 * r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 14038 * @param p BURS node to apply the rule to 14039 */ 14040 private void code170(AbstractBURS_TreeNode p) { 14041 EMIT_Commutative(IA32_SAR, P(p), CondMove.getResult(P(p)), consumeMO(), IC(31)); 14042 } 14043 14044 /** 14045 * Emit code for rule number 171: 14046 * r: CMP_CMOV(r, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 14047 * @param p BURS node to apply the rule to 14048 */ 14049 private void code171(AbstractBURS_TreeNode p) { 14050 RegisterOperand result = CondMove.getResult(P(p)); 14051EMIT_Commutative(IA32_SAR, P(p), result, CondMove.getVal1(P(p)), IC(31)); 14052EMIT(CPOS(P(p),MIR_UnaryAcc.create(IA32_NOT, result.copyRO()))); 14053 } 14054 14055 /** 14056 * Emit code for rule number 172: 14057 * r: CMP_CMOV(load32, OTHER_OPERAND(INT_CONSTANT, OTHER_OPERAND(INT_CONSTANT, INT_CONSTANT))) 14058 * @param p BURS node to apply the rule to 14059 */ 14060 private void code172(AbstractBURS_TreeNode p) { 14061 RegisterOperand result = CondMove.getResult(P(p)); 14062EMIT_Commutative(IA32_SAR, P(p), result, consumeMO(), IC(31)); 14063EMIT(CPOS(P(p),MIR_UnaryAcc.create(IA32_NOT, result.copyRO()))); 14064 } 14065 14066 /** 14067 * Emit code for rule number 173: 14068 * r: CMP_CMOV(load8, OTHER_OPERAND(INT_CONSTANT, any)) 14069 * @param p BURS node to apply the rule to 14070 */ 14071 private void code173(AbstractBURS_TreeNode p) { 14072 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 14073CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14074 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14075 } 14076 14077 /** 14078 * Emit code for rule number 174: 14079 * r: CMP_CMOV(uload8, OTHER_OPERAND(riv, any)) 14080 * @param p BURS node to apply the rule to 14081 */ 14082 private void code174(AbstractBURS_TreeNode p) { 14083 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 14084CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14085 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14086 } 14087 14088 /** 14089 * Emit code for rule number 175: 14090 * r: CMP_CMOV(riv, OTHER_OPERAND(uload8, any)) 14091 * @param p BURS node to apply the rule to 14092 */ 14093 private void code175(AbstractBURS_TreeNode p) { 14094 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 14095CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14096 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14097 } 14098 14099 /** 14100 * Emit code for rule number 176: 14101 * r: CMP_CMOV(sload16, OTHER_OPERAND(INT_CONSTANT, any)) 14102 * @param p BURS node to apply the rule to 14103 */ 14104 private void code176(AbstractBURS_TreeNode p) { 14105 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 14106CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14107 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14108 } 14109 14110 /** 14111 * Emit code for rule number 177: 14112 * r: CMP_CMOV(load32, OTHER_OPERAND(riv, any)) 14113 * @param p BURS node to apply the rule to 14114 */ 14115 private void code177(AbstractBURS_TreeNode p) { 14116 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal2(P(p))))); 14117CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14118 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14119 } 14120 14121 /** 14122 * Emit code for rule number 178: 14123 * r: CMP_CMOV(riv, OTHER_OPERAND(load32, any)) 14124 * @param p BURS node to apply the rule to 14125 */ 14126 private void code178(AbstractBURS_TreeNode p) { 14127 EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), CondMove.getVal1(P(p))))); 14128CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)).flipOperands(), 14129 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14130 } 14131 14132 /** 14133 * Emit code for rule number 179: 14134 * r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 14135 * @param p BURS node to apply the rule to 14136 */ 14137 private void code179(AbstractBURS_TreeNode p) { 14138 CMOV_MOV(P(p), CondMove.getResult(P(p)), consumeCOND(), 14139 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14140 } 14141 14142 /** 14143 * Emit code for rule number 180: 14144 * r: CMP_CMOV(boolcmp, OTHER_OPERAND(INT_CONSTANT, any)) 14145 * @param p BURS node to apply the rule to 14146 */ 14147 private void code180(AbstractBURS_TreeNode p) { 14148 CMOV_MOV(P(p), CondMove.getResult(P(p)), consumeCOND().flipCode(), 14149 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14150 } 14151 14152 /** 14153 * Emit code for rule number 181: 14154 * r: CMP_CMOV(bittest, OTHER_OPERAND(INT_CONSTANT, any)) 14155 * @param p BURS node to apply the rule to 14156 */ 14157 private void code181(AbstractBURS_TreeNode p) { 14158 CMOV_MOV(P(p), CondMove.getResult(P(p)), BIT_TEST(VRL(p), CondMove.getCond(P(p))), 14159 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14160 } 14161 14162 /** 14163 * Emit code for rule number 182: 14164 * r: CMP_CMOV(cz, OTHER_OPERAND(INT_CONSTANT, any)) 14165 * @param p BURS node to apply the rule to 14166 */ 14167 private void code182(AbstractBURS_TreeNode p) { 14168 CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14169 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14170 } 14171 14172 /** 14173 * Emit code for rule number 183: 14174 * r: CMP_CMOV(szp, OTHER_OPERAND(INT_CONSTANT, any)) 14175 * @param p BURS node to apply the rule to 14176 */ 14177 private void code183(AbstractBURS_TreeNode p) { 14178 CMOV_MOV(P(p), CondMove.getResult(P(p)), CondMove.getCond(P(p)), 14179 CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 14180 } 14181 14182 /** 14183 * Emit code for rule number 184: 14184 * r: INT_2BYTE(r) 14185 * @param p BURS node to apply the rule to 14186 */ 14187 private void code184(AbstractBURS_TreeNode p) { 14188 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), Unary.getVal(P(p)))); 14189 } 14190 14191 /** 14192 * Emit code for rule number 185: 14193 * r: INT_2BYTE(load8_16_32) 14194 * @param p BURS node to apply the rule to 14195 */ 14196 private void code185(AbstractBURS_TreeNode p) { 14197 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Unary.getResult(P(p)), consumeMO())); 14198 } 14199 14200 /** 14201 * Emit code for rule number 186: 14202 * stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 14203 * @param p BURS node to apply the rule to 14204 */ 14205 private void code186(AbstractBURS_TreeNode p) { 14206 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), B), Unary.getVal(PL(p)))); 14207 } 14208 14209 /** 14210 * Emit code for rule number 187: 14211 * stm: BYTE_ASTORE(INT_2BYTE(r),OTHER_OPERAND(riv, riv)) 14212 * @param p BURS node to apply the rule to 14213 */ 14214 private void code187(AbstractBURS_TreeNode p) { 14215 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), B_S, B), Unary.getVal(PL(p)))); 14216 } 14217 14218 /** 14219 * Emit code for rule number 188: 14220 * r: INT_2LONG(r) 14221 * @param p BURS node to apply the rule to 14222 */ 14223 private void code188(AbstractBURS_TreeNode p) { 14224 INT_2LONG(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), true); 14225 } 14226 14227 /** 14228 * Emit code for rule number 189: 14229 * r: INT_2LONG(load32) 14230 * @param p BURS node to apply the rule to 14231 */ 14232 private void code189(AbstractBURS_TreeNode p) { 14233 INT_2LONG(P(p), Unary.getResult(P(p)), consumeMO(), true); 14234 } 14235 14236 /** 14237 * Emit code for rule number 190: 14238 * r: LONG_AND(INT_2LONG(r), LONG_CONSTANT) 14239 * @param p BURS node to apply the rule to 14240 */ 14241 private void code190(AbstractBURS_TreeNode p) { 14242 INT_2LONG(P(p), Binary.getResult(P(p)), Unary.getVal(PL(p)), false); 14243 } 14244 14245 /** 14246 * Emit code for rule number 191: 14247 * r: LONG_AND(INT_2LONG(load32), LONG_CONSTANT) 14248 * @param p BURS node to apply the rule to 14249 */ 14250 private void code191(AbstractBURS_TreeNode p) { 14251 INT_2LONG(P(p), Binary.getResult(P(p)), consumeMO(), false); 14252 } 14253 14254 /** 14255 * Emit code for rule number 192: 14256 * r: LONG_SHL(INT_2LONG(r), INT_CONSTANT) 14257 * @param p BURS node to apply the rule to 14258 */ 14259 private void code192(AbstractBURS_TreeNode p) { 14260 Register hr = Binary.getResult(P(p)).getRegister(); 14261Register lr = regpool.getSecondReg(hr); 14262EMIT(MIR_Move.mutate(P(p), IA32_MOV, new RegisterOperand(hr, TypeReference.Int), Unary.getVal(PL(p)).copy())); 14263EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(lr, TypeReference.Int), IC(0)))); 14264 } 14265 14266 /** 14267 * Emit code for rule number 193: 14268 * r: LONG_SHL(INT_2LONG(load64), INT_CONSTANT) 14269 * @param p BURS node to apply the rule to 14270 */ 14271 private void code193(AbstractBURS_TreeNode p) { 14272 Register hr = Binary.getResult(P(p)).getRegister(); 14273Register lr = regpool.getSecondReg(hr); 14274EMIT(MIR_Move.mutate(P(p), IA32_MOV, new RegisterOperand(hr, TypeReference.Int), setSize(consumeMO(),4))); 14275EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(lr, TypeReference.Int), IC(0)))); 14276 } 14277 14278 /** 14279 * Emit code for rule number 194: 14280 * r: INT_2SHORT(r) 14281 * @param p BURS node to apply the rule to 14282 */ 14283 private void code194(AbstractBURS_TreeNode p) { 14284 if (VM.BuildFor32Addr) { 14285EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Unary.getResult(P(p)), Unary.getVal(P(p)))); 14286} else { 14287EMIT(MIR_Unary.mutate(P(p), IA32_MOVSXQ__W, Unary.getResult(P(p)), Unary.getVal(P(p)))); 14288} 14289 } 14290 14291 /** 14292 * Emit code for rule number 195: 14293 * r: INT_2SHORT(load16_32) 14294 * @param p BURS node to apply the rule to 14295 */ 14296 private void code195(AbstractBURS_TreeNode p) { 14297 if (VM.BuildFor32Addr) { 14298EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Unary.getResult(P(p)), setSize(consumeMO(), 2))); 14299} else { 14300EMIT(MIR_Unary.mutate(P(p), IA32_MOVSXQ__W, Unary.getResult(P(p)), setSize(consumeMO(), 2))); 14301} 14302 } 14303 14304 /** 14305 * Emit code for rule number 196: 14306 * sload16: INT_2SHORT(load16_32) 14307 * @param p BURS node to apply the rule to 14308 */ 14309 private void code196(AbstractBURS_TreeNode p) { 14310 pushMO(setSize(consumeMO(),2)); 14311 } 14312 14313 /** 14314 * Emit code for rule number 197: 14315 * stm: SHORT_STORE(INT_2SHORT(r), OTHER_OPERAND(riv,riv)) 14316 * @param p BURS node to apply the rule to 14317 */ 14318 private void code197(AbstractBURS_TreeNode p) { 14319 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Unary.getVal(PL(p)))); 14320 } 14321 14322 /** 14323 * Emit code for rule number 198: 14324 * stm: SHORT_ASTORE(INT_2SHORT(r), OTHER_OPERAND(riv, riv)) 14325 * @param p BURS node to apply the rule to 14326 */ 14327 private void code198(AbstractBURS_TreeNode p) { 14328 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), Unary.getVal(PL(p)))); 14329 } 14330 14331 /** 14332 * Emit code for rule number 199: 14333 * szpr: INT_2USHORT(r) 14334 * @param p BURS node to apply the rule to 14335 */ 14336 private void code199(AbstractBURS_TreeNode p) { 14337 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, Unary.getResult(P(p)), Unary.getVal(P(p))))); 14338EMIT(MIR_BinaryAcc.mutate(P(p), IA32_AND, Unary.getResult(P(p)).copyRO(), IC(0xFFFF))); 14339 } 14340 14341 /** 14342 * Emit code for rule number 200: 14343 * uload16: INT_2USHORT(load16_32) 14344 * @param p BURS node to apply the rule to 14345 */ 14346 private void code200(AbstractBURS_TreeNode p) { 14347 pushMO(setSize(consumeMO(),2)); 14348 } 14349 14350 /** 14351 * Emit code for rule number 201: 14352 * r: INT_2USHORT(load16_32) 14353 * @param p BURS node to apply the rule to 14354 */ 14355 private void code201(AbstractBURS_TreeNode p) { 14356 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Unary.getResult(P(p)), setSize(consumeMO(),2))); 14357 } 14358 14359 /** 14360 * Emit code for rule number 202: 14361 * stm: SHORT_STORE(INT_2USHORT(r), OTHER_OPERAND(riv,riv)) 14362 * @param p BURS node to apply the rule to 14363 */ 14364 private void code202(AbstractBURS_TreeNode p) { 14365 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), W), Unary.getVal(PL(p)))); 14366 } 14367 14368 /** 14369 * Emit code for rule number 203: 14370 * stm: SHORT_ASTORE(INT_2USHORT(r), OTHER_OPERAND(riv, riv)) 14371 * @param p BURS node to apply the rule to 14372 */ 14373 private void code203(AbstractBURS_TreeNode p) { 14374 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), W_S, W), Unary.getVal(PL(p)))); 14375 } 14376 14377 /** 14378 * Emit code for rule number 204: 14379 * czr: INT_ADD(r, riv) 14380 * @param p BURS node to apply the rule to 14381 */ 14382 private void code204(AbstractBURS_TreeNode p) { 14383 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 14384 } 14385 14386 /** 14387 * Emit code for rule number 205: 14388 * r: INT_ADD(r, riv) 14389 * @param p BURS node to apply the rule to 14390 */ 14391 private void code205(AbstractBURS_TreeNode p) { 14392 if (Binary.getVal2(P(p)).isIntConstant()) { 14393 pushAddress(R(Binary.getVal1(P(p))), null, B_S, Offset.fromIntSignExtend(VR(p))); 14394} else { 14395 pushAddress(R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))), B_S, Offset.zero()); 14396} 14397EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 14398 } 14399 14400 /** 14401 * Emit code for rule number 206: 14402 * czr: INT_ADD(r, load32) 14403 * @param p BURS node to apply the rule to 14404 */ 14405 private void code206(AbstractBURS_TreeNode p) { 14406 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 14407 } 14408 14409 /** 14410 * Emit code for rule number 207: 14411 * czr: INT_ADD(load32, riv) 14412 * @param p BURS node to apply the rule to 14413 */ 14414 private void code207(AbstractBURS_TreeNode p) { 14415 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 14416 } 14417 14418 /** 14419 * Emit code for rule number 208: 14420 * stm: INT_STORE(INT_ADD(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14421 * @param p BURS node to apply the rule to 14422 */ 14423 private void code208(AbstractBURS_TreeNode p) { 14424 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p))); 14425 } 14426 14427 /** 14428 * Emit code for rule number 209: 14429 * stm: INT_STORE(INT_ADD(riv,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14430 * @param p BURS node to apply the rule to 14431 */ 14432 private void code209(AbstractBURS_TreeNode p) { 14433 EMIT_Commutative(IA32_ADD, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p))); 14434 } 14435 14436 /** 14437 * Emit code for rule number 210: 14438 * stm: INT_ASTORE(INT_ADD(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14439 * @param p BURS node to apply the rule to 14440 */ 14441 private void code210(AbstractBURS_TreeNode p) { 14442 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p))); 14443 } 14444 14445 /** 14446 * Emit code for rule number 211: 14447 * stm: INT_ASTORE(INT_ADD(riv,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14448 * @param p BURS node to apply the rule to 14449 */ 14450 private void code211(AbstractBURS_TreeNode p) { 14451 EMIT_Commutative(IA32_ADD, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p))); 14452 } 14453 14454 /** 14455 * Emit code for rule number 212: 14456 * szpr: INT_AND(r, riv) 14457 * @param p BURS node to apply the rule to 14458 */ 14459 private void code212(AbstractBURS_TreeNode p) { 14460 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 14461 } 14462 14463 /** 14464 * Emit code for rule number 213: 14465 * szp: INT_AND(r, riv) 14466 * @param p BURS node to apply the rule to 14467 */ 14468 private void code213(AbstractBURS_TreeNode p) { 14469 EMIT(MIR_Test.mutate(P(p), IA32_TEST, Binary.getVal1(P(p)), Binary.getVal2(P(p)))); 14470 } 14471 14472 /** 14473 * Emit code for rule number 214: 14474 * szpr: INT_AND(r, load32) 14475 * @param p BURS node to apply the rule to 14476 */ 14477 private void code214(AbstractBURS_TreeNode p) { 14478 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 14479 } 14480 14481 /** 14482 * Emit code for rule number 215: 14483 * szpr: INT_AND(load32, riv) 14484 * @param p BURS node to apply the rule to 14485 */ 14486 private void code215(AbstractBURS_TreeNode p) { 14487 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 14488 } 14489 14490 /** 14491 * Emit code for rule number 216: 14492 * szp: INT_AND(load8_16_32, riv) 14493 * @param p BURS node to apply the rule to 14494 */ 14495 private void code216(AbstractBURS_TreeNode p) { 14496 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal2(P(p)))); 14497 } 14498 14499 /** 14500 * Emit code for rule number 217: 14501 * szp: INT_AND(r, load8_16_32) 14502 * @param p BURS node to apply the rule to 14503 */ 14504 private void code217(AbstractBURS_TreeNode p) { 14505 EMIT(MIR_Test.mutate(P(p), IA32_TEST, consumeMO(), Binary.getVal1(P(p)))); 14506 } 14507 14508 /** 14509 * Emit code for rule number 218: 14510 * stm: INT_STORE(INT_AND(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14511 * @param p BURS node to apply the rule to 14512 */ 14513 private void code218(AbstractBURS_TreeNode p) { 14514 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 14515 } 14516 14517 /** 14518 * Emit code for rule number 219: 14519 * stm: INT_STORE(INT_AND(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14520 * @param p BURS node to apply the rule to 14521 */ 14522 private void code219(AbstractBURS_TreeNode p) { 14523 EMIT_Commutative(IA32_AND, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 14524 } 14525 14526 /** 14527 * Emit code for rule number 220: 14528 * stm: INT_ASTORE(INT_AND(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14529 * @param p BURS node to apply the rule to 14530 */ 14531 private void code220(AbstractBURS_TreeNode p) { 14532 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 14533 } 14534 14535 /** 14536 * Emit code for rule number 221: 14537 * stm: INT_ASTORE(INT_AND(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14538 * @param p BURS node to apply the rule to 14539 */ 14540 private void code221(AbstractBURS_TreeNode p) { 14541 EMIT_Commutative(IA32_AND, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 14542 } 14543 14544 /** 14545 * Emit code for rule number 222: 14546 * r: INT_DIV(riv, riv) 14547 * @param p BURS node to apply the rule to 14548 */ 14549 private void code222(AbstractBURS_TreeNode p) { 14550 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 14551 GuardedBinary.getVal2(P(p)), true, true); 14552 } 14553 14554 /** 14555 * Emit code for rule number 223: 14556 * r: INT_DIV(riv, load32) 14557 * @param p BURS node to apply the rule to 14558 */ 14559 private void code223(AbstractBURS_TreeNode p) { 14560 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 14561 consumeMO(), true, true); 14562 } 14563 14564 /** 14565 * Emit code for rule number 224: 14566 * stm: INT_IFCMP(r,riv) 14567 * @param p BURS node to apply the rule to 14568 */ 14569 private void code224(AbstractBURS_TreeNode p) { 14570 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 14571 } 14572 14573 /** 14574 * Emit code for rule number 225: 14575 * stm: INT_IFCMP(r, INT_CONSTANT) 14576 * @param p BURS node to apply the rule to 14577 */ 14578 private void code225(AbstractBURS_TreeNode p) { 14579 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14580EMIT(CPOS(P(p), MIR_Test.create(IA32_TEST, IfCmp.getVal1(P(p)), IfCmp.getVal1(P(p)).copy()))); 14581EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14582 } 14583 14584 /** 14585 * Emit code for rule number 226: 14586 * stm: INT_IFCMP(load8, INT_CONSTANT) 14587 * @param p BURS node to apply the rule to 14588 */ 14589 private void code226(AbstractBURS_TreeNode p) { 14590 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 14591 } 14592 14593 /** 14594 * Emit code for rule number 227: 14595 * stm: INT_IFCMP(uload8, r) 14596 * @param p BURS node to apply the rule to 14597 */ 14598 private void code227(AbstractBURS_TreeNode p) { 14599 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 14600 } 14601 14602 /** 14603 * Emit code for rule number 228: 14604 * stm: INT_IFCMP(r, uload8) 14605 * @param p BURS node to apply the rule to 14606 */ 14607 private void code228(AbstractBURS_TreeNode p) { 14608 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), consumeMO(), IfCmp.getCond(P(p))); 14609 } 14610 14611 /** 14612 * Emit code for rule number 229: 14613 * stm: INT_IFCMP(sload16, INT_CONSTANT) 14614 * @param p BURS node to apply the rule to 14615 */ 14616 private void code229(AbstractBURS_TreeNode p) { 14617 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 14618 } 14619 14620 /** 14621 * Emit code for rule number 230: 14622 * stm: INT_IFCMP(load32, riv) 14623 * @param p BURS node to apply the rule to 14624 */ 14625 private void code230(AbstractBURS_TreeNode p) { 14626 IFCMP(P(p), IfCmp.getGuardResult(P(p)), consumeMO(), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p))); 14627 } 14628 14629 /** 14630 * Emit code for rule number 231: 14631 * stm: INT_IFCMP(r, load32) 14632 * @param p BURS node to apply the rule to 14633 */ 14634 private void code231(AbstractBURS_TreeNode p) { 14635 IFCMP(P(p), IfCmp.getGuardResult(P(p)), IfCmp.getVal1(P(p)), consumeMO(), IfCmp.getCond(P(p))); 14636 } 14637 14638 /** 14639 * Emit code for rule number 232: 14640 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 14641 * @param p BURS node to apply the rule to 14642 */ 14643 private void code232(AbstractBURS_TreeNode p) { 14644 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14645EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(consumeCOND()), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14646 } 14647 14648 /** 14649 * Emit code for rule number 233: 14650 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 14651 * @param p BURS node to apply the rule to 14652 */ 14653 private void code233(AbstractBURS_TreeNode p) { 14654 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14655EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(consumeCOND().flipCode()), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14656 } 14657 14658 /** 14659 * Emit code for rule number 234: 14660 * stm: INT_IFCMP(cz, INT_CONSTANT) 14661 * @param p BURS node to apply the rule to 14662 */ 14663 private void code234(AbstractBURS_TreeNode p) { 14664 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14665EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14666 } 14667 14668 /** 14669 * Emit code for rule number 235: 14670 * stm: INT_IFCMP(szp, INT_CONSTANT) 14671 * @param p BURS node to apply the rule to 14672 */ 14673 private void code235(AbstractBURS_TreeNode p) { 14674 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14675EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(IfCmp.getCond(P(p))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14676 } 14677 14678 /** 14679 * Emit code for rule number 236: 14680 * stm: INT_IFCMP(bittest, INT_CONSTANT) 14681 * @param p BURS node to apply the rule to 14682 */ 14683 private void code236(AbstractBURS_TreeNode p) { 14684 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 14685EMIT(MIR_CondBranch.mutate(P(p), IA32_JCC, COND(BIT_TEST(VR(p), IfCmp.getCond(P(p)))), IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p)))); 14686 } 14687 14688 /** 14689 * Emit code for rule number 237: 14690 * stm: INT_IFCMP2(r,riv) 14691 * @param p BURS node to apply the rule to 14692 */ 14693 private void code237(AbstractBURS_TreeNode p) { 14694 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 14695EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, IfCmp2.getVal1(P(p)), IfCmp2.getVal2(P(p))))); 14696EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 14697 COND(IfCmp2.getCond1(P(p))), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 14698 COND(IfCmp2.getCond2(P(p))), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 14699 } 14700 14701 /** 14702 * Emit code for rule number 238: 14703 * stm: INT_IFCMP2(load32,riv) 14704 * @param p BURS node to apply the rule to 14705 */ 14706 private void code238(AbstractBURS_TreeNode p) { 14707 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 14708EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), IfCmp2.getVal2(P(p))))); 14709EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 14710 COND(IfCmp2.getCond1(P(p))), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 14711 COND(IfCmp2.getCond2(P(p))), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 14712 } 14713 14714 /** 14715 * Emit code for rule number 239: 14716 * stm: INT_IFCMP2(riv,load32) 14717 * @param p BURS node to apply the rule to 14718 */ 14719 private void code239(AbstractBURS_TreeNode p) { 14720 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 14721EMIT(CPOS(P(p), MIR_Compare.create(IA32_CMP, consumeMO(), IfCmp2.getVal1(P(p))))); 14722EMIT(MIR_CondBranch2.mutate(P(p), IA32_JCC2, 14723 COND(IfCmp2.getCond1(P(p)).flipOperands()), IfCmp2.getTarget1(P(p)),IfCmp2.getBranchProfile1(P(p)), 14724 COND(IfCmp2.getCond2(P(p)).flipOperands()), IfCmp2.getTarget2(P(p)), IfCmp2.getBranchProfile2(P(p)))); 14725 } 14726 14727 /** 14728 * Emit code for rule number 240: 14729 * r: INT_LOAD(riv, riv) 14730 * @param p BURS node to apply the rule to 14731 */ 14732 private void code240(AbstractBURS_TreeNode p) { 14733 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), MO_L(P(p), DW))); 14734 } 14735 14736 /** 14737 * Emit code for rule number 241: 14738 * r: INT_LOAD(riv, address1scaledreg) 14739 * @param p BURS node to apply the rule to 14740 */ 14741 private void code241(AbstractBURS_TreeNode p) { 14742 augmentAddress(Load.getAddress(P(p))); 14743EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 14744 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 14745 } 14746 14747 /** 14748 * Emit code for rule number 242: 14749 * r: INT_LOAD(address1scaledreg, riv) 14750 * @param p BURS node to apply the rule to 14751 */ 14752 private void code242(AbstractBURS_TreeNode p) { 14753 augmentAddress(Load.getOffset(P(p))); 14754EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 14755 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 14756 } 14757 14758 /** 14759 * Emit code for rule number 243: 14760 * r: INT_LOAD(address1scaledreg, address1reg) 14761 * @param p BURS node to apply the rule to 14762 */ 14763 private void code243(AbstractBURS_TreeNode p) { 14764 combineAddresses(); 14765EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 14766 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 14767 } 14768 14769 /** 14770 * Emit code for rule number 244: 14771 * r: INT_LOAD(address1reg, address1scaledreg) 14772 * @param p BURS node to apply the rule to 14773 */ 14774 private void code244(AbstractBURS_TreeNode p) { 14775 combineAddresses(); 14776EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 14777 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 14778 } 14779 14780 /** 14781 * Emit code for rule number 245: 14782 * r: INT_LOAD(address, INT_CONSTANT) 14783 * @param p BURS node to apply the rule to 14784 */ 14785 private void code245(AbstractBURS_TreeNode p) { 14786 augmentAddress(Load.getOffset(P(p))); 14787EMIT(MIR_Move.mutate(P(p), IA32_MOV, Load.getResult(P(p)), 14788 consumeAddress(DW, Load.getLocation(P(p)), Load.getGuard(P(p))))); 14789 } 14790 14791 /** 14792 * Emit code for rule number 246: 14793 * r: INT_ALOAD(riv, riv) 14794 * @param p BURS node to apply the rule to 14795 */ 14796 private void code246(AbstractBURS_TreeNode p) { 14797 EMIT(MIR_Move.mutate(P(p), IA32_MOV, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 14798 } 14799 14800 /** 14801 * Emit code for rule number 247: 14802 * r: INT_MOVE(riv) 14803 * @param p BURS node to apply the rule to 14804 */ 14805 private void code247(AbstractBURS_TreeNode p) { 14806 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 14807 } 14808 14809 /** 14810 * Emit code for rule number 248: 14811 * czr: INT_MOVE(czr) 14812 * @param p BURS node to apply the rule to 14813 */ 14814 private void code248(AbstractBURS_TreeNode p) { 14815 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 14816 } 14817 14818 /** 14819 * Emit code for rule number 250: 14820 * szpr: INT_MOVE(szpr) 14821 * @param p BURS node to apply the rule to 14822 */ 14823 private void code250(AbstractBURS_TreeNode p) { 14824 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Move.getResult(P(p)), Move.getVal(P(p)))); 14825 } 14826 14827 /** 14828 * Emit code for rule number 259: 14829 * r: INT_MUL(r, riv) 14830 * @param p BURS node to apply the rule to 14831 */ 14832 private void code259(AbstractBURS_TreeNode p) { 14833 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 14834 } 14835 14836 /** 14837 * Emit code for rule number 260: 14838 * r: INT_MUL(r, load32) 14839 * @param p BURS node to apply the rule to 14840 */ 14841 private void code260(AbstractBURS_TreeNode p) { 14842 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 14843 } 14844 14845 /** 14846 * Emit code for rule number 261: 14847 * r: INT_MUL(load32, riv) 14848 * @param p BURS node to apply the rule to 14849 */ 14850 private void code261(AbstractBURS_TreeNode p) { 14851 EMIT_Commutative(IA32_IMUL2, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 14852 } 14853 14854 /** 14855 * Emit code for rule number 262: 14856 * szpr: INT_NEG(r) 14857 * @param p BURS node to apply the rule to 14858 */ 14859 private void code262(AbstractBURS_TreeNode p) { 14860 EMIT_Unary(IA32_NEG, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 14861 } 14862 14863 /** 14864 * Emit code for rule number 263: 14865 * stm: INT_STORE(INT_NEG(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14866 * @param p BURS node to apply the rule to 14867 */ 14868 private void code263(AbstractBURS_TreeNode p) { 14869 EMIT_Unary(IA32_NEG, P(p), MO_S(P(p), DW), MO_S(P(p), DW)); 14870 } 14871 14872 /** 14873 * Emit code for rule number 264: 14874 * stm: INT_ASTORE(INT_NEG(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14875 * @param p BURS node to apply the rule to 14876 */ 14877 private void code264(AbstractBURS_TreeNode p) { 14878 EMIT_Unary(IA32_NEG, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW)); 14879 } 14880 14881 /** 14882 * Emit code for rule number 265: 14883 * r: INT_NOT(r) 14884 * @param p BURS node to apply the rule to 14885 */ 14886 private void code265(AbstractBURS_TreeNode p) { 14887 EMIT_Unary(IA32_NOT, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 14888 } 14889 14890 /** 14891 * Emit code for rule number 266: 14892 * stm: INT_STORE(INT_NOT(INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14893 * @param p BURS node to apply the rule to 14894 */ 14895 private void code266(AbstractBURS_TreeNode p) { 14896 EMIT_Unary(IA32_NOT, P(p), MO_S(P(p), DW), MO_S(P(p), DW)); 14897 } 14898 14899 /** 14900 * Emit code for rule number 267: 14901 * stm: INT_ASTORE(INT_NOT(INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14902 * @param p BURS node to apply the rule to 14903 */ 14904 private void code267(AbstractBURS_TreeNode p) { 14905 EMIT_Unary(IA32_NOT, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW)); 14906 } 14907 14908 /** 14909 * Emit code for rule number 268: 14910 * szpr: INT_OR(r, riv) 14911 * @param p BURS node to apply the rule to 14912 */ 14913 private void code268(AbstractBURS_TreeNode p) { 14914 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 14915 } 14916 14917 /** 14918 * Emit code for rule number 269: 14919 * szpr: INT_OR(r, load32) 14920 * @param p BURS node to apply the rule to 14921 */ 14922 private void code269(AbstractBURS_TreeNode p) { 14923 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO() ); 14924 } 14925 14926 /** 14927 * Emit code for rule number 270: 14928 * szpr: INT_OR(load32, riv) 14929 * @param p BURS node to apply the rule to 14930 */ 14931 private void code270(AbstractBURS_TreeNode p) { 14932 EMIT_Commutative(IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO() ); 14933 } 14934 14935 /** 14936 * Emit code for rule number 271: 14937 * stm: INT_STORE(INT_OR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14938 * @param p BURS node to apply the rule to 14939 */ 14940 private void code271(AbstractBURS_TreeNode p) { 14941 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 14942 } 14943 14944 /** 14945 * Emit code for rule number 272: 14946 * stm: INT_STORE(INT_OR(r, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14947 * @param p BURS node to apply the rule to 14948 */ 14949 private void code272(AbstractBURS_TreeNode p) { 14950 EMIT_Commutative(IA32_OR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 14951 } 14952 14953 /** 14954 * Emit code for rule number 273: 14955 * stm: INT_ASTORE(INT_OR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 14956 * @param p BURS node to apply the rule to 14957 */ 14958 private void code273(AbstractBURS_TreeNode p) { 14959 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 14960 } 14961 14962 /** 14963 * Emit code for rule number 274: 14964 * stm: INT_ASTORE(INT_OR(r, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 14965 * @param p BURS node to apply the rule to 14966 */ 14967 private void code274(AbstractBURS_TreeNode p) { 14968 EMIT_Commutative(IA32_OR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 14969 } 14970 14971 /** 14972 * Emit code for rule number 275: 14973 * r: INT_REM(riv, riv) 14974 * @param p BURS node to apply the rule to 14975 */ 14976 private void code275(AbstractBURS_TreeNode p) { 14977 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 14978 GuardedBinary.getVal2(P(p)), false, true); 14979 } 14980 14981 /** 14982 * Emit code for rule number 276: 14983 * r: INT_REM(riv, load32) 14984 * @param p BURS node to apply the rule to 14985 */ 14986 private void code276(AbstractBURS_TreeNode p) { 14987 INT_DIVIDES(P(p), GuardedBinary.getResult(P(p)), GuardedBinary.getVal1(P(p)), 14988 consumeMO(), false, true); 14989 } 14990 14991 /** 14992 * Emit code for rule number 277: 14993 * r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 14994 * @param p BURS node to apply the rule to 14995 */ 14996 private void code277(AbstractBURS_TreeNode p) { 14997 EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(VLR(p)&0x1f)); 14998 } 14999 15000 /** 15001 * Emit code for rule number 278: 15002 * r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 15003 * @param p BURS node to apply the rule to 15004 */ 15005 private void code278(AbstractBURS_TreeNode p) { 15006 EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(VRR(p)&0x1f)); 15007 } 15008 15009 /** 15010 * Emit code for rule number 279: 15011 * r: INT_OR(INT_SHL(r,INT_CONSTANT),INT_USHR(r,INT_CONSTANT)) 15012 * @param p BURS node to apply the rule to 15013 */ 15014 private void code279(AbstractBURS_TreeNode p) { 15015 EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(1)); 15016 } 15017 15018 /** 15019 * Emit code for rule number 280: 15020 * r: INT_OR(INT_USHR(r,INT_CONSTANT),INT_SHL(r,INT_CONSTANT)) 15021 * @param p BURS node to apply the rule to 15022 */ 15023 private void code280(AbstractBURS_TreeNode p) { 15024 EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), IC(1)); 15025 } 15026 15027 /** 15028 * Emit code for rule number 281: 15029 * r: INT_OR(INT_SHL(r,INT_AND(r,INT_CONSTANT)),INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 15030 * @param p BURS node to apply the rule to 15031 */ 15032 private void code281(AbstractBURS_TreeNode p) { 15033 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 15034EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 15035 } 15036 15037 /** 15038 * Emit code for rule number 282: 15039 * r: INT_OR(INT_USHR(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_SHL(r,INT_AND(r,INT_CONSTANT))) 15040 * @param p BURS node to apply the rule to 15041 */ 15042 private void code282(AbstractBURS_TreeNode p) { 15043 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PRR(p))))); 15044EMIT_NonCommutative(IA32_ROL, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 15045 } 15046 15047 /** 15048 * Emit code for rule number 283: 15049 * r: INT_OR(INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT)),INT_USHR(r,INT_AND(r,INT_CONSTANT))) 15050 * @param p BURS node to apply the rule to 15051 */ 15052 private void code283(AbstractBURS_TreeNode p) { 15053 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PRR(p))))); 15054EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 15055 } 15056 15057 /** 15058 * Emit code for rule number 284: 15059 * r: INT_OR(INT_USHR(r,INT_AND(r,INT_CONSTANT)),INT_SHL(r,INT_AND(INT_NEG(r),INT_CONSTANT))) 15060 * @param p BURS node to apply the rule to 15061 */ 15062 private void code284(AbstractBURS_TreeNode p) { 15063 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 15064EMIT_NonCommutative(IA32_ROR, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)).copy(), new RegisterOperand(getECX(), TypeReference.Int)); 15065 } 15066 15067 /** 15068 * Emit code for rule number 285: 15069 * szpr: INT_SHL(riv, INT_AND(r, INT_CONSTANT)) 15070 * @param p BURS node to apply the rule to 15071 */ 15072 private void code285(AbstractBURS_TreeNode p) { 15073 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 15074EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15075 } 15076 15077 /** 15078 * Emit code for rule number 286: 15079 * szpr: INT_SHL(riv, riv) 15080 * @param p BURS node to apply the rule to 15081 */ 15082 private void code286(AbstractBURS_TreeNode p) { 15083 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 15084EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15085 } 15086 15087 /** 15088 * Emit code for rule number 287: 15089 * szpr: INT_SHL(r, INT_CONSTANT) 15090 * @param p BURS node to apply the rule to 15091 */ 15092 private void code287(AbstractBURS_TreeNode p) { 15093 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); if(Binary.getVal2(P(p)).asIntConstant().value == 1) { 15094 EMIT_Commutative(IA32_ADD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(P(p)).copy()); 15095} else { 15096 EMIT_NonCommutative(IA32_SHL, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 15097} 15098 } 15099 15100 /** 15101 * Emit code for rule number 288: 15102 * r: INT_SHL(r, INT_CONSTANT) 15103 * @param p BURS node to apply the rule to 15104 */ 15105 private void code288(AbstractBURS_TreeNode p) { 15106 pushAddress(null, Binary.getVal1(P(p)).asRegister(), LEA_SHIFT(Binary.getVal2(P(p))), Offset.zero()); 15107EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15108 } 15109 15110 /** 15111 * Emit code for rule number 289: 15112 * szpr: INT_SHL(INT_SHR(r, INT_CONSTANT), INT_CONSTANT) 15113 * @param p BURS node to apply the rule to 15114 */ 15115 private void code289(AbstractBURS_TreeNode p) { 15116 EMIT_Commutative(IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)), IC(0xffffffff << VR(p))); 15117 } 15118 15119 /** 15120 * Emit code for rule number 290: 15121 * stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15122 * @param p BURS node to apply the rule to 15123 */ 15124 private void code290(AbstractBURS_TreeNode p) { 15125 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 15126EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 15127 } 15128 15129 /** 15130 * Emit code for rule number 291: 15131 * stm: INT_STORE(INT_SHL(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15132 * @param p BURS node to apply the rule to 15133 */ 15134 private void code291(AbstractBURS_TreeNode p) { 15135 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 15136EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 15137 } 15138 15139 /** 15140 * Emit code for rule number 292: 15141 * stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15142 * @param p BURS node to apply the rule to 15143 */ 15144 private void code292(AbstractBURS_TreeNode p) { 15145 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 15146EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 15147 } 15148 15149 /** 15150 * Emit code for rule number 293: 15151 * stm: INT_ASTORE(INT_SHL(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15152 * @param p BURS node to apply the rule to 15153 */ 15154 private void code293(AbstractBURS_TreeNode p) { 15155 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHL, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 15156 } 15157 15158 /** 15159 * Emit code for rule number 294: 15160 * szpr: INT_SHR(riv, INT_AND(r, INT_CONSTANT)) 15161 * @param p BURS node to apply the rule to 15162 */ 15163 private void code294(AbstractBURS_TreeNode p) { 15164 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 15165EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15166 } 15167 15168 /** 15169 * Emit code for rule number 295: 15170 * szpr: INT_SHR(riv, riv) 15171 * @param p BURS node to apply the rule to 15172 */ 15173 private void code295(AbstractBURS_TreeNode p) { 15174 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 15175EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15176 } 15177 15178 /** 15179 * Emit code for rule number 296: 15180 * szpr: INT_SHR(riv, INT_CONSTANT) 15181 * @param p BURS node to apply the rule to 15182 */ 15183 private void code296(AbstractBURS_TreeNode p) { 15184 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); 15185EMIT_NonCommutative(IA32_SAR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 15186 } 15187 15188 /** 15189 * Emit code for rule number 297: 15190 * stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15191 * @param p BURS node to apply the rule to 15192 */ 15193 private void code297(AbstractBURS_TreeNode p) { 15194 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 15195EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 15196 } 15197 15198 /** 15199 * Emit code for rule number 298: 15200 * stm: INT_STORE(INT_SHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15201 * @param p BURS node to apply the rule to 15202 */ 15203 private void code298(AbstractBURS_TreeNode p) { 15204 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 15205EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 15206 } 15207 15208 /** 15209 * Emit code for rule number 299: 15210 * stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15211 * @param p BURS node to apply the rule to 15212 */ 15213 private void code299(AbstractBURS_TreeNode p) { 15214 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 15215EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 15216 } 15217 15218 /** 15219 * Emit code for rule number 300: 15220 * stm: INT_ASTORE(INT_SHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15221 * @param p BURS node to apply the rule to 15222 */ 15223 private void code300(AbstractBURS_TreeNode p) { 15224 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SAR, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 15225 } 15226 15227 /** 15228 * Emit code for rule number 301: 15229 * stm: INT_STORE(riv, OTHER_OPERAND(riv, riv)) 15230 * @param p BURS node to apply the rule to 15231 */ 15232 private void code301(AbstractBURS_TreeNode p) { 15233 EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), Store.getValue(P(p)))); 15234 } 15235 15236 /** 15237 * Emit code for rule number 302: 15238 * stm: INT_STORE(riv, OTHER_OPERAND(riv, address1scaledreg)) 15239 * @param p BURS node to apply the rule to 15240 */ 15241 private void code302(AbstractBURS_TreeNode p) { 15242 augmentAddress(Store.getAddress(P(p))); 15243EMIT(MIR_Move.mutate(P(p), IA32_MOV, 15244 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 15245 Store.getValue(P(p)))); 15246 } 15247 15248 /** 15249 * Emit code for rule number 303: 15250 * stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, riv)) 15251 * @param p BURS node to apply the rule to 15252 */ 15253 private void code303(AbstractBURS_TreeNode p) { 15254 augmentAddress(Store.getOffset(P(p))); 15255EMIT(MIR_Move.mutate(P(p), IA32_MOV, 15256 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 15257 Store.getValue(P(p)))); 15258 } 15259 15260 /** 15261 * Emit code for rule number 304: 15262 * stm: INT_STORE(riv, OTHER_OPERAND(address1scaledreg, address1reg)) 15263 * @param p BURS node to apply the rule to 15264 */ 15265 private void code304(AbstractBURS_TreeNode p) { 15266 combineAddresses(); 15267EMIT(MIR_Move.mutate(P(p), IA32_MOV, 15268 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 15269 Store.getValue(P(p)))); 15270 } 15271 15272 /** 15273 * Emit code for rule number 305: 15274 * stm: INT_STORE(riv, OTHER_OPERAND(address1reg, address1scaledreg)) 15275 * @param p BURS node to apply the rule to 15276 */ 15277 private void code305(AbstractBURS_TreeNode p) { 15278 combineAddresses(); 15279EMIT(MIR_Move.mutate(P(p), IA32_MOV, 15280 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 15281 Store.getValue(P(p)))); 15282 } 15283 15284 /** 15285 * Emit code for rule number 306: 15286 * stm: INT_STORE(riv, OTHER_OPERAND(address, INT_CONSTANT)) 15287 * @param p BURS node to apply the rule to 15288 */ 15289 private void code306(AbstractBURS_TreeNode p) { 15290 augmentAddress(Store.getOffset(P(p))); 15291EMIT(MIR_Move.mutate(P(p), IA32_MOV, 15292 consumeAddress(DW, Store.getLocation(P(p)), Store.getGuard(P(p))), 15293 Store.getValue(P(p)))); 15294 } 15295 15296 /** 15297 * Emit code for rule number 307: 15298 * czr: INT_SUB(riv, r) 15299 * @param p BURS node to apply the rule to 15300 */ 15301 private void code307(AbstractBURS_TreeNode p) { 15302 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 15303 } 15304 15305 /** 15306 * Emit code for rule number 308: 15307 * r: INT_SUB(riv, r) 15308 * @param p BURS node to apply the rule to 15309 */ 15310 private void code308(AbstractBURS_TreeNode p) { 15311 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 15312EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), Binary.getVal1(P(p)))); 15313 } 15314 15315 /** 15316 * Emit code for rule number 309: 15317 * r: INT_SUB(load32, r) 15318 * @param p BURS node to apply the rule to 15319 */ 15320 private void code309(AbstractBURS_TreeNode p) { 15321 EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, Binary.getResult(P(p))))); 15322EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, Binary.getResult(P(p)), consumeMO())); 15323 } 15324 15325 /** 15326 * Emit code for rule number 310: 15327 * czr: INT_SUB(riv, load32) 15328 * @param p BURS node to apply the rule to 15329 */ 15330 private void code310(AbstractBURS_TreeNode p) { 15331 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 15332 } 15333 15334 /** 15335 * Emit code for rule number 311: 15336 * czr: INT_SUB(load32, riv) 15337 * @param p BURS node to apply the rule to 15338 */ 15339 private void code311(AbstractBURS_TreeNode p) { 15340 EMIT_NonCommutative(IA32_SUB, P(p), Binary.getResult(P(p)), consumeMO(), Binary.getVal2(P(p))); 15341 } 15342 15343 /** 15344 * Emit code for rule number 312: 15345 * stm: INT_STORE(INT_SUB(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 15346 * @param p BURS node to apply the rule to 15347 */ 15348 private void code312(AbstractBURS_TreeNode p) { 15349 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 15350 } 15351 15352 /** 15353 * Emit code for rule number 313: 15354 * stm: INT_STORE(INT_SUB(riv, INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 15355 * @param p BURS node to apply the rule to 15356 */ 15357 private void code313(AbstractBURS_TreeNode p) { 15358 MemoryOperand result = MO_S(P(p), DW); 15359EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 15360EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 15361 } 15362 15363 /** 15364 * Emit code for rule number 314: 15365 * stm: INT_ASTORE(INT_SUB(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 15366 * @param p BURS node to apply the rule to 15367 */ 15368 private void code314(AbstractBURS_TreeNode p) { 15369 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SUB, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 15370 } 15371 15372 /** 15373 * Emit code for rule number 315: 15374 * stm: INT_ASTORE(INT_SUB(riv, INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 15375 * @param p BURS node to apply the rule to 15376 */ 15377 private void code315(AbstractBURS_TreeNode p) { 15378 MemoryOperand result = MO_AS(P(p), DW_S, DW); 15379EMIT(CPOS(P(p), MIR_UnaryAcc.create(IA32_NEG, result))); 15380EMIT(MIR_BinaryAcc.mutate(P(p), IA32_ADD, result.copy(), Binary.getVal1(PL(p)))); 15381 } 15382 15383 /** 15384 * Emit code for rule number 316: 15385 * szpr: INT_USHR(riv, INT_AND(r, INT_CONSTANT)) 15386 * @param p BURS node to apply the rule to 15387 */ 15388 private void code316(AbstractBURS_TreeNode p) { 15389 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PR(p))))); 15390EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15391 } 15392 15393 /** 15394 * Emit code for rule number 317: 15395 * szpr: INT_USHR(riv, riv) 15396 * @param p BURS node to apply the rule to 15397 */ 15398 private void code317(AbstractBURS_TreeNode p) { 15399 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal2(P(p))))); 15400EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), new RegisterOperand(getECX(), TypeReference.Int)); 15401 } 15402 15403 /** 15404 * Emit code for rule number 318: 15405 * szpr: INT_USHR(riv, INT_CONSTANT) 15406 * @param p BURS node to apply the rule to 15407 */ 15408 private void code318(AbstractBURS_TreeNode p) { 15409 if (VM.VerifyAssertions) VM._assert((VR(p) & 0x7FFFFFFF) <= 31); 15410EMIT_NonCommutative(IA32_SHR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 15411 } 15412 15413 /** 15414 * Emit code for rule number 319: 15415 * stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv),INT_AND(r,INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15416 * @param p BURS node to apply the rule to 15417 */ 15418 private void code319(AbstractBURS_TreeNode p) { 15419 EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p))))); 15420EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), DW), new RegisterOperand(getECX(), TypeReference.Int))); 15421 } 15422 15423 /** 15424 * Emit code for rule number 320: 15425 * stm: INT_STORE(INT_USHR(INT_LOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15426 * @param p BURS node to apply the rule to 15427 */ 15428 private void code320(AbstractBURS_TreeNode p) { 15429 if (VM.VerifyAssertions) VM._assert((VLR(p) & 0x7FFFFFFF) <= 31); 15430EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_S(P(p), DW), Binary.getVal2(PL(p)))); 15431 } 15432 15433 /** 15434 * Emit code for rule number 321: 15435 * stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv),INT_AND(r, INT_CONSTANT)),OTHER_OPERAND(riv, riv)) 15436 * @param p BURS node to apply the rule to 15437 */ 15438 private void code321(AbstractBURS_TreeNode p) { 15439 EMIT(MIR_Move.create(IA32_MOV, new RegisterOperand(getECX(), TypeReference.Int), Binary.getVal1(PLR(p)))); 15440EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), DW_S, DW), new RegisterOperand(getECX(), TypeReference.Int))); 15441 } 15442 15443 /** 15444 * Emit code for rule number 322: 15445 * stm: INT_ASTORE(INT_USHR(INT_ALOAD(riv,riv), INT_CONSTANT),OTHER_OPERAND(riv, riv)) 15446 * @param p BURS node to apply the rule to 15447 */ 15448 private void code322(AbstractBURS_TreeNode p) { 15449 EMIT(MIR_BinaryAcc.mutate(P(p), IA32_SHR, MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)))); 15450 } 15451 15452 /** 15453 * Emit code for rule number 323: 15454 * szpr: INT_XOR(r, riv) 15455 * @param p BURS node to apply the rule to 15456 */ 15457 private void code323(AbstractBURS_TreeNode p) { 15458 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 15459 } 15460 15461 /** 15462 * Emit code for rule number 324: 15463 * szpr: INT_XOR(r, load32) 15464 * @param p BURS node to apply the rule to 15465 */ 15466 private void code324(AbstractBURS_TreeNode p) { 15467 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO() ); 15468 } 15469 15470 /** 15471 * Emit code for rule number 325: 15472 * szpr: INT_XOR(load32, riv) 15473 * @param p BURS node to apply the rule to 15474 */ 15475 private void code325(AbstractBURS_TreeNode p) { 15476 EMIT_Commutative(IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO() ); 15477 } 15478 15479 /** 15480 * Emit code for rule number 326: 15481 * stm: INT_STORE(INT_XOR(INT_LOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 15482 * @param p BURS node to apply the rule to 15483 */ 15484 private void code326(AbstractBURS_TreeNode p) { 15485 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal2(PL(p)) ); 15486 } 15487 15488 /** 15489 * Emit code for rule number 327: 15490 * stm: INT_STORE(INT_XOR(r,INT_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 15491 * @param p BURS node to apply the rule to 15492 */ 15493 private void code327(AbstractBURS_TreeNode p) { 15494 EMIT_Commutative(IA32_XOR, P(p), MO_S(P(p), DW), MO_S(P(p), DW), Binary.getVal1(PL(p)) ); 15495 } 15496 15497 /** 15498 * Emit code for rule number 328: 15499 * stm: INT_ASTORE(INT_XOR(INT_ALOAD(riv,riv),riv),OTHER_OPERAND(riv, riv)) 15500 * @param p BURS node to apply the rule to 15501 */ 15502 private void code328(AbstractBURS_TreeNode p) { 15503 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal2(PL(p)) ); 15504 } 15505 15506 /** 15507 * Emit code for rule number 329: 15508 * stm: INT_ASTORE(INT_XOR(r,INT_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 15509 * @param p BURS node to apply the rule to 15510 */ 15511 private void code329(AbstractBURS_TreeNode p) { 15512 EMIT_Commutative(IA32_XOR, P(p), MO_AS(P(p), DW_S, DW), MO_AS(P(p), DW_S, DW), Binary.getVal1(PL(p)) ); 15513 } 15514 15515 /** 15516 * Emit code for rule number 330: 15517 * r: LCMP_CMOV(r, OTHER_OPERAND(rlv, any)) 15518 * @param p BURS node to apply the rule to 15519 */ 15520 private void code330(AbstractBURS_TreeNode p) { 15521 LCMP_CMOV(P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p)), CondMove.getVal2(P(p)), 15522 CondMove.getCond(P(p)), CondMove.getTrueValue(P(p)), CondMove.getFalseValue(P(p))); 15523 } 15524 15525 /** 15526 * Emit code for rule number 331: 15527 * r: INT_ADD(address1scaledreg, r) 15528 * @param p BURS node to apply the rule to 15529 */ 15530 private void code331(AbstractBURS_TreeNode p) { 15531 augmentAddress(Binary.getVal2(P(p))); 15532EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15533 } 15534 15535 /** 15536 * Emit code for rule number 332: 15537 * r: INT_ADD(r, address1scaledreg) 15538 * @param p BURS node to apply the rule to 15539 */ 15540 private void code332(AbstractBURS_TreeNode p) { 15541 augmentAddress(Binary.getVal1(P(p))); 15542EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15543 } 15544 15545 /** 15546 * Emit code for rule number 333: 15547 * r: INT_ADD(address1scaledreg, address1reg) 15548 * @param p BURS node to apply the rule to 15549 */ 15550 private void code333(AbstractBURS_TreeNode p) { 15551 combineAddresses(); 15552EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15553 } 15554 15555 /** 15556 * Emit code for rule number 334: 15557 * r: INT_ADD(address1reg, address1scaledreg) 15558 * @param p BURS node to apply the rule to 15559 */ 15560 private void code334(AbstractBURS_TreeNode p) { 15561 combineAddresses(); 15562EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15563 } 15564 15565 /** 15566 * Emit code for rule number 335: 15567 * r: INT_ADD(address, INT_CONSTANT) 15568 * @param p BURS node to apply the rule to 15569 */ 15570 private void code335(AbstractBURS_TreeNode p) { 15571 augmentAddress(Binary.getVal2(P(p))); 15572EMIT_Lea(P(p), Binary.getResult(P(p)), consumeAddress(DW, null, null)); 15573 } 15574 15575 /** 15576 * Emit code for rule number 336: 15577 * r: INT_MOVE(address) 15578 * @param p BURS node to apply the rule to 15579 */ 15580 private void code336(AbstractBURS_TreeNode p) { 15581 EMIT_Lea(P(p), Move.getResult(P(p)), consumeAddress(DW, null, null)); 15582 } 15583 15584 /** 15585 * Emit code for rule number 337: 15586 * r: BYTE_LOAD(riv, riv) 15587 * @param p BURS node to apply the rule to 15588 */ 15589 private void code337(AbstractBURS_TreeNode p) { 15590 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, Load.getResult(P(p)), MO_L(P(p), B))); 15591 } 15592 15593 /** 15594 * Emit code for rule number 338: 15595 * sload8: BYTE_LOAD(riv, riv) 15596 * @param p BURS node to apply the rule to 15597 */ 15598 private void code338(AbstractBURS_TreeNode p) { 15599 pushMO(MO_L(P(p), B)); 15600 } 15601 15602 /** 15603 * Emit code for rule number 339: 15604 * r: BYTE_ALOAD(riv, riv) 15605 * @param p BURS node to apply the rule to 15606 */ 15607 private void code339(AbstractBURS_TreeNode p) { 15608 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 15609 } 15610 15611 /** 15612 * Emit code for rule number 340: 15613 * sload8: BYTE_ALOAD(riv, riv) 15614 * @param p BURS node to apply the rule to 15615 */ 15616 private void code340(AbstractBURS_TreeNode p) { 15617 pushMO(MO_AL(P(p), B_S, B)); 15618 } 15619 15620 /** 15621 * Emit code for rule number 341: 15622 * r: UBYTE_LOAD(riv, riv) 15623 * @param p BURS node to apply the rule to 15624 */ 15625 private void code341(AbstractBURS_TreeNode p) { 15626 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, Load.getResult(P(p)), MO_L(P(p), B))); 15627 } 15628 15629 /** 15630 * Emit code for rule number 342: 15631 * uload8: UBYTE_LOAD(riv, riv) 15632 * @param p BURS node to apply the rule to 15633 */ 15634 private void code342(AbstractBURS_TreeNode p) { 15635 pushMO(MO_L(P(p), B)); 15636 } 15637 15638 /** 15639 * Emit code for rule number 343: 15640 * r: UBYTE_ALOAD(riv, riv) 15641 * @param p BURS node to apply the rule to 15642 */ 15643 private void code343(AbstractBURS_TreeNode p) { 15644 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__B, ALoad.getResult(P(p)), MO_AL(P(p), B_S, B))); 15645 } 15646 15647 /** 15648 * Emit code for rule number 344: 15649 * uload8: UBYTE_ALOAD(riv, riv) 15650 * @param p BURS node to apply the rule to 15651 */ 15652 private void code344(AbstractBURS_TreeNode p) { 15653 pushMO(MO_AL(P(p), B_S, B)); 15654 } 15655 15656 /** 15657 * Emit code for rule number 347: 15658 * r: SHORT_LOAD(riv, riv) 15659 * @param p BURS node to apply the rule to 15660 */ 15661 private void code347(AbstractBURS_TreeNode p) { 15662 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, Load.getResult(P(p)), MO_L(P(p), W))); 15663 } 15664 15665 /** 15666 * Emit code for rule number 348: 15667 * sload16: SHORT_LOAD(riv, riv) 15668 * @param p BURS node to apply the rule to 15669 */ 15670 private void code348(AbstractBURS_TreeNode p) { 15671 pushMO(MO_L(P(p), W)); 15672 } 15673 15674 /** 15675 * Emit code for rule number 349: 15676 * r: SHORT_ALOAD(riv, riv) 15677 * @param p BURS node to apply the rule to 15678 */ 15679 private void code349(AbstractBURS_TreeNode p) { 15680 EMIT(MIR_Unary.mutate(P(p), IA32_MOVSX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 15681 } 15682 15683 /** 15684 * Emit code for rule number 350: 15685 * sload16: SHORT_ALOAD(riv, riv) 15686 * @param p BURS node to apply the rule to 15687 */ 15688 private void code350(AbstractBURS_TreeNode p) { 15689 pushMO(MO_AL(P(p), W_S, W)); 15690 } 15691 15692 /** 15693 * Emit code for rule number 351: 15694 * r: USHORT_LOAD(riv, riv) 15695 * @param p BURS node to apply the rule to 15696 */ 15697 private void code351(AbstractBURS_TreeNode p) { 15698 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, Load.getResult(P(p)), MO_L(P(p), W))); 15699 } 15700 15701 /** 15702 * Emit code for rule number 352: 15703 * uload16: USHORT_LOAD(riv, riv) 15704 * @param p BURS node to apply the rule to 15705 */ 15706 private void code352(AbstractBURS_TreeNode p) { 15707 pushMO(MO_L(P(p), W)); 15708 } 15709 15710 /** 15711 * Emit code for rule number 353: 15712 * r: USHORT_ALOAD(riv, riv) 15713 * @param p BURS node to apply the rule to 15714 */ 15715 private void code353(AbstractBURS_TreeNode p) { 15716 EMIT(MIR_Unary.mutate(P(p), IA32_MOVZX__W, ALoad.getResult(P(p)), MO_AL(P(p), W_S, W))); 15717 } 15718 15719 /** 15720 * Emit code for rule number 354: 15721 * uload16: USHORT_ALOAD(riv, riv) 15722 * @param p BURS node to apply the rule to 15723 */ 15724 private void code354(AbstractBURS_TreeNode p) { 15725 pushMO(MO_AL(P(p), W_S, W)); 15726 } 15727 15728 /** 15729 * Emit code for rule number 357: 15730 * load32: INT_LOAD(riv, riv) 15731 * @param p BURS node to apply the rule to 15732 */ 15733 private void code357(AbstractBURS_TreeNode p) { 15734 pushMO(MO_L(P(p), DW)); 15735 } 15736 15737 /** 15738 * Emit code for rule number 358: 15739 * load32: INT_ALOAD(riv, riv) 15740 * @param p BURS node to apply the rule to 15741 */ 15742 private void code358(AbstractBURS_TreeNode p) { 15743 pushMO(MO_AL(P(p), DW_S, DW)); 15744 } 15745 15746 /** 15747 * Emit code for rule number 363: 15748 * load64: LONG_LOAD(riv, riv) 15749 * @param p BURS node to apply the rule to 15750 */ 15751 private void code363(AbstractBURS_TreeNode p) { 15752 pushMO(MO_L(P(p), QW)); 15753 } 15754 15755 /** 15756 * Emit code for rule number 364: 15757 * load64: LONG_ALOAD(riv, riv) 15758 * @param p BURS node to apply the rule to 15759 */ 15760 private void code364(AbstractBURS_TreeNode p) { 15761 pushMO(MO_AL(P(p), QW_S, QW)); 15762 } 15763 15764 /** 15765 * Emit code for rule number 365: 15766 * r: LONG_2INT(r) 15767 * @param p BURS node to apply the rule to 15768 */ 15769 private void code365(AbstractBURS_TreeNode p) { 15770 RegisterOperand val = R(Unary.getVal(P(p))); 15771if (VM.BuildFor64Addr) { 15772RegisterOperand r = Unary.getResult(P(p)); 15773RegisterOperand temp = regpool.makeTempInt(); 15774EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 15775EMIT(MIR_Move.mutate(P(p), IA32_MOV, r, temp)); 15776} else { 15777Register lh = regpool.getSecondReg(R(Unary.getVal(P(p))).getRegister()); 15778EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(lh, TypeReference.Int))); 15779} 15780 } 15781 15782 /** 15783 * Emit code for rule number 366: 15784 * stm: INT_STORE(LONG_2INT(r), OTHER_OPERAND(riv,riv)) 15785 * @param p BURS node to apply the rule to 15786 */ 15787 private void code366(AbstractBURS_TreeNode p) { 15788 RegisterOperand val = R(Unary.getVal(PL(p))); 15789if (VM.BuildFor64Addr) { 15790RegisterOperand temp = regpool.makeTempInt(); 15791EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 15792EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW),temp)); 15793} else { 15794Register lh = regpool.getSecondReg(R(Unary.getVal(PL(p))).getRegister()); 15795EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), new RegisterOperand(lh, TypeReference.Int))); 15796} 15797 } 15798 15799 /** 15800 * Emit code for rule number 367: 15801 * stm: INT_ASTORE(LONG_2INT(r), OTHER_OPERAND(riv, riv)) 15802 * @param p BURS node to apply the rule to 15803 */ 15804 private void code367(AbstractBURS_TreeNode p) { 15805 RegisterOperand val = R(Unary.getVal(PL(p))); 15806if (VM.BuildFor64Addr) { 15807RegisterOperand temp = regpool.makeTempInt(); 15808EMIT(CPOS(P(p),MIR_Move.create(IA32_MOV, temp, val))); 15809EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW),temp)); 15810} else { 15811Register lh = regpool.getSecondReg(R(Unary.getVal(PL(p))).getRegister()); 15812EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_AS(P(p), DW_S, DW), new RegisterOperand(lh, TypeReference.Int))); 15813} 15814 } 15815 15816 /** 15817 * Emit code for rule number 368: 15818 * r: LONG_2INT(load64) 15819 * @param p BURS node to apply the rule to 15820 */ 15821 private void code368(AbstractBURS_TreeNode p) { 15822 EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), setSize(consumeMO(), 4))); 15823 } 15824 15825 /** 15826 * Emit code for rule number 369: 15827 * load32: LONG_2INT(load64) 15828 * @param p BURS node to apply the rule to 15829 */ 15830 private void code369(AbstractBURS_TreeNode p) { 15831 pushMO(setSize(consumeMO(), 4)); 15832 } 15833 15834 /** 15835 * Emit code for rule number 370: 15836 * r: LONG_2INT(LONG_USHR(r, INT_CONSTANT)) 15837 * @param p BURS node to apply the rule to 15838 */ 15839 private void code370(AbstractBURS_TreeNode p) { 15840 RegisterOperand val = R(Binary.getVal1(PL(p))); 15841if (VM.BuildFor64Addr) { 15842RegisterOperand temp = regpool.makeTempInt(); 15843EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 15844EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_SHR,temp,LC(32)))); 15845EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), temp)); 15846} else { 15847Register uh = Binary.getVal1(PL(p)).asRegister().getRegister(); 15848EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(uh, TypeReference.Int))); 15849} 15850 } 15851 15852 /** 15853 * Emit code for rule number 371: 15854 * r: LONG_2INT(LONG_SHR(r, INT_CONSTANT)) 15855 * @param p BURS node to apply the rule to 15856 */ 15857 private void code371(AbstractBURS_TreeNode p) { 15858 RegisterOperand val = R(Binary.getVal1(PL(p))); 15859if (VM.BuildFor64Addr) { 15860RegisterOperand temp = regpool.makeTempInt(); 15861EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, temp, val))); 15862EMIT(CPOS(P(p), MIR_BinaryAcc.create(IA32_SAR,temp,LC(32)))); 15863EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), temp)); 15864} else { 15865Register uh = Binary.getVal1(PL(p)).asRegister().getRegister(); 15866EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), new RegisterOperand(uh, TypeReference.Int))); 15867} 15868 } 15869 15870 /** 15871 * Emit code for rule number 372: 15872 * r: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 15873 * @param p BURS node to apply the rule to 15874 */ 15875 private void code372(AbstractBURS_TreeNode p) { 15876 MemoryOperand mo = consumeMO(); 15877mo.disp = mo.disp.plus(4); 15878mo = setSize(mo,4); 15879EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), mo)); 15880 } 15881 15882 /** 15883 * Emit code for rule number 373: 15884 * r: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 15885 * @param p BURS node to apply the rule to 15886 */ 15887 private void code373(AbstractBURS_TreeNode p) { 15888 MemoryOperand mo = consumeMO(); 15889mo.disp = mo.disp.plus(4); 15890mo = setSize(mo,4); 15891EMIT(MIR_Move.mutate(P(p), IA32_MOV, Unary.getResult(P(p)), mo)); 15892 } 15893 15894 /** 15895 * Emit code for rule number 374: 15896 * load32: LONG_2INT(LONG_USHR(load64, INT_CONSTANT)) 15897 * @param p BURS node to apply the rule to 15898 */ 15899 private void code374(AbstractBURS_TreeNode p) { 15900 MemoryOperand mo = consumeMO(); 15901mo.disp = mo.disp.plus(4); 15902mo = setSize(mo,4); 15903pushMO(mo); 15904 } 15905 15906 /** 15907 * Emit code for rule number 375: 15908 * load32: LONG_2INT(LONG_SHR(load64, INT_CONSTANT)) 15909 * @param p BURS node to apply the rule to 15910 */ 15911 private void code375(AbstractBURS_TreeNode p) { 15912 MemoryOperand mo = consumeMO(); 15913mo.disp = mo.disp.plus(4); 15914mo = setSize(mo,4); 15915pushMO(mo); 15916 } 15917 15918 /** 15919 * Emit code for rule number 376: 15920 * r: LONG_ADD(r, rlv) 15921 * @param p BURS node to apply the rule to 15922 */ 15923 private void code376(AbstractBURS_TreeNode p) { 15924 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), true); 15925 } 15926 15927 /** 15928 * Emit code for rule number 377: 15929 * r: LONG_ADD(r, load64) 15930 * @param p BURS node to apply the rule to 15931 */ 15932 private void code377(AbstractBURS_TreeNode p) { 15933 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO(), true); 15934 } 15935 15936 /** 15937 * Emit code for rule number 378: 15938 * r: LONG_ADD(load64, rlv) 15939 * @param p BURS node to apply the rule to 15940 */ 15941 private void code378(AbstractBURS_TreeNode p) { 15942 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO(), true); 15943 } 15944 15945 /** 15946 * Emit code for rule number 379: 15947 * stm: LONG_STORE(LONG_ADD(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 15948 * @param p BURS node to apply the rule to 15949 */ 15950 private void code379(AbstractBURS_TreeNode p) { 15951 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)), true); 15952 } 15953 15954 /** 15955 * Emit code for rule number 380: 15956 * stm: LONG_STORE(LONG_ADD(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 15957 * @param p BURS node to apply the rule to 15958 */ 15959 private void code380(AbstractBURS_TreeNode p) { 15960 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)), true); 15961 } 15962 15963 /** 15964 * Emit code for rule number 381: 15965 * stm: LONG_ASTORE(LONG_ADD(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 15966 * @param p BURS node to apply the rule to 15967 */ 15968 private void code381(AbstractBURS_TreeNode p) { 15969 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)), true); 15970 } 15971 15972 /** 15973 * Emit code for rule number 382: 15974 * stm: LONG_ASTORE(LONG_ADD(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 15975 * @param p BURS node to apply the rule to 15976 */ 15977 private void code382(AbstractBURS_TreeNode p) { 15978 EMIT_LongBinary(IA32_ADD, IA32_ADC, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)), true); 15979 } 15980 15981 /** 15982 * Emit code for rule number 383: 15983 * r: LONG_AND(r, rlv) 15984 * @param p BURS node to apply the rule to 15985 */ 15986 private void code383(AbstractBURS_TreeNode p) { 15987 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), true); 15988 } 15989 15990 /** 15991 * Emit code for rule number 384: 15992 * r: LONG_AND(r, load64) 15993 * @param p BURS node to apply the rule to 15994 */ 15995 private void code384(AbstractBURS_TreeNode p) { 15996 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO(), true); 15997 } 15998 15999 /** 16000 * Emit code for rule number 385: 16001 * r: LONG_AND(load64, rlv) 16002 * @param p BURS node to apply the rule to 16003 */ 16004 private void code385(AbstractBURS_TreeNode p) { 16005 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO(), true); 16006 } 16007 16008 /** 16009 * Emit code for rule number 386: 16010 * stm: LONG_STORE(LONG_AND(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16011 * @param p BURS node to apply the rule to 16012 */ 16013 private void code386(AbstractBURS_TreeNode p) { 16014 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)), true); 16015 } 16016 16017 /** 16018 * Emit code for rule number 387: 16019 * stm: LONG_STORE(LONG_AND(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16020 * @param p BURS node to apply the rule to 16021 */ 16022 private void code387(AbstractBURS_TreeNode p) { 16023 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)), true); 16024 } 16025 16026 /** 16027 * Emit code for rule number 388: 16028 * stm: LONG_ASTORE(LONG_AND(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16029 * @param p BURS node to apply the rule to 16030 */ 16031 private void code388(AbstractBURS_TreeNode p) { 16032 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)), true); 16033 } 16034 16035 /** 16036 * Emit code for rule number 389: 16037 * stm: LONG_ASTORE(LONG_AND(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16038 * @param p BURS node to apply the rule to 16039 */ 16040 private void code389(AbstractBURS_TreeNode p) { 16041 EMIT_LongBinary(IA32_AND, IA32_AND, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)), true); 16042 } 16043 16044 /** 16045 * Emit code for rule number 390: 16046 * stm: LONG_IFCMP(r,rlv) 16047 * @param p BURS node to apply the rule to 16048 */ 16049 private void code390(AbstractBURS_TreeNode p) { 16050 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 16051 } 16052 16053 /** 16054 * Emit code for rule number 391: 16055 * r: LONG_LOAD(riv, riv) 16056 * @param p BURS node to apply the rule to 16057 */ 16058 private void code391(AbstractBURS_TreeNode p) { 16059 RegisterOperand hres = Load.getResult(P(p)); 16060RegisterOperand lres = new RegisterOperand(regpool.getSecondReg(hres.getRegister()), TypeReference.Int); 16061hres.setType(TypeReference.Int); 16062EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, hres, MO_L(P(p), DW, DW).copy()))); 16063EMIT(MIR_Move.mutate(P(p), IA32_MOV, lres, MO_L(P(p), DW))); 16064 } 16065 16066 /** 16067 * Emit code for rule number 392: 16068 * r: LONG_ALOAD(riv, riv) 16069 * @param p BURS node to apply the rule to 16070 */ 16071 private void code392(AbstractBURS_TreeNode p) { 16072 RegisterOperand hres = ALoad.getResult(P(p)); 16073RegisterOperand lres = new RegisterOperand(regpool.getSecondReg(hres.getRegister()), TypeReference.Int); 16074hres.setType(TypeReference.Int); 16075EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, hres, MO_AL(P(p), QW_S, DW, DW).copy()))); 16076EMIT(MIR_Move.mutate(P(p), IA32_MOV, lres, MO_AL(P(p), QW_S, DW))); 16077 } 16078 16079 /** 16080 * Emit code for rule number 393: 16081 * r: LONG_MOVE(r) 16082 * @param p BURS node to apply the rule to 16083 */ 16084 private void code393(AbstractBURS_TreeNode p) { 16085 Register res1 = Move.getResult(P(p)).getRegister(); 16086Register res2 = regpool.getSecondReg(res1); 16087Register val1 = Move.getVal(P(p)).asRegister().getRegister(); 16088Register val2 = regpool.getSecondReg(val1); 16089EMIT(MIR_Move.mutate(P(p), IA32_MOV, new RegisterOperand(res1, TypeReference.Int), 16090 new RegisterOperand(val1, TypeReference.Int))); 16091EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, new RegisterOperand(res2, TypeReference.Int), 16092 new RegisterOperand(val2, TypeReference.Int)))); 16093 } 16094 16095 /** 16096 * Emit code for rule number 394: 16097 * r: LONG_MOVE(LONG_CONSTANT) 16098 * @param p BURS node to apply the rule to 16099 */ 16100 private void code394(AbstractBURS_TreeNode p) { 16101 Register res1 = Move.getResult(P(p)).getRegister(); 16102Register res2 = regpool.getSecondReg(res1); 16103LongConstantOperand val = LC(Move.getVal(P(p))); 16104EMIT(MIR_Move.mutate(P(p), IA32_MOV, new RegisterOperand(res1, TypeReference.Int), IC(val.upper32()))); 16105EMIT(CPOS(P(p),MIR_Move.create(IA32_MOV, new RegisterOperand(res2, TypeReference.Int), IC(val.lower32())))); 16106 } 16107 16108 /** 16109 * Emit code for rule number 396: 16110 * r: LONG_MUL(r, rlv) 16111 * @param p BURS node to apply the rule to 16112 */ 16113 private void code396(AbstractBURS_TreeNode p) { 16114 LONG_MUL(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16115 } 16116 16117 /** 16118 * Emit code for rule number 397: 16119 * r: LONG_MUL(LONG_AND(rlv, LONG_CONSTANT), LONG_AND(rlv, LONG_CONSTANT)) 16120 * @param p BURS node to apply the rule to 16121 */ 16122 private void code397(AbstractBURS_TreeNode p) { 16123 INT_TO_LONG_MUL(P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)), Binary.getVal1(PR(p)), false); 16124 } 16125 16126 /** 16127 * Emit code for rule number 398: 16128 * r: LONG_MUL(LONG_AND(rlv, LONG_CONSTANT), LONG_CONSTANT) 16129 * @param p BURS node to apply the rule to 16130 */ 16131 private void code398(AbstractBURS_TreeNode p) { 16132 INT_TO_LONG_MUL(P(p), Binary.getResult(P(p)), Binary.getVal1(PL(p)), Binary.getVal2(P(p)), false); 16133 } 16134 16135 /** 16136 * Emit code for rule number 399: 16137 * r: LONG_MUL(INT_2LONG(riv), INT_2LONG(riv)) 16138 * @param p BURS node to apply the rule to 16139 */ 16140 private void code399(AbstractBURS_TreeNode p) { 16141 INT_TO_LONG_MUL(P(p), Binary.getResult(P(p)), Unary.getVal(PL(p)), Unary.getVal(PR(p)), true); 16142 } 16143 16144 /** 16145 * Emit code for rule number 400: 16146 * r: LONG_NEG(r) 16147 * @param p BURS node to apply the rule to 16148 */ 16149 private void code400(AbstractBURS_TreeNode p) { 16150 EMIT_LongUnary(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), true); 16151 } 16152 16153 /** 16154 * Emit code for rule number 401: 16155 * stm: LONG_STORE(LONG_NEG(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16156 * @param p BURS node to apply the rule to 16157 */ 16158 private void code401(AbstractBURS_TreeNode p) { 16159 EMIT_LongUnary(P(p), MO_S(P(p), QW), MO_S(P(p), QW), true); 16160 } 16161 16162 /** 16163 * Emit code for rule number 402: 16164 * stm: LONG_ASTORE(LONG_NEG(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16165 * @param p BURS node to apply the rule to 16166 */ 16167 private void code402(AbstractBURS_TreeNode p) { 16168 EMIT_LongUnary(P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), true); 16169 } 16170 16171 /** 16172 * Emit code for rule number 403: 16173 * r: LONG_NOT(r) 16174 * @param p BURS node to apply the rule to 16175 */ 16176 private void code403(AbstractBURS_TreeNode p) { 16177 EMIT_LongUnary(P(p), Unary.getResult(P(p)), Unary.getVal(P(p)), false); 16178 } 16179 16180 /** 16181 * Emit code for rule number 404: 16182 * stm: LONG_STORE(LONG_NOT(LONG_LOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16183 * @param p BURS node to apply the rule to 16184 */ 16185 private void code404(AbstractBURS_TreeNode p) { 16186 EMIT_LongUnary(P(p), MO_S(P(p), QW), MO_S(P(p), QW), false); 16187 } 16188 16189 /** 16190 * Emit code for rule number 405: 16191 * stm: LONG_ASTORE(LONG_NOT(LONG_ALOAD(riv,riv)),OTHER_OPERAND(riv, riv)) 16192 * @param p BURS node to apply the rule to 16193 */ 16194 private void code405(AbstractBURS_TreeNode p) { 16195 EMIT_LongUnary(P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), false); 16196 } 16197 16198 /** 16199 * Emit code for rule number 406: 16200 * r: LONG_OR(r, rlv) 16201 * @param p BURS node to apply the rule to 16202 */ 16203 private void code406(AbstractBURS_TreeNode p) { 16204 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), true); 16205 } 16206 16207 /** 16208 * Emit code for rule number 407: 16209 * r: LONG_OR(r, load64) 16210 * @param p BURS node to apply the rule to 16211 */ 16212 private void code407(AbstractBURS_TreeNode p) { 16213 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO(), true); 16214 } 16215 16216 /** 16217 * Emit code for rule number 408: 16218 * r: LONG_OR(load64, rlv) 16219 * @param p BURS node to apply the rule to 16220 */ 16221 private void code408(AbstractBURS_TreeNode p) { 16222 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO(), true); 16223 } 16224 16225 /** 16226 * Emit code for rule number 409: 16227 * stm: LONG_STORE(LONG_OR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16228 * @param p BURS node to apply the rule to 16229 */ 16230 private void code409(AbstractBURS_TreeNode p) { 16231 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)), true); 16232 } 16233 16234 /** 16235 * Emit code for rule number 410: 16236 * stm: LONG_STORE(LONG_OR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16237 * @param p BURS node to apply the rule to 16238 */ 16239 private void code410(AbstractBURS_TreeNode p) { 16240 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)), true); 16241 } 16242 16243 /** 16244 * Emit code for rule number 411: 16245 * stm: LONG_ASTORE(LONG_OR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16246 * @param p BURS node to apply the rule to 16247 */ 16248 private void code411(AbstractBURS_TreeNode p) { 16249 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)), true); 16250 } 16251 16252 /** 16253 * Emit code for rule number 412: 16254 * stm: LONG_ASTORE(LONG_OR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16255 * @param p BURS node to apply the rule to 16256 */ 16257 private void code412(AbstractBURS_TreeNode p) { 16258 EMIT_LongBinary(IA32_OR, IA32_OR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)), true); 16259 } 16260 16261 /** 16262 * Emit code for rule number 413: 16263 * r: LONG_SHL(rlv, riv) 16264 * @param p BURS node to apply the rule to 16265 */ 16266 private void code413(AbstractBURS_TreeNode p) { 16267 LONG_SHL(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), false); 16268 } 16269 16270 /** 16271 * Emit code for rule number 414: 16272 * r: LONG_SHL(rlv, INT_AND(riv, INT_CONSTANT)) 16273 * @param p BURS node to apply the rule to 16274 */ 16275 private void code414(AbstractBURS_TreeNode p) { 16276 if (VM.VerifyAssertions) VM._assert((VRR(p) & 0x7FFFFFFF) <= 63); 16277LONG_SHL(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(PR(p)), true); 16278 } 16279 16280 /** 16281 * Emit code for rule number 415: 16282 * r: LONG_SHR(rlv, riv) 16283 * @param p BURS node to apply the rule to 16284 */ 16285 private void code415(AbstractBURS_TreeNode p) { 16286 LONG_SHR(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), false); 16287 } 16288 16289 /** 16290 * Emit code for rule number 416: 16291 * r: LONG_SHR(rlv, INT_AND(riv, INT_CONSTANT)) 16292 * @param p BURS node to apply the rule to 16293 */ 16294 private void code416(AbstractBURS_TreeNode p) { 16295 if (VM.VerifyAssertions) VM._assert((VRR(p) & 0x7FFFFFFF) <= 63); 16296LONG_SHR(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(PR(p)), true); 16297 } 16298 16299 /** 16300 * Emit code for rule number 417: 16301 * stm: LONG_STORE(r, OTHER_OPERAND(riv, riv)) 16302 * @param p BURS node to apply the rule to 16303 */ 16304 private void code417(AbstractBURS_TreeNode p) { 16305 RegisterOperand hval = (RegisterOperand)Store.getValue(P(p)); 16306hval.setType(TypeReference.Int); 16307RegisterOperand lval = new RegisterOperand(regpool.getSecondReg(hval.getRegister()), TypeReference.Int); 16308EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_S(P(p), DW, DW).copy(), hval))); 16309EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), lval)); 16310 } 16311 16312 /** 16313 * Emit code for rule number 418: 16314 * stm: LONG_STORE(LONG_CONSTANT, OTHER_OPERAND(riv, riv)) 16315 * @param p BURS node to apply the rule to 16316 */ 16317 private void code418(AbstractBURS_TreeNode p) { 16318 LongConstantOperand val = LC(Store.getValue(P(p))); 16319EMIT(CPOS(P(p), MIR_Move.create(IA32_MOV, MO_S(P(p), DW, DW).copy(), IC(val.upper32())))); 16320EMIT(MIR_Move.mutate(P(p), IA32_MOV, MO_S(P(p), DW), IC(val.lower32()))); 16321 } 16322 16323 /** 16324 * Emit code for rule number 419: 16325 * r: LONG_SUB(rlv, rlv) 16326 * @param p BURS node to apply the rule to 16327 */ 16328 private void code419(AbstractBURS_TreeNode p) { 16329 EMIT_LongBinary(IA32_SUB, IA32_SBB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), false); 16330 } 16331 16332 /** 16333 * Emit code for rule number 420: 16334 * r: LONG_SUB(rlv, load64) 16335 * @param p BURS node to apply the rule to 16336 */ 16337 private void code420(AbstractBURS_TreeNode p) { 16338 EMIT_LongBinary(IA32_SUB, IA32_SBB, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO(), false); 16339 } 16340 16341 /** 16342 * Emit code for rule number 421: 16343 * r: LONG_SUB(load64, rlv) 16344 * @param p BURS node to apply the rule to 16345 */ 16346 private void code421(AbstractBURS_TreeNode p) { 16347 EMIT_LongBinary(IA32_SUB, IA32_SBB, P(p), Binary.getResult(P(p)), consumeMO(), Binary.getVal2(P(p)), false); 16348 } 16349 16350 /** 16351 * Emit code for rule number 422: 16352 * stm: LONG_STORE(LONG_SUB(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16353 * @param p BURS node to apply the rule to 16354 */ 16355 private void code422(AbstractBURS_TreeNode p) { 16356 EMIT_LongBinary(IA32_SUB, IA32_SBB, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)), false); 16357 } 16358 16359 /** 16360 * Emit code for rule number 423: 16361 * stm: LONG_ASTORE(LONG_SUB(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16362 * @param p BURS node to apply the rule to 16363 */ 16364 private void code423(AbstractBURS_TreeNode p) { 16365 EMIT_LongBinary(IA32_SUB, IA32_SBB, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)), false); 16366 } 16367 16368 /** 16369 * Emit code for rule number 424: 16370 * r: LONG_USHR(rlv, riv) 16371 * @param p BURS node to apply the rule to 16372 */ 16373 private void code424(AbstractBURS_TreeNode p) { 16374 LONG_USHR(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), false); 16375 } 16376 16377 /** 16378 * Emit code for rule number 425: 16379 * r: LONG_USHR(rlv, INT_AND(riv, INT_CONSTANT)) 16380 * @param p BURS node to apply the rule to 16381 */ 16382 private void code425(AbstractBURS_TreeNode p) { 16383 if (VM.VerifyAssertions) VM._assert((VRR(p) & 0x7FFFFFFF) <= 63); 16384LONG_USHR(P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal1(PR(p)), true); 16385 } 16386 16387 /** 16388 * Emit code for rule number 426: 16389 * r: LONG_XOR(r, rlv) 16390 * @param p BURS node to apply the rule to 16391 */ 16392 private void code426(AbstractBURS_TreeNode p) { 16393 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p)), true); 16394 } 16395 16396 /** 16397 * Emit code for rule number 427: 16398 * r: LONG_XOR(r, load64) 16399 * @param p BURS node to apply the rule to 16400 */ 16401 private void code427(AbstractBURS_TreeNode p) { 16402 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO(), true); 16403 } 16404 16405 /** 16406 * Emit code for rule number 428: 16407 * r: LONG_XOR(load64, rlv) 16408 * @param p BURS node to apply the rule to 16409 */ 16410 private void code428(AbstractBURS_TreeNode p) { 16411 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO(), true); 16412 } 16413 16414 /** 16415 * Emit code for rule number 429: 16416 * stm: LONG_STORE(LONG_XOR(LONG_LOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16417 * @param p BURS node to apply the rule to 16418 */ 16419 private void code429(AbstractBURS_TreeNode p) { 16420 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal2(PL(p)), true); 16421 } 16422 16423 /** 16424 * Emit code for rule number 430: 16425 * stm: LONG_STORE(LONG_XOR(r,LONG_LOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16426 * @param p BURS node to apply the rule to 16427 */ 16428 private void code430(AbstractBURS_TreeNode p) { 16429 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), MO_S(P(p), QW), MO_S(P(p), QW), Binary.getVal1(PL(p)), true); 16430 } 16431 16432 /** 16433 * Emit code for rule number 431: 16434 * stm: LONG_ASTORE(LONG_XOR(LONG_ALOAD(rlv,rlv),rlv),OTHER_OPERAND(rlv, rlv)) 16435 * @param p BURS node to apply the rule to 16436 */ 16437 private void code431(AbstractBURS_TreeNode p) { 16438 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal2(PL(p)), true); 16439 } 16440 16441 /** 16442 * Emit code for rule number 432: 16443 * stm: LONG_ASTORE(LONG_XOR(r,LONG_ALOAD(rlv,rlv)),OTHER_OPERAND(rlv, rlv)) 16444 * @param p BURS node to apply the rule to 16445 */ 16446 private void code432(AbstractBURS_TreeNode p) { 16447 EMIT_LongBinary(IA32_XOR, IA32_XOR, P(p), MO_AS(P(p), QW_S, QW), MO_AS(P(p), QW_S, QW), Binary.getVal1(PL(p)), true); 16448 } 16449 16450 /** 16451 * Emit code for rule number 433: 16452 * r: FLOAT_ADD(r, r) 16453 * @param p BURS node to apply the rule to 16454 */ 16455 private void code433(AbstractBURS_TreeNode p) { 16456 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16457 } 16458 16459 /** 16460 * Emit code for rule number 434: 16461 * r: FLOAT_ADD(r, float_load) 16462 * @param p BURS node to apply the rule to 16463 */ 16464 private void code434(AbstractBURS_TreeNode p) { 16465 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16466 } 16467 16468 /** 16469 * Emit code for rule number 435: 16470 * r: FLOAT_ADD(float_load,r) 16471 * @param p BURS node to apply the rule to 16472 */ 16473 private void code435(AbstractBURS_TreeNode p) { 16474 SSE2_COP(IA32_ADDSS, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16475 } 16476 16477 /** 16478 * Emit code for rule number 436: 16479 * r: DOUBLE_ADD(r, r) 16480 * @param p BURS node to apply the rule to 16481 */ 16482 private void code436(AbstractBURS_TreeNode p) { 16483 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), Binary.getVal1(P(p))); 16484 } 16485 16486 /** 16487 * Emit code for rule number 437: 16488 * r: DOUBLE_ADD(r, double_load) 16489 * @param p BURS node to apply the rule to 16490 */ 16491 private void code437(AbstractBURS_TreeNode p) { 16492 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16493 } 16494 16495 /** 16496 * Emit code for rule number 438: 16497 * r: DOUBLE_ADD(double_load,r) 16498 * @param p BURS node to apply the rule to 16499 */ 16500 private void code438(AbstractBURS_TreeNode p) { 16501 SSE2_COP(IA32_ADDSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16502 } 16503 16504 /** 16505 * Emit code for rule number 439: 16506 * r: FLOAT_SUB(r, r) 16507 * @param p BURS node to apply the rule to 16508 */ 16509 private void code439(AbstractBURS_TreeNode p) { 16510 SSE2_NCOP(IA32_SUBSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16511 } 16512 16513 /** 16514 * Emit code for rule number 440: 16515 * r: FLOAT_SUB(r, float_load) 16516 * @param p BURS node to apply the rule to 16517 */ 16518 private void code440(AbstractBURS_TreeNode p) { 16519 SSE2_NCOP(IA32_SUBSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16520 } 16521 16522 /** 16523 * Emit code for rule number 441: 16524 * r: DOUBLE_SUB(r, r) 16525 * @param p BURS node to apply the rule to 16526 */ 16527 private void code441(AbstractBURS_TreeNode p) { 16528 SSE2_NCOP(IA32_SUBSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16529 } 16530 16531 /** 16532 * Emit code for rule number 442: 16533 * r: DOUBLE_SUB(r, double_load) 16534 * @param p BURS node to apply the rule to 16535 */ 16536 private void code442(AbstractBURS_TreeNode p) { 16537 SSE2_NCOP(IA32_SUBSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16538 } 16539 16540 /** 16541 * Emit code for rule number 443: 16542 * r: FLOAT_MUL(r, r) 16543 * @param p BURS node to apply the rule to 16544 */ 16545 private void code443(AbstractBURS_TreeNode p) { 16546 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16547 } 16548 16549 /** 16550 * Emit code for rule number 444: 16551 * r: FLOAT_MUL(r, float_load) 16552 * @param p BURS node to apply the rule to 16553 */ 16554 private void code444(AbstractBURS_TreeNode p) { 16555 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16556 } 16557 16558 /** 16559 * Emit code for rule number 445: 16560 * r: FLOAT_MUL(float_load, r) 16561 * @param p BURS node to apply the rule to 16562 */ 16563 private void code445(AbstractBURS_TreeNode p) { 16564 SSE2_COP(IA32_MULSS, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16565 } 16566 16567 /** 16568 * Emit code for rule number 446: 16569 * r: DOUBLE_MUL(r, r) 16570 * @param p BURS node to apply the rule to 16571 */ 16572 private void code446(AbstractBURS_TreeNode p) { 16573 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16574 } 16575 16576 /** 16577 * Emit code for rule number 447: 16578 * r: DOUBLE_MUL(r, double_load) 16579 * @param p BURS node to apply the rule to 16580 */ 16581 private void code447(AbstractBURS_TreeNode p) { 16582 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16583 } 16584 16585 /** 16586 * Emit code for rule number 448: 16587 * r: DOUBLE_MUL(double_load, r) 16588 * @param p BURS node to apply the rule to 16589 */ 16590 private void code448(AbstractBURS_TreeNode p) { 16591 SSE2_COP(IA32_MULSD, P(p), Binary.getResult(P(p)), Binary.getVal2(P(p)), consumeMO()); 16592 } 16593 16594 /** 16595 * Emit code for rule number 449: 16596 * r: FLOAT_DIV(r, r) 16597 * @param p BURS node to apply the rule to 16598 */ 16599 private void code449(AbstractBURS_TreeNode p) { 16600 SSE2_NCOP(IA32_DIVSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16601 } 16602 16603 /** 16604 * Emit code for rule number 450: 16605 * r: FLOAT_DIV(r, float_load) 16606 * @param p BURS node to apply the rule to 16607 */ 16608 private void code450(AbstractBURS_TreeNode p) { 16609 SSE2_NCOP(IA32_DIVSS, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16610 } 16611 16612 /** 16613 * Emit code for rule number 451: 16614 * r: DOUBLE_DIV(r, r) 16615 * @param p BURS node to apply the rule to 16616 */ 16617 private void code451(AbstractBURS_TreeNode p) { 16618 SSE2_NCOP(IA32_DIVSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), Binary.getVal2(P(p))); 16619 } 16620 16621 /** 16622 * Emit code for rule number 452: 16623 * r: DOUBLE_DIV(r, double_load) 16624 * @param p BURS node to apply the rule to 16625 */ 16626 private void code452(AbstractBURS_TreeNode p) { 16627 SSE2_NCOP(IA32_DIVSD, P(p), Binary.getResult(P(p)), Binary.getVal1(P(p)), consumeMO()); 16628 } 16629 16630 /** 16631 * Emit code for rule number 453: 16632 * r: FLOAT_NEG(r) 16633 * @param p BURS node to apply the rule to 16634 */ 16635 private void code453(AbstractBURS_TreeNode p) { 16636 SSE2_NEG(true, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 16637 } 16638 16639 /** 16640 * Emit code for rule number 454: 16641 * r: DOUBLE_NEG(r) 16642 * @param p BURS node to apply the rule to 16643 */ 16644 private void code454(AbstractBURS_TreeNode p) { 16645 SSE2_NEG(false, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 16646 } 16647 16648 /** 16649 * Emit code for rule number 455: 16650 * r: FLOAT_SQRT(r) 16651 * @param p BURS node to apply the rule to 16652 */ 16653 private void code455(AbstractBURS_TreeNode p) { 16654 EMIT(MIR_Unary.mutate(P(p), IA32_SQRTSS, Unary.getResult(P(p)), Unary.getVal(P(p)))); 16655 } 16656 16657 /** 16658 * Emit code for rule number 456: 16659 * r: DOUBLE_SQRT(r) 16660 * @param p BURS node to apply the rule to 16661 */ 16662 private void code456(AbstractBURS_TreeNode p) { 16663 EMIT(MIR_Unary.mutate(P(p), IA32_SQRTSD, Unary.getResult(P(p)), Unary.getVal(P(p)))); 16664 } 16665 16666 /** 16667 * Emit code for rule number 457: 16668 * r: FLOAT_REM(r, r) 16669 * @param p BURS node to apply the rule to 16670 */ 16671 private void code457(AbstractBURS_TreeNode p) { 16672 SSE2_X87_REM(P(p)); 16673 } 16674 16675 /** 16676 * Emit code for rule number 458: 16677 * r: DOUBLE_REM(r, r) 16678 * @param p BURS node to apply the rule to 16679 */ 16680 private void code458(AbstractBURS_TreeNode p) { 16681 SSE2_X87_REM(P(p)); 16682 } 16683 16684 /** 16685 * Emit code for rule number 459: 16686 * r: LONG_2FLOAT(r) 16687 * @param p BURS node to apply the rule to 16688 */ 16689 private void code459(AbstractBURS_TreeNode p) { 16690 SSE2_X87_FROMLONG(P(p)); 16691 } 16692 16693 /** 16694 * Emit code for rule number 460: 16695 * r: LONG_2DOUBLE(r) 16696 * @param p BURS node to apply the rule to 16697 */ 16698 private void code460(AbstractBURS_TreeNode p) { 16699 SSE2_X87_FROMLONG(P(p)); 16700 } 16701 16702 /** 16703 * Emit code for rule number 461: 16704 * r: FLOAT_MOVE(r) 16705 * @param p BURS node to apply the rule to 16706 */ 16707 private void code461(AbstractBURS_TreeNode p) { 16708 EMIT(MIR_Move.mutate(P(p), IA32_MOVAPS, Move.getResult(P(p)), Move.getVal(P(p)))); 16709 } 16710 16711 /** 16712 * Emit code for rule number 462: 16713 * r: DOUBLE_MOVE(r) 16714 * @param p BURS node to apply the rule to 16715 */ 16716 private void code462(AbstractBURS_TreeNode p) { 16717 EMIT(MIR_Move.mutate(P(p), IA32_MOVAPD, Move.getResult(P(p)), Move.getVal(P(p)))); 16718 } 16719 16720 /** 16721 * Emit code for rule number 463: 16722 * r: DOUBLE_LOAD(riv, riv) 16723 * @param p BURS node to apply the rule to 16724 */ 16725 private void code463(AbstractBURS_TreeNode p) { 16726 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 16727 } 16728 16729 /** 16730 * Emit code for rule number 464: 16731 * r: DOUBLE_LOAD(riv, rlv) 16732 * @param p BURS node to apply the rule to 16733 */ 16734 private void code464(AbstractBURS_TreeNode p) { 16735 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 16736 } 16737 16738 /** 16739 * Emit code for rule number 465: 16740 * r: DOUBLE_LOAD(rlv, rlv) 16741 * @param p BURS node to apply the rule to 16742 */ 16743 private void code465(AbstractBURS_TreeNode p) { 16744 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, Load.getResult(P(p)), MO_L(P(p), QW))); 16745 } 16746 16747 /** 16748 * Emit code for rule number 466: 16749 * double_load: DOUBLE_LOAD(riv, riv) 16750 * @param p BURS node to apply the rule to 16751 */ 16752 private void code466(AbstractBURS_TreeNode p) { 16753 pushMO(MO_L(P(p), QW)); 16754 } 16755 16756 /** 16757 * Emit code for rule number 467: 16758 * r: DOUBLE_ALOAD(riv, riv) 16759 * @param p BURS node to apply the rule to 16760 */ 16761 private void code467(AbstractBURS_TreeNode p) { 16762 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 16763 } 16764 16765 /** 16766 * Emit code for rule number 468: 16767 * double_load: DOUBLE_LOAD(rlv, rlv) 16768 * @param p BURS node to apply the rule to 16769 */ 16770 private void code468(AbstractBURS_TreeNode p) { 16771 pushMO(MO_L(P(p), QW)); 16772 } 16773 16774 /** 16775 * Emit code for rule number 469: 16776 * r: DOUBLE_ALOAD(riv, r) 16777 * @param p BURS node to apply the rule to 16778 */ 16779 private void code469(AbstractBURS_TreeNode p) { 16780 RegisterOperand index=ALoad.getIndex(P(p)).asRegister(); 16781if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 16782EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 16783EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 16784}else{ 16785EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 16786} 16787 } 16788 16789 /** 16790 * Emit code for rule number 470: 16791 * r: DOUBLE_ALOAD(rlv, rlv) 16792 * @param p BURS node to apply the rule to 16793 */ 16794 private void code470(AbstractBURS_TreeNode p) { 16795 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, ALoad.getResult(P(p)), MO_AL(P(p), QW_S, QW))); 16796 } 16797 16798 /** 16799 * Emit code for rule number 471: 16800 * double_load: DOUBLE_ALOAD(riv, riv) 16801 * @param p BURS node to apply the rule to 16802 */ 16803 private void code471(AbstractBURS_TreeNode p) { 16804 pushMO(MO_AL(P(p), QW_S, QW)); 16805 } 16806 16807 /** 16808 * Emit code for rule number 472: 16809 * r: FLOAT_LOAD(riv, riv) 16810 * @param p BURS node to apply the rule to 16811 */ 16812 private void code472(AbstractBURS_TreeNode p) { 16813 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, Load.getResult(P(p)), MO_L(P(p), DW))); 16814 } 16815 16816 /** 16817 * Emit code for rule number 473: 16818 * r: FLOAT_LOAD(rlv, rlv) 16819 * @param p BURS node to apply the rule to 16820 */ 16821 private void code473(AbstractBURS_TreeNode p) { 16822 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, Load.getResult(P(p)), MO_L(P(p), DW))); 16823 } 16824 16825 /** 16826 * Emit code for rule number 474: 16827 * float_load: FLOAT_LOAD(riv, riv) 16828 * @param p BURS node to apply the rule to 16829 */ 16830 private void code474(AbstractBURS_TreeNode p) { 16831 pushMO(MO_L(P(p), DW)); 16832 } 16833 16834 /** 16835 * Emit code for rule number 475: 16836 * r: FLOAT_ALOAD(riv, riv) 16837 * @param p BURS node to apply the rule to 16838 */ 16839 private void code475(AbstractBURS_TreeNode p) { 16840 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 16841 } 16842 16843 /** 16844 * Emit code for rule number 476: 16845 * r: FLOAT_ALOAD(riv, r) 16846 * @param p BURS node to apply the rule to 16847 */ 16848 private void code476(AbstractBURS_TreeNode p) { 16849 RegisterOperand index=ALoad.getIndex(P(p)).asRegister(); 16850if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 16851EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 16852EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 16853}else{ 16854EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 16855} 16856 } 16857 16858 /** 16859 * Emit code for rule number 477: 16860 * r: FLOAT_ALOAD(rlv, rlv) 16861 * @param p BURS node to apply the rule to 16862 */ 16863 private void code477(AbstractBURS_TreeNode p) { 16864 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, ALoad.getResult(P(p)), MO_AL(P(p), DW_S, DW))); 16865 } 16866 16867 /** 16868 * Emit code for rule number 478: 16869 * float_load: FLOAT_ALOAD(riv, riv) 16870 * @param p BURS node to apply the rule to 16871 */ 16872 private void code478(AbstractBURS_TreeNode p) { 16873 pushMO(MO_AL(P(p), DW_S, DW)); 16874 } 16875 16876 /** 16877 * Emit code for rule number 479: 16878 * stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, riv)) 16879 * @param p BURS node to apply the rule to 16880 */ 16881 private void code479(AbstractBURS_TreeNode p) { 16882 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 16883 } 16884 16885 /** 16886 * Emit code for rule number 480: 16887 * stm: DOUBLE_STORE(r, OTHER_OPERAND(riv, rlv)) 16888 * @param p BURS node to apply the rule to 16889 */ 16890 private void code480(AbstractBURS_TreeNode p) { 16891 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 16892 } 16893 16894 /** 16895 * Emit code for rule number 481: 16896 * stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, riv)) 16897 * @param p BURS node to apply the rule to 16898 */ 16899 private void code481(AbstractBURS_TreeNode p) { 16900 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 16901 } 16902 16903 /** 16904 * Emit code for rule number 482: 16905 * stm: DOUBLE_STORE(r, OTHER_OPERAND(rlv, rlv)) 16906 * @param p BURS node to apply the rule to 16907 */ 16908 private void code482(AbstractBURS_TreeNode p) { 16909 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_S(P(p), QW), Store.getValue(P(p)))); 16910 } 16911 16912 /** 16913 * Emit code for rule number 483: 16914 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, riv)) 16915 * @param p BURS node to apply the rule to 16916 */ 16917 private void code483(AbstractBURS_TreeNode p) { 16918 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16919 } 16920 16921 /** 16922 * Emit code for rule number 484: 16923 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, riv)) 16924 * @param p BURS node to apply the rule to 16925 */ 16926 private void code484(AbstractBURS_TreeNode p) { 16927 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16928 } 16929 16930 /** 16931 * Emit code for rule number 485: 16932 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(riv, rlv)) 16933 * @param p BURS node to apply the rule to 16934 */ 16935 private void code485(AbstractBURS_TreeNode p) { 16936 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16937 } 16938 16939 /** 16940 * Emit code for rule number 486: 16941 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 16942 * @param p BURS node to apply the rule to 16943 */ 16944 private void code486(AbstractBURS_TreeNode p) { 16945 EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16946 } 16947 16948 /** 16949 * Emit code for rule number 487: 16950 * stm: DOUBLE_ASTORE(r, OTHER_OPERAND(r, r)) 16951 * @param p BURS node to apply the rule to 16952 */ 16953 private void code487(AbstractBURS_TreeNode p) { 16954 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 16955if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 16956EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 16957EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16958}else{ 16959EMIT(MIR_Move.mutate(P(p), IA32_MOVSD, MO_AS(P(p), QW_S, QW), AStore.getValue(P(p)))); 16960} 16961 } 16962 16963 /** 16964 * Emit code for rule number 488: 16965 * stm: FLOAT_STORE(r, OTHER_OPERAND(riv, riv)) 16966 * @param p BURS node to apply the rule to 16967 */ 16968 private void code488(AbstractBURS_TreeNode p) { 16969 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 16970 } 16971 16972 /** 16973 * Emit code for rule number 489: 16974 * stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, rlv)) 16975 * @param p BURS node to apply the rule to 16976 */ 16977 private void code489(AbstractBURS_TreeNode p) { 16978 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 16979 } 16980 16981 /** 16982 * Emit code for rule number 490: 16983 * stm: FLOAT_STORE(r, OTHER_OPERAND(rlv, riv)) 16984 * @param p BURS node to apply the rule to 16985 */ 16986 private void code490(AbstractBURS_TreeNode p) { 16987 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 16988 } 16989 16990 /** 16991 * Emit code for rule number 491: 16992 * stm: FLOAT_STORE(r, OTHER_OPERAND(riv, rlv)) 16993 * @param p BURS node to apply the rule to 16994 */ 16995 private void code491(AbstractBURS_TreeNode p) { 16996 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_S(P(p), DW), Store.getValue(P(p)))); 16997 } 16998 16999 /** 17000 * Emit code for rule number 492: 17001 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, riv)) 17002 * @param p BURS node to apply the rule to 17003 */ 17004 private void code492(AbstractBURS_TreeNode p) { 17005 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17006 } 17007 17008 /** 17009 * Emit code for rule number 493: 17010 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, riv)) 17011 * @param p BURS node to apply the rule to 17012 */ 17013 private void code493(AbstractBURS_TreeNode p) { 17014 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17015 } 17016 17017 /** 17018 * Emit code for rule number 494: 17019 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(riv, rlv)) 17020 * @param p BURS node to apply the rule to 17021 */ 17022 private void code494(AbstractBURS_TreeNode p) { 17023 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17024 } 17025 17026 /** 17027 * Emit code for rule number 495: 17028 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(rlv, rlv)) 17029 * @param p BURS node to apply the rule to 17030 */ 17031 private void code495(AbstractBURS_TreeNode p) { 17032 EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17033 } 17034 17035 /** 17036 * Emit code for rule number 496: 17037 * stm: FLOAT_ASTORE(r, OTHER_OPERAND(r, r)) 17038 * @param p BURS node to apply the rule to 17039 */ 17040 private void code496(AbstractBURS_TreeNode p) { 17041 RegisterOperand index=AStore.getIndex(P(p)).asRegister(); 17042if (VM.BuildFor64Addr && index.getRegister().isInteger()){ 17043EMIT(CPOS(P(p),MIR_BinaryAcc.create(IA32_AND, index, LC(0xffffffff)))); 17044EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17045}else{ 17046EMIT(MIR_Move.mutate(P(p), IA32_MOVSS, MO_AS(P(p), DW_S, DW), AStore.getValue(P(p)))); 17047} 17048 } 17049 17050 /** 17051 * Emit code for rule number 497: 17052 * r: INT_2FLOAT(riv) 17053 * @param p BURS node to apply the rule to 17054 */ 17055 private void code497(AbstractBURS_TreeNode p) { 17056 SSE2_CONV(IA32_CVTSI2SS, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 17057 } 17058 17059 /** 17060 * Emit code for rule number 498: 17061 * r: INT_2FLOAT(load32) 17062 * @param p BURS node to apply the rule to 17063 */ 17064 private void code498(AbstractBURS_TreeNode p) { 17065 SSE2_CONV(IA32_CVTSI2SS, P(p), Unary.getResult(P(p)), consumeMO()); 17066 } 17067 17068 /** 17069 * Emit code for rule number 499: 17070 * r: INT_2DOUBLE(riv) 17071 * @param p BURS node to apply the rule to 17072 */ 17073 private void code499(AbstractBURS_TreeNode p) { 17074 SSE2_CONV(IA32_CVTSI2SD, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 17075 } 17076 17077 /** 17078 * Emit code for rule number 500: 17079 * r: INT_2DOUBLE(load32) 17080 * @param p BURS node to apply the rule to 17081 */ 17082 private void code500(AbstractBURS_TreeNode p) { 17083 SSE2_CONV(IA32_CVTSI2SD, P(p), Unary.getResult(P(p)), consumeMO()); 17084 } 17085 17086 /** 17087 * Emit code for rule number 501: 17088 * r: FLOAT_2DOUBLE(r) 17089 * @param p BURS node to apply the rule to 17090 */ 17091 private void code501(AbstractBURS_TreeNode p) { 17092 SSE2_CONV(IA32_CVTSS2SD, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 17093 } 17094 17095 /** 17096 * Emit code for rule number 502: 17097 * r: FLOAT_2DOUBLE(float_load) 17098 * @param p BURS node to apply the rule to 17099 */ 17100 private void code502(AbstractBURS_TreeNode p) { 17101 SSE2_CONV(IA32_CVTSS2SD, P(p), Unary.getResult(P(p)), consumeMO()); 17102 } 17103 17104 /** 17105 * Emit code for rule number 503: 17106 * r: DOUBLE_2FLOAT(r) 17107 * @param p BURS node to apply the rule to 17108 */ 17109 private void code503(AbstractBURS_TreeNode p) { 17110 SSE2_CONV(IA32_CVTSD2SS, P(p), Unary.getResult(P(p)), Unary.getVal(P(p))); 17111 } 17112 17113 /** 17114 * Emit code for rule number 504: 17115 * r: DOUBLE_2FLOAT(double_load) 17116 * @param p BURS node to apply the rule to 17117 */ 17118 private void code504(AbstractBURS_TreeNode p) { 17119 SSE2_CONV(IA32_CVTSD2SS, P(p), Unary.getResult(P(p)), consumeMO()); 17120 } 17121 17122 /** 17123 * Emit code for rule number 505: 17124 * r: FLOAT_2INT(r) 17125 * @param p BURS node to apply the rule to 17126 */ 17127 private void code505(AbstractBURS_TreeNode p) { 17128 EMIT(P(p)); /* leave for complex operators */ 17129 } 17130 17131 /** 17132 * Emit code for rule number 506: 17133 * r: FLOAT_2LONG(r) 17134 * @param p BURS node to apply the rule to 17135 */ 17136 private void code506(AbstractBURS_TreeNode p) { 17137 EMIT(P(p)); /* leave for complex operators */ 17138 } 17139 17140 /** 17141 * Emit code for rule number 507: 17142 * r: DOUBLE_2INT(r) 17143 * @param p BURS node to apply the rule to 17144 */ 17145 private void code507(AbstractBURS_TreeNode p) { 17146 EMIT(P(p)); /* leave for complex operators */ 17147 } 17148 17149 /** 17150 * Emit code for rule number 508: 17151 * r: DOUBLE_2LONG(r) 17152 * @param p BURS node to apply the rule to 17153 */ 17154 private void code508(AbstractBURS_TreeNode p) { 17155 EMIT(P(p)); /* leave for complex operators */ 17156 } 17157 17158 /** 17159 * Emit code for rule number 509: 17160 * r: FLOAT_AS_INT_BITS(r) 17161 * @param p BURS node to apply the rule to 17162 */ 17163 private void code509(AbstractBURS_TreeNode p) { 17164 SSE2_FPR2GPR_32(P(p)); 17165 } 17166 17167 /** 17168 * Emit code for rule number 511: 17169 * r: DOUBLE_AS_LONG_BITS(r) 17170 * @param p BURS node to apply the rule to 17171 */ 17172 private void code511(AbstractBURS_TreeNode p) { 17173 SSE2_FPR2GPR_64(P(p)); 17174 } 17175 17176 /** 17177 * Emit code for rule number 513: 17178 * r: INT_BITS_AS_FLOAT(riv) 17179 * @param p BURS node to apply the rule to 17180 */ 17181 private void code513(AbstractBURS_TreeNode p) { 17182 SSE2_GPR2FPR_32(P(p)); 17183 } 17184 17185 /** 17186 * Emit code for rule number 515: 17187 * r: LONG_BITS_AS_DOUBLE(rlv) 17188 * @param p BURS node to apply the rule to 17189 */ 17190 private void code515(AbstractBURS_TreeNode p) { 17191 SSE2_GPR2FPR_64(P(p)); 17192 } 17193 17194 /** 17195 * Emit code for rule number 517: 17196 * r: MATERIALIZE_FP_CONSTANT(any) 17197 * @param p BURS node to apply the rule to 17198 */ 17199 private void code517(AbstractBURS_TreeNode p) { 17200 SSE2_FPCONSTANT(P(p)); 17201 } 17202 17203 /** 17204 * Emit code for rule number 518: 17205 * float_load: MATERIALIZE_FP_CONSTANT(any) 17206 * @param p BURS node to apply the rule to 17207 */ 17208 private void code518(AbstractBURS_TreeNode p) { 17209 pushMO(MO_MC(P(p))); 17210 } 17211 17212 /** 17213 * Emit code for rule number 519: 17214 * double_load: MATERIALIZE_FP_CONSTANT(any) 17215 * @param p BURS node to apply the rule to 17216 */ 17217 private void code519(AbstractBURS_TreeNode p) { 17218 pushMO(MO_MC(P(p))); 17219 } 17220 17221 /** 17222 * Emit code for rule number 520: 17223 * stm: CLEAR_FLOATING_POINT_STATE 17224 * @param p BURS node to apply the rule to 17225 */ 17226 private void code520(AbstractBURS_TreeNode p) { 17227 EMIT(MIR_Empty.mutate(P(p), IA32_FNINIT)); 17228 } 17229 17230 /** 17231 * Emit code for rule number 521: 17232 * stm: FLOAT_IFCMP(r,r) 17233 * @param p BURS node to apply the rule to 17234 */ 17235 private void code521(AbstractBURS_TreeNode p) { 17236 SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal1(P(p)), IfCmp.getClearVal2(P(p))); 17237 } 17238 17239 /** 17240 * Emit code for rule number 522: 17241 * stm: FLOAT_IFCMP(r,float_load) 17242 * @param p BURS node to apply the rule to 17243 */ 17244 private void code522(AbstractBURS_TreeNode p) { 17245 SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal1(P(p)), consumeMO()); 17246 } 17247 17248 /** 17249 * Emit code for rule number 523: 17250 * stm: FLOAT_IFCMP(float_load,r) 17251 * @param p BURS node to apply the rule to 17252 */ 17253 private void code523(AbstractBURS_TreeNode p) { 17254 IfCmp.getCond(P(p)).flipOperands(); SSE2_IFCMP(IA32_UCOMISS, P(p), IfCmp.getClearVal2(P(p)), consumeMO()); 17255 } 17256 17257 /** 17258 * Emit code for rule number 524: 17259 * stm: DOUBLE_IFCMP(r,r) 17260 * @param p BURS node to apply the rule to 17261 */ 17262 private void code524(AbstractBURS_TreeNode p) { 17263 SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal1(P(p)), IfCmp.getClearVal2(P(p))); 17264 } 17265 17266 /** 17267 * Emit code for rule number 525: 17268 * stm: DOUBLE_IFCMP(r,double_load) 17269 * @param p BURS node to apply the rule to 17270 */ 17271 private void code525(AbstractBURS_TreeNode p) { 17272 SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal1(P(p)), consumeMO()); 17273 } 17274 17275 /** 17276 * Emit code for rule number 526: 17277 * stm: DOUBLE_IFCMP(double_load,r) 17278 * @param p BURS node to apply the rule to 17279 */ 17280 private void code526(AbstractBURS_TreeNode p) { 17281 IfCmp.getCond(P(p)).flipOperands(); SSE2_IFCMP(IA32_UCOMISD, P(p), IfCmp.getClearVal2(P(p)), consumeMO()); 17282 } 17283 17284 /** 17285 * Emit code for rule number 527: 17286 * r: FCMP_CMOV(r, OTHER_OPERAND(r, any)) 17287 * @param p BURS node to apply the rule to 17288 */ 17289 private void code527(AbstractBURS_TreeNode p) { 17290 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))); 17291 } 17292 17293 /** 17294 * Emit code for rule number 528: 17295 * r: FCMP_CMOV(r, OTHER_OPERAND(float_load, any)) 17296 * @param p BURS node to apply the rule to 17297 */ 17298 private void code528(AbstractBURS_TreeNode p) { 17299 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))); 17300 } 17301 17302 /** 17303 * Emit code for rule number 529: 17304 * r: FCMP_CMOV(r, OTHER_OPERAND(double_load, any)) 17305 * @param p BURS node to apply the rule to 17306 */ 17307 private void code529(AbstractBURS_TreeNode p) { 17308 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))); 17309 } 17310 17311 /** 17312 * Emit code for rule number 530: 17313 * r: FCMP_CMOV(float_load, OTHER_OPERAND(r, any)) 17314 * @param p BURS node to apply the rule to 17315 */ 17316 private void code530(AbstractBURS_TreeNode p) { 17317 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))); 17318 } 17319 17320 /** 17321 * Emit code for rule number 531: 17322 * r: FCMP_CMOV(double_load, OTHER_OPERAND(r, any)) 17323 * @param p BURS node to apply the rule to 17324 */ 17325 private void code531(AbstractBURS_TreeNode p) { 17326 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))); 17327 } 17328 17329 /** 17330 * Emit code for rule number 532: 17331 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, any)) 17332 * @param p BURS node to apply the rule to 17333 */ 17334 private void code532(AbstractBURS_TreeNode p) { 17335 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))); 17336 } 17337 17338 /** 17339 * Emit code for rule number 533: 17340 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, float_load))) 17341 * @param p BURS node to apply the rule to 17342 */ 17343 private void code533(AbstractBURS_TreeNode p) { 17344 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()); 17345 } 17346 17347 /** 17348 * Emit code for rule number 534: 17349 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(r, double_load))) 17350 * @param p BURS node to apply the rule to 17351 */ 17352 private void code534(AbstractBURS_TreeNode p) { 17353 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()); 17354 } 17355 17356 /** 17357 * Emit code for rule number 535: 17358 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(float_load, r))) 17359 * @param p BURS node to apply the rule to 17360 */ 17361 private void code535(AbstractBURS_TreeNode p) { 17362 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))); 17363 } 17364 17365 /** 17366 * Emit code for rule number 536: 17367 * r: FCMP_FCMOV(r, OTHER_OPERAND(r, OTHER_OPERAND(double_load, r))) 17368 * @param p BURS node to apply the rule to 17369 */ 17370 private void code536(AbstractBURS_TreeNode p) { 17371 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))); 17372 } 17373 17374 /** 17375 * Emit code for rule number 537: 17376 * r: FCMP_FCMOV(r, OTHER_OPERAND(float_load, any)) 17377 * @param p BURS node to apply the rule to 17378 */ 17379 private void code537(AbstractBURS_TreeNode p) { 17380 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))); 17381 } 17382 17383 /** 17384 * Emit code for rule number 538: 17385 * r: FCMP_FCMOV(r, OTHER_OPERAND(double_load, any)) 17386 * @param p BURS node to apply the rule to 17387 */ 17388 private void code538(AbstractBURS_TreeNode p) { 17389 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))); 17390 } 17391 17392 /** 17393 * Emit code for rule number 539: 17394 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 17395 * @param p BURS node to apply the rule to 17396 */ 17397 private void code539(AbstractBURS_TreeNode p) { 17398 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17399 } 17400 17401 /** 17402 * Emit code for rule number 540: 17403 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, FLOAT_NEG(r)))) 17404 * @param p BURS node to apply the rule to 17405 */ 17406 private void code540(AbstractBURS_TreeNode p) { 17407 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17408 } 17409 17410 /** 17411 * Emit code for rule number 541: 17412 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 17413 * @param p BURS node to apply the rule to 17414 */ 17415 private void code541(AbstractBURS_TreeNode p) { 17416 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17417 } 17418 17419 /** 17420 * Emit code for rule number 542: 17421 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(FLOAT_NEG(r), r))) 17422 * @param p BURS node to apply the rule to 17423 */ 17424 private void code542(AbstractBURS_TreeNode p) { 17425 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17426 } 17427 17428 /** 17429 * Emit code for rule number 543: 17430 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 17431 * @param p BURS node to apply the rule to 17432 */ 17433 private void code543(AbstractBURS_TreeNode p) { 17434 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17435 } 17436 17437 /** 17438 * Emit code for rule number 544: 17439 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(FLOAT_NEG(r), r))) 17440 * @param p BURS node to apply the rule to 17441 */ 17442 private void code544(AbstractBURS_TreeNode p) { 17443 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17444 } 17445 17446 /** 17447 * Emit code for rule number 545: 17448 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 17449 * @param p BURS node to apply the rule to 17450 */ 17451 private void code545(AbstractBURS_TreeNode p) { 17452 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17453 } 17454 17455 /** 17456 * Emit code for rule number 546: 17457 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, FLOAT_NEG(r)))) 17458 * @param p BURS node to apply the rule to 17459 */ 17460 private void code546(AbstractBURS_TreeNode p) { 17461 SSE2_ABS(true, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17462 } 17463 17464 /** 17465 * Emit code for rule number 547: 17466 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 17467 * @param p BURS node to apply the rule to 17468 */ 17469 private void code547(AbstractBURS_TreeNode p) { 17470 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17471 } 17472 17473 /** 17474 * Emit code for rule number 548: 17475 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, DOUBLE_NEG(r)))) 17476 * @param p BURS node to apply the rule to 17477 */ 17478 private void code548(AbstractBURS_TreeNode p) { 17479 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17480 } 17481 17482 /** 17483 * Emit code for rule number 549: 17484 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 17485 * @param p BURS node to apply the rule to 17486 */ 17487 private void code549(AbstractBURS_TreeNode p) { 17488 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17489 } 17490 17491 /** 17492 * Emit code for rule number 550: 17493 * r: FCMP_FCMOV(r, OTHER_OPERAND(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(DOUBLE_NEG(r), r))) 17494 * @param p BURS node to apply the rule to 17495 */ 17496 private void code550(AbstractBURS_TreeNode p) { 17497 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal1(P(p))); 17498 } 17499 17500 /** 17501 * Emit code for rule number 551: 17502 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 17503 * @param p BURS node to apply the rule to 17504 */ 17505 private void code551(AbstractBURS_TreeNode p) { 17506 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17507 } 17508 17509 /** 17510 * Emit code for rule number 552: 17511 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(DOUBLE_NEG(r), r))) 17512 * @param p BURS node to apply the rule to 17513 */ 17514 private void code552(AbstractBURS_TreeNode p) { 17515 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17516 } 17517 17518 /** 17519 * Emit code for rule number 553: 17520 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(INT_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 17521 * @param p BURS node to apply the rule to 17522 */ 17523 private void code553(AbstractBURS_TreeNode p) { 17524 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17525 } 17526 17527 /** 17528 * Emit code for rule number 554: 17529 * r: FCMP_FCMOV(MATERIALIZE_FP_CONSTANT(LONG_CONSTANT), OTHER_OPERAND(r, OTHER_OPERAND(r, DOUBLE_NEG(r)))) 17530 * @param p BURS node to apply the rule to 17531 */ 17532 private void code554(AbstractBURS_TreeNode p) { 17533 SSE2_ABS(false, P(p), CondMove.getResult(P(p)), CondMove.getVal2(P(p))); 17534 } 17535 17536 /** 17537 * Emit code for rule number 555: 17538 * stm: LONG_ASTORE(load64, OTHER_OPERAND(riv, riv)) 17539 * @param p BURS node to apply the rule to 17540 */ 17541 private void code555(AbstractBURS_TreeNode p) { 17542 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())); 17543 } 17544 17545 /** 17546 * Emit code for rule number 556: 17547 * stm: LONG_ASTORE(load64, OTHER_OPERAND(rlv, riv)) 17548 * @param p BURS node to apply the rule to 17549 */ 17550 private void code556(AbstractBURS_TreeNode p) { 17551 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())); 17552 } 17553 17554 /** 17555 * Emit code for rule number 557: 17556 * stm: LONG_STORE(load64, OTHER_OPERAND(riv, riv)) 17557 * @param p BURS node to apply the rule to 17558 */ 17559 private void code557(AbstractBURS_TreeNode p) { 17560 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())); 17561 } 17562 17563 /** 17564 * Emit code for rule number 558: 17565 * stm: LONG_STORE(load64, OTHER_OPERAND(rlv, riv)) 17566 * @param p BURS node to apply the rule to 17567 */ 17568 private void code558(AbstractBURS_TreeNode p) { 17569 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())); 17570 } 17571 17572 /** 17573 * Emit code using given rule number 17574 * 17575 * @param p the tree that's being emitted 17576 * @param n the non-terminal goal of that tree 17577 * @param ruleno the rule that will generate the tree 17578 */ 17579 @Override 17580 public void code(AbstractBURS_TreeNode p, int n, int ruleno) { 17581 switch(unsortedErnMap[ruleno]) { 17582 case 16: code16(p); break; 17583 case 17: code17(p); break; 17584 case 18: code18(p); break; 17585 case 19: code19(p); break; 17586 case 20: code20(p); break; 17587 case 21: code21(p); break; 17588 case 22: code22(p); break; 17589 case 23: code23(p); break; 17590 case 25: code25(p); break; 17591 case 26: code26(p); break; 17592 case 27: code27(p); break; 17593 case 28: code28(p); break; 17594 case 29: code29(p); break; 17595 case 30: code30(p); break; 17596 case 31: code31(p); break; 17597 case 32: code32(p); break; 17598 case 33: code33(p); break; 17599 case 34: code34(p); break; 17600 case 35: code35(p); break; 17601 case 36: code36(p); break; 17602 case 37: code37(p); break; 17603 case 38: code38(p); break; 17604 case 39: code39(p); break; 17605 case 40: code40(p); break; 17606 case 41: code41(p); break; 17607 case 42: code42(p); break; 17608 case 43: code43(p); break; 17609 case 44: code44(p); break; 17610 case 45: code45(p); break; 17611 case 46: code46(p); break; 17612 case 47: code47(p); break; 17613 case 48: code48(p); break; 17614 case 49: code49(p); break; 17615 case 50: code50(p); break; 17616 case 51: code51(p); break; 17617 case 52: code52(p); break; 17618 case 53: code53(p); break; 17619 case 54: code54(p); break; 17620 case 55: code55(p); break; 17621 case 56: code56(p); break; 17622 case 57: code57(p); break; 17623 case 58: code58(p); break; 17624 case 59: code59(p); break; 17625 case 60: code60(p); break; 17626 case 61: code61(p); break; 17627 case 62: code62(p); break; 17628 case 63: code63(p); break; 17629 case 64: code64(p); break; 17630 case 65: code65(p); break; 17631 case 66: code66(p); break; 17632 case 67: code67(p); break; 17633 case 68: code68(p); break; 17634 case 69: code69(p); break; 17635 case 70: code70(p); break; 17636 case 71: code71(p); break; 17637 case 72: code72(p); break; 17638 case 73: code73(p); break; 17639 case 74: code74(p); break; 17640 case 75: code75(p); break; 17641 case 76: code76(p); break; 17642 case 77: code77(p); break; 17643 case 78: code78(p); break; 17644 case 79: code79(p); break; 17645 case 80: code80(p); break; 17646 case 81: code81(p); break; 17647 case 84: code84(p); break; 17648 case 85: code85(p); break; 17649 case 86: code86(p); break; 17650 case 87: code87(p); break; 17651 case 88: code88(p); break; 17652 case 89: code89(p); break; 17653 case 90: code90(p); break; 17654 case 91: code91(p); break; 17655 case 93: code93(p); break; 17656 case 96: code96(p); break; 17657 case 97: code97(p); break; 17658 case 98: code98(p); break; 17659 case 99: code99(p); break; 17660 case 100: code100(p); break; 17661 case 101: code101(p); break; 17662 case 102: code102(p); break; 17663 case 103: code103(p); break; 17664 case 104: code104(p); break; 17665 case 105: code105(p); break; 17666 case 106: code106(p); break; 17667 case 107: code107(p); break; 17668 case 108: code108(p); break; 17669 case 109: code109(p); break; 17670 case 110: code110(p); break; 17671 case 111: code111(p); break; 17672 case 112: code112(p); break; 17673 case 113: code113(p); break; 17674 case 114: code114(p); break; 17675 case 115: code115(p); break; 17676 case 116: code116(p); break; 17677 case 117: code117(p); break; 17678 case 118: code118(p); break; 17679 case 119: code119(p); break; 17680 case 120: code120(p); break; 17681 case 121: code121(p); break; 17682 case 122: code122(p); break; 17683 case 123: code123(p); break; 17684 case 124: code124(p); break; 17685 case 125: code125(p); break; 17686 case 126: code126(p); break; 17687 case 127: code127(p); break; 17688 case 128: code128(p); break; 17689 case 129: code129(p); break; 17690 case 130: code130(p); break; 17691 case 131: code131(p); break; 17692 case 132: code132(p); break; 17693 case 133: code133(p); break; 17694 case 134: code134(p); break; 17695 case 135: code135(p); break; 17696 case 136: code136(p); break; 17697 case 137: code137(p); break; 17698 case 138: code138(p); break; 17699 case 139: code139(p); break; 17700 case 140: code140(p); break; 17701 case 141: code141(p); break; 17702 case 142: code142(p); break; 17703 case 143: code143(p); break; 17704 case 144: code144(p); break; 17705 case 145: code145(p); break; 17706 case 146: code146(p); break; 17707 case 147: code147(p); break; 17708 case 148: code148(p); break; 17709 case 150: code150(p); break; 17710 case 151: code151(p); break; 17711 case 152: code152(p); break; 17712 case 153: code153(p); break; 17713 case 154: code154(p); break; 17714 case 155: code155(p); break; 17715 case 156: code156(p); break; 17716 case 157: code157(p); break; 17717 case 158: code158(p); break; 17718 case 159: code159(p); break; 17719 case 160: code160(p); break; 17720 case 161: code161(p); break; 17721 case 162: code162(p); break; 17722 case 163: code163(p); break; 17723 case 164: code164(p); break; 17724 case 165: code165(p); break; 17725 case 166: code166(p); break; 17726 case 167: code167(p); break; 17727 case 168: code168(p); break; 17728 case 169: code169(p); break; 17729 case 170: code170(p); break; 17730 case 171: code171(p); break; 17731 case 172: code172(p); break; 17732 case 173: code173(p); break; 17733 case 174: code174(p); break; 17734 case 175: code175(p); break; 17735 case 176: code176(p); break; 17736 case 177: code177(p); break; 17737 case 178: code178(p); break; 17738 case 179: code179(p); break; 17739 case 180: code180(p); break; 17740 case 181: code181(p); break; 17741 case 182: code182(p); break; 17742 case 183: code183(p); break; 17743 case 184: code184(p); break; 17744 case 185: code185(p); break; 17745 case 186: code186(p); break; 17746 case 187: code187(p); break; 17747 case 188: code188(p); break; 17748 case 189: code189(p); break; 17749 case 190: code190(p); break; 17750 case 191: code191(p); break; 17751 case 192: code192(p); break; 17752 case 193: code193(p); break; 17753 case 194: code194(p); break; 17754 case 195: code195(p); break; 17755 case 196: code196(p); break; 17756 case 197: code197(p); break; 17757 case 198: code198(p); break; 17758 case 199: code199(p); break; 17759 case 200: code200(p); break; 17760 case 201: code201(p); break; 17761 case 202: code202(p); break; 17762 case 203: code203(p); break; 17763 case 204: code204(p); break; 17764 case 205: code205(p); break; 17765 case 206: code206(p); break; 17766 case 207: code207(p); break; 17767 case 208: code208(p); break; 17768 case 209: code209(p); break; 17769 case 210: code210(p); break; 17770 case 211: code211(p); break; 17771 case 212: code212(p); break; 17772 case 213: code213(p); break; 17773 case 214: code214(p); break; 17774 case 215: code215(p); break; 17775 case 216: code216(p); break; 17776 case 217: code217(p); break; 17777 case 218: code218(p); break; 17778 case 219: code219(p); break; 17779 case 220: code220(p); break; 17780 case 221: code221(p); break; 17781 case 222: code222(p); break; 17782 case 223: code223(p); break; 17783 case 224: code224(p); break; 17784 case 225: code225(p); break; 17785 case 226: code226(p); break; 17786 case 227: code227(p); break; 17787 case 228: code228(p); break; 17788 case 229: code229(p); break; 17789 case 230: code230(p); break; 17790 case 231: code231(p); break; 17791 case 232: code232(p); break; 17792 case 233: code233(p); break; 17793 case 234: code234(p); break; 17794 case 235: code235(p); break; 17795 case 236: code236(p); break; 17796 case 237: code237(p); break; 17797 case 238: code238(p); break; 17798 case 239: code239(p); break; 17799 case 240: code240(p); break; 17800 case 241: code241(p); break; 17801 case 242: code242(p); break; 17802 case 243: code243(p); break; 17803 case 244: code244(p); break; 17804 case 245: code245(p); break; 17805 case 246: code246(p); break; 17806 case 247: code247(p); break; 17807 case 248: code248(p); break; 17808 case 250: code250(p); break; 17809 case 259: code259(p); break; 17810 case 260: code260(p); break; 17811 case 261: code261(p); break; 17812 case 262: code262(p); break; 17813 case 263: code263(p); break; 17814 case 264: code264(p); break; 17815 case 265: code265(p); break; 17816 case 266: code266(p); break; 17817 case 267: code267(p); break; 17818 case 268: code268(p); break; 17819 case 269: code269(p); break; 17820 case 270: code270(p); break; 17821 case 271: code271(p); break; 17822 case 272: code272(p); break; 17823 case 273: code273(p); break; 17824 case 274: code274(p); break; 17825 case 275: code275(p); break; 17826 case 276: code276(p); break; 17827 case 277: code277(p); break; 17828 case 278: code278(p); break; 17829 case 279: code279(p); break; 17830 case 280: code280(p); break; 17831 case 281: code281(p); break; 17832 case 282: code282(p); break; 17833 case 283: code283(p); break; 17834 case 284: code284(p); break; 17835 case 285: code285(p); break; 17836 case 286: code286(p); break; 17837 case 287: code287(p); break; 17838 case 288: code288(p); break; 17839 case 289: code289(p); break; 17840 case 290: code290(p); break; 17841 case 291: code291(p); break; 17842 case 292: code292(p); break; 17843 case 293: code293(p); break; 17844 case 294: code294(p); break; 17845 case 295: code295(p); break; 17846 case 296: code296(p); break; 17847 case 297: code297(p); break; 17848 case 298: code298(p); break; 17849 case 299: code299(p); break; 17850 case 300: code300(p); break; 17851 case 301: code301(p); break; 17852 case 302: code302(p); break; 17853 case 303: code303(p); break; 17854 case 304: code304(p); break; 17855 case 305: code305(p); break; 17856 case 306: code306(p); break; 17857 case 307: code307(p); break; 17858 case 308: code308(p); break; 17859 case 309: code309(p); break; 17860 case 310: code310(p); break; 17861 case 311: code311(p); break; 17862 case 312: code312(p); break; 17863 case 313: code313(p); break; 17864 case 314: code314(p); break; 17865 case 315: code315(p); break; 17866 case 316: code316(p); break; 17867 case 317: code317(p); break; 17868 case 318: code318(p); break; 17869 case 319: code319(p); break; 17870 case 320: code320(p); break; 17871 case 321: code321(p); break; 17872 case 322: code322(p); break; 17873 case 323: code323(p); break; 17874 case 324: code324(p); break; 17875 case 325: code325(p); break; 17876 case 326: code326(p); break; 17877 case 327: code327(p); break; 17878 case 328: code328(p); break; 17879 case 329: code329(p); break; 17880 case 330: code330(p); break; 17881 case 331: code331(p); break; 17882 case 332: code332(p); break; 17883 case 333: code333(p); break; 17884 case 334: code334(p); break; 17885 case 335: code335(p); break; 17886 case 336: code336(p); break; 17887 case 337: code337(p); break; 17888 case 338: code338(p); break; 17889 case 339: code339(p); break; 17890 case 340: code340(p); break; 17891 case 341: code341(p); break; 17892 case 342: code342(p); break; 17893 case 343: code343(p); break; 17894 case 344: code344(p); break; 17895 case 347: code347(p); break; 17896 case 348: code348(p); break; 17897 case 349: code349(p); break; 17898 case 350: code350(p); break; 17899 case 351: code351(p); break; 17900 case 352: code352(p); break; 17901 case 353: code353(p); break; 17902 case 354: code354(p); break; 17903 case 357: code357(p); break; 17904 case 358: code358(p); break; 17905 case 363: code363(p); break; 17906 case 364: code364(p); break; 17907 case 365: code365(p); break; 17908 case 366: code366(p); break; 17909 case 367: code367(p); break; 17910 case 368: code368(p); break; 17911 case 369: code369(p); break; 17912 case 370: code370(p); break; 17913 case 371: code371(p); break; 17914 case 372: code372(p); break; 17915 case 373: code373(p); break; 17916 case 374: code374(p); break; 17917 case 375: code375(p); break; 17918 case 376: code376(p); break; 17919 case 377: code377(p); break; 17920 case 378: code378(p); break; 17921 case 379: code379(p); break; 17922 case 380: code380(p); break; 17923 case 381: code381(p); break; 17924 case 382: code382(p); break; 17925 case 383: code383(p); break; 17926 case 384: code384(p); break; 17927 case 385: code385(p); break; 17928 case 386: code386(p); break; 17929 case 387: code387(p); break; 17930 case 388: code388(p); break; 17931 case 389: code389(p); break; 17932 case 390: code390(p); break; 17933 case 391: code391(p); break; 17934 case 392: code392(p); break; 17935 case 393: code393(p); break; 17936 case 394: code394(p); break; 17937 case 396: code396(p); break; 17938 case 397: code397(p); break; 17939 case 398: code398(p); break; 17940 case 399: code399(p); break; 17941 case 400: code400(p); break; 17942 case 401: code401(p); break; 17943 case 402: code402(p); break; 17944 case 403: code403(p); break; 17945 case 404: code404(p); break; 17946 case 405: code405(p); break; 17947 case 406: code406(p); break; 17948 case 407: code407(p); break; 17949 case 408: code408(p); break; 17950 case 409: code409(p); break; 17951 case 410: code410(p); break; 17952 case 411: code411(p); break; 17953 case 412: code412(p); break; 17954 case 413: code413(p); break; 17955 case 414: code414(p); break; 17956 case 415: code415(p); break; 17957 case 416: code416(p); break; 17958 case 417: code417(p); break; 17959 case 418: code418(p); break; 17960 case 419: code419(p); break; 17961 case 420: code420(p); break; 17962 case 421: code421(p); break; 17963 case 422: code422(p); break; 17964 case 423: code423(p); break; 17965 case 424: code424(p); break; 17966 case 425: code425(p); break; 17967 case 426: code426(p); break; 17968 case 427: code427(p); break; 17969 case 428: code428(p); break; 17970 case 429: code429(p); break; 17971 case 430: code430(p); break; 17972 case 431: code431(p); break; 17973 case 432: code432(p); break; 17974 case 433: code433(p); break; 17975 case 434: code434(p); break; 17976 case 435: code435(p); break; 17977 case 436: code436(p); break; 17978 case 437: code437(p); break; 17979 case 438: code438(p); break; 17980 case 439: code439(p); break; 17981 case 440: code440(p); break; 17982 case 441: code441(p); break; 17983 case 442: code442(p); break; 17984 case 443: code443(p); break; 17985 case 444: code444(p); break; 17986 case 445: code445(p); break; 17987 case 446: code446(p); break; 17988 case 447: code447(p); break; 17989 case 448: code448(p); break; 17990 case 449: code449(p); break; 17991 case 450: code450(p); break; 17992 case 451: code451(p); break; 17993 case 452: code452(p); break; 17994 case 453: code453(p); break; 17995 case 454: code454(p); break; 17996 case 455: code455(p); break; 17997 case 456: code456(p); break; 17998 case 457: code457(p); break; 17999 case 458: code458(p); break; 18000 case 459: code459(p); break; 18001 case 460: code460(p); break; 18002 case 461: code461(p); break; 18003 case 462: code462(p); break; 18004 case 463: code463(p); break; 18005 case 464: code464(p); break; 18006 case 465: code465(p); break; 18007 case 466: code466(p); break; 18008 case 467: code467(p); break; 18009 case 468: code468(p); break; 18010 case 469: code469(p); break; 18011 case 470: code470(p); break; 18012 case 471: code471(p); break; 18013 case 472: code472(p); break; 18014 case 473: code473(p); break; 18015 case 474: code474(p); break; 18016 case 475: code475(p); break; 18017 case 476: code476(p); break; 18018 case 477: code477(p); break; 18019 case 478: code478(p); break; 18020 case 479: code479(p); break; 18021 case 480: code480(p); break; 18022 case 481: code481(p); break; 18023 case 482: code482(p); break; 18024 case 483: code483(p); break; 18025 case 484: code484(p); break; 18026 case 485: code485(p); break; 18027 case 486: code486(p); break; 18028 case 487: code487(p); break; 18029 case 488: code488(p); break; 18030 case 489: code489(p); break; 18031 case 490: code490(p); break; 18032 case 491: code491(p); break; 18033 case 492: code492(p); break; 18034 case 493: code493(p); break; 18035 case 494: code494(p); break; 18036 case 495: code495(p); break; 18037 case 496: code496(p); break; 18038 case 497: code497(p); break; 18039 case 498: code498(p); break; 18040 case 499: code499(p); break; 18041 case 500: code500(p); break; 18042 case 501: code501(p); break; 18043 case 502: code502(p); break; 18044 case 503: code503(p); break; 18045 case 504: code504(p); break; 18046 case 505: code505(p); break; 18047 case 506: code506(p); break; 18048 case 507: code507(p); break; 18049 case 508: code508(p); break; 18050 case 509: code509(p); break; 18051 case 511: code511(p); break; 18052 case 513: code513(p); break; 18053 case 515: code515(p); break; 18054 case 517: code517(p); break; 18055 case 518: code518(p); break; 18056 case 519: code519(p); break; 18057 case 520: code520(p); break; 18058 case 521: code521(p); break; 18059 case 522: code522(p); break; 18060 case 523: code523(p); break; 18061 case 524: code524(p); break; 18062 case 525: code525(p); break; 18063 case 526: code526(p); break; 18064 case 527: code527(p); break; 18065 case 528: code528(p); break; 18066 case 529: code529(p); break; 18067 case 530: code530(p); break; 18068 case 531: code531(p); break; 18069 case 532: code532(p); break; 18070 case 533: code533(p); break; 18071 case 534: code534(p); break; 18072 case 535: code535(p); break; 18073 case 536: code536(p); break; 18074 case 537: code537(p); break; 18075 case 538: code538(p); break; 18076 case 539: code539(p); break; 18077 case 540: code540(p); break; 18078 case 541: code541(p); break; 18079 case 542: code542(p); break; 18080 case 543: code543(p); break; 18081 case 544: code544(p); break; 18082 case 545: code545(p); break; 18083 case 546: code546(p); break; 18084 case 547: code547(p); break; 18085 case 548: code548(p); break; 18086 case 549: code549(p); break; 18087 case 550: code550(p); break; 18088 case 551: code551(p); break; 18089 case 552: code552(p); break; 18090 case 553: code553(p); break; 18091 case 554: code554(p); break; 18092 case 555: code555(p); break; 18093 case 556: code556(p); break; 18094 case 557: code557(p); break; 18095 case 558: code558(p); break; 18096 default: 18097 throw new OptimizingCompilerException("BURS", "rule " + ruleno + " without emit code:", 18098 BURS_Debug.string[unsortedErnMap[ruleno]]); 18099 } 18100 } 18101}