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.ppc_64; 014 015import static org.jikesrvm.compilers.opt.ir.Operators.*; 016import static org.jikesrvm.compilers.opt.ir.ppc.ArchOperators.*; 017import static org.jikesrvm.compilers.opt.lir2mir.ppc_64.BURS_Definitions.*; 018import static org.jikesrvm.compilers.opt.ir.IRTools.*; 019 020import org.jikesrvm.*; 021import org.jikesrvm.classloader.*; 022import org.jikesrvm.compilers.opt.ir.*; 023import org.jikesrvm.compilers.opt.ir.ppc.*; 024import org.jikesrvm.compilers.opt.ir.operand.*; 025import org.jikesrvm.compilers.opt.ir.operand.ppc.*; 026import org.jikesrvm.compilers.opt.lir2mir.ppc.BURS_Helpers; 027import org.jikesrvm.compilers.opt.lir2mir.ppc_64.BURS_TreeNode; 028import org.jikesrvm.compilers.opt.lir2mir.AbstractBURS_TreeNode; 029import org.jikesrvm.compilers.opt.lir2mir.BURS; 030import org.jikesrvm.compilers.opt.lir2mir.BURS_StateCoder; 031import org.jikesrvm.compilers.opt.OptimizingCompilerException; 032import org.jikesrvm.runtime.ArchEntrypoints; 033import org.jikesrvm.util.Bits; //NOPMD 034 035import org.vmmagic.unboxed.*; 036import org.vmmagic.pragma.Inline; 037import org.vmmagic.pragma.Pure; 038 039/** 040 * Machine-specific instruction selection rules. Program generated. 041 * 042 * Note: some of the functions have been taken and modified 043 * from the file gen.c, from the LCC compiler. 044 * See $RVM_ROOT/rvm/src-generated/opt-burs/jburg/COPYRIGHT file for copyright restrictions. 045 * 046 * @see BURS 047 * 048 * NOTE: Program generated file, do not edit! 049 */ 050@SuppressWarnings("unused") // Machine generated code is hard to get perfect 051public class BURS_STATE extends BURS_Helpers implements BURS_StateCoder { 052 053 public BURS_STATE(BURS b) { 054 super(b); 055 } 056 057/*****************************************************************/ 058/* */ 059/* BURS TEMPLATE */ 060/* */ 061/*****************************************************************/ 062 063 /** 064 * Gets the state of a BURS node. This accessor is used by BURS. 065 * 066 * @param a the node 067 * 068 * @return the node's state 069 */ 070 private static AbstractBURS_TreeNode STATE(AbstractBURS_TreeNode a) { return a; } 071 072 /*********************************************************************** 073 * 074 * This file contains BURG utilities 075 * 076 * Note: some of the functions have been taken and modified 077 * from the file gen.c, from the LCC compiler. 078 * 079 ************************************************************************/ 080 081 /** 082 * Prints a debug message. No-op if debugging is disabled. 083 * 084 * @param p the BURS node 085 * @param rule the rule 086 * @param cost the rule's cost 087 * @param bestcost the best cost seen so far 088 */ 089 private static void trace(AbstractBURS_TreeNode p, int rule, int cost, int bestcost) { 090 if (BURS.DEBUG) { 091 VM.sysWriteln(p + " matched " + BURS_Debug.string[rule] + " with cost " + 092 cost + " vs. " + bestcost); 093 } 094 } 095 096 /** 097 * Dumps the whole tree starting at the given node. No-op if 098 * debugging is disabled. 099 * 100 * @param p the node to start at 101 */ 102 public static void dumpTree(AbstractBURS_TreeNode p) { 103 if (BURS.DEBUG) { 104 VM.sysWrite(dumpTree("\n",p,1)); 105 } 106 } 107 108 public static String dumpTree(String out, AbstractBURS_TreeNode p, int indent) { 109 if (p == null) return out; 110 StringBuilder result = new StringBuilder(out); 111 for (int i=0; i<indent; i++) 112 result.append(" "); 113 result.append(p); 114 result.append('\n'); 115 if (p.getChild1() != null) { 116 indent++; 117 result.append(dumpTree("",p.getChild1(),indent)); 118 if (p.getChild2() != null) { 119 result.append(dumpTree("",p.getChild2(),indent)); 120 } 121 } 122 return result.toString(); 123 } 124 125 /** 126 * Dumps the cover of a tree, i.e. the rules 127 * that cover the tree with a minimal cost. No-op if debugging is 128 * disabled. 129 * 130 * @param p the tree's root 131 * @param goalnt the non-terminal that is a goal. This is an external rule number 132 * @param indent number of spaces to use for indentation 133 */ 134 public static void dumpCover(AbstractBURS_TreeNode p, byte goalnt, int indent){ 135 if (BURS.DEBUG) { 136 if (p == null) return; 137 int rule = STATE(p).rule(goalnt); 138 VM.sysWrite(STATE(p).getCost(goalnt)+"\t"); 139 for (int i = 0; i < indent; i++) 140 VM.sysWrite(' '); 141 VM.sysWrite(BURS_Debug.string[rule]+"\n"); 142 for (int i = 0; i < nts[rule].length; i++) 143 dumpCover(kids(p,rule,i), nts[rule][i], indent + 1); 144 } 145 } 146 147 // caution: MARK should be used in single threaded mode, 148 @Inline 149 public static void mark(AbstractBURS_TreeNode p, byte goalnt) { 150 if (p == null) return; 151 int rule = STATE(p).rule(goalnt); 152 byte act = action(rule); 153 if ((act & EMIT_INSTRUCTION) != 0) { 154 p.setNonTerminal(goalnt); 155 } 156 if (rule == 0) { 157 if (BURS.DEBUG) { 158 VM.sysWrite("marking " + p + " with a goalnt of " + goalnt + " failed as the rule " + rule + " has no action"); 159 } 160 throw new OptimizingCompilerException("BURS", "rule missing in ", 161 p.getInstructionString(), dumpTree("", p, 1)); 162 } 163 mark_kids(p,rule); 164 } 165/* 166 * This file is part of the Jikes RVM project (http://jikesrvm.org). 167 * 168 * This file is licensed to You under the Eclipse Public License (EPL); 169 * You may not use this file except in compliance with the License. You 170 * may obtain a copy of the License at 171 * 172 * http://www.opensource.org/licenses/eclipse-1.0.php 173 * 174 * See the COPYRIGHT.txt file distributed with this work for information 175 * regarding copyright ownership. 176 */ 177//ir.brg 178 179 /** 180 * Generate from ir.template and assembled rules files. 181 */ 182 /** Sorted rule number to unsorted rule number map */ 183 private static int[] unsortedErnMap = { 184 0, /* 0 - no rule */ 185 1, /* 1 - stm: r */ 186 3, /* 2 - r: czr */ 187 4, /* 3 - r: rs */ 188 5, /* 4 - r: rz */ 189 6, /* 5 - rs: rp */ 190 7, /* 6 - rz: rp */ 191 9, /* 7 - any: r */ 192 2, /* 8 - r: REGISTER */ 193 8, /* 9 - any: NULL */ 194 10, /* 10 - any: ADDRESS_CONSTANT */ 195 11, /* 11 - any: INT_CONSTANT */ 196 12, /* 12 - any: LONG_CONSTANT */ 197 14, /* 13 - stm: RESOLVE */ 198 15, /* 14 - stm: IG_PATCH_POINT */ 199 16, /* 15 - stm: UNINT_BEGIN */ 200 17, /* 16 - stm: UNINT_END */ 201 18, /* 17 - stm: YIELDPOINT_PROLOGUE */ 202 19, /* 18 - stm: YIELDPOINT_EPILOGUE */ 203 20, /* 19 - stm: YIELDPOINT_BACKEDGE */ 204 22, /* 20 - stm: NOP */ 205 23, /* 21 - r: GUARD_MOVE */ 206 24, /* 22 - r: GUARD_COMBINE */ 207 26, /* 23 - r: GET_CAUGHT_EXCEPTION */ 208 28, /* 24 - stm: FENCE */ 209 29, /* 25 - stm: WRITE_FLOOR */ 210 30, /* 26 - stm: READ_CEILING */ 211 38, /* 27 - stm: TRAP */ 212 136, /* 28 - rs: REF_MOVE(INT_CONSTANT) */ 213 137, /* 29 - rs: REF_MOVE(INT_CONSTANT) */ 214 138, /* 30 - rs: REF_MOVE(INT_CONSTANT) */ 215 205, /* 31 - stm: GOTO */ 216 206, /* 32 - stm: RETURN(NULL) */ 217 211, /* 33 - r: GET_TIME_BASE */ 218 218, /* 34 - stm: IR_PROLOGUE */ 219 240, /* 35 - r: REF_MOVE(ADDRESS_CONSTANT) */ 220 241, /* 36 - r: REF_MOVE(LONG_CONSTANT) */ 221 13, /* 37 - any: OTHER_OPERAND(any,any) */ 222 39, /* 38 - stm: TRAP_IF(r,r) */ 223 44, /* 39 - r: BOOLEAN_CMP_INT(r,r) */ 224 46, /* 40 - boolcmp: BOOLEAN_CMP_INT(r,r) */ 225 48, /* 41 - r: BOOLEAN_CMP_ADDR(r,r) */ 226 50, /* 42 - boolcmp: BOOLEAN_CMP_ADDR(r,r) */ 227 60, /* 43 - r: REF_ADD(r,r) */ 228 63, /* 44 - r: REF_SUB(r,r) */ 229 66, /* 45 - r: INT_MUL(r,r) */ 230 67, /* 46 - r: INT_DIV(r,r) */ 231 69, /* 47 - r: INT_REM(r,r) */ 232 73, /* 48 - rz: INT_SHL(r,r) */ 233 76, /* 49 - rs: INT_SHR(r,r) */ 234 79, /* 50 - rz: INT_USHR(r,r) */ 235 83, /* 51 - r: REF_AND(r,r) */ 236 90, /* 52 - r: REF_OR(r,r) */ 237 94, /* 53 - r: REF_XOR(r,r) */ 238 100, /* 54 - r: FLOAT_ADD(r,r) */ 239 101, /* 55 - r: DOUBLE_ADD(r,r) */ 240 102, /* 56 - r: FLOAT_MUL(r,r) */ 241 103, /* 57 - r: DOUBLE_MUL(r,r) */ 242 104, /* 58 - r: FLOAT_SUB(r,r) */ 243 105, /* 59 - r: DOUBLE_SUB(r,r) */ 244 106, /* 60 - r: FLOAT_DIV(r,r) */ 245 107, /* 61 - r: DOUBLE_DIV(r,r) */ 246 142, /* 62 - rs: BYTE_LOAD(r,r) */ 247 146, /* 63 - rp: UBYTE_LOAD(r,r) */ 248 148, /* 64 - rs: SHORT_LOAD(r,r) */ 249 150, /* 65 - rp: USHORT_LOAD(r,r) */ 250 153, /* 66 - r: FLOAT_LOAD(r,r) */ 251 156, /* 67 - r: DOUBLE_LOAD(r,r) */ 252 159, /* 68 - rs: INT_LOAD(r,r) */ 253 182, /* 69 - stm: INT_IFCMP(r,r) */ 254 197, /* 70 - stm: INT_IFCMP2(r,r) */ 255 199, /* 71 - stm: FLOAT_IFCMP(r,r) */ 256 200, /* 72 - stm: DOUBLE_IFCMP(r,r) */ 257 201, /* 73 - stm: FLOAT_CMPL(r,r) */ 258 202, /* 74 - stm: FLOAT_CMPG(r,r) */ 259 203, /* 75 - stm: DOUBLE_CMPL(r,r) */ 260 204, /* 76 - stm: DOUBLE_CMPG(r,r) */ 261 208, /* 77 - r: CALL(r,any) */ 262 210, /* 78 - r: SYSCALL(r,any) */ 263 212, /* 79 - r: OTHER_OPERAND(r,r) */ 264 213, /* 80 - r: YIELDPOINT_OSR(any,any) */ 265 214, /* 81 - r: PREPARE_INT(r,r) */ 266 215, /* 82 - r: PREPARE_LONG(r,r) */ 267 216, /* 83 - r: ATTEMPT_INT(r,r) */ 268 217, /* 84 - r: ATTEMPT_LONG(r,r) */ 269 220, /* 85 - r: LONG_MUL(r,r) */ 270 221, /* 86 - r: LONG_DIV(r,r) */ 271 223, /* 87 - r: LONG_REM(r,r) */ 272 226, /* 88 - r: LONG_SHL(r,r) */ 273 230, /* 89 - r: LONG_SHR(r,r) */ 274 232, /* 90 - r: LONG_USHR(r,r) */ 275 242, /* 91 - r: LONG_CMP(r,r) */ 276 243, /* 92 - stm: LONG_IFCMP(r,r) */ 277 255, /* 93 - r: LONG_LOAD(r,r) */ 278 262, /* 94 - r: PREPARE_ADDR(r,r) */ 279 263, /* 95 - r: ATTEMPT_ADDR(r,r) */ 280 21, /* 96 - stm: LOWTABLESWITCH(r) */ 281 25, /* 97 - stm: NULL_CHECK(r) */ 282 27, /* 98 - stm: SET_CAUGHT_EXCEPTION(r) */ 283 31, /* 99 - stm: DCBF(r) */ 284 32, /* 100 - stm: DCBST(r) */ 285 33, /* 101 - stm: DCBT(r) */ 286 34, /* 102 - stm: DCBTST(r) */ 287 35, /* 103 - stm: DCBZ(r) */ 288 36, /* 104 - stm: DCBZL(r) */ 289 37, /* 105 - stm: ICBI(r) */ 290 40, /* 106 - stm: TRAP_IF(r,INT_CONSTANT) */ 291 41, /* 107 - stm: TRAP_IF(r,LONG_CONSTANT) */ 292 42, /* 108 - r: BOOLEAN_NOT(r) */ 293 43, /* 109 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 294 45, /* 110 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) */ 295 47, /* 111 - r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) */ 296 49, /* 112 - boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) */ 297 51, /* 113 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 298 52, /* 114 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 299 53, /* 115 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 300 54, /* 116 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 301 55, /* 117 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 302 56, /* 118 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 303 57, /* 119 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 304 58, /* 120 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) */ 305 59, /* 121 - r: REF_ADD(r,INT_CONSTANT) */ 306 61, /* 122 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) */ 307 62, /* 123 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) */ 308 65, /* 124 - r: INT_MUL(r,INT_CONSTANT) */ 309 68, /* 125 - r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) */ 310 70, /* 126 - r: INT_REM(r,REF_MOVE(INT_CONSTANT)) */ 311 71, /* 127 - r: REF_NEG(r) */ 312 72, /* 128 - rz: INT_SHL(r,INT_CONSTANT) */ 313 75, /* 129 - rs: INT_SHR(r,INT_CONSTANT) */ 314 78, /* 130 - rp: INT_USHR(r,INT_CONSTANT) */ 315 84, /* 131 - czr: REF_AND(r,INT_CONSTANT) */ 316 85, /* 132 - rp: REF_AND(r,INT_CONSTANT) */ 317 91, /* 133 - r: REF_OR(r,INT_CONSTANT) */ 318 95, /* 134 - r: REF_XOR(r,INT_CONSTANT) */ 319 96, /* 135 - r: REF_NOT(r) */ 320 108, /* 136 - r: FLOAT_NEG(r) */ 321 109, /* 137 - r: DOUBLE_NEG(r) */ 322 110, /* 138 - r: FLOAT_SQRT(r) */ 323 111, /* 139 - r: DOUBLE_SQRT(r) */ 324 124, /* 140 - rs: INT_2BYTE(r) */ 325 125, /* 141 - rp: INT_2USHORT(r) */ 326 126, /* 142 - rs: INT_2SHORT(r) */ 327 127, /* 143 - r: INT_2FLOAT(r) */ 328 128, /* 144 - r: INT_2DOUBLE(r) */ 329 129, /* 145 - r: FLOAT_2INT(r) */ 330 130, /* 146 - r: FLOAT_2DOUBLE(r) */ 331 131, /* 147 - r: DOUBLE_2INT(r) */ 332 132, /* 148 - r: DOUBLE_2FLOAT(r) */ 333 133, /* 149 - r: FLOAT_AS_INT_BITS(r) */ 334 134, /* 150 - r: INT_BITS_AS_FLOAT(r) */ 335 135, /* 151 - r: REF_MOVE(r) */ 336 139, /* 152 - r: FLOAT_MOVE(r) */ 337 140, /* 153 - r: DOUBLE_MOVE(r) */ 338 141, /* 154 - rs: BYTE_LOAD(r,INT_CONSTANT) */ 339 145, /* 155 - rp: UBYTE_LOAD(r,INT_CONSTANT) */ 340 147, /* 156 - rs: SHORT_LOAD(r,INT_CONSTANT) */ 341 149, /* 157 - rp: USHORT_LOAD(r,INT_CONSTANT) */ 342 151, /* 158 - r: FLOAT_LOAD(r,INT_CONSTANT) */ 343 152, /* 159 - r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) */ 344 154, /* 160 - r: DOUBLE_LOAD(r,INT_CONSTANT) */ 345 155, /* 161 - r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) */ 346 157, /* 162 - rs: INT_LOAD(r,INT_CONSTANT) */ 347 158, /* 163 - rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) */ 348 183, /* 164 - stm: INT_IFCMP(r,INT_CONSTANT) */ 349 193, /* 165 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 350 194, /* 166 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 351 195, /* 167 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 352 196, /* 168 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) */ 353 198, /* 169 - stm: INT_IFCMP2(r,INT_CONSTANT) */ 354 207, /* 170 - stm: RETURN(r) */ 355 219, /* 171 - r: LONG_MUL(r,INT_CONSTANT) */ 356 222, /* 172 - r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) */ 357 224, /* 173 - r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) */ 358 225, /* 174 - r: LONG_SHL(r,INT_CONSTANT) */ 359 229, /* 175 - r: LONG_SHR(r,INT_CONSTANT) */ 360 231, /* 176 - r: LONG_USHR(r,INT_CONSTANT) */ 361 233, /* 177 - rs: INT_2LONG(r) */ 362 234, /* 178 - rs: INT_2LONG(rs) */ 363 235, /* 179 - r: LONG_2INT(r) */ 364 236, /* 180 - r: FLOAT_2LONG(r) */ 365 237, /* 181 - r: DOUBLE_2LONG(r) */ 366 238, /* 182 - r: DOUBLE_AS_LONG_BITS(r) */ 367 239, /* 183 - r: LONG_BITS_AS_DOUBLE(r) */ 368 244, /* 184 - stm: LONG_IFCMP(r,INT_CONSTANT) */ 369 245, /* 185 - stm: LONG_IFCMP(r,LONG_CONSTANT) */ 370 248, /* 186 - rz: INT_2ADDRZerExt(rz) */ 371 249, /* 187 - rz: INT_2ADDRZerExt(r) */ 372 253, /* 188 - r: LONG_LOAD(r,INT_CONSTANT) */ 373 254, /* 189 - r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) */ 374 64, /* 190 - r: REF_SUB(INT_CONSTANT,r) */ 375 209, /* 191 - r: CALL(BRANCH_TARGET,any) */ 376 74, /* 192 - rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 377 77, /* 193 - rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) */ 378 80, /* 194 - rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) */ 379 81, /* 195 - rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) */ 380 82, /* 196 - rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) */ 381 88, /* 197 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 382 89, /* 198 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) */ 383 144, /* 199 - rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) */ 384 161, /* 200 - rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) */ 385 184, /* 201 - stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) */ 386 185, /* 202 - stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) */ 387 189, /* 203 - stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 388 190, /* 204 - stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) */ 389 191, /* 205 - stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) */ 390 192, /* 206 - stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) */ 391 227, /* 207 - r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) */ 392 228, /* 208 - r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) */ 393 250, /* 209 - rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) */ 394 257, /* 210 - r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) */ 395 86, /* 211 - r: REF_AND(REF_NOT(r),REF_NOT(r)) */ 396 92, /* 212 - r: REF_OR(REF_NOT(r),REF_NOT(r)) */ 397 164, /* 213 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) */ 398 168, /* 214 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) */ 399 170, /* 215 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) */ 400 87, /* 216 - r: REF_AND(r,REF_NOT(r)) */ 401 93, /* 217 - r: REF_OR(r,REF_NOT(r)) */ 402 162, /* 218 - stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 403 166, /* 219 - stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 404 172, /* 220 - stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 405 173, /* 221 - stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) */ 406 176, /* 222 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 407 177, /* 223 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) */ 408 179, /* 224 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 409 180, /* 225 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) */ 410 258, /* 226 - stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) */ 411 259, /* 227 - stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) */ 412 97, /* 228 - r: REF_NOT(REF_OR(r,r)) */ 413 98, /* 229 - r: REF_NOT(REF_AND(r,r)) */ 414 99, /* 230 - r: REF_NOT(REF_XOR(r,r)) */ 415 143, /* 231 - rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) */ 416 160, /* 232 - rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) */ 417 186, /* 233 - stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) */ 418 187, /* 234 - stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) */ 419 188, /* 235 - stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) */ 420 246, /* 236 - stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) */ 421 247, /* 237 - stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) */ 422 251, /* 238 - rz: INT_2ADDRZerExt(INT_LOAD(r,r)) */ 423 256, /* 239 - r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) */ 424 112, /* 240 - r: FLOAT_ADD(FLOAT_MUL(r,r),r) */ 425 113, /* 241 - r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) */ 426 116, /* 242 - r: FLOAT_SUB(FLOAT_MUL(r,r),r) */ 427 117, /* 243 - r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) */ 428 114, /* 244 - r: FLOAT_ADD(r,FLOAT_MUL(r,r)) */ 429 115, /* 245 - r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) */ 430 163, /* 246 - stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) */ 431 167, /* 247 - stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) */ 432 174, /* 248 - stm: INT_STORE(r,OTHER_OPERAND(r,r)) */ 433 178, /* 249 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) */ 434 181, /* 250 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) */ 435 260, /* 251 - stm: LONG_STORE(r,OTHER_OPERAND(r,r)) */ 436 118, /* 252 - r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) */ 437 119, /* 253 - r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) */ 438 122, /* 254 - r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) */ 439 123, /* 255 - r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) */ 440 120, /* 256 - r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) */ 441 121, /* 257 - r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) */ 442 165, /* 258 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) */ 443 169, /* 259 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) */ 444 171, /* 260 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) */ 445 175, /* 261 - stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) */ 446 261, /* 262 - stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) */ 447 }; 448 449 /** Ragged array for non-terminal leaves of r_NT, */ 450 private static final byte[] nts_0 = { r_NT, }; 451 /** Ragged array for non-terminal leaves of czr_NT, */ 452 private static final byte[] nts_1 = { czr_NT, }; 453 /** Ragged array for non-terminal leaves of rs_NT, */ 454 private static final byte[] nts_2 = { rs_NT, }; 455 /** Ragged array for non-terminal leaves of rz_NT, */ 456 private static final byte[] nts_3 = { rz_NT, }; 457 /** Ragged array for non-terminal leaves of rp_NT, */ 458 private static final byte[] nts_4 = { rp_NT, }; 459 /** Ragged array for non-terminal leaves of */ 460 private static final byte[] nts_5 = { }; 461 /** Ragged array for non-terminal leaves of any_NT, any_NT, */ 462 private static final byte[] nts_6 = { any_NT, any_NT, }; 463 /** Ragged array for non-terminal leaves of r_NT, r_NT, */ 464 private static final byte[] nts_7 = { r_NT, r_NT, }; 465 /** Ragged array for non-terminal leaves of r_NT, any_NT, */ 466 private static final byte[] nts_8 = { r_NT, any_NT, }; 467 /** Ragged array for non-terminal leaves of boolcmp_NT, */ 468 private static final byte[] nts_9 = { boolcmp_NT, }; 469 /** Ragged array for non-terminal leaves of any_NT, */ 470 private static final byte[] nts_10 = { any_NT, }; 471 /** Ragged array for non-terminal leaves of r_NT, r_NT, r_NT, */ 472 private static final byte[] nts_11 = { r_NT, r_NT, r_NT, }; 473 474 /** Map non-terminal to non-terminal leaves */ 475 private static final byte[][] nts = { 476 null, /* 0 */ 477 nts_0, // 1 - stm: r 478 nts_1, // 2 - r: czr 479 nts_2, // 3 - r: rs 480 nts_3, // 4 - r: rz 481 nts_4, // 5 - rs: rp 482 nts_4, // 6 - rz: rp 483 nts_0, // 7 - any: r 484 nts_5, // 8 - r: REGISTER 485 nts_5, // 9 - any: NULL 486 nts_5, // 10 - any: ADDRESS_CONSTANT 487 nts_5, // 11 - any: INT_CONSTANT 488 nts_5, // 12 - any: LONG_CONSTANT 489 nts_5, // 13 - stm: RESOLVE 490 nts_5, // 14 - stm: IG_PATCH_POINT 491 nts_5, // 15 - stm: UNINT_BEGIN 492 nts_5, // 16 - stm: UNINT_END 493 nts_5, // 17 - stm: YIELDPOINT_PROLOGUE 494 nts_5, // 18 - stm: YIELDPOINT_EPILOGUE 495 nts_5, // 19 - stm: YIELDPOINT_BACKEDGE 496 nts_5, // 20 - stm: NOP 497 nts_5, // 21 - r: GUARD_MOVE 498 nts_5, // 22 - r: GUARD_COMBINE 499 nts_5, // 23 - r: GET_CAUGHT_EXCEPTION 500 nts_5, // 24 - stm: FENCE 501 nts_5, // 25 - stm: WRITE_FLOOR 502 nts_5, // 26 - stm: READ_CEILING 503 nts_5, // 27 - stm: TRAP 504 nts_5, // 28 - rs: REF_MOVE(INT_CONSTANT) 505 nts_5, // 29 - rs: REF_MOVE(INT_CONSTANT) 506 nts_5, // 30 - rs: REF_MOVE(INT_CONSTANT) 507 nts_5, // 31 - stm: GOTO 508 nts_5, // 32 - stm: RETURN(NULL) 509 nts_5, // 33 - r: GET_TIME_BASE 510 nts_5, // 34 - stm: IR_PROLOGUE 511 nts_5, // 35 - r: REF_MOVE(ADDRESS_CONSTANT) 512 nts_5, // 36 - r: REF_MOVE(LONG_CONSTANT) 513 nts_6, // 37 - any: OTHER_OPERAND(any,any) 514 nts_7, // 38 - stm: TRAP_IF(r,r) 515 nts_7, // 39 - r: BOOLEAN_CMP_INT(r,r) 516 nts_7, // 40 - boolcmp: BOOLEAN_CMP_INT(r,r) 517 nts_7, // 41 - r: BOOLEAN_CMP_ADDR(r,r) 518 nts_7, // 42 - boolcmp: BOOLEAN_CMP_ADDR(r,r) 519 nts_7, // 43 - r: REF_ADD(r,r) 520 nts_7, // 44 - r: REF_SUB(r,r) 521 nts_7, // 45 - r: INT_MUL(r,r) 522 nts_7, // 46 - r: INT_DIV(r,r) 523 nts_7, // 47 - r: INT_REM(r,r) 524 nts_7, // 48 - rz: INT_SHL(r,r) 525 nts_7, // 49 - rs: INT_SHR(r,r) 526 nts_7, // 50 - rz: INT_USHR(r,r) 527 nts_7, // 51 - r: REF_AND(r,r) 528 nts_7, // 52 - r: REF_OR(r,r) 529 nts_7, // 53 - r: REF_XOR(r,r) 530 nts_7, // 54 - r: FLOAT_ADD(r,r) 531 nts_7, // 55 - r: DOUBLE_ADD(r,r) 532 nts_7, // 56 - r: FLOAT_MUL(r,r) 533 nts_7, // 57 - r: DOUBLE_MUL(r,r) 534 nts_7, // 58 - r: FLOAT_SUB(r,r) 535 nts_7, // 59 - r: DOUBLE_SUB(r,r) 536 nts_7, // 60 - r: FLOAT_DIV(r,r) 537 nts_7, // 61 - r: DOUBLE_DIV(r,r) 538 nts_7, // 62 - rs: BYTE_LOAD(r,r) 539 nts_7, // 63 - rp: UBYTE_LOAD(r,r) 540 nts_7, // 64 - rs: SHORT_LOAD(r,r) 541 nts_7, // 65 - rp: USHORT_LOAD(r,r) 542 nts_7, // 66 - r: FLOAT_LOAD(r,r) 543 nts_7, // 67 - r: DOUBLE_LOAD(r,r) 544 nts_7, // 68 - rs: INT_LOAD(r,r) 545 nts_7, // 69 - stm: INT_IFCMP(r,r) 546 nts_7, // 70 - stm: INT_IFCMP2(r,r) 547 nts_7, // 71 - stm: FLOAT_IFCMP(r,r) 548 nts_7, // 72 - stm: DOUBLE_IFCMP(r,r) 549 nts_7, // 73 - stm: FLOAT_CMPL(r,r) 550 nts_7, // 74 - stm: FLOAT_CMPG(r,r) 551 nts_7, // 75 - stm: DOUBLE_CMPL(r,r) 552 nts_7, // 76 - stm: DOUBLE_CMPG(r,r) 553 nts_8, // 77 - r: CALL(r,any) 554 nts_8, // 78 - r: SYSCALL(r,any) 555 nts_7, // 79 - r: OTHER_OPERAND(r,r) 556 nts_6, // 80 - r: YIELDPOINT_OSR(any,any) 557 nts_7, // 81 - r: PREPARE_INT(r,r) 558 nts_7, // 82 - r: PREPARE_LONG(r,r) 559 nts_7, // 83 - r: ATTEMPT_INT(r,r) 560 nts_7, // 84 - r: ATTEMPT_LONG(r,r) 561 nts_7, // 85 - r: LONG_MUL(r,r) 562 nts_7, // 86 - r: LONG_DIV(r,r) 563 nts_7, // 87 - r: LONG_REM(r,r) 564 nts_7, // 88 - r: LONG_SHL(r,r) 565 nts_7, // 89 - r: LONG_SHR(r,r) 566 nts_7, // 90 - r: LONG_USHR(r,r) 567 nts_7, // 91 - r: LONG_CMP(r,r) 568 nts_7, // 92 - stm: LONG_IFCMP(r,r) 569 nts_7, // 93 - r: LONG_LOAD(r,r) 570 nts_7, // 94 - r: PREPARE_ADDR(r,r) 571 nts_7, // 95 - r: ATTEMPT_ADDR(r,r) 572 nts_0, // 96 - stm: LOWTABLESWITCH(r) 573 nts_0, // 97 - stm: NULL_CHECK(r) 574 nts_0, // 98 - stm: SET_CAUGHT_EXCEPTION(r) 575 nts_0, // 99 - stm: DCBF(r) 576 nts_0, // 100 - stm: DCBST(r) 577 nts_0, // 101 - stm: DCBT(r) 578 nts_0, // 102 - stm: DCBTST(r) 579 nts_0, // 103 - stm: DCBZ(r) 580 nts_0, // 104 - stm: DCBZL(r) 581 nts_0, // 105 - stm: ICBI(r) 582 nts_0, // 106 - stm: TRAP_IF(r,INT_CONSTANT) 583 nts_0, // 107 - stm: TRAP_IF(r,LONG_CONSTANT) 584 nts_0, // 108 - r: BOOLEAN_NOT(r) 585 nts_0, // 109 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 586 nts_0, // 110 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 587 nts_0, // 111 - r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 588 nts_0, // 112 - boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 589 nts_9, // 113 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 590 nts_9, // 114 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 591 nts_9, // 115 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 592 nts_9, // 116 - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 593 nts_9, // 117 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 594 nts_9, // 118 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 595 nts_9, // 119 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 596 nts_9, // 120 - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 597 nts_0, // 121 - r: REF_ADD(r,INT_CONSTANT) 598 nts_0, // 122 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 599 nts_0, // 123 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 600 nts_0, // 124 - r: INT_MUL(r,INT_CONSTANT) 601 nts_0, // 125 - r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 602 nts_0, // 126 - r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 603 nts_0, // 127 - r: REF_NEG(r) 604 nts_0, // 128 - rz: INT_SHL(r,INT_CONSTANT) 605 nts_0, // 129 - rs: INT_SHR(r,INT_CONSTANT) 606 nts_0, // 130 - rp: INT_USHR(r,INT_CONSTANT) 607 nts_0, // 131 - czr: REF_AND(r,INT_CONSTANT) 608 nts_0, // 132 - rp: REF_AND(r,INT_CONSTANT) 609 nts_0, // 133 - r: REF_OR(r,INT_CONSTANT) 610 nts_0, // 134 - r: REF_XOR(r,INT_CONSTANT) 611 nts_0, // 135 - r: REF_NOT(r) 612 nts_0, // 136 - r: FLOAT_NEG(r) 613 nts_0, // 137 - r: DOUBLE_NEG(r) 614 nts_0, // 138 - r: FLOAT_SQRT(r) 615 nts_0, // 139 - r: DOUBLE_SQRT(r) 616 nts_0, // 140 - rs: INT_2BYTE(r) 617 nts_0, // 141 - rp: INT_2USHORT(r) 618 nts_0, // 142 - rs: INT_2SHORT(r) 619 nts_0, // 143 - r: INT_2FLOAT(r) 620 nts_0, // 144 - r: INT_2DOUBLE(r) 621 nts_0, // 145 - r: FLOAT_2INT(r) 622 nts_0, // 146 - r: FLOAT_2DOUBLE(r) 623 nts_0, // 147 - r: DOUBLE_2INT(r) 624 nts_0, // 148 - r: DOUBLE_2FLOAT(r) 625 nts_0, // 149 - r: FLOAT_AS_INT_BITS(r) 626 nts_0, // 150 - r: INT_BITS_AS_FLOAT(r) 627 nts_0, // 151 - r: REF_MOVE(r) 628 nts_0, // 152 - r: FLOAT_MOVE(r) 629 nts_0, // 153 - r: DOUBLE_MOVE(r) 630 nts_0, // 154 - rs: BYTE_LOAD(r,INT_CONSTANT) 631 nts_0, // 155 - rp: UBYTE_LOAD(r,INT_CONSTANT) 632 nts_0, // 156 - rs: SHORT_LOAD(r,INT_CONSTANT) 633 nts_0, // 157 - rp: USHORT_LOAD(r,INT_CONSTANT) 634 nts_0, // 158 - r: FLOAT_LOAD(r,INT_CONSTANT) 635 nts_0, // 159 - r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 636 nts_0, // 160 - r: DOUBLE_LOAD(r,INT_CONSTANT) 637 nts_0, // 161 - r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 638 nts_0, // 162 - rs: INT_LOAD(r,INT_CONSTANT) 639 nts_0, // 163 - rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 640 nts_0, // 164 - stm: INT_IFCMP(r,INT_CONSTANT) 641 nts_9, // 165 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 642 nts_9, // 166 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 643 nts_9, // 167 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 644 nts_9, // 168 - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 645 nts_0, // 169 - stm: INT_IFCMP2(r,INT_CONSTANT) 646 nts_0, // 170 - stm: RETURN(r) 647 nts_0, // 171 - r: LONG_MUL(r,INT_CONSTANT) 648 nts_0, // 172 - r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 649 nts_0, // 173 - r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 650 nts_0, // 174 - r: LONG_SHL(r,INT_CONSTANT) 651 nts_0, // 175 - r: LONG_SHR(r,INT_CONSTANT) 652 nts_0, // 176 - r: LONG_USHR(r,INT_CONSTANT) 653 nts_0, // 177 - rs: INT_2LONG(r) 654 nts_2, // 178 - rs: INT_2LONG(rs) 655 nts_0, // 179 - r: LONG_2INT(r) 656 nts_0, // 180 - r: FLOAT_2LONG(r) 657 nts_0, // 181 - r: DOUBLE_2LONG(r) 658 nts_0, // 182 - r: DOUBLE_AS_LONG_BITS(r) 659 nts_0, // 183 - r: LONG_BITS_AS_DOUBLE(r) 660 nts_0, // 184 - stm: LONG_IFCMP(r,INT_CONSTANT) 661 nts_0, // 185 - stm: LONG_IFCMP(r,LONG_CONSTANT) 662 nts_3, // 186 - rz: INT_2ADDRZerExt(rz) 663 nts_0, // 187 - rz: INT_2ADDRZerExt(r) 664 nts_0, // 188 - r: LONG_LOAD(r,INT_CONSTANT) 665 nts_0, // 189 - r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 666 nts_0, // 190 - r: REF_SUB(INT_CONSTANT,r) 667 nts_10, // 191 - r: CALL(BRANCH_TARGET,any) 668 nts_0, // 192 - rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 669 nts_0, // 193 - rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 670 nts_0, // 194 - rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 671 nts_0, // 195 - rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 672 nts_0, // 196 - rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 673 nts_0, // 197 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 674 nts_0, // 198 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 675 nts_0, // 199 - rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 676 nts_0, // 200 - rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 677 nts_0, // 201 - stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 678 nts_0, // 202 - stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 679 nts_0, // 203 - stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 680 nts_0, // 204 - stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 681 nts_0, // 205 - stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 682 nts_0, // 206 - stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 683 nts_0, // 207 - r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 684 nts_0, // 208 - r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 685 nts_0, // 209 - rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 686 nts_0, // 210 - r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 687 nts_7, // 211 - r: REF_AND(REF_NOT(r),REF_NOT(r)) 688 nts_7, // 212 - r: REF_OR(REF_NOT(r),REF_NOT(r)) 689 nts_7, // 213 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 690 nts_7, // 214 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 691 nts_7, // 215 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 692 nts_7, // 216 - r: REF_AND(r,REF_NOT(r)) 693 nts_7, // 217 - r: REF_OR(r,REF_NOT(r)) 694 nts_7, // 218 - stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 695 nts_7, // 219 - stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 696 nts_7, // 220 - stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 697 nts_7, // 221 - stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 698 nts_7, // 222 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 699 nts_7, // 223 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 700 nts_7, // 224 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 701 nts_7, // 225 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 702 nts_7, // 226 - stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 703 nts_7, // 227 - stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 704 nts_7, // 228 - r: REF_NOT(REF_OR(r,r)) 705 nts_7, // 229 - r: REF_NOT(REF_AND(r,r)) 706 nts_7, // 230 - r: REF_NOT(REF_XOR(r,r)) 707 nts_7, // 231 - rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 708 nts_7, // 232 - rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 709 nts_7, // 233 - stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 710 nts_7, // 234 - stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 711 nts_7, // 235 - stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 712 nts_7, // 236 - stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 713 nts_7, // 237 - stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 714 nts_7, // 238 - rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 715 nts_7, // 239 - r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 716 nts_11, // 240 - r: FLOAT_ADD(FLOAT_MUL(r,r),r) 717 nts_11, // 241 - r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) 718 nts_11, // 242 - r: FLOAT_SUB(FLOAT_MUL(r,r),r) 719 nts_11, // 243 - r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) 720 nts_11, // 244 - r: FLOAT_ADD(r,FLOAT_MUL(r,r)) 721 nts_11, // 245 - r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) 722 nts_11, // 246 - stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 723 nts_11, // 247 - stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 724 nts_11, // 248 - stm: INT_STORE(r,OTHER_OPERAND(r,r)) 725 nts_11, // 249 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 726 nts_11, // 250 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 727 nts_11, // 251 - stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 728 nts_11, // 252 - r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) 729 nts_11, // 253 - r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) 730 nts_11, // 254 - r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) 731 nts_11, // 255 - r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) 732 nts_11, // 256 - r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) 733 nts_11, // 257 - r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) 734 nts_11, // 258 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 735 nts_11, // 259 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 736 nts_11, // 260 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 737 nts_7, // 261 - stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 738 nts_7, // 262 - stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 739 nts_0, // 263 - rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 740 }; 741 742 /* private static final byte arity[] = { 743 0, // 0 - GET_CAUGHT_EXCEPTION 744 1, // 1 - SET_CAUGHT_EXCEPTION 745 -1, // 2 - NEW 746 -1, // 3 - NEW_UNRESOLVED 747 -1, // 4 - NEWARRAY 748 -1, // 5 - NEWARRAY_UNRESOLVED 749 -1, // 6 - ATHROW 750 -1, // 7 - CHECKCAST 751 -1, // 8 - CHECKCAST_NOTNULL 752 -1, // 9 - CHECKCAST_UNRESOLVED 753 -1, // 10 - MUST_IMPLEMENT_INTERFACE 754 -1, // 11 - INSTANCEOF 755 -1, // 12 - INSTANCEOF_NOTNULL 756 -1, // 13 - INSTANCEOF_UNRESOLVED 757 -1, // 14 - MONITORENTER 758 -1, // 15 - MONITOREXIT 759 -1, // 16 - NEWOBJMULTIARRAY 760 -1, // 17 - GETSTATIC 761 -1, // 18 - PUTSTATIC 762 -1, // 19 - GETFIELD 763 -1, // 20 - PUTFIELD 764 -1, // 21 - INT_ZERO_CHECK 765 -1, // 22 - LONG_ZERO_CHECK 766 -1, // 23 - BOUNDS_CHECK 767 -1, // 24 - OBJARRAY_STORE_CHECK 768 -1, // 25 - OBJARRAY_STORE_CHECK_NOTNULL 769 0, // 26 - IG_PATCH_POINT 770 -1, // 27 - IG_CLASS_TEST 771 -1, // 28 - IG_METHOD_TEST 772 -1, // 29 - TABLESWITCH 773 -1, // 30 - LOOKUPSWITCH 774 -1, // 31 - INT_ALOAD 775 -1, // 32 - LONG_ALOAD 776 -1, // 33 - FLOAT_ALOAD 777 -1, // 34 - DOUBLE_ALOAD 778 -1, // 35 - REF_ALOAD 779 -1, // 36 - UBYTE_ALOAD 780 -1, // 37 - BYTE_ALOAD 781 -1, // 38 - USHORT_ALOAD 782 -1, // 39 - SHORT_ALOAD 783 -1, // 40 - INT_ASTORE 784 -1, // 41 - LONG_ASTORE 785 -1, // 42 - FLOAT_ASTORE 786 -1, // 43 - DOUBLE_ASTORE 787 -1, // 44 - REF_ASTORE 788 -1, // 45 - BYTE_ASTORE 789 -1, // 46 - SHORT_ASTORE 790 2, // 47 - INT_IFCMP 791 2, // 48 - INT_IFCMP2 792 2, // 49 - LONG_IFCMP 793 2, // 50 - FLOAT_IFCMP 794 2, // 51 - DOUBLE_IFCMP 795 -1, // 52 - REF_IFCMP 796 -1, // 53 - LABEL 797 -1, // 54 - BBEND 798 0, // 55 - UNINT_BEGIN 799 0, // 56 - UNINT_END 800 0, // 57 - FENCE 801 0, // 58 - READ_CEILING 802 0, // 59 - WRITE_FLOOR 803 -1, // 60 - PHI 804 -1, // 61 - SPLIT 805 -1, // 62 - PI 806 0, // 63 - NOP 807 -1, // 64 - INT_MOVE 808 -1, // 65 - LONG_MOVE 809 1, // 66 - FLOAT_MOVE 810 1, // 67 - DOUBLE_MOVE 811 1, // 68 - REF_MOVE 812 0, // 69 - GUARD_MOVE 813 -1, // 70 - INT_COND_MOVE 814 -1, // 71 - LONG_COND_MOVE 815 -1, // 72 - FLOAT_COND_MOVE 816 -1, // 73 - DOUBLE_COND_MOVE 817 -1, // 74 - REF_COND_MOVE 818 -1, // 75 - GUARD_COND_MOVE 819 0, // 76 - GUARD_COMBINE 820 2, // 77 - REF_ADD 821 -1, // 78 - INT_ADD 822 -1, // 79 - LONG_ADD 823 2, // 80 - FLOAT_ADD 824 2, // 81 - DOUBLE_ADD 825 2, // 82 - REF_SUB 826 -1, // 83 - INT_SUB 827 -1, // 84 - LONG_SUB 828 2, // 85 - FLOAT_SUB 829 2, // 86 - DOUBLE_SUB 830 2, // 87 - INT_MUL 831 2, // 88 - LONG_MUL 832 2, // 89 - FLOAT_MUL 833 2, // 90 - DOUBLE_MUL 834 2, // 91 - INT_DIV 835 2, // 92 - LONG_DIV 836 2, // 93 - FLOAT_DIV 837 2, // 94 - DOUBLE_DIV 838 2, // 95 - INT_REM 839 2, // 96 - LONG_REM 840 -1, // 97 - FLOAT_REM 841 -1, // 98 - DOUBLE_REM 842 1, // 99 - REF_NEG 843 -1, // 100 - INT_NEG 844 -1, // 101 - LONG_NEG 845 1, // 102 - FLOAT_NEG 846 1, // 103 - DOUBLE_NEG 847 1, // 104 - FLOAT_SQRT 848 1, // 105 - DOUBLE_SQRT 849 -1, // 106 - REF_SHL 850 2, // 107 - INT_SHL 851 2, // 108 - LONG_SHL 852 -1, // 109 - REF_SHR 853 2, // 110 - INT_SHR 854 2, // 111 - LONG_SHR 855 -1, // 112 - REF_USHR 856 2, // 113 - INT_USHR 857 2, // 114 - LONG_USHR 858 2, // 115 - REF_AND 859 -1, // 116 - INT_AND 860 -1, // 117 - LONG_AND 861 2, // 118 - REF_OR 862 -1, // 119 - INT_OR 863 -1, // 120 - LONG_OR 864 2, // 121 - REF_XOR 865 -1, // 122 - INT_XOR 866 1, // 123 - REF_NOT 867 -1, // 124 - INT_NOT 868 -1, // 125 - LONG_NOT 869 -1, // 126 - LONG_XOR 870 -1, // 127 - INT_2ADDRSigExt 871 1, // 128 - INT_2ADDRZerExt 872 -1, // 129 - LONG_2ADDR 873 -1, // 130 - ADDR_2INT 874 -1, // 131 - ADDR_2LONG 875 1, // 132 - INT_2LONG 876 1, // 133 - INT_2FLOAT 877 1, // 134 - INT_2DOUBLE 878 1, // 135 - LONG_2INT 879 -1, // 136 - LONG_2FLOAT 880 -1, // 137 - LONG_2DOUBLE 881 1, // 138 - FLOAT_2INT 882 1, // 139 - FLOAT_2LONG 883 1, // 140 - FLOAT_2DOUBLE 884 1, // 141 - DOUBLE_2INT 885 1, // 142 - DOUBLE_2LONG 886 1, // 143 - DOUBLE_2FLOAT 887 1, // 144 - INT_2BYTE 888 1, // 145 - INT_2USHORT 889 1, // 146 - INT_2SHORT 890 2, // 147 - LONG_CMP 891 2, // 148 - FLOAT_CMPL 892 2, // 149 - FLOAT_CMPG 893 2, // 150 - DOUBLE_CMPL 894 2, // 151 - DOUBLE_CMPG 895 1, // 152 - RETURN 896 1, // 153 - NULL_CHECK 897 0, // 154 - GOTO 898 1, // 155 - BOOLEAN_NOT 899 2, // 156 - BOOLEAN_CMP_INT 900 2, // 157 - BOOLEAN_CMP_ADDR 901 -1, // 158 - BOOLEAN_CMP_LONG 902 -1, // 159 - BOOLEAN_CMP_FLOAT 903 -1, // 160 - BOOLEAN_CMP_DOUBLE 904 2, // 161 - BYTE_LOAD 905 2, // 162 - UBYTE_LOAD 906 2, // 163 - SHORT_LOAD 907 2, // 164 - USHORT_LOAD 908 -1, // 165 - REF_LOAD 909 -1, // 166 - REF_STORE 910 2, // 167 - INT_LOAD 911 2, // 168 - LONG_LOAD 912 2, // 169 - FLOAT_LOAD 913 2, // 170 - DOUBLE_LOAD 914 2, // 171 - BYTE_STORE 915 2, // 172 - SHORT_STORE 916 2, // 173 - INT_STORE 917 2, // 174 - LONG_STORE 918 2, // 175 - FLOAT_STORE 919 2, // 176 - DOUBLE_STORE 920 2, // 177 - PREPARE_INT 921 2, // 178 - PREPARE_ADDR 922 2, // 179 - PREPARE_LONG 923 2, // 180 - ATTEMPT_INT 924 2, // 181 - ATTEMPT_ADDR 925 2, // 182 - ATTEMPT_LONG 926 2, // 183 - CALL 927 2, // 184 - SYSCALL 928 0, // 185 - YIELDPOINT_PROLOGUE 929 0, // 186 - YIELDPOINT_EPILOGUE 930 0, // 187 - YIELDPOINT_BACKEDGE 931 2, // 188 - YIELDPOINT_OSR 932 -1, // 189 - OSR_BARRIER 933 0, // 190 - IR_PROLOGUE 934 0, // 191 - RESOLVE 935 -1, // 192 - RESOLVE_MEMBER 936 0, // 193 - GET_TIME_BASE 937 -1, // 194 - INSTRUMENTED_EVENT_COUNTER 938 2, // 195 - TRAP_IF 939 0, // 196 - TRAP 940 1, // 197 - FLOAT_AS_INT_BITS 941 1, // 198 - INT_BITS_AS_FLOAT 942 1, // 199 - DOUBLE_AS_LONG_BITS 943 1, // 200 - LONG_BITS_AS_DOUBLE 944 -1, // 201 - ARRAYLENGTH 945 -1, // 202 - GET_OBJ_TIB 946 -1, // 203 - GET_CLASS_TIB 947 -1, // 204 - GET_TYPE_FROM_TIB 948 -1, // 205 - GET_SUPERCLASS_IDS_FROM_TIB 949 -1, // 206 - GET_DOES_IMPLEMENT_FROM_TIB 950 -1, // 207 - GET_ARRAY_ELEMENT_TIB_FROM_TIB 951 1, // 208 - LOWTABLESWITCH 952 0, // 209 - ADDRESS_CONSTANT 953 0, // 210 - INT_CONSTANT 954 0, // 211 - LONG_CONSTANT 955 0, // 212 - REGISTER 956 2, // 213 - OTHER_OPERAND 957 0, // 214 - NULL 958 0, // 215 - BRANCH_TARGET 959 1, // 216 - DCBF 960 1, // 217 - DCBST 961 1, // 218 - DCBT 962 1, // 219 - DCBTST 963 1, // 220 - DCBZ 964 1, // 221 - DCBZL 965 1, // 222 - ICBI 966 -1, // 223 - CALL_SAVE_VOLATILE 967 -1, // 224 - MIR_START 968 -1, // 225 - MIR_LOWTABLESWITCH 969 -1, // 226 - PPC_DATA_INT 970 -1, // 227 - PPC_DATA_LABEL 971 -1, // 228 - PPC_ADD 972 -1, // 229 - PPC_ADDr 973 -1, // 230 - PPC_ADDC 974 -1, // 231 - PPC_ADDE 975 -1, // 232 - PPC_ADDZE 976 -1, // 233 - PPC_ADDME 977 -1, // 234 - PPC_ADDIC 978 -1, // 235 - PPC_ADDICr 979 -1, // 236 - PPC_SUBF 980 -1, // 237 - PPC_SUBFr 981 -1, // 238 - PPC_SUBFC 982 -1, // 239 - PPC_SUBFCr 983 -1, // 240 - PPC_SUBFIC 984 -1, // 241 - PPC_SUBFE 985 -1, // 242 - PPC_SUBFZE 986 -1, // 243 - PPC_SUBFME 987 -1, // 244 - PPC_AND 988 -1, // 245 - PPC_ANDr 989 -1, // 246 - PPC_ANDIr 990 -1, // 247 - PPC_ANDISr 991 -1, // 248 - PPC_NAND 992 -1, // 249 - PPC_NANDr 993 -1, // 250 - PPC_ANDC 994 -1, // 251 - PPC_ANDCr 995 -1, // 252 - PPC_OR 996 -1, // 253 - PPC_ORr 997 -1, // 254 - PPC_MOVE 998 -1, // 255 - PPC_ORI 999 -1, // 256 - PPC_ORIS 1000 -1, // 257 - PPC_NOR 1001 -1, // 258 - PPC_NORr 1002 -1, // 259 - PPC_ORC 1003 -1, // 260 - PPC_ORCr 1004 -1, // 261 - PPC_XOR 1005 -1, // 262 - PPC_XORr 1006 -1, // 263 - PPC_XORI 1007 -1, // 264 - PPC_XORIS 1008 -1, // 265 - PPC_EQV 1009 -1, // 266 - PPC_EQVr 1010 -1, // 267 - PPC_NEG 1011 -1, // 268 - PPC_NEGr 1012 -1, // 269 - PPC_CNTLZW 1013 -1, // 270 - PPC_EXTSB 1014 -1, // 271 - PPC_EXTSBr 1015 -1, // 272 - PPC_EXTSH 1016 -1, // 273 - PPC_EXTSHr 1017 -1, // 274 - PPC_SLW 1018 -1, // 275 - PPC_SLWr 1019 -1, // 276 - PPC_SLWI 1020 -1, // 277 - PPC_SLWIr 1021 -1, // 278 - PPC_SRW 1022 -1, // 279 - PPC_SRWr 1023 -1, // 280 - PPC_SRWI 1024 -1, // 281 - PPC_SRWIr 1025 -1, // 282 - PPC_SRAW 1026 -1, // 283 - PPC_SRAWr 1027 -1, // 284 - PPC_SRAWI 1028 -1, // 285 - PPC_SRAWIr 1029 -1, // 286 - PPC_RLWINM 1030 -1, // 287 - PPC_RLWINMr 1031 -1, // 288 - PPC_RLWIMI 1032 -1, // 289 - PPC_RLWIMIr 1033 -1, // 290 - PPC_RLWNM 1034 -1, // 291 - PPC_RLWNMr 1035 -1, // 292 - PPC_B 1036 -1, // 293 - PPC_BL 1037 -1, // 294 - PPC_BL_SYS 1038 -1, // 295 - PPC_BLR 1039 -1, // 296 - PPC_BCTR 1040 -1, // 297 - PPC_BCTRL 1041 -1, // 298 - PPC_BCTRL_SYS 1042 -1, // 299 - PPC_BCLR 1043 -1, // 300 - PPC_BLRL 1044 -1, // 301 - PPC_BCLRL 1045 -1, // 302 - PPC_BC 1046 -1, // 303 - PPC_BCL 1047 -1, // 304 - PPC_BCOND 1048 -1, // 305 - PPC_BCOND2 1049 -1, // 306 - PPC_BCCTR 1050 -1, // 307 - PPC_BCC 1051 -1, // 308 - PPC_ADDI 1052 -1, // 309 - PPC_ADDIS 1053 -1, // 310 - PPC_LDI 1054 -1, // 311 - PPC_LDIS 1055 -1, // 312 - PPC_CMP 1056 -1, // 313 - PPC_CMPI 1057 -1, // 314 - PPC_CMPL 1058 -1, // 315 - PPC_CMPLI 1059 -1, // 316 - PPC_CRAND 1060 -1, // 317 - PPC_CRANDC 1061 -1, // 318 - PPC_CROR 1062 -1, // 319 - PPC_CRORC 1063 -1, // 320 - PPC_FMR 1064 -1, // 321 - PPC_FRSP 1065 -1, // 322 - PPC_FCTIW 1066 -1, // 323 - PPC_FCTIWZ 1067 -1, // 324 - PPC_FADD 1068 -1, // 325 - PPC_FADDS 1069 -1, // 326 - PPC_FSQRT 1070 -1, // 327 - PPC_FSQRTS 1071 -1, // 328 - PPC_FABS 1072 -1, // 329 - PPC_FCMPO 1073 -1, // 330 - PPC_FCMPU 1074 -1, // 331 - PPC_FDIV 1075 -1, // 332 - PPC_FDIVS 1076 -1, // 333 - PPC_DIVW 1077 -1, // 334 - PPC_DIVWU 1078 -1, // 335 - PPC_FMUL 1079 -1, // 336 - PPC_FMULS 1080 -1, // 337 - PPC_FSEL 1081 -1, // 338 - PPC_FMADD 1082 -1, // 339 - PPC_FMADDS 1083 -1, // 340 - PPC_FMSUB 1084 -1, // 341 - PPC_FMSUBS 1085 -1, // 342 - PPC_FNMADD 1086 -1, // 343 - PPC_FNMADDS 1087 -1, // 344 - PPC_FNMSUB 1088 -1, // 345 - PPC_FNMSUBS 1089 -1, // 346 - PPC_MULLI 1090 -1, // 347 - PPC_MULLW 1091 -1, // 348 - PPC_MULHW 1092 -1, // 349 - PPC_MULHWU 1093 -1, // 350 - PPC_FNEG 1094 -1, // 351 - PPC_FSUB 1095 -1, // 352 - PPC_FSUBS 1096 -1, // 353 - PPC_LWZ 1097 -1, // 354 - PPC_LWZU 1098 -1, // 355 - PPC_LWZUX 1099 -1, // 356 - PPC_LWZX 1100 -1, // 357 - PPC_LWARX 1101 -1, // 358 - PPC_LBZ 1102 -1, // 359 - PPC_LBZUX 1103 -1, // 360 - PPC_LBZX 1104 -1, // 361 - PPC_LHA 1105 -1, // 362 - PPC_LHAX 1106 -1, // 363 - PPC_LHZ 1107 -1, // 364 - PPC_LHZX 1108 -1, // 365 - PPC_LFD 1109 -1, // 366 - PPC_LFDX 1110 -1, // 367 - PPC_LFS 1111 -1, // 368 - PPC_LFSX 1112 -1, // 369 - PPC_LMW 1113 -1, // 370 - PPC_STW 1114 -1, // 371 - PPC_STWX 1115 -1, // 372 - PPC_STWCXr 1116 -1, // 373 - PPC_STWU 1117 -1, // 374 - PPC_STB 1118 -1, // 375 - PPC_STBX 1119 -1, // 376 - PPC_STH 1120 -1, // 377 - PPC_STHX 1121 -1, // 378 - PPC_STFD 1122 -1, // 379 - PPC_STFDX 1123 -1, // 380 - PPC_STFDU 1124 -1, // 381 - PPC_STFS 1125 -1, // 382 - PPC_STFSX 1126 -1, // 383 - PPC_STFSU 1127 -1, // 384 - PPC_STMW 1128 -1, // 385 - PPC_TW 1129 -1, // 386 - PPC_TWI 1130 -1, // 387 - PPC_MFSPR 1131 -1, // 388 - PPC_MTSPR 1132 -1, // 389 - PPC_MFTB 1133 -1, // 390 - PPC_MFTBU 1134 -1, // 391 - PPC_HWSYNC 1135 -1, // 392 - PPC_SYNC 1136 -1, // 393 - PPC_ISYNC 1137 -1, // 394 - PPC_DCBF 1138 -1, // 395 - PPC_DCBST 1139 -1, // 396 - PPC_DCBT 1140 -1, // 397 - PPC_DCBTST 1141 -1, // 398 - PPC_DCBZ 1142 -1, // 399 - PPC_DCBZL 1143 -1, // 400 - PPC_ICBI 1144 -1, // 401 - PPC64_EXTSW 1145 -1, // 402 - PPC64_EXTSWr 1146 -1, // 403 - PPC64_EXTZW 1147 -1, // 404 - PPC64_RLDICL 1148 -1, // 405 - PPC64_RLDICR 1149 -1, // 406 - PPC64_SLD 1150 -1, // 407 - PPC64_SLDr 1151 -1, // 408 - PPC64_SLDI 1152 -1, // 409 - PPC64_SRD 1153 -1, // 410 - PPC64_SRDr 1154 -1, // 411 - PPC64_SRAD 1155 -1, // 412 - PPC64_SRADr 1156 -1, // 413 - PPC64_SRADI 1157 -1, // 414 - PPC64_SRADIr 1158 -1, // 415 - PPC64_SRDI 1159 -1, // 416 - PPC64_RLDIMI 1160 -1, // 417 - PPC64_RLDIMIr 1161 -1, // 418 - PPC64_CMP 1162 -1, // 419 - PPC64_CMPI 1163 -1, // 420 - PPC64_CMPL 1164 -1, // 421 - PPC64_CMPLI 1165 -1, // 422 - PPC64_FCFID 1166 -1, // 423 - PPC64_FCTIDZ 1167 -1, // 424 - PPC64_DIVD 1168 -1, // 425 - PPC64_MULLD 1169 -1, // 426 - PPC64_LD 1170 -1, // 427 - PPC64_LDX 1171 -1, // 428 - PPC64_STD 1172 -1, // 429 - PPC64_STDX 1173 -1, // 430 - PPC64_TD 1174 -1, // 431 - PPC64_TDI 1175 -1, // 432 - PPC_CNTLZAddr 1176 -1, // 433 - PPC_SRAAddrI 1177 -1, // 434 - PPC_SRAddrI 1178 -1, // 435 - PPC64_LWA 1179 -1, // 436 - PPC_LInt 1180 -1, // 437 - PPC64_LWAX 1181 -1, // 438 - PPC_LIntX 1182 -1, // 439 - PPC_LIntUX 1183 -1, // 440 - PPC_LAddr 1184 -1, // 441 - PPC_LAddrX 1185 -1, // 442 - PPC_LAddrU 1186 -1, // 443 - PPC_LAddrUX 1187 -1, // 444 - PPC_LAddrARX 1188 -1, // 445 - PPC_STAddr 1189 -1, // 446 - PPC_STAddrX 1190 -1, // 447 - PPC_STAddrU 1191 -1, // 448 - PPC_STAddrUX 1192 -1, // 449 - PPC_STAddrCXr 1193 -1, // 450 - PPC_TAddr 1194 -1, // 451 - MIR_END 1195 };*/ 1196 1197 /** 1198 * Decoding table. Translate the target non-terminal and minimal cost covering state encoding 1199 * non-terminal into the rule that produces the non-terminal. 1200 * The first index is the non-terminal that we wish to produce. 1201 * The second index is the state non-terminal associated with covering a tree 1202 * with minimal cost and is computed by jburg based on the non-terminal to be produced. 1203 * The value in the array is the rule number 1204 */ 1205 private static final char[][] decode = { 1206 null, // [0][0] 1207 { // stm_NT 1208 0, // [1][0] 1209 1, // [1][1] - stm: r 1210 13, // [1][2] - stm: RESOLVE 1211 14, // [1][3] - stm: IG_PATCH_POINT 1212 15, // [1][4] - stm: UNINT_BEGIN 1213 16, // [1][5] - stm: UNINT_END 1214 17, // [1][6] - stm: YIELDPOINT_PROLOGUE 1215 18, // [1][7] - stm: YIELDPOINT_EPILOGUE 1216 19, // [1][8] - stm: YIELDPOINT_BACKEDGE 1217 96, // [1][9] - stm: LOWTABLESWITCH(r) 1218 20, // [1][10] - stm: NOP 1219 97, // [1][11] - stm: NULL_CHECK(r) 1220 98, // [1][12] - stm: SET_CAUGHT_EXCEPTION(r) 1221 24, // [1][13] - stm: FENCE 1222 25, // [1][14] - stm: WRITE_FLOOR 1223 26, // [1][15] - stm: READ_CEILING 1224 99, // [1][16] - stm: DCBF(r) 1225 100, // [1][17] - stm: DCBST(r) 1226 101, // [1][18] - stm: DCBT(r) 1227 102, // [1][19] - stm: DCBTST(r) 1228 103, // [1][20] - stm: DCBZ(r) 1229 104, // [1][21] - stm: DCBZL(r) 1230 105, // [1][22] - stm: ICBI(r) 1231 27, // [1][23] - stm: TRAP 1232 38, // [1][24] - stm: TRAP_IF(r,r) 1233 106, // [1][25] - stm: TRAP_IF(r,INT_CONSTANT) 1234 107, // [1][26] - stm: TRAP_IF(r,LONG_CONSTANT) 1235 218, // [1][27] - stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1236 246, // [1][28] - stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 1237 213, // [1][29] - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 1238 258, // [1][30] - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 1239 219, // [1][31] - stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1240 247, // [1][32] - stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 1241 214, // [1][33] - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 1242 259, // [1][34] - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 1243 215, // [1][35] - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 1244 260, // [1][36] - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 1245 220, // [1][37] - stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1246 221, // [1][38] - stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 1247 248, // [1][39] - stm: INT_STORE(r,OTHER_OPERAND(r,r)) 1248 261, // [1][40] - stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 1249 222, // [1][41] - stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1250 223, // [1][42] - stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 1251 249, // [1][43] - stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 1252 224, // [1][44] - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1253 225, // [1][45] - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 1254 250, // [1][46] - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 1255 69, // [1][47] - stm: INT_IFCMP(r,r) 1256 164, // [1][48] - stm: INT_IFCMP(r,INT_CONSTANT) 1257 201, // [1][49] - stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 1258 202, // [1][50] - stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 1259 233, // [1][51] - stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 1260 234, // [1][52] - stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 1261 235, // [1][53] - stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 1262 203, // [1][54] - stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 1263 204, // [1][55] - stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 1264 205, // [1][56] - stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 1265 206, // [1][57] - stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 1266 165, // [1][58] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1267 166, // [1][59] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1268 167, // [1][60] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1269 168, // [1][61] - stm: INT_IFCMP(boolcmp,INT_CONSTANT) 1270 70, // [1][62] - stm: INT_IFCMP2(r,r) 1271 169, // [1][63] - stm: INT_IFCMP2(r,INT_CONSTANT) 1272 71, // [1][64] - stm: FLOAT_IFCMP(r,r) 1273 72, // [1][65] - stm: DOUBLE_IFCMP(r,r) 1274 73, // [1][66] - stm: FLOAT_CMPL(r,r) 1275 74, // [1][67] - stm: FLOAT_CMPG(r,r) 1276 75, // [1][68] - stm: DOUBLE_CMPL(r,r) 1277 76, // [1][69] - stm: DOUBLE_CMPG(r,r) 1278 31, // [1][70] - stm: GOTO 1279 32, // [1][71] - stm: RETURN(NULL) 1280 170, // [1][72] - stm: RETURN(r) 1281 34, // [1][73] - stm: IR_PROLOGUE 1282 92, // [1][74] - stm: LONG_IFCMP(r,r) 1283 184, // [1][75] - stm: LONG_IFCMP(r,INT_CONSTANT) 1284 185, // [1][76] - stm: LONG_IFCMP(r,LONG_CONSTANT) 1285 236, // [1][77] - stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 1286 237, // [1][78] - stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 1287 226, // [1][79] - stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 1288 227, // [1][80] - stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 1289 251, // [1][81] - stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 1290 262, // [1][82] - stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 1291 }, 1292 { // r_NT 1293 0, // [2][0] 1294 8, // [2][1] - r: REGISTER 1295 2, // [2][2] - r: czr 1296 3, // [2][3] - r: rs 1297 4, // [2][4] - r: rz 1298 21, // [2][5] - r: GUARD_MOVE 1299 22, // [2][6] - r: GUARD_COMBINE 1300 23, // [2][7] - r: GET_CAUGHT_EXCEPTION 1301 108, // [2][8] - r: BOOLEAN_NOT(r) 1302 109, // [2][9] - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1303 39, // [2][10] - r: BOOLEAN_CMP_INT(r,r) 1304 111, // [2][11] - r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 1305 41, // [2][12] - r: BOOLEAN_CMP_ADDR(r,r) 1306 117, // [2][13] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1307 118, // [2][14] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1308 119, // [2][15] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1309 120, // [2][16] - r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1310 121, // [2][17] - r: REF_ADD(r,INT_CONSTANT) 1311 43, // [2][18] - r: REF_ADD(r,r) 1312 122, // [2][19] - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 1313 123, // [2][20] - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 1314 44, // [2][21] - r: REF_SUB(r,r) 1315 190, // [2][22] - r: REF_SUB(INT_CONSTANT,r) 1316 124, // [2][23] - r: INT_MUL(r,INT_CONSTANT) 1317 45, // [2][24] - r: INT_MUL(r,r) 1318 46, // [2][25] - r: INT_DIV(r,r) 1319 125, // [2][26] - r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 1320 47, // [2][27] - r: INT_REM(r,r) 1321 126, // [2][28] - r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 1322 127, // [2][29] - r: REF_NEG(r) 1323 51, // [2][30] - r: REF_AND(r,r) 1324 211, // [2][31] - r: REF_AND(REF_NOT(r),REF_NOT(r)) 1325 216, // [2][32] - r: REF_AND(r,REF_NOT(r)) 1326 52, // [2][33] - r: REF_OR(r,r) 1327 133, // [2][34] - r: REF_OR(r,INT_CONSTANT) 1328 212, // [2][35] - r: REF_OR(REF_NOT(r),REF_NOT(r)) 1329 217, // [2][36] - r: REF_OR(r,REF_NOT(r)) 1330 53, // [2][37] - r: REF_XOR(r,r) 1331 134, // [2][38] - r: REF_XOR(r,INT_CONSTANT) 1332 135, // [2][39] - r: REF_NOT(r) 1333 228, // [2][40] - r: REF_NOT(REF_OR(r,r)) 1334 229, // [2][41] - r: REF_NOT(REF_AND(r,r)) 1335 230, // [2][42] - r: REF_NOT(REF_XOR(r,r)) 1336 54, // [2][43] - r: FLOAT_ADD(r,r) 1337 55, // [2][44] - r: DOUBLE_ADD(r,r) 1338 56, // [2][45] - r: FLOAT_MUL(r,r) 1339 57, // [2][46] - r: DOUBLE_MUL(r,r) 1340 58, // [2][47] - r: FLOAT_SUB(r,r) 1341 59, // [2][48] - r: DOUBLE_SUB(r,r) 1342 60, // [2][49] - r: FLOAT_DIV(r,r) 1343 61, // [2][50] - r: DOUBLE_DIV(r,r) 1344 136, // [2][51] - r: FLOAT_NEG(r) 1345 137, // [2][52] - r: DOUBLE_NEG(r) 1346 138, // [2][53] - r: FLOAT_SQRT(r) 1347 139, // [2][54] - r: DOUBLE_SQRT(r) 1348 240, // [2][55] - r: FLOAT_ADD(FLOAT_MUL(r,r),r) 1349 241, // [2][56] - r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) 1350 244, // [2][57] - r: FLOAT_ADD(r,FLOAT_MUL(r,r)) 1351 245, // [2][58] - r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) 1352 242, // [2][59] - r: FLOAT_SUB(FLOAT_MUL(r,r),r) 1353 243, // [2][60] - r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) 1354 252, // [2][61] - r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) 1355 253, // [2][62] - r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) 1356 256, // [2][63] - r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) 1357 257, // [2][64] - r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) 1358 254, // [2][65] - r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) 1359 255, // [2][66] - r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) 1360 143, // [2][67] - r: INT_2FLOAT(r) 1361 144, // [2][68] - r: INT_2DOUBLE(r) 1362 145, // [2][69] - r: FLOAT_2INT(r) 1363 146, // [2][70] - r: FLOAT_2DOUBLE(r) 1364 147, // [2][71] - r: DOUBLE_2INT(r) 1365 148, // [2][72] - r: DOUBLE_2FLOAT(r) 1366 149, // [2][73] - r: FLOAT_AS_INT_BITS(r) 1367 150, // [2][74] - r: INT_BITS_AS_FLOAT(r) 1368 151, // [2][75] - r: REF_MOVE(r) 1369 152, // [2][76] - r: FLOAT_MOVE(r) 1370 153, // [2][77] - r: DOUBLE_MOVE(r) 1371 158, // [2][78] - r: FLOAT_LOAD(r,INT_CONSTANT) 1372 159, // [2][79] - r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 1373 66, // [2][80] - r: FLOAT_LOAD(r,r) 1374 160, // [2][81] - r: DOUBLE_LOAD(r,INT_CONSTANT) 1375 161, // [2][82] - r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 1376 67, // [2][83] - r: DOUBLE_LOAD(r,r) 1377 77, // [2][84] - r: CALL(r,any) 1378 191, // [2][85] - r: CALL(BRANCH_TARGET,any) 1379 78, // [2][86] - r: SYSCALL(r,any) 1380 33, // [2][87] - r: GET_TIME_BASE 1381 79, // [2][88] - r: OTHER_OPERAND(r,r) 1382 80, // [2][89] - r: YIELDPOINT_OSR(any,any) 1383 81, // [2][90] - r: PREPARE_INT(r,r) 1384 82, // [2][91] - r: PREPARE_LONG(r,r) 1385 83, // [2][92] - r: ATTEMPT_INT(r,r) 1386 84, // [2][93] - r: ATTEMPT_LONG(r,r) 1387 171, // [2][94] - r: LONG_MUL(r,INT_CONSTANT) 1388 85, // [2][95] - r: LONG_MUL(r,r) 1389 86, // [2][96] - r: LONG_DIV(r,r) 1390 172, // [2][97] - r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 1391 87, // [2][98] - r: LONG_REM(r,r) 1392 173, // [2][99] - r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 1393 174, // [2][100] - r: LONG_SHL(r,INT_CONSTANT) 1394 88, // [2][101] - r: LONG_SHL(r,r) 1395 207, // [2][102] - r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 1396 208, // [2][103] - r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 1397 175, // [2][104] - r: LONG_SHR(r,INT_CONSTANT) 1398 89, // [2][105] - r: LONG_SHR(r,r) 1399 176, // [2][106] - r: LONG_USHR(r,INT_CONSTANT) 1400 90, // [2][107] - r: LONG_USHR(r,r) 1401 179, // [2][108] - r: LONG_2INT(r) 1402 180, // [2][109] - r: FLOAT_2LONG(r) 1403 181, // [2][110] - r: DOUBLE_2LONG(r) 1404 182, // [2][111] - r: DOUBLE_AS_LONG_BITS(r) 1405 183, // [2][112] - r: LONG_BITS_AS_DOUBLE(r) 1406 35, // [2][113] - r: REF_MOVE(ADDRESS_CONSTANT) 1407 36, // [2][114] - r: REF_MOVE(LONG_CONSTANT) 1408 91, // [2][115] - r: LONG_CMP(r,r) 1409 188, // [2][116] - r: LONG_LOAD(r,INT_CONSTANT) 1410 189, // [2][117] - r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 1411 93, // [2][118] - r: LONG_LOAD(r,r) 1412 239, // [2][119] - r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 1413 210, // [2][120] - r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 1414 94, // [2][121] - r: PREPARE_ADDR(r,r) 1415 95, // [2][122] - r: ATTEMPT_ADDR(r,r) 1416 }, 1417 { // czr_NT 1418 0, // [3][0] 1419 131, // [3][1] - czr: REF_AND(r,INT_CONSTANT) 1420 }, 1421 { // rs_NT 1422 0, // [4][0] 1423 5, // [4][1] - rs: rp 1424 129, // [4][2] - rs: INT_SHR(r,INT_CONSTANT) 1425 49, // [4][3] - rs: INT_SHR(r,r) 1426 140, // [4][4] - rs: INT_2BYTE(r) 1427 142, // [4][5] - rs: INT_2SHORT(r) 1428 28, // [4][6] - rs: REF_MOVE(INT_CONSTANT) 1429 29, // [4][7] - rs: REF_MOVE(INT_CONSTANT) 1430 30, // [4][8] - rs: REF_MOVE(INT_CONSTANT) 1431 154, // [4][9] - rs: BYTE_LOAD(r,INT_CONSTANT) 1432 62, // [4][10] - rs: BYTE_LOAD(r,r) 1433 156, // [4][11] - rs: SHORT_LOAD(r,INT_CONSTANT) 1434 64, // [4][12] - rs: SHORT_LOAD(r,r) 1435 162, // [4][13] - rs: INT_LOAD(r,INT_CONSTANT) 1436 163, // [4][14] - rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 1437 68, // [4][15] - rs: INT_LOAD(r,r) 1438 232, // [4][16] - rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 1439 200, // [4][17] - rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 1440 177, // [4][18] - rs: INT_2LONG(r) 1441 178, // [4][19] - rs: INT_2LONG(rs) 1442 }, 1443 { // rz_NT 1444 0, // [5][0] 1445 6, // [5][1] - rz: rp 1446 128, // [5][2] - rz: INT_SHL(r,INT_CONSTANT) 1447 48, // [5][3] - rz: INT_SHL(r,r) 1448 192, // [5][4] - rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 1449 50, // [5][5] - rz: INT_USHR(r,r) 1450 186, // [5][6] - rz: INT_2ADDRZerExt(rz) 1451 187, // [5][7] - rz: INT_2ADDRZerExt(r) 1452 209, // [5][8] - rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 1453 238, // [5][9] - rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 1454 263, // [5][10] - rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 1455 }, 1456 { // rp_NT 1457 0, // [6][0] 1458 193, // [6][1] - rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 1459 130, // [6][2] - rp: INT_USHR(r,INT_CONSTANT) 1460 194, // [6][3] - rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 1461 195, // [6][4] - rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 1462 196, // [6][5] - rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 1463 132, // [6][6] - rp: REF_AND(r,INT_CONSTANT) 1464 197, // [6][7] - rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 1465 198, // [6][8] - rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 1466 141, // [6][9] - rp: INT_2USHORT(r) 1467 231, // [6][10] - rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 1468 199, // [6][11] - rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 1469 155, // [6][12] - rp: UBYTE_LOAD(r,INT_CONSTANT) 1470 63, // [6][13] - rp: UBYTE_LOAD(r,r) 1471 157, // [6][14] - rp: USHORT_LOAD(r,INT_CONSTANT) 1472 65, // [6][15] - rp: USHORT_LOAD(r,r) 1473 }, 1474 { // any_NT 1475 0, // [7][0] 1476 9, // [7][1] - any: NULL 1477 7, // [7][2] - any: r 1478 10, // [7][3] - any: ADDRESS_CONSTANT 1479 11, // [7][4] - any: INT_CONSTANT 1480 12, // [7][5] - any: LONG_CONSTANT 1481 37, // [7][6] - any: OTHER_OPERAND(any,any) 1482 }, 1483 { // boolcmp_NT 1484 0, // [8][0] 1485 110, // [8][1] - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 1486 40, // [8][2] - boolcmp: BOOLEAN_CMP_INT(r,r) 1487 112, // [8][3] - boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 1488 42, // [8][4] - boolcmp: BOOLEAN_CMP_ADDR(r,r) 1489 113, // [8][5] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1490 114, // [8][6] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1491 115, // [8][7] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1492 116, // [8][8] - boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 1493 }, 1494 }; 1495 1496 /** 1497 * Create closure for r 1498 * @param p the node 1499 * @param c the cost 1500 */ 1501 @Inline 1502 private static void closure_r(AbstractBURS_TreeNode p, int c) { 1503 if(BURS.DEBUG) trace(p, 7, c + 0, p.getCost(7) /* any */); 1504 if (c < p.getCost(7) /* any */) { 1505 p.setCost(7 /* any */, (char)(c)); 1506 p.writePacked(0, 0x8FFFFFFF, 0x20000000); // p.any = 2 1507 } 1508 if(BURS.DEBUG) trace(p, 1, c + 0, p.getCost(1) /* stm */); 1509 if (c < p.getCost(1) /* stm */) { 1510 p.setCost(1 /* stm */, (char)(c)); 1511 p.writePacked(0, 0xFFFFFF80, 0x1); // p.stm = 1 1512 } 1513 } 1514 1515 /** 1516 * Create closure for czr 1517 * @param p the node 1518 * @param c the cost 1519 */ 1520 @Inline 1521 private static void closure_czr(AbstractBURS_TreeNode p, int c) { 1522 if(BURS.DEBUG) trace(p, 2, c + 0, p.getCost(2) /* r */); 1523 if (c < p.getCost(2) /* r */) { 1524 p.setCost(2 /* r */, (char)(c)); 1525 p.writePacked(0, 0xFFFFC07F, 0x100); // p.r = 2 1526 closure_r(p, c); 1527 } 1528 } 1529 1530 /** 1531 * Create closure for rs 1532 * @param p the node 1533 * @param c the cost 1534 */ 1535 @Inline 1536 private static void closure_rs(AbstractBURS_TreeNode p, int c) { 1537 if(BURS.DEBUG) trace(p, 3, c + 0, p.getCost(2) /* r */); 1538 if (c < p.getCost(2) /* r */) { 1539 p.setCost(2 /* r */, (char)(c)); 1540 p.writePacked(0, 0xFFFFC07F, 0x180); // p.r = 3 1541 closure_r(p, c); 1542 } 1543 } 1544 1545 /** 1546 * Create closure for rz 1547 * @param p the node 1548 * @param c the cost 1549 */ 1550 @Inline 1551 private static void closure_rz(AbstractBURS_TreeNode p, int c) { 1552 if(BURS.DEBUG) trace(p, 4, c + 0, p.getCost(2) /* r */); 1553 if (c < p.getCost(2) /* r */) { 1554 p.setCost(2 /* r */, (char)(c)); 1555 p.writePacked(0, 0xFFFFC07F, 0x200); // p.r = 4 1556 closure_r(p, c); 1557 } 1558 } 1559 1560 /** 1561 * Create closure for rp 1562 * @param p the node 1563 * @param c the cost 1564 */ 1565 @Inline 1566 private static void closure_rp(AbstractBURS_TreeNode p, int c) { 1567 if(BURS.DEBUG) trace(p, 6, c + 0, p.getCost(5) /* rz */); 1568 if (c < p.getCost(5) /* rz */) { 1569 p.setCost(5 /* rz */, (char)(c)); 1570 p.writePacked(0, 0xFF0FFFFF, 0x100000); // p.rz = 1 1571 closure_rz(p, c); 1572 } 1573 if(BURS.DEBUG) trace(p, 5, c + 0, p.getCost(4) /* rs */); 1574 if (c < p.getCost(4) /* rs */) { 1575 p.setCost(4 /* rs */, (char)(c)); 1576 p.writePacked(0, 0xFFF07FFF, 0x8000); // p.rs = 1 1577 closure_rs(p, c); 1578 } 1579 } 1580 1581 /** 1582 /** Recursively labels the tree/ 1583 * @param p node to label 1584 */ 1585 public static void label(AbstractBURS_TreeNode p) { 1586 switch (p.getOpcode()) { 1587 case GET_CAUGHT_EXCEPTION_opcode: 1588 label_GET_CAUGHT_EXCEPTION(p); 1589 break; 1590 case SET_CAUGHT_EXCEPTION_opcode: 1591 label_SET_CAUGHT_EXCEPTION(p); 1592 break; 1593 case IG_PATCH_POINT_opcode: 1594 label_IG_PATCH_POINT(p); 1595 break; 1596 case INT_IFCMP_opcode: 1597 label_INT_IFCMP(p); 1598 break; 1599 case INT_IFCMP2_opcode: 1600 label_INT_IFCMP2(p); 1601 break; 1602 case LONG_IFCMP_opcode: 1603 label_LONG_IFCMP(p); 1604 break; 1605 case FLOAT_IFCMP_opcode: 1606 label_FLOAT_IFCMP(p); 1607 break; 1608 case DOUBLE_IFCMP_opcode: 1609 label_DOUBLE_IFCMP(p); 1610 break; 1611 case UNINT_BEGIN_opcode: 1612 label_UNINT_BEGIN(p); 1613 break; 1614 case UNINT_END_opcode: 1615 label_UNINT_END(p); 1616 break; 1617 case FENCE_opcode: 1618 label_FENCE(p); 1619 break; 1620 case READ_CEILING_opcode: 1621 label_READ_CEILING(p); 1622 break; 1623 case WRITE_FLOOR_opcode: 1624 label_WRITE_FLOOR(p); 1625 break; 1626 case NOP_opcode: 1627 label_NOP(p); 1628 break; 1629 case FLOAT_MOVE_opcode: 1630 label_FLOAT_MOVE(p); 1631 break; 1632 case DOUBLE_MOVE_opcode: 1633 label_DOUBLE_MOVE(p); 1634 break; 1635 case REF_MOVE_opcode: 1636 label_REF_MOVE(p); 1637 break; 1638 case GUARD_MOVE_opcode: 1639 label_GUARD_MOVE(p); 1640 break; 1641 case GUARD_COMBINE_opcode: 1642 label_GUARD_COMBINE(p); 1643 break; 1644 case REF_ADD_opcode: 1645 label_REF_ADD(p); 1646 break; 1647 case FLOAT_ADD_opcode: 1648 label_FLOAT_ADD(p); 1649 break; 1650 case DOUBLE_ADD_opcode: 1651 label_DOUBLE_ADD(p); 1652 break; 1653 case REF_SUB_opcode: 1654 label_REF_SUB(p); 1655 break; 1656 case FLOAT_SUB_opcode: 1657 label_FLOAT_SUB(p); 1658 break; 1659 case DOUBLE_SUB_opcode: 1660 label_DOUBLE_SUB(p); 1661 break; 1662 case INT_MUL_opcode: 1663 label_INT_MUL(p); 1664 break; 1665 case LONG_MUL_opcode: 1666 label_LONG_MUL(p); 1667 break; 1668 case FLOAT_MUL_opcode: 1669 label_FLOAT_MUL(p); 1670 break; 1671 case DOUBLE_MUL_opcode: 1672 label_DOUBLE_MUL(p); 1673 break; 1674 case INT_DIV_opcode: 1675 label_INT_DIV(p); 1676 break; 1677 case LONG_DIV_opcode: 1678 label_LONG_DIV(p); 1679 break; 1680 case FLOAT_DIV_opcode: 1681 label_FLOAT_DIV(p); 1682 break; 1683 case DOUBLE_DIV_opcode: 1684 label_DOUBLE_DIV(p); 1685 break; 1686 case INT_REM_opcode: 1687 label_INT_REM(p); 1688 break; 1689 case LONG_REM_opcode: 1690 label_LONG_REM(p); 1691 break; 1692 case REF_NEG_opcode: 1693 label_REF_NEG(p); 1694 break; 1695 case FLOAT_NEG_opcode: 1696 label_FLOAT_NEG(p); 1697 break; 1698 case DOUBLE_NEG_opcode: 1699 label_DOUBLE_NEG(p); 1700 break; 1701 case FLOAT_SQRT_opcode: 1702 label_FLOAT_SQRT(p); 1703 break; 1704 case DOUBLE_SQRT_opcode: 1705 label_DOUBLE_SQRT(p); 1706 break; 1707 case INT_SHL_opcode: 1708 label_INT_SHL(p); 1709 break; 1710 case LONG_SHL_opcode: 1711 label_LONG_SHL(p); 1712 break; 1713 case INT_SHR_opcode: 1714 label_INT_SHR(p); 1715 break; 1716 case LONG_SHR_opcode: 1717 label_LONG_SHR(p); 1718 break; 1719 case INT_USHR_opcode: 1720 label_INT_USHR(p); 1721 break; 1722 case LONG_USHR_opcode: 1723 label_LONG_USHR(p); 1724 break; 1725 case REF_AND_opcode: 1726 label_REF_AND(p); 1727 break; 1728 case REF_OR_opcode: 1729 label_REF_OR(p); 1730 break; 1731 case REF_XOR_opcode: 1732 label_REF_XOR(p); 1733 break; 1734 case REF_NOT_opcode: 1735 label_REF_NOT(p); 1736 break; 1737 case INT_2ADDRZerExt_opcode: 1738 label_INT_2ADDRZerExt(p); 1739 break; 1740 case INT_2LONG_opcode: 1741 label_INT_2LONG(p); 1742 break; 1743 case INT_2FLOAT_opcode: 1744 label_INT_2FLOAT(p); 1745 break; 1746 case INT_2DOUBLE_opcode: 1747 label_INT_2DOUBLE(p); 1748 break; 1749 case LONG_2INT_opcode: 1750 label_LONG_2INT(p); 1751 break; 1752 case FLOAT_2INT_opcode: 1753 label_FLOAT_2INT(p); 1754 break; 1755 case FLOAT_2LONG_opcode: 1756 label_FLOAT_2LONG(p); 1757 break; 1758 case FLOAT_2DOUBLE_opcode: 1759 label_FLOAT_2DOUBLE(p); 1760 break; 1761 case DOUBLE_2INT_opcode: 1762 label_DOUBLE_2INT(p); 1763 break; 1764 case DOUBLE_2LONG_opcode: 1765 label_DOUBLE_2LONG(p); 1766 break; 1767 case DOUBLE_2FLOAT_opcode: 1768 label_DOUBLE_2FLOAT(p); 1769 break; 1770 case INT_2BYTE_opcode: 1771 label_INT_2BYTE(p); 1772 break; 1773 case INT_2USHORT_opcode: 1774 label_INT_2USHORT(p); 1775 break; 1776 case INT_2SHORT_opcode: 1777 label_INT_2SHORT(p); 1778 break; 1779 case LONG_CMP_opcode: 1780 label_LONG_CMP(p); 1781 break; 1782 case FLOAT_CMPL_opcode: 1783 label_FLOAT_CMPL(p); 1784 break; 1785 case FLOAT_CMPG_opcode: 1786 label_FLOAT_CMPG(p); 1787 break; 1788 case DOUBLE_CMPL_opcode: 1789 label_DOUBLE_CMPL(p); 1790 break; 1791 case DOUBLE_CMPG_opcode: 1792 label_DOUBLE_CMPG(p); 1793 break; 1794 case RETURN_opcode: 1795 label_RETURN(p); 1796 break; 1797 case NULL_CHECK_opcode: 1798 label_NULL_CHECK(p); 1799 break; 1800 case GOTO_opcode: 1801 label_GOTO(p); 1802 break; 1803 case BOOLEAN_NOT_opcode: 1804 label_BOOLEAN_NOT(p); 1805 break; 1806 case BOOLEAN_CMP_INT_opcode: 1807 label_BOOLEAN_CMP_INT(p); 1808 break; 1809 case BOOLEAN_CMP_ADDR_opcode: 1810 label_BOOLEAN_CMP_ADDR(p); 1811 break; 1812 case BYTE_LOAD_opcode: 1813 label_BYTE_LOAD(p); 1814 break; 1815 case UBYTE_LOAD_opcode: 1816 label_UBYTE_LOAD(p); 1817 break; 1818 case SHORT_LOAD_opcode: 1819 label_SHORT_LOAD(p); 1820 break; 1821 case USHORT_LOAD_opcode: 1822 label_USHORT_LOAD(p); 1823 break; 1824 case INT_LOAD_opcode: 1825 label_INT_LOAD(p); 1826 break; 1827 case LONG_LOAD_opcode: 1828 label_LONG_LOAD(p); 1829 break; 1830 case FLOAT_LOAD_opcode: 1831 label_FLOAT_LOAD(p); 1832 break; 1833 case DOUBLE_LOAD_opcode: 1834 label_DOUBLE_LOAD(p); 1835 break; 1836 case BYTE_STORE_opcode: 1837 label_BYTE_STORE(p); 1838 break; 1839 case SHORT_STORE_opcode: 1840 label_SHORT_STORE(p); 1841 break; 1842 case INT_STORE_opcode: 1843 label_INT_STORE(p); 1844 break; 1845 case LONG_STORE_opcode: 1846 label_LONG_STORE(p); 1847 break; 1848 case FLOAT_STORE_opcode: 1849 label_FLOAT_STORE(p); 1850 break; 1851 case DOUBLE_STORE_opcode: 1852 label_DOUBLE_STORE(p); 1853 break; 1854 case PREPARE_INT_opcode: 1855 label_PREPARE_INT(p); 1856 break; 1857 case PREPARE_ADDR_opcode: 1858 label_PREPARE_ADDR(p); 1859 break; 1860 case PREPARE_LONG_opcode: 1861 label_PREPARE_LONG(p); 1862 break; 1863 case ATTEMPT_INT_opcode: 1864 label_ATTEMPT_INT(p); 1865 break; 1866 case ATTEMPT_ADDR_opcode: 1867 label_ATTEMPT_ADDR(p); 1868 break; 1869 case ATTEMPT_LONG_opcode: 1870 label_ATTEMPT_LONG(p); 1871 break; 1872 case CALL_opcode: 1873 label_CALL(p); 1874 break; 1875 case SYSCALL_opcode: 1876 label_SYSCALL(p); 1877 break; 1878 case YIELDPOINT_PROLOGUE_opcode: 1879 label_YIELDPOINT_PROLOGUE(p); 1880 break; 1881 case YIELDPOINT_EPILOGUE_opcode: 1882 label_YIELDPOINT_EPILOGUE(p); 1883 break; 1884 case YIELDPOINT_BACKEDGE_opcode: 1885 label_YIELDPOINT_BACKEDGE(p); 1886 break; 1887 case YIELDPOINT_OSR_opcode: 1888 label_YIELDPOINT_OSR(p); 1889 break; 1890 case IR_PROLOGUE_opcode: 1891 label_IR_PROLOGUE(p); 1892 break; 1893 case RESOLVE_opcode: 1894 label_RESOLVE(p); 1895 break; 1896 case GET_TIME_BASE_opcode: 1897 label_GET_TIME_BASE(p); 1898 break; 1899 case TRAP_IF_opcode: 1900 label_TRAP_IF(p); 1901 break; 1902 case TRAP_opcode: 1903 label_TRAP(p); 1904 break; 1905 case FLOAT_AS_INT_BITS_opcode: 1906 label_FLOAT_AS_INT_BITS(p); 1907 break; 1908 case INT_BITS_AS_FLOAT_opcode: 1909 label_INT_BITS_AS_FLOAT(p); 1910 break; 1911 case DOUBLE_AS_LONG_BITS_opcode: 1912 label_DOUBLE_AS_LONG_BITS(p); 1913 break; 1914 case LONG_BITS_AS_DOUBLE_opcode: 1915 label_LONG_BITS_AS_DOUBLE(p); 1916 break; 1917 case LOWTABLESWITCH_opcode: 1918 label_LOWTABLESWITCH(p); 1919 break; 1920 case ADDRESS_CONSTANT_opcode: 1921 label_ADDRESS_CONSTANT(p); 1922 break; 1923 case INT_CONSTANT_opcode: 1924 label_INT_CONSTANT(p); 1925 break; 1926 case LONG_CONSTANT_opcode: 1927 label_LONG_CONSTANT(p); 1928 break; 1929 case REGISTER_opcode: 1930 label_REGISTER(p); 1931 break; 1932 case OTHER_OPERAND_opcode: 1933 label_OTHER_OPERAND(p); 1934 break; 1935 case NULL_opcode: 1936 label_NULL(p); 1937 break; 1938 case BRANCH_TARGET_opcode: 1939 label_BRANCH_TARGET(p); 1940 break; 1941 case DCBF_opcode: 1942 label_DCBF(p); 1943 break; 1944 case DCBST_opcode: 1945 label_DCBST(p); 1946 break; 1947 case DCBT_opcode: 1948 label_DCBT(p); 1949 break; 1950 case DCBTST_opcode: 1951 label_DCBTST(p); 1952 break; 1953 case DCBZ_opcode: 1954 label_DCBZ(p); 1955 break; 1956 case DCBZL_opcode: 1957 label_DCBZL(p); 1958 break; 1959 case ICBI_opcode: 1960 label_ICBI(p); 1961 break; 1962 default: 1963 throw new OptimizingCompilerException("BURS","terminal not in grammar:", 1964 p.toString()); 1965 } 1966 } 1967 1968 /** 1969 * Labels GET_CAUGHT_EXCEPTION tree node 1970 * @param p node to label 1971 */ 1972 private static void label_GET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 1973 p.initCost(); 1974 // r: GET_CAUGHT_EXCEPTION 1975 if(BURS.DEBUG) trace(p, 23, 11 + 0, p.getCost(2) /* r */); 1976 if (11 < p.getCost(2) /* r */) { 1977 p.setCost(2 /* r */, (char)(11)); 1978 p.writePacked(0, 0xFFFFC07F, 0x380); // p.r = 7 1979 closure_r(p, 11); 1980 } 1981 } 1982 1983 /** 1984 * Labels SET_CAUGHT_EXCEPTION tree node 1985 * @param p node to label 1986 */ 1987 private static void label_SET_CAUGHT_EXCEPTION(AbstractBURS_TreeNode p) { 1988 p.initCost(); 1989 AbstractBURS_TreeNode lchild; 1990 lchild = p.getChild1(); 1991 label(lchild); 1992 int c; 1993 // stm: SET_CAUGHT_EXCEPTION(r) 1994 c = STATE(lchild).getCost(2 /* r */) + 11; 1995 if(BURS.DEBUG) trace(p, 98, c + 0, p.getCost(1) /* stm */); 1996 if (c < p.getCost(1) /* stm */) { 1997 p.setCost(1 /* stm */, (char)(c)); 1998 p.writePacked(0, 0xFFFFFF80, 0xC); // p.stm = 12 1999 } 2000 } 2001 2002 /** 2003 * Labels IG_PATCH_POINT tree node 2004 * @param p node to label 2005 */ 2006 private static void label_IG_PATCH_POINT(AbstractBURS_TreeNode p) { 2007 p.initCost(); 2008 // stm: IG_PATCH_POINT 2009 if(BURS.DEBUG) trace(p, 14, 10 + 0, p.getCost(1) /* stm */); 2010 if (10 < p.getCost(1) /* stm */) { 2011 p.setCost(1 /* stm */, (char)(10)); 2012 p.writePacked(0, 0xFFFFFF80, 0x3); // p.stm = 3 2013 } 2014 } 2015 2016 /** 2017 * Labels INT_IFCMP tree node 2018 * @param p node to label 2019 */ 2020 private static void label_INT_IFCMP(AbstractBURS_TreeNode p) { 2021 p.initCost(); 2022 AbstractBURS_TreeNode lchild, rchild; 2023 lchild = p.getChild1(); 2024 rchild = p.getChild2(); 2025 label(lchild); 2026 label(rchild); 2027 int c; 2028 // stm: INT_IFCMP(r,r) 2029 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2030 if(BURS.DEBUG) trace(p, 69, c + 0, p.getCost(1) /* stm */); 2031 if (c < p.getCost(1) /* stm */) { 2032 p.setCost(1 /* stm */, (char)(c)); 2033 p.writePacked(0, 0xFFFFFF80, 0x2F); // p.stm = 47 2034 } 2035 if ( // stm: INT_IFCMP(r,INT_CONSTANT) 2036 rchild.getOpcode() == INT_CONSTANT_opcode 2037 ) { 2038 c = STATE(lchild).getCost(2 /* r */) + 20; 2039 if(BURS.DEBUG) trace(p, 164, c + 0, p.getCost(1) /* stm */); 2040 if (c < p.getCost(1) /* stm */) { 2041 p.setCost(1 /* stm */, (char)(c)); 2042 p.writePacked(0, 0xFFFFFF80, 0x30); // p.stm = 48 2043 } 2044 } 2045 if ( // stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 2046 lchild.getOpcode() == INT_2BYTE_opcode && 2047 rchild.getOpcode() == INT_CONSTANT_opcode 2048 ) { 2049 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2050 if(BURS.DEBUG) trace(p, 201, c + 0, p.getCost(1) /* stm */); 2051 if (c < p.getCost(1) /* stm */) { 2052 p.setCost(1 /* stm */, (char)(c)); 2053 p.writePacked(0, 0xFFFFFF80, 0x31); // p.stm = 49 2054 } 2055 } 2056 if ( // stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 2057 lchild.getOpcode() == INT_2SHORT_opcode && 2058 rchild.getOpcode() == INT_CONSTANT_opcode 2059 ) { 2060 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2061 if(BURS.DEBUG) trace(p, 202, c + 0, p.getCost(1) /* stm */); 2062 if (c < p.getCost(1) /* stm */) { 2063 p.setCost(1 /* stm */, (char)(c)); 2064 p.writePacked(0, 0xFFFFFF80, 0x32); // p.stm = 50 2065 } 2066 } 2067 if ( // stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 2068 lchild.getOpcode() == INT_USHR_opcode && 2069 rchild.getOpcode() == INT_CONSTANT_opcode 2070 ) { 2071 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2072 if(BURS.DEBUG) trace(p, 233, c + 0, p.getCost(1) /* stm */); 2073 if (c < p.getCost(1) /* stm */) { 2074 p.setCost(1 /* stm */, (char)(c)); 2075 p.writePacked(0, 0xFFFFFF80, 0x33); // p.stm = 51 2076 } 2077 } 2078 if ( // stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 2079 lchild.getOpcode() == INT_SHL_opcode && 2080 rchild.getOpcode() == INT_CONSTANT_opcode 2081 ) { 2082 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2083 if(BURS.DEBUG) trace(p, 234, c + 0, p.getCost(1) /* stm */); 2084 if (c < p.getCost(1) /* stm */) { 2085 p.setCost(1 /* stm */, (char)(c)); 2086 p.writePacked(0, 0xFFFFFF80, 0x34); // p.stm = 52 2087 } 2088 } 2089 if ( // stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 2090 lchild.getOpcode() == INT_SHR_opcode && 2091 rchild.getOpcode() == INT_CONSTANT_opcode 2092 ) { 2093 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2094 if(BURS.DEBUG) trace(p, 235, c + 0, p.getCost(1) /* stm */); 2095 if (c < p.getCost(1) /* stm */) { 2096 p.setCost(1 /* stm */, (char)(c)); 2097 p.writePacked(0, 0xFFFFFF80, 0x35); // p.stm = 53 2098 } 2099 } 2100 if ( // stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 2101 lchild.getOpcode() == INT_USHR_opcode && 2102 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 2103 rchild.getOpcode() == INT_CONSTANT_opcode 2104 ) { 2105 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2106 if(BURS.DEBUG) trace(p, 203, c + 0, p.getCost(1) /* stm */); 2107 if (c < p.getCost(1) /* stm */) { 2108 p.setCost(1 /* stm */, (char)(c)); 2109 p.writePacked(0, 0xFFFFFF80, 0x36); // p.stm = 54 2110 } 2111 } 2112 if ( // stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 2113 lchild.getOpcode() == INT_SHL_opcode && 2114 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 2115 rchild.getOpcode() == INT_CONSTANT_opcode 2116 ) { 2117 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2118 if(BURS.DEBUG) trace(p, 204, c + 0, p.getCost(1) /* stm */); 2119 if (c < p.getCost(1) /* stm */) { 2120 p.setCost(1 /* stm */, (char)(c)); 2121 p.writePacked(0, 0xFFFFFF80, 0x37); // p.stm = 55 2122 } 2123 } 2124 if ( // stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 2125 lchild.getOpcode() == INT_SHR_opcode && 2126 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 2127 rchild.getOpcode() == INT_CONSTANT_opcode 2128 ) { 2129 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2130 if(BURS.DEBUG) trace(p, 205, c + 0, p.getCost(1) /* stm */); 2131 if (c < p.getCost(1) /* stm */) { 2132 p.setCost(1 /* stm */, (char)(c)); 2133 p.writePacked(0, 0xFFFFFF80, 0x38); // p.stm = 56 2134 } 2135 } 2136 if ( // stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 2137 lchild.getOpcode() == REF_AND_opcode && 2138 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 2139 rchild.getOpcode() == INT_CONSTANT_opcode 2140 ) { 2141 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2142 if(BURS.DEBUG) trace(p, 206, c + 0, p.getCost(1) /* stm */); 2143 if (c < p.getCost(1) /* stm */) { 2144 p.setCost(1 /* stm */, (char)(c)); 2145 p.writePacked(0, 0xFFFFFF80, 0x39); // p.stm = 57 2146 } 2147 } 2148 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2149 rchild.getOpcode() == INT_CONSTANT_opcode 2150 ) { 2151 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && IfCmp.getCond(P(p)).isNOT_EQUAL()?20:INFINITE); 2152 if(BURS.DEBUG) trace(p, 165, c + 0, p.getCost(1) /* stm */); 2153 if (c < p.getCost(1) /* stm */) { 2154 p.setCost(1 /* stm */, (char)(c)); 2155 p.writePacked(0, 0xFFFFFF80, 0x3A); // p.stm = 58 2156 } 2157 } 2158 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2159 rchild.getOpcode() == INT_CONSTANT_opcode 2160 ) { 2161 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && IfCmp.getCond(P(p)).isEQUAL()?20:INFINITE); 2162 if(BURS.DEBUG) trace(p, 166, c + 0, p.getCost(1) /* stm */); 2163 if (c < p.getCost(1) /* stm */) { 2164 p.setCost(1 /* stm */, (char)(c)); 2165 p.writePacked(0, 0xFFFFFF80, 0x3B); // p.stm = 59 2166 } 2167 } 2168 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2169 rchild.getOpcode() == INT_CONSTANT_opcode 2170 ) { 2171 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && IfCmp.getCond(P(p)).isEQUAL()?20:INFINITE); 2172 if(BURS.DEBUG) trace(p, 167, c + 0, p.getCost(1) /* stm */); 2173 if (c < p.getCost(1) /* stm */) { 2174 p.setCost(1 /* stm */, (char)(c)); 2175 p.writePacked(0, 0xFFFFFF80, 0x3C); // p.stm = 60 2176 } 2177 } 2178 if ( // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 2179 rchild.getOpcode() == INT_CONSTANT_opcode 2180 ) { 2181 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && (IfCmp.getCond(P(p)).isNOT_EQUAL())?26:INFINITE); 2182 if(BURS.DEBUG) trace(p, 168, c + 0, p.getCost(1) /* stm */); 2183 if (c < p.getCost(1) /* stm */) { 2184 p.setCost(1 /* stm */, (char)(c)); 2185 p.writePacked(0, 0xFFFFFF80, 0x3D); // p.stm = 61 2186 } 2187 } 2188 if ( // stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 2189 lchild.getOpcode() == ATTEMPT_INT_opcode && 2190 rchild.getOpcode() == INT_CONSTANT_opcode 2191 ) { 2192 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2193 if(BURS.DEBUG) trace(p, 236, c + 0, p.getCost(1) /* stm */); 2194 if (c < p.getCost(1) /* stm */) { 2195 p.setCost(1 /* stm */, (char)(c)); 2196 p.writePacked(0, 0xFFFFFF80, 0x4D); // p.stm = 77 2197 } 2198 } 2199 if ( // stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 2200 lchild.getOpcode() == ATTEMPT_ADDR_opcode && 2201 rchild.getOpcode() == INT_CONSTANT_opcode 2202 ) { 2203 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + ((!IfCmp.getCond(P(p)).isUNSIGNED())&&ZERO(IfCmp.getVal2(P(p)))?20:INFINITE); 2204 if(BURS.DEBUG) trace(p, 237, c + 0, p.getCost(1) /* stm */); 2205 if (c < p.getCost(1) /* stm */) { 2206 p.setCost(1 /* stm */, (char)(c)); 2207 p.writePacked(0, 0xFFFFFF80, 0x4E); // p.stm = 78 2208 } 2209 } 2210 } 2211 2212 /** 2213 * Labels INT_IFCMP2 tree node 2214 * @param p node to label 2215 */ 2216 private static void label_INT_IFCMP2(AbstractBURS_TreeNode p) { 2217 p.initCost(); 2218 AbstractBURS_TreeNode lchild, rchild; 2219 lchild = p.getChild1(); 2220 rchild = p.getChild2(); 2221 label(lchild); 2222 label(rchild); 2223 int c; 2224 // stm: INT_IFCMP2(r,r) 2225 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2226 if(BURS.DEBUG) trace(p, 70, c + 0, p.getCost(1) /* stm */); 2227 if (c < p.getCost(1) /* stm */) { 2228 p.setCost(1 /* stm */, (char)(c)); 2229 p.writePacked(0, 0xFFFFFF80, 0x3E); // p.stm = 62 2230 } 2231 if ( // stm: INT_IFCMP2(r,INT_CONSTANT) 2232 rchild.getOpcode() == INT_CONSTANT_opcode 2233 ) { 2234 c = STATE(lchild).getCost(2 /* r */) + 20; 2235 if(BURS.DEBUG) trace(p, 169, c + 0, p.getCost(1) /* stm */); 2236 if (c < p.getCost(1) /* stm */) { 2237 p.setCost(1 /* stm */, (char)(c)); 2238 p.writePacked(0, 0xFFFFFF80, 0x3F); // p.stm = 63 2239 } 2240 } 2241 } 2242 2243 /** 2244 * Labels LONG_IFCMP tree node 2245 * @param p node to label 2246 */ 2247 private static void label_LONG_IFCMP(AbstractBURS_TreeNode p) { 2248 p.initCost(); 2249 AbstractBURS_TreeNode lchild, rchild; 2250 lchild = p.getChild1(); 2251 rchild = p.getChild2(); 2252 label(lchild); 2253 label(rchild); 2254 int c; 2255 // stm: LONG_IFCMP(r,r) 2256 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2257 if(BURS.DEBUG) trace(p, 92, c + 0, p.getCost(1) /* stm */); 2258 if (c < p.getCost(1) /* stm */) { 2259 p.setCost(1 /* stm */, (char)(c)); 2260 p.writePacked(0, 0xFFFFFF80, 0x4A); // p.stm = 74 2261 } 2262 if ( // stm: LONG_IFCMP(r,INT_CONSTANT) 2263 rchild.getOpcode() == INT_CONSTANT_opcode 2264 ) { 2265 c = STATE(lchild).getCost(2 /* r */) + 20; 2266 if(BURS.DEBUG) trace(p, 184, c + 0, p.getCost(1) /* stm */); 2267 if (c < p.getCost(1) /* stm */) { 2268 p.setCost(1 /* stm */, (char)(c)); 2269 p.writePacked(0, 0xFFFFFF80, 0x4B); // p.stm = 75 2270 } 2271 } 2272 if ( // stm: LONG_IFCMP(r,LONG_CONSTANT) 2273 rchild.getOpcode() == LONG_CONSTANT_opcode 2274 ) { 2275 c = STATE(lchild).getCost(2 /* r */) + 20; 2276 if(BURS.DEBUG) trace(p, 185, c + 0, p.getCost(1) /* stm */); 2277 if (c < p.getCost(1) /* stm */) { 2278 p.setCost(1 /* stm */, (char)(c)); 2279 p.writePacked(0, 0xFFFFFF80, 0x4C); // p.stm = 76 2280 } 2281 } 2282 } 2283 2284 /** 2285 * Labels FLOAT_IFCMP tree node 2286 * @param p node to label 2287 */ 2288 private static void label_FLOAT_IFCMP(AbstractBURS_TreeNode p) { 2289 p.initCost(); 2290 AbstractBURS_TreeNode lchild, rchild; 2291 lchild = p.getChild1(); 2292 rchild = p.getChild2(); 2293 label(lchild); 2294 label(rchild); 2295 int c; 2296 // stm: FLOAT_IFCMP(r,r) 2297 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2298 if(BURS.DEBUG) trace(p, 71, c + 0, p.getCost(1) /* stm */); 2299 if (c < p.getCost(1) /* stm */) { 2300 p.setCost(1 /* stm */, (char)(c)); 2301 p.writePacked(0, 0xFFFFFF80, 0x40); // p.stm = 64 2302 } 2303 } 2304 2305 /** 2306 * Labels DOUBLE_IFCMP tree node 2307 * @param p node to label 2308 */ 2309 private static void label_DOUBLE_IFCMP(AbstractBURS_TreeNode p) { 2310 p.initCost(); 2311 AbstractBURS_TreeNode lchild, rchild; 2312 lchild = p.getChild1(); 2313 rchild = p.getChild2(); 2314 label(lchild); 2315 label(rchild); 2316 int c; 2317 // stm: DOUBLE_IFCMP(r,r) 2318 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2319 if(BURS.DEBUG) trace(p, 72, c + 0, p.getCost(1) /* stm */); 2320 if (c < p.getCost(1) /* stm */) { 2321 p.setCost(1 /* stm */, (char)(c)); 2322 p.writePacked(0, 0xFFFFFF80, 0x41); // p.stm = 65 2323 } 2324 } 2325 2326 /** 2327 * Labels UNINT_BEGIN tree node 2328 * @param p node to label 2329 */ 2330 private static void label_UNINT_BEGIN(AbstractBURS_TreeNode p) { 2331 p.initCost(); 2332 // stm: UNINT_BEGIN 2333 if(BURS.DEBUG) trace(p, 15, 10 + 0, p.getCost(1) /* stm */); 2334 if (10 < p.getCost(1) /* stm */) { 2335 p.setCost(1 /* stm */, (char)(10)); 2336 p.writePacked(0, 0xFFFFFF80, 0x4); // p.stm = 4 2337 } 2338 } 2339 2340 /** 2341 * Labels UNINT_END tree node 2342 * @param p node to label 2343 */ 2344 private static void label_UNINT_END(AbstractBURS_TreeNode p) { 2345 p.initCost(); 2346 // stm: UNINT_END 2347 if(BURS.DEBUG) trace(p, 16, 10 + 0, p.getCost(1) /* stm */); 2348 if (10 < p.getCost(1) /* stm */) { 2349 p.setCost(1 /* stm */, (char)(10)); 2350 p.writePacked(0, 0xFFFFFF80, 0x5); // p.stm = 5 2351 } 2352 } 2353 2354 /** 2355 * Labels FENCE tree node 2356 * @param p node to label 2357 */ 2358 private static void label_FENCE(AbstractBURS_TreeNode p) { 2359 p.initCost(); 2360 // stm: FENCE 2361 if(BURS.DEBUG) trace(p, 24, 11 + 0, p.getCost(1) /* stm */); 2362 if (11 < p.getCost(1) /* stm */) { 2363 p.setCost(1 /* stm */, (char)(11)); 2364 p.writePacked(0, 0xFFFFFF80, 0xD); // p.stm = 13 2365 } 2366 } 2367 2368 /** 2369 * Labels READ_CEILING tree node 2370 * @param p node to label 2371 */ 2372 private static void label_READ_CEILING(AbstractBURS_TreeNode p) { 2373 p.initCost(); 2374 // stm: READ_CEILING 2375 if(BURS.DEBUG) trace(p, 26, 11 + 0, p.getCost(1) /* stm */); 2376 if (11 < p.getCost(1) /* stm */) { 2377 p.setCost(1 /* stm */, (char)(11)); 2378 p.writePacked(0, 0xFFFFFF80, 0xF); // p.stm = 15 2379 } 2380 } 2381 2382 /** 2383 * Labels WRITE_FLOOR tree node 2384 * @param p node to label 2385 */ 2386 private static void label_WRITE_FLOOR(AbstractBURS_TreeNode p) { 2387 p.initCost(); 2388 // stm: WRITE_FLOOR 2389 if(BURS.DEBUG) trace(p, 25, 11 + 0, p.getCost(1) /* stm */); 2390 if (11 < p.getCost(1) /* stm */) { 2391 p.setCost(1 /* stm */, (char)(11)); 2392 p.writePacked(0, 0xFFFFFF80, 0xE); // p.stm = 14 2393 } 2394 } 2395 2396 /** 2397 * Labels NOP tree node 2398 * @param p node to label 2399 */ 2400 private static void label_NOP(AbstractBURS_TreeNode p) { 2401 p.initCost(); 2402 // stm: NOP 2403 if(BURS.DEBUG) trace(p, 20, 10 + 0, p.getCost(1) /* stm */); 2404 if (10 < p.getCost(1) /* stm */) { 2405 p.setCost(1 /* stm */, (char)(10)); 2406 p.writePacked(0, 0xFFFFFF80, 0xA); // p.stm = 10 2407 } 2408 } 2409 2410 /** 2411 * Labels FLOAT_MOVE tree node 2412 * @param p node to label 2413 */ 2414 private static void label_FLOAT_MOVE(AbstractBURS_TreeNode p) { 2415 p.initCost(); 2416 AbstractBURS_TreeNode lchild; 2417 lchild = p.getChild1(); 2418 label(lchild); 2419 int c; 2420 // r: FLOAT_MOVE(r) 2421 c = STATE(lchild).getCost(2 /* r */) + 10; 2422 if(BURS.DEBUG) trace(p, 152, c + 0, p.getCost(2) /* r */); 2423 if (c < p.getCost(2) /* r */) { 2424 p.setCost(2 /* r */, (char)(c)); 2425 p.writePacked(0, 0xFFFFC07F, 0x2600); // p.r = 76 2426 closure_r(p, c); 2427 } 2428 } 2429 2430 /** 2431 * Labels DOUBLE_MOVE tree node 2432 * @param p node to label 2433 */ 2434 private static void label_DOUBLE_MOVE(AbstractBURS_TreeNode p) { 2435 p.initCost(); 2436 AbstractBURS_TreeNode lchild; 2437 lchild = p.getChild1(); 2438 label(lchild); 2439 int c; 2440 // r: DOUBLE_MOVE(r) 2441 c = STATE(lchild).getCost(2 /* r */) + 10; 2442 if(BURS.DEBUG) trace(p, 153, c + 0, p.getCost(2) /* r */); 2443 if (c < p.getCost(2) /* r */) { 2444 p.setCost(2 /* r */, (char)(c)); 2445 p.writePacked(0, 0xFFFFC07F, 0x2680); // p.r = 77 2446 closure_r(p, c); 2447 } 2448 } 2449 2450 /** 2451 * Labels REF_MOVE tree node 2452 * @param p node to label 2453 */ 2454 private static void label_REF_MOVE(AbstractBURS_TreeNode p) { 2455 p.initCost(); 2456 AbstractBURS_TreeNode lchild; 2457 lchild = p.getChild1(); 2458 label(lchild); 2459 int c; 2460 // r: REF_MOVE(r) 2461 c = STATE(lchild).getCost(2 /* r */) + 11; 2462 if(BURS.DEBUG) trace(p, 151, c + 0, p.getCost(2) /* r */); 2463 if (c < p.getCost(2) /* r */) { 2464 p.setCost(2 /* r */, (char)(c)); 2465 p.writePacked(0, 0xFFFFC07F, 0x2580); // p.r = 75 2466 closure_r(p, c); 2467 } 2468 if ( // rs: REF_MOVE(INT_CONSTANT) 2469 lchild.getOpcode() == INT_CONSTANT_opcode 2470 ) { 2471 c = (SI16(IV(Move.getVal(P(p))))?11:INFINITE); 2472 if(BURS.DEBUG) trace(p, 28, c + 0, p.getCost(4) /* rs */); 2473 if (c < p.getCost(4) /* rs */) { 2474 p.setCost(4 /* rs */, (char)(c)); 2475 p.writePacked(0, 0xFFF07FFF, 0x30000); // p.rs = 6 2476 closure_rs(p, c); 2477 } 2478 } 2479 if ( // rs: REF_MOVE(INT_CONSTANT) 2480 lchild.getOpcode() == INT_CONSTANT_opcode 2481 ) { 2482 c = (U16(IV(Move.getVal(P(p))))?11:INFINITE); 2483 if(BURS.DEBUG) trace(p, 29, c + 0, p.getCost(4) /* rs */); 2484 if (c < p.getCost(4) /* rs */) { 2485 p.setCost(4 /* rs */, (char)(c)); 2486 p.writePacked(0, 0xFFF07FFF, 0x38000); // p.rs = 7 2487 closure_rs(p, c); 2488 } 2489 } 2490 if ( // rs: REF_MOVE(INT_CONSTANT) 2491 lchild.getOpcode() == INT_CONSTANT_opcode 2492 ) { 2493 c = 22; 2494 if(BURS.DEBUG) trace(p, 30, c + 0, p.getCost(4) /* rs */); 2495 if (c < p.getCost(4) /* rs */) { 2496 p.setCost(4 /* rs */, (char)(c)); 2497 p.writePacked(0, 0xFFF07FFF, 0x40000); // p.rs = 8 2498 closure_rs(p, c); 2499 } 2500 } 2501 if ( // r: REF_MOVE(ADDRESS_CONSTANT) 2502 lchild.getOpcode() == ADDRESS_CONSTANT_opcode 2503 ) { 2504 c = 40; 2505 if(BURS.DEBUG) trace(p, 35, c + 0, p.getCost(2) /* r */); 2506 if (c < p.getCost(2) /* r */) { 2507 p.setCost(2 /* r */, (char)(c)); 2508 p.writePacked(0, 0xFFFFC07F, 0x3880); // p.r = 113 2509 closure_r(p, c); 2510 } 2511 } 2512 if ( // r: REF_MOVE(LONG_CONSTANT) 2513 lchild.getOpcode() == LONG_CONSTANT_opcode 2514 ) { 2515 c = 40; 2516 if(BURS.DEBUG) trace(p, 36, c + 0, p.getCost(2) /* r */); 2517 if (c < p.getCost(2) /* r */) { 2518 p.setCost(2 /* r */, (char)(c)); 2519 p.writePacked(0, 0xFFFFC07F, 0x3900); // p.r = 114 2520 closure_r(p, c); 2521 } 2522 } 2523 } 2524 2525 /** 2526 * Labels GUARD_MOVE tree node 2527 * @param p node to label 2528 */ 2529 private static void label_GUARD_MOVE(AbstractBURS_TreeNode p) { 2530 p.initCost(); 2531 // r: GUARD_MOVE 2532 if(BURS.DEBUG) trace(p, 21, 11 + 0, p.getCost(2) /* r */); 2533 if (11 < p.getCost(2) /* r */) { 2534 p.setCost(2 /* r */, (char)(11)); 2535 p.writePacked(0, 0xFFFFC07F, 0x280); // p.r = 5 2536 closure_r(p, 11); 2537 } 2538 } 2539 2540 /** 2541 * Labels GUARD_COMBINE tree node 2542 * @param p node to label 2543 */ 2544 private static void label_GUARD_COMBINE(AbstractBURS_TreeNode p) { 2545 p.initCost(); 2546 // r: GUARD_COMBINE 2547 if(BURS.DEBUG) trace(p, 22, 11 + 0, p.getCost(2) /* r */); 2548 if (11 < p.getCost(2) /* r */) { 2549 p.setCost(2 /* r */, (char)(11)); 2550 p.writePacked(0, 0xFFFFC07F, 0x300); // p.r = 6 2551 closure_r(p, 11); 2552 } 2553 } 2554 2555 /** 2556 * Labels REF_ADD tree node 2557 * @param p node to label 2558 */ 2559 private static void label_REF_ADD(AbstractBURS_TreeNode p) { 2560 p.initCost(); 2561 AbstractBURS_TreeNode lchild, rchild; 2562 lchild = p.getChild1(); 2563 rchild = p.getChild2(); 2564 label(lchild); 2565 label(rchild); 2566 int c; 2567 if ( // r: REF_ADD(r,INT_CONSTANT) 2568 rchild.getOpcode() == INT_CONSTANT_opcode 2569 ) { 2570 c = STATE(lchild).getCost(2 /* r */) + 11; 2571 if(BURS.DEBUG) trace(p, 121, c + 0, p.getCost(2) /* r */); 2572 if (c < p.getCost(2) /* r */) { 2573 p.setCost(2 /* r */, (char)(c)); 2574 p.writePacked(0, 0xFFFFC07F, 0x880); // p.r = 17 2575 closure_r(p, c); 2576 } 2577 } 2578 // r: REF_ADD(r,r) 2579 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 2580 if(BURS.DEBUG) trace(p, 43, c + 0, p.getCost(2) /* r */); 2581 if (c < p.getCost(2) /* r */) { 2582 p.setCost(2 /* r */, (char)(c)); 2583 p.writePacked(0, 0xFFFFC07F, 0x900); // p.r = 18 2584 closure_r(p, c); 2585 } 2586 if ( // r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 2587 rchild.getOpcode() == REF_MOVE_opcode && 2588 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 2589 ) { 2590 c = STATE(lchild).getCost(2 /* r */) + 20; 2591 if(BURS.DEBUG) trace(p, 122, c + 0, p.getCost(2) /* r */); 2592 if (c < p.getCost(2) /* r */) { 2593 p.setCost(2 /* r */, (char)(c)); 2594 p.writePacked(0, 0xFFFFC07F, 0x980); // p.r = 19 2595 closure_r(p, c); 2596 } 2597 } 2598 if ( // r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 2599 rchild.getOpcode() == REF_MOVE_opcode && 2600 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 2601 ) { 2602 c = STATE(lchild).getCost(2 /* r */) + (U16(IV(Move.getVal(PR(p))))?10:INFINITE); 2603 if(BURS.DEBUG) trace(p, 123, c + 0, p.getCost(2) /* r */); 2604 if (c < p.getCost(2) /* r */) { 2605 p.setCost(2 /* r */, (char)(c)); 2606 p.writePacked(0, 0xFFFFC07F, 0xA00); // p.r = 20 2607 closure_r(p, c); 2608 } 2609 } 2610 } 2611 2612 /** 2613 * Labels FLOAT_ADD tree node 2614 * @param p node to label 2615 */ 2616 private static void label_FLOAT_ADD(AbstractBURS_TreeNode p) { 2617 p.initCost(); 2618 AbstractBURS_TreeNode lchild, rchild; 2619 lchild = p.getChild1(); 2620 rchild = p.getChild2(); 2621 label(lchild); 2622 label(rchild); 2623 int c; 2624 // r: FLOAT_ADD(r,r) 2625 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2626 if(BURS.DEBUG) trace(p, 54, c + 0, p.getCost(2) /* r */); 2627 if (c < p.getCost(2) /* r */) { 2628 p.setCost(2 /* r */, (char)(c)); 2629 p.writePacked(0, 0xFFFFC07F, 0x1580); // p.r = 43 2630 closure_r(p, c); 2631 } 2632 if ( // r: FLOAT_ADD(FLOAT_MUL(r,r),r) 2633 lchild.getOpcode() == FLOAT_MUL_opcode 2634 ) { 2635 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p))?INFINITE:10); 2636 if(BURS.DEBUG) trace(p, 240, c + 0, p.getCost(2) /* r */); 2637 if (c < p.getCost(2) /* r */) { 2638 p.setCost(2 /* r */, (char)(c)); 2639 p.writePacked(0, 0xFFFFC07F, 0x1B80); // p.r = 55 2640 closure_r(p, c); 2641 } 2642 } 2643 if ( // r: FLOAT_ADD(r,FLOAT_MUL(r,r)) 2644 rchild.getOpcode() == FLOAT_MUL_opcode 2645 ) { 2646 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PR(p))?INFINITE:10); 2647 if(BURS.DEBUG) trace(p, 244, c + 0, p.getCost(2) /* r */); 2648 if (c < p.getCost(2) /* r */) { 2649 p.setCost(2 /* r */, (char)(c)); 2650 p.writePacked(0, 0xFFFFC07F, 0x1C80); // p.r = 57 2651 closure_r(p, c); 2652 } 2653 } 2654 } 2655 2656 /** 2657 * Labels DOUBLE_ADD tree node 2658 * @param p node to label 2659 */ 2660 private static void label_DOUBLE_ADD(AbstractBURS_TreeNode p) { 2661 p.initCost(); 2662 AbstractBURS_TreeNode lchild, rchild; 2663 lchild = p.getChild1(); 2664 rchild = p.getChild2(); 2665 label(lchild); 2666 label(rchild); 2667 int c; 2668 // r: DOUBLE_ADD(r,r) 2669 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2670 if(BURS.DEBUG) trace(p, 55, c + 0, p.getCost(2) /* r */); 2671 if (c < p.getCost(2) /* r */) { 2672 p.setCost(2 /* r */, (char)(c)); 2673 p.writePacked(0, 0xFFFFC07F, 0x1600); // p.r = 44 2674 closure_r(p, c); 2675 } 2676 if ( // r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) 2677 lchild.getOpcode() == DOUBLE_MUL_opcode 2678 ) { 2679 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p))?INFINITE:10); 2680 if(BURS.DEBUG) trace(p, 241, c + 0, p.getCost(2) /* r */); 2681 if (c < p.getCost(2) /* r */) { 2682 p.setCost(2 /* r */, (char)(c)); 2683 p.writePacked(0, 0xFFFFC07F, 0x1C00); // p.r = 56 2684 closure_r(p, c); 2685 } 2686 } 2687 if ( // r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) 2688 rchild.getOpcode() == DOUBLE_MUL_opcode 2689 ) { 2690 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PR(p))?INFINITE:10); 2691 if(BURS.DEBUG) trace(p, 245, c + 0, p.getCost(2) /* r */); 2692 if (c < p.getCost(2) /* r */) { 2693 p.setCost(2 /* r */, (char)(c)); 2694 p.writePacked(0, 0xFFFFC07F, 0x1D00); // p.r = 58 2695 closure_r(p, c); 2696 } 2697 } 2698 } 2699 2700 /** 2701 * Labels REF_SUB tree node 2702 * @param p node to label 2703 */ 2704 private static void label_REF_SUB(AbstractBURS_TreeNode p) { 2705 p.initCost(); 2706 AbstractBURS_TreeNode lchild, rchild; 2707 lchild = p.getChild1(); 2708 rchild = p.getChild2(); 2709 label(lchild); 2710 label(rchild); 2711 int c; 2712 // r: REF_SUB(r,r) 2713 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 2714 if(BURS.DEBUG) trace(p, 44, c + 0, p.getCost(2) /* r */); 2715 if (c < p.getCost(2) /* r */) { 2716 p.setCost(2 /* r */, (char)(c)); 2717 p.writePacked(0, 0xFFFFC07F, 0xA80); // p.r = 21 2718 closure_r(p, c); 2719 } 2720 if ( // r: REF_SUB(INT_CONSTANT,r) 2721 lchild.getOpcode() == INT_CONSTANT_opcode 2722 ) { 2723 c = STATE(rchild).getCost(2 /* r */) + (SI16(IV(Binary.getVal1(P(p))))?11:INFINITE); 2724 if(BURS.DEBUG) trace(p, 190, c + 0, p.getCost(2) /* r */); 2725 if (c < p.getCost(2) /* r */) { 2726 p.setCost(2 /* r */, (char)(c)); 2727 p.writePacked(0, 0xFFFFC07F, 0xB00); // p.r = 22 2728 closure_r(p, c); 2729 } 2730 } 2731 } 2732 2733 /** 2734 * Labels FLOAT_SUB tree node 2735 * @param p node to label 2736 */ 2737 private static void label_FLOAT_SUB(AbstractBURS_TreeNode p) { 2738 p.initCost(); 2739 AbstractBURS_TreeNode lchild, rchild; 2740 lchild = p.getChild1(); 2741 rchild = p.getChild2(); 2742 label(lchild); 2743 label(rchild); 2744 int c; 2745 // r: FLOAT_SUB(r,r) 2746 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2747 if(BURS.DEBUG) trace(p, 58, c + 0, p.getCost(2) /* r */); 2748 if (c < p.getCost(2) /* r */) { 2749 p.setCost(2 /* r */, (char)(c)); 2750 p.writePacked(0, 0xFFFFC07F, 0x1780); // p.r = 47 2751 closure_r(p, c); 2752 } 2753 if ( // r: FLOAT_SUB(FLOAT_MUL(r,r),r) 2754 lchild.getOpcode() == FLOAT_MUL_opcode 2755 ) { 2756 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p))?INFINITE:10); 2757 if(BURS.DEBUG) trace(p, 242, c + 0, p.getCost(2) /* r */); 2758 if (c < p.getCost(2) /* r */) { 2759 p.setCost(2 /* r */, (char)(c)); 2760 p.writePacked(0, 0xFFFFC07F, 0x1D80); // p.r = 59 2761 closure_r(p, c); 2762 } 2763 } 2764 } 2765 2766 /** 2767 * Labels DOUBLE_SUB tree node 2768 * @param p node to label 2769 */ 2770 private static void label_DOUBLE_SUB(AbstractBURS_TreeNode p) { 2771 p.initCost(); 2772 AbstractBURS_TreeNode lchild, rchild; 2773 lchild = p.getChild1(); 2774 rchild = p.getChild2(); 2775 label(lchild); 2776 label(rchild); 2777 int c; 2778 // r: DOUBLE_SUB(r,r) 2779 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2780 if(BURS.DEBUG) trace(p, 59, c + 0, p.getCost(2) /* r */); 2781 if (c < p.getCost(2) /* r */) { 2782 p.setCost(2 /* r */, (char)(c)); 2783 p.writePacked(0, 0xFFFFC07F, 0x1800); // p.r = 48 2784 closure_r(p, c); 2785 } 2786 if ( // r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) 2787 lchild.getOpcode() == DOUBLE_MUL_opcode 2788 ) { 2789 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p))?INFINITE:10); 2790 if(BURS.DEBUG) trace(p, 243, c + 0, p.getCost(2) /* r */); 2791 if (c < p.getCost(2) /* r */) { 2792 p.setCost(2 /* r */, (char)(c)); 2793 p.writePacked(0, 0xFFFFC07F, 0x1E00); // p.r = 60 2794 closure_r(p, c); 2795 } 2796 } 2797 } 2798 2799 /** 2800 * Labels INT_MUL tree node 2801 * @param p node to label 2802 */ 2803 private static void label_INT_MUL(AbstractBURS_TreeNode p) { 2804 p.initCost(); 2805 AbstractBURS_TreeNode lchild, rchild; 2806 lchild = p.getChild1(); 2807 rchild = p.getChild2(); 2808 label(lchild); 2809 label(rchild); 2810 int c; 2811 if ( // r: INT_MUL(r,INT_CONSTANT) 2812 rchild.getOpcode() == INT_CONSTANT_opcode 2813 ) { 2814 c = STATE(lchild).getCost(2 /* r */) + 11; 2815 if(BURS.DEBUG) trace(p, 124, c + 0, p.getCost(2) /* r */); 2816 if (c < p.getCost(2) /* r */) { 2817 p.setCost(2 /* r */, (char)(c)); 2818 p.writePacked(0, 0xFFFFC07F, 0xB80); // p.r = 23 2819 closure_r(p, c); 2820 } 2821 } 2822 // r: INT_MUL(r,r) 2823 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 2824 if(BURS.DEBUG) trace(p, 45, c + 0, p.getCost(2) /* r */); 2825 if (c < p.getCost(2) /* r */) { 2826 p.setCost(2 /* r */, (char)(c)); 2827 p.writePacked(0, 0xFFFFC07F, 0xC00); // p.r = 24 2828 closure_r(p, c); 2829 } 2830 } 2831 2832 /** 2833 * Labels LONG_MUL tree node 2834 * @param p node to label 2835 */ 2836 private static void label_LONG_MUL(AbstractBURS_TreeNode p) { 2837 p.initCost(); 2838 AbstractBURS_TreeNode lchild, rchild; 2839 lchild = p.getChild1(); 2840 rchild = p.getChild2(); 2841 label(lchild); 2842 label(rchild); 2843 int c; 2844 if ( // r: LONG_MUL(r,INT_CONSTANT) 2845 rchild.getOpcode() == INT_CONSTANT_opcode 2846 ) { 2847 c = STATE(lchild).getCost(2 /* r */) + 11; 2848 if(BURS.DEBUG) trace(p, 171, c + 0, p.getCost(2) /* r */); 2849 if (c < p.getCost(2) /* r */) { 2850 p.setCost(2 /* r */, (char)(c)); 2851 p.writePacked(0, 0xFFFFC07F, 0x2F00); // p.r = 94 2852 closure_r(p, c); 2853 } 2854 } 2855 // r: LONG_MUL(r,r) 2856 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 2857 if(BURS.DEBUG) trace(p, 85, c + 0, p.getCost(2) /* r */); 2858 if (c < p.getCost(2) /* r */) { 2859 p.setCost(2 /* r */, (char)(c)); 2860 p.writePacked(0, 0xFFFFC07F, 0x2F80); // p.r = 95 2861 closure_r(p, c); 2862 } 2863 } 2864 2865 /** 2866 * Labels FLOAT_MUL tree node 2867 * @param p node to label 2868 */ 2869 private static void label_FLOAT_MUL(AbstractBURS_TreeNode p) { 2870 p.initCost(); 2871 AbstractBURS_TreeNode lchild, rchild; 2872 lchild = p.getChild1(); 2873 rchild = p.getChild2(); 2874 label(lchild); 2875 label(rchild); 2876 int c; 2877 // r: FLOAT_MUL(r,r) 2878 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2879 if(BURS.DEBUG) trace(p, 56, c + 0, p.getCost(2) /* r */); 2880 if (c < p.getCost(2) /* r */) { 2881 p.setCost(2 /* r */, (char)(c)); 2882 p.writePacked(0, 0xFFFFC07F, 0x1680); // p.r = 45 2883 closure_r(p, c); 2884 } 2885 } 2886 2887 /** 2888 * Labels DOUBLE_MUL tree node 2889 * @param p node to label 2890 */ 2891 private static void label_DOUBLE_MUL(AbstractBURS_TreeNode p) { 2892 p.initCost(); 2893 AbstractBURS_TreeNode lchild, rchild; 2894 lchild = p.getChild1(); 2895 rchild = p.getChild2(); 2896 label(lchild); 2897 label(rchild); 2898 int c; 2899 // r: DOUBLE_MUL(r,r) 2900 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2901 if(BURS.DEBUG) trace(p, 57, c + 0, p.getCost(2) /* r */); 2902 if (c < p.getCost(2) /* r */) { 2903 p.setCost(2 /* r */, (char)(c)); 2904 p.writePacked(0, 0xFFFFC07F, 0x1700); // p.r = 46 2905 closure_r(p, c); 2906 } 2907 } 2908 2909 /** 2910 * Labels INT_DIV tree node 2911 * @param p node to label 2912 */ 2913 private static void label_INT_DIV(AbstractBURS_TreeNode p) { 2914 p.initCost(); 2915 AbstractBURS_TreeNode lchild, rchild; 2916 lchild = p.getChild1(); 2917 rchild = p.getChild2(); 2918 label(lchild); 2919 label(rchild); 2920 int c; 2921 // r: INT_DIV(r,r) 2922 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2923 if(BURS.DEBUG) trace(p, 46, c + 0, p.getCost(2) /* r */); 2924 if (c < p.getCost(2) /* r */) { 2925 p.setCost(2 /* r */, (char)(c)); 2926 p.writePacked(0, 0xFFFFC07F, 0xC80); // p.r = 25 2927 closure_r(p, c); 2928 } 2929 if ( // r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 2930 rchild.getOpcode() == REF_MOVE_opcode && 2931 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 2932 ) { 2933 c = STATE(lchild).getCost(2 /* r */) + 20; 2934 if(BURS.DEBUG) trace(p, 125, c + 0, p.getCost(2) /* r */); 2935 if (c < p.getCost(2) /* r */) { 2936 p.setCost(2 /* r */, (char)(c)); 2937 p.writePacked(0, 0xFFFFC07F, 0xD00); // p.r = 26 2938 closure_r(p, c); 2939 } 2940 } 2941 } 2942 2943 /** 2944 * Labels LONG_DIV tree node 2945 * @param p node to label 2946 */ 2947 private static void label_LONG_DIV(AbstractBURS_TreeNode p) { 2948 p.initCost(); 2949 AbstractBURS_TreeNode lchild, rchild; 2950 lchild = p.getChild1(); 2951 rchild = p.getChild2(); 2952 label(lchild); 2953 label(rchild); 2954 int c; 2955 // r: LONG_DIV(r,r) 2956 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 2957 if(BURS.DEBUG) trace(p, 86, c + 0, p.getCost(2) /* r */); 2958 if (c < p.getCost(2) /* r */) { 2959 p.setCost(2 /* r */, (char)(c)); 2960 p.writePacked(0, 0xFFFFC07F, 0x3000); // p.r = 96 2961 closure_r(p, c); 2962 } 2963 if ( // r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 2964 rchild.getOpcode() == REF_MOVE_opcode && 2965 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 2966 ) { 2967 c = STATE(lchild).getCost(2 /* r */) + 20; 2968 if(BURS.DEBUG) trace(p, 172, c + 0, p.getCost(2) /* r */); 2969 if (c < p.getCost(2) /* r */) { 2970 p.setCost(2 /* r */, (char)(c)); 2971 p.writePacked(0, 0xFFFFC07F, 0x3080); // p.r = 97 2972 closure_r(p, c); 2973 } 2974 } 2975 } 2976 2977 /** 2978 * Labels FLOAT_DIV tree node 2979 * @param p node to label 2980 */ 2981 private static void label_FLOAT_DIV(AbstractBURS_TreeNode p) { 2982 p.initCost(); 2983 AbstractBURS_TreeNode lchild, rchild; 2984 lchild = p.getChild1(); 2985 rchild = p.getChild2(); 2986 label(lchild); 2987 label(rchild); 2988 int c; 2989 // r: FLOAT_DIV(r,r) 2990 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 2991 if(BURS.DEBUG) trace(p, 60, c + 0, p.getCost(2) /* r */); 2992 if (c < p.getCost(2) /* r */) { 2993 p.setCost(2 /* r */, (char)(c)); 2994 p.writePacked(0, 0xFFFFC07F, 0x1880); // p.r = 49 2995 closure_r(p, c); 2996 } 2997 } 2998 2999 /** 3000 * Labels DOUBLE_DIV tree node 3001 * @param p node to label 3002 */ 3003 private static void label_DOUBLE_DIV(AbstractBURS_TreeNode p) { 3004 p.initCost(); 3005 AbstractBURS_TreeNode lchild, rchild; 3006 lchild = p.getChild1(); 3007 rchild = p.getChild2(); 3008 label(lchild); 3009 label(rchild); 3010 int c; 3011 // r: DOUBLE_DIV(r,r) 3012 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 3013 if(BURS.DEBUG) trace(p, 61, c + 0, p.getCost(2) /* r */); 3014 if (c < p.getCost(2) /* r */) { 3015 p.setCost(2 /* r */, (char)(c)); 3016 p.writePacked(0, 0xFFFFC07F, 0x1900); // p.r = 50 3017 closure_r(p, c); 3018 } 3019 } 3020 3021 /** 3022 * Labels INT_REM tree node 3023 * @param p node to label 3024 */ 3025 private static void label_INT_REM(AbstractBURS_TreeNode p) { 3026 p.initCost(); 3027 AbstractBURS_TreeNode lchild, rchild; 3028 lchild = p.getChild1(); 3029 rchild = p.getChild2(); 3030 label(lchild); 3031 label(rchild); 3032 int c; 3033 // r: INT_REM(r,r) 3034 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3035 if(BURS.DEBUG) trace(p, 47, c + 0, p.getCost(2) /* r */); 3036 if (c < p.getCost(2) /* r */) { 3037 p.setCost(2 /* r */, (char)(c)); 3038 p.writePacked(0, 0xFFFFC07F, 0xD80); // p.r = 27 3039 closure_r(p, c); 3040 } 3041 if ( // r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 3042 rchild.getOpcode() == REF_MOVE_opcode && 3043 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 3044 ) { 3045 c = STATE(lchild).getCost(2 /* r */) + 20; 3046 if(BURS.DEBUG) trace(p, 126, c + 0, p.getCost(2) /* r */); 3047 if (c < p.getCost(2) /* r */) { 3048 p.setCost(2 /* r */, (char)(c)); 3049 p.writePacked(0, 0xFFFFC07F, 0xE00); // p.r = 28 3050 closure_r(p, c); 3051 } 3052 } 3053 } 3054 3055 /** 3056 * Labels LONG_REM tree node 3057 * @param p node to label 3058 */ 3059 private static void label_LONG_REM(AbstractBURS_TreeNode p) { 3060 p.initCost(); 3061 AbstractBURS_TreeNode lchild, rchild; 3062 lchild = p.getChild1(); 3063 rchild = p.getChild2(); 3064 label(lchild); 3065 label(rchild); 3066 int c; 3067 // r: LONG_REM(r,r) 3068 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3069 if(BURS.DEBUG) trace(p, 87, c + 0, p.getCost(2) /* r */); 3070 if (c < p.getCost(2) /* r */) { 3071 p.setCost(2 /* r */, (char)(c)); 3072 p.writePacked(0, 0xFFFFC07F, 0x3100); // p.r = 98 3073 closure_r(p, c); 3074 } 3075 if ( // r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 3076 rchild.getOpcode() == REF_MOVE_opcode && 3077 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 3078 ) { 3079 c = STATE(lchild).getCost(2 /* r */) + 20; 3080 if(BURS.DEBUG) trace(p, 173, c + 0, p.getCost(2) /* r */); 3081 if (c < p.getCost(2) /* r */) { 3082 p.setCost(2 /* r */, (char)(c)); 3083 p.writePacked(0, 0xFFFFC07F, 0x3180); // p.r = 99 3084 closure_r(p, c); 3085 } 3086 } 3087 } 3088 3089 /** 3090 * Labels REF_NEG tree node 3091 * @param p node to label 3092 */ 3093 private static void label_REF_NEG(AbstractBURS_TreeNode p) { 3094 p.initCost(); 3095 AbstractBURS_TreeNode lchild; 3096 lchild = p.getChild1(); 3097 label(lchild); 3098 int c; 3099 // r: REF_NEG(r) 3100 c = STATE(lchild).getCost(2 /* r */) + 11; 3101 if(BURS.DEBUG) trace(p, 127, c + 0, p.getCost(2) /* r */); 3102 if (c < p.getCost(2) /* r */) { 3103 p.setCost(2 /* r */, (char)(c)); 3104 p.writePacked(0, 0xFFFFC07F, 0xE80); // p.r = 29 3105 closure_r(p, c); 3106 } 3107 } 3108 3109 /** 3110 * Labels FLOAT_NEG tree node 3111 * @param p node to label 3112 */ 3113 private static void label_FLOAT_NEG(AbstractBURS_TreeNode p) { 3114 p.initCost(); 3115 AbstractBURS_TreeNode lchild; 3116 lchild = p.getChild1(); 3117 label(lchild); 3118 int c; 3119 // r: FLOAT_NEG(r) 3120 c = STATE(lchild).getCost(2 /* r */) + 10; 3121 if(BURS.DEBUG) trace(p, 136, c + 0, p.getCost(2) /* r */); 3122 if (c < p.getCost(2) /* r */) { 3123 p.setCost(2 /* r */, (char)(c)); 3124 p.writePacked(0, 0xFFFFC07F, 0x1980); // p.r = 51 3125 closure_r(p, c); 3126 } 3127 if ( // r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) 3128 lchild.getOpcode() == FLOAT_ADD_opcode && 3129 lchild.getChild1().getOpcode() == FLOAT_MUL_opcode 3130 ) { 3131 c = STATE(lchild.getChild1().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild1().getChild2()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLL(p))?INFINITE:10); 3132 if(BURS.DEBUG) trace(p, 252, c + 0, p.getCost(2) /* r */); 3133 if (c < p.getCost(2) /* r */) { 3134 p.setCost(2 /* r */, (char)(c)); 3135 p.writePacked(0, 0xFFFFC07F, 0x1E80); // p.r = 61 3136 closure_r(p, c); 3137 } 3138 } 3139 if ( // r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) 3140 lchild.getOpcode() == FLOAT_ADD_opcode && 3141 lchild.getChild2().getOpcode() == FLOAT_MUL_opcode 3142 ) { 3143 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLR(p))?INFINITE:10); 3144 if(BURS.DEBUG) trace(p, 256, c + 0, p.getCost(2) /* r */); 3145 if (c < p.getCost(2) /* r */) { 3146 p.setCost(2 /* r */, (char)(c)); 3147 p.writePacked(0, 0xFFFFC07F, 0x1F80); // p.r = 63 3148 closure_r(p, c); 3149 } 3150 } 3151 if ( // r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) 3152 lchild.getOpcode() == FLOAT_SUB_opcode && 3153 lchild.getChild1().getOpcode() == FLOAT_MUL_opcode 3154 ) { 3155 c = STATE(lchild.getChild1().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild1().getChild2()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLL(p))?INFINITE:10); 3156 if(BURS.DEBUG) trace(p, 254, c + 0, p.getCost(2) /* r */); 3157 if (c < p.getCost(2) /* r */) { 3158 p.setCost(2 /* r */, (char)(c)); 3159 p.writePacked(0, 0xFFFFC07F, 0x2080); // p.r = 65 3160 closure_r(p, c); 3161 } 3162 } 3163 } 3164 3165 /** 3166 * Labels DOUBLE_NEG tree node 3167 * @param p node to label 3168 */ 3169 private static void label_DOUBLE_NEG(AbstractBURS_TreeNode p) { 3170 p.initCost(); 3171 AbstractBURS_TreeNode lchild; 3172 lchild = p.getChild1(); 3173 label(lchild); 3174 int c; 3175 // r: DOUBLE_NEG(r) 3176 c = STATE(lchild).getCost(2 /* r */) + 10; 3177 if(BURS.DEBUG) trace(p, 137, c + 0, p.getCost(2) /* r */); 3178 if (c < p.getCost(2) /* r */) { 3179 p.setCost(2 /* r */, (char)(c)); 3180 p.writePacked(0, 0xFFFFC07F, 0x1A00); // p.r = 52 3181 closure_r(p, c); 3182 } 3183 if ( // r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) 3184 lchild.getOpcode() == DOUBLE_ADD_opcode && 3185 lchild.getChild1().getOpcode() == DOUBLE_MUL_opcode 3186 ) { 3187 c = STATE(lchild.getChild1().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild1().getChild2()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLL(p))?INFINITE:10); 3188 if(BURS.DEBUG) trace(p, 253, c + 0, p.getCost(2) /* r */); 3189 if (c < p.getCost(2) /* r */) { 3190 p.setCost(2 /* r */, (char)(c)); 3191 p.writePacked(0, 0xFFFFC07F, 0x1F00); // p.r = 62 3192 closure_r(p, c); 3193 } 3194 } 3195 if ( // r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) 3196 lchild.getOpcode() == DOUBLE_ADD_opcode && 3197 lchild.getChild2().getOpcode() == DOUBLE_MUL_opcode 3198 ) { 3199 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2().getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLR(p))?INFINITE:10); 3200 if(BURS.DEBUG) trace(p, 257, c + 0, p.getCost(2) /* r */); 3201 if (c < p.getCost(2) /* r */) { 3202 p.setCost(2 /* r */, (char)(c)); 3203 p.writePacked(0, 0xFFFFC07F, 0x2000); // p.r = 64 3204 closure_r(p, c); 3205 } 3206 } 3207 if ( // r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) 3208 lchild.getOpcode() == DOUBLE_SUB_opcode && 3209 lchild.getChild1().getOpcode() == DOUBLE_MUL_opcode 3210 ) { 3211 c = STATE(lchild.getChild1().getChild1()).getCost(2 /* r */) + STATE(lchild.getChild1().getChild2()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + (IR.strictFP(P(p),PL(p),PLL(p))?INFINITE:10); 3212 if(BURS.DEBUG) trace(p, 255, c + 0, p.getCost(2) /* r */); 3213 if (c < p.getCost(2) /* r */) { 3214 p.setCost(2 /* r */, (char)(c)); 3215 p.writePacked(0, 0xFFFFC07F, 0x2100); // p.r = 66 3216 closure_r(p, c); 3217 } 3218 } 3219 } 3220 3221 /** 3222 * Labels FLOAT_SQRT tree node 3223 * @param p node to label 3224 */ 3225 private static void label_FLOAT_SQRT(AbstractBURS_TreeNode p) { 3226 p.initCost(); 3227 AbstractBURS_TreeNode lchild; 3228 lchild = p.getChild1(); 3229 label(lchild); 3230 int c; 3231 // r: FLOAT_SQRT(r) 3232 c = STATE(lchild).getCost(2 /* r */) + 10; 3233 if(BURS.DEBUG) trace(p, 138, c + 0, p.getCost(2) /* r */); 3234 if (c < p.getCost(2) /* r */) { 3235 p.setCost(2 /* r */, (char)(c)); 3236 p.writePacked(0, 0xFFFFC07F, 0x1A80); // p.r = 53 3237 closure_r(p, c); 3238 } 3239 } 3240 3241 /** 3242 * Labels DOUBLE_SQRT tree node 3243 * @param p node to label 3244 */ 3245 private static void label_DOUBLE_SQRT(AbstractBURS_TreeNode p) { 3246 p.initCost(); 3247 AbstractBURS_TreeNode lchild; 3248 lchild = p.getChild1(); 3249 label(lchild); 3250 int c; 3251 // r: DOUBLE_SQRT(r) 3252 c = STATE(lchild).getCost(2 /* r */) + 10; 3253 if(BURS.DEBUG) trace(p, 139, c + 0, p.getCost(2) /* r */); 3254 if (c < p.getCost(2) /* r */) { 3255 p.setCost(2 /* r */, (char)(c)); 3256 p.writePacked(0, 0xFFFFC07F, 0x1B00); // p.r = 54 3257 closure_r(p, c); 3258 } 3259 } 3260 3261 /** 3262 * Labels INT_SHL tree node 3263 * @param p node to label 3264 */ 3265 private static void label_INT_SHL(AbstractBURS_TreeNode p) { 3266 p.initCost(); 3267 AbstractBURS_TreeNode lchild, rchild; 3268 lchild = p.getChild1(); 3269 rchild = p.getChild2(); 3270 label(lchild); 3271 label(rchild); 3272 int c; 3273 if ( // rz: INT_SHL(r,INT_CONSTANT) 3274 rchild.getOpcode() == INT_CONSTANT_opcode 3275 ) { 3276 c = STATE(lchild).getCost(2 /* r */) + 10; 3277 if(BURS.DEBUG) trace(p, 128, c + 0, p.getCost(5) /* rz */); 3278 if (c < p.getCost(5) /* rz */) { 3279 p.setCost(5 /* rz */, (char)(c)); 3280 p.writePacked(0, 0xFF0FFFFF, 0x200000); // p.rz = 2 3281 closure_rz(p, c); 3282 } 3283 } 3284 // rz: INT_SHL(r,r) 3285 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3286 if(BURS.DEBUG) trace(p, 48, c + 0, p.getCost(5) /* rz */); 3287 if (c < p.getCost(5) /* rz */) { 3288 p.setCost(5 /* rz */, (char)(c)); 3289 p.writePacked(0, 0xFF0FFFFF, 0x300000); // p.rz = 3 3290 closure_rz(p, c); 3291 } 3292 if ( // rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 3293 lchild.getOpcode() == INT_USHR_opcode && 3294 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3295 rchild.getOpcode() == INT_CONSTANT_opcode 3296 ) { 3297 c = STATE(lchild.getChild1()).getCost(2 /* r */) + 10; 3298 if(BURS.DEBUG) trace(p, 192, c + 0, p.getCost(5) /* rz */); 3299 if (c < p.getCost(5) /* rz */) { 3300 p.setCost(5 /* rz */, (char)(c)); 3301 p.writePacked(0, 0xFF0FFFFF, 0x400000); // p.rz = 4 3302 closure_rz(p, c); 3303 } 3304 } 3305 } 3306 3307 /** 3308 * Labels LONG_SHL tree node 3309 * @param p node to label 3310 */ 3311 private static void label_LONG_SHL(AbstractBURS_TreeNode p) { 3312 p.initCost(); 3313 AbstractBURS_TreeNode lchild, rchild; 3314 lchild = p.getChild1(); 3315 rchild = p.getChild2(); 3316 label(lchild); 3317 label(rchild); 3318 int c; 3319 if ( // r: LONG_SHL(r,INT_CONSTANT) 3320 rchild.getOpcode() == INT_CONSTANT_opcode 3321 ) { 3322 c = STATE(lchild).getCost(2 /* r */) + 10; 3323 if(BURS.DEBUG) trace(p, 174, c + 0, p.getCost(2) /* r */); 3324 if (c < p.getCost(2) /* r */) { 3325 p.setCost(2 /* r */, (char)(c)); 3326 p.writePacked(0, 0xFFFFC07F, 0x3200); // p.r = 100 3327 closure_r(p, c); 3328 } 3329 } 3330 // r: LONG_SHL(r,r) 3331 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3332 if(BURS.DEBUG) trace(p, 88, c + 0, p.getCost(2) /* r */); 3333 if (c < p.getCost(2) /* r */) { 3334 p.setCost(2 /* r */, (char)(c)); 3335 p.writePacked(0, 0xFFFFC07F, 0x3280); // p.r = 101 3336 closure_r(p, c); 3337 } 3338 if ( // r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 3339 lchild.getOpcode() == LONG_USHR_opcode && 3340 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3341 rchild.getOpcode() == INT_CONSTANT_opcode 3342 ) { 3343 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VLR(p) <= VR(p)) ? 10 : INFINITE); 3344 if(BURS.DEBUG) trace(p, 207, c + 0, p.getCost(2) /* r */); 3345 if (c < p.getCost(2) /* r */) { 3346 p.setCost(2 /* r */, (char)(c)); 3347 p.writePacked(0, 0xFFFFC07F, 0x3300); // p.r = 102 3348 closure_r(p, c); 3349 } 3350 } 3351 } 3352 3353 /** 3354 * Labels INT_SHR tree node 3355 * @param p node to label 3356 */ 3357 private static void label_INT_SHR(AbstractBURS_TreeNode p) { 3358 p.initCost(); 3359 AbstractBURS_TreeNode lchild, rchild; 3360 lchild = p.getChild1(); 3361 rchild = p.getChild2(); 3362 label(lchild); 3363 label(rchild); 3364 int c; 3365 if ( // rs: INT_SHR(r,INT_CONSTANT) 3366 rchild.getOpcode() == INT_CONSTANT_opcode 3367 ) { 3368 c = STATE(lchild).getCost(2 /* r */) + 10; 3369 if(BURS.DEBUG) trace(p, 129, c + 0, p.getCost(4) /* rs */); 3370 if (c < p.getCost(4) /* rs */) { 3371 p.setCost(4 /* rs */, (char)(c)); 3372 p.writePacked(0, 0xFFF07FFF, 0x10000); // p.rs = 2 3373 closure_rs(p, c); 3374 } 3375 } 3376 // rs: INT_SHR(r,r) 3377 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3378 if(BURS.DEBUG) trace(p, 49, c + 0, p.getCost(4) /* rs */); 3379 if (c < p.getCost(4) /* rs */) { 3380 p.setCost(4 /* rs */, (char)(c)); 3381 p.writePacked(0, 0xFFF07FFF, 0x18000); // p.rs = 3 3382 closure_rs(p, c); 3383 } 3384 if ( // rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 3385 lchild.getOpcode() == REF_AND_opcode && 3386 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3387 rchild.getOpcode() == INT_CONSTANT_opcode 3388 ) { 3389 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (POSITIVE_MASK(IV(Binary.getVal2(PL(p))))?10:INFINITE); 3390 if(BURS.DEBUG) trace(p, 193, c + 0, p.getCost(6) /* rp */); 3391 if (c < p.getCost(6) /* rp */) { 3392 p.setCost(6 /* rp */, (char)(c)); 3393 p.writePacked(0, 0xF0FFFFFF, 0x1000000); // p.rp = 1 3394 closure_rp(p, c); 3395 } 3396 } 3397 } 3398 3399 /** 3400 * Labels LONG_SHR tree node 3401 * @param p node to label 3402 */ 3403 private static void label_LONG_SHR(AbstractBURS_TreeNode p) { 3404 p.initCost(); 3405 AbstractBURS_TreeNode lchild, rchild; 3406 lchild = p.getChild1(); 3407 rchild = p.getChild2(); 3408 label(lchild); 3409 label(rchild); 3410 int c; 3411 if ( // r: LONG_SHR(r,INT_CONSTANT) 3412 rchild.getOpcode() == INT_CONSTANT_opcode 3413 ) { 3414 c = STATE(lchild).getCost(2 /* r */) + 10; 3415 if(BURS.DEBUG) trace(p, 175, c + 0, p.getCost(2) /* r */); 3416 if (c < p.getCost(2) /* r */) { 3417 p.setCost(2 /* r */, (char)(c)); 3418 p.writePacked(0, 0xFFFFC07F, 0x3400); // p.r = 104 3419 closure_r(p, c); 3420 } 3421 } 3422 // r: LONG_SHR(r,r) 3423 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3424 if(BURS.DEBUG) trace(p, 89, c + 0, p.getCost(2) /* r */); 3425 if (c < p.getCost(2) /* r */) { 3426 p.setCost(2 /* r */, (char)(c)); 3427 p.writePacked(0, 0xFFFFC07F, 0x3480); // p.r = 105 3428 closure_r(p, c); 3429 } 3430 } 3431 3432 /** 3433 * Labels INT_USHR tree node 3434 * @param p node to label 3435 */ 3436 private static void label_INT_USHR(AbstractBURS_TreeNode p) { 3437 p.initCost(); 3438 AbstractBURS_TreeNode lchild, rchild; 3439 lchild = p.getChild1(); 3440 rchild = p.getChild2(); 3441 label(lchild); 3442 label(rchild); 3443 int c; 3444 if ( // rp: INT_USHR(r,INT_CONSTANT) 3445 rchild.getOpcode() == INT_CONSTANT_opcode 3446 ) { 3447 c = STATE(lchild).getCost(2 /* r */) + 10; 3448 if(BURS.DEBUG) trace(p, 130, c + 0, p.getCost(6) /* rp */); 3449 if (c < p.getCost(6) /* rp */) { 3450 p.setCost(6 /* rp */, (char)(c)); 3451 p.writePacked(0, 0xF0FFFFFF, 0x2000000); // p.rp = 2 3452 closure_rp(p, c); 3453 } 3454 } 3455 // rz: INT_USHR(r,r) 3456 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3457 if(BURS.DEBUG) trace(p, 50, c + 0, p.getCost(5) /* rz */); 3458 if (c < p.getCost(5) /* rz */) { 3459 p.setCost(5 /* rz */, (char)(c)); 3460 p.writePacked(0, 0xFF0FFFFF, 0x500000); // p.rz = 5 3461 closure_rz(p, c); 3462 } 3463 if ( // rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 3464 lchild.getOpcode() == REF_AND_opcode && 3465 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3466 rchild.getOpcode() == INT_CONSTANT_opcode 3467 ) { 3468 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (POSITIVE_MASK(IV(Binary.getVal2(PL(p))))?10:INFINITE); 3469 if(BURS.DEBUG) trace(p, 194, c + 0, p.getCost(6) /* rp */); 3470 if (c < p.getCost(6) /* rp */) { 3471 p.setCost(6 /* rp */, (char)(c)); 3472 p.writePacked(0, 0xF0FFFFFF, 0x3000000); // p.rp = 3 3473 closure_rp(p, c); 3474 } 3475 } 3476 if ( // rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 3477 lchild.getOpcode() == REF_AND_opcode && 3478 lchild.getChild2().getOpcode() == REF_MOVE_opcode && 3479 lchild.getChild2().getChild1().getOpcode() == INT_CONSTANT_opcode && 3480 rchild.getOpcode() == INT_CONSTANT_opcode 3481 ) { 3482 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (POSITIVE_MASK(IV(Move.getVal(PLR(p))))?10:INFINITE); 3483 if(BURS.DEBUG) trace(p, 195, c + 0, p.getCost(6) /* rp */); 3484 if (c < p.getCost(6) /* rp */) { 3485 p.setCost(6 /* rp */, (char)(c)); 3486 p.writePacked(0, 0xF0FFFFFF, 0x4000000); // p.rp = 4 3487 closure_rp(p, c); 3488 } 3489 } 3490 if ( // rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 3491 lchild.getOpcode() == INT_SHL_opcode && 3492 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3493 rchild.getOpcode() == INT_CONSTANT_opcode 3494 ) { 3495 c = STATE(lchild.getChild1()).getCost(2 /* r */) + 10; 3496 if(BURS.DEBUG) trace(p, 196, c + 0, p.getCost(6) /* rp */); 3497 if (c < p.getCost(6) /* rp */) { 3498 p.setCost(6 /* rp */, (char)(c)); 3499 p.writePacked(0, 0xF0FFFFFF, 0x5000000); // p.rp = 5 3500 closure_rp(p, c); 3501 } 3502 } 3503 } 3504 3505 /** 3506 * Labels LONG_USHR tree node 3507 * @param p node to label 3508 */ 3509 private static void label_LONG_USHR(AbstractBURS_TreeNode p) { 3510 p.initCost(); 3511 AbstractBURS_TreeNode lchild, rchild; 3512 lchild = p.getChild1(); 3513 rchild = p.getChild2(); 3514 label(lchild); 3515 label(rchild); 3516 int c; 3517 if ( // r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 3518 lchild.getOpcode() == LONG_SHL_opcode && 3519 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3520 rchild.getOpcode() == INT_CONSTANT_opcode 3521 ) { 3522 c = STATE(lchild.getChild1()).getCost(2 /* r */) + ((VLR(p) <= VR(p)) ? 10 : INFINITE); 3523 if(BURS.DEBUG) trace(p, 208, c + 0, p.getCost(2) /* r */); 3524 if (c < p.getCost(2) /* r */) { 3525 p.setCost(2 /* r */, (char)(c)); 3526 p.writePacked(0, 0xFFFFC07F, 0x3380); // p.r = 103 3527 closure_r(p, c); 3528 } 3529 } 3530 if ( // r: LONG_USHR(r,INT_CONSTANT) 3531 rchild.getOpcode() == INT_CONSTANT_opcode 3532 ) { 3533 c = STATE(lchild).getCost(2 /* r */) + 10; 3534 if(BURS.DEBUG) trace(p, 176, c + 0, p.getCost(2) /* r */); 3535 if (c < p.getCost(2) /* r */) { 3536 p.setCost(2 /* r */, (char)(c)); 3537 p.writePacked(0, 0xFFFFC07F, 0x3500); // p.r = 106 3538 closure_r(p, c); 3539 } 3540 } 3541 // r: LONG_USHR(r,r) 3542 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 20; 3543 if(BURS.DEBUG) trace(p, 90, c + 0, p.getCost(2) /* r */); 3544 if (c < p.getCost(2) /* r */) { 3545 p.setCost(2 /* r */, (char)(c)); 3546 p.writePacked(0, 0xFFFFC07F, 0x3580); // p.r = 107 3547 closure_r(p, c); 3548 } 3549 } 3550 3551 /** 3552 * Labels REF_AND tree node 3553 * @param p node to label 3554 */ 3555 private static void label_REF_AND(AbstractBURS_TreeNode p) { 3556 p.initCost(); 3557 AbstractBURS_TreeNode lchild, rchild; 3558 lchild = p.getChild1(); 3559 rchild = p.getChild2(); 3560 label(lchild); 3561 label(rchild); 3562 int c; 3563 // r: REF_AND(r,r) 3564 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 3565 if(BURS.DEBUG) trace(p, 51, c + 0, p.getCost(2) /* r */); 3566 if (c < p.getCost(2) /* r */) { 3567 p.setCost(2 /* r */, (char)(c)); 3568 p.writePacked(0, 0xFFFFC07F, 0xF00); // p.r = 30 3569 closure_r(p, c); 3570 } 3571 if ( // czr: REF_AND(r,INT_CONSTANT) 3572 rchild.getOpcode() == INT_CONSTANT_opcode 3573 ) { 3574 c = STATE(lchild).getCost(2 /* r */) + 11; 3575 if(BURS.DEBUG) trace(p, 131, c + 0, p.getCost(3) /* czr */); 3576 if (c < p.getCost(3) /* czr */) { 3577 p.setCost(3 /* czr */, (char)(c)); 3578 p.writePacked(0, 0xFFFFBFFF, 0x4000); // p.czr = 1 3579 closure_czr(p, c); 3580 } 3581 } 3582 if ( // rp: REF_AND(r,INT_CONSTANT) 3583 rchild.getOpcode() == INT_CONSTANT_opcode 3584 ) { 3585 c = STATE(lchild).getCost(2 /* r */) + (MASK(IV(Binary.getVal2(P(p))))?10:INFINITE); 3586 if(BURS.DEBUG) trace(p, 132, c + 0, p.getCost(6) /* rp */); 3587 if (c < p.getCost(6) /* rp */) { 3588 p.setCost(6 /* rp */, (char)(c)); 3589 p.writePacked(0, 0xF0FFFFFF, 0x6000000); // p.rp = 6 3590 closure_rp(p, c); 3591 } 3592 } 3593 if ( // r: REF_AND(REF_NOT(r),REF_NOT(r)) 3594 lchild.getOpcode() == REF_NOT_opcode && 3595 rchild.getOpcode() == REF_NOT_opcode 3596 ) { 3597 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 10; 3598 if(BURS.DEBUG) trace(p, 211, c + 0, p.getCost(2) /* r */); 3599 if (c < p.getCost(2) /* r */) { 3600 p.setCost(2 /* r */, (char)(c)); 3601 p.writePacked(0, 0xFFFFC07F, 0xF80); // p.r = 31 3602 closure_r(p, c); 3603 } 3604 } 3605 if ( // r: REF_AND(r,REF_NOT(r)) 3606 rchild.getOpcode() == REF_NOT_opcode 3607 ) { 3608 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 10; 3609 if(BURS.DEBUG) trace(p, 216, c + 0, p.getCost(2) /* r */); 3610 if (c < p.getCost(2) /* r */) { 3611 p.setCost(2 /* r */, (char)(c)); 3612 p.writePacked(0, 0xFFFFC07F, 0x1000); // p.r = 32 3613 closure_r(p, c); 3614 } 3615 } 3616 if ( // rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 3617 lchild.getOpcode() == INT_USHR_opcode && 3618 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3619 rchild.getOpcode() == INT_CONSTANT_opcode 3620 ) { 3621 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (POSITIVE_MASK(IV(Binary.getVal2(P(p))))?10:INFINITE); 3622 if(BURS.DEBUG) trace(p, 197, c + 0, p.getCost(6) /* rp */); 3623 if (c < p.getCost(6) /* rp */) { 3624 p.setCost(6 /* rp */, (char)(c)); 3625 p.writePacked(0, 0xF0FFFFFF, 0x7000000); // p.rp = 7 3626 closure_rp(p, c); 3627 } 3628 } 3629 if ( // rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 3630 lchild.getOpcode() == INT_USHR_opcode && 3631 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3632 rchild.getOpcode() == REF_MOVE_opcode && 3633 rchild.getChild1().getOpcode() == INT_CONSTANT_opcode 3634 ) { 3635 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (POSITIVE_MASK(IV(Move.getVal(PR(p))))?10:INFINITE); 3636 if(BURS.DEBUG) trace(p, 198, c + 0, p.getCost(6) /* rp */); 3637 if (c < p.getCost(6) /* rp */) { 3638 p.setCost(6 /* rp */, (char)(c)); 3639 p.writePacked(0, 0xF0FFFFFF, 0x8000000); // p.rp = 8 3640 closure_rp(p, c); 3641 } 3642 } 3643 if ( // rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 3644 lchild.getOpcode() == BYTE_LOAD_opcode && 3645 rchild.getOpcode() == INT_CONSTANT_opcode 3646 ) { 3647 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + (VR(p) == 0xff ? 10 : INFINITE); 3648 if(BURS.DEBUG) trace(p, 231, c + 0, p.getCost(6) /* rp */); 3649 if (c < p.getCost(6) /* rp */) { 3650 p.setCost(6 /* rp */, (char)(c)); 3651 p.writePacked(0, 0xF0FFFFFF, 0xA000000); // p.rp = 10 3652 closure_rp(p, c); 3653 } 3654 } 3655 if ( // rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 3656 lchild.getOpcode() == BYTE_LOAD_opcode && 3657 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 3658 rchild.getOpcode() == INT_CONSTANT_opcode 3659 ) { 3660 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (VR(p) == 0xff ? 10 : INFINITE); 3661 if(BURS.DEBUG) trace(p, 199, c + 0, p.getCost(6) /* rp */); 3662 if (c < p.getCost(6) /* rp */) { 3663 p.setCost(6 /* rp */, (char)(c)); 3664 p.writePacked(0, 0xF0FFFFFF, 0xB000000); // p.rp = 11 3665 closure_rp(p, c); 3666 } 3667 } 3668 } 3669 3670 /** 3671 * Labels REF_OR tree node 3672 * @param p node to label 3673 */ 3674 private static void label_REF_OR(AbstractBURS_TreeNode p) { 3675 p.initCost(); 3676 AbstractBURS_TreeNode lchild, rchild; 3677 lchild = p.getChild1(); 3678 rchild = p.getChild2(); 3679 label(lchild); 3680 label(rchild); 3681 int c; 3682 // r: REF_OR(r,r) 3683 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 3684 if(BURS.DEBUG) trace(p, 52, c + 0, p.getCost(2) /* r */); 3685 if (c < p.getCost(2) /* r */) { 3686 p.setCost(2 /* r */, (char)(c)); 3687 p.writePacked(0, 0xFFFFC07F, 0x1080); // p.r = 33 3688 closure_r(p, c); 3689 } 3690 if ( // r: REF_OR(r,INT_CONSTANT) 3691 rchild.getOpcode() == INT_CONSTANT_opcode 3692 ) { 3693 c = STATE(lchild).getCost(2 /* r */) + 10; 3694 if(BURS.DEBUG) trace(p, 133, c + 0, p.getCost(2) /* r */); 3695 if (c < p.getCost(2) /* r */) { 3696 p.setCost(2 /* r */, (char)(c)); 3697 p.writePacked(0, 0xFFFFC07F, 0x1100); // p.r = 34 3698 closure_r(p, c); 3699 } 3700 } 3701 if ( // r: REF_OR(REF_NOT(r),REF_NOT(r)) 3702 lchild.getOpcode() == REF_NOT_opcode && 3703 rchild.getOpcode() == REF_NOT_opcode 3704 ) { 3705 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 10; 3706 if(BURS.DEBUG) trace(p, 212, c + 0, p.getCost(2) /* r */); 3707 if (c < p.getCost(2) /* r */) { 3708 p.setCost(2 /* r */, (char)(c)); 3709 p.writePacked(0, 0xFFFFC07F, 0x1180); // p.r = 35 3710 closure_r(p, c); 3711 } 3712 } 3713 if ( // r: REF_OR(r,REF_NOT(r)) 3714 rchild.getOpcode() == REF_NOT_opcode 3715 ) { 3716 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 10; 3717 if(BURS.DEBUG) trace(p, 217, c + 0, p.getCost(2) /* r */); 3718 if (c < p.getCost(2) /* r */) { 3719 p.setCost(2 /* r */, (char)(c)); 3720 p.writePacked(0, 0xFFFFC07F, 0x1200); // p.r = 36 3721 closure_r(p, c); 3722 } 3723 } 3724 } 3725 3726 /** 3727 * Labels REF_XOR tree node 3728 * @param p node to label 3729 */ 3730 private static void label_REF_XOR(AbstractBURS_TreeNode p) { 3731 p.initCost(); 3732 AbstractBURS_TreeNode lchild, rchild; 3733 lchild = p.getChild1(); 3734 rchild = p.getChild2(); 3735 label(lchild); 3736 label(rchild); 3737 int c; 3738 // r: REF_XOR(r,r) 3739 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 3740 if(BURS.DEBUG) trace(p, 53, c + 0, p.getCost(2) /* r */); 3741 if (c < p.getCost(2) /* r */) { 3742 p.setCost(2 /* r */, (char)(c)); 3743 p.writePacked(0, 0xFFFFC07F, 0x1280); // p.r = 37 3744 closure_r(p, c); 3745 } 3746 if ( // r: REF_XOR(r,INT_CONSTANT) 3747 rchild.getOpcode() == INT_CONSTANT_opcode 3748 ) { 3749 c = STATE(lchild).getCost(2 /* r */) + 10; 3750 if(BURS.DEBUG) trace(p, 134, c + 0, p.getCost(2) /* r */); 3751 if (c < p.getCost(2) /* r */) { 3752 p.setCost(2 /* r */, (char)(c)); 3753 p.writePacked(0, 0xFFFFC07F, 0x1300); // p.r = 38 3754 closure_r(p, c); 3755 } 3756 } 3757 } 3758 3759 /** 3760 * Labels REF_NOT tree node 3761 * @param p node to label 3762 */ 3763 private static void label_REF_NOT(AbstractBURS_TreeNode p) { 3764 p.initCost(); 3765 AbstractBURS_TreeNode lchild; 3766 lchild = p.getChild1(); 3767 label(lchild); 3768 int c; 3769 // r: REF_NOT(r) 3770 c = STATE(lchild).getCost(2 /* r */) + 10; 3771 if(BURS.DEBUG) trace(p, 135, c + 0, p.getCost(2) /* r */); 3772 if (c < p.getCost(2) /* r */) { 3773 p.setCost(2 /* r */, (char)(c)); 3774 p.writePacked(0, 0xFFFFC07F, 0x1380); // p.r = 39 3775 closure_r(p, c); 3776 } 3777 if ( // r: REF_NOT(REF_OR(r,r)) 3778 lchild.getOpcode() == REF_OR_opcode 3779 ) { 3780 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + 10; 3781 if(BURS.DEBUG) trace(p, 228, c + 0, p.getCost(2) /* r */); 3782 if (c < p.getCost(2) /* r */) { 3783 p.setCost(2 /* r */, (char)(c)); 3784 p.writePacked(0, 0xFFFFC07F, 0x1400); // p.r = 40 3785 closure_r(p, c); 3786 } 3787 } 3788 if ( // r: REF_NOT(REF_AND(r,r)) 3789 lchild.getOpcode() == REF_AND_opcode 3790 ) { 3791 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + 10; 3792 if(BURS.DEBUG) trace(p, 229, c + 0, p.getCost(2) /* r */); 3793 if (c < p.getCost(2) /* r */) { 3794 p.setCost(2 /* r */, (char)(c)); 3795 p.writePacked(0, 0xFFFFC07F, 0x1480); // p.r = 41 3796 closure_r(p, c); 3797 } 3798 } 3799 if ( // r: REF_NOT(REF_XOR(r,r)) 3800 lchild.getOpcode() == REF_XOR_opcode 3801 ) { 3802 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + 10; 3803 if(BURS.DEBUG) trace(p, 230, c + 0, p.getCost(2) /* r */); 3804 if (c < p.getCost(2) /* r */) { 3805 p.setCost(2 /* r */, (char)(c)); 3806 p.writePacked(0, 0xFFFFC07F, 0x1500); // p.r = 42 3807 closure_r(p, c); 3808 } 3809 } 3810 } 3811 3812 /** 3813 * Labels INT_2ADDRZerExt tree node 3814 * @param p node to label 3815 */ 3816 private static void label_INT_2ADDRZerExt(AbstractBURS_TreeNode p) { 3817 p.initCost(); 3818 AbstractBURS_TreeNode lchild; 3819 lchild = p.getChild1(); 3820 label(lchild); 3821 int c; 3822 // rz: INT_2ADDRZerExt(rz) 3823 c = STATE(lchild).getCost(5 /* rz */) + 10; 3824 if(BURS.DEBUG) trace(p, 186, c + 0, p.getCost(5) /* rz */); 3825 if (c < p.getCost(5) /* rz */) { 3826 p.setCost(5 /* rz */, (char)(c)); 3827 p.writePacked(0, 0xFF0FFFFF, 0x600000); // p.rz = 6 3828 closure_rz(p, c); 3829 } 3830 // rz: INT_2ADDRZerExt(r) 3831 c = STATE(lchild).getCost(2 /* r */) + 11; 3832 if(BURS.DEBUG) trace(p, 187, c + 0, p.getCost(5) /* rz */); 3833 if (c < p.getCost(5) /* rz */) { 3834 p.setCost(5 /* rz */, (char)(c)); 3835 p.writePacked(0, 0xFF0FFFFF, 0x700000); // p.rz = 7 3836 closure_rz(p, c); 3837 } 3838 if ( // rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 3839 lchild.getOpcode() == INT_LOAD_opcode && 3840 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 3841 ) { 3842 c = STATE(lchild.getChild1()).getCost(2 /* r */) + 11; 3843 if(BURS.DEBUG) trace(p, 209, c + 0, p.getCost(5) /* rz */); 3844 if (c < p.getCost(5) /* rz */) { 3845 p.setCost(5 /* rz */, (char)(c)); 3846 p.writePacked(0, 0xFF0FFFFF, 0x800000); // p.rz = 8 3847 closure_rz(p, c); 3848 } 3849 } 3850 if ( // rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 3851 lchild.getOpcode() == INT_LOAD_opcode 3852 ) { 3853 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + 11; 3854 if(BURS.DEBUG) trace(p, 238, c + 0, p.getCost(5) /* rz */); 3855 if (c < p.getCost(5) /* rz */) { 3856 p.setCost(5 /* rz */, (char)(c)); 3857 p.writePacked(0, 0xFF0FFFFF, 0x900000); // p.rz = 9 3858 closure_rz(p, c); 3859 } 3860 } 3861 if ( // rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 3862 lchild.getOpcode() == INT_LOAD_opcode && 3863 lchild.getChild1().getOpcode() == REF_ADD_opcode && 3864 lchild.getChild1().getChild2().getOpcode() == INT_CONSTANT_opcode && 3865 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode 3866 ) { 3867 c = STATE(lchild.getChild1().getChild1()).getCost(2 /* r */) + (SI16(VLR(p)+VLLR(p)) ? 14 : INFINITE); 3868 if(BURS.DEBUG) trace(p, 263, c + 0, p.getCost(5) /* rz */); 3869 if (c < p.getCost(5) /* rz */) { 3870 p.setCost(5 /* rz */, (char)(c)); 3871 p.writePacked(0, 0xFF0FFFFF, 0xA00000); // p.rz = 10 3872 closure_rz(p, c); 3873 } 3874 } 3875 } 3876 3877 /** 3878 * Labels INT_2LONG tree node 3879 * @param p node to label 3880 */ 3881 private static void label_INT_2LONG(AbstractBURS_TreeNode p) { 3882 p.initCost(); 3883 AbstractBURS_TreeNode lchild; 3884 lchild = p.getChild1(); 3885 label(lchild); 3886 int c; 3887 // rs: INT_2LONG(r) 3888 c = STATE(lchild).getCost(2 /* r */) + 11; 3889 if(BURS.DEBUG) trace(p, 177, c + 0, p.getCost(4) /* rs */); 3890 if (c < p.getCost(4) /* rs */) { 3891 p.setCost(4 /* rs */, (char)(c)); 3892 p.writePacked(0, 0xFFF07FFF, 0x90000); // p.rs = 18 3893 closure_rs(p, c); 3894 } 3895 // rs: INT_2LONG(rs) 3896 c = STATE(lchild).getCost(4 /* rs */) + 10; 3897 if(BURS.DEBUG) trace(p, 178, c + 0, p.getCost(4) /* rs */); 3898 if (c < p.getCost(4) /* rs */) { 3899 p.setCost(4 /* rs */, (char)(c)); 3900 p.writePacked(0, 0xFFF07FFF, 0x98000); // p.rs = 19 3901 closure_rs(p, c); 3902 } 3903 } 3904 3905 /** 3906 * Labels INT_2FLOAT tree node 3907 * @param p node to label 3908 */ 3909 private static void label_INT_2FLOAT(AbstractBURS_TreeNode p) { 3910 p.initCost(); 3911 AbstractBURS_TreeNode lchild; 3912 lchild = p.getChild1(); 3913 label(lchild); 3914 int c; 3915 // r: INT_2FLOAT(r) 3916 c = STATE(lchild).getCost(2 /* r */) + 10; 3917 if(BURS.DEBUG) trace(p, 143, c + 0, p.getCost(2) /* r */); 3918 if (c < p.getCost(2) /* r */) { 3919 p.setCost(2 /* r */, (char)(c)); 3920 p.writePacked(0, 0xFFFFC07F, 0x2180); // p.r = 67 3921 closure_r(p, c); 3922 } 3923 } 3924 3925 /** 3926 * Labels INT_2DOUBLE tree node 3927 * @param p node to label 3928 */ 3929 private static void label_INT_2DOUBLE(AbstractBURS_TreeNode p) { 3930 p.initCost(); 3931 AbstractBURS_TreeNode lchild; 3932 lchild = p.getChild1(); 3933 label(lchild); 3934 int c; 3935 // r: INT_2DOUBLE(r) 3936 c = STATE(lchild).getCost(2 /* r */) + 10; 3937 if(BURS.DEBUG) trace(p, 144, c + 0, p.getCost(2) /* r */); 3938 if (c < p.getCost(2) /* r */) { 3939 p.setCost(2 /* r */, (char)(c)); 3940 p.writePacked(0, 0xFFFFC07F, 0x2200); // p.r = 68 3941 closure_r(p, c); 3942 } 3943 } 3944 3945 /** 3946 * Labels LONG_2INT tree node 3947 * @param p node to label 3948 */ 3949 private static void label_LONG_2INT(AbstractBURS_TreeNode p) { 3950 p.initCost(); 3951 AbstractBURS_TreeNode lchild; 3952 lchild = p.getChild1(); 3953 label(lchild); 3954 int c; 3955 // r: LONG_2INT(r) 3956 c = STATE(lchild).getCost(2 /* r */) + 10; 3957 if(BURS.DEBUG) trace(p, 179, c + 0, p.getCost(2) /* r */); 3958 if (c < p.getCost(2) /* r */) { 3959 p.setCost(2 /* r */, (char)(c)); 3960 p.writePacked(0, 0xFFFFC07F, 0x3600); // p.r = 108 3961 closure_r(p, c); 3962 } 3963 } 3964 3965 /** 3966 * Labels FLOAT_2INT tree node 3967 * @param p node to label 3968 */ 3969 private static void label_FLOAT_2INT(AbstractBURS_TreeNode p) { 3970 p.initCost(); 3971 AbstractBURS_TreeNode lchild; 3972 lchild = p.getChild1(); 3973 label(lchild); 3974 int c; 3975 // r: FLOAT_2INT(r) 3976 c = STATE(lchild).getCost(2 /* r */) + 10; 3977 if(BURS.DEBUG) trace(p, 145, c + 0, p.getCost(2) /* r */); 3978 if (c < p.getCost(2) /* r */) { 3979 p.setCost(2 /* r */, (char)(c)); 3980 p.writePacked(0, 0xFFFFC07F, 0x2280); // p.r = 69 3981 closure_r(p, c); 3982 } 3983 } 3984 3985 /** 3986 * Labels FLOAT_2LONG tree node 3987 * @param p node to label 3988 */ 3989 private static void label_FLOAT_2LONG(AbstractBURS_TreeNode p) { 3990 p.initCost(); 3991 AbstractBURS_TreeNode lchild; 3992 lchild = p.getChild1(); 3993 label(lchild); 3994 int c; 3995 // r: FLOAT_2LONG(r) 3996 c = STATE(lchild).getCost(2 /* r */) + 10; 3997 if(BURS.DEBUG) trace(p, 180, c + 0, p.getCost(2) /* r */); 3998 if (c < p.getCost(2) /* r */) { 3999 p.setCost(2 /* r */, (char)(c)); 4000 p.writePacked(0, 0xFFFFC07F, 0x3680); // p.r = 109 4001 closure_r(p, c); 4002 } 4003 } 4004 4005 /** 4006 * Labels FLOAT_2DOUBLE tree node 4007 * @param p node to label 4008 */ 4009 private static void label_FLOAT_2DOUBLE(AbstractBURS_TreeNode p) { 4010 p.initCost(); 4011 AbstractBURS_TreeNode lchild; 4012 lchild = p.getChild1(); 4013 label(lchild); 4014 int c; 4015 // r: FLOAT_2DOUBLE(r) 4016 c = STATE(lchild).getCost(2 /* r */) + 10; 4017 if(BURS.DEBUG) trace(p, 146, c + 0, p.getCost(2) /* r */); 4018 if (c < p.getCost(2) /* r */) { 4019 p.setCost(2 /* r */, (char)(c)); 4020 p.writePacked(0, 0xFFFFC07F, 0x2300); // p.r = 70 4021 closure_r(p, c); 4022 } 4023 } 4024 4025 /** 4026 * Labels DOUBLE_2INT tree node 4027 * @param p node to label 4028 */ 4029 private static void label_DOUBLE_2INT(AbstractBURS_TreeNode p) { 4030 p.initCost(); 4031 AbstractBURS_TreeNode lchild; 4032 lchild = p.getChild1(); 4033 label(lchild); 4034 int c; 4035 // r: DOUBLE_2INT(r) 4036 c = STATE(lchild).getCost(2 /* r */) + 10; 4037 if(BURS.DEBUG) trace(p, 147, c + 0, p.getCost(2) /* r */); 4038 if (c < p.getCost(2) /* r */) { 4039 p.setCost(2 /* r */, (char)(c)); 4040 p.writePacked(0, 0xFFFFC07F, 0x2380); // p.r = 71 4041 closure_r(p, c); 4042 } 4043 } 4044 4045 /** 4046 * Labels DOUBLE_2LONG tree node 4047 * @param p node to label 4048 */ 4049 private static void label_DOUBLE_2LONG(AbstractBURS_TreeNode p) { 4050 p.initCost(); 4051 AbstractBURS_TreeNode lchild; 4052 lchild = p.getChild1(); 4053 label(lchild); 4054 int c; 4055 // r: DOUBLE_2LONG(r) 4056 c = STATE(lchild).getCost(2 /* r */) + 10; 4057 if(BURS.DEBUG) trace(p, 181, c + 0, p.getCost(2) /* r */); 4058 if (c < p.getCost(2) /* r */) { 4059 p.setCost(2 /* r */, (char)(c)); 4060 p.writePacked(0, 0xFFFFC07F, 0x3700); // p.r = 110 4061 closure_r(p, c); 4062 } 4063 } 4064 4065 /** 4066 * Labels DOUBLE_2FLOAT tree node 4067 * @param p node to label 4068 */ 4069 private static void label_DOUBLE_2FLOAT(AbstractBURS_TreeNode p) { 4070 p.initCost(); 4071 AbstractBURS_TreeNode lchild; 4072 lchild = p.getChild1(); 4073 label(lchild); 4074 int c; 4075 // r: DOUBLE_2FLOAT(r) 4076 c = STATE(lchild).getCost(2 /* r */) + 10; 4077 if(BURS.DEBUG) trace(p, 148, c + 0, p.getCost(2) /* r */); 4078 if (c < p.getCost(2) /* r */) { 4079 p.setCost(2 /* r */, (char)(c)); 4080 p.writePacked(0, 0xFFFFC07F, 0x2400); // p.r = 72 4081 closure_r(p, c); 4082 } 4083 } 4084 4085 /** 4086 * Labels INT_2BYTE tree node 4087 * @param p node to label 4088 */ 4089 private static void label_INT_2BYTE(AbstractBURS_TreeNode p) { 4090 p.initCost(); 4091 AbstractBURS_TreeNode lchild; 4092 lchild = p.getChild1(); 4093 label(lchild); 4094 int c; 4095 // rs: INT_2BYTE(r) 4096 c = STATE(lchild).getCost(2 /* r */) + 10; 4097 if(BURS.DEBUG) trace(p, 140, c + 0, p.getCost(4) /* rs */); 4098 if (c < p.getCost(4) /* rs */) { 4099 p.setCost(4 /* rs */, (char)(c)); 4100 p.writePacked(0, 0xFFF07FFF, 0x20000); // p.rs = 4 4101 closure_rs(p, c); 4102 } 4103 } 4104 4105 /** 4106 * Labels INT_2USHORT tree node 4107 * @param p node to label 4108 */ 4109 private static void label_INT_2USHORT(AbstractBURS_TreeNode p) { 4110 p.initCost(); 4111 AbstractBURS_TreeNode lchild; 4112 lchild = p.getChild1(); 4113 label(lchild); 4114 int c; 4115 // rp: INT_2USHORT(r) 4116 c = STATE(lchild).getCost(2 /* r */) + 20; 4117 if(BURS.DEBUG) trace(p, 141, c + 0, p.getCost(6) /* rp */); 4118 if (c < p.getCost(6) /* rp */) { 4119 p.setCost(6 /* rp */, (char)(c)); 4120 p.writePacked(0, 0xF0FFFFFF, 0x9000000); // p.rp = 9 4121 closure_rp(p, c); 4122 } 4123 } 4124 4125 /** 4126 * Labels INT_2SHORT tree node 4127 * @param p node to label 4128 */ 4129 private static void label_INT_2SHORT(AbstractBURS_TreeNode p) { 4130 p.initCost(); 4131 AbstractBURS_TreeNode lchild; 4132 lchild = p.getChild1(); 4133 label(lchild); 4134 int c; 4135 // rs: INT_2SHORT(r) 4136 c = STATE(lchild).getCost(2 /* r */) + 10; 4137 if(BURS.DEBUG) trace(p, 142, c + 0, p.getCost(4) /* rs */); 4138 if (c < p.getCost(4) /* rs */) { 4139 p.setCost(4 /* rs */, (char)(c)); 4140 p.writePacked(0, 0xFFF07FFF, 0x28000); // p.rs = 5 4141 closure_rs(p, c); 4142 } 4143 } 4144 4145 /** 4146 * Labels LONG_CMP tree node 4147 * @param p node to label 4148 */ 4149 private static void label_LONG_CMP(AbstractBURS_TreeNode p) { 4150 p.initCost(); 4151 AbstractBURS_TreeNode lchild, rchild; 4152 lchild = p.getChild1(); 4153 rchild = p.getChild2(); 4154 label(lchild); 4155 label(rchild); 4156 int c; 4157 // r: LONG_CMP(r,r) 4158 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 40; 4159 if(BURS.DEBUG) trace(p, 91, c + 0, p.getCost(2) /* r */); 4160 if (c < p.getCost(2) /* r */) { 4161 p.setCost(2 /* r */, (char)(c)); 4162 p.writePacked(0, 0xFFFFC07F, 0x3980); // p.r = 115 4163 closure_r(p, c); 4164 } 4165 } 4166 4167 /** 4168 * Labels FLOAT_CMPL tree node 4169 * @param p node to label 4170 */ 4171 private static void label_FLOAT_CMPL(AbstractBURS_TreeNode p) { 4172 p.initCost(); 4173 AbstractBURS_TreeNode lchild, rchild; 4174 lchild = p.getChild1(); 4175 rchild = p.getChild2(); 4176 label(lchild); 4177 label(rchild); 4178 int c; 4179 // stm: FLOAT_CMPL(r,r) 4180 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 40; 4181 if(BURS.DEBUG) trace(p, 73, c + 0, p.getCost(1) /* stm */); 4182 if (c < p.getCost(1) /* stm */) { 4183 p.setCost(1 /* stm */, (char)(c)); 4184 p.writePacked(0, 0xFFFFFF80, 0x42); // p.stm = 66 4185 } 4186 } 4187 4188 /** 4189 * Labels FLOAT_CMPG tree node 4190 * @param p node to label 4191 */ 4192 private static void label_FLOAT_CMPG(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 // stm: FLOAT_CMPG(r,r) 4201 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 40; 4202 if(BURS.DEBUG) trace(p, 74, c + 0, p.getCost(1) /* stm */); 4203 if (c < p.getCost(1) /* stm */) { 4204 p.setCost(1 /* stm */, (char)(c)); 4205 p.writePacked(0, 0xFFFFFF80, 0x43); // p.stm = 67 4206 } 4207 } 4208 4209 /** 4210 * Labels DOUBLE_CMPL tree node 4211 * @param p node to label 4212 */ 4213 private static void label_DOUBLE_CMPL(AbstractBURS_TreeNode p) { 4214 p.initCost(); 4215 AbstractBURS_TreeNode lchild, rchild; 4216 lchild = p.getChild1(); 4217 rchild = p.getChild2(); 4218 label(lchild); 4219 label(rchild); 4220 int c; 4221 // stm: DOUBLE_CMPL(r,r) 4222 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 40; 4223 if(BURS.DEBUG) trace(p, 75, c + 0, p.getCost(1) /* stm */); 4224 if (c < p.getCost(1) /* stm */) { 4225 p.setCost(1 /* stm */, (char)(c)); 4226 p.writePacked(0, 0xFFFFFF80, 0x44); // p.stm = 68 4227 } 4228 } 4229 4230 /** 4231 * Labels DOUBLE_CMPG tree node 4232 * @param p node to label 4233 */ 4234 private static void label_DOUBLE_CMPG(AbstractBURS_TreeNode p) { 4235 p.initCost(); 4236 AbstractBURS_TreeNode lchild, rchild; 4237 lchild = p.getChild1(); 4238 rchild = p.getChild2(); 4239 label(lchild); 4240 label(rchild); 4241 int c; 4242 // stm: DOUBLE_CMPG(r,r) 4243 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 40; 4244 if(BURS.DEBUG) trace(p, 76, c + 0, p.getCost(1) /* stm */); 4245 if (c < p.getCost(1) /* stm */) { 4246 p.setCost(1 /* stm */, (char)(c)); 4247 p.writePacked(0, 0xFFFFFF80, 0x45); // p.stm = 69 4248 } 4249 } 4250 4251 /** 4252 * Labels RETURN tree node 4253 * @param p node to label 4254 */ 4255 private static void label_RETURN(AbstractBURS_TreeNode p) { 4256 p.initCost(); 4257 AbstractBURS_TreeNode lchild; 4258 lchild = p.getChild1(); 4259 label(lchild); 4260 int c; 4261 if ( // stm: RETURN(NULL) 4262 lchild.getOpcode() == NULL_opcode 4263 ) { 4264 c = 10; 4265 if(BURS.DEBUG) trace(p, 32, c + 0, p.getCost(1) /* stm */); 4266 if (c < p.getCost(1) /* stm */) { 4267 p.setCost(1 /* stm */, (char)(c)); 4268 p.writePacked(0, 0xFFFFFF80, 0x47); // p.stm = 71 4269 } 4270 } 4271 // stm: RETURN(r) 4272 c = STATE(lchild).getCost(2 /* r */) + 10; 4273 if(BURS.DEBUG) trace(p, 170, c + 0, p.getCost(1) /* stm */); 4274 if (c < p.getCost(1) /* stm */) { 4275 p.setCost(1 /* stm */, (char)(c)); 4276 p.writePacked(0, 0xFFFFFF80, 0x48); // p.stm = 72 4277 } 4278 } 4279 4280 /** 4281 * Labels NULL_CHECK tree node 4282 * @param p node to label 4283 */ 4284 private static void label_NULL_CHECK(AbstractBURS_TreeNode p) { 4285 p.initCost(); 4286 AbstractBURS_TreeNode lchild; 4287 lchild = p.getChild1(); 4288 label(lchild); 4289 int c; 4290 // stm: NULL_CHECK(r) 4291 c = STATE(lchild).getCost(2 /* r */) + 11; 4292 if(BURS.DEBUG) trace(p, 97, c + 0, p.getCost(1) /* stm */); 4293 if (c < p.getCost(1) /* stm */) { 4294 p.setCost(1 /* stm */, (char)(c)); 4295 p.writePacked(0, 0xFFFFFF80, 0xB); // p.stm = 11 4296 } 4297 } 4298 4299 /** 4300 * Labels GOTO tree node 4301 * @param p node to label 4302 */ 4303 private static void label_GOTO(AbstractBURS_TreeNode p) { 4304 p.initCost(); 4305 // stm: GOTO 4306 if(BURS.DEBUG) trace(p, 31, 11 + 0, p.getCost(1) /* stm */); 4307 if (11 < p.getCost(1) /* stm */) { 4308 p.setCost(1 /* stm */, (char)(11)); 4309 p.writePacked(0, 0xFFFFFF80, 0x46); // p.stm = 70 4310 } 4311 } 4312 4313 /** 4314 * Labels BOOLEAN_NOT tree node 4315 * @param p node to label 4316 */ 4317 private static void label_BOOLEAN_NOT(AbstractBURS_TreeNode p) { 4318 p.initCost(); 4319 AbstractBURS_TreeNode lchild; 4320 lchild = p.getChild1(); 4321 label(lchild); 4322 int c; 4323 // r: BOOLEAN_NOT(r) 4324 c = STATE(lchild).getCost(2 /* r */) + 11; 4325 if(BURS.DEBUG) trace(p, 108, c + 0, p.getCost(2) /* r */); 4326 if (c < p.getCost(2) /* r */) { 4327 p.setCost(2 /* r */, (char)(c)); 4328 p.writePacked(0, 0xFFFFC07F, 0x400); // p.r = 8 4329 closure_r(p, c); 4330 } 4331 } 4332 4333 /** 4334 * Labels BOOLEAN_CMP_INT tree node 4335 * @param p node to label 4336 */ 4337 private static void label_BOOLEAN_CMP_INT(AbstractBURS_TreeNode p) { 4338 p.initCost(); 4339 AbstractBURS_TreeNode lchild, rchild; 4340 lchild = p.getChild1(); 4341 rchild = p.getChild2(); 4342 label(lchild); 4343 label(rchild); 4344 int c; 4345 if ( // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 4346 rchild.getOpcode() == INT_CONSTANT_opcode 4347 ) { 4348 c = STATE(lchild).getCost(2 /* r */) + 10; 4349 if(BURS.DEBUG) trace(p, 109, c + 0, p.getCost(2) /* r */); 4350 if (c < p.getCost(2) /* r */) { 4351 p.setCost(2 /* r */, (char)(c)); 4352 p.writePacked(0, 0xFFFFC07F, 0x480); // p.r = 9 4353 closure_r(p, c); 4354 } 4355 } 4356 // r: BOOLEAN_CMP_INT(r,r) 4357 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 4358 if(BURS.DEBUG) trace(p, 39, c + 0, p.getCost(2) /* r */); 4359 if (c < p.getCost(2) /* r */) { 4360 p.setCost(2 /* r */, (char)(c)); 4361 p.writePacked(0, 0xFFFFC07F, 0x500); // p.r = 10 4362 closure_r(p, c); 4363 } 4364 if ( // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 4365 rchild.getOpcode() == INT_CONSTANT_opcode 4366 ) { 4367 c = STATE(lchild).getCost(2 /* r */) + 0; 4368 if(BURS.DEBUG) trace(p, 110, c + 0, p.getCost(8) /* boolcmp */); 4369 if (c < p.getCost(8) /* boolcmp */) { 4370 p.setCost(8 /* boolcmp */, (char)(c)); 4371 p.writePacked(1, 0xFFFFFFF0, 0x1); // p.boolcmp = 1 4372 } 4373 } 4374 // boolcmp: BOOLEAN_CMP_INT(r,r) 4375 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 4376 if(BURS.DEBUG) trace(p, 40, c + 0, p.getCost(8) /* boolcmp */); 4377 if (c < p.getCost(8) /* boolcmp */) { 4378 p.setCost(8 /* boolcmp */, (char)(c)); 4379 p.writePacked(1, 0xFFFFFFF0, 0x2); // p.boolcmp = 2 4380 } 4381 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4382 rchild.getOpcode() == INT_CONSTANT_opcode 4383 ) { 4384 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && BooleanCmp.getCond(P(p)).isEQUAL()?0:INFINITE); 4385 if(BURS.DEBUG) trace(p, 113, c + 0, p.getCost(8) /* boolcmp */); 4386 if (c < p.getCost(8) /* boolcmp */) { 4387 p.setCost(8 /* boolcmp */, (char)(c)); 4388 p.writePacked(1, 0xFFFFFFF0, 0x5); // p.boolcmp = 5 4389 } 4390 } 4391 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4392 rchild.getOpcode() == INT_CONSTANT_opcode 4393 ) { 4394 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()?0:INFINITE); 4395 if(BURS.DEBUG) trace(p, 114, c + 0, p.getCost(8) /* boolcmp */); 4396 if (c < p.getCost(8) /* boolcmp */) { 4397 p.setCost(8 /* boolcmp */, (char)(c)); 4398 p.writePacked(1, 0xFFFFFFF0, 0x6); // p.boolcmp = 6 4399 } 4400 } 4401 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4402 rchild.getOpcode() == INT_CONSTANT_opcode 4403 ) { 4404 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()?0:INFINITE); 4405 if(BURS.DEBUG) trace(p, 115, c + 0, p.getCost(8) /* boolcmp */); 4406 if (c < p.getCost(8) /* boolcmp */) { 4407 p.setCost(8 /* boolcmp */, (char)(c)); 4408 p.writePacked(1, 0xFFFFFFF0, 0x7); // p.boolcmp = 7 4409 } 4410 } 4411 if ( // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4412 rchild.getOpcode() == INT_CONSTANT_opcode 4413 ) { 4414 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isEQUAL()?0:INFINITE); 4415 if(BURS.DEBUG) trace(p, 116, c + 0, p.getCost(8) /* boolcmp */); 4416 if (c < p.getCost(8) /* boolcmp */) { 4417 p.setCost(8 /* boolcmp */, (char)(c)); 4418 p.writePacked(1, 0xFFFFFFF0, 0x8); // p.boolcmp = 8 4419 } 4420 } 4421 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4422 rchild.getOpcode() == INT_CONSTANT_opcode 4423 ) { 4424 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && BooleanCmp.getCond(P(p)).isEQUAL()?10:INFINITE); 4425 if(BURS.DEBUG) trace(p, 117, c + 0, p.getCost(2) /* r */); 4426 if (c < p.getCost(2) /* r */) { 4427 p.setCost(2 /* r */, (char)(c)); 4428 p.writePacked(0, 0xFFFFC07F, 0x680); // p.r = 13 4429 closure_r(p, c); 4430 } 4431 } 4432 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4433 rchild.getOpcode() == INT_CONSTANT_opcode 4434 ) { 4435 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 1 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()?10:INFINITE); 4436 if(BURS.DEBUG) trace(p, 118, c + 0, p.getCost(2) /* r */); 4437 if (c < p.getCost(2) /* r */) { 4438 p.setCost(2 /* r */, (char)(c)); 4439 p.writePacked(0, 0xFFFFC07F, 0x700); // p.r = 14 4440 closure_r(p, c); 4441 } 4442 } 4443 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4444 rchild.getOpcode() == INT_CONSTANT_opcode 4445 ) { 4446 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isNOT_EQUAL()?10:INFINITE); 4447 if(BURS.DEBUG) trace(p, 119, c + 0, p.getCost(2) /* r */); 4448 if (c < p.getCost(2) /* r */) { 4449 p.setCost(2 /* r */, (char)(c)); 4450 p.writePacked(0, 0xFFFFC07F, 0x780); // p.r = 15 4451 closure_r(p, c); 4452 } 4453 } 4454 if ( // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 4455 rchild.getOpcode() == INT_CONSTANT_opcode 4456 ) { 4457 c = STATE(lchild).getCost(8 /* boolcmp */) + (VR(p) == 0 && BooleanCmp.getCond(P(p)).isEQUAL()?10:INFINITE); 4458 if(BURS.DEBUG) trace(p, 120, c + 0, p.getCost(2) /* r */); 4459 if (c < p.getCost(2) /* r */) { 4460 p.setCost(2 /* r */, (char)(c)); 4461 p.writePacked(0, 0xFFFFC07F, 0x800); // p.r = 16 4462 closure_r(p, c); 4463 } 4464 } 4465 } 4466 4467 /** 4468 * Labels BOOLEAN_CMP_ADDR tree node 4469 * @param p node to label 4470 */ 4471 private static void label_BOOLEAN_CMP_ADDR(AbstractBURS_TreeNode p) { 4472 p.initCost(); 4473 AbstractBURS_TreeNode lchild, rchild; 4474 lchild = p.getChild1(); 4475 rchild = p.getChild2(); 4476 label(lchild); 4477 label(rchild); 4478 int c; 4479 if ( // r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 4480 rchild.getOpcode() == INT_CONSTANT_opcode 4481 ) { 4482 c = STATE(lchild).getCost(2 /* r */) + 10; 4483 if(BURS.DEBUG) trace(p, 111, c + 0, p.getCost(2) /* r */); 4484 if (c < p.getCost(2) /* r */) { 4485 p.setCost(2 /* r */, (char)(c)); 4486 p.writePacked(0, 0xFFFFC07F, 0x580); // p.r = 11 4487 closure_r(p, c); 4488 } 4489 } 4490 // r: BOOLEAN_CMP_ADDR(r,r) 4491 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 4492 if(BURS.DEBUG) trace(p, 41, c + 0, p.getCost(2) /* r */); 4493 if (c < p.getCost(2) /* r */) { 4494 p.setCost(2 /* r */, (char)(c)); 4495 p.writePacked(0, 0xFFFFC07F, 0x600); // p.r = 12 4496 closure_r(p, c); 4497 } 4498 if ( // boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 4499 rchild.getOpcode() == INT_CONSTANT_opcode 4500 ) { 4501 c = STATE(lchild).getCost(2 /* r */) + 0; 4502 if(BURS.DEBUG) trace(p, 112, c + 0, p.getCost(8) /* boolcmp */); 4503 if (c < p.getCost(8) /* boolcmp */) { 4504 p.setCost(8 /* boolcmp */, (char)(c)); 4505 p.writePacked(1, 0xFFFFFFF0, 0x3); // p.boolcmp = 3 4506 } 4507 } 4508 // boolcmp: BOOLEAN_CMP_ADDR(r,r) 4509 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 4510 if(BURS.DEBUG) trace(p, 42, c + 0, p.getCost(8) /* boolcmp */); 4511 if (c < p.getCost(8) /* boolcmp */) { 4512 p.setCost(8 /* boolcmp */, (char)(c)); 4513 p.writePacked(1, 0xFFFFFFF0, 0x4); // p.boolcmp = 4 4514 } 4515 } 4516 4517 /** 4518 * Labels BYTE_LOAD tree node 4519 * @param p node to label 4520 */ 4521 private static void label_BYTE_LOAD(AbstractBURS_TreeNode p) { 4522 p.initCost(); 4523 AbstractBURS_TreeNode lchild, rchild; 4524 lchild = p.getChild1(); 4525 rchild = p.getChild2(); 4526 label(lchild); 4527 label(rchild); 4528 int c; 4529 if ( // rs: BYTE_LOAD(r,INT_CONSTANT) 4530 rchild.getOpcode() == INT_CONSTANT_opcode 4531 ) { 4532 c = STATE(lchild).getCost(2 /* r */) + 22; 4533 if(BURS.DEBUG) trace(p, 154, c + 0, p.getCost(4) /* rs */); 4534 if (c < p.getCost(4) /* rs */) { 4535 p.setCost(4 /* rs */, (char)(c)); 4536 p.writePacked(0, 0xFFF07FFF, 0x48000); // p.rs = 9 4537 closure_rs(p, c); 4538 } 4539 } 4540 // rs: BYTE_LOAD(r,r) 4541 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 22; 4542 if(BURS.DEBUG) trace(p, 62, c + 0, p.getCost(4) /* rs */); 4543 if (c < p.getCost(4) /* rs */) { 4544 p.setCost(4 /* rs */, (char)(c)); 4545 p.writePacked(0, 0xFFF07FFF, 0x50000); // p.rs = 10 4546 closure_rs(p, c); 4547 } 4548 } 4549 4550 /** 4551 * Labels UBYTE_LOAD tree node 4552 * @param p node to label 4553 */ 4554 private static void label_UBYTE_LOAD(AbstractBURS_TreeNode p) { 4555 p.initCost(); 4556 AbstractBURS_TreeNode lchild, rchild; 4557 lchild = p.getChild1(); 4558 rchild = p.getChild2(); 4559 label(lchild); 4560 label(rchild); 4561 int c; 4562 if ( // rp: UBYTE_LOAD(r,INT_CONSTANT) 4563 rchild.getOpcode() == INT_CONSTANT_opcode 4564 ) { 4565 c = STATE(lchild).getCost(2 /* r */) + 11; 4566 if(BURS.DEBUG) trace(p, 155, c + 0, p.getCost(6) /* rp */); 4567 if (c < p.getCost(6) /* rp */) { 4568 p.setCost(6 /* rp */, (char)(c)); 4569 p.writePacked(0, 0xF0FFFFFF, 0xC000000); // p.rp = 12 4570 closure_rp(p, c); 4571 } 4572 } 4573 // rp: UBYTE_LOAD(r,r) 4574 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4575 if(BURS.DEBUG) trace(p, 63, c + 0, p.getCost(6) /* rp */); 4576 if (c < p.getCost(6) /* rp */) { 4577 p.setCost(6 /* rp */, (char)(c)); 4578 p.writePacked(0, 0xF0FFFFFF, 0xD000000); // p.rp = 13 4579 closure_rp(p, c); 4580 } 4581 } 4582 4583 /** 4584 * Labels SHORT_LOAD tree node 4585 * @param p node to label 4586 */ 4587 private static void label_SHORT_LOAD(AbstractBURS_TreeNode p) { 4588 p.initCost(); 4589 AbstractBURS_TreeNode lchild, rchild; 4590 lchild = p.getChild1(); 4591 rchild = p.getChild2(); 4592 label(lchild); 4593 label(rchild); 4594 int c; 4595 if ( // rs: SHORT_LOAD(r,INT_CONSTANT) 4596 rchild.getOpcode() == INT_CONSTANT_opcode 4597 ) { 4598 c = STATE(lchild).getCost(2 /* r */) + 11; 4599 if(BURS.DEBUG) trace(p, 156, c + 0, p.getCost(4) /* rs */); 4600 if (c < p.getCost(4) /* rs */) { 4601 p.setCost(4 /* rs */, (char)(c)); 4602 p.writePacked(0, 0xFFF07FFF, 0x58000); // p.rs = 11 4603 closure_rs(p, c); 4604 } 4605 } 4606 // rs: SHORT_LOAD(r,r) 4607 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4608 if(BURS.DEBUG) trace(p, 64, c + 0, p.getCost(4) /* rs */); 4609 if (c < p.getCost(4) /* rs */) { 4610 p.setCost(4 /* rs */, (char)(c)); 4611 p.writePacked(0, 0xFFF07FFF, 0x60000); // p.rs = 12 4612 closure_rs(p, c); 4613 } 4614 } 4615 4616 /** 4617 * Labels USHORT_LOAD tree node 4618 * @param p node to label 4619 */ 4620 private static void label_USHORT_LOAD(AbstractBURS_TreeNode p) { 4621 p.initCost(); 4622 AbstractBURS_TreeNode lchild, rchild; 4623 lchild = p.getChild1(); 4624 rchild = p.getChild2(); 4625 label(lchild); 4626 label(rchild); 4627 int c; 4628 if ( // rp: USHORT_LOAD(r,INT_CONSTANT) 4629 rchild.getOpcode() == INT_CONSTANT_opcode 4630 ) { 4631 c = STATE(lchild).getCost(2 /* r */) + 11; 4632 if(BURS.DEBUG) trace(p, 157, c + 0, p.getCost(6) /* rp */); 4633 if (c < p.getCost(6) /* rp */) { 4634 p.setCost(6 /* rp */, (char)(c)); 4635 p.writePacked(0, 0xF0FFFFFF, 0xE000000); // p.rp = 14 4636 closure_rp(p, c); 4637 } 4638 } 4639 // rp: USHORT_LOAD(r,r) 4640 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4641 if(BURS.DEBUG) trace(p, 65, c + 0, p.getCost(6) /* rp */); 4642 if (c < p.getCost(6) /* rp */) { 4643 p.setCost(6 /* rp */, (char)(c)); 4644 p.writePacked(0, 0xF0FFFFFF, 0xF000000); // p.rp = 15 4645 closure_rp(p, c); 4646 } 4647 } 4648 4649 /** 4650 * Labels INT_LOAD tree node 4651 * @param p node to label 4652 */ 4653 private static void label_INT_LOAD(AbstractBURS_TreeNode p) { 4654 p.initCost(); 4655 AbstractBURS_TreeNode lchild, rchild; 4656 lchild = p.getChild1(); 4657 rchild = p.getChild2(); 4658 label(lchild); 4659 label(rchild); 4660 int c; 4661 if ( // rs: INT_LOAD(r,INT_CONSTANT) 4662 rchild.getOpcode() == INT_CONSTANT_opcode 4663 ) { 4664 c = STATE(lchild).getCost(2 /* r */) + 11; 4665 if(BURS.DEBUG) trace(p, 162, c + 0, p.getCost(4) /* rs */); 4666 if (c < p.getCost(4) /* rs */) { 4667 p.setCost(4 /* rs */, (char)(c)); 4668 p.writePacked(0, 0xFFF07FFF, 0x68000); // p.rs = 13 4669 closure_rs(p, c); 4670 } 4671 } 4672 if ( // rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 4673 rchild.getOpcode() == REF_MOVE_opcode && 4674 rchild.getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 4675 ) { 4676 c = STATE(lchild).getCost(2 /* r */) + FITS(Move.getVal(PR(p)),32,22); 4677 if(BURS.DEBUG) trace(p, 163, c + 0, p.getCost(4) /* rs */); 4678 if (c < p.getCost(4) /* rs */) { 4679 p.setCost(4 /* rs */, (char)(c)); 4680 p.writePacked(0, 0xFFF07FFF, 0x70000); // p.rs = 14 4681 closure_rs(p, c); 4682 } 4683 } 4684 // rs: INT_LOAD(r,r) 4685 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4686 if(BURS.DEBUG) trace(p, 68, c + 0, p.getCost(4) /* rs */); 4687 if (c < p.getCost(4) /* rs */) { 4688 p.setCost(4 /* rs */, (char)(c)); 4689 p.writePacked(0, 0xFFF07FFF, 0x78000); // p.rs = 15 4690 closure_rs(p, c); 4691 } 4692 if ( // rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 4693 lchild.getOpcode() == REF_ADD_opcode && 4694 rchild.getOpcode() == INT_CONSTANT_opcode 4695 ) { 4696 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + isZERO(VR(p), 11); 4697 if(BURS.DEBUG) trace(p, 232, c + 0, p.getCost(4) /* rs */); 4698 if (c < p.getCost(4) /* rs */) { 4699 p.setCost(4 /* rs */, (char)(c)); 4700 p.writePacked(0, 0xFFF07FFF, 0x80000); // p.rs = 16 4701 closure_rs(p, c); 4702 } 4703 } 4704 if ( // rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 4705 lchild.getOpcode() == REF_ADD_opcode && 4706 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4707 rchild.getOpcode() == INT_CONSTANT_opcode 4708 ) { 4709 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (SI16(VR(p)+VLR(p)) ? 14 : INFINITE); 4710 if(BURS.DEBUG) trace(p, 200, c + 0, p.getCost(4) /* rs */); 4711 if (c < p.getCost(4) /* rs */) { 4712 p.setCost(4 /* rs */, (char)(c)); 4713 p.writePacked(0, 0xFFF07FFF, 0x88000); // p.rs = 17 4714 closure_rs(p, c); 4715 } 4716 } 4717 } 4718 4719 /** 4720 * Labels LONG_LOAD tree node 4721 * @param p node to label 4722 */ 4723 private static void label_LONG_LOAD(AbstractBURS_TreeNode p) { 4724 p.initCost(); 4725 AbstractBURS_TreeNode lchild, rchild; 4726 lchild = p.getChild1(); 4727 rchild = p.getChild2(); 4728 label(lchild); 4729 label(rchild); 4730 int c; 4731 if ( // r: LONG_LOAD(r,INT_CONSTANT) 4732 rchild.getOpcode() == INT_CONSTANT_opcode 4733 ) { 4734 c = STATE(lchild).getCost(2 /* r */) + 11; 4735 if(BURS.DEBUG) trace(p, 188, c + 0, p.getCost(2) /* r */); 4736 if (c < p.getCost(2) /* r */) { 4737 p.setCost(2 /* r */, (char)(c)); 4738 p.writePacked(0, 0xFFFFC07F, 0x3A00); // p.r = 116 4739 closure_r(p, c); 4740 } 4741 } 4742 if ( // r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 4743 rchild.getOpcode() == REF_MOVE_opcode && 4744 rchild.getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 4745 ) { 4746 c = STATE(lchild).getCost(2 /* r */) + FITS(Move.getVal(PR(p)),32,22); 4747 if(BURS.DEBUG) trace(p, 189, c + 0, p.getCost(2) /* r */); 4748 if (c < p.getCost(2) /* r */) { 4749 p.setCost(2 /* r */, (char)(c)); 4750 p.writePacked(0, 0xFFFFC07F, 0x3A80); // p.r = 117 4751 closure_r(p, c); 4752 } 4753 } 4754 // r: LONG_LOAD(r,r) 4755 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4756 if(BURS.DEBUG) trace(p, 93, c + 0, p.getCost(2) /* r */); 4757 if (c < p.getCost(2) /* r */) { 4758 p.setCost(2 /* r */, (char)(c)); 4759 p.writePacked(0, 0xFFFFC07F, 0x3B00); // p.r = 118 4760 closure_r(p, c); 4761 } 4762 if ( // r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 4763 lchild.getOpcode() == REF_ADD_opcode && 4764 rchild.getOpcode() == INT_CONSTANT_opcode 4765 ) { 4766 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(lchild.getChild2()).getCost(2 /* r */) + isZERO(VR(p), 11); 4767 if(BURS.DEBUG) trace(p, 239, c + 0, p.getCost(2) /* r */); 4768 if (c < p.getCost(2) /* r */) { 4769 p.setCost(2 /* r */, (char)(c)); 4770 p.writePacked(0, 0xFFFFC07F, 0x3B80); // p.r = 119 4771 closure_r(p, c); 4772 } 4773 } 4774 if ( // r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 4775 lchild.getOpcode() == REF_ADD_opcode && 4776 lchild.getChild2().getOpcode() == INT_CONSTANT_opcode && 4777 rchild.getOpcode() == INT_CONSTANT_opcode 4778 ) { 4779 c = STATE(lchild.getChild1()).getCost(2 /* r */) + (SI16(VR(p)+VLR(p)) ? 14 : INFINITE); 4780 if(BURS.DEBUG) trace(p, 210, c + 0, p.getCost(2) /* r */); 4781 if (c < p.getCost(2) /* r */) { 4782 p.setCost(2 /* r */, (char)(c)); 4783 p.writePacked(0, 0xFFFFC07F, 0x3C00); // p.r = 120 4784 closure_r(p, c); 4785 } 4786 } 4787 } 4788 4789 /** 4790 * Labels FLOAT_LOAD tree node 4791 * @param p node to label 4792 */ 4793 private static void label_FLOAT_LOAD(AbstractBURS_TreeNode p) { 4794 p.initCost(); 4795 AbstractBURS_TreeNode lchild, rchild; 4796 lchild = p.getChild1(); 4797 rchild = p.getChild2(); 4798 label(lchild); 4799 label(rchild); 4800 int c; 4801 if ( // r: FLOAT_LOAD(r,INT_CONSTANT) 4802 rchild.getOpcode() == INT_CONSTANT_opcode 4803 ) { 4804 c = STATE(lchild).getCost(2 /* r */) + 11; 4805 if(BURS.DEBUG) trace(p, 158, c + 0, p.getCost(2) /* r */); 4806 if (c < p.getCost(2) /* r */) { 4807 p.setCost(2 /* r */, (char)(c)); 4808 p.writePacked(0, 0xFFFFC07F, 0x2700); // p.r = 78 4809 closure_r(p, c); 4810 } 4811 } 4812 if ( // r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 4813 rchild.getOpcode() == REF_MOVE_opcode && 4814 rchild.getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 4815 ) { 4816 c = STATE(lchild).getCost(2 /* r */) + FITS(Move.getVal(PR(p)),32,22); 4817 if(BURS.DEBUG) trace(p, 159, c + 0, p.getCost(2) /* r */); 4818 if (c < p.getCost(2) /* r */) { 4819 p.setCost(2 /* r */, (char)(c)); 4820 p.writePacked(0, 0xFFFFC07F, 0x2780); // p.r = 79 4821 closure_r(p, c); 4822 } 4823 } 4824 // r: FLOAT_LOAD(r,r) 4825 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4826 if(BURS.DEBUG) trace(p, 66, c + 0, p.getCost(2) /* r */); 4827 if (c < p.getCost(2) /* r */) { 4828 p.setCost(2 /* r */, (char)(c)); 4829 p.writePacked(0, 0xFFFFC07F, 0x2800); // p.r = 80 4830 closure_r(p, c); 4831 } 4832 } 4833 4834 /** 4835 * Labels DOUBLE_LOAD tree node 4836 * @param p node to label 4837 */ 4838 private static void label_DOUBLE_LOAD(AbstractBURS_TreeNode p) { 4839 p.initCost(); 4840 AbstractBURS_TreeNode lchild, rchild; 4841 lchild = p.getChild1(); 4842 rchild = p.getChild2(); 4843 label(lchild); 4844 label(rchild); 4845 int c; 4846 if ( // r: DOUBLE_LOAD(r,INT_CONSTANT) 4847 rchild.getOpcode() == INT_CONSTANT_opcode 4848 ) { 4849 c = STATE(lchild).getCost(2 /* r */) + 11; 4850 if(BURS.DEBUG) trace(p, 160, c + 0, p.getCost(2) /* r */); 4851 if (c < p.getCost(2) /* r */) { 4852 p.setCost(2 /* r */, (char)(c)); 4853 p.writePacked(0, 0xFFFFC07F, 0x2880); // p.r = 81 4854 closure_r(p, c); 4855 } 4856 } 4857 if ( // r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 4858 rchild.getOpcode() == REF_MOVE_opcode && 4859 rchild.getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 4860 ) { 4861 c = STATE(lchild).getCost(2 /* r */) + FITS(Move.getVal(PR(p)),32,22); 4862 if(BURS.DEBUG) trace(p, 161, c + 0, p.getCost(2) /* r */); 4863 if (c < p.getCost(2) /* r */) { 4864 p.setCost(2 /* r */, (char)(c)); 4865 p.writePacked(0, 0xFFFFC07F, 0x2900); // p.r = 82 4866 closure_r(p, c); 4867 } 4868 } 4869 // r: DOUBLE_LOAD(r,r) 4870 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 4871 if(BURS.DEBUG) trace(p, 67, c + 0, p.getCost(2) /* r */); 4872 if (c < p.getCost(2) /* r */) { 4873 p.setCost(2 /* r */, (char)(c)); 4874 p.writePacked(0, 0xFFFFC07F, 0x2980); // p.r = 83 4875 closure_r(p, c); 4876 } 4877 } 4878 4879 /** 4880 * Labels BYTE_STORE tree node 4881 * @param p node to label 4882 */ 4883 private static void label_BYTE_STORE(AbstractBURS_TreeNode p) { 4884 p.initCost(); 4885 AbstractBURS_TreeNode lchild, rchild; 4886 lchild = p.getChild1(); 4887 rchild = p.getChild2(); 4888 label(lchild); 4889 label(rchild); 4890 int c; 4891 if ( // stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 4892 rchild.getOpcode() == OTHER_OPERAND_opcode && 4893 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 4894 ) { 4895 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 4896 if(BURS.DEBUG) trace(p, 218, c + 0, p.getCost(1) /* stm */); 4897 if (c < p.getCost(1) /* stm */) { 4898 p.setCost(1 /* stm */, (char)(c)); 4899 p.writePacked(0, 0xFFFFFF80, 0x1B); // p.stm = 27 4900 } 4901 } 4902 if ( // stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 4903 rchild.getOpcode() == OTHER_OPERAND_opcode 4904 ) { 4905 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 4906 if(BURS.DEBUG) trace(p, 246, c + 0, p.getCost(1) /* stm */); 4907 if (c < p.getCost(1) /* stm */) { 4908 p.setCost(1 /* stm */, (char)(c)); 4909 p.writePacked(0, 0xFFFFFF80, 0x1C); // p.stm = 28 4910 } 4911 } 4912 if ( // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 4913 lchild.getOpcode() == INT_2BYTE_opcode && 4914 rchild.getOpcode() == OTHER_OPERAND_opcode && 4915 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 4916 ) { 4917 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 4918 if(BURS.DEBUG) trace(p, 213, c + 0, p.getCost(1) /* stm */); 4919 if (c < p.getCost(1) /* stm */) { 4920 p.setCost(1 /* stm */, (char)(c)); 4921 p.writePacked(0, 0xFFFFFF80, 0x1D); // p.stm = 29 4922 } 4923 } 4924 if ( // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 4925 lchild.getOpcode() == INT_2BYTE_opcode && 4926 rchild.getOpcode() == OTHER_OPERAND_opcode 4927 ) { 4928 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 4929 if(BURS.DEBUG) trace(p, 258, c + 0, p.getCost(1) /* stm */); 4930 if (c < p.getCost(1) /* stm */) { 4931 p.setCost(1 /* stm */, (char)(c)); 4932 p.writePacked(0, 0xFFFFFF80, 0x1E); // p.stm = 30 4933 } 4934 } 4935 } 4936 4937 /** 4938 * Labels SHORT_STORE tree node 4939 * @param p node to label 4940 */ 4941 private static void label_SHORT_STORE(AbstractBURS_TreeNode p) { 4942 p.initCost(); 4943 AbstractBURS_TreeNode lchild, rchild; 4944 lchild = p.getChild1(); 4945 rchild = p.getChild2(); 4946 label(lchild); 4947 label(rchild); 4948 int c; 4949 if ( // stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 4950 rchild.getOpcode() == OTHER_OPERAND_opcode && 4951 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 4952 ) { 4953 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 4954 if(BURS.DEBUG) trace(p, 219, c + 0, p.getCost(1) /* stm */); 4955 if (c < p.getCost(1) /* stm */) { 4956 p.setCost(1 /* stm */, (char)(c)); 4957 p.writePacked(0, 0xFFFFFF80, 0x1F); // p.stm = 31 4958 } 4959 } 4960 if ( // stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 4961 rchild.getOpcode() == OTHER_OPERAND_opcode 4962 ) { 4963 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 4964 if(BURS.DEBUG) trace(p, 247, c + 0, p.getCost(1) /* stm */); 4965 if (c < p.getCost(1) /* stm */) { 4966 p.setCost(1 /* stm */, (char)(c)); 4967 p.writePacked(0, 0xFFFFFF80, 0x20); // p.stm = 32 4968 } 4969 } 4970 if ( // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 4971 lchild.getOpcode() == INT_2SHORT_opcode && 4972 rchild.getOpcode() == OTHER_OPERAND_opcode && 4973 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 4974 ) { 4975 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 4976 if(BURS.DEBUG) trace(p, 214, c + 0, p.getCost(1) /* stm */); 4977 if (c < p.getCost(1) /* stm */) { 4978 p.setCost(1 /* stm */, (char)(c)); 4979 p.writePacked(0, 0xFFFFFF80, 0x21); // p.stm = 33 4980 } 4981 } 4982 if ( // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 4983 lchild.getOpcode() == INT_2SHORT_opcode && 4984 rchild.getOpcode() == OTHER_OPERAND_opcode 4985 ) { 4986 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 4987 if(BURS.DEBUG) trace(p, 259, c + 0, p.getCost(1) /* stm */); 4988 if (c < p.getCost(1) /* stm */) { 4989 p.setCost(1 /* stm */, (char)(c)); 4990 p.writePacked(0, 0xFFFFFF80, 0x22); // p.stm = 34 4991 } 4992 } 4993 if ( // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 4994 lchild.getOpcode() == INT_2USHORT_opcode && 4995 rchild.getOpcode() == OTHER_OPERAND_opcode && 4996 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 4997 ) { 4998 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 4999 if(BURS.DEBUG) trace(p, 215, c + 0, p.getCost(1) /* stm */); 5000 if (c < p.getCost(1) /* stm */) { 5001 p.setCost(1 /* stm */, (char)(c)); 5002 p.writePacked(0, 0xFFFFFF80, 0x23); // p.stm = 35 5003 } 5004 } 5005 if ( // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 5006 lchild.getOpcode() == INT_2USHORT_opcode && 5007 rchild.getOpcode() == OTHER_OPERAND_opcode 5008 ) { 5009 c = STATE(lchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 5010 if(BURS.DEBUG) trace(p, 260, c + 0, p.getCost(1) /* stm */); 5011 if (c < p.getCost(1) /* stm */) { 5012 p.setCost(1 /* stm */, (char)(c)); 5013 p.writePacked(0, 0xFFFFFF80, 0x24); // p.stm = 36 5014 } 5015 } 5016 } 5017 5018 /** 5019 * Labels INT_STORE tree node 5020 * @param p node to label 5021 */ 5022 private static void label_INT_STORE(AbstractBURS_TreeNode p) { 5023 p.initCost(); 5024 AbstractBURS_TreeNode lchild, rchild; 5025 lchild = p.getChild1(); 5026 rchild = p.getChild2(); 5027 label(lchild); 5028 label(rchild); 5029 int c; 5030 if ( // stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 5031 rchild.getOpcode() == OTHER_OPERAND_opcode && 5032 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5033 ) { 5034 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 5035 if(BURS.DEBUG) trace(p, 220, c + 0, p.getCost(1) /* stm */); 5036 if (c < p.getCost(1) /* stm */) { 5037 p.setCost(1 /* stm */, (char)(c)); 5038 p.writePacked(0, 0xFFFFFF80, 0x25); // p.stm = 37 5039 } 5040 } 5041 if ( // stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 5042 rchild.getOpcode() == OTHER_OPERAND_opcode && 5043 rchild.getChild2().getOpcode() == REF_MOVE_opcode && 5044 rchild.getChild2().getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 5045 ) { 5046 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + FITS(Move.getVal(PRR(p)),32,22); 5047 if(BURS.DEBUG) trace(p, 221, c + 0, p.getCost(1) /* stm */); 5048 if (c < p.getCost(1) /* stm */) { 5049 p.setCost(1 /* stm */, (char)(c)); 5050 p.writePacked(0, 0xFFFFFF80, 0x26); // p.stm = 38 5051 } 5052 } 5053 if ( // stm: INT_STORE(r,OTHER_OPERAND(r,r)) 5054 rchild.getOpcode() == OTHER_OPERAND_opcode 5055 ) { 5056 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 5057 if(BURS.DEBUG) trace(p, 248, c + 0, p.getCost(1) /* stm */); 5058 if (c < p.getCost(1) /* stm */) { 5059 p.setCost(1 /* stm */, (char)(c)); 5060 p.writePacked(0, 0xFFFFFF80, 0x27); // p.stm = 39 5061 } 5062 } 5063 if ( // stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 5064 rchild.getOpcode() == OTHER_OPERAND_opcode && 5065 rchild.getChild1().getOpcode() == REF_ADD_opcode && 5066 rchild.getChild1().getChild2().getOpcode() == INT_CONSTANT_opcode && 5067 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5068 ) { 5069 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1().getChild1()).getCost(2 /* r */) + (SI16(VRR(p)+VRLR(p))?14:INFINITE); 5070 if(BURS.DEBUG) trace(p, 261, c + 0, p.getCost(1) /* stm */); 5071 if (c < p.getCost(1) /* stm */) { 5072 p.setCost(1 /* stm */, (char)(c)); 5073 p.writePacked(0, 0xFFFFFF80, 0x28); // p.stm = 40 5074 } 5075 } 5076 } 5077 5078 /** 5079 * Labels LONG_STORE tree node 5080 * @param p node to label 5081 */ 5082 private static void label_LONG_STORE(AbstractBURS_TreeNode p) { 5083 p.initCost(); 5084 AbstractBURS_TreeNode lchild, rchild; 5085 lchild = p.getChild1(); 5086 rchild = p.getChild2(); 5087 label(lchild); 5088 label(rchild); 5089 int c; 5090 if ( // stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 5091 rchild.getOpcode() == OTHER_OPERAND_opcode && 5092 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5093 ) { 5094 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 5095 if(BURS.DEBUG) trace(p, 226, c + 0, p.getCost(1) /* stm */); 5096 if (c < p.getCost(1) /* stm */) { 5097 p.setCost(1 /* stm */, (char)(c)); 5098 p.writePacked(0, 0xFFFFFF80, 0x4F); // p.stm = 79 5099 } 5100 } 5101 if ( // stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 5102 rchild.getOpcode() == OTHER_OPERAND_opcode && 5103 rchild.getChild2().getOpcode() == REF_MOVE_opcode && 5104 rchild.getChild2().getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 5105 ) { 5106 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + FITS(Move.getVal(PRR(p)),32,22); 5107 if(BURS.DEBUG) trace(p, 227, c + 0, p.getCost(1) /* stm */); 5108 if (c < p.getCost(1) /* stm */) { 5109 p.setCost(1 /* stm */, (char)(c)); 5110 p.writePacked(0, 0xFFFFFF80, 0x50); // p.stm = 80 5111 } 5112 } 5113 if ( // stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 5114 rchild.getOpcode() == OTHER_OPERAND_opcode 5115 ) { 5116 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 5117 if(BURS.DEBUG) trace(p, 251, c + 0, p.getCost(1) /* stm */); 5118 if (c < p.getCost(1) /* stm */) { 5119 p.setCost(1 /* stm */, (char)(c)); 5120 p.writePacked(0, 0xFFFFFF80, 0x51); // p.stm = 81 5121 } 5122 } 5123 if ( // stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 5124 rchild.getOpcode() == OTHER_OPERAND_opcode && 5125 rchild.getChild1().getOpcode() == REF_ADD_opcode && 5126 rchild.getChild1().getChild2().getOpcode() == INT_CONSTANT_opcode && 5127 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5128 ) { 5129 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1().getChild1()).getCost(2 /* r */) + (SI16(VRR(p)+VRLR(p))?14:INFINITE); 5130 if(BURS.DEBUG) trace(p, 262, c + 0, p.getCost(1) /* stm */); 5131 if (c < p.getCost(1) /* stm */) { 5132 p.setCost(1 /* stm */, (char)(c)); 5133 p.writePacked(0, 0xFFFFFF80, 0x52); // p.stm = 82 5134 } 5135 } 5136 } 5137 5138 /** 5139 * Labels FLOAT_STORE tree node 5140 * @param p node to label 5141 */ 5142 private static void label_FLOAT_STORE(AbstractBURS_TreeNode p) { 5143 p.initCost(); 5144 AbstractBURS_TreeNode lchild, rchild; 5145 lchild = p.getChild1(); 5146 rchild = p.getChild2(); 5147 label(lchild); 5148 label(rchild); 5149 int c; 5150 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 5151 rchild.getOpcode() == OTHER_OPERAND_opcode && 5152 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5153 ) { 5154 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 5155 if(BURS.DEBUG) trace(p, 222, c + 0, p.getCost(1) /* stm */); 5156 if (c < p.getCost(1) /* stm */) { 5157 p.setCost(1 /* stm */, (char)(c)); 5158 p.writePacked(0, 0xFFFFFF80, 0x29); // p.stm = 41 5159 } 5160 } 5161 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 5162 rchild.getOpcode() == OTHER_OPERAND_opcode && 5163 rchild.getChild2().getOpcode() == REF_MOVE_opcode && 5164 rchild.getChild2().getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 5165 ) { 5166 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + FITS(Move.getVal(PRR(p)),32,22); 5167 if(BURS.DEBUG) trace(p, 223, c + 0, p.getCost(1) /* stm */); 5168 if (c < p.getCost(1) /* stm */) { 5169 p.setCost(1 /* stm */, (char)(c)); 5170 p.writePacked(0, 0xFFFFFF80, 0x2A); // p.stm = 42 5171 } 5172 } 5173 if ( // stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 5174 rchild.getOpcode() == OTHER_OPERAND_opcode 5175 ) { 5176 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 5177 if(BURS.DEBUG) trace(p, 249, c + 0, p.getCost(1) /* stm */); 5178 if (c < p.getCost(1) /* stm */) { 5179 p.setCost(1 /* stm */, (char)(c)); 5180 p.writePacked(0, 0xFFFFFF80, 0x2B); // p.stm = 43 5181 } 5182 } 5183 } 5184 5185 /** 5186 * Labels DOUBLE_STORE tree node 5187 * @param p node to label 5188 */ 5189 private static void label_DOUBLE_STORE(AbstractBURS_TreeNode p) { 5190 p.initCost(); 5191 AbstractBURS_TreeNode lchild, rchild; 5192 lchild = p.getChild1(); 5193 rchild = p.getChild2(); 5194 label(lchild); 5195 label(rchild); 5196 int c; 5197 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 5198 rchild.getOpcode() == OTHER_OPERAND_opcode && 5199 rchild.getChild2().getOpcode() == INT_CONSTANT_opcode 5200 ) { 5201 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + 11; 5202 if(BURS.DEBUG) trace(p, 224, c + 0, p.getCost(1) /* stm */); 5203 if (c < p.getCost(1) /* stm */) { 5204 p.setCost(1 /* stm */, (char)(c)); 5205 p.writePacked(0, 0xFFFFFF80, 0x2C); // p.stm = 44 5206 } 5207 } 5208 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 5209 rchild.getOpcode() == OTHER_OPERAND_opcode && 5210 rchild.getChild2().getOpcode() == REF_MOVE_opcode && 5211 rchild.getChild2().getChild1().getOpcode() == ADDRESS_CONSTANT_opcode 5212 ) { 5213 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + FITS(Move.getVal(PRR(p)),32,22); 5214 if(BURS.DEBUG) trace(p, 225, c + 0, p.getCost(1) /* stm */); 5215 if (c < p.getCost(1) /* stm */) { 5216 p.setCost(1 /* stm */, (char)(c)); 5217 p.writePacked(0, 0xFFFFFF80, 0x2D); // p.stm = 45 5218 } 5219 } 5220 if ( // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 5221 rchild.getOpcode() == OTHER_OPERAND_opcode 5222 ) { 5223 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild.getChild1()).getCost(2 /* r */) + STATE(rchild.getChild2()).getCost(2 /* r */) + 11; 5224 if(BURS.DEBUG) trace(p, 250, c + 0, p.getCost(1) /* stm */); 5225 if (c < p.getCost(1) /* stm */) { 5226 p.setCost(1 /* stm */, (char)(c)); 5227 p.writePacked(0, 0xFFFFFF80, 0x2E); // p.stm = 46 5228 } 5229 } 5230 } 5231 5232 /** 5233 * Labels PREPARE_INT tree node 5234 * @param p node to label 5235 */ 5236 private static void label_PREPARE_INT(AbstractBURS_TreeNode p) { 5237 p.initCost(); 5238 AbstractBURS_TreeNode lchild, rchild; 5239 lchild = p.getChild1(); 5240 rchild = p.getChild2(); 5241 label(lchild); 5242 label(rchild); 5243 int c; 5244 // r: PREPARE_INT(r,r) 5245 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5246 if(BURS.DEBUG) trace(p, 81, c + 0, p.getCost(2) /* r */); 5247 if (c < p.getCost(2) /* r */) { 5248 p.setCost(2 /* r */, (char)(c)); 5249 p.writePacked(0, 0xFFFFC07F, 0x2D00); // p.r = 90 5250 closure_r(p, c); 5251 } 5252 } 5253 5254 /** 5255 * Labels PREPARE_ADDR tree node 5256 * @param p node to label 5257 */ 5258 private static void label_PREPARE_ADDR(AbstractBURS_TreeNode p) { 5259 p.initCost(); 5260 AbstractBURS_TreeNode lchild, rchild; 5261 lchild = p.getChild1(); 5262 rchild = p.getChild2(); 5263 label(lchild); 5264 label(rchild); 5265 int c; 5266 // r: PREPARE_ADDR(r,r) 5267 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5268 if(BURS.DEBUG) trace(p, 94, c + 0, p.getCost(2) /* r */); 5269 if (c < p.getCost(2) /* r */) { 5270 p.setCost(2 /* r */, (char)(c)); 5271 p.writePacked(0, 0xFFFFC07F, 0x3C80); // p.r = 121 5272 closure_r(p, c); 5273 } 5274 } 5275 5276 /** 5277 * Labels PREPARE_LONG tree node 5278 * @param p node to label 5279 */ 5280 private static void label_PREPARE_LONG(AbstractBURS_TreeNode p) { 5281 p.initCost(); 5282 AbstractBURS_TreeNode lchild, rchild; 5283 lchild = p.getChild1(); 5284 rchild = p.getChild2(); 5285 label(lchild); 5286 label(rchild); 5287 int c; 5288 // r: PREPARE_LONG(r,r) 5289 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5290 if(BURS.DEBUG) trace(p, 82, c + 0, p.getCost(2) /* r */); 5291 if (c < p.getCost(2) /* r */) { 5292 p.setCost(2 /* r */, (char)(c)); 5293 p.writePacked(0, 0xFFFFC07F, 0x2D80); // p.r = 91 5294 closure_r(p, c); 5295 } 5296 } 5297 5298 /** 5299 * Labels ATTEMPT_INT tree node 5300 * @param p node to label 5301 */ 5302 private static void label_ATTEMPT_INT(AbstractBURS_TreeNode p) { 5303 p.initCost(); 5304 AbstractBURS_TreeNode lchild, rchild; 5305 lchild = p.getChild1(); 5306 rchild = p.getChild2(); 5307 label(lchild); 5308 label(rchild); 5309 int c; 5310 // r: ATTEMPT_INT(r,r) 5311 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5312 if(BURS.DEBUG) trace(p, 83, c + 0, p.getCost(2) /* r */); 5313 if (c < p.getCost(2) /* r */) { 5314 p.setCost(2 /* r */, (char)(c)); 5315 p.writePacked(0, 0xFFFFC07F, 0x2E00); // p.r = 92 5316 closure_r(p, c); 5317 } 5318 } 5319 5320 /** 5321 * Labels ATTEMPT_ADDR tree node 5322 * @param p node to label 5323 */ 5324 private static void label_ATTEMPT_ADDR(AbstractBURS_TreeNode p) { 5325 p.initCost(); 5326 AbstractBURS_TreeNode lchild, rchild; 5327 lchild = p.getChild1(); 5328 rchild = p.getChild2(); 5329 label(lchild); 5330 label(rchild); 5331 int c; 5332 // r: ATTEMPT_ADDR(r,r) 5333 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5334 if(BURS.DEBUG) trace(p, 95, c + 0, p.getCost(2) /* r */); 5335 if (c < p.getCost(2) /* r */) { 5336 p.setCost(2 /* r */, (char)(c)); 5337 p.writePacked(0, 0xFFFFC07F, 0x3D00); // p.r = 122 5338 closure_r(p, c); 5339 } 5340 } 5341 5342 /** 5343 * Labels ATTEMPT_LONG tree node 5344 * @param p node to label 5345 */ 5346 private static void label_ATTEMPT_LONG(AbstractBURS_TreeNode p) { 5347 p.initCost(); 5348 AbstractBURS_TreeNode lchild, rchild; 5349 lchild = p.getChild1(); 5350 rchild = p.getChild2(); 5351 label(lchild); 5352 label(rchild); 5353 int c; 5354 // r: ATTEMPT_LONG(r,r) 5355 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 11; 5356 if(BURS.DEBUG) trace(p, 84, c + 0, p.getCost(2) /* r */); 5357 if (c < p.getCost(2) /* r */) { 5358 p.setCost(2 /* r */, (char)(c)); 5359 p.writePacked(0, 0xFFFFC07F, 0x2E80); // p.r = 93 5360 closure_r(p, c); 5361 } 5362 } 5363 5364 /** 5365 * Labels CALL tree node 5366 * @param p node to label 5367 */ 5368 private static void label_CALL(AbstractBURS_TreeNode p) { 5369 p.initCost(); 5370 AbstractBURS_TreeNode lchild, rchild; 5371 lchild = p.getChild1(); 5372 rchild = p.getChild2(); 5373 label(lchild); 5374 label(rchild); 5375 int c; 5376 // r: CALL(r,any) 5377 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* any */) + 10; 5378 if(BURS.DEBUG) trace(p, 77, c + 0, p.getCost(2) /* r */); 5379 if (c < p.getCost(2) /* r */) { 5380 p.setCost(2 /* r */, (char)(c)); 5381 p.writePacked(0, 0xFFFFC07F, 0x2A00); // p.r = 84 5382 closure_r(p, c); 5383 } 5384 if ( // r: CALL(BRANCH_TARGET,any) 5385 lchild.getOpcode() == BRANCH_TARGET_opcode 5386 ) { 5387 c = STATE(rchild).getCost(7 /* any */) + 10; 5388 if(BURS.DEBUG) trace(p, 191, c + 0, p.getCost(2) /* r */); 5389 if (c < p.getCost(2) /* r */) { 5390 p.setCost(2 /* r */, (char)(c)); 5391 p.writePacked(0, 0xFFFFC07F, 0x2A80); // p.r = 85 5392 closure_r(p, c); 5393 } 5394 } 5395 } 5396 5397 /** 5398 * Labels SYSCALL tree node 5399 * @param p node to label 5400 */ 5401 private static void label_SYSCALL(AbstractBURS_TreeNode p) { 5402 p.initCost(); 5403 AbstractBURS_TreeNode lchild, rchild; 5404 lchild = p.getChild1(); 5405 rchild = p.getChild2(); 5406 label(lchild); 5407 label(rchild); 5408 int c; 5409 // r: SYSCALL(r,any) 5410 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(7 /* any */) + 10; 5411 if(BURS.DEBUG) trace(p, 78, c + 0, p.getCost(2) /* r */); 5412 if (c < p.getCost(2) /* r */) { 5413 p.setCost(2 /* r */, (char)(c)); 5414 p.writePacked(0, 0xFFFFC07F, 0x2B00); // p.r = 86 5415 closure_r(p, c); 5416 } 5417 } 5418 5419 /** 5420 * Labels YIELDPOINT_PROLOGUE tree node 5421 * @param p node to label 5422 */ 5423 private static void label_YIELDPOINT_PROLOGUE(AbstractBURS_TreeNode p) { 5424 p.initCost(); 5425 // stm: YIELDPOINT_PROLOGUE 5426 if(BURS.DEBUG) trace(p, 17, 10 + 0, p.getCost(1) /* stm */); 5427 if (10 < p.getCost(1) /* stm */) { 5428 p.setCost(1 /* stm */, (char)(10)); 5429 p.writePacked(0, 0xFFFFFF80, 0x6); // p.stm = 6 5430 } 5431 } 5432 5433 /** 5434 * Labels YIELDPOINT_EPILOGUE tree node 5435 * @param p node to label 5436 */ 5437 private static void label_YIELDPOINT_EPILOGUE(AbstractBURS_TreeNode p) { 5438 p.initCost(); 5439 // stm: YIELDPOINT_EPILOGUE 5440 if(BURS.DEBUG) trace(p, 18, 10 + 0, p.getCost(1) /* stm */); 5441 if (10 < p.getCost(1) /* stm */) { 5442 p.setCost(1 /* stm */, (char)(10)); 5443 p.writePacked(0, 0xFFFFFF80, 0x7); // p.stm = 7 5444 } 5445 } 5446 5447 /** 5448 * Labels YIELDPOINT_BACKEDGE tree node 5449 * @param p node to label 5450 */ 5451 private static void label_YIELDPOINT_BACKEDGE(AbstractBURS_TreeNode p) { 5452 p.initCost(); 5453 // stm: YIELDPOINT_BACKEDGE 5454 if(BURS.DEBUG) trace(p, 19, 10 + 0, p.getCost(1) /* stm */); 5455 if (10 < p.getCost(1) /* stm */) { 5456 p.setCost(1 /* stm */, (char)(10)); 5457 p.writePacked(0, 0xFFFFFF80, 0x8); // p.stm = 8 5458 } 5459 } 5460 5461 /** 5462 * Labels YIELDPOINT_OSR tree node 5463 * @param p node to label 5464 */ 5465 private static void label_YIELDPOINT_OSR(AbstractBURS_TreeNode p) { 5466 p.initCost(); 5467 AbstractBURS_TreeNode lchild, rchild; 5468 lchild = p.getChild1(); 5469 rchild = p.getChild2(); 5470 label(lchild); 5471 label(rchild); 5472 int c; 5473 // r: YIELDPOINT_OSR(any,any) 5474 c = STATE(lchild).getCost(7 /* any */) + STATE(rchild).getCost(7 /* any */) + 11; 5475 if(BURS.DEBUG) trace(p, 80, c + 0, p.getCost(2) /* r */); 5476 if (c < p.getCost(2) /* r */) { 5477 p.setCost(2 /* r */, (char)(c)); 5478 p.writePacked(0, 0xFFFFC07F, 0x2C80); // p.r = 89 5479 closure_r(p, c); 5480 } 5481 } 5482 5483 /** 5484 * Labels IR_PROLOGUE tree node 5485 * @param p node to label 5486 */ 5487 private static void label_IR_PROLOGUE(AbstractBURS_TreeNode p) { 5488 p.initCost(); 5489 // stm: IR_PROLOGUE 5490 if(BURS.DEBUG) trace(p, 34, 11 + 0, p.getCost(1) /* stm */); 5491 if (11 < p.getCost(1) /* stm */) { 5492 p.setCost(1 /* stm */, (char)(11)); 5493 p.writePacked(0, 0xFFFFFF80, 0x49); // p.stm = 73 5494 } 5495 } 5496 5497 /** 5498 * Labels RESOLVE tree node 5499 * @param p node to label 5500 */ 5501 private static void label_RESOLVE(AbstractBURS_TreeNode p) { 5502 p.initCost(); 5503 // stm: RESOLVE 5504 if(BURS.DEBUG) trace(p, 13, 10 + 0, p.getCost(1) /* stm */); 5505 if (10 < p.getCost(1) /* stm */) { 5506 p.setCost(1 /* stm */, (char)(10)); 5507 p.writePacked(0, 0xFFFFFF80, 0x2); // p.stm = 2 5508 } 5509 } 5510 5511 /** 5512 * Labels GET_TIME_BASE tree node 5513 * @param p node to label 5514 */ 5515 private static void label_GET_TIME_BASE(AbstractBURS_TreeNode p) { 5516 p.initCost(); 5517 // r: GET_TIME_BASE 5518 if(BURS.DEBUG) trace(p, 33, 11 + 0, p.getCost(2) /* r */); 5519 if (11 < p.getCost(2) /* r */) { 5520 p.setCost(2 /* r */, (char)(11)); 5521 p.writePacked(0, 0xFFFFC07F, 0x2B80); // p.r = 87 5522 closure_r(p, 11); 5523 } 5524 } 5525 5526 /** 5527 * Labels TRAP_IF tree node 5528 * @param p node to label 5529 */ 5530 private static void label_TRAP_IF(AbstractBURS_TreeNode p) { 5531 p.initCost(); 5532 AbstractBURS_TreeNode lchild, rchild; 5533 lchild = p.getChild1(); 5534 rchild = p.getChild2(); 5535 label(lchild); 5536 label(rchild); 5537 int c; 5538 // stm: TRAP_IF(r,r) 5539 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 10; 5540 if(BURS.DEBUG) trace(p, 38, c + 0, p.getCost(1) /* stm */); 5541 if (c < p.getCost(1) /* stm */) { 5542 p.setCost(1 /* stm */, (char)(c)); 5543 p.writePacked(0, 0xFFFFFF80, 0x18); // p.stm = 24 5544 } 5545 if ( // stm: TRAP_IF(r,INT_CONSTANT) 5546 rchild.getOpcode() == INT_CONSTANT_opcode 5547 ) { 5548 c = STATE(lchild).getCost(2 /* r */) + 10; 5549 if(BURS.DEBUG) trace(p, 106, c + 0, p.getCost(1) /* stm */); 5550 if (c < p.getCost(1) /* stm */) { 5551 p.setCost(1 /* stm */, (char)(c)); 5552 p.writePacked(0, 0xFFFFFF80, 0x19); // p.stm = 25 5553 } 5554 } 5555 if ( // stm: TRAP_IF(r,LONG_CONSTANT) 5556 rchild.getOpcode() == LONG_CONSTANT_opcode 5557 ) { 5558 c = STATE(lchild).getCost(2 /* r */) + 10; 5559 if(BURS.DEBUG) trace(p, 107, c + 0, p.getCost(1) /* stm */); 5560 if (c < p.getCost(1) /* stm */) { 5561 p.setCost(1 /* stm */, (char)(c)); 5562 p.writePacked(0, 0xFFFFFF80, 0x1A); // p.stm = 26 5563 } 5564 } 5565 } 5566 5567 /** 5568 * Labels TRAP tree node 5569 * @param p node to label 5570 */ 5571 private static void label_TRAP(AbstractBURS_TreeNode p) { 5572 p.initCost(); 5573 // stm: TRAP 5574 if(BURS.DEBUG) trace(p, 27, 10 + 0, p.getCost(1) /* stm */); 5575 if (10 < p.getCost(1) /* stm */) { 5576 p.setCost(1 /* stm */, (char)(10)); 5577 p.writePacked(0, 0xFFFFFF80, 0x17); // p.stm = 23 5578 } 5579 } 5580 5581 /** 5582 * Labels FLOAT_AS_INT_BITS tree node 5583 * @param p node to label 5584 */ 5585 private static void label_FLOAT_AS_INT_BITS(AbstractBURS_TreeNode p) { 5586 p.initCost(); 5587 AbstractBURS_TreeNode lchild; 5588 lchild = p.getChild1(); 5589 label(lchild); 5590 int c; 5591 // r: FLOAT_AS_INT_BITS(r) 5592 c = STATE(lchild).getCost(2 /* r */) + 20; 5593 if(BURS.DEBUG) trace(p, 149, c + 0, p.getCost(2) /* r */); 5594 if (c < p.getCost(2) /* r */) { 5595 p.setCost(2 /* r */, (char)(c)); 5596 p.writePacked(0, 0xFFFFC07F, 0x2480); // p.r = 73 5597 closure_r(p, c); 5598 } 5599 } 5600 5601 /** 5602 * Labels INT_BITS_AS_FLOAT tree node 5603 * @param p node to label 5604 */ 5605 private static void label_INT_BITS_AS_FLOAT(AbstractBURS_TreeNode p) { 5606 p.initCost(); 5607 AbstractBURS_TreeNode lchild; 5608 lchild = p.getChild1(); 5609 label(lchild); 5610 int c; 5611 // r: INT_BITS_AS_FLOAT(r) 5612 c = STATE(lchild).getCost(2 /* r */) + 20; 5613 if(BURS.DEBUG) trace(p, 150, c + 0, p.getCost(2) /* r */); 5614 if (c < p.getCost(2) /* r */) { 5615 p.setCost(2 /* r */, (char)(c)); 5616 p.writePacked(0, 0xFFFFC07F, 0x2500); // p.r = 74 5617 closure_r(p, c); 5618 } 5619 } 5620 5621 /** 5622 * Labels DOUBLE_AS_LONG_BITS tree node 5623 * @param p node to label 5624 */ 5625 private static void label_DOUBLE_AS_LONG_BITS(AbstractBURS_TreeNode p) { 5626 p.initCost(); 5627 AbstractBURS_TreeNode lchild; 5628 lchild = p.getChild1(); 5629 label(lchild); 5630 int c; 5631 // r: DOUBLE_AS_LONG_BITS(r) 5632 c = STATE(lchild).getCost(2 /* r */) + 40; 5633 if(BURS.DEBUG) trace(p, 182, c + 0, p.getCost(2) /* r */); 5634 if (c < p.getCost(2) /* r */) { 5635 p.setCost(2 /* r */, (char)(c)); 5636 p.writePacked(0, 0xFFFFC07F, 0x3780); // p.r = 111 5637 closure_r(p, c); 5638 } 5639 } 5640 5641 /** 5642 * Labels LONG_BITS_AS_DOUBLE tree node 5643 * @param p node to label 5644 */ 5645 private static void label_LONG_BITS_AS_DOUBLE(AbstractBURS_TreeNode p) { 5646 p.initCost(); 5647 AbstractBURS_TreeNode lchild; 5648 lchild = p.getChild1(); 5649 label(lchild); 5650 int c; 5651 // r: LONG_BITS_AS_DOUBLE(r) 5652 c = STATE(lchild).getCost(2 /* r */) + 40; 5653 if(BURS.DEBUG) trace(p, 183, c + 0, p.getCost(2) /* r */); 5654 if (c < p.getCost(2) /* r */) { 5655 p.setCost(2 /* r */, (char)(c)); 5656 p.writePacked(0, 0xFFFFC07F, 0x3800); // p.r = 112 5657 closure_r(p, c); 5658 } 5659 } 5660 5661 /** 5662 * Labels LOWTABLESWITCH tree node 5663 * @param p node to label 5664 */ 5665 private static void label_LOWTABLESWITCH(AbstractBURS_TreeNode p) { 5666 p.initCost(); 5667 AbstractBURS_TreeNode lchild; 5668 lchild = p.getChild1(); 5669 label(lchild); 5670 int c; 5671 // stm: LOWTABLESWITCH(r) 5672 c = STATE(lchild).getCost(2 /* r */) + 10; 5673 if(BURS.DEBUG) trace(p, 96, c + 0, p.getCost(1) /* stm */); 5674 if (c < p.getCost(1) /* stm */) { 5675 p.setCost(1 /* stm */, (char)(c)); 5676 p.writePacked(0, 0xFFFFFF80, 0x9); // p.stm = 9 5677 } 5678 } 5679 5680 /** 5681 * Labels ADDRESS_CONSTANT tree node 5682 * @param p node to label 5683 */ 5684 private static void label_ADDRESS_CONSTANT(AbstractBURS_TreeNode p) { 5685 p.initCost(); 5686 // any: ADDRESS_CONSTANT 5687 if(BURS.DEBUG) trace(p, 10, 0 + 0, p.getCost(7) /* any */); 5688 if (0 < p.getCost(7) /* any */) { 5689 p.setCost(7 /* any */, (char)(0)); 5690 p.writePacked(0, 0x8FFFFFFF, 0x30000000); // p.any = 3 5691 } 5692 } 5693 5694 /** 5695 * Labels INT_CONSTANT tree node 5696 * @param p node to label 5697 */ 5698 private static void label_INT_CONSTANT(AbstractBURS_TreeNode p) { 5699 p.initCost(); 5700 // any: INT_CONSTANT 5701 if(BURS.DEBUG) trace(p, 11, 0 + 0, p.getCost(7) /* any */); 5702 if (0 < p.getCost(7) /* any */) { 5703 p.setCost(7 /* any */, (char)(0)); 5704 p.writePacked(0, 0x8FFFFFFF, 0x40000000); // p.any = 4 5705 } 5706 } 5707 5708 /** 5709 * Labels LONG_CONSTANT tree node 5710 * @param p node to label 5711 */ 5712 private static void label_LONG_CONSTANT(AbstractBURS_TreeNode p) { 5713 p.initCost(); 5714 // any: LONG_CONSTANT 5715 if(BURS.DEBUG) trace(p, 12, 0 + 0, p.getCost(7) /* any */); 5716 if (0 < p.getCost(7) /* any */) { 5717 p.setCost(7 /* any */, (char)(0)); 5718 p.writePacked(0, 0x8FFFFFFF, 0x50000000); // p.any = 5 5719 } 5720 } 5721 5722 /** 5723 * Labels REGISTER tree node 5724 * @param p node to label 5725 */ 5726 private static void label_REGISTER(AbstractBURS_TreeNode p) { 5727 p.initCost(); 5728 // r: REGISTER 5729 if(BURS.DEBUG) trace(p, 8, 0 + 0, p.getCost(2) /* r */); 5730 if (0 < p.getCost(2) /* r */) { 5731 p.setCost(2 /* r */, (char)(0)); 5732 p.writePacked(0, 0xFFFFC07F, 0x80); // p.r = 1 5733 closure_r(p, 0); 5734 } 5735 } 5736 5737 /** 5738 * Labels OTHER_OPERAND tree node 5739 * @param p node to label 5740 */ 5741 private static void label_OTHER_OPERAND(AbstractBURS_TreeNode p) { 5742 p.initCost(); 5743 AbstractBURS_TreeNode lchild, rchild; 5744 lchild = p.getChild1(); 5745 rchild = p.getChild2(); 5746 label(lchild); 5747 label(rchild); 5748 int c; 5749 // any: OTHER_OPERAND(any,any) 5750 c = STATE(lchild).getCost(7 /* any */) + STATE(rchild).getCost(7 /* any */) + 0; 5751 if(BURS.DEBUG) trace(p, 37, c + 0, p.getCost(7) /* any */); 5752 if (c < p.getCost(7) /* any */) { 5753 p.setCost(7 /* any */, (char)(c)); 5754 p.writePacked(0, 0x8FFFFFFF, 0x60000000); // p.any = 6 5755 } 5756 // r: OTHER_OPERAND(r,r) 5757 c = STATE(lchild).getCost(2 /* r */) + STATE(rchild).getCost(2 /* r */) + 0; 5758 if(BURS.DEBUG) trace(p, 79, c + 0, p.getCost(2) /* r */); 5759 if (c < p.getCost(2) /* r */) { 5760 p.setCost(2 /* r */, (char)(c)); 5761 p.writePacked(0, 0xFFFFC07F, 0x2C00); // p.r = 88 5762 closure_r(p, c); 5763 } 5764 } 5765 5766 /** 5767 * Labels NULL tree node 5768 * @param p node to label 5769 */ 5770 private static void label_NULL(AbstractBURS_TreeNode p) { 5771 p.initCost(); 5772 // any: NULL 5773 if(BURS.DEBUG) trace(p, 9, 0 + 0, p.getCost(7) /* any */); 5774 if (0 < p.getCost(7) /* any */) { 5775 p.setCost(7 /* any */, (char)(0)); 5776 p.writePacked(0, 0x8FFFFFFF, 0x10000000); // p.any = 1 5777 } 5778 } 5779 5780 /** 5781 * Labels BRANCH_TARGET tree node 5782 * @param p node to label 5783 */ 5784 private static void label_BRANCH_TARGET(AbstractBURS_TreeNode p) { 5785 p.initCost(); 5786 } 5787 5788 /** 5789 * Labels DCBF tree node 5790 * @param p node to label 5791 */ 5792 private static void label_DCBF(AbstractBURS_TreeNode p) { 5793 p.initCost(); 5794 AbstractBURS_TreeNode lchild; 5795 lchild = p.getChild1(); 5796 label(lchild); 5797 int c; 5798 // stm: DCBF(r) 5799 c = STATE(lchild).getCost(2 /* r */) + 11; 5800 if(BURS.DEBUG) trace(p, 99, c + 0, p.getCost(1) /* stm */); 5801 if (c < p.getCost(1) /* stm */) { 5802 p.setCost(1 /* stm */, (char)(c)); 5803 p.writePacked(0, 0xFFFFFF80, 0x10); // p.stm = 16 5804 } 5805 } 5806 5807 /** 5808 * Labels DCBST tree node 5809 * @param p node to label 5810 */ 5811 private static void label_DCBST(AbstractBURS_TreeNode p) { 5812 p.initCost(); 5813 AbstractBURS_TreeNode lchild; 5814 lchild = p.getChild1(); 5815 label(lchild); 5816 int c; 5817 // stm: DCBST(r) 5818 c = STATE(lchild).getCost(2 /* r */) + 11; 5819 if(BURS.DEBUG) trace(p, 100, c + 0, p.getCost(1) /* stm */); 5820 if (c < p.getCost(1) /* stm */) { 5821 p.setCost(1 /* stm */, (char)(c)); 5822 p.writePacked(0, 0xFFFFFF80, 0x11); // p.stm = 17 5823 } 5824 } 5825 5826 /** 5827 * Labels DCBT tree node 5828 * @param p node to label 5829 */ 5830 private static void label_DCBT(AbstractBURS_TreeNode p) { 5831 p.initCost(); 5832 AbstractBURS_TreeNode lchild; 5833 lchild = p.getChild1(); 5834 label(lchild); 5835 int c; 5836 // stm: DCBT(r) 5837 c = STATE(lchild).getCost(2 /* r */) + 11; 5838 if(BURS.DEBUG) trace(p, 101, c + 0, p.getCost(1) /* stm */); 5839 if (c < p.getCost(1) /* stm */) { 5840 p.setCost(1 /* stm */, (char)(c)); 5841 p.writePacked(0, 0xFFFFFF80, 0x12); // p.stm = 18 5842 } 5843 } 5844 5845 /** 5846 * Labels DCBTST tree node 5847 * @param p node to label 5848 */ 5849 private static void label_DCBTST(AbstractBURS_TreeNode p) { 5850 p.initCost(); 5851 AbstractBURS_TreeNode lchild; 5852 lchild = p.getChild1(); 5853 label(lchild); 5854 int c; 5855 // stm: DCBTST(r) 5856 c = STATE(lchild).getCost(2 /* r */) + 11; 5857 if(BURS.DEBUG) trace(p, 102, c + 0, p.getCost(1) /* stm */); 5858 if (c < p.getCost(1) /* stm */) { 5859 p.setCost(1 /* stm */, (char)(c)); 5860 p.writePacked(0, 0xFFFFFF80, 0x13); // p.stm = 19 5861 } 5862 } 5863 5864 /** 5865 * Labels DCBZ tree node 5866 * @param p node to label 5867 */ 5868 private static void label_DCBZ(AbstractBURS_TreeNode p) { 5869 p.initCost(); 5870 AbstractBURS_TreeNode lchild; 5871 lchild = p.getChild1(); 5872 label(lchild); 5873 int c; 5874 // stm: DCBZ(r) 5875 c = STATE(lchild).getCost(2 /* r */) + 11; 5876 if(BURS.DEBUG) trace(p, 103, c + 0, p.getCost(1) /* stm */); 5877 if (c < p.getCost(1) /* stm */) { 5878 p.setCost(1 /* stm */, (char)(c)); 5879 p.writePacked(0, 0xFFFFFF80, 0x14); // p.stm = 20 5880 } 5881 } 5882 5883 /** 5884 * Labels DCBZL tree node 5885 * @param p node to label 5886 */ 5887 private static void label_DCBZL(AbstractBURS_TreeNode p) { 5888 p.initCost(); 5889 AbstractBURS_TreeNode lchild; 5890 lchild = p.getChild1(); 5891 label(lchild); 5892 int c; 5893 // stm: DCBZL(r) 5894 c = STATE(lchild).getCost(2 /* r */) + 11; 5895 if(BURS.DEBUG) trace(p, 104, c + 0, p.getCost(1) /* stm */); 5896 if (c < p.getCost(1) /* stm */) { 5897 p.setCost(1 /* stm */, (char)(c)); 5898 p.writePacked(0, 0xFFFFFF80, 0x15); // p.stm = 21 5899 } 5900 } 5901 5902 /** 5903 * Labels ICBI tree node 5904 * @param p node to label 5905 */ 5906 private static void label_ICBI(AbstractBURS_TreeNode p) { 5907 p.initCost(); 5908 AbstractBURS_TreeNode lchild; 5909 lchild = p.getChild1(); 5910 label(lchild); 5911 int c; 5912 // stm: ICBI(r) 5913 c = STATE(lchild).getCost(2 /* r */) + 11; 5914 if(BURS.DEBUG) trace(p, 105, c + 0, p.getCost(1) /* stm */); 5915 if (c < p.getCost(1) /* stm */) { 5916 p.setCost(1 /* stm */, (char)(c)); 5917 p.writePacked(0, 0xFFFFFF80, 0x16); // p.stm = 22 5918 } 5919 } 5920 5921 /** 5922 * Give leaf child corresponding to external rule and child number. 5923 * e.g. . 5924 * 5925 * @param p tree node to get child for 5926 * @param eruleno external rule number 5927 * @param kidnumber the child to return 5928 * @return the requested child 5929 */ 5930 private static AbstractBURS_TreeNode kids(AbstractBURS_TreeNode p, int eruleno, int kidnumber) { 5931 if (BURS.DEBUG) { 5932 switch (eruleno) { 5933 case 7: // any: r 5934 case 6: // rz: rp 5935 case 5: // rs: rp 5936 case 4: // r: rz 5937 case 3: // r: rs 5938 case 2: // r: czr 5939 case 1: // stm: r 5940 if (kidnumber == 0) { 5941 return p; 5942 } 5943 break; 5944 case 36: // r: REF_MOVE(LONG_CONSTANT) 5945 case 35: // r: REF_MOVE(ADDRESS_CONSTANT) 5946 case 34: // stm: IR_PROLOGUE 5947 case 33: // r: GET_TIME_BASE 5948 case 32: // stm: RETURN(NULL) 5949 case 31: // stm: GOTO 5950 case 30: // rs: REF_MOVE(INT_CONSTANT) 5951 case 29: // rs: REF_MOVE(INT_CONSTANT) 5952 case 28: // rs: REF_MOVE(INT_CONSTANT) 5953 case 27: // stm: TRAP 5954 case 26: // stm: READ_CEILING 5955 case 25: // stm: WRITE_FLOOR 5956 case 24: // stm: FENCE 5957 case 23: // r: GET_CAUGHT_EXCEPTION 5958 case 22: // r: GUARD_COMBINE 5959 case 21: // r: GUARD_MOVE 5960 case 20: // stm: NOP 5961 case 19: // stm: YIELDPOINT_BACKEDGE 5962 case 18: // stm: YIELDPOINT_EPILOGUE 5963 case 17: // stm: YIELDPOINT_PROLOGUE 5964 case 16: // stm: UNINT_END 5965 case 15: // stm: UNINT_BEGIN 5966 case 14: // stm: IG_PATCH_POINT 5967 case 13: // stm: RESOLVE 5968 case 12: // any: LONG_CONSTANT 5969 case 11: // any: INT_CONSTANT 5970 case 10: // any: ADDRESS_CONSTANT 5971 case 9: // any: NULL 5972 case 8: // r: REGISTER 5973 break; 5974 case 95: // r: ATTEMPT_ADDR(r,r) 5975 case 94: // r: PREPARE_ADDR(r,r) 5976 case 93: // r: LONG_LOAD(r,r) 5977 case 92: // stm: LONG_IFCMP(r,r) 5978 case 91: // r: LONG_CMP(r,r) 5979 case 90: // r: LONG_USHR(r,r) 5980 case 89: // r: LONG_SHR(r,r) 5981 case 88: // r: LONG_SHL(r,r) 5982 case 87: // r: LONG_REM(r,r) 5983 case 86: // r: LONG_DIV(r,r) 5984 case 85: // r: LONG_MUL(r,r) 5985 case 84: // r: ATTEMPT_LONG(r,r) 5986 case 83: // r: ATTEMPT_INT(r,r) 5987 case 82: // r: PREPARE_LONG(r,r) 5988 case 81: // r: PREPARE_INT(r,r) 5989 case 80: // r: YIELDPOINT_OSR(any,any) 5990 case 79: // r: OTHER_OPERAND(r,r) 5991 case 78: // r: SYSCALL(r,any) 5992 case 77: // r: CALL(r,any) 5993 case 76: // stm: DOUBLE_CMPG(r,r) 5994 case 75: // stm: DOUBLE_CMPL(r,r) 5995 case 74: // stm: FLOAT_CMPG(r,r) 5996 case 73: // stm: FLOAT_CMPL(r,r) 5997 case 72: // stm: DOUBLE_IFCMP(r,r) 5998 case 71: // stm: FLOAT_IFCMP(r,r) 5999 case 70: // stm: INT_IFCMP2(r,r) 6000 case 69: // stm: INT_IFCMP(r,r) 6001 case 68: // rs: INT_LOAD(r,r) 6002 case 67: // r: DOUBLE_LOAD(r,r) 6003 case 66: // r: FLOAT_LOAD(r,r) 6004 case 65: // rp: USHORT_LOAD(r,r) 6005 case 64: // rs: SHORT_LOAD(r,r) 6006 case 63: // rp: UBYTE_LOAD(r,r) 6007 case 62: // rs: BYTE_LOAD(r,r) 6008 case 61: // r: DOUBLE_DIV(r,r) 6009 case 60: // r: FLOAT_DIV(r,r) 6010 case 59: // r: DOUBLE_SUB(r,r) 6011 case 58: // r: FLOAT_SUB(r,r) 6012 case 57: // r: DOUBLE_MUL(r,r) 6013 case 56: // r: FLOAT_MUL(r,r) 6014 case 55: // r: DOUBLE_ADD(r,r) 6015 case 54: // r: FLOAT_ADD(r,r) 6016 case 53: // r: REF_XOR(r,r) 6017 case 52: // r: REF_OR(r,r) 6018 case 51: // r: REF_AND(r,r) 6019 case 50: // rz: INT_USHR(r,r) 6020 case 49: // rs: INT_SHR(r,r) 6021 case 48: // rz: INT_SHL(r,r) 6022 case 47: // r: INT_REM(r,r) 6023 case 46: // r: INT_DIV(r,r) 6024 case 45: // r: INT_MUL(r,r) 6025 case 44: // r: REF_SUB(r,r) 6026 case 43: // r: REF_ADD(r,r) 6027 case 42: // boolcmp: BOOLEAN_CMP_ADDR(r,r) 6028 case 41: // r: BOOLEAN_CMP_ADDR(r,r) 6029 case 40: // boolcmp: BOOLEAN_CMP_INT(r,r) 6030 case 39: // r: BOOLEAN_CMP_INT(r,r) 6031 case 38: // stm: TRAP_IF(r,r) 6032 case 37: // any: OTHER_OPERAND(any,any) 6033 if (kidnumber == 0) { 6034 return p.getChild1(); 6035 } 6036 if (kidnumber == 1) { 6037 return p.getChild2(); 6038 } 6039 break; 6040 case 189: // r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6041 case 188: // r: LONG_LOAD(r,INT_CONSTANT) 6042 case 187: // rz: INT_2ADDRZerExt(r) 6043 case 186: // rz: INT_2ADDRZerExt(rz) 6044 case 185: // stm: LONG_IFCMP(r,LONG_CONSTANT) 6045 case 184: // stm: LONG_IFCMP(r,INT_CONSTANT) 6046 case 183: // r: LONG_BITS_AS_DOUBLE(r) 6047 case 182: // r: DOUBLE_AS_LONG_BITS(r) 6048 case 181: // r: DOUBLE_2LONG(r) 6049 case 180: // r: FLOAT_2LONG(r) 6050 case 179: // r: LONG_2INT(r) 6051 case 178: // rs: INT_2LONG(rs) 6052 case 177: // rs: INT_2LONG(r) 6053 case 176: // r: LONG_USHR(r,INT_CONSTANT) 6054 case 175: // r: LONG_SHR(r,INT_CONSTANT) 6055 case 174: // r: LONG_SHL(r,INT_CONSTANT) 6056 case 173: // r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 6057 case 172: // r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 6058 case 171: // r: LONG_MUL(r,INT_CONSTANT) 6059 case 170: // stm: RETURN(r) 6060 case 169: // stm: INT_IFCMP2(r,INT_CONSTANT) 6061 case 168: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6062 case 167: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6063 case 166: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6064 case 165: // stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6065 case 164: // stm: INT_IFCMP(r,INT_CONSTANT) 6066 case 163: // rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6067 case 162: // rs: INT_LOAD(r,INT_CONSTANT) 6068 case 161: // r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6069 case 160: // r: DOUBLE_LOAD(r,INT_CONSTANT) 6070 case 159: // r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6071 case 158: // r: FLOAT_LOAD(r,INT_CONSTANT) 6072 case 157: // rp: USHORT_LOAD(r,INT_CONSTANT) 6073 case 156: // rs: SHORT_LOAD(r,INT_CONSTANT) 6074 case 155: // rp: UBYTE_LOAD(r,INT_CONSTANT) 6075 case 154: // rs: BYTE_LOAD(r,INT_CONSTANT) 6076 case 153: // r: DOUBLE_MOVE(r) 6077 case 152: // r: FLOAT_MOVE(r) 6078 case 151: // r: REF_MOVE(r) 6079 case 150: // r: INT_BITS_AS_FLOAT(r) 6080 case 149: // r: FLOAT_AS_INT_BITS(r) 6081 case 148: // r: DOUBLE_2FLOAT(r) 6082 case 147: // r: DOUBLE_2INT(r) 6083 case 146: // r: FLOAT_2DOUBLE(r) 6084 case 145: // r: FLOAT_2INT(r) 6085 case 144: // r: INT_2DOUBLE(r) 6086 case 143: // r: INT_2FLOAT(r) 6087 case 142: // rs: INT_2SHORT(r) 6088 case 141: // rp: INT_2USHORT(r) 6089 case 140: // rs: INT_2BYTE(r) 6090 case 139: // r: DOUBLE_SQRT(r) 6091 case 138: // r: FLOAT_SQRT(r) 6092 case 137: // r: DOUBLE_NEG(r) 6093 case 136: // r: FLOAT_NEG(r) 6094 case 135: // r: REF_NOT(r) 6095 case 134: // r: REF_XOR(r,INT_CONSTANT) 6096 case 133: // r: REF_OR(r,INT_CONSTANT) 6097 case 132: // rp: REF_AND(r,INT_CONSTANT) 6098 case 131: // czr: REF_AND(r,INT_CONSTANT) 6099 case 130: // rp: INT_USHR(r,INT_CONSTANT) 6100 case 129: // rs: INT_SHR(r,INT_CONSTANT) 6101 case 128: // rz: INT_SHL(r,INT_CONSTANT) 6102 case 127: // r: REF_NEG(r) 6103 case 126: // r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 6104 case 125: // r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 6105 case 124: // r: INT_MUL(r,INT_CONSTANT) 6106 case 123: // r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6107 case 122: // r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6108 case 121: // r: REF_ADD(r,INT_CONSTANT) 6109 case 120: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6110 case 119: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6111 case 118: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6112 case 117: // r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6113 case 116: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6114 case 115: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6115 case 114: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6116 case 113: // boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6117 case 112: // boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6118 case 111: // r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6119 case 110: // boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6120 case 109: // r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6121 case 108: // r: BOOLEAN_NOT(r) 6122 case 107: // stm: TRAP_IF(r,LONG_CONSTANT) 6123 case 106: // stm: TRAP_IF(r,INT_CONSTANT) 6124 case 105: // stm: ICBI(r) 6125 case 104: // stm: DCBZL(r) 6126 case 103: // stm: DCBZ(r) 6127 case 102: // stm: DCBTST(r) 6128 case 101: // stm: DCBT(r) 6129 case 100: // stm: DCBST(r) 6130 case 99: // stm: DCBF(r) 6131 case 98: // stm: SET_CAUGHT_EXCEPTION(r) 6132 case 97: // stm: NULL_CHECK(r) 6133 case 96: // stm: LOWTABLESWITCH(r) 6134 if (kidnumber == 0) { 6135 return p.getChild1(); 6136 } 6137 break; 6138 case 191: // r: CALL(BRANCH_TARGET,any) 6139 case 190: // r: REF_SUB(INT_CONSTANT,r) 6140 if (kidnumber == 0) { 6141 return p.getChild2(); 6142 } 6143 break; 6144 case 210: // r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6145 case 209: // rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 6146 case 208: // r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 6147 case 207: // r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 6148 case 206: // stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6149 case 205: // stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 6150 case 204: // stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6151 case 203: // stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6152 case 202: // stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 6153 case 201: // stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 6154 case 200: // rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6155 case 199: // rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 6156 case 198: // rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 6157 case 197: // rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6158 case 196: // rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6159 case 195: // rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 6160 case 194: // rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6161 case 193: // rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6162 case 192: // rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6163 if (kidnumber == 0) { 6164 return p.getChild1().getChild1(); 6165 } 6166 break; 6167 case 215: // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6168 case 214: // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6169 case 213: // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 6170 case 212: // r: REF_OR(REF_NOT(r),REF_NOT(r)) 6171 case 211: // r: REF_AND(REF_NOT(r),REF_NOT(r)) 6172 if (kidnumber == 0) { 6173 return p.getChild1().getChild1(); 6174 } 6175 if (kidnumber == 1) { 6176 return p.getChild2().getChild1(); 6177 } 6178 break; 6179 case 227: // stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6180 case 226: // stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6181 case 225: // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6182 case 224: // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6183 case 223: // stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6184 case 222: // stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6185 case 221: // stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6186 case 220: // stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6187 case 219: // stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6188 case 218: // stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6189 case 217: // r: REF_OR(r,REF_NOT(r)) 6190 case 216: // r: REF_AND(r,REF_NOT(r)) 6191 if (kidnumber == 0) { 6192 return p.getChild1(); 6193 } 6194 if (kidnumber == 1) { 6195 return p.getChild2().getChild1(); 6196 } 6197 break; 6198 case 239: // r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 6199 case 238: // rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 6200 case 237: // stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 6201 case 236: // stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 6202 case 235: // stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 6203 case 234: // stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 6204 case 233: // stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 6205 case 232: // rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 6206 case 231: // rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 6207 case 230: // r: REF_NOT(REF_XOR(r,r)) 6208 case 229: // r: REF_NOT(REF_AND(r,r)) 6209 case 228: // r: REF_NOT(REF_OR(r,r)) 6210 if (kidnumber == 0) { 6211 return p.getChild1().getChild1(); 6212 } 6213 if (kidnumber == 1) { 6214 return p.getChild1().getChild2(); 6215 } 6216 break; 6217 case 243: // r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) 6218 case 242: // r: FLOAT_SUB(FLOAT_MUL(r,r),r) 6219 case 241: // r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) 6220 case 240: // r: FLOAT_ADD(FLOAT_MUL(r,r),r) 6221 if (kidnumber == 0) { 6222 return p.getChild1().getChild1(); 6223 } 6224 if (kidnumber == 1) { 6225 return p.getChild1().getChild2(); 6226 } 6227 if (kidnumber == 2) { 6228 return p.getChild2(); 6229 } 6230 break; 6231 case 251: // stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 6232 case 250: // stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 6233 case 249: // stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 6234 case 248: // stm: INT_STORE(r,OTHER_OPERAND(r,r)) 6235 case 247: // stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 6236 case 246: // stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 6237 case 245: // r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) 6238 case 244: // r: FLOAT_ADD(r,FLOAT_MUL(r,r)) 6239 if (kidnumber == 0) { 6240 return p.getChild1(); 6241 } 6242 if (kidnumber == 1) { 6243 return p.getChild2().getChild1(); 6244 } 6245 if (kidnumber == 2) { 6246 return p.getChild2().getChild2(); 6247 } 6248 break; 6249 case 255: // r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) 6250 case 254: // r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) 6251 case 253: // r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) 6252 case 252: // r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) 6253 if (kidnumber == 0) { 6254 return p.getChild1().getChild1().getChild1(); 6255 } 6256 if (kidnumber == 1) { 6257 return p.getChild1().getChild1().getChild2(); 6258 } 6259 if (kidnumber == 2) { 6260 return p.getChild1().getChild2(); 6261 } 6262 break; 6263 case 257: // r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) 6264 case 256: // r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) 6265 if (kidnumber == 0) { 6266 return p.getChild1().getChild1(); 6267 } 6268 if (kidnumber == 1) { 6269 return p.getChild1().getChild2().getChild1(); 6270 } 6271 if (kidnumber == 2) { 6272 return p.getChild1().getChild2().getChild2(); 6273 } 6274 break; 6275 case 260: // stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 6276 case 259: // stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 6277 case 258: // stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 6278 if (kidnumber == 0) { 6279 return p.getChild1().getChild1(); 6280 } 6281 if (kidnumber == 1) { 6282 return p.getChild2().getChild1(); 6283 } 6284 if (kidnumber == 2) { 6285 return p.getChild2().getChild2(); 6286 } 6287 break; 6288 case 262: // stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6289 case 261: // stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6290 if (kidnumber == 0) { 6291 return p.getChild1(); 6292 } 6293 if (kidnumber == 1) { 6294 return p.getChild2().getChild1().getChild1(); 6295 } 6296 break; 6297 case 263: // rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6298 if (kidnumber == 0) { 6299 return p.getChild1().getChild1().getChild1(); 6300 } 6301 break; 6302 } 6303 throw new OptimizingCompilerException("BURS","Bad rule number ", 6304 Integer.toString(eruleno)); 6305 } else { 6306 return null; 6307 } 6308 } 6309 6310 /** 6311 * @param p node whose kids will be marked 6312 * @param eruleno rule number 6313 */ 6314 private static void mark_kids(AbstractBURS_TreeNode p, int eruleno) 6315 { 6316 byte[] ntsrule = nts[eruleno]; 6317 // 7: any: r 6318 // 6: rz: rp 6319 // 5: rs: rp 6320 // 4: r: rz 6321 // 3: r: rs 6322 // 2: r: czr 6323 // 1: stm: r 6324 if (eruleno <= 7) { 6325 if (VM.VerifyAssertions) VM._assert(eruleno > 0); 6326 mark(p, ntsrule[0]); 6327 } 6328 // 36: r: REF_MOVE(LONG_CONSTANT) 6329 // 35: r: REF_MOVE(ADDRESS_CONSTANT) 6330 // 34: stm: IR_PROLOGUE 6331 // 33: r: GET_TIME_BASE 6332 // 32: stm: RETURN(NULL) 6333 // 31: stm: GOTO 6334 // 30: rs: REF_MOVE(INT_CONSTANT) 6335 // 29: rs: REF_MOVE(INT_CONSTANT) 6336 // 28: rs: REF_MOVE(INT_CONSTANT) 6337 // 27: stm: TRAP 6338 // 26: stm: READ_CEILING 6339 // 25: stm: WRITE_FLOOR 6340 // 24: stm: FENCE 6341 // 23: r: GET_CAUGHT_EXCEPTION 6342 // 22: r: GUARD_COMBINE 6343 // 21: r: GUARD_MOVE 6344 // 20: stm: NOP 6345 // 19: stm: YIELDPOINT_BACKEDGE 6346 // 18: stm: YIELDPOINT_EPILOGUE 6347 // 17: stm: YIELDPOINT_PROLOGUE 6348 // 16: stm: UNINT_END 6349 // 15: stm: UNINT_BEGIN 6350 // 14: stm: IG_PATCH_POINT 6351 // 13: stm: RESOLVE 6352 // 12: any: LONG_CONSTANT 6353 // 11: any: INT_CONSTANT 6354 // 10: any: ADDRESS_CONSTANT 6355 // 9: any: NULL 6356 // 8: r: REGISTER 6357 else if (eruleno <= 36) { 6358 } 6359 // 95: r: ATTEMPT_ADDR(r,r) 6360 // 94: r: PREPARE_ADDR(r,r) 6361 // 93: r: LONG_LOAD(r,r) 6362 // 92: stm: LONG_IFCMP(r,r) 6363 // 91: r: LONG_CMP(r,r) 6364 // 90: r: LONG_USHR(r,r) 6365 // 89: r: LONG_SHR(r,r) 6366 // 88: r: LONG_SHL(r,r) 6367 // 87: r: LONG_REM(r,r) 6368 // 86: r: LONG_DIV(r,r) 6369 // 85: r: LONG_MUL(r,r) 6370 // 84: r: ATTEMPT_LONG(r,r) 6371 // 83: r: ATTEMPT_INT(r,r) 6372 // 82: r: PREPARE_LONG(r,r) 6373 // 81: r: PREPARE_INT(r,r) 6374 // 80: r: YIELDPOINT_OSR(any,any) 6375 // 79: r: OTHER_OPERAND(r,r) 6376 // 78: r: SYSCALL(r,any) 6377 // 77: r: CALL(r,any) 6378 // 76: stm: DOUBLE_CMPG(r,r) 6379 // 75: stm: DOUBLE_CMPL(r,r) 6380 // 74: stm: FLOAT_CMPG(r,r) 6381 // 73: stm: FLOAT_CMPL(r,r) 6382 // 72: stm: DOUBLE_IFCMP(r,r) 6383 // 71: stm: FLOAT_IFCMP(r,r) 6384 // 70: stm: INT_IFCMP2(r,r) 6385 // 69: stm: INT_IFCMP(r,r) 6386 // 68: rs: INT_LOAD(r,r) 6387 // 67: r: DOUBLE_LOAD(r,r) 6388 // 66: r: FLOAT_LOAD(r,r) 6389 // 65: rp: USHORT_LOAD(r,r) 6390 // 64: rs: SHORT_LOAD(r,r) 6391 // 63: rp: UBYTE_LOAD(r,r) 6392 // 62: rs: BYTE_LOAD(r,r) 6393 // 61: r: DOUBLE_DIV(r,r) 6394 // 60: r: FLOAT_DIV(r,r) 6395 // 59: r: DOUBLE_SUB(r,r) 6396 // 58: r: FLOAT_SUB(r,r) 6397 // 57: r: DOUBLE_MUL(r,r) 6398 // 56: r: FLOAT_MUL(r,r) 6399 // 55: r: DOUBLE_ADD(r,r) 6400 // 54: r: FLOAT_ADD(r,r) 6401 // 53: r: REF_XOR(r,r) 6402 // 52: r: REF_OR(r,r) 6403 // 51: r: REF_AND(r,r) 6404 // 50: rz: INT_USHR(r,r) 6405 // 49: rs: INT_SHR(r,r) 6406 // 48: rz: INT_SHL(r,r) 6407 // 47: r: INT_REM(r,r) 6408 // 46: r: INT_DIV(r,r) 6409 // 45: r: INT_MUL(r,r) 6410 // 44: r: REF_SUB(r,r) 6411 // 43: r: REF_ADD(r,r) 6412 // 42: boolcmp: BOOLEAN_CMP_ADDR(r,r) 6413 // 41: r: BOOLEAN_CMP_ADDR(r,r) 6414 // 40: boolcmp: BOOLEAN_CMP_INT(r,r) 6415 // 39: r: BOOLEAN_CMP_INT(r,r) 6416 // 38: stm: TRAP_IF(r,r) 6417 // 37: any: OTHER_OPERAND(any,any) 6418 else if (eruleno <= 95) { 6419 mark(p.getChild1(), ntsrule[0]); 6420 mark(p.getChild2(), ntsrule[1]); 6421 } 6422 // 189: r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6423 // 188: r: LONG_LOAD(r,INT_CONSTANT) 6424 // 187: rz: INT_2ADDRZerExt(r) 6425 // 186: rz: INT_2ADDRZerExt(rz) 6426 // 185: stm: LONG_IFCMP(r,LONG_CONSTANT) 6427 // 184: stm: LONG_IFCMP(r,INT_CONSTANT) 6428 // 183: r: LONG_BITS_AS_DOUBLE(r) 6429 // 182: r: DOUBLE_AS_LONG_BITS(r) 6430 // 181: r: DOUBLE_2LONG(r) 6431 // 180: r: FLOAT_2LONG(r) 6432 // 179: r: LONG_2INT(r) 6433 // 178: rs: INT_2LONG(rs) 6434 // 177: rs: INT_2LONG(r) 6435 // 176: r: LONG_USHR(r,INT_CONSTANT) 6436 // 175: r: LONG_SHR(r,INT_CONSTANT) 6437 // 174: r: LONG_SHL(r,INT_CONSTANT) 6438 // 173: r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 6439 // 172: r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 6440 // 171: r: LONG_MUL(r,INT_CONSTANT) 6441 // 170: stm: RETURN(r) 6442 // 169: stm: INT_IFCMP2(r,INT_CONSTANT) 6443 // 168: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6444 // 167: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6445 // 166: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6446 // 165: stm: INT_IFCMP(boolcmp,INT_CONSTANT) 6447 // 164: stm: INT_IFCMP(r,INT_CONSTANT) 6448 // 163: rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6449 // 162: rs: INT_LOAD(r,INT_CONSTANT) 6450 // 161: r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6451 // 160: r: DOUBLE_LOAD(r,INT_CONSTANT) 6452 // 159: r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6453 // 158: r: FLOAT_LOAD(r,INT_CONSTANT) 6454 // 157: rp: USHORT_LOAD(r,INT_CONSTANT) 6455 // 156: rs: SHORT_LOAD(r,INT_CONSTANT) 6456 // 155: rp: UBYTE_LOAD(r,INT_CONSTANT) 6457 // 154: rs: BYTE_LOAD(r,INT_CONSTANT) 6458 // 153: r: DOUBLE_MOVE(r) 6459 // 152: r: FLOAT_MOVE(r) 6460 // 151: r: REF_MOVE(r) 6461 // 150: r: INT_BITS_AS_FLOAT(r) 6462 // 149: r: FLOAT_AS_INT_BITS(r) 6463 // 148: r: DOUBLE_2FLOAT(r) 6464 // 147: r: DOUBLE_2INT(r) 6465 // 146: r: FLOAT_2DOUBLE(r) 6466 // 145: r: FLOAT_2INT(r) 6467 // 144: r: INT_2DOUBLE(r) 6468 // 143: r: INT_2FLOAT(r) 6469 // 142: rs: INT_2SHORT(r) 6470 // 141: rp: INT_2USHORT(r) 6471 // 140: rs: INT_2BYTE(r) 6472 // 139: r: DOUBLE_SQRT(r) 6473 // 138: r: FLOAT_SQRT(r) 6474 // 137: r: DOUBLE_NEG(r) 6475 // 136: r: FLOAT_NEG(r) 6476 // 135: r: REF_NOT(r) 6477 // 134: r: REF_XOR(r,INT_CONSTANT) 6478 // 133: r: REF_OR(r,INT_CONSTANT) 6479 // 132: rp: REF_AND(r,INT_CONSTANT) 6480 // 131: czr: REF_AND(r,INT_CONSTANT) 6481 // 130: rp: INT_USHR(r,INT_CONSTANT) 6482 // 129: rs: INT_SHR(r,INT_CONSTANT) 6483 // 128: rz: INT_SHL(r,INT_CONSTANT) 6484 // 127: r: REF_NEG(r) 6485 // 126: r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 6486 // 125: r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 6487 // 124: r: INT_MUL(r,INT_CONSTANT) 6488 // 123: r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6489 // 122: r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6490 // 121: r: REF_ADD(r,INT_CONSTANT) 6491 // 120: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6492 // 119: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6493 // 118: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6494 // 117: r: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6495 // 116: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6496 // 115: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6497 // 114: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6498 // 113: boolcmp: BOOLEAN_CMP_INT(boolcmp,INT_CONSTANT) 6499 // 112: boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6500 // 111: r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6501 // 110: boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6502 // 109: r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6503 // 108: r: BOOLEAN_NOT(r) 6504 // 107: stm: TRAP_IF(r,LONG_CONSTANT) 6505 // 106: stm: TRAP_IF(r,INT_CONSTANT) 6506 // 105: stm: ICBI(r) 6507 // 104: stm: DCBZL(r) 6508 // 103: stm: DCBZ(r) 6509 // 102: stm: DCBTST(r) 6510 // 101: stm: DCBT(r) 6511 // 100: stm: DCBST(r) 6512 // 99: stm: DCBF(r) 6513 // 98: stm: SET_CAUGHT_EXCEPTION(r) 6514 // 97: stm: NULL_CHECK(r) 6515 // 96: stm: LOWTABLESWITCH(r) 6516 else if (eruleno <= 189) { 6517 mark(p.getChild1(), ntsrule[0]); 6518 } 6519 // 191: r: CALL(BRANCH_TARGET,any) 6520 // 190: r: REF_SUB(INT_CONSTANT,r) 6521 else if (eruleno <= 191) { 6522 mark(p.getChild2(), ntsrule[0]); 6523 } 6524 // 210: r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6525 // 209: rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 6526 // 208: r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 6527 // 207: r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 6528 // 206: stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6529 // 205: stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 6530 // 204: stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6531 // 203: stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6532 // 202: stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 6533 // 201: stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 6534 // 200: rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6535 // 199: rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 6536 // 198: rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 6537 // 197: rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6538 // 196: rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6539 // 195: rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 6540 // 194: rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6541 // 193: rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6542 // 192: rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6543 else if (eruleno <= 210) { 6544 mark(p.getChild1().getChild1(), ntsrule[0]); 6545 } 6546 // 215: stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6547 // 214: stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6548 // 213: stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 6549 // 212: r: REF_OR(REF_NOT(r),REF_NOT(r)) 6550 // 211: r: REF_AND(REF_NOT(r),REF_NOT(r)) 6551 else if (eruleno <= 215) { 6552 mark(p.getChild1().getChild1(), ntsrule[0]); 6553 mark(p.getChild2().getChild1(), ntsrule[1]); 6554 } 6555 // 227: stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6556 // 226: stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6557 // 225: stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6558 // 224: stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6559 // 223: stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6560 // 222: stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6561 // 221: stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6562 // 220: stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6563 // 219: stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6564 // 218: stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6565 // 217: r: REF_OR(r,REF_NOT(r)) 6566 // 216: r: REF_AND(r,REF_NOT(r)) 6567 else if (eruleno <= 227) { 6568 mark(p.getChild1(), ntsrule[0]); 6569 mark(p.getChild2().getChild1(), ntsrule[1]); 6570 } 6571 // 239: r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 6572 // 238: rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 6573 // 237: stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 6574 // 236: stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 6575 // 235: stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 6576 // 234: stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 6577 // 233: stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 6578 // 232: rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 6579 // 231: rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 6580 // 230: r: REF_NOT(REF_XOR(r,r)) 6581 // 229: r: REF_NOT(REF_AND(r,r)) 6582 // 228: r: REF_NOT(REF_OR(r,r)) 6583 else if (eruleno <= 239) { 6584 mark(p.getChild1().getChild1(), ntsrule[0]); 6585 mark(p.getChild1().getChild2(), ntsrule[1]); 6586 } 6587 // 243: r: DOUBLE_SUB(DOUBLE_MUL(r,r),r) 6588 // 242: r: FLOAT_SUB(FLOAT_MUL(r,r),r) 6589 // 241: r: DOUBLE_ADD(DOUBLE_MUL(r,r),r) 6590 // 240: r: FLOAT_ADD(FLOAT_MUL(r,r),r) 6591 else if (eruleno <= 243) { 6592 mark(p.getChild1().getChild1(), ntsrule[0]); 6593 mark(p.getChild1().getChild2(), ntsrule[1]); 6594 mark(p.getChild2(), ntsrule[2]); 6595 } 6596 // 251: stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 6597 // 250: stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 6598 // 249: stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 6599 // 248: stm: INT_STORE(r,OTHER_OPERAND(r,r)) 6600 // 247: stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 6601 // 246: stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 6602 // 245: r: DOUBLE_ADD(r,DOUBLE_MUL(r,r)) 6603 // 244: r: FLOAT_ADD(r,FLOAT_MUL(r,r)) 6604 else if (eruleno <= 251) { 6605 mark(p.getChild1(), ntsrule[0]); 6606 mark(p.getChild2().getChild1(), ntsrule[1]); 6607 mark(p.getChild2().getChild2(), ntsrule[2]); 6608 } 6609 // 255: r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r,r),r)) 6610 // 254: r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r,r),r)) 6611 // 253: r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r,r),r)) 6612 // 252: r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r,r),r)) 6613 else if (eruleno <= 255) { 6614 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 6615 mark(p.getChild1().getChild1().getChild2(), ntsrule[1]); 6616 mark(p.getChild1().getChild2(), ntsrule[2]); 6617 } 6618 // 257: r: DOUBLE_NEG(DOUBLE_ADD(r,DOUBLE_MUL(r,r))) 6619 // 256: r: FLOAT_NEG(FLOAT_ADD(r,FLOAT_MUL(r,r))) 6620 else if (eruleno <= 257) { 6621 mark(p.getChild1().getChild1(), ntsrule[0]); 6622 mark(p.getChild1().getChild2().getChild1(), ntsrule[1]); 6623 mark(p.getChild1().getChild2().getChild2(), ntsrule[2]); 6624 } 6625 // 260: stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 6626 // 259: stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 6627 // 258: stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 6628 else if (eruleno <= 260) { 6629 mark(p.getChild1().getChild1(), ntsrule[0]); 6630 mark(p.getChild2().getChild1(), ntsrule[1]); 6631 mark(p.getChild2().getChild2(), ntsrule[2]); 6632 } 6633 // 262: stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6634 // 261: stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6635 else if (eruleno <= 262) { 6636 mark(p.getChild1(), ntsrule[0]); 6637 mark(p.getChild2().getChild1().getChild1(), ntsrule[1]); 6638 } 6639 // 263: rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6640 else { 6641 if (VM.VerifyAssertions) VM._assert(eruleno <= 263); 6642 mark(p.getChild1().getChild1().getChild1(), ntsrule[0]); 6643 } 6644 } 6645 6646 /** 6647 * For each BURS rule (the number of which provides the index) give its flags byte 6648 */ 6649 private static final byte[] action={ 6650 0, 6651 NOFLAGS, // 1 - stm: r 6652 NOFLAGS, // 2 - r: REGISTER 6653 NOFLAGS, // 3 - r: czr 6654 NOFLAGS, // 4 - r: rs 6655 NOFLAGS, // 5 - r: rz 6656 NOFLAGS, // 6 - rs: rp 6657 NOFLAGS, // 7 - rz: rp 6658 NOFLAGS, // 8 - any: NULL 6659 NOFLAGS, // 9 - any: r 6660 NOFLAGS, // 10 - any: ADDRESS_CONSTANT 6661 NOFLAGS, // 11 - any: INT_CONSTANT 6662 NOFLAGS, // 12 - any: LONG_CONSTANT 6663 NOFLAGS, // 13 - any: OTHER_OPERAND(any, any) 6664 EMIT_INSTRUCTION, // 14 - stm: RESOLVE 6665 EMIT_INSTRUCTION, // 15 - stm: IG_PATCH_POINT 6666 EMIT_INSTRUCTION, // 16 - stm: UNINT_BEGIN 6667 EMIT_INSTRUCTION, // 17 - stm: UNINT_END 6668 EMIT_INSTRUCTION, // 18 - stm: YIELDPOINT_PROLOGUE 6669 EMIT_INSTRUCTION, // 19 - stm: YIELDPOINT_EPILOGUE 6670 EMIT_INSTRUCTION, // 20 - stm: YIELDPOINT_BACKEDGE 6671 EMIT_INSTRUCTION, // 21 - stm: LOWTABLESWITCH(r) 6672 NOFLAGS, // 22 - stm: NOP 6673 EMIT_INSTRUCTION, // 23 - r: GUARD_MOVE 6674 EMIT_INSTRUCTION, // 24 - r: GUARD_COMBINE 6675 EMIT_INSTRUCTION, // 25 - stm: NULL_CHECK(r) 6676 EMIT_INSTRUCTION, // 26 - r: GET_CAUGHT_EXCEPTION 6677 EMIT_INSTRUCTION, // 27 - stm: SET_CAUGHT_EXCEPTION(r) 6678 EMIT_INSTRUCTION, // 28 - stm: FENCE 6679 EMIT_INSTRUCTION, // 29 - stm: WRITE_FLOOR 6680 EMIT_INSTRUCTION, // 30 - stm: READ_CEILING 6681 EMIT_INSTRUCTION, // 31 - stm: DCBF(r) 6682 EMIT_INSTRUCTION, // 32 - stm: DCBST(r) 6683 EMIT_INSTRUCTION, // 33 - stm: DCBT(r) 6684 EMIT_INSTRUCTION, // 34 - stm: DCBTST(r) 6685 EMIT_INSTRUCTION, // 35 - stm: DCBZ(r) 6686 EMIT_INSTRUCTION, // 36 - stm: DCBZL(r) 6687 EMIT_INSTRUCTION, // 37 - stm: ICBI(r) 6688 EMIT_INSTRUCTION, // 38 - stm: TRAP 6689 EMIT_INSTRUCTION, // 39 - stm: TRAP_IF(r,r) 6690 EMIT_INSTRUCTION, // 40 - stm: TRAP_IF(r,INT_CONSTANT) 6691 EMIT_INSTRUCTION, // 41 - stm: TRAP_IF(r,LONG_CONSTANT) 6692 EMIT_INSTRUCTION, // 42 - r: BOOLEAN_NOT(r) 6693 EMIT_INSTRUCTION, // 43 - r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6694 EMIT_INSTRUCTION, // 44 - r: BOOLEAN_CMP_INT(r,r) 6695 EMIT_INSTRUCTION, // 45 - boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 6696 EMIT_INSTRUCTION, // 46 - boolcmp: BOOLEAN_CMP_INT(r,r) 6697 EMIT_INSTRUCTION, // 47 - r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6698 EMIT_INSTRUCTION, // 48 - r: BOOLEAN_CMP_ADDR(r,r) 6699 EMIT_INSTRUCTION, // 49 - boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 6700 EMIT_INSTRUCTION, // 50 - boolcmp: BOOLEAN_CMP_ADDR(r,r) 6701 NOFLAGS, // 51 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6702 EMIT_INSTRUCTION, // 52 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6703 NOFLAGS, // 53 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6704 EMIT_INSTRUCTION, // 54 - boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6705 EMIT_INSTRUCTION, // 55 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6706 EMIT_INSTRUCTION, // 56 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6707 EMIT_INSTRUCTION, // 57 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6708 EMIT_INSTRUCTION, // 58 - r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 6709 EMIT_INSTRUCTION, // 59 - r: REF_ADD(r,INT_CONSTANT) 6710 EMIT_INSTRUCTION, // 60 - r: REF_ADD(r,r) 6711 EMIT_INSTRUCTION, // 61 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6712 EMIT_INSTRUCTION, // 62 - r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 6713 EMIT_INSTRUCTION, // 63 - r: REF_SUB(r,r) 6714 EMIT_INSTRUCTION, // 64 - r: REF_SUB(INT_CONSTANT,r) 6715 EMIT_INSTRUCTION, // 65 - r: INT_MUL(r,INT_CONSTANT) 6716 EMIT_INSTRUCTION, // 66 - r: INT_MUL(r,r) 6717 EMIT_INSTRUCTION, // 67 - r: INT_DIV(r,r) 6718 EMIT_INSTRUCTION, // 68 - r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 6719 EMIT_INSTRUCTION, // 69 - r: INT_REM(r,r) 6720 EMIT_INSTRUCTION, // 70 - r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 6721 EMIT_INSTRUCTION, // 71 - r: REF_NEG(r) 6722 EMIT_INSTRUCTION, // 72 - rz: INT_SHL(r,INT_CONSTANT) 6723 EMIT_INSTRUCTION, // 73 - rz: INT_SHL(r,r) 6724 EMIT_INSTRUCTION, // 74 - rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6725 EMIT_INSTRUCTION, // 75 - rs: INT_SHR(r,INT_CONSTANT) 6726 EMIT_INSTRUCTION, // 76 - rs: INT_SHR(r,r) 6727 EMIT_INSTRUCTION, // 77 - rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6728 EMIT_INSTRUCTION, // 78 - rp: INT_USHR(r,INT_CONSTANT) 6729 EMIT_INSTRUCTION, // 79 - rz: INT_USHR(r,r) 6730 EMIT_INSTRUCTION, // 80 - rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6731 EMIT_INSTRUCTION, // 81 - rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 6732 EMIT_INSTRUCTION, // 82 - rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6733 EMIT_INSTRUCTION, // 83 - r: REF_AND(r,r) 6734 EMIT_INSTRUCTION, // 84 - czr: REF_AND(r,INT_CONSTANT) 6735 EMIT_INSTRUCTION, // 85 - rp: REF_AND(r,INT_CONSTANT) 6736 EMIT_INSTRUCTION, // 86 - r: REF_AND(REF_NOT(r),REF_NOT(r)) 6737 EMIT_INSTRUCTION, // 87 - r: REF_AND(r,REF_NOT(r)) 6738 EMIT_INSTRUCTION, // 88 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6739 EMIT_INSTRUCTION, // 89 - rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 6740 EMIT_INSTRUCTION, // 90 - r: REF_OR(r,r) 6741 EMIT_INSTRUCTION, // 91 - r: REF_OR(r,INT_CONSTANT) 6742 EMIT_INSTRUCTION, // 92 - r: REF_OR(REF_NOT(r),REF_NOT(r)) 6743 EMIT_INSTRUCTION, // 93 - r: REF_OR(r,REF_NOT(r)) 6744 EMIT_INSTRUCTION, // 94 - r: REF_XOR(r,r) 6745 EMIT_INSTRUCTION, // 95 - r: REF_XOR(r,INT_CONSTANT) 6746 EMIT_INSTRUCTION, // 96 - r: REF_NOT(r) 6747 EMIT_INSTRUCTION, // 97 - r: REF_NOT(REF_OR(r,r)) 6748 EMIT_INSTRUCTION, // 98 - r: REF_NOT(REF_AND(r,r)) 6749 EMIT_INSTRUCTION, // 99 - r: REF_NOT(REF_XOR(r,r)) 6750 EMIT_INSTRUCTION, // 100 - r: FLOAT_ADD(r,r) 6751 EMIT_INSTRUCTION, // 101 - r: DOUBLE_ADD(r,r) 6752 EMIT_INSTRUCTION, // 102 - r: FLOAT_MUL(r,r) 6753 EMIT_INSTRUCTION, // 103 - r: DOUBLE_MUL(r,r) 6754 EMIT_INSTRUCTION, // 104 - r: FLOAT_SUB(r,r) 6755 EMIT_INSTRUCTION, // 105 - r: DOUBLE_SUB(r,r) 6756 EMIT_INSTRUCTION, // 106 - r: FLOAT_DIV(r,r) 6757 EMIT_INSTRUCTION, // 107 - r: DOUBLE_DIV(r,r) 6758 EMIT_INSTRUCTION, // 108 - r: FLOAT_NEG(r) 6759 EMIT_INSTRUCTION, // 109 - r: DOUBLE_NEG(r) 6760 EMIT_INSTRUCTION, // 110 - r: FLOAT_SQRT(r) 6761 EMIT_INSTRUCTION, // 111 - r: DOUBLE_SQRT(r) 6762 EMIT_INSTRUCTION, // 112 - r: FLOAT_ADD(FLOAT_MUL(r, r), r) 6763 EMIT_INSTRUCTION, // 113 - r: DOUBLE_ADD(DOUBLE_MUL(r, r), r) 6764 EMIT_INSTRUCTION, // 114 - r: FLOAT_ADD(r, FLOAT_MUL(r,r)) 6765 EMIT_INSTRUCTION, // 115 - r: DOUBLE_ADD(r, DOUBLE_MUL(r,r)) 6766 EMIT_INSTRUCTION, // 116 - r: FLOAT_SUB(FLOAT_MUL(r, r), r) 6767 EMIT_INSTRUCTION, // 117 - r: DOUBLE_SUB(DOUBLE_MUL(r, r), r) 6768 EMIT_INSTRUCTION, // 118 - r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r, r), r)) 6769 EMIT_INSTRUCTION, // 119 - r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r, r), r)) 6770 EMIT_INSTRUCTION, // 120 - r: FLOAT_NEG(FLOAT_ADD(r, FLOAT_MUL(r,r))) 6771 EMIT_INSTRUCTION, // 121 - r: DOUBLE_NEG(DOUBLE_ADD(r, DOUBLE_MUL(r,r))) 6772 EMIT_INSTRUCTION, // 122 - r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r, r), r)) 6773 EMIT_INSTRUCTION, // 123 - r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r, r), r)) 6774 EMIT_INSTRUCTION, // 124 - rs: INT_2BYTE(r) 6775 EMIT_INSTRUCTION, // 125 - rp: INT_2USHORT(r) 6776 EMIT_INSTRUCTION, // 126 - rs: INT_2SHORT(r) 6777 EMIT_INSTRUCTION, // 127 - r: INT_2FLOAT(r) 6778 EMIT_INSTRUCTION, // 128 - r: INT_2DOUBLE(r) 6779 EMIT_INSTRUCTION, // 129 - r: FLOAT_2INT(r) 6780 EMIT_INSTRUCTION, // 130 - r: FLOAT_2DOUBLE(r) 6781 EMIT_INSTRUCTION, // 131 - r: DOUBLE_2INT(r) 6782 EMIT_INSTRUCTION, // 132 - r: DOUBLE_2FLOAT(r) 6783 EMIT_INSTRUCTION, // 133 - r: FLOAT_AS_INT_BITS(r) 6784 EMIT_INSTRUCTION, // 134 - r: INT_BITS_AS_FLOAT(r) 6785 EMIT_INSTRUCTION, // 135 - r: REF_MOVE(r) 6786 EMIT_INSTRUCTION, // 136 - rs: REF_MOVE(INT_CONSTANT) 6787 EMIT_INSTRUCTION, // 137 - rs: REF_MOVE(INT_CONSTANT) 6788 EMIT_INSTRUCTION, // 138 - rs: REF_MOVE(INT_CONSTANT) 6789 EMIT_INSTRUCTION, // 139 - r: FLOAT_MOVE(r) 6790 EMIT_INSTRUCTION, // 140 - r: DOUBLE_MOVE(r) 6791 EMIT_INSTRUCTION, // 141 - rs: BYTE_LOAD(r,INT_CONSTANT) 6792 EMIT_INSTRUCTION, // 142 - rs: BYTE_LOAD(r,r) 6793 EMIT_INSTRUCTION, // 143 - rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 6794 EMIT_INSTRUCTION, // 144 - rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 6795 EMIT_INSTRUCTION, // 145 - rp: UBYTE_LOAD(r,INT_CONSTANT) 6796 EMIT_INSTRUCTION, // 146 - rp: UBYTE_LOAD(r,r) 6797 EMIT_INSTRUCTION, // 147 - rs: SHORT_LOAD(r,INT_CONSTANT) 6798 EMIT_INSTRUCTION, // 148 - rs: SHORT_LOAD(r,r) 6799 EMIT_INSTRUCTION, // 149 - rp: USHORT_LOAD(r,INT_CONSTANT) 6800 EMIT_INSTRUCTION, // 150 - rp: USHORT_LOAD(r,r) 6801 EMIT_INSTRUCTION, // 151 - r: FLOAT_LOAD(r,INT_CONSTANT) 6802 EMIT_INSTRUCTION, // 152 - r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6803 EMIT_INSTRUCTION, // 153 - r: FLOAT_LOAD(r,r) 6804 EMIT_INSTRUCTION, // 154 - r: DOUBLE_LOAD(r,INT_CONSTANT) 6805 EMIT_INSTRUCTION, // 155 - r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6806 EMIT_INSTRUCTION, // 156 - r: DOUBLE_LOAD(r,r) 6807 EMIT_INSTRUCTION, // 157 - rs: INT_LOAD(r,INT_CONSTANT) 6808 EMIT_INSTRUCTION, // 158 - rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6809 EMIT_INSTRUCTION, // 159 - rs: INT_LOAD(r,r) 6810 EMIT_INSTRUCTION, // 160 - rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 6811 EMIT_INSTRUCTION, // 161 - rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6812 EMIT_INSTRUCTION, // 162 - stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6813 EMIT_INSTRUCTION, // 163 - stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 6814 EMIT_INSTRUCTION, // 164 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 6815 EMIT_INSTRUCTION, // 165 - stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 6816 EMIT_INSTRUCTION, // 166 - stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6817 EMIT_INSTRUCTION, // 167 - stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 6818 EMIT_INSTRUCTION, // 168 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6819 EMIT_INSTRUCTION, // 169 - stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 6820 EMIT_INSTRUCTION, // 170 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 6821 EMIT_INSTRUCTION, // 171 - stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 6822 EMIT_INSTRUCTION, // 172 - stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6823 EMIT_INSTRUCTION, // 173 - stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6824 EMIT_INSTRUCTION, // 174 - stm: INT_STORE(r,OTHER_OPERAND(r,r)) 6825 EMIT_INSTRUCTION, // 175 - stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6826 EMIT_INSTRUCTION, // 176 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6827 EMIT_INSTRUCTION, // 177 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6828 EMIT_INSTRUCTION, // 178 - stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 6829 EMIT_INSTRUCTION, // 179 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6830 EMIT_INSTRUCTION, // 180 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6831 EMIT_INSTRUCTION, // 181 - stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 6832 EMIT_INSTRUCTION, // 182 - stm: INT_IFCMP(r,r) 6833 EMIT_INSTRUCTION, // 183 - stm: INT_IFCMP(r,INT_CONSTANT) 6834 EMIT_INSTRUCTION, // 184 - stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 6835 EMIT_INSTRUCTION, // 185 - stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 6836 EMIT_INSTRUCTION, // 186 - stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 6837 EMIT_INSTRUCTION, // 187 - stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 6838 EMIT_INSTRUCTION, // 188 - stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 6839 EMIT_INSTRUCTION, // 189 - stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 6840 EMIT_INSTRUCTION, // 190 - stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 6841 EMIT_INSTRUCTION, // 191 - stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 6842 EMIT_INSTRUCTION, // 192 - stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 6843 EMIT_INSTRUCTION, // 193 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 6844 EMIT_INSTRUCTION, // 194 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 6845 EMIT_INSTRUCTION, // 195 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 6846 EMIT_INSTRUCTION, // 196 - stm: INT_IFCMP(boolcmp, INT_CONSTANT) 6847 EMIT_INSTRUCTION, // 197 - stm: INT_IFCMP2(r,r) 6848 EMIT_INSTRUCTION, // 198 - stm: INT_IFCMP2(r,INT_CONSTANT) 6849 EMIT_INSTRUCTION, // 199 - stm: FLOAT_IFCMP(r,r) 6850 EMIT_INSTRUCTION, // 200 - stm: DOUBLE_IFCMP(r,r) 6851 EMIT_INSTRUCTION, // 201 - stm: FLOAT_CMPL(r,r) 6852 EMIT_INSTRUCTION, // 202 - stm: FLOAT_CMPG(r,r) 6853 EMIT_INSTRUCTION, // 203 - stm: DOUBLE_CMPL(r,r) 6854 EMIT_INSTRUCTION, // 204 - stm: DOUBLE_CMPG(r,r) 6855 EMIT_INSTRUCTION, // 205 - stm: GOTO 6856 EMIT_INSTRUCTION, // 206 - stm: RETURN(NULL) 6857 EMIT_INSTRUCTION, // 207 - stm: RETURN(r) 6858 EMIT_INSTRUCTION, // 208 - r: CALL(r,any) 6859 EMIT_INSTRUCTION, // 209 - r: CALL(BRANCH_TARGET,any) 6860 EMIT_INSTRUCTION, // 210 - r: SYSCALL(r,any) 6861 EMIT_INSTRUCTION, // 211 - r: GET_TIME_BASE 6862 NOFLAGS, // 212 - r: OTHER_OPERAND(r,r) 6863 EMIT_INSTRUCTION, // 213 - r: YIELDPOINT_OSR(any, any) 6864 EMIT_INSTRUCTION, // 214 - r: PREPARE_INT(r, r) 6865 EMIT_INSTRUCTION, // 215 - r: PREPARE_LONG(r, r) 6866 EMIT_INSTRUCTION, // 216 - r: ATTEMPT_INT(r, r) 6867 EMIT_INSTRUCTION, // 217 - r: ATTEMPT_LONG(r, r) 6868 EMIT_INSTRUCTION, // 218 - stm: IR_PROLOGUE 6869 EMIT_INSTRUCTION, // 219 - r: LONG_MUL(r,INT_CONSTANT) 6870 EMIT_INSTRUCTION, // 220 - r: LONG_MUL(r,r) 6871 EMIT_INSTRUCTION, // 221 - r: LONG_DIV(r,r) 6872 EMIT_INSTRUCTION, // 222 - r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 6873 EMIT_INSTRUCTION, // 223 - r: LONG_REM(r,r) 6874 EMIT_INSTRUCTION, // 224 - r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 6875 EMIT_INSTRUCTION, // 225 - r: LONG_SHL(r,INT_CONSTANT) 6876 EMIT_INSTRUCTION, // 226 - r: LONG_SHL(r,r) 6877 EMIT_INSTRUCTION, // 227 - r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 6878 EMIT_INSTRUCTION, // 228 - r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 6879 EMIT_INSTRUCTION, // 229 - r: LONG_SHR(r,INT_CONSTANT) 6880 EMIT_INSTRUCTION, // 230 - r: LONG_SHR(r,r) 6881 EMIT_INSTRUCTION, // 231 - r: LONG_USHR(r,INT_CONSTANT) 6882 EMIT_INSTRUCTION, // 232 - r: LONG_USHR(r,r) 6883 EMIT_INSTRUCTION, // 233 - rs: INT_2LONG(r) 6884 EMIT_INSTRUCTION, // 234 - rs: INT_2LONG(rs) 6885 EMIT_INSTRUCTION, // 235 - r: LONG_2INT(r) 6886 EMIT_INSTRUCTION, // 236 - r: FLOAT_2LONG(r) 6887 EMIT_INSTRUCTION, // 237 - r: DOUBLE_2LONG(r) 6888 EMIT_INSTRUCTION, // 238 - r: DOUBLE_AS_LONG_BITS(r) 6889 EMIT_INSTRUCTION, // 239 - r: LONG_BITS_AS_DOUBLE(r) 6890 EMIT_INSTRUCTION, // 240 - r: REF_MOVE(ADDRESS_CONSTANT) 6891 EMIT_INSTRUCTION, // 241 - r: REF_MOVE(LONG_CONSTANT) 6892 EMIT_INSTRUCTION, // 242 - r: LONG_CMP(r,r) 6893 EMIT_INSTRUCTION, // 243 - stm: LONG_IFCMP(r,r) 6894 EMIT_INSTRUCTION, // 244 - stm: LONG_IFCMP(r,INT_CONSTANT) 6895 EMIT_INSTRUCTION, // 245 - stm: LONG_IFCMP(r,LONG_CONSTANT) 6896 EMIT_INSTRUCTION, // 246 - stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 6897 EMIT_INSTRUCTION, // 247 - stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 6898 EMIT_INSTRUCTION, // 248 - rz: INT_2ADDRZerExt(rz) 6899 EMIT_INSTRUCTION, // 249 - rz: INT_2ADDRZerExt(r) 6900 EMIT_INSTRUCTION, // 250 - rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 6901 EMIT_INSTRUCTION, // 251 - rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 6902 EMIT_INSTRUCTION, // 252 - rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6903 EMIT_INSTRUCTION, // 253 - r: LONG_LOAD(r,INT_CONSTANT) 6904 EMIT_INSTRUCTION, // 254 - r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 6905 EMIT_INSTRUCTION, // 255 - r: LONG_LOAD(r,r) 6906 EMIT_INSTRUCTION, // 256 - r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 6907 EMIT_INSTRUCTION, // 257 - r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 6908 EMIT_INSTRUCTION, // 258 - stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 6909 EMIT_INSTRUCTION, // 259 - stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 6910 EMIT_INSTRUCTION, // 260 - stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 6911 EMIT_INSTRUCTION, // 261 - stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 6912 EMIT_INSTRUCTION, // 262 - r: PREPARE_ADDR(r, r) 6913 EMIT_INSTRUCTION, // 263 - r: ATTEMPT_ADDR(r, r) 6914 }; 6915 6916 /** 6917 * Gets the action flags (such as EMIT_INSTRUCTION) associated with the given 6918 * rule number. 6919 * 6920 * @param ruleno the rule number we want the action flags for 6921 * @return the action byte for the rule 6922 */ 6923 @Pure 6924 public static byte action(int ruleno) { 6925 return action[unsortedErnMap[ruleno]]; 6926 } 6927 6928 /** 6929 * Decode the target non-terminal and minimal cost covering statement 6930 * into the rule that produces the non-terminal 6931 * 6932 * @param goalnt the non-terminal that we wish to produce. 6933 * @param stateNT the state encoding the non-terminals associated associated 6934 * with covering a tree with minimal cost (computed by at compile time 6935 * by jburg). 6936 * @return the rule number 6937 */ 6938 @Pure 6939 public static char decode(int goalnt, int stateNT) { 6940 return decode[goalnt][stateNT]; 6941 } 6942 6943 6944 /** 6945 * Emit code for rule number 14: 6946 * stm: RESOLVE 6947 * @param p BURS node to apply the rule to 6948 */ 6949 private void code14(AbstractBURS_TreeNode p) { 6950 EMIT(P(p)); 6951 } 6952 6953 /** 6954 * Emit code for rule number 15: 6955 * stm: IG_PATCH_POINT 6956 * @param p BURS node to apply the rule to 6957 */ 6958 private void code15(AbstractBURS_TreeNode p) { 6959 EMIT(InlineGuard.mutate(P(p), IG_PATCH_POINT, null, null, null, InlineGuard.getTarget(P(p)), InlineGuard.getBranchProfile(P(p)))); 6960 } 6961 6962 /** 6963 * Emit code for rule number 16: 6964 * stm: UNINT_BEGIN 6965 * @param p BURS node to apply the rule to 6966 */ 6967 private void code16(AbstractBURS_TreeNode p) { 6968 EMIT(P(p)); 6969 } 6970 6971 /** 6972 * Emit code for rule number 17: 6973 * stm: UNINT_END 6974 * @param p BURS node to apply the rule to 6975 */ 6976 private void code17(AbstractBURS_TreeNode p) { 6977 EMIT(P(p)); 6978 } 6979 6980 /** 6981 * Emit code for rule number 18: 6982 * stm: YIELDPOINT_PROLOGUE 6983 * @param p BURS node to apply the rule to 6984 */ 6985 private void code18(AbstractBURS_TreeNode p) { 6986 EMIT(P(p)); 6987 } 6988 6989 /** 6990 * Emit code for rule number 19: 6991 * stm: YIELDPOINT_EPILOGUE 6992 * @param p BURS node to apply the rule to 6993 */ 6994 private void code19(AbstractBURS_TreeNode p) { 6995 EMIT(P(p)); 6996 } 6997 6998 /** 6999 * Emit code for rule number 20: 7000 * stm: YIELDPOINT_BACKEDGE 7001 * @param p BURS node to apply the rule to 7002 */ 7003 private void code20(AbstractBURS_TreeNode p) { 7004 EMIT(P(p)); 7005 } 7006 7007 /** 7008 * Emit code for rule number 21: 7009 * stm: LOWTABLESWITCH(r) 7010 * @param p BURS node to apply the rule to 7011 */ 7012 private void code21(AbstractBURS_TreeNode p) { 7013 LOWTABLESWITCH(P(p)); 7014 } 7015 7016 /** 7017 * Emit code for rule number 23: 7018 * r: GUARD_MOVE 7019 * @param p BURS node to apply the rule to 7020 */ 7021 private void code23(AbstractBURS_TreeNode p) { 7022 EMIT(P(p)); 7023 } 7024 7025 /** 7026 * Emit code for rule number 24: 7027 * r: GUARD_COMBINE 7028 * @param p BURS node to apply the rule to 7029 */ 7030 private void code24(AbstractBURS_TreeNode p) { 7031 EMIT(P(p)); 7032 } 7033 7034 /** 7035 * Emit code for rule number 25: 7036 * stm: NULL_CHECK(r) 7037 * @param p BURS node to apply the rule to 7038 */ 7039 private void code25(AbstractBURS_TreeNode p) { 7040 EMIT(P(p)); 7041 } 7042 7043 /** 7044 * Emit code for rule number 26: 7045 * r: GET_CAUGHT_EXCEPTION 7046 * @param p BURS node to apply the rule to 7047 */ 7048 private void code26(AbstractBURS_TreeNode p) { 7049 GET_EXCEPTION_OBJECT(P(p)); 7050 } 7051 7052 /** 7053 * Emit code for rule number 27: 7054 * stm: SET_CAUGHT_EXCEPTION(r) 7055 * @param p BURS node to apply the rule to 7056 */ 7057 private void code27(AbstractBURS_TreeNode p) { 7058 SET_EXCEPTION_OBJECT(P(p)); 7059 } 7060 7061 /** 7062 * Emit code for rule number 28: 7063 * stm: FENCE 7064 * @param p BURS node to apply the rule to 7065 */ 7066 private void code28(AbstractBURS_TreeNode p) { 7067 EMIT(MIR_Empty.mutate(P(p), PPC_HWSYNC)); 7068 } 7069 7070 /** 7071 * Emit code for rule number 29: 7072 * stm: WRITE_FLOOR 7073 * @param p BURS node to apply the rule to 7074 */ 7075 private void code29(AbstractBURS_TreeNode p) { 7076 EMIT(MIR_Empty.mutate(P(p), PPC_SYNC)); 7077 } 7078 7079 /** 7080 * Emit code for rule number 30: 7081 * stm: READ_CEILING 7082 * @param p BURS node to apply the rule to 7083 */ 7084 private void code30(AbstractBURS_TreeNode p) { 7085 EMIT(MIR_Empty.mutate(P(p), PPC_ISYNC)); 7086 } 7087 7088 /** 7089 * Emit code for rule number 31: 7090 * stm: DCBF(r) 7091 * @param p BURS node to apply the rule to 7092 */ 7093 private void code31(AbstractBURS_TreeNode p) { 7094 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBF, I(0), R(CacheOp.getRef(P(p))))); 7095 } 7096 7097 /** 7098 * Emit code for rule number 32: 7099 * stm: DCBST(r) 7100 * @param p BURS node to apply the rule to 7101 */ 7102 private void code32(AbstractBURS_TreeNode p) { 7103 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBST, I(0), R(CacheOp.getRef(P(p))))); 7104 } 7105 7106 /** 7107 * Emit code for rule number 33: 7108 * stm: DCBT(r) 7109 * @param p BURS node to apply the rule to 7110 */ 7111 private void code33(AbstractBURS_TreeNode p) { 7112 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBT, I(0), R(CacheOp.getRef(P(p))))); 7113 } 7114 7115 /** 7116 * Emit code for rule number 34: 7117 * stm: DCBTST(r) 7118 * @param p BURS node to apply the rule to 7119 */ 7120 private void code34(AbstractBURS_TreeNode p) { 7121 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBTST, I(0), R(CacheOp.getRef(P(p))))); 7122 } 7123 7124 /** 7125 * Emit code for rule number 35: 7126 * stm: DCBZ(r) 7127 * @param p BURS node to apply the rule to 7128 */ 7129 private void code35(AbstractBURS_TreeNode p) { 7130 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBZ, I(0), R(CacheOp.getRef(P(p))))); 7131 } 7132 7133 /** 7134 * Emit code for rule number 36: 7135 * stm: DCBZL(r) 7136 * @param p BURS node to apply the rule to 7137 */ 7138 private void code36(AbstractBURS_TreeNode p) { 7139 EMIT(MIR_CacheOp.mutate(P(p), PPC_DCBZL, I(0), R(CacheOp.getRef(P(p))))); 7140 } 7141 7142 /** 7143 * Emit code for rule number 37: 7144 * stm: ICBI(r) 7145 * @param p BURS node to apply the rule to 7146 */ 7147 private void code37(AbstractBURS_TreeNode p) { 7148 EMIT(MIR_CacheOp.mutate(P(p), PPC_ICBI, I(0), R(CacheOp.getRef(P(p))))); 7149 } 7150 7151 /** 7152 * Emit code for rule number 38: 7153 * stm: TRAP 7154 * @param p BURS node to apply the rule to 7155 */ 7156 private void code38(AbstractBURS_TreeNode p) { 7157 TRAP(P(p)); 7158 } 7159 7160 /** 7161 * Emit code for rule number 39: 7162 * stm: TRAP_IF(r,r) 7163 * @param p BURS node to apply the rule to 7164 */ 7165 private void code39(AbstractBURS_TreeNode p) { 7166 TRAP_IF(P(p)); 7167 } 7168 7169 /** 7170 * Emit code for rule number 40: 7171 * stm: TRAP_IF(r,INT_CONSTANT) 7172 * @param p BURS node to apply the rule to 7173 */ 7174 private void code40(AbstractBURS_TreeNode p) { 7175 TRAP_IF_IMM(P(p), false); 7176 } 7177 7178 /** 7179 * Emit code for rule number 41: 7180 * stm: TRAP_IF(r,LONG_CONSTANT) 7181 * @param p BURS node to apply the rule to 7182 */ 7183 private void code41(AbstractBURS_TreeNode p) { 7184 TRAP_IF_IMM(P(p), true); 7185 } 7186 7187 /** 7188 * Emit code for rule number 42: 7189 * r: BOOLEAN_NOT(r) 7190 * @param p BURS node to apply the rule to 7191 */ 7192 private void code42(AbstractBURS_TreeNode p) { 7193 EMIT(MIR_Binary.mutate(P(p), PPC_XORI, Unary.getResult(P(p)), R(Unary.getVal(P(p))), IC(1))); 7194 } 7195 7196 /** 7197 * Emit code for rule number 43: 7198 * r: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7199 * @param p BURS node to apply the rule to 7200 */ 7201 private void code43(AbstractBURS_TreeNode p) { 7202 BOOLEAN_CMP_INT_IMM(BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p)), R(BooleanCmp.getVal1(P(p))), IC(BooleanCmp.getVal2(P(p)))); 7203 } 7204 7205 /** 7206 * Emit code for rule number 44: 7207 * r: BOOLEAN_CMP_INT(r,r) 7208 * @param p BURS node to apply the rule to 7209 */ 7210 private void code44(AbstractBURS_TreeNode p) { 7211 BOOLEAN_CMP_INT(BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p)), R(BooleanCmp.getVal1(P(p))), R(BooleanCmp.getVal2(P(p)))); 7212 } 7213 7214 /** 7215 * Emit code for rule number 45: 7216 * boolcmp: BOOLEAN_CMP_INT(r,INT_CONSTANT) 7217 * @param p BURS node to apply the rule to 7218 */ 7219 private void code45(AbstractBURS_TreeNode p) { 7220 PUSH_BOOLCMP(BooleanCmp.getCond(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), false); 7221 } 7222 7223 /** 7224 * Emit code for rule number 46: 7225 * boolcmp: BOOLEAN_CMP_INT(r,r) 7226 * @param p BURS node to apply the rule to 7227 */ 7228 private void code46(AbstractBURS_TreeNode p) { 7229 PUSH_BOOLCMP(BooleanCmp.getCond(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), false); 7230 } 7231 7232 /** 7233 * Emit code for rule number 47: 7234 * r: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 7235 * @param p BURS node to apply the rule to 7236 */ 7237 private void code47(AbstractBURS_TreeNode p) { 7238 BOOLEAN_CMP_ADDR_IMM(BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p)), R(BooleanCmp.getVal1(P(p))), IC(BooleanCmp.getVal2(P(p)))); 7239 } 7240 7241 /** 7242 * Emit code for rule number 48: 7243 * r: BOOLEAN_CMP_ADDR(r,r) 7244 * @param p BURS node to apply the rule to 7245 */ 7246 private void code48(AbstractBURS_TreeNode p) { 7247 BOOLEAN_CMP_ADDR(BooleanCmp.getResult(P(p)), BooleanCmp.getCond(P(p)), R(BooleanCmp.getVal1(P(p))), R(BooleanCmp.getVal2(P(p)))); 7248 } 7249 7250 /** 7251 * Emit code for rule number 49: 7252 * boolcmp: BOOLEAN_CMP_ADDR(r,INT_CONSTANT) 7253 * @param p BURS node to apply the rule to 7254 */ 7255 private void code49(AbstractBURS_TreeNode p) { 7256 PUSH_BOOLCMP(BooleanCmp.getCond(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), true); 7257 } 7258 7259 /** 7260 * Emit code for rule number 50: 7261 * boolcmp: BOOLEAN_CMP_ADDR(r,r) 7262 * @param p BURS node to apply the rule to 7263 */ 7264 private void code50(AbstractBURS_TreeNode p) { 7265 PUSH_BOOLCMP(BooleanCmp.getCond(P(p)), BooleanCmp.getVal1(P(p)), BooleanCmp.getVal2(P(p)), true); 7266 } 7267 7268 /** 7269 * Emit code for rule number 52: 7270 * boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7271 * @param p BURS node to apply the rule to 7272 */ 7273 private void code52(AbstractBURS_TreeNode p) { 7274 FLIP_BOOLCMP(); // invert condition 7275 } 7276 7277 /** 7278 * Emit code for rule number 54: 7279 * boolcmp: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7280 * @param p BURS node to apply the rule to 7281 */ 7282 private void code54(AbstractBURS_TreeNode p) { 7283 FLIP_BOOLCMP(); // invert condition 7284 } 7285 7286 /** 7287 * Emit code for rule number 55: 7288 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7289 * @param p BURS node to apply the rule to 7290 */ 7291 private void code55(AbstractBURS_TreeNode p) { 7292 EMIT_PUSHED_BOOLCMP(BooleanCmp.getResult(P(p))); 7293 } 7294 7295 /** 7296 * Emit code for rule number 56: 7297 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7298 * @param p BURS node to apply the rule to 7299 */ 7300 private void code56(AbstractBURS_TreeNode p) { 7301 FLIP_BOOLCMP(); EMIT_PUSHED_BOOLCMP(BooleanCmp.getResult(P(p))); 7302 } 7303 7304 /** 7305 * Emit code for rule number 57: 7306 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7307 * @param p BURS node to apply the rule to 7308 */ 7309 private void code57(AbstractBURS_TreeNode p) { 7310 EMIT_PUSHED_BOOLCMP(BooleanCmp.getResult(P(p))); 7311 } 7312 7313 /** 7314 * Emit code for rule number 58: 7315 * r: BOOLEAN_CMP_INT(boolcmp, INT_CONSTANT) 7316 * @param p BURS node to apply the rule to 7317 */ 7318 private void code58(AbstractBURS_TreeNode p) { 7319 FLIP_BOOLCMP(); EMIT_PUSHED_BOOLCMP(BooleanCmp.getResult(P(p))); 7320 } 7321 7322 /** 7323 * Emit code for rule number 59: 7324 * r: REF_ADD(r,INT_CONSTANT) 7325 * @param p BURS node to apply the rule to 7326 */ 7327 private void code59(AbstractBURS_TreeNode p) { 7328 EMIT(MIR_Binary.mutate(P(p), PPC_ADDI, Binary.getResult(P(p)), 7329 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7330 } 7331 7332 /** 7333 * Emit code for rule number 60: 7334 * r: REF_ADD(r,r) 7335 * @param p BURS node to apply the rule to 7336 */ 7337 private void code60(AbstractBURS_TreeNode p) { 7338 EMIT(MIR_Binary.mutate(P(p), PPC_ADD, Binary.getResult(P(p)), 7339 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7340 } 7341 7342 /** 7343 * Emit code for rule number 61: 7344 * r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 7345 * @param p BURS node to apply the rule to 7346 */ 7347 private void code61(AbstractBURS_TreeNode p) { 7348 { 7349 int val = IV(Move.getVal(PR(p))); 7350 EMIT(MIR_Binary.create(PPC_ADDI, Move.getResult(PR(p)), 7351 R(Binary.getVal1(P(p))), CAL16(val))); 7352 EMIT(MIR_Binary.mutate(P(p), PPC_ADDIS, Binary.getResult(P(p)), 7353 Move.getResult(PR(p)).copyRO(), CAU16(val))); 7354} 7355 } 7356 7357 /** 7358 * Emit code for rule number 62: 7359 * r: REF_ADD(r,REF_MOVE(INT_CONSTANT)) 7360 * @param p BURS node to apply the rule to 7361 */ 7362 private void code62(AbstractBURS_TreeNode p) { 7363 EMIT(MIR_Binary.mutate(P(p), PPC_ADDIS, Binary.getResult(P(p)), 7364 R(Binary.getVal1(P(p))), CAU16(IV(Move.getVal(PR(p)))))); 7365 } 7366 7367 /** 7368 * Emit code for rule number 63: 7369 * r: REF_SUB(r,r) 7370 * @param p BURS node to apply the rule to 7371 */ 7372 private void code63(AbstractBURS_TreeNode p) { 7373 EMIT(MIR_Binary.mutate(P(p), PPC_SUBF, Binary.getResult(P(p)), 7374 R(Binary.getVal2(P(p))), Binary.getVal1(P(p)))); 7375 } 7376 7377 /** 7378 * Emit code for rule number 64: 7379 * r: REF_SUB(INT_CONSTANT,r) 7380 * @param p BURS node to apply the rule to 7381 */ 7382 private void code64(AbstractBURS_TreeNode p) { 7383 EMIT(MIR_Binary.mutate(P(p), PPC_SUBFIC, Binary.getResult(P(p)), 7384 R(Binary.getVal2(P(p))), Binary.getVal1(P(p)))); 7385 } 7386 7387 /** 7388 * Emit code for rule number 65: 7389 * r: INT_MUL(r,INT_CONSTANT) 7390 * @param p BURS node to apply the rule to 7391 */ 7392 private void code65(AbstractBURS_TreeNode p) { 7393 EMIT(MIR_Binary.mutate(P(p), PPC_MULLI, Binary.getResult(P(p)), 7394 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7395 } 7396 7397 /** 7398 * Emit code for rule number 66: 7399 * r: INT_MUL(r,r) 7400 * @param p BURS node to apply the rule to 7401 */ 7402 private void code66(AbstractBURS_TreeNode p) { 7403 EMIT(MIR_Binary.mutate(P(p), PPC_MULLW, Binary.getResult(P(p)), 7404 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7405 } 7406 7407 /** 7408 * Emit code for rule number 67: 7409 * r: INT_DIV(r,r) 7410 * @param p BURS node to apply the rule to 7411 */ 7412 private void code67(AbstractBURS_TreeNode p) { 7413 EMIT(MIR_Binary.mutate(P(p), PPC_DIVW, GuardedBinary.getResult(P(p)), 7414 R(GuardedBinary.getVal1(P(p))), GuardedBinary.getVal2(P(p)))); 7415 } 7416 7417 /** 7418 * Emit code for rule number 68: 7419 * r: INT_DIV(r,REF_MOVE(INT_CONSTANT)) 7420 * @param p BURS node to apply the rule to 7421 */ 7422 private void code68(AbstractBURS_TreeNode p) { 7423 INT_DIV_IMM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), 7424 Move.getResult(PR(p)), IC(Move.getVal(PR(p)))); 7425 } 7426 7427 /** 7428 * Emit code for rule number 69: 7429 * r: INT_REM(r,r) 7430 * @param p BURS node to apply the rule to 7431 */ 7432 private void code69(AbstractBURS_TreeNode p) { 7433 INT_REM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), R(GuardedBinary.getVal2(P(p)))); 7434 } 7435 7436 /** 7437 * Emit code for rule number 70: 7438 * r: INT_REM(r,REF_MOVE(INT_CONSTANT)) 7439 * @param p BURS node to apply the rule to 7440 */ 7441 private void code70(AbstractBURS_TreeNode p) { 7442 INT_REM_IMM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), 7443 Move.getResult(PR(p)), IC(Move.getVal(PR(p)))); 7444 } 7445 7446 /** 7447 * Emit code for rule number 71: 7448 * r: REF_NEG(r) 7449 * @param p BURS node to apply the rule to 7450 */ 7451 private void code71(AbstractBURS_TreeNode p) { 7452 EMIT(MIR_Unary.mutate(P(p), PPC_NEG, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7453 } 7454 7455 /** 7456 * Emit code for rule number 72: 7457 * rz: INT_SHL(r,INT_CONSTANT) 7458 * @param p BURS node to apply the rule to 7459 */ 7460 private void code72(AbstractBURS_TreeNode p) { 7461 EMIT(MIR_Binary.mutate(P(p), PPC_SLWI, Binary.getResult(P(p)), 7462 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7463 } 7464 7465 /** 7466 * Emit code for rule number 73: 7467 * rz: INT_SHL(r,r) 7468 * @param p BURS node to apply the rule to 7469 */ 7470 private void code73(AbstractBURS_TreeNode p) { 7471 EMIT(MIR_Binary.mutate(P(p), PPC_SLW, Binary.getResult(P(p)), 7472 R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))))); 7473 } 7474 7475 /** 7476 * Emit code for rule number 74: 7477 * rz: INT_SHL(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 7478 * @param p BURS node to apply the rule to 7479 */ 7480 private void code74(AbstractBURS_TreeNode p) { 7481 USHR_SHL(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), IC(Binary.getVal2(PL(p))), 7482 IC(Binary.getVal2(P(p)))); 7483 } 7484 7485 /** 7486 * Emit code for rule number 75: 7487 * rs: INT_SHR(r,INT_CONSTANT) 7488 * @param p BURS node to apply the rule to 7489 */ 7490 private void code75(AbstractBURS_TreeNode p) { 7491 EMIT(MIR_Binary.mutate(P(p), PPC_SRAWI, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7492 } 7493 7494 /** 7495 * Emit code for rule number 76: 7496 * rs: INT_SHR(r,r) 7497 * @param p BURS node to apply the rule to 7498 */ 7499 private void code76(AbstractBURS_TreeNode p) { 7500 EMIT(MIR_Binary.mutate(P(p), PPC_SRAW, Binary.getResult(P(p)), 7501 R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))))); 7502 } 7503 7504 /** 7505 * Emit code for rule number 77: 7506 * rp: INT_SHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 7507 * @param p BURS node to apply the rule to 7508 */ 7509 private void code77(AbstractBURS_TreeNode p) { 7510 AND_USHR(P(p), Binary.getResult(P(p)), 7511 R(Binary.getVal1(PL(p))), IC(Binary.getVal2(PL(p))), 7512 IC(Binary.getVal2(P(p)))); 7513 } 7514 7515 /** 7516 * Emit code for rule number 78: 7517 * rp: INT_USHR(r,INT_CONSTANT) 7518 * @param p BURS node to apply the rule to 7519 */ 7520 private void code78(AbstractBURS_TreeNode p) { 7521 EMIT(MIR_Binary.mutate(P(p), PPC_SRWI, Binary.getResult(P(p)), 7522 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7523 } 7524 7525 /** 7526 * Emit code for rule number 79: 7527 * rz: INT_USHR(r,r) 7528 * @param p BURS node to apply the rule to 7529 */ 7530 private void code79(AbstractBURS_TreeNode p) { 7531 EMIT(MIR_Binary.mutate(P(p), PPC_SRW, Binary.getResult(P(p)), 7532 R(Binary.getVal1(P(p))), R(Binary.getVal2(P(p))))); 7533 } 7534 7535 /** 7536 * Emit code for rule number 80: 7537 * rp: INT_USHR(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 7538 * @param p BURS node to apply the rule to 7539 */ 7540 private void code80(AbstractBURS_TreeNode p) { 7541 AND_USHR(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 7542 IC(Binary.getVal2(PL(p))), IC(Binary.getVal2(P(p)))); 7543 } 7544 7545 /** 7546 * Emit code for rule number 81: 7547 * rp: INT_USHR(REF_AND(r,REF_MOVE(INT_CONSTANT)),INT_CONSTANT) 7548 * @param p BURS node to apply the rule to 7549 */ 7550 private void code81(AbstractBURS_TreeNode p) { 7551 AND_USHR(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 7552 IC(Move.getVal(PLR(p))), IC(Binary.getVal2(P(p)))); 7553 } 7554 7555 /** 7556 * Emit code for rule number 82: 7557 * rp: INT_USHR(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 7558 * @param p BURS node to apply the rule to 7559 */ 7560 private void code82(AbstractBURS_TreeNode p) { 7561 SHL_USHR(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 7562 IC(Binary.getVal2(PL(p))), IC(Binary.getVal2(P(p)))); 7563 } 7564 7565 /** 7566 * Emit code for rule number 83: 7567 * r: REF_AND(r,r) 7568 * @param p BURS node to apply the rule to 7569 */ 7570 private void code83(AbstractBURS_TreeNode p) { 7571 EMIT(MIR_Binary.mutate(P(p), PPC_AND, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7572 } 7573 7574 /** 7575 * Emit code for rule number 84: 7576 * czr: REF_AND(r,INT_CONSTANT) 7577 * @param p BURS node to apply the rule to 7578 */ 7579 private void code84(AbstractBURS_TreeNode p) { 7580 EMIT(MIR_Binary.mutate(P(p), PPC_ANDIr, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), IC(Binary.getVal2(P(p))))); 7581 } 7582 7583 /** 7584 * Emit code for rule number 85: 7585 * rp: REF_AND(r,INT_CONSTANT) 7586 * @param p BURS node to apply the rule to 7587 */ 7588 private void code85(AbstractBURS_TreeNode p) { 7589 { 7590 int mask = IV(Binary.getVal2(P(p))); 7591 EMIT(MIR_RotateAndMask.create(PPC_RLWINM, Binary.getResult(P(p)), 7592 R(Binary.getVal1(P(p))), IC(0), 7593 IC(MaskBegin(mask)), IC(MaskEnd(mask)))); 7594} 7595 } 7596 7597 /** 7598 * Emit code for rule number 86: 7599 * r: REF_AND(REF_NOT(r),REF_NOT(r)) 7600 * @param p BURS node to apply the rule to 7601 */ 7602 private void code86(AbstractBURS_TreeNode p) { 7603 EMIT(MIR_Binary.mutate(P(p), PPC_NOR, Binary.getResult(P(p)), 7604 R(Unary.getVal(PL(p))), Unary.getVal(PR(p)))); 7605 } 7606 7607 /** 7608 * Emit code for rule number 87: 7609 * r: REF_AND(r,REF_NOT(r)) 7610 * @param p BURS node to apply the rule to 7611 */ 7612 private void code87(AbstractBURS_TreeNode p) { 7613 EMIT(MIR_Binary.mutate(P(p), PPC_ANDC, Binary.getResult(P(p)), 7614 R(Binary.getVal1(P(p))), Unary.getVal(PR(p)))); 7615 } 7616 7617 /** 7618 * Emit code for rule number 88: 7619 * rp: REF_AND(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 7620 * @param p BURS node to apply the rule to 7621 */ 7622 private void code88(AbstractBURS_TreeNode p) { 7623 USHR_AND(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 7624 IC(Binary.getVal2(P(p))), IC(Binary.getVal2(PL(p)))); 7625 } 7626 7627 /** 7628 * Emit code for rule number 89: 7629 * rp: REF_AND(INT_USHR(r,INT_CONSTANT),REF_MOVE(INT_CONSTANT)) 7630 * @param p BURS node to apply the rule to 7631 */ 7632 private void code89(AbstractBURS_TreeNode p) { 7633 USHR_AND(P(p), Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 7634 IC(Move.getVal(PR(p))), IC(Binary.getVal2(PL(p)))); 7635 } 7636 7637 /** 7638 * Emit code for rule number 90: 7639 * r: REF_OR(r,r) 7640 * @param p BURS node to apply the rule to 7641 */ 7642 private void code90(AbstractBURS_TreeNode p) { 7643 EMIT(MIR_Binary.mutate(P(p), PPC_OR, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7644 } 7645 7646 /** 7647 * Emit code for rule number 91: 7648 * r: REF_OR(r,INT_CONSTANT) 7649 * @param p BURS node to apply the rule to 7650 */ 7651 private void code91(AbstractBURS_TreeNode p) { 7652 EMIT(MIR_Binary.mutate(P(p), PPC_ORI, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7653 } 7654 7655 /** 7656 * Emit code for rule number 92: 7657 * r: REF_OR(REF_NOT(r),REF_NOT(r)) 7658 * @param p BURS node to apply the rule to 7659 */ 7660 private void code92(AbstractBURS_TreeNode p) { 7661 EMIT(MIR_Binary.mutate(P(p), PPC_NAND, Binary.getResult(P(p)), R(Unary.getVal(PL(p))), Unary.getVal(PR(p)))); 7662 } 7663 7664 /** 7665 * Emit code for rule number 93: 7666 * r: REF_OR(r,REF_NOT(r)) 7667 * @param p BURS node to apply the rule to 7668 */ 7669 private void code93(AbstractBURS_TreeNode p) { 7670 EMIT(MIR_Binary.mutate(P(p), PPC_ORC, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Unary.getVal(PR(p)))); 7671 } 7672 7673 /** 7674 * Emit code for rule number 94: 7675 * r: REF_XOR(r,r) 7676 * @param p BURS node to apply the rule to 7677 */ 7678 private void code94(AbstractBURS_TreeNode p) { 7679 EMIT(MIR_Binary.mutate(P(p), PPC_XOR, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7680 } 7681 7682 /** 7683 * Emit code for rule number 95: 7684 * r: REF_XOR(r,INT_CONSTANT) 7685 * @param p BURS node to apply the rule to 7686 */ 7687 private void code95(AbstractBURS_TreeNode p) { 7688 EMIT(MIR_Binary.mutate(P(p), PPC_XORI, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7689 } 7690 7691 /** 7692 * Emit code for rule number 96: 7693 * r: REF_NOT(r) 7694 * @param p BURS node to apply the rule to 7695 */ 7696 private void code96(AbstractBURS_TreeNode p) { 7697 EMIT(MIR_Binary.mutate(P(p), PPC_NOR, Unary.getResult(P(p)), R(Unary.getVal(P(p))), Unary.getVal(P(p)))); 7698 } 7699 7700 /** 7701 * Emit code for rule number 97: 7702 * r: REF_NOT(REF_OR(r,r)) 7703 * @param p BURS node to apply the rule to 7704 */ 7705 private void code97(AbstractBURS_TreeNode p) { 7706 EMIT(MIR_Binary.mutate(P(p), PPC_NOR, Unary.getResult(P(p)), R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)))); 7707 } 7708 7709 /** 7710 * Emit code for rule number 98: 7711 * r: REF_NOT(REF_AND(r,r)) 7712 * @param p BURS node to apply the rule to 7713 */ 7714 private void code98(AbstractBURS_TreeNode p) { 7715 EMIT(MIR_Binary.mutate(P(p), PPC_NAND, Unary.getResult(P(p)), R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)))); 7716 } 7717 7718 /** 7719 * Emit code for rule number 99: 7720 * r: REF_NOT(REF_XOR(r,r)) 7721 * @param p BURS node to apply the rule to 7722 */ 7723 private void code99(AbstractBURS_TreeNode p) { 7724 EMIT(MIR_Binary.mutate(P(p), PPC_EQV, Unary.getResult(P(p)), R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)))); 7725 } 7726 7727 /** 7728 * Emit code for rule number 100: 7729 * r: FLOAT_ADD(r,r) 7730 * @param p BURS node to apply the rule to 7731 */ 7732 private void code100(AbstractBURS_TreeNode p) { 7733 EMIT(MIR_Binary.mutate(P(p), PPC_FADDS, Binary.getResult(P(p)), 7734 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7735 } 7736 7737 /** 7738 * Emit code for rule number 101: 7739 * r: DOUBLE_ADD(r,r) 7740 * @param p BURS node to apply the rule to 7741 */ 7742 private void code101(AbstractBURS_TreeNode p) { 7743 EMIT(MIR_Binary.mutate(P(p), PPC_FADD, Binary.getResult(P(p)), 7744 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7745 } 7746 7747 /** 7748 * Emit code for rule number 102: 7749 * r: FLOAT_MUL(r,r) 7750 * @param p BURS node to apply the rule to 7751 */ 7752 private void code102(AbstractBURS_TreeNode p) { 7753 EMIT(MIR_Binary.mutate(P(p), PPC_FMULS, Binary.getResult(P(p)), 7754 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7755 } 7756 7757 /** 7758 * Emit code for rule number 103: 7759 * r: DOUBLE_MUL(r,r) 7760 * @param p BURS node to apply the rule to 7761 */ 7762 private void code103(AbstractBURS_TreeNode p) { 7763 EMIT(MIR_Binary.mutate(P(p), PPC_FMUL, Binary.getResult(P(p)), 7764 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7765 } 7766 7767 /** 7768 * Emit code for rule number 104: 7769 * r: FLOAT_SUB(r,r) 7770 * @param p BURS node to apply the rule to 7771 */ 7772 private void code104(AbstractBURS_TreeNode p) { 7773 EMIT(MIR_Binary.mutate(P(p), PPC_FSUBS, Binary.getResult(P(p)), 7774 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7775 } 7776 7777 /** 7778 * Emit code for rule number 105: 7779 * r: DOUBLE_SUB(r,r) 7780 * @param p BURS node to apply the rule to 7781 */ 7782 private void code105(AbstractBURS_TreeNode p) { 7783 EMIT(MIR_Binary.mutate(P(p), PPC_FSUB, Binary.getResult(P(p)), 7784 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7785 } 7786 7787 /** 7788 * Emit code for rule number 106: 7789 * r: FLOAT_DIV(r,r) 7790 * @param p BURS node to apply the rule to 7791 */ 7792 private void code106(AbstractBURS_TreeNode p) { 7793 EMIT(MIR_Binary.mutate(P(p), PPC_FDIVS, Binary.getResult(P(p)), 7794 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7795 } 7796 7797 /** 7798 * Emit code for rule number 107: 7799 * r: DOUBLE_DIV(r,r) 7800 * @param p BURS node to apply the rule to 7801 */ 7802 private void code107(AbstractBURS_TreeNode p) { 7803 EMIT(MIR_Binary.mutate(P(p), PPC_FDIV, Binary.getResult(P(p)), 7804 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 7805 } 7806 7807 /** 7808 * Emit code for rule number 108: 7809 * r: FLOAT_NEG(r) 7810 * @param p BURS node to apply the rule to 7811 */ 7812 private void code108(AbstractBURS_TreeNode p) { 7813 EMIT(MIR_Unary.mutate(P(p), PPC_FNEG, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7814 } 7815 7816 /** 7817 * Emit code for rule number 109: 7818 * r: DOUBLE_NEG(r) 7819 * @param p BURS node to apply the rule to 7820 */ 7821 private void code109(AbstractBURS_TreeNode p) { 7822 EMIT(MIR_Unary.mutate(P(p), PPC_FNEG, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7823 } 7824 7825 /** 7826 * Emit code for rule number 110: 7827 * r: FLOAT_SQRT(r) 7828 * @param p BURS node to apply the rule to 7829 */ 7830 private void code110(AbstractBURS_TreeNode p) { 7831 EMIT(MIR_Unary.mutate(P(p), PPC_FSQRTS, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7832 } 7833 7834 /** 7835 * Emit code for rule number 111: 7836 * r: DOUBLE_SQRT(r) 7837 * @param p BURS node to apply the rule to 7838 */ 7839 private void code111(AbstractBURS_TreeNode p) { 7840 EMIT(MIR_Unary.mutate(P(p), PPC_FSQRT, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7841 } 7842 7843 /** 7844 * Emit code for rule number 112: 7845 * r: FLOAT_ADD(FLOAT_MUL(r, r), r) 7846 * @param p BURS node to apply the rule to 7847 */ 7848 private void code112(AbstractBURS_TreeNode p) { 7849 EMIT(MIR_Ternary.mutate(P(p), PPC_FMADDS, Binary.getResult(P(p)), 7850 R(Binary.getVal1(PL(p))), R(Binary.getVal2(PL(p))), 7851 R(Binary.getVal2(P(p))))); 7852 } 7853 7854 /** 7855 * Emit code for rule number 113: 7856 * r: DOUBLE_ADD(DOUBLE_MUL(r, r), r) 7857 * @param p BURS node to apply the rule to 7858 */ 7859 private void code113(AbstractBURS_TreeNode p) { 7860 EMIT(MIR_Ternary.mutate(P(p), PPC_FMADD, Binary.getResult(P(p)), 7861 R(Binary.getVal1(PL(p))), R(Binary.getVal2(PL(p))), 7862 R(Binary.getVal2(P(p))))); 7863 } 7864 7865 /** 7866 * Emit code for rule number 114: 7867 * r: FLOAT_ADD(r, FLOAT_MUL(r,r)) 7868 * @param p BURS node to apply the rule to 7869 */ 7870 private void code114(AbstractBURS_TreeNode p) { 7871 EMIT(MIR_Ternary.mutate(P(p), PPC_FMADDS, Binary.getResult(P(p)), 7872 R(Binary.getVal1(PR(p))), R(Binary.getVal2(PR(p))), 7873 R(Binary.getVal1(P(p))))); 7874 } 7875 7876 /** 7877 * Emit code for rule number 115: 7878 * r: DOUBLE_ADD(r, DOUBLE_MUL(r,r)) 7879 * @param p BURS node to apply the rule to 7880 */ 7881 private void code115(AbstractBURS_TreeNode p) { 7882 EMIT(MIR_Ternary.mutate(P(p), PPC_FMADD, Binary.getResult(P(p)), 7883 R(Binary.getVal1(PR(p))), R(Binary.getVal2(PR(p))), 7884 R(Binary.getVal1(P(p))))); 7885 } 7886 7887 /** 7888 * Emit code for rule number 116: 7889 * r: FLOAT_SUB(FLOAT_MUL(r, r), r) 7890 * @param p BURS node to apply the rule to 7891 */ 7892 private void code116(AbstractBURS_TreeNode p) { 7893 EMIT(MIR_Ternary.mutate(P(p), PPC_FMSUBS, Binary.getResult(P(p)), 7894 R(Binary.getVal1(PL(p))), R(Binary.getVal2(PL(p))), 7895 R(Binary.getVal2(P(p))))); 7896 } 7897 7898 /** 7899 * Emit code for rule number 117: 7900 * r: DOUBLE_SUB(DOUBLE_MUL(r, r), r) 7901 * @param p BURS node to apply the rule to 7902 */ 7903 private void code117(AbstractBURS_TreeNode p) { 7904 EMIT(MIR_Ternary.mutate(P(p), PPC_FMSUB, Binary.getResult(P(p)), 7905 R(Binary.getVal1(PL(p))), R(Binary.getVal2(PL(p))), 7906 R(Binary.getVal2(P(p))))); 7907 } 7908 7909 /** 7910 * Emit code for rule number 118: 7911 * r: FLOAT_NEG(FLOAT_ADD(FLOAT_MUL(r, r), r)) 7912 * @param p BURS node to apply the rule to 7913 */ 7914 private void code118(AbstractBURS_TreeNode p) { 7915 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMADDS, Unary.getResult(P(p)), 7916 R(Binary.getVal1(PLL(p))), R(Binary.getVal2(PLL(p))), 7917 R(Binary.getVal2(PL(p))))); 7918 } 7919 7920 /** 7921 * Emit code for rule number 119: 7922 * r: DOUBLE_NEG(DOUBLE_ADD(DOUBLE_MUL(r, r), r)) 7923 * @param p BURS node to apply the rule to 7924 */ 7925 private void code119(AbstractBURS_TreeNode p) { 7926 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMADD, Unary.getResult(P(p)), 7927 R(Binary.getVal1(PLL(p))), R(Binary.getVal2(PLL(p))), 7928 R(Binary.getVal2(PL(p))))); 7929 } 7930 7931 /** 7932 * Emit code for rule number 120: 7933 * r: FLOAT_NEG(FLOAT_ADD(r, FLOAT_MUL(r,r))) 7934 * @param p BURS node to apply the rule to 7935 */ 7936 private void code120(AbstractBURS_TreeNode p) { 7937 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMADDS, Unary.getResult(P(p)), 7938 R(Binary.getVal1(PLR(p))), R(Binary.getVal2(PLR(p))), 7939 R(Binary.getVal1(PL(p))))); 7940 } 7941 7942 /** 7943 * Emit code for rule number 121: 7944 * r: DOUBLE_NEG(DOUBLE_ADD(r, DOUBLE_MUL(r,r))) 7945 * @param p BURS node to apply the rule to 7946 */ 7947 private void code121(AbstractBURS_TreeNode p) { 7948 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMADD, Unary.getResult(P(p)), 7949 R(Binary.getVal1(PLR(p))), R(Binary.getVal2(PLR(p))), 7950 R(Binary.getVal1(PL(p))))); 7951 } 7952 7953 /** 7954 * Emit code for rule number 122: 7955 * r: FLOAT_NEG(FLOAT_SUB(FLOAT_MUL(r, r), r)) 7956 * @param p BURS node to apply the rule to 7957 */ 7958 private void code122(AbstractBURS_TreeNode p) { 7959 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMSUBS, Unary.getResult(P(p)), 7960 R(Binary.getVal1(PLL(p))), R(Binary.getVal2(PLL(p))), 7961 R(Binary.getVal2(PL(p))))); 7962 } 7963 7964 /** 7965 * Emit code for rule number 123: 7966 * r: DOUBLE_NEG(DOUBLE_SUB(DOUBLE_MUL(r, r), r)) 7967 * @param p BURS node to apply the rule to 7968 */ 7969 private void code123(AbstractBURS_TreeNode p) { 7970 EMIT(MIR_Ternary.mutate(P(p), PPC_FNMSUB, Unary.getResult(P(p)), 7971 R(Binary.getVal1(PLL(p))), R(Binary.getVal2(PLL(p))), 7972 R(Binary.getVal2(PL(p))))); 7973 } 7974 7975 /** 7976 * Emit code for rule number 124: 7977 * rs: INT_2BYTE(r) 7978 * @param p BURS node to apply the rule to 7979 */ 7980 private void code124(AbstractBURS_TreeNode p) { 7981 EMIT(MIR_Unary.mutate(P(p), PPC_EXTSB, Unary.getResult(P(p)), Unary.getVal(P(p)))); 7982 } 7983 7984 /** 7985 * Emit code for rule number 125: 7986 * rp: INT_2USHORT(r) 7987 * @param p BURS node to apply the rule to 7988 */ 7989 private void code125(AbstractBURS_TreeNode p) { 7990 EMIT(MIR_RotateAndMask.create(PPC_RLWINM, Unary.getResult(P(p)), null, 7991 R(Unary.getVal(P(p))), IC(0), IC(16), IC(31))); 7992 } 7993 7994 /** 7995 * Emit code for rule number 126: 7996 * rs: INT_2SHORT(r) 7997 * @param p BURS node to apply the rule to 7998 */ 7999 private void code126(AbstractBURS_TreeNode p) { 8000 EMIT(MIR_Unary.mutate(P(p), PPC_EXTSH, Unary.getResult(P(p)), Unary.getVal(P(p)))); 8001 } 8002 8003 /** 8004 * Emit code for rule number 127: 8005 * r: INT_2FLOAT(r) 8006 * @param p BURS node to apply the rule to 8007 */ 8008 private void code127(AbstractBURS_TreeNode p) { 8009 INT_2DOUBLE(P(p), Unary.getResult(P(p)), R(Unary.getVal(P(p)))); 8010 } 8011 8012 /** 8013 * Emit code for rule number 128: 8014 * r: INT_2DOUBLE(r) 8015 * @param p BURS node to apply the rule to 8016 */ 8017 private void code128(AbstractBURS_TreeNode p) { 8018 INT_2DOUBLE(P(p), Unary.getResult(P(p)), R(Unary.getVal(P(p)))); 8019 } 8020 8021 /** 8022 * Emit code for rule number 129: 8023 * r: FLOAT_2INT(r) 8024 * @param p BURS node to apply the rule to 8025 */ 8026 private void code129(AbstractBURS_TreeNode p) { 8027 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 8028 } 8029 8030 /** 8031 * Emit code for rule number 130: 8032 * r: FLOAT_2DOUBLE(r) 8033 * @param p BURS node to apply the rule to 8034 */ 8035 private void code130(AbstractBURS_TreeNode p) { 8036 EMIT(MIR_Move.mutate(P(p), PPC_FMR, Unary.getResult(P(p)), R(Unary.getVal(P(p))))); 8037 } 8038 8039 /** 8040 * Emit code for rule number 131: 8041 * r: DOUBLE_2INT(r) 8042 * @param p BURS node to apply the rule to 8043 */ 8044 private void code131(AbstractBURS_TreeNode p) { 8045 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansionLeave 8046 } 8047 8048 /** 8049 * Emit code for rule number 132: 8050 * r: DOUBLE_2FLOAT(r) 8051 * @param p BURS node to apply the rule to 8052 */ 8053 private void code132(AbstractBURS_TreeNode p) { 8054 EMIT(MIR_Unary.mutate(P(p), PPC_FRSP, Unary.getResult(P(p)), Unary.getVal(P(p)))); 8055 } 8056 8057 /** 8058 * Emit code for rule number 133: 8059 * r: FLOAT_AS_INT_BITS(r) 8060 * @param p BURS node to apply the rule to 8061 */ 8062 private void code133(AbstractBURS_TreeNode p) { 8063 FPR2GPR_32(P(p)); 8064 } 8065 8066 /** 8067 * Emit code for rule number 134: 8068 * r: INT_BITS_AS_FLOAT(r) 8069 * @param p BURS node to apply the rule to 8070 */ 8071 private void code134(AbstractBURS_TreeNode p) { 8072 GPR2FPR_32(P(p)); 8073 } 8074 8075 /** 8076 * Emit code for rule number 135: 8077 * r: REF_MOVE(r) 8078 * @param p BURS node to apply the rule to 8079 */ 8080 private void code135(AbstractBURS_TreeNode p) { 8081 EMIT(MIR_Move.mutate(P(p), PPC_MOVE, Move.getResult(P(p)), R(Move.getVal(P(p))))); 8082 } 8083 8084 /** 8085 * Emit code for rule number 136: 8086 * rs: REF_MOVE(INT_CONSTANT) 8087 * @param p BURS node to apply the rule to 8088 */ 8089 private void code136(AbstractBURS_TreeNode p) { 8090 EMIT(MIR_Unary.mutate(P(p), PPC_LDI, Move.getResult(P(p)), Move.getVal(P(p)))); 8091 } 8092 8093 /** 8094 * Emit code for rule number 137: 8095 * rs: REF_MOVE(INT_CONSTANT) 8096 * @param p BURS node to apply the rule to 8097 */ 8098 private void code137(AbstractBURS_TreeNode p) { 8099 EMIT(MIR_Unary.mutate(P(p), PPC_LDIS, Move.getResult(P(p)), SRI(IV(Move.getVal(P(p))), 16))); 8100 } 8101 8102 /** 8103 * Emit code for rule number 138: 8104 * rs: REF_MOVE(INT_CONSTANT) 8105 * @param p BURS node to apply the rule to 8106 */ 8107 private void code138(AbstractBURS_TreeNode p) { 8108 { 8109 int one = IV(Move.getVal(P(p))); 8110 EMIT(MIR_Unary.create(PPC_LDIS, Move.getResult(P(p)), CAU16(one))); 8111 EMIT(MIR_Binary.mutate(P(p), PPC_ADDI, Move.getResult(P(p)).copyRO(), 8112 Move.getResult(P(p)).copyRO(), CAL16(one))); 8113} 8114 } 8115 8116 /** 8117 * Emit code for rule number 139: 8118 * r: FLOAT_MOVE(r) 8119 * @param p BURS node to apply the rule to 8120 */ 8121 private void code139(AbstractBURS_TreeNode p) { 8122 EMIT(MIR_Move.mutate(P(p), PPC_FMR, Move.getResult(P(p)), R(Move.getVal(P(p))))); 8123 } 8124 8125 /** 8126 * Emit code for rule number 140: 8127 * r: DOUBLE_MOVE(r) 8128 * @param p BURS node to apply the rule to 8129 */ 8130 private void code140(AbstractBURS_TreeNode p) { 8131 EMIT(MIR_Move.mutate(P(p), PPC_FMR, Move.getResult(P(p)), R(Move.getVal(P(p))))); 8132 } 8133 8134 /** 8135 * Emit code for rule number 141: 8136 * rs: BYTE_LOAD(r,INT_CONSTANT) 8137 * @param p BURS node to apply the rule to 8138 */ 8139 private void code141(AbstractBURS_TreeNode p) { 8140 BYTE_LOAD(P(p), PPC_LBZ, Load.getResult(P(p)), R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8141 Load.getLocation(P(p)), Load.getGuard(P(p))); 8142 } 8143 8144 /** 8145 * Emit code for rule number 142: 8146 * rs: BYTE_LOAD(r,r) 8147 * @param p BURS node to apply the rule to 8148 */ 8149 private void code142(AbstractBURS_TreeNode p) { 8150 BYTE_LOAD(P(p), PPC_LBZX, Load.getResult(P(p)), R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8151 Load.getLocation(P(p)), Load.getGuard(P(p))); 8152 } 8153 8154 /** 8155 * Emit code for rule number 143: 8156 * rp: REF_AND(BYTE_LOAD(r,r),INT_CONSTANT) 8157 * @param p BURS node to apply the rule to 8158 */ 8159 private void code143(AbstractBURS_TreeNode p) { 8160 EMIT(MIR_Load.mutate(PL(p), PPC_LBZX, Binary.getResult(P(p)), R(Load.getAddress(PL(p))), 8161 Load.getOffset(PL(p)), Load.getLocation(PL(p)), 8162 Load.getGuard(PL(p)))); 8163 } 8164 8165 /** 8166 * Emit code for rule number 144: 8167 * rp: REF_AND(BYTE_LOAD(r,INT_CONSTANT),INT_CONSTANT) 8168 * @param p BURS node to apply the rule to 8169 */ 8170 private void code144(AbstractBURS_TreeNode p) { 8171 EMIT(MIR_Load.mutate(PL(p), PPC_LBZ, Binary.getResult(P(p)), R(Load.getAddress(PL(p))), 8172 Load.getOffset(PL(p)), Load.getLocation(PL(p)), 8173 Load.getGuard(PL(p)))); 8174 } 8175 8176 /** 8177 * Emit code for rule number 145: 8178 * rp: UBYTE_LOAD(r,INT_CONSTANT) 8179 * @param p BURS node to apply the rule to 8180 */ 8181 private void code145(AbstractBURS_TreeNode p) { 8182 EMIT(MIR_Load.mutate(P(p), PPC_LBZ, Load.getResult(P(p)), 8183 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8184 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8185 } 8186 8187 /** 8188 * Emit code for rule number 146: 8189 * rp: UBYTE_LOAD(r,r) 8190 * @param p BURS node to apply the rule to 8191 */ 8192 private void code146(AbstractBURS_TreeNode p) { 8193 EMIT(MIR_Load.mutate(P(p), PPC_LBZX, Load.getResult(P(p)), 8194 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8195 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8196 } 8197 8198 /** 8199 * Emit code for rule number 147: 8200 * rs: SHORT_LOAD(r,INT_CONSTANT) 8201 * @param p BURS node to apply the rule to 8202 */ 8203 private void code147(AbstractBURS_TreeNode p) { 8204 EMIT(MIR_Load.mutate(P(p), PPC_LHA, Load.getResult(P(p)), 8205 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8206 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8207 } 8208 8209 /** 8210 * Emit code for rule number 148: 8211 * rs: SHORT_LOAD(r,r) 8212 * @param p BURS node to apply the rule to 8213 */ 8214 private void code148(AbstractBURS_TreeNode p) { 8215 EMIT(MIR_Load.mutate(P(p), PPC_LHAX, Load.getResult(P(p)), 8216 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8217 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8218 } 8219 8220 /** 8221 * Emit code for rule number 149: 8222 * rp: USHORT_LOAD(r,INT_CONSTANT) 8223 * @param p BURS node to apply the rule to 8224 */ 8225 private void code149(AbstractBURS_TreeNode p) { 8226 EMIT(MIR_Load.mutate(P(p), PPC_LHZ, Load.getResult(P(p)), 8227 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8228 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8229 } 8230 8231 /** 8232 * Emit code for rule number 150: 8233 * rp: USHORT_LOAD(r,r) 8234 * @param p BURS node to apply the rule to 8235 */ 8236 private void code150(AbstractBURS_TreeNode p) { 8237 EMIT(MIR_Load.mutate(P(p), PPC_LHZX, Load.getResult(P(p)), 8238 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8239 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8240 } 8241 8242 /** 8243 * Emit code for rule number 151: 8244 * r: FLOAT_LOAD(r,INT_CONSTANT) 8245 * @param p BURS node to apply the rule to 8246 */ 8247 private void code151(AbstractBURS_TreeNode p) { 8248 EMIT(MIR_Load.mutate(P(p), PPC_LFS, Load.getResult(P(p)), 8249 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8250 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8251 } 8252 8253 /** 8254 * Emit code for rule number 152: 8255 * r: FLOAT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 8256 * @param p BURS node to apply the rule to 8257 */ 8258 private void code152(AbstractBURS_TreeNode p) { 8259 { 8260 Address val = AV(Move.getVal(PR(p))); 8261 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PR(p)), 8262 R(Load.getAddress(P(p))), CAU16(val))); 8263 EMIT(MIR_Load.mutate(P(p), PPC_LFS, Load.getResult(P(p)), 8264 Move.getResult(PR(p)).copyRO(), CAL16(val), 8265 Load.getLocation(P(p)), 8266 Load.getGuard(P(p)))); 8267} 8268 } 8269 8270 /** 8271 * Emit code for rule number 153: 8272 * r: FLOAT_LOAD(r,r) 8273 * @param p BURS node to apply the rule to 8274 */ 8275 private void code153(AbstractBURS_TreeNode p) { 8276 EMIT(MIR_Load.mutate(P(p), PPC_LFSX, Load.getResult(P(p)), 8277 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8278 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8279 } 8280 8281 /** 8282 * Emit code for rule number 154: 8283 * r: DOUBLE_LOAD(r,INT_CONSTANT) 8284 * @param p BURS node to apply the rule to 8285 */ 8286 private void code154(AbstractBURS_TreeNode p) { 8287 EMIT(MIR_Load.mutate(P(p), PPC_LFD, Load.getResult(P(p)), 8288 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8289 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8290 } 8291 8292 /** 8293 * Emit code for rule number 155: 8294 * r: DOUBLE_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 8295 * @param p BURS node to apply the rule to 8296 */ 8297 private void code155(AbstractBURS_TreeNode p) { 8298 { 8299 Address val = AV(Move.getVal(PR(p))); 8300 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PR(p)), 8301 R(Load.getAddress(P(p))), CAU16(val))); 8302 EMIT(MIR_Load.mutate(P(p), PPC_LFD, Load.getResult(P(p)), 8303 Move.getResult(PR(p)).copyRO(), CAL16(val), 8304 Load.getLocation(P(p)), 8305 Load.getGuard(P(p)))); 8306} 8307 } 8308 8309 /** 8310 * Emit code for rule number 156: 8311 * r: DOUBLE_LOAD(r,r) 8312 * @param p BURS node to apply the rule to 8313 */ 8314 private void code156(AbstractBURS_TreeNode p) { 8315 EMIT(MIR_Load.mutate(P(p), PPC_LFDX, Load.getResult(P(p)), 8316 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8317 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8318 } 8319 8320 /** 8321 * Emit code for rule number 157: 8322 * rs: INT_LOAD(r,INT_CONSTANT) 8323 * @param p BURS node to apply the rule to 8324 */ 8325 private void code157(AbstractBURS_TreeNode p) { 8326 EMIT(MIR_Load.mutate(P(p), PPC_LInt, Load.getResult(P(p)), 8327 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8328 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8329 } 8330 8331 /** 8332 * Emit code for rule number 158: 8333 * rs: INT_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 8334 * @param p BURS node to apply the rule to 8335 */ 8336 private void code158(AbstractBURS_TreeNode p) { 8337 { 8338 Address val = AV(Move.getVal(PR(p))); 8339 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PR(p)), 8340 R(Load.getAddress(P(p))), CAU16(val))); 8341 EMIT(MIR_Load.mutate(P(p), PPC_LInt, Load.getResult(P(p)), 8342 Move.getResult(PR(p)).copyRO(), CAL16(val), 8343 Load.getLocation(P(p)), 8344 Load.getGuard(P(p)))); 8345} 8346 } 8347 8348 /** 8349 * Emit code for rule number 159: 8350 * rs: INT_LOAD(r,r) 8351 * @param p BURS node to apply the rule to 8352 */ 8353 private void code159(AbstractBURS_TreeNode p) { 8354 EMIT(MIR_Load.mutate(P(p), PPC_LIntX, Load.getResult(P(p)), 8355 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 8356 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8357 } 8358 8359 /** 8360 * Emit code for rule number 160: 8361 * rs: INT_LOAD(REF_ADD(r,r),INT_CONSTANT) 8362 * @param p BURS node to apply the rule to 8363 */ 8364 private void code160(AbstractBURS_TreeNode p) { 8365 EMIT(MIR_Load.mutate(P(p), PPC_LIntX, Load.getResult(P(p)), 8366 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), 8367 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8368 } 8369 8370 /** 8371 * Emit code for rule number 161: 8372 * rs: INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 8373 * @param p BURS node to apply the rule to 8374 */ 8375 private void code161(AbstractBURS_TreeNode p) { 8376 EMIT(MIR_Load.mutate(P(p), PPC_LInt, Load.getResult(P(p)), 8377 R(Binary.getVal1(PL(p))), IC(VR(p)+VLR(p)), 8378 Load.getLocation(P(p)), Load.getGuard(P(p)))); 8379 } 8380 8381 /** 8382 * Emit code for rule number 162: 8383 * stm: BYTE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 8384 * @param p BURS node to apply the rule to 8385 */ 8386 private void code162(AbstractBURS_TreeNode p) { 8387 EMIT(MIR_Store.mutate(P(p), PPC_STB, R(Store.getValue(P(p))), 8388 R(Store.getAddress(P(p))), 8389 Store.getOffset(P(p)), 8390 Store.getLocation(P(p)), 8391 Store.getGuard(P(p)))); 8392 } 8393 8394 /** 8395 * Emit code for rule number 163: 8396 * stm: BYTE_STORE(r,OTHER_OPERAND(r,r)) 8397 * @param p BURS node to apply the rule to 8398 */ 8399 private void code163(AbstractBURS_TreeNode p) { 8400 EMIT(MIR_Store.mutate(P(p), PPC_STBX, R(Store.getValue(P(p))), 8401 R(Store.getAddress(P(p))), 8402 Store.getOffset(P(p)), 8403 Store.getLocation(P(p)), 8404 Store.getGuard(P(p)))); 8405 } 8406 8407 /** 8408 * Emit code for rule number 164: 8409 * stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,INT_CONSTANT)) 8410 * @param p BURS node to apply the rule to 8411 */ 8412 private void code164(AbstractBURS_TreeNode p) { 8413 EMIT(MIR_Store.mutate(P(p), PPC_STB, R(Unary.getVal(PL(p))), 8414 R(Store.getAddress(P(p))), 8415 Store.getOffset(P(p)), 8416 Store.getLocation(P(p)), 8417 Store.getGuard(P(p)))); 8418 } 8419 8420 /** 8421 * Emit code for rule number 165: 8422 * stm: BYTE_STORE(INT_2BYTE(r),OTHER_OPERAND(r,r)) 8423 * @param p BURS node to apply the rule to 8424 */ 8425 private void code165(AbstractBURS_TreeNode p) { 8426 EMIT(MIR_Store.mutate(P(p), PPC_STBX, R(Unary.getVal(PL(p))), 8427 R(Store.getAddress(P(p))), 8428 Store.getOffset(P(p)), 8429 Store.getLocation(P(p)), 8430 Store.getGuard(P(p)))); 8431 } 8432 8433 /** 8434 * Emit code for rule number 166: 8435 * stm: SHORT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 8436 * @param p BURS node to apply the rule to 8437 */ 8438 private void code166(AbstractBURS_TreeNode p) { 8439 EMIT(MIR_Store.mutate(P(p), PPC_STH, R(Store.getValue(P(p))), 8440 R(Store.getAddress(P(p))), 8441 Store.getOffset(P(p)), 8442 Store.getLocation(P(p)), 8443 Store.getGuard(P(p)))); 8444 } 8445 8446 /** 8447 * Emit code for rule number 167: 8448 * stm: SHORT_STORE(r,OTHER_OPERAND(r,r)) 8449 * @param p BURS node to apply the rule to 8450 */ 8451 private void code167(AbstractBURS_TreeNode p) { 8452 EMIT(MIR_Store.mutate(P(p), PPC_STHX, R(Store.getValue(P(p))), 8453 R(Store.getAddress(P(p))), 8454 Store.getOffset(P(p)), 8455 Store.getLocation(P(p)), 8456 Store.getGuard(P(p)))); 8457 } 8458 8459 /** 8460 * Emit code for rule number 168: 8461 * stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 8462 * @param p BURS node to apply the rule to 8463 */ 8464 private void code168(AbstractBURS_TreeNode p) { 8465 EMIT(MIR_Store.mutate(P(p), PPC_STH, R(Unary.getVal(PL(p))), 8466 R(Store.getAddress(P(p))), 8467 Store.getOffset(P(p)), 8468 Store.getLocation(P(p)), 8469 Store.getGuard(P(p)))); 8470 } 8471 8472 /** 8473 * Emit code for rule number 169: 8474 * stm: SHORT_STORE(INT_2SHORT(r),OTHER_OPERAND(r,r)) 8475 * @param p BURS node to apply the rule to 8476 */ 8477 private void code169(AbstractBURS_TreeNode p) { 8478 EMIT(MIR_Store.mutate(P(p), PPC_STHX, R(Unary.getVal(PL(p))), 8479 R(Store.getAddress(P(p))), 8480 Store.getOffset(P(p)), 8481 Store.getLocation(P(p)), 8482 Store.getGuard(P(p)))); 8483 } 8484 8485 /** 8486 * Emit code for rule number 170: 8487 * stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,INT_CONSTANT)) 8488 * @param p BURS node to apply the rule to 8489 */ 8490 private void code170(AbstractBURS_TreeNode p) { 8491 EMIT(MIR_Store.mutate(P(p), PPC_STH, R(Unary.getVal(PL(p))), 8492 R(Store.getAddress(P(p))), 8493 Store.getOffset(P(p)), 8494 Store.getLocation(P(p)), 8495 Store.getGuard(P(p)))); 8496 } 8497 8498 /** 8499 * Emit code for rule number 171: 8500 * stm: SHORT_STORE(INT_2USHORT(r),OTHER_OPERAND(r,r)) 8501 * @param p BURS node to apply the rule to 8502 */ 8503 private void code171(AbstractBURS_TreeNode p) { 8504 EMIT(MIR_Store.mutate(P(p), PPC_STHX, R(Unary.getVal(PL(p))), 8505 R(Store.getAddress(P(p))), 8506 Store.getOffset(P(p)), 8507 Store.getLocation(P(p)), 8508 Store.getGuard(P(p)))); 8509 } 8510 8511 /** 8512 * Emit code for rule number 172: 8513 * stm: INT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 8514 * @param p BURS node to apply the rule to 8515 */ 8516 private void code172(AbstractBURS_TreeNode p) { 8517 EMIT(MIR_Store.mutate(P(p), PPC_STW, R(Store.getValue(P(p))), 8518 R(Store.getAddress(P(p))), 8519 Store.getOffset(P(p)), 8520 Store.getLocation(P(p)), 8521 Store.getGuard(P(p)))); 8522 } 8523 8524 /** 8525 * Emit code for rule number 173: 8526 * stm: INT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 8527 * @param p BURS node to apply the rule to 8528 */ 8529 private void code173(AbstractBURS_TreeNode p) { 8530 { 8531 Address val = AV(Move.getVal(PRR(p))); 8532 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PRR(p)), 8533 R(Store.getAddress(P(p))), CAU16(val))); 8534 EMIT(MIR_Store.mutate(P(p), PPC_STW, R(Store.getValue(P(p))), 8535 Move.getResult(PRR(p)).copyRO(), CAL16(val), 8536 Store.getLocation(P(p)), 8537 Store.getGuard(P(p)))); 8538} 8539 } 8540 8541 /** 8542 * Emit code for rule number 174: 8543 * stm: INT_STORE(r,OTHER_OPERAND(r,r)) 8544 * @param p BURS node to apply the rule to 8545 */ 8546 private void code174(AbstractBURS_TreeNode p) { 8547 EMIT(MIR_Store.mutate(P(p), PPC_STWX, R(Store.getValue(P(p))), 8548 R(Store.getAddress(P(p))), 8549 Store.getOffset(P(p)), 8550 Store.getLocation(P(p)), 8551 Store.getGuard(P(p)))); 8552 } 8553 8554 /** 8555 * Emit code for rule number 175: 8556 * stm: INT_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 8557 * @param p BURS node to apply the rule to 8558 */ 8559 private void code175(AbstractBURS_TreeNode p) { 8560 EMIT(MIR_Store.mutate(P(p), PPC_STW, R(Store.getValue(P(p))), 8561 R(Binary.getVal1(PRL(p))), 8562 IC(VRR(p) + VRLR(p)), 8563 Store.getLocation(P(p)), 8564 Store.getGuard(P(p)))); 8565 } 8566 8567 /** 8568 * Emit code for rule number 176: 8569 * stm: FLOAT_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 8570 * @param p BURS node to apply the rule to 8571 */ 8572 private void code176(AbstractBURS_TreeNode p) { 8573 EMIT(MIR_Store.mutate(P(p), PPC_STFS, R(Store.getValue(P(p))), 8574 R(Store.getAddress(P(p))), 8575 Store.getOffset(P(p)), 8576 Store.getLocation(P(p)), 8577 Store.getGuard(P(p)))); 8578 } 8579 8580 /** 8581 * Emit code for rule number 177: 8582 * stm: FLOAT_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 8583 * @param p BURS node to apply the rule to 8584 */ 8585 private void code177(AbstractBURS_TreeNode p) { 8586 { 8587 Address val = AV(Move.getVal(PRR(p))); 8588 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PRR(p)), 8589 R(Store.getAddress(P(p))), CAU16(val))); 8590 EMIT(MIR_Store.mutate(P(p), PPC_STFS, R(Store.getValue(P(p))), 8591 Move.getResult(PRR(p)).copyRO(), CAL16(val), 8592 Store.getLocation(P(p)), 8593 Store.getGuard(P(p)))); 8594} 8595 } 8596 8597 /** 8598 * Emit code for rule number 178: 8599 * stm: FLOAT_STORE(r,OTHER_OPERAND(r,r)) 8600 * @param p BURS node to apply the rule to 8601 */ 8602 private void code178(AbstractBURS_TreeNode p) { 8603 EMIT(MIR_Store.mutate(P(p), PPC_STFSX, R(Store.getValue(P(p))), 8604 R(Store.getAddress(P(p))), 8605 Store.getOffset(P(p)), 8606 Store.getLocation(P(p)), 8607 Store.getGuard(P(p)))); 8608 } 8609 8610 /** 8611 * Emit code for rule number 179: 8612 * stm: DOUBLE_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 8613 * @param p BURS node to apply the rule to 8614 */ 8615 private void code179(AbstractBURS_TreeNode p) { 8616 EMIT(MIR_Store.mutate(P(p), PPC_STFD, R(Store.getValue(P(p))), 8617 R(Store.getAddress(P(p))), 8618 Store.getOffset(P(p)), 8619 Store.getLocation(P(p)), 8620 Store.getGuard(P(p)))); 8621 } 8622 8623 /** 8624 * Emit code for rule number 180: 8625 * stm: DOUBLE_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 8626 * @param p BURS node to apply the rule to 8627 */ 8628 private void code180(AbstractBURS_TreeNode p) { 8629 { 8630 Address val = AV(Move.getVal(PRR(p))); 8631 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PRR(p)), 8632 R(Store.getAddress(P(p))), CAU16(val))); 8633 EMIT(MIR_Store.mutate(P(p), PPC_STFD, R(Store.getValue(P(p))), 8634 Move.getResult(PRR(p)).copyRO(), CAL16(val), 8635 Store.getLocation(P(p)), 8636 Store.getGuard(P(p)))); 8637} 8638 } 8639 8640 /** 8641 * Emit code for rule number 181: 8642 * stm: DOUBLE_STORE(r,OTHER_OPERAND(r,r)) 8643 * @param p BURS node to apply the rule to 8644 */ 8645 private void code181(AbstractBURS_TreeNode p) { 8646 EMIT(MIR_Store.mutate(P(p), PPC_STFDX, R(Store.getValue(P(p))), 8647 R(Store.getAddress(P(p))), 8648 Store.getOffset(P(p)), 8649 Store.getLocation(P(p)), 8650 Store.getGuard(P(p)))); 8651 } 8652 8653 /** 8654 * Emit code for rule number 182: 8655 * stm: INT_IFCMP(r,r) 8656 * @param p BURS node to apply the rule to 8657 */ 8658 private void code182(AbstractBURS_TreeNode p) { 8659 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8660CMP(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p)), false); 8661 } 8662 8663 /** 8664 * Emit code for rule number 183: 8665 * stm: INT_IFCMP(r,INT_CONSTANT) 8666 * @param p BURS node to apply the rule to 8667 */ 8668 private void code183(AbstractBURS_TreeNode p) { 8669 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8670CMP(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p)), true); 8671 } 8672 8673 /** 8674 * Emit code for rule number 184: 8675 * stm: INT_IFCMP(INT_2BYTE(r),INT_CONSTANT) 8676 * @param p BURS node to apply the rule to 8677 */ 8678 private void code184(AbstractBURS_TreeNode p) { 8679 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8680CMP_ZERO(P(p), PPC_EXTSBr, Unary.getResult(PL(p)), 8681 Unary.getVal(PL(p)), IfCmp.getCond(P(p))); 8682 } 8683 8684 /** 8685 * Emit code for rule number 185: 8686 * stm: INT_IFCMP(INT_2SHORT(r),INT_CONSTANT) 8687 * @param p BURS node to apply the rule to 8688 */ 8689 private void code185(AbstractBURS_TreeNode p) { 8690 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8691CMP_ZERO(P(p), PPC_EXTSHr, Unary.getResult(PL(p)), 8692 Unary.getVal(PL(p)), IfCmp.getCond(P(p))); 8693 } 8694 8695 /** 8696 * Emit code for rule number 186: 8697 * stm: INT_IFCMP(INT_USHR(r,r),INT_CONSTANT) 8698 * @param p BURS node to apply the rule to 8699 */ 8700 private void code186(AbstractBURS_TreeNode p) { 8701 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8702CMP_ZERO(P(p), PPC_SRWr, Binary.getResult(PL(p)), 8703 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8704 } 8705 8706 /** 8707 * Emit code for rule number 187: 8708 * stm: INT_IFCMP(INT_SHL(r,r),INT_CONSTANT) 8709 * @param p BURS node to apply the rule to 8710 */ 8711 private void code187(AbstractBURS_TreeNode p) { 8712 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8713CMP_ZERO(P(p), PPC_SLWr, Binary.getResult(PL(p)), 8714 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8715 } 8716 8717 /** 8718 * Emit code for rule number 188: 8719 * stm: INT_IFCMP(INT_SHR(r,r),INT_CONSTANT) 8720 * @param p BURS node to apply the rule to 8721 */ 8722 private void code188(AbstractBURS_TreeNode p) { 8723 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8724CMP_ZERO(P(p), PPC_SRAWr, Binary.getResult(PL(p)), 8725 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8726 } 8727 8728 /** 8729 * Emit code for rule number 189: 8730 * stm: INT_IFCMP(INT_USHR(r,INT_CONSTANT),INT_CONSTANT) 8731 * @param p BURS node to apply the rule to 8732 */ 8733 private void code189(AbstractBURS_TreeNode p) { 8734 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8735CMP_ZERO(P(p), PPC_SRWIr, Binary.getResult(PL(p)), 8736 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8737 } 8738 8739 /** 8740 * Emit code for rule number 190: 8741 * stm: INT_IFCMP(INT_SHL(r,INT_CONSTANT),INT_CONSTANT) 8742 * @param p BURS node to apply the rule to 8743 */ 8744 private void code190(AbstractBURS_TreeNode p) { 8745 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8746CMP_ZERO(P(p), PPC_SLWIr, Binary.getResult(PL(p)), 8747 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8748 } 8749 8750 /** 8751 * Emit code for rule number 191: 8752 * stm: INT_IFCMP(INT_SHR(r,INT_CONSTANT),INT_CONSTANT) 8753 * @param p BURS node to apply the rule to 8754 */ 8755 private void code191(AbstractBURS_TreeNode p) { 8756 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8757CMP_ZERO(P(p), PPC_SRAWIr, Binary.getResult(PL(p)), 8758 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8759 } 8760 8761 /** 8762 * Emit code for rule number 192: 8763 * stm: INT_IFCMP(REF_AND(r,INT_CONSTANT),INT_CONSTANT) 8764 * @param p BURS node to apply the rule to 8765 */ 8766 private void code192(AbstractBURS_TreeNode p) { 8767 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8768CMP_ZERO(P(p), PPC_ANDIr, Binary.getResult(PL(p)), 8769 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), IfCmp.getCond(P(p))); 8770 } 8771 8772 /** 8773 * Emit code for rule number 193: 8774 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 8775 * @param p BURS node to apply the rule to 8776 */ 8777 private void code193(AbstractBURS_TreeNode p) { 8778 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8779EMIT_BOOLCMP_BRANCH(IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 8780 } 8781 8782 /** 8783 * Emit code for rule number 194: 8784 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 8785 * @param p BURS node to apply the rule to 8786 */ 8787 private void code194(AbstractBURS_TreeNode p) { 8788 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8789FLIP_BOOLCMP(); EMIT_BOOLCMP_BRANCH(IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 8790 } 8791 8792 /** 8793 * Emit code for rule number 195: 8794 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 8795 * @param p BURS node to apply the rule to 8796 */ 8797 private void code195(AbstractBURS_TreeNode p) { 8798 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8799EMIT_BOOLCMP_BRANCH(IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 8800 } 8801 8802 /** 8803 * Emit code for rule number 196: 8804 * stm: INT_IFCMP(boolcmp, INT_CONSTANT) 8805 * @param p BURS node to apply the rule to 8806 */ 8807 private void code196(AbstractBURS_TreeNode p) { 8808 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8809FLIP_BOOLCMP(); EMIT_BOOLCMP_BRANCH(IfCmp.getTarget(P(p)), IfCmp.getBranchProfile(P(p))); 8810 } 8811 8812 /** 8813 * Emit code for rule number 197: 8814 * stm: INT_IFCMP2(r,r) 8815 * @param p BURS node to apply the rule to 8816 */ 8817 private void code197(AbstractBURS_TreeNode p) { 8818 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 8819CMP2(P(p), R(IfCmp2.getVal1(P(p))), IfCmp2.getVal2(P(p)), IfCmp2.getCond1(P(p)), IfCmp2.getCond2(P(p)), false); 8820 } 8821 8822 /** 8823 * Emit code for rule number 198: 8824 * stm: INT_IFCMP2(r,INT_CONSTANT) 8825 * @param p BURS node to apply the rule to 8826 */ 8827 private void code198(AbstractBURS_TreeNode p) { 8828 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp2.getGuardResult(P(p)), new TrueGuardOperand()))); 8829CMP2(P(p), R(IfCmp2.getVal1(P(p))), IfCmp2.getVal2(P(p)), IfCmp2.getCond1(P(p)), IfCmp2.getCond2(P(p)), true); 8830 } 8831 8832 /** 8833 * Emit code for rule number 199: 8834 * stm: FLOAT_IFCMP(r,r) 8835 * @param p BURS node to apply the rule to 8836 */ 8837 private void code199(AbstractBURS_TreeNode p) { 8838 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8839DOUBLE_IFCMP(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p))); 8840 } 8841 8842 /** 8843 * Emit code for rule number 200: 8844 * stm: DOUBLE_IFCMP(r,r) 8845 * @param p BURS node to apply the rule to 8846 */ 8847 private void code200(AbstractBURS_TreeNode p) { 8848 EMIT(CPOS(P(p), Move.create(GUARD_MOVE, IfCmp.getGuardResult(P(p)), new TrueGuardOperand()))); 8849DOUBLE_IFCMP(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p))); 8850 } 8851 8852 /** 8853 * Emit code for rule number 201: 8854 * stm: FLOAT_CMPL(r,r) 8855 * @param p BURS node to apply the rule to 8856 */ 8857 private void code201(AbstractBURS_TreeNode p) { 8858 EMIT (P(p)); // Leave for ComplexLIR2MIRExpansion 8859 } 8860 8861 /** 8862 * Emit code for rule number 202: 8863 * stm: FLOAT_CMPG(r,r) 8864 * @param p BURS node to apply the rule to 8865 */ 8866 private void code202(AbstractBURS_TreeNode p) { 8867 EMIT (P(p)); // Leave for ComplexLIR2MIRExpansion 8868 } 8869 8870 /** 8871 * Emit code for rule number 203: 8872 * stm: DOUBLE_CMPL(r,r) 8873 * @param p BURS node to apply the rule to 8874 */ 8875 private void code203(AbstractBURS_TreeNode p) { 8876 EMIT (P(p)); // Leave for ComplexLIR2MIRExpansion 8877 } 8878 8879 /** 8880 * Emit code for rule number 204: 8881 * stm: DOUBLE_CMPG(r,r) 8882 * @param p BURS node to apply the rule to 8883 */ 8884 private void code204(AbstractBURS_TreeNode p) { 8885 EMIT (P(p)); // Leave for ComplexLIR2MIRExpansion 8886 } 8887 8888 /** 8889 * Emit code for rule number 205: 8890 * stm: GOTO 8891 * @param p BURS node to apply the rule to 8892 */ 8893 private void code205(AbstractBURS_TreeNode p) { 8894 EMIT(MIR_Branch.mutate(P(p), PPC_B, Goto.getTarget(P(p)))); 8895 } 8896 8897 /** 8898 * Emit code for rule number 206: 8899 * stm: RETURN(NULL) 8900 * @param p BURS node to apply the rule to 8901 */ 8902 private void code206(AbstractBURS_TreeNode p) { 8903 RETURN(P(p), null); 8904 } 8905 8906 /** 8907 * Emit code for rule number 207: 8908 * stm: RETURN(r) 8909 * @param p BURS node to apply the rule to 8910 */ 8911 private void code207(AbstractBURS_TreeNode p) { 8912 RETURN(P(p), Return.getVal(P(p))); 8913 } 8914 8915 /** 8916 * Emit code for rule number 208: 8917 * r: CALL(r,any) 8918 * @param p BURS node to apply the rule to 8919 */ 8920 private void code208(AbstractBURS_TreeNode p) { 8921 CALL(P(p)); 8922 } 8923 8924 /** 8925 * Emit code for rule number 209: 8926 * r: CALL(BRANCH_TARGET,any) 8927 * @param p BURS node to apply the rule to 8928 */ 8929 private void code209(AbstractBURS_TreeNode p) { 8930 CALL(P(p)); 8931 } 8932 8933 /** 8934 * Emit code for rule number 210: 8935 * r: SYSCALL(r,any) 8936 * @param p BURS node to apply the rule to 8937 */ 8938 private void code210(AbstractBURS_TreeNode p) { 8939 SYSCALL(P(p)); 8940 } 8941 8942 /** 8943 * Emit code for rule number 211: 8944 * r: GET_TIME_BASE 8945 * @param p BURS node to apply the rule to 8946 */ 8947 private void code211(AbstractBURS_TreeNode p) { 8948 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 8949 } 8950 8951 /** 8952 * Emit code for rule number 213: 8953 * r: YIELDPOINT_OSR(any, any) 8954 * @param p BURS node to apply the rule to 8955 */ 8956 private void code213(AbstractBURS_TreeNode p) { 8957 OSR(burs, P(p)); 8958 } 8959 8960 /** 8961 * Emit code for rule number 214: 8962 * r: PREPARE_INT(r, r) 8963 * @param p BURS node to apply the rule to 8964 */ 8965 private void code214(AbstractBURS_TreeNode p) { 8966 EMIT(MIR_Load.mutate(P(p), PPC_LWARX, Prepare.getResult(P(p)), 8967 R(Prepare.getAddress(P(p))), Prepare.getOffset(P(p)), 8968 Prepare.getLocation(P(p)), 8969 Prepare.getGuard(P(p)))); 8970 } 8971 8972 /** 8973 * Emit code for rule number 215: 8974 * r: PREPARE_LONG(r, r) 8975 * @param p BURS node to apply the rule to 8976 */ 8977 private void code215(AbstractBURS_TreeNode p) { 8978 EMIT(MIR_Load.mutate(P(p), PPC_LAddrARX, Prepare.getResult(P(p)), 8979 R(Prepare.getAddress(P(p))), Prepare.getOffset(P(p)), 8980 Prepare.getLocation(P(p)), 8981 Prepare.getGuard(P(p)))); 8982 } 8983 8984 /** 8985 * Emit code for rule number 216: 8986 * r: ATTEMPT_INT(r, r) 8987 * @param p BURS node to apply the rule to 8988 */ 8989 private void code216(AbstractBURS_TreeNode p) { 8990 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 8991 } 8992 8993 /** 8994 * Emit code for rule number 217: 8995 * r: ATTEMPT_LONG(r, r) 8996 * @param p BURS node to apply the rule to 8997 */ 8998 private void code217(AbstractBURS_TreeNode p) { 8999 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 9000 } 9001 9002 /** 9003 * Emit code for rule number 218: 9004 * stm: IR_PROLOGUE 9005 * @param p BURS node to apply the rule to 9006 */ 9007 private void code218(AbstractBURS_TreeNode p) { 9008 EMIT(P(p)); 9009 } 9010 9011 /** 9012 * Emit code for rule number 219: 9013 * r: LONG_MUL(r,INT_CONSTANT) 9014 * @param p BURS node to apply the rule to 9015 */ 9016 private void code219(AbstractBURS_TreeNode p) { 9017 EMIT(MIR_Binary.mutate(P(p), PPC_MULLI, Binary.getResult(P(p)), 9018 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9019 } 9020 9021 /** 9022 * Emit code for rule number 220: 9023 * r: LONG_MUL(r,r) 9024 * @param p BURS node to apply the rule to 9025 */ 9026 private void code220(AbstractBURS_TreeNode p) { 9027 EMIT(MIR_Binary.mutate(P(p), PPC64_MULLD, Binary.getResult(P(p)), 9028 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9029 } 9030 9031 /** 9032 * Emit code for rule number 221: 9033 * r: LONG_DIV(r,r) 9034 * @param p BURS node to apply the rule to 9035 */ 9036 private void code221(AbstractBURS_TreeNode p) { 9037 EMIT(MIR_Binary.mutate(P(p), PPC64_DIVD, GuardedBinary.getResult(P(p)), 9038 R(GuardedBinary.getVal1(P(p))), GuardedBinary.getVal2(P(p)))); 9039 } 9040 9041 /** 9042 * Emit code for rule number 222: 9043 * r: LONG_DIV(r,REF_MOVE(INT_CONSTANT)) 9044 * @param p BURS node to apply the rule to 9045 */ 9046 private void code222(AbstractBURS_TreeNode p) { 9047 LONG_DIV_IMM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), 9048 Move.getResult(PR(p)), IC(Move.getVal(PR(p)))); 9049 } 9050 9051 /** 9052 * Emit code for rule number 223: 9053 * r: LONG_REM(r,r) 9054 * @param p BURS node to apply the rule to 9055 */ 9056 private void code223(AbstractBURS_TreeNode p) { 9057 LONG_REM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), R(GuardedBinary.getVal2(P(p)))); 9058 } 9059 9060 /** 9061 * Emit code for rule number 224: 9062 * r: LONG_REM(r,REF_MOVE(INT_CONSTANT)) 9063 * @param p BURS node to apply the rule to 9064 */ 9065 private void code224(AbstractBURS_TreeNode p) { 9066 LONG_REM_IMM(P(p), GuardedBinary.getResult(P(p)), R(GuardedBinary.getVal1(P(p))), 9067 Move.getResult(PR(p)), IC(Move.getVal(PR(p)))); 9068 } 9069 9070 /** 9071 * Emit code for rule number 225: 9072 * r: LONG_SHL(r,INT_CONSTANT) 9073 * @param p BURS node to apply the rule to 9074 */ 9075 private void code225(AbstractBURS_TreeNode p) { 9076 EMIT(MIR_Binary.mutate(P(p), PPC64_SLDI, Binary.getResult(P(p)), 9077 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9078 } 9079 9080 /** 9081 * Emit code for rule number 226: 9082 * r: LONG_SHL(r,r) 9083 * @param p BURS node to apply the rule to 9084 */ 9085 private void code226(AbstractBURS_TreeNode p) { 9086 EMIT(MIR_Binary.mutate(P(p), PPC64_SLD, Binary.getResult(P(p)), 9087 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9088 } 9089 9090 /** 9091 * Emit code for rule number 227: 9092 * r: LONG_SHL(LONG_USHR(r,INT_CONSTANT),INT_CONSTANT) 9093 * @param p BURS node to apply the rule to 9094 */ 9095 private void code227(AbstractBURS_TreeNode p) { 9096 EMIT(MIR_RotateAndMask.mutate(P(p), PPC64_RLDICR, Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 9097 IC(VR(p) - VLR(p)), IC(0), IC(63 - VR(p)))); 9098 } 9099 9100 /** 9101 * Emit code for rule number 228: 9102 * r: LONG_USHR(LONG_SHL(r,INT_CONSTANT),INT_CONSTANT) 9103 * @param p BURS node to apply the rule to 9104 */ 9105 private void code228(AbstractBURS_TreeNode p) { 9106 EMIT(MIR_RotateAndMask.mutate(P(p), PPC64_RLDICL, Binary.getResult(P(p)), R(Binary.getVal1(PL(p))), 9107 IC(64 - (VR(p) - VLR(p))), IC(VR(p)), IC(63))); 9108 } 9109 9110 /** 9111 * Emit code for rule number 229: 9112 * r: LONG_SHR(r,INT_CONSTANT) 9113 * @param p BURS node to apply the rule to 9114 */ 9115 private void code229(AbstractBURS_TreeNode p) { 9116 EMIT(MIR_Binary.mutate(P(p), PPC64_SRADI, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9117 } 9118 9119 /** 9120 * Emit code for rule number 230: 9121 * r: LONG_SHR(r,r) 9122 * @param p BURS node to apply the rule to 9123 */ 9124 private void code230(AbstractBURS_TreeNode p) { 9125 EMIT(MIR_Binary.mutate(P(p), PPC64_SRAD, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9126 } 9127 9128 /** 9129 * Emit code for rule number 231: 9130 * r: LONG_USHR(r,INT_CONSTANT) 9131 * @param p BURS node to apply the rule to 9132 */ 9133 private void code231(AbstractBURS_TreeNode p) { 9134 EMIT(MIR_Binary.mutate(P(p), PPC64_SRDI, Binary.getResult(P(p)), R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9135 } 9136 9137 /** 9138 * Emit code for rule number 232: 9139 * r: LONG_USHR(r,r) 9140 * @param p BURS node to apply the rule to 9141 */ 9142 private void code232(AbstractBURS_TreeNode p) { 9143 EMIT(MIR_Binary.mutate(P(p), PPC64_SRD, Binary.getResult(P(p)), 9144 R(Binary.getVal1(P(p))), Binary.getVal2(P(p)))); 9145 } 9146 9147 /** 9148 * Emit code for rule number 233: 9149 * rs: INT_2LONG(r) 9150 * @param p BURS node to apply the rule to 9151 */ 9152 private void code233(AbstractBURS_TreeNode p) { 9153 INT_2LONG(P(p), Unary.getResult(P(p)), R(Unary.getVal(P(p)))); 9154 } 9155 9156 /** 9157 * Emit code for rule number 234: 9158 * rs: INT_2LONG(rs) 9159 * @param p BURS node to apply the rule to 9160 */ 9161 private void code234(AbstractBURS_TreeNode p) { 9162 EMIT(MIR_Move.mutate(P(p), PPC_MOVE, Unary.getResult(P(p)), R(Unary.getVal(P(p))))); 9163 } 9164 9165 /** 9166 * Emit code for rule number 235: 9167 * r: LONG_2INT(r) 9168 * @param p BURS node to apply the rule to 9169 */ 9170 private void code235(AbstractBURS_TreeNode p) { 9171 LONG_2INT(P(p), Unary.getResult(P(p)), R(Unary.getVal(P(p)))); 9172 } 9173 9174 /** 9175 * Emit code for rule number 236: 9176 * r: FLOAT_2LONG(r) 9177 * @param p BURS node to apply the rule to 9178 */ 9179 private void code236(AbstractBURS_TreeNode p) { 9180 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 9181 } 9182 9183 /** 9184 * Emit code for rule number 237: 9185 * r: DOUBLE_2LONG(r) 9186 * @param p BURS node to apply the rule to 9187 */ 9188 private void code237(AbstractBURS_TreeNode p) { 9189 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansionLeave 9190 } 9191 9192 /** 9193 * Emit code for rule number 238: 9194 * r: DOUBLE_AS_LONG_BITS(r) 9195 * @param p BURS node to apply the rule to 9196 */ 9197 private void code238(AbstractBURS_TreeNode p) { 9198 FPR2GPR_64(P(p)); 9199 } 9200 9201 /** 9202 * Emit code for rule number 239: 9203 * r: LONG_BITS_AS_DOUBLE(r) 9204 * @param p BURS node to apply the rule to 9205 */ 9206 private void code239(AbstractBURS_TreeNode p) { 9207 GPR2FPR_64(P(p)); 9208 } 9209 9210 /** 9211 * Emit code for rule number 240: 9212 * r: REF_MOVE(ADDRESS_CONSTANT) 9213 * @param p BURS node to apply the rule to 9214 */ 9215 private void code240(AbstractBURS_TreeNode p) { 9216 LONG_CONSTANT(P(p), Move.getResult(P(p)), AC(Move.getVal(P(p)))); 9217 } 9218 9219 /** 9220 * Emit code for rule number 241: 9221 * r: REF_MOVE(LONG_CONSTANT) 9222 * @param p BURS node to apply the rule to 9223 */ 9224 private void code241(AbstractBURS_TreeNode p) { 9225 LONG_CONSTANT(P(p), Move.getResult(P(p)), LC(Move.getVal(P(p)))); 9226 } 9227 9228 /** 9229 * Emit code for rule number 242: 9230 * r: LONG_CMP(r,r) 9231 * @param p BURS node to apply the rule to 9232 */ 9233 private void code242(AbstractBURS_TreeNode p) { 9234 EMIT (P(p)); // Leave for ComplexLIR2MIRExpansion 9235 } 9236 9237 /** 9238 * Emit code for rule number 243: 9239 * stm: LONG_IFCMP(r,r) 9240 * @param p BURS node to apply the rule to 9241 */ 9242 private void code243(AbstractBURS_TreeNode p) { 9243 CMP64(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p)), false); 9244 } 9245 9246 /** 9247 * Emit code for rule number 244: 9248 * stm: LONG_IFCMP(r,INT_CONSTANT) 9249 * @param p BURS node to apply the rule to 9250 */ 9251 private void code244(AbstractBURS_TreeNode p) { 9252 CMP64(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p)), true); 9253 } 9254 9255 /** 9256 * Emit code for rule number 245: 9257 * stm: LONG_IFCMP(r,LONG_CONSTANT) 9258 * @param p BURS node to apply the rule to 9259 */ 9260 private void code245(AbstractBURS_TreeNode p) { 9261 CMP64(P(p), R(IfCmp.getVal1(P(p))), IfCmp.getVal2(P(p)), IfCmp.getCond(P(p)), true); 9262 } 9263 9264 /** 9265 * Emit code for rule number 246: 9266 * stm: INT_IFCMP(ATTEMPT_INT(r,r),INT_CONSTANT) 9267 * @param p BURS node to apply the rule to 9268 */ 9269 private void code246(AbstractBURS_TreeNode p) { 9270 { 9271 ConditionOperand c = IfCmp.getCond(P(p)).flipCode(); 9272 EMIT(MIR_Store.create(PPC_STWCXr, R(Attempt.getNewValue(PL(p))), 9273 R(Attempt.getAddress(PL(p))), Attempt.getOffset(PL(p)), 9274 Attempt.getLocation(PL(p)), 9275 Attempt.getGuard(PL(p)))); 9276 EMIT(MIR_CondBranch.mutate(P(p), PPC_BCOND, CR(0), 9277 new PowerPCConditionOperand(c), 9278 IfCmp.getTarget(P(p)), 9279 IfCmp.getBranchProfile(P(p)))); 9280} 9281 } 9282 9283 /** 9284 * Emit code for rule number 247: 9285 * stm: INT_IFCMP(ATTEMPT_ADDR(r,r),INT_CONSTANT) 9286 * @param p BURS node to apply the rule to 9287 */ 9288 private void code247(AbstractBURS_TreeNode p) { 9289 { 9290 ConditionOperand c = IfCmp.getCond(P(p)).flipCode(); 9291 EMIT(MIR_Store.create(PPC_STAddrCXr, R(Attempt.getNewValue(PL(p))), 9292 R(Attempt.getAddress(PL(p))), Attempt.getOffset(PL(p)), 9293 Attempt.getLocation(PL(p)), 9294 Attempt.getGuard(PL(p)))); 9295 EMIT(MIR_CondBranch.mutate(P(p), PPC_BCOND, CR(0), 9296 new PowerPCConditionOperand(c), 9297 IfCmp.getTarget(P(p)), 9298 IfCmp.getBranchProfile(P(p)))); 9299} 9300 } 9301 9302 /** 9303 * Emit code for rule number 248: 9304 * rz: INT_2ADDRZerExt(rz) 9305 * @param p BURS node to apply the rule to 9306 */ 9307 private void code248(AbstractBURS_TreeNode p) { 9308 EMIT(MIR_Move.mutate(P(p), PPC_MOVE, Unary.getResult(P(p)), R(Unary.getVal(P(p))))); 9309 } 9310 9311 /** 9312 * Emit code for rule number 249: 9313 * rz: INT_2ADDRZerExt(r) 9314 * @param p BURS node to apply the rule to 9315 */ 9316 private void code249(AbstractBURS_TreeNode p) { 9317 INT_2ADDRZerExt(P(p), Unary.getResult(P(p)), R(Unary.getVal(P(p)))); 9318 } 9319 9320 /** 9321 * Emit code for rule number 250: 9322 * rz: INT_2ADDRZerExt(INT_LOAD(r,INT_CONSTANT)) 9323 * @param p BURS node to apply the rule to 9324 */ 9325 private void code250(AbstractBURS_TreeNode p) { 9326 EMIT(MIR_Load.mutate(PL(p), PPC_LWZ, Unary.getResult(P(p)), 9327 R(Load.getAddress(PL(p))), Load.getOffset(PL(p)), 9328 Load.getLocation(PL(p)), Load.getGuard(PL(p)))); 9329 } 9330 9331 /** 9332 * Emit code for rule number 251: 9333 * rz: INT_2ADDRZerExt(INT_LOAD(r,r)) 9334 * @param p BURS node to apply the rule to 9335 */ 9336 private void code251(AbstractBURS_TreeNode p) { 9337 EMIT(MIR_Load.mutate(PL(p), PPC_LWZX, Unary.getResult(P(p)), 9338 R(Load.getAddress(PL(p))), Load.getOffset(PL(p)), 9339 Load.getLocation(PL(p)), Load.getGuard(PL(p)))); 9340 } 9341 9342 /** 9343 * Emit code for rule number 252: 9344 * rz: INT_2ADDRZerExt(INT_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 9345 * @param p BURS node to apply the rule to 9346 */ 9347 private void code252(AbstractBURS_TreeNode p) { 9348 EMIT(MIR_Load.mutate(PL(p), PPC_LWZ, Unary.getResult(P(p)), 9349 R(Binary.getVal1(PLL(p))), IC(VLR(p)+VLLR(p)), 9350 Load.getLocation(PL(p)), Load.getGuard(PL(p)))); 9351 } 9352 9353 /** 9354 * Emit code for rule number 253: 9355 * r: LONG_LOAD(r,INT_CONSTANT) 9356 * @param p BURS node to apply the rule to 9357 */ 9358 private void code253(AbstractBURS_TreeNode p) { 9359 EMIT(MIR_Load.mutate(P(p), PPC_LAddr, Load.getResult(P(p)), 9360 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 9361 Load.getLocation(P(p)), Load.getGuard(P(p)))); 9362 } 9363 9364 /** 9365 * Emit code for rule number 254: 9366 * r: LONG_LOAD(r,REF_MOVE(ADDRESS_CONSTANT)) 9367 * @param p BURS node to apply the rule to 9368 */ 9369 private void code254(AbstractBURS_TreeNode p) { 9370 { 9371 Address val = AV(Move.getVal(PR(p))); 9372 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PR(p)), 9373 R(Load.getAddress(P(p))), CAU16(val))); 9374 EMIT(MIR_Load.mutate(P(p), PPC_LAddr, Load.getResult(P(p)), 9375 Move.getResult(PR(p)).copyRO(), CAL16(val), 9376 Load.getLocation(P(p)), 9377 Load.getGuard(P(p)))); 9378} 9379 } 9380 9381 /** 9382 * Emit code for rule number 255: 9383 * r: LONG_LOAD(r,r) 9384 * @param p BURS node to apply the rule to 9385 */ 9386 private void code255(AbstractBURS_TreeNode p) { 9387 EMIT(MIR_Load.mutate(P(p), PPC_LAddrX, Load.getResult(P(p)), 9388 R(Load.getAddress(P(p))), Load.getOffset(P(p)), 9389 Load.getLocation(P(p)), Load.getGuard(P(p)))); 9390 } 9391 9392 /** 9393 * Emit code for rule number 256: 9394 * r: LONG_LOAD(REF_ADD(r,r),INT_CONSTANT) 9395 * @param p BURS node to apply the rule to 9396 */ 9397 private void code256(AbstractBURS_TreeNode p) { 9398 EMIT(MIR_Load.mutate(P(p), PPC_LAddrX, Load.getResult(P(p)), 9399 R(Binary.getVal1(PL(p))), Binary.getVal2(PL(p)), 9400 Load.getLocation(P(p)), Load.getGuard(P(p)))); 9401 } 9402 9403 /** 9404 * Emit code for rule number 257: 9405 * r: LONG_LOAD(REF_ADD(r,INT_CONSTANT),INT_CONSTANT) 9406 * @param p BURS node to apply the rule to 9407 */ 9408 private void code257(AbstractBURS_TreeNode p) { 9409 EMIT(MIR_Load.mutate(P(p), PPC_LAddr, Load.getResult(P(p)), 9410 R(Binary.getVal1(PL(p))), IC(VR(p)+VLR(p)), 9411 Load.getLocation(P(p)), Load.getGuard(P(p)))); 9412 } 9413 9414 /** 9415 * Emit code for rule number 258: 9416 * stm: LONG_STORE(r,OTHER_OPERAND(r,INT_CONSTANT)) 9417 * @param p BURS node to apply the rule to 9418 */ 9419 private void code258(AbstractBURS_TreeNode p) { 9420 EMIT(MIR_Store.mutate(P(p), PPC_STAddr, R(Store.getValue(P(p))), 9421 R(Store.getAddress(P(p))), 9422 Store.getOffset(P(p)), 9423 Store.getLocation(P(p)), 9424 Store.getGuard(P(p)))); 9425 } 9426 9427 /** 9428 * Emit code for rule number 259: 9429 * stm: LONG_STORE(r,OTHER_OPERAND(r,REF_MOVE(ADDRESS_CONSTANT))) 9430 * @param p BURS node to apply the rule to 9431 */ 9432 private void code259(AbstractBURS_TreeNode p) { 9433 { 9434 Address val = AV(Move.getVal(PRR(p))); 9435 EMIT(MIR_Binary.create(PPC_ADDIS, Move.getResult(PRR(p)), 9436 R(Store.getAddress(P(p))), CAU16(val))); 9437 EMIT(MIR_Store.mutate(P(p), PPC_STAddr, R(Store.getValue(P(p))), 9438 Move.getResult(PRR(p)).copyRO(), CAL16(val), 9439 Store.getLocation(P(p)), 9440 Store.getGuard(P(p)))); 9441} 9442 } 9443 9444 /** 9445 * Emit code for rule number 260: 9446 * stm: LONG_STORE(r,OTHER_OPERAND(r,r)) 9447 * @param p BURS node to apply the rule to 9448 */ 9449 private void code260(AbstractBURS_TreeNode p) { 9450 EMIT(MIR_Store.mutate(P(p), PPC_STAddrX, R(Store.getValue(P(p))), 9451 R(Store.getAddress(P(p))), 9452 Store.getOffset(P(p)), 9453 Store.getLocation(P(p)), 9454 Store.getGuard(P(p)))); 9455 } 9456 9457 /** 9458 * Emit code for rule number 261: 9459 * stm: LONG_STORE(r,OTHER_OPERAND(REF_ADD(r,INT_CONSTANT),INT_CONSTANT)) 9460 * @param p BURS node to apply the rule to 9461 */ 9462 private void code261(AbstractBURS_TreeNode p) { 9463 EMIT(MIR_Store.mutate(P(p), PPC_STAddr, R(Store.getValue(P(p))), 9464 R(Binary.getVal1(PRL(p))), 9465 IC(VRR(p) + VRLR(p)), 9466 Store.getLocation(P(p)), 9467 Store.getGuard(P(p)))); 9468 } 9469 9470 /** 9471 * Emit code for rule number 262: 9472 * r: PREPARE_ADDR(r, r) 9473 * @param p BURS node to apply the rule to 9474 */ 9475 private void code262(AbstractBURS_TreeNode p) { 9476 EMIT(MIR_Load.mutate(P(p), PPC_LAddrARX, Prepare.getResult(P(p)), 9477 R(Prepare.getAddress(P(p))), Prepare.getOffset(P(p)), 9478 Prepare.getLocation(P(p)), 9479 Prepare.getGuard(P(p)))); 9480 } 9481 9482 /** 9483 * Emit code for rule number 263: 9484 * r: ATTEMPT_ADDR(r, r) 9485 * @param p BURS node to apply the rule to 9486 */ 9487 private void code263(AbstractBURS_TreeNode p) { 9488 EMIT(P(p)); // Leave for ComplexLIR2MIRExpansion 9489 } 9490 9491 /** 9492 * Emit code using given rule number 9493 * 9494 * @param p the tree that's being emitted 9495 * @param n the non-terminal goal of that tree 9496 * @param ruleno the rule that will generate the tree 9497 */ 9498 @Override 9499 public void code(AbstractBURS_TreeNode p, int n, int ruleno) { 9500 switch(unsortedErnMap[ruleno]) { 9501 case 14: code14(p); break; 9502 case 15: code15(p); break; 9503 case 16: code16(p); break; 9504 case 17: code17(p); break; 9505 case 18: code18(p); break; 9506 case 19: code19(p); break; 9507 case 20: code20(p); break; 9508 case 21: code21(p); break; 9509 case 23: code23(p); break; 9510 case 24: code24(p); break; 9511 case 25: code25(p); break; 9512 case 26: code26(p); break; 9513 case 27: code27(p); break; 9514 case 28: code28(p); break; 9515 case 29: code29(p); break; 9516 case 30: code30(p); break; 9517 case 31: code31(p); break; 9518 case 32: code32(p); break; 9519 case 33: code33(p); break; 9520 case 34: code34(p); break; 9521 case 35: code35(p); break; 9522 case 36: code36(p); break; 9523 case 37: code37(p); break; 9524 case 38: code38(p); break; 9525 case 39: code39(p); break; 9526 case 40: code40(p); break; 9527 case 41: code41(p); break; 9528 case 42: code42(p); break; 9529 case 43: code43(p); break; 9530 case 44: code44(p); break; 9531 case 45: code45(p); break; 9532 case 46: code46(p); break; 9533 case 47: code47(p); break; 9534 case 48: code48(p); break; 9535 case 49: code49(p); break; 9536 case 50: code50(p); break; 9537 case 52: code52(p); break; 9538 case 54: code54(p); break; 9539 case 55: code55(p); break; 9540 case 56: code56(p); break; 9541 case 57: code57(p); break; 9542 case 58: code58(p); break; 9543 case 59: code59(p); break; 9544 case 60: code60(p); break; 9545 case 61: code61(p); break; 9546 case 62: code62(p); break; 9547 case 63: code63(p); break; 9548 case 64: code64(p); break; 9549 case 65: code65(p); break; 9550 case 66: code66(p); break; 9551 case 67: code67(p); break; 9552 case 68: code68(p); break; 9553 case 69: code69(p); break; 9554 case 70: code70(p); break; 9555 case 71: code71(p); break; 9556 case 72: code72(p); break; 9557 case 73: code73(p); break; 9558 case 74: code74(p); break; 9559 case 75: code75(p); break; 9560 case 76: code76(p); break; 9561 case 77: code77(p); break; 9562 case 78: code78(p); break; 9563 case 79: code79(p); break; 9564 case 80: code80(p); break; 9565 case 81: code81(p); break; 9566 case 82: code82(p); break; 9567 case 83: code83(p); break; 9568 case 84: code84(p); break; 9569 case 85: code85(p); break; 9570 case 86: code86(p); break; 9571 case 87: code87(p); break; 9572 case 88: code88(p); break; 9573 case 89: code89(p); break; 9574 case 90: code90(p); break; 9575 case 91: code91(p); break; 9576 case 92: code92(p); break; 9577 case 93: code93(p); break; 9578 case 94: code94(p); break; 9579 case 95: code95(p); break; 9580 case 96: code96(p); break; 9581 case 97: code97(p); break; 9582 case 98: code98(p); break; 9583 case 99: code99(p); break; 9584 case 100: code100(p); break; 9585 case 101: code101(p); break; 9586 case 102: code102(p); break; 9587 case 103: code103(p); break; 9588 case 104: code104(p); break; 9589 case 105: code105(p); break; 9590 case 106: code106(p); break; 9591 case 107: code107(p); break; 9592 case 108: code108(p); break; 9593 case 109: code109(p); break; 9594 case 110: code110(p); break; 9595 case 111: code111(p); break; 9596 case 112: code112(p); break; 9597 case 113: code113(p); break; 9598 case 114: code114(p); break; 9599 case 115: code115(p); break; 9600 case 116: code116(p); break; 9601 case 117: code117(p); break; 9602 case 118: code118(p); break; 9603 case 119: code119(p); break; 9604 case 120: code120(p); break; 9605 case 121: code121(p); break; 9606 case 122: code122(p); break; 9607 case 123: code123(p); break; 9608 case 124: code124(p); break; 9609 case 125: code125(p); break; 9610 case 126: code126(p); break; 9611 case 127: code127(p); break; 9612 case 128: code128(p); break; 9613 case 129: code129(p); break; 9614 case 130: code130(p); break; 9615 case 131: code131(p); break; 9616 case 132: code132(p); break; 9617 case 133: code133(p); break; 9618 case 134: code134(p); break; 9619 case 135: code135(p); break; 9620 case 136: code136(p); break; 9621 case 137: code137(p); break; 9622 case 138: code138(p); break; 9623 case 139: code139(p); break; 9624 case 140: code140(p); break; 9625 case 141: code141(p); break; 9626 case 142: code142(p); break; 9627 case 143: code143(p); break; 9628 case 144: code144(p); break; 9629 case 145: code145(p); break; 9630 case 146: code146(p); break; 9631 case 147: code147(p); break; 9632 case 148: code148(p); break; 9633 case 149: code149(p); break; 9634 case 150: code150(p); break; 9635 case 151: code151(p); break; 9636 case 152: code152(p); break; 9637 case 153: code153(p); break; 9638 case 154: code154(p); break; 9639 case 155: code155(p); break; 9640 case 156: code156(p); break; 9641 case 157: code157(p); break; 9642 case 158: code158(p); break; 9643 case 159: code159(p); break; 9644 case 160: code160(p); break; 9645 case 161: code161(p); break; 9646 case 162: code162(p); break; 9647 case 163: code163(p); break; 9648 case 164: code164(p); break; 9649 case 165: code165(p); break; 9650 case 166: code166(p); break; 9651 case 167: code167(p); break; 9652 case 168: code168(p); break; 9653 case 169: code169(p); break; 9654 case 170: code170(p); break; 9655 case 171: code171(p); break; 9656 case 172: code172(p); break; 9657 case 173: code173(p); break; 9658 case 174: code174(p); break; 9659 case 175: code175(p); break; 9660 case 176: code176(p); break; 9661 case 177: code177(p); break; 9662 case 178: code178(p); break; 9663 case 179: code179(p); break; 9664 case 180: code180(p); break; 9665 case 181: code181(p); break; 9666 case 182: code182(p); break; 9667 case 183: code183(p); break; 9668 case 184: code184(p); break; 9669 case 185: code185(p); break; 9670 case 186: code186(p); break; 9671 case 187: code187(p); break; 9672 case 188: code188(p); break; 9673 case 189: code189(p); break; 9674 case 190: code190(p); break; 9675 case 191: code191(p); break; 9676 case 192: code192(p); break; 9677 case 193: code193(p); break; 9678 case 194: code194(p); break; 9679 case 195: code195(p); break; 9680 case 196: code196(p); break; 9681 case 197: code197(p); break; 9682 case 198: code198(p); break; 9683 case 199: code199(p); break; 9684 case 200: code200(p); break; 9685 case 201: code201(p); break; 9686 case 202: code202(p); break; 9687 case 203: code203(p); break; 9688 case 204: code204(p); break; 9689 case 205: code205(p); break; 9690 case 206: code206(p); break; 9691 case 207: code207(p); break; 9692 case 208: code208(p); break; 9693 case 209: code209(p); break; 9694 case 210: code210(p); break; 9695 case 211: code211(p); break; 9696 case 213: code213(p); break; 9697 case 214: code214(p); break; 9698 case 215: code215(p); break; 9699 case 216: code216(p); break; 9700 case 217: code217(p); break; 9701 case 218: code218(p); break; 9702 case 219: code219(p); break; 9703 case 220: code220(p); break; 9704 case 221: code221(p); break; 9705 case 222: code222(p); break; 9706 case 223: code223(p); break; 9707 case 224: code224(p); break; 9708 case 225: code225(p); break; 9709 case 226: code226(p); break; 9710 case 227: code227(p); break; 9711 case 228: code228(p); break; 9712 case 229: code229(p); break; 9713 case 230: code230(p); break; 9714 case 231: code231(p); break; 9715 case 232: code232(p); break; 9716 case 233: code233(p); break; 9717 case 234: code234(p); break; 9718 case 235: code235(p); break; 9719 case 236: code236(p); break; 9720 case 237: code237(p); break; 9721 case 238: code238(p); break; 9722 case 239: code239(p); break; 9723 case 240: code240(p); break; 9724 case 241: code241(p); break; 9725 case 242: code242(p); break; 9726 case 243: code243(p); break; 9727 case 244: code244(p); break; 9728 case 245: code245(p); break; 9729 case 246: code246(p); break; 9730 case 247: code247(p); break; 9731 case 248: code248(p); break; 9732 case 249: code249(p); break; 9733 case 250: code250(p); break; 9734 case 251: code251(p); break; 9735 case 252: code252(p); break; 9736 case 253: code253(p); break; 9737 case 254: code254(p); break; 9738 case 255: code255(p); break; 9739 case 256: code256(p); break; 9740 case 257: code257(p); break; 9741 case 258: code258(p); break; 9742 case 259: code259(p); break; 9743 case 260: code260(p); break; 9744 case 261: code261(p); break; 9745 case 262: code262(p); break; 9746 case 263: code263(p); break; 9747 default: 9748 throw new OptimizingCompilerException("BURS", "rule " + ruleno + " without emit code:", 9749 BURS_Debug.string[unsortedErnMap[ruleno]]); 9750 } 9751 } 9752}