Mercurial > hg > graal-compiler

comparison src/cpu/x86/vm/x86_64.ad @ 3842:c7b60b601eb4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7069452: Cleanup NodeFlags Summary: Remove flags which duplicate information in Node::NodeClasses. Reviewed-by: never
author kvn
date Wed, 27 Jul 2011 17:28:36 -0700
parents 3d42f82cd811
children f1c12354c3f7
comparison
equal deleted inserted replaced
3841:0f34fdee809e 3842:c7b60b601eb4
4011 op_attrib op_cost(0); // Required cost attribute 4011 op_attrib op_cost(0); // Required cost attribute
4012 4012
4013 //----------Instruction Attributes--------------------------------------------- 4013 //----------Instruction Attributes---------------------------------------------
4014 ins_attrib ins_cost(100); // Required cost attribute 4014 ins_attrib ins_cost(100); // Required cost attribute
4015 ins_attrib ins_size(8); // Required size attribute (in bits) 4015 ins_attrib ins_size(8); // Required size attribute (in bits)
4016 ins_attrib ins_pc_relative(0); // Required PC Relative flag
4017 ins_attrib ins_short_branch(0); // Required flag: is this instruction 4016 ins_attrib ins_short_branch(0); // Required flag: is this instruction
4018 // a non-matching short branch variant 4017 // a non-matching short branch variant
4019 // of some long branch? 4018 // of some long branch?
4020 ins_attrib ins_alignment(1); // Required alignment attribute (must 4019 ins_attrib ins_alignment(1); // Required alignment attribute (must
4021 // be a power of 2) specifies the 4020 // be a power of 2) specifies the
7545 Address dispatch($dest$$Register, $switch_val$$Register, (Address::ScaleFactor) $shift$$constant); 7544 Address dispatch($dest$$Register, $switch_val$$Register, (Address::ScaleFactor) $shift$$constant);
7546 __ lea($dest$$Register, $constantaddress); 7545 __ lea($dest$$Register, $constantaddress);
7547 __ jmp(dispatch); 7546 __ jmp(dispatch);
7548 %} 7547 %}
7549 ins_pipe(pipe_jmp); 7548 ins_pipe(pipe_jmp);
7550 ins_pc_relative(1);
7551 %} 7549 %}
7552 7550
7553 instruct jumpXtnd_addr(rRegL switch_val, immI2 shift, immL32 offset, rRegI dest) %{ 7551 instruct jumpXtnd_addr(rRegL switch_val, immI2 shift, immL32 offset, rRegI dest) %{
7554 match(Jump (AddL (LShiftL switch_val shift) offset)); 7552 match(Jump (AddL (LShiftL switch_val shift) offset));
7555 ins_cost(350); 7553 ins_cost(350);
7566 Address dispatch($dest$$Register, $switch_val$$Register, (Address::ScaleFactor) $shift$$constant, (int) $offset$$constant); 7564 Address dispatch($dest$$Register, $switch_val$$Register, (Address::ScaleFactor) $shift$$constant, (int) $offset$$constant);
7567 __ lea($dest$$Register, $constantaddress); 7565 __ lea($dest$$Register, $constantaddress);
7568 __ jmp(dispatch); 7566 __ jmp(dispatch);
7569 %} 7567 %}
7570 ins_pipe(pipe_jmp); 7568 ins_pipe(pipe_jmp);
7571 ins_pc_relative(1);
7572 %} 7569 %}
7573 7570
7574 instruct jumpXtnd(rRegL switch_val, rRegI dest) %{ 7571 instruct jumpXtnd(rRegL switch_val, rRegI dest) %{
7575 match(Jump switch_val); 7572 match(Jump switch_val);
7576 ins_cost(350); 7573 ins_cost(350);
7587 Address dispatch($dest$$Register, $switch_val$$Register, Address::times_1); 7584 Address dispatch($dest$$Register, $switch_val$$Register, Address::times_1);
7588 __ lea($dest$$Register, $constantaddress); 7585 __ lea($dest$$Register, $constantaddress);
7589 __ jmp(dispatch); 7586 __ jmp(dispatch);
7590 %} 7587 %}
7591 ins_pipe(pipe_jmp); 7588 ins_pipe(pipe_jmp);
7592 ins_pc_relative(1);
7593 %} 7589 %}
7594 7590
7595 // Conditional move 7591 // Conditional move
7596 instruct cmovI_reg(rRegI dst, rRegI src, rFlagsReg cr, cmpOp cop) 7592 instruct cmovI_reg(rRegI dst, rRegI src, rFlagsReg cr, cmpOp cop)
7597 %{ 7593 %{
12018 format %{ "jmp $labl" %} 12014 format %{ "jmp $labl" %}
12019 size(5); 12015 size(5);
12020 opcode(0xE9); 12016 opcode(0xE9);
12021 ins_encode(OpcP, Lbl(labl)); 12017 ins_encode(OpcP, Lbl(labl));
12022 ins_pipe(pipe_jmp); 12018 ins_pipe(pipe_jmp);
12023 ins_pc_relative(1);
12024 %} 12019 %}
12025 12020
12026 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12021 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12027 instruct jmpCon(cmpOp cop, rFlagsReg cr, label labl) 12022 instruct jmpCon(cmpOp cop, rFlagsReg cr, label labl)
12028 %{ 12023 %{
12033 format %{ "j$cop $labl" %} 12028 format %{ "j$cop $labl" %}
12034 size(6); 12029 size(6);
12035 opcode(0x0F, 0x80); 12030 opcode(0x0F, 0x80);
12036 ins_encode(Jcc(cop, labl)); 12031 ins_encode(Jcc(cop, labl));
12037 ins_pipe(pipe_jcc); 12032 ins_pipe(pipe_jcc);
12038 ins_pc_relative(1);
12039 %} 12033 %}
12040 12034
12041 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12035 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12042 instruct jmpLoopEnd(cmpOp cop, rFlagsReg cr, label labl) 12036 instruct jmpLoopEnd(cmpOp cop, rFlagsReg cr, label labl)
12043 %{ 12037 %{
12048 format %{ "j$cop $labl\t# loop end" %} 12042 format %{ "j$cop $labl\t# loop end" %}
12049 size(6); 12043 size(6);
12050 opcode(0x0F, 0x80); 12044 opcode(0x0F, 0x80);
12051 ins_encode(Jcc(cop, labl)); 12045 ins_encode(Jcc(cop, labl));
12052 ins_pipe(pipe_jcc); 12046 ins_pipe(pipe_jcc);
12053 ins_pc_relative(1);
12054 %} 12047 %}
12055 12048
12056 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12049 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12057 instruct jmpLoopEndU(cmpOpU cop, rFlagsRegU cmp, label labl) %{ 12050 instruct jmpLoopEndU(cmpOpU cop, rFlagsRegU cmp, label labl) %{
12058 match(CountedLoopEnd cop cmp); 12051 match(CountedLoopEnd cop cmp);
12062 format %{ "j$cop,u $labl\t# loop end" %} 12055 format %{ "j$cop,u $labl\t# loop end" %}
12063 size(6); 12056 size(6);
12064 opcode(0x0F, 0x80); 12057 opcode(0x0F, 0x80);
12065 ins_encode(Jcc(cop, labl)); 12058 ins_encode(Jcc(cop, labl));
12066 ins_pipe(pipe_jcc); 12059 ins_pipe(pipe_jcc);
12067 ins_pc_relative(1);
12068 %} 12060 %}
12069 12061
12070 instruct jmpLoopEndUCF(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{ 12062 instruct jmpLoopEndUCF(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{
12071 match(CountedLoopEnd cop cmp); 12063 match(CountedLoopEnd cop cmp);
12072 effect(USE labl); 12064 effect(USE labl);
12075 format %{ "j$cop,u $labl\t# loop end" %} 12067 format %{ "j$cop,u $labl\t# loop end" %}
12076 size(6); 12068 size(6);
12077 opcode(0x0F, 0x80); 12069 opcode(0x0F, 0x80);
12078 ins_encode(Jcc(cop, labl)); 12070 ins_encode(Jcc(cop, labl));
12079 ins_pipe(pipe_jcc); 12071 ins_pipe(pipe_jcc);
12080 ins_pc_relative(1);
12081 %} 12072 %}
12082 12073
12083 // Jump Direct Conditional - using unsigned comparison 12074 // Jump Direct Conditional - using unsigned comparison
12084 instruct jmpConU(cmpOpU cop, rFlagsRegU cmp, label labl) %{ 12075 instruct jmpConU(cmpOpU cop, rFlagsRegU cmp, label labl) %{
12085 match(If cop cmp); 12076 match(If cop cmp);
12089 format %{ "j$cop,u $labl" %} 12080 format %{ "j$cop,u $labl" %}
12090 size(6); 12081 size(6);
12091 opcode(0x0F, 0x80); 12082 opcode(0x0F, 0x80);
12092 ins_encode(Jcc(cop, labl)); 12083 ins_encode(Jcc(cop, labl));
12093 ins_pipe(pipe_jcc); 12084 ins_pipe(pipe_jcc);
12094 ins_pc_relative(1);
12095 %} 12085 %}
12096 12086
12097 instruct jmpConUCF(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{ 12087 instruct jmpConUCF(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{
12098 match(If cop cmp); 12088 match(If cop cmp);
12099 effect(USE labl); 12089 effect(USE labl);
12102 format %{ "j$cop,u $labl" %} 12092 format %{ "j$cop,u $labl" %}
12103 size(6); 12093 size(6);
12104 opcode(0x0F, 0x80); 12094 opcode(0x0F, 0x80);
12105 ins_encode(Jcc(cop, labl)); 12095 ins_encode(Jcc(cop, labl));
12106 ins_pipe(pipe_jcc); 12096 ins_pipe(pipe_jcc);
12107 ins_pc_relative(1);
12108 %} 12097 %}
12109 12098
12110 instruct jmpConUCF2(cmpOpUCF2 cop, rFlagsRegUCF cmp, label labl) %{ 12099 instruct jmpConUCF2(cmpOpUCF2 cop, rFlagsRegUCF cmp, label labl) %{
12111 match(If cop cmp); 12100 match(If cop cmp);
12112 effect(USE labl); 12101 effect(USE labl);
12142 emit_cc(cbuf, $secondary, $cop$$cmpcode); 12131 emit_cc(cbuf, $secondary, $cop$$cmpcode);
12143 int disp = l->loc_pos() - (cbuf.insts_size() + 4); 12132 int disp = l->loc_pos() - (cbuf.insts_size() + 4);
12144 emit_d32(cbuf, disp); 12133 emit_d32(cbuf, disp);
12145 %} 12134 %}
12146 ins_pipe(pipe_jcc); 12135 ins_pipe(pipe_jcc);
12147 ins_pc_relative(1);
12148 %} 12136 %}
12149 12137
12150 // ============================================================================ 12138 // ============================================================================
12151 // The 2nd slow-half of a subtype check. Scan the subklass's 2ndary 12139 // The 2nd slow-half of a subtype check. Scan the subklass's 2ndary
12152 // superklass array for an instance of the superklass. Set a hidden 12140 // superklass array for an instance of the superklass. Set a hidden
12219 format %{ "jmp,s $labl" %} 12207 format %{ "jmp,s $labl" %}
12220 size(2); 12208 size(2);
12221 opcode(0xEB); 12209 opcode(0xEB);
12222 ins_encode(OpcP, LblShort(labl)); 12210 ins_encode(OpcP, LblShort(labl));
12223 ins_pipe(pipe_jmp); 12211 ins_pipe(pipe_jmp);
12224 ins_pc_relative(1);
12225 ins_short_branch(1); 12212 ins_short_branch(1);
12226 %} 12213 %}
12227 12214
12228 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12215 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12229 instruct jmpCon_short(cmpOp cop, rFlagsReg cr, label labl) %{ 12216 instruct jmpCon_short(cmpOp cop, rFlagsReg cr, label labl) %{
12234 format %{ "j$cop,s $labl" %} 12221 format %{ "j$cop,s $labl" %}
12235 size(2); 12222 size(2);
12236 opcode(0x70); 12223 opcode(0x70);
12237 ins_encode(JccShort(cop, labl)); 12224 ins_encode(JccShort(cop, labl));
12238 ins_pipe(pipe_jcc); 12225 ins_pipe(pipe_jcc);
12239 ins_pc_relative(1);
12240 ins_short_branch(1); 12226 ins_short_branch(1);
12241 %} 12227 %}
12242 12228
12243 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12229 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12244 instruct jmpLoopEnd_short(cmpOp cop, rFlagsReg cr, label labl) %{ 12230 instruct jmpLoopEnd_short(cmpOp cop, rFlagsReg cr, label labl) %{
12249 format %{ "j$cop,s $labl\t# loop end" %} 12235 format %{ "j$cop,s $labl\t# loop end" %}
12250 size(2); 12236 size(2);
12251 opcode(0x70); 12237 opcode(0x70);
12252 ins_encode(JccShort(cop, labl)); 12238 ins_encode(JccShort(cop, labl));
12253 ins_pipe(pipe_jcc); 12239 ins_pipe(pipe_jcc);
12254 ins_pc_relative(1);
12255 ins_short_branch(1); 12240 ins_short_branch(1);
12256 %} 12241 %}
12257 12242
12258 // Jump Direct Conditional - Label defines a relative address from Jcc+1 12243 // Jump Direct Conditional - Label defines a relative address from Jcc+1
12259 instruct jmpLoopEndU_short(cmpOpU cop, rFlagsRegU cmp, label labl) %{ 12244 instruct jmpLoopEndU_short(cmpOpU cop, rFlagsRegU cmp, label labl) %{
12264 format %{ "j$cop,us $labl\t# loop end" %} 12249 format %{ "j$cop,us $labl\t# loop end" %}
12265 size(2); 12250 size(2);
12266 opcode(0x70); 12251 opcode(0x70);
12267 ins_encode(JccShort(cop, labl)); 12252 ins_encode(JccShort(cop, labl));
12268 ins_pipe(pipe_jcc); 12253 ins_pipe(pipe_jcc);
12269 ins_pc_relative(1);
12270 ins_short_branch(1); 12254 ins_short_branch(1);
12271 %} 12255 %}
12272 12256
12273 instruct jmpLoopEndUCF_short(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{ 12257 instruct jmpLoopEndUCF_short(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{
12274 match(CountedLoopEnd cop cmp); 12258 match(CountedLoopEnd cop cmp);
12278 format %{ "j$cop,us $labl\t# loop end" %} 12262 format %{ "j$cop,us $labl\t# loop end" %}
12279 size(2); 12263 size(2);
12280 opcode(0x70); 12264 opcode(0x70);
12281 ins_encode(JccShort(cop, labl)); 12265 ins_encode(JccShort(cop, labl));
12282 ins_pipe(pipe_jcc); 12266 ins_pipe(pipe_jcc);
12283 ins_pc_relative(1);
12284 ins_short_branch(1); 12267 ins_short_branch(1);
12285 %} 12268 %}
12286 12269
12287 // Jump Direct Conditional - using unsigned comparison 12270 // Jump Direct Conditional - using unsigned comparison
12288 instruct jmpConU_short(cmpOpU cop, rFlagsRegU cmp, label labl) %{ 12271 instruct jmpConU_short(cmpOpU cop, rFlagsRegU cmp, label labl) %{
12293 format %{ "j$cop,us $labl" %} 12276 format %{ "j$cop,us $labl" %}
12294 size(2); 12277 size(2);
12295 opcode(0x70); 12278 opcode(0x70);
12296 ins_encode(JccShort(cop, labl)); 12279 ins_encode(JccShort(cop, labl));
12297 ins_pipe(pipe_jcc); 12280 ins_pipe(pipe_jcc);
12298 ins_pc_relative(1);
12299 ins_short_branch(1); 12281 ins_short_branch(1);
12300 %} 12282 %}
12301 12283
12302 instruct jmpConUCF_short(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{ 12284 instruct jmpConUCF_short(cmpOpUCF cop, rFlagsRegUCF cmp, label labl) %{
12303 match(If cop cmp); 12285 match(If cop cmp);
12307 format %{ "j$cop,us $labl" %} 12289 format %{ "j$cop,us $labl" %}
12308 size(2); 12290 size(2);
12309 opcode(0x70); 12291 opcode(0x70);
12310 ins_encode(JccShort(cop, labl)); 12292 ins_encode(JccShort(cop, labl));
12311 ins_pipe(pipe_jcc); 12293 ins_pipe(pipe_jcc);
12312 ins_pc_relative(1);
12313 ins_short_branch(1); 12294 ins_short_branch(1);
12314 %} 12295 %}
12315 12296
12316 instruct jmpConUCF2_short(cmpOpUCF2 cop, rFlagsRegUCF cmp, label labl) %{ 12297 instruct jmpConUCF2_short(cmpOpUCF2 cop, rFlagsRegUCF cmp, label labl) %{
12317 match(If cop cmp); 12298 match(If cop cmp);
12347 emit_d8(cbuf, disp); 12328 emit_d8(cbuf, disp);
12348 assert(-128 <= disp && disp <= 127, "Displacement too large for short jmp"); 12329 assert(-128 <= disp && disp <= 127, "Displacement too large for short jmp");
12349 assert(-128 <= parity_disp && parity_disp <= 127, "Displacement too large for short jmp"); 12330 assert(-128 <= parity_disp && parity_disp <= 127, "Displacement too large for short jmp");
12350 %} 12331 %}
12351 ins_pipe(pipe_jcc); 12332 ins_pipe(pipe_jcc);
12352 ins_pc_relative(1);
12353 ins_short_branch(1); 12333 ins_short_branch(1);
12354 %} 12334 %}
12355 12335
12356 // ============================================================================ 12336 // ============================================================================
12357 // inlined locking and unlocking 12337 // inlined locking and unlocking
12364 12344
12365 ins_cost(300); 12345 ins_cost(300);
12366 format %{ "fastlock $object,$box,$tmp,$scr" %} 12346 format %{ "fastlock $object,$box,$tmp,$scr" %}
12367 ins_encode(Fast_Lock(object, box, tmp, scr)); 12347 ins_encode(Fast_Lock(object, box, tmp, scr));
12368 ins_pipe(pipe_slow); 12348 ins_pipe(pipe_slow);
12369 ins_pc_relative(1);
12370 %} 12349 %}
12371 12350
12372 instruct cmpFastUnlock(rFlagsReg cr, 12351 instruct cmpFastUnlock(rFlagsReg cr,
12373 rRegP object, rax_RegP box, rRegP tmp) 12352 rRegP object, rax_RegP box, rRegP tmp)
12374 %{ 12353 %{
12377 12356
12378 ins_cost(300); 12357 ins_cost(300);
12379 format %{ "fastunlock $object, $box, $tmp" %} 12358 format %{ "fastunlock $object, $box, $tmp" %}
12380 ins_encode(Fast_Unlock(object, box, tmp)); 12359 ins_encode(Fast_Unlock(object, box, tmp));
12381 ins_pipe(pipe_slow); 12360 ins_pipe(pipe_slow);
12382 ins_pc_relative(1);
12383 %} 12361 %}
12384 12362
12385 12363
12386 // ============================================================================ 12364 // ============================================================================
12387 // Safepoint Instructions 12365 // Safepoint Instructions
12430 ins_cost(300); 12408 ins_cost(300);
12431 format %{ "call,static " %} 12409 format %{ "call,static " %}
12432 opcode(0xE8); /* E8 cd */ 12410 opcode(0xE8); /* E8 cd */
12433 ins_encode(Java_Static_Call(meth), call_epilog); 12411 ins_encode(Java_Static_Call(meth), call_epilog);
12434 ins_pipe(pipe_slow); 12412 ins_pipe(pipe_slow);
12435 ins_pc_relative(1);
12436 ins_alignment(4); 12413 ins_alignment(4);
12437 %} 12414 %}
12438 12415
12439 // Call Java Static Instruction (method handle version) 12416 // Call Java Static Instruction (method handle version)
12440 // Note: If this code changes, the corresponding ret_addr_offset() and 12417 // Note: If this code changes, the corresponding ret_addr_offset() and
12452 ins_encode(preserve_SP, 12429 ins_encode(preserve_SP,
12453 Java_Static_Call(meth), 12430 Java_Static_Call(meth),
12454 restore_SP, 12431 restore_SP,
12455 call_epilog); 12432 call_epilog);
12456 ins_pipe(pipe_slow); 12433 ins_pipe(pipe_slow);
12457 ins_pc_relative(1);
12458 ins_alignment(4); 12434 ins_alignment(4);
12459 %} 12435 %}
12460 12436
12461 // Call Java Dynamic Instruction 12437 // Call Java Dynamic Instruction
12462 // Note: If this code changes, the corresponding ret_addr_offset() and 12438 // Note: If this code changes, the corresponding ret_addr_offset() and
12470 format %{ "movq rax, #Universe::non_oop_word()\n\t" 12446 format %{ "movq rax, #Universe::non_oop_word()\n\t"
12471 "call,dynamic " %} 12447 "call,dynamic " %}
12472 opcode(0xE8); /* E8 cd */ 12448 opcode(0xE8); /* E8 cd */
12473 ins_encode(Java_Dynamic_Call(meth), call_epilog); 12449 ins_encode(Java_Dynamic_Call(meth), call_epilog);
12474 ins_pipe(pipe_slow); 12450 ins_pipe(pipe_slow);
12475 ins_pc_relative(1);
12476 ins_alignment(4); 12451 ins_alignment(4);
12477 %} 12452 %}
12478 12453
12479 // Call Runtime Instruction 12454 // Call Runtime Instruction
12480 instruct CallRuntimeDirect(method meth) 12455 instruct CallRuntimeDirect(method meth)
12485 ins_cost(300); 12460 ins_cost(300);
12486 format %{ "call,runtime " %} 12461 format %{ "call,runtime " %}
12487 opcode(0xE8); /* E8 cd */ 12462 opcode(0xE8); /* E8 cd */
12488 ins_encode(Java_To_Runtime(meth)); 12463 ins_encode(Java_To_Runtime(meth));
12489 ins_pipe(pipe_slow); 12464 ins_pipe(pipe_slow);
12490 ins_pc_relative(1);
12491 %} 12465 %}
12492 12466
12493 // Call runtime without safepoint 12467 // Call runtime without safepoint
12494 instruct CallLeafDirect(method meth) 12468 instruct CallLeafDirect(method meth)
12495 %{ 12469 %{
12499 ins_cost(300); 12473 ins_cost(300);
12500 format %{ "call_leaf,runtime " %} 12474 format %{ "call_leaf,runtime " %}
12501 opcode(0xE8); /* E8 cd */ 12475 opcode(0xE8); /* E8 cd */
12502 ins_encode(Java_To_Runtime(meth)); 12476 ins_encode(Java_To_Runtime(meth));
12503 ins_pipe(pipe_slow); 12477 ins_pipe(pipe_slow);
12504 ins_pc_relative(1);
12505 %} 12478 %}
12506 12479
12507 // Call runtime without safepoint 12480 // Call runtime without safepoint
12508 instruct CallLeafNoFPDirect(method meth) 12481 instruct CallLeafNoFPDirect(method meth)
12509 %{ 12482 %{
12513 ins_cost(300); 12486 ins_cost(300);
12514 format %{ "call_leaf_nofp,runtime " %} 12487 format %{ "call_leaf_nofp,runtime " %}
12515 opcode(0xE8); /* E8 cd */ 12488 opcode(0xE8); /* E8 cd */
12516 ins_encode(Java_To_Runtime(meth)); 12489 ins_encode(Java_To_Runtime(meth));
12517 ins_pipe(pipe_slow); 12490 ins_pipe(pipe_slow);
12518 ins_pc_relative(1);
12519 %} 12491 %}
12520 12492
12521 // Return Instruction 12493 // Return Instruction
12522 // Remove the return address & jump to it. 12494 // Remove the return address & jump to it.
12523 // Notice: We always emit a nop after a ret to make sure there is room 12495 // Notice: We always emit a nop after a ret to make sure there is room