Be more consistent in the naming convention for the various RET instructions to specify in terms of bitwidth.
Helps prevent future scheduler model mismatches like those that were only addressed in D44687.
Differential Revision: https://reviews.llvm.org/D113302
// be found here:
// https://software.intel.com/security-software-guidance/insights/deep-dive-load-value-injection#specialinstructions
switch (Inst.getOpcode()) {
- case X86::RETW:
- case X86::RETL:
- case X86::RETQ:
- case X86::RETIL:
- case X86::RETIQ:
- case X86::RETIW: {
+ case X86::RET16:
+ case X86::RET32:
+ case X86::RET64:
+ case X86::RETI16:
+ case X86::RETI32:
+ case X86::RETI64: {
MCInst ShlInst, FenceInst;
bool Parse32 = is32BitMode() || Code16GCC;
unsigned Basereg =
MachineInstrBuilder MIB;
if (StackAdj == 0) {
MIB = BuildMI(MBB, MBBI, DL,
- TII->get(STI->is64Bit() ? X86::RETQ : X86::RETL));
+ TII->get(STI->is64Bit() ? X86::RET64 : X86::RET32));
} else if (isUInt<16>(StackAdj)) {
MIB = BuildMI(MBB, MBBI, DL,
- TII->get(STI->is64Bit() ? X86::RETIQ : X86::RETIL))
+ TII->get(STI->is64Bit() ? X86::RETI64 : X86::RETI32))
.addImm(StackAdj);
} else {
assert(!STI->is64Bit() &&
BuildMI(MBB, MBBI, DL, TII->get(X86::POP32r)).addReg(X86::ECX, RegState::Define);
X86FL->emitSPUpdate(MBB, MBBI, DL, StackAdj, /*InEpilogue=*/true);
BuildMI(MBB, MBBI, DL, TII->get(X86::PUSH32r)).addReg(X86::ECX);
- MIB = BuildMI(MBB, MBBI, DL, TII->get(X86::RETL));
+ MIB = BuildMI(MBB, MBBI, DL, TII->get(X86::RET32));
}
for (unsigned I = 1, E = MBBI->getNumOperands(); I != E; ++I)
MIB.add(MBBI->getOperand(I));
MachineInstrBuilder MIB;
if (X86MFInfo->getBytesToPopOnReturn()) {
MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
- TII.get(Subtarget->is64Bit() ? X86::RETIQ : X86::RETIL))
+ TII.get(Subtarget->is64Bit() ? X86::RETI64 : X86::RETI32))
.addImm(X86MFInfo->getBytesToPopOnReturn());
} else {
MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc,
- TII.get(Subtarget->is64Bit() ? X86::RETQ : X86::RETL));
+ TII.get(Subtarget->is64Bit() ? X86::RET64 : X86::RET32));
}
for (unsigned i = 0, e = RetRegs.size(); i != e; ++i)
MIB.addReg(RetRegs[i], RegState::Implicit);
MF.push_back(CallTarget);
const unsigned CallOpc = Is64Bit ? X86::CALL64pcrel32 : X86::CALLpcrel32;
- const unsigned RetOpc = Is64Bit ? X86::RETQ : X86::RETL;
+ const unsigned RetOpc = Is64Bit ? X86::RET64 : X86::RET32;
Entry->addLiveIn(ThunkReg);
BuildMI(Entry, DebugLoc(), TII->get(CallOpc)).addSym(TargetSym);
// ST1 arguments when returning values on the x87 stack.
let isTerminator = 1, isReturn = 1, isBarrier = 1,
hasCtrlDep = 1, FPForm = SpecialFP, SchedRW = [WriteJumpLd] in {
- def RETL : I <0xC3, RawFrm, (outs), (ins variable_ops),
+ def RET32 : I <0xC3, RawFrm, (outs), (ins variable_ops),
"ret{l}", []>, OpSize32, Requires<[Not64BitMode]>;
- def RETQ : I <0xC3, RawFrm, (outs), (ins variable_ops),
+ def RET64 : I <0xC3, RawFrm, (outs), (ins variable_ops),
"ret{q}", []>, OpSize32, Requires<[In64BitMode]>;
- def RETW : I <0xC3, RawFrm, (outs), (ins),
+ def RET16 : I <0xC3, RawFrm, (outs), (ins),
"ret{w}", []>, OpSize16;
- def RETIL : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt, variable_ops),
+ def RETI32 : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt, variable_ops),
"ret{l}\t$amt", []>, OpSize32, Requires<[Not64BitMode]>;
- def RETIQ : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt, variable_ops),
+ def RETI64 : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt, variable_ops),
"ret{q}\t$amt", []>, OpSize32, Requires<[In64BitMode]>;
- def RETIW : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt),
+ def RETI16 : Ii16<0xC2, RawFrm, (outs), (ins i16imm:$amt),
"ret{w}\t$amt", []>, OpSize16;
- def LRETL : I <0xCB, RawFrm, (outs), (ins),
+ def LRET32 : I <0xCB, RawFrm, (outs), (ins),
"{l}ret{l|f}", []>, OpSize32;
- def LRETQ : RI <0xCB, RawFrm, (outs), (ins),
+ def LRET64 : RI <0xCB, RawFrm, (outs), (ins),
"{l}ret{|f}q", []>, Requires<[In64BitMode]>;
- def LRETW : I <0xCB, RawFrm, (outs), (ins),
+ def LRET16 : I <0xCB, RawFrm, (outs), (ins),
"{l}ret{w|f}", []>, OpSize16;
- def LRETIL : Ii16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
- "{l}ret{l|f}\t$amt", []>, OpSize32;
- def LRETIQ : RIi16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
- "{l}ret{|f}q\t$amt", []>, Requires<[In64BitMode]>;
- def LRETIW : Ii16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
- "{l}ret{w|f}\t$amt", []>, OpSize16;
+ def LRETI32 : Ii16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
+ "{l}ret{l|f}\t$amt", []>, OpSize32;
+ def LRETI64 : RIi16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
+ "{l}ret{|f}q\t$amt", []>, Requires<[In64BitMode]>;
+ def LRETI16 : Ii16<0xCA, RawFrm, (outs), (ins i16imm:$amt),
+ "{l}ret{w|f}\t$amt", []>, OpSize16;
// The machine return from interrupt instruction, but sometimes we need to
// perform a post-epilogue stack adjustment. Codegen emits the pseudo form
(STI.isTarget64BitLP64() ? X86::ADJCALLSTACKUP64
: X86::ADJCALLSTACKUP32),
X86::CATCHRET,
- (STI.is64Bit() ? X86::RETQ : X86::RETL)),
+ (STI.is64Bit() ? X86::RET64 : X86::RET32)),
Subtarget(STI), RI(STI.getTargetTriple()) {
}
// We're a normal call, so our sequence doesn't have a return instruction.
// Add it in.
- MachineInstr *retq = BuildMI(MF, DebugLoc(), get(X86::RETQ));
+ MachineInstr *retq = BuildMI(MF, DebugLoc(), get(X86::RET64));
MBB.insert(MBB.end(), retq);
}
bool Modified = false;
for (auto &MBB : MF) {
for (auto MBBI = MBB.begin(); MBBI != MBB.end(); ++MBBI) {
- if (MBBI->getOpcode() != X86::RETQ)
+ if (MBBI->getOpcode() != X86::RET64)
continue;
unsigned ClobberReg = TRI->findDeadCallerSavedReg(MBB, MBBI);
}
static unsigned getRetOpcode(const X86Subtarget &Subtarget) {
- return Subtarget.is64Bit() ? X86::RETQ : X86::RETL;
+ return Subtarget.is64Bit() ? X86::RET64 : X86::RET32;
}
Optional<MCOperand>
return 0;
case TargetOpcode::PATCHABLE_RET:
case X86::RET:
- case X86::RETL:
- case X86::RETQ:
- case X86::RETIL:
- case X86::RETIQ:
+ case X86::RET32:
+ case X86::RET64:
+ case X86::RETI32:
+ case X86::RETI64:
case X86::TCRETURNdi:
case X86::TCRETURNri:
case X86::TCRETURNmi:
let NumMicroOps = 3;
let ResourceCycles = [1,1,1];
}
-def: InstRW<[BWWriteResGroup84], (instrs LRETQ, RETQ)>;
+def: InstRW<[BWWriteResGroup84], (instrs LRET64, RET64)>;
def BWWriteResGroup87 : SchedWriteRes<[BWPort4,BWPort23,BWPort237,BWPort06]> {
let Latency = 7;
let NumMicroOps = 4;
let ResourceCycles = [1, 2, 1];
}
-def : InstRW<[HWWriteRETI], (instregex "RETI(L|Q|W)", "LRETI(L|Q|W)")>;
+def : InstRW<[HWWriteRETI], (instregex "RETI(16|32|64)", "LRETI(16|32|64)")>;
// BOUND.
// r,m.
let NumMicroOps = 3;
let ResourceCycles = [1,1,1];
}
-def: InstRW<[HWWriteResGroup41], (instrs LRETQ, RETL, RETQ)>;
+def: InstRW<[HWWriteResGroup41], (instrs LRET64, RET32, RET64)>;
def HWWriteResGroup44 : SchedWriteRes<[HWPort4,HWPort6,HWPort237,HWPort0156]> {
let Latency = 3;
let NumMicroOps = 3;
let ResourceCycles = [1,1,1];
}
-def: InstRW<[ICXWriteResGroup104], (instrs LRETQ, RETQ)>;
+def: InstRW<[ICXWriteResGroup104], (instrs LRET64, RET64)>;
def ICXWriteResGroup106 : SchedWriteRes<[ICXPort4,ICXPort5,ICXPort237]> {
let Latency = 7;
def: InstRW<[SBWriteResGroup2], (instrs FDECSTP, FINCSTP, FFREE, FFREEP, FNOP,
LD_Frr, ST_Frr, ST_FPrr)>;
def: InstRW<[SBWriteResGroup2], (instrs LOOP, LOOPE, LOOPNE)>; // FIXME: This seems wrong compared to other Intel CPUs.
-def: InstRW<[SBWriteResGroup2], (instrs RETQ)>;
+def: InstRW<[SBWriteResGroup2], (instrs RET64)>;
def SBWriteResGroup4 : SchedWriteRes<[SBPort05]> {
let Latency = 1;
let NumMicroOps = 3;
let ResourceCycles = [1,1,1];
}
-def: InstRW<[SKLWriteResGroup98], (instrs LRETQ, RETQ)>;
+def: InstRW<[SKLWriteResGroup98], (instrs LRET64, RET64)>;
def SKLWriteResGroup100 : SchedWriteRes<[SKLPort4,SKLPort23,SKLPort237,SKLPort06]> {
let Latency = 7;
let NumMicroOps = 3;
let ResourceCycles = [1,1,1];
}
-def: InstRW<[SKXWriteResGroup104], (instrs LRETQ, RETQ)>;
+def: InstRW<[SKXWriteResGroup104], (instrs LRET64, RET64)>;
def SKXWriteResGroup106 : SchedWriteRes<[SKXPort4,SKXPort5,SKXPort237]> {
let Latency = 7;
PUSH16rmr, PUSH32rmr, PUSH64rmr,
PUSH16i8, PUSH32i8, PUSH64i8, PUSH64i32,
XCH_F)>;
-def : InstRW<[AtomWrite0_1_1], (instregex "RETI(L|Q|W)$",
+def : InstRW<[AtomWrite0_1_1], (instregex "RETI(16|32|64)$",
"IRET(16|32|64)?")>;
def AtomWrite0_1_5 : SchedWriteRes<[AtomPort0, AtomPort1]> {
let Latency = 79;
let ResourceCycles = [79];
}
-def : InstRW<[AtomWrite01_79], (instregex "RET(L|Q|W)?$",
- "LRETI?(L|Q|W)")>;
+def : InstRW<[AtomWrite01_79], (instregex "RET(16|32|64)?$",
+ "LRETI?(16|32|64)")>;
def AtomWrite01_92 : SchedWriteRes<[AtomPort01]> {
let Latency = 92;
def ZnWriteRET : SchedWriteRes<[ZnALU03]> {
let NumMicroOps = 2;
}
-def : InstRW<[ZnWriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)",
+def : InstRW<[ZnWriteRET], (instregex "RET(16|32|64)", "LRET(16|32|64)",
"IRET(16|32|64)")>;
//-- Logic instructions --//
def Zn2WriteRET : SchedWriteRes<[Zn2ALU03]> {
let NumMicroOps = 2;
}
-def : InstRW<[Zn2WriteRET], (instregex "RET(L|Q|W)", "LRET(L|Q|W)",
+def : InstRW<[Zn2WriteRET], (instregex "RET(16|32|64)", "LRET(16|32|64)",
"IRET(16|32|64)")>;
//-- Logic instructions --//
MOV32mr $noreg, 1, $noreg, @ga, $noreg, killed %8 :: (store (s32) into @ga)
%5:gr32 = MOV32rm %stack.2.c, 1, $noreg, 0, $noreg :: (load (s32) from %ir.c)
$eax = COPY %5
- RETQ implicit $eax
+ RET64 implicit $eax
;CHECK: WARNING: Missing line 9
;CHECK-NEXT: Machine IR debug info check: FAIL
# CHECK-NOT: successors
# CHECK: JCC_1 %bb.1, 4, implicit undef $eflags
# CHECK: bb.3:
-# CHECK: RETQ undef $eax
+# CHECK: RET64 undef $eax
name: func0
body: |
bb.0:
JCC_1 %bb.4, 4, implicit undef $eflags ; condjump+fallthrough to same block
bb.4:
- RETQ undef $eax
+ RET64 undef $eax
...
---
# Some cases that need explicit successors:
bb.3:
; CHECK: bb.3:
- ; CHECK: RETQ undef $eax
- RETQ undef $eax
+ ; CHECK: RET64 undef $eax
+ RET64 undef $eax
...
liveins: $edi, $esi
$eax = LEA64_32r killed $rdi, 1, killed $rsi, 0, _
- RETQ $eax
+ RET64 $eax
...
---
name: test2
liveins: $esi
$eax = LEA64_32r killed $rdi, 1, killed $rsi, 0, _
- RETQ $eax
+ RET64 $eax
...
---
name: test3
liveins:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
...
; CHECK: [[@LINE+1]]:8: basic block definition should be located at the start of the line
less bb.1:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
---
name: test2
JMP64m $rip, 1, _, @addr, _
bb.1 (address-taken):
- RETQ
+ RET64
...
---
name: slot_in_other_function
; CHECK: $rax = LEA64r $rip, 1, $noreg, blockaddress(@test3, %ir-block.0), $noreg
$rax = LEA64r $rip, 1, _, blockaddress(@test3, %ir-block.0), _
MOV64mr killed $rdi, 1, _, 0, _, killed $rax
- RETQ
+ RET64
...
---
name: test3
JMP64m $rip, 1, _, @addr, _
bb.1 (address-taken):
- RETQ
+ RET64
...
---
name: test4
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
NOOP
bb.2:
- RETQ undef $eax
+ RET64 undef $eax
...
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
---
name: func
$eax = MOV32r0 implicit-def dead $eflags
$rsp = ADD64ri8 $rsp, 16, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
; CHECK: CFI_INSTRUCTION def_cfa_offset 4048
CFI_INSTRUCTION def_cfa_offset 4048
$rsp = ADD64ri32 $rsp, 4040, implicit-def dead $eflags
- RETQ
+ RET64
...
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp
$eax = LEA64_32r killed $rbx, 1, $rbx, 0, _
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
body: |
bb.0.entry:
%xmm0 = ADDSDrm killed %xmm0, %rip, 1, _, %const.0, _
- RETQ %xmm0
+ RET64 %xmm0
...
$xmm1 = ADDSSrm killed $xmm1, $rip, 1, _, %const.1, _, implicit $mxcsr
$xmm1 = CVTSS2SDrr killed $xmm1, implicit $mxcsr
$xmm0 = MULSDrr killed $xmm0, killed $xmm1, implicit $mxcsr
- RETQ $xmm0
+ RET64 $xmm0
...
---
# Verify that alignment can be inferred:
$xmm1 = ADDSSrm killed $xmm1, $rip, 1, _, %const.1, _, implicit $mxcsr
$xmm1 = CVTSS2SDrr killed $xmm1, implicit $mxcsr
$xmm0 = MULSDrr killed $xmm0, killed $xmm1, implicit $mxcsr
- RETQ $xmm0
+ RET64 $xmm0
...
---
# Verify that the non-standard alignments are respected:
$xmm1 = ADDSSrm killed $xmm1, $rip, 1, _, %const.1, _, implicit $mxcsr
$xmm1 = CVTSS2SDrr killed $xmm1, implicit $mxcsr
$xmm0 = MULSDrr killed $xmm0, killed $xmm1, implicit $mxcsr
- RETQ $xmm0
+ RET64 $xmm0
...
---
# CHECK: name: test4
$xmm1 = ADDSSrm killed $xmm1, $rip, 1, _, %const.0 + 8, _, implicit $mxcsr
$xmm1 = CVTSS2SDrr killed $xmm1, implicit $mxcsr
$xmm0 = MULSDrr killed $xmm0, killed $xmm1, implicit $mxcsr
- RETQ $xmm0
+ RET64 $xmm0
...
body: |
bb.0.entry:
%xmm0 = ADDSDrm killed %xmm0, %rip, 1, _, %const.0, _
- RETQ %xmm0
+ RET64 %xmm0
...
DBG_VALUE $esi, $noreg, !13, !DIExpression(), debug-location !15\r
DBG_VALUE $eax, $noreg, !12, !DIExpression(), debug-location !15\r
renamable $eax = nsw IMUL32rr killed renamable $eax, killed renamable $esi, implicit-def dead $eflags, debug-location !16\r
- RETQ $eax, debug-location !17\r
+ RET64 $eax, debug-location !17\r
\r
...\r
\r
bb.0.body:
; CHECK: $eax = IMUL32rri8 $edi, 11, implicit-def dead $eflags
$eax = IMUL32rri8 $edi, 11, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:83: the tied-def operand #3 is already tied with another register operand
INLINEASM &"$foo", 1, 2818058, def $rdi, 2147483657, killed $rdi(tied-def 3), killed $rdi(tied-def 3)
$rax = COPY killed $rdi
- RETQ killed $rax
+ RET64 killed $rax
...
$eax = MOV32rm $rdi, 1, _, 0, _ :: (volatile volatile load (s32) from %ir.x)
$eax = INC32r killed $eax, implicit-def dead $eflags
MOV32mr killed $rdi, 1, _, 0, _, $eax :: (volatile store (s32) into %ir.x)
- RETQ $eax
+ RET64 $eax
...
bb.1.less:
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.2.exit:
$eax = COPY $edi
- RETQ $eax
+ RET64 $eax
...
$edi = COPY killed $ecx
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp
$rax = POP64r implicit-def $rsp, implicit $rsp
- RETQ
+ RET64
...
$xmm1 = MOVSSrr killed $xmm1, killed $xmm2
MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec, align 32)
MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 32)
- RETQ
+ RET64
...
$xmm1 = MOVSSrr killed $xmm1, killed $xmm2
MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec, align 32)
MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 32)
- RETQ
+ RET64
...
bb.1.less:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp
$eax = LEA64_32r killed $rbx, 1, $rbx, 0, _
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:91: expected ',' before the next machine memory operand
INC32m killed $rdi, 1, _, 0, _, implicit-def dead $eflags :: (store (s32) into %ir.a) (load (s32) from %ir.a)
- RETQ
+ RET64
...
$eax = MOV32r0 implicit-def $eflags
bb.2.exit:
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2.exit:
- RETQ $eax
+ RET64 $eax
...
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
$rax = MOV64rm $rip, 1, _, @G + , _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:78: expected tied-def or low-level type after '('
INLINEASM &"$foo", 1, 2818058, def $rdi, 2147483657, killed $rdi(tied-def)
$rax = COPY killed $rdi
- RETQ killed $rax
+ RET64 killed $rax
...
bb.1.less:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:48: expected 'load' or 'store' memory operation
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (4 from %ir.a)
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:20: expected a machine operand
$eax = XOR32rr =
- RETQ $eax
+ RET64 $eax
...
DBG_VALUE _, 0, !12, !13, debug-location 14
MOV32mr $stack.x.addr, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
DBG_VALUE _, 0, !12, ! _
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
MOV32mr $rsp, 1, _, -4, _, $edi :: (store (s32) into %ir.xa)
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
%2 = COPY $edi
%2 = IMUL32rr %2, %1, implicit-def dead $eflags
$eax = COPY %2
- RETQ killed $eax
+ RET64 killed $eax
...
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
---
name: func
$eax = MOV32r0 implicit-def dead $eflags
$rsp = ADD64ri8 $rsp, 16, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
%0 = COPY %edi
%eax = COPY %0
- RETQ %eax
+ RET64 %eax
...
liveins: %0
$eax = COPY $edi
- RETQ $eax
+ RET64 $eax
...
bb.1.less:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2.nah:
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:36: expected a cfi offset
CFI_INSTRUCTION def_cfa_offset _
$rsp = ADD64ri32 $rsp, 4040, implicit-def dead $eflags
- RETQ
+ RET64
...
liveins: $rdi
; CHECK: [[@LINE+1]]:64: expected a pointer IR value
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load (s32) from %ir.b)
- RETQ $eax
+ RET64 $eax
...
$xmm1 = MOVSSrr killed $xmm1, killed $xmm2
MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec, align 32)
MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 32)
- RETQ
+ RET64
...
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp
$eax = LEA64_32r killed $rbx, 1, $rbx, 0, _
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:33: expected a register after register flags
$eax = MOV32r0 implicit-def 2
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:53: expected an atomic scope, ordering or a size specification
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load from %ir.a)
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:53: expected memory LLT, the size integer literal or 'unknown-size' after memory operation
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load . from %ir.a)
- RETQ $eax
+ RET64 $eax
...
CMP64rm killed $rbx, $rsp, 1, _, 24, _, implicit-def $eflags
$rsp = ADD64ri8 $rsp, 32, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
%1 = COPY %0 . 42
%2 = AND8ri %1, 1, implicit-def $eflags
$al = COPY %2
- RETQ $al
+ RET64 $al
...
$rax = MOV64rm $rip, 1, _, target-flags( ) @G, _
$eax = MOV32rm killed $rax, 1, _, 0, _
$eax = INC32r killed $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:70: expected tied-def or low-level type after '('
INLINEASM &"$foo", 1, 2818058, def $rdi, 2147483657, killed $rdi(3)
$rax = COPY killed $rdi
- RETQ killed $rax
+ RET64 killed $rax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:64: expected an IR value reference
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load (s32) from a)
- RETQ $eax
+ RET64 $eax
...
%0 = COPY $edi
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
liveins: $eax
$rsp = ADD64ri32 $rsp, 520, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.2.entry:
; CHECK: CALL64pcrel32 &__stack_chk_fail,
$eax = MOV32rm $esp, 1, _, 8, _ :: (load (s32) from %fixed-stack.0, align 16)
MOV32mr $esp, 1, _, 0, _, $eax :: (store (s32) into %ir.b)
$edx = POP32r implicit-def $esp, implicit $esp
- RETL $eax
+ RET32 $eax
...
bb.0.entry:
$eax = MOV32rm $esp, 1, _, 4, _
$eax = ADD32rm killed $eax, $esp, 1, _, 8, _, implicit-def dead $eflags
- RETL $eax
+ RET32 $eax
...
bb.0.entry:
$eax = MOV32rm $esp, 1, _, 8, _
MOV32mr $esp, 1, _, 0, _, $eax
- RETL $eax
+ RET32 $eax
...
bb.3.false:
liveins: $eax
- RETQ $eax
+ RET64 $eax
...
$rsp = ADD64ri8 $rsp, 32, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
bb.2.entry:
CALL64pcrel32 &__stack_chk_fail, csr_64, implicit $rsp, implicit-def $rsp
body: |
bb.0.body:
$eax = IMUL32rri8 $edi, 11, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
---
name: foo
$rdx = frame-setup frame-destroy POP64r implicit-def $rsp, implicit $rsp
; CHECK: $rdx = frame-setup frame-destroy POP64r
$rdx = frame-destroy frame-setup POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
%0 = COPY $edi
%2 = ADD32rr %0, %1, implicit-def dead $eflags
$eax = COPY %2
- RETQ $eax
+ RET64 $eax
...
$rax = MOV64rm $rip, 1, _, @G, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: inc2
$rax = MOV64rm $rip, 1, _, @0, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
---
name: test
$eax = MOV32rm killed $rax, 1, _, 0, _
$rcx = MOV64rm $rip, 1, _, @$.-B, _
MOV32mr killed $rcx, 1, _, 0, _, $eax
- RETQ $eax
+ RET64 $eax
...
---
name: test2
; CHECK: , @"\01Hello@$%09 \\ World,",
$rax = MOV64rm $rip, 1, _, @"\01Hello@$%09 \\ World,", _
$eax = MOV32rm killed $rax, 1, _, 0, _
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: test3
$eax = MOV32rm killed $rax, 1, _, 0, _
$rcx = MOV64rm $rip, 1, _, @$.-B - 8, _
MOV32mr killed $rcx, 1, _, 0, _, $eax
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: tf
$rax = MOV64rm $rip, 1, _, target-flags(x86-gotpcrel) @G, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
body: |
bb.0.entry:
; CHECK: $eax = MOV32ri 42
- ; CHECK-NEXT: RETQ $eax
+ ; CHECK-NEXT: RET64 $eax
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: bar
body: |
bb.0.entry:
; CHECK: $eax = MOV32ri -11
- ; CHECK-NEXT: RETQ $eax
+ ; CHECK-NEXT: RET64 $eax
$eax = MOV32ri -11
- RETQ $eax
+ RET64 $eax
...
bb.1.less:
; CHECK: $eax = MOV32r0 implicit-def $eflags
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.2.exit:
$eax = COPY $edi
- RETQ $eax
+ RET64 $eax
...
---
name: implicit_subregister1
; CHECK-LABEL: name: implicit_subregister1
; CHECK: dead $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, implicit-def $al
dead $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, implicit-def $al
- RETQ killed $al
+ RET64 killed $al
...
---
name: implicit_subregister2
; CHECK-LABEL: name: implicit_subregister2
; CHECK: dead $r15 = XOR64rr undef $r15, undef $r15, implicit-def dead $eflags, implicit-def $r15w
dead $r15 = XOR64rr undef $r15, undef $r15, implicit-def dead $eflags, implicit-def $r15w
- RETQ killed $r15w
+ RET64 killed $r15w
...
; CHECK: INLINEASM &foo, 0 /* attdialect */, 4390922 /* regdef:GR64 */, def $rsi, 4390922 /* regdef:GR64 */, def dead $rdi,
INLINEASM &foo, 0, 4390922, def $rsi, 4390922, def dead $rdi, 2147549193, killed $rdi, 2147483657, killed $rsi, 12, implicit-def dead early-clobber $eflags
$rax = MOV64rr killed $rsi
- RETQ killed $rax
+ RET64 killed $rax
...
---
name: test2
; CHECK: INLINEASM &foo, 0 /* attdialect */, 4390922 /* regdef:GR64 */, def $rsi, 4390922 /* regdef:GR64 */, def dead $rdi, 2147549193 /* reguse tiedto:$1 */, killed $rdi(tied-def 5), 2147483657 /* reguse tiedto:$0 */, killed $rsi(tied-def 3), 12 /* clobber */, implicit-def dead early-clobber $eflags
INLINEASM &foo, 0, 4390922, def $rsi, 4390922, def dead $rdi, 2147549193, killed $rdi(tied-def 5), 2147483657, killed $rsi(tied-def 3), 12, implicit-def dead early-clobber $eflags
$rax = MOV64rr killed $rsi
- RETQ killed $rax
+ RET64 killed $rax
...
%7:gr64 = ADD64rr killed %4, killed %5, implicit-def $eflags
%8:gr64 = ADD64rr killed %6, killed %7, implicit-def $eflags
$rax = COPY %8
- RETQ implicit $rax
+ RET64 implicit $rax
...
; CHECK: DBG_VALUE $noreg, 0, !11, !DIExpression(), debug-location !12
; CHECK: DBG_VALUE $noreg, 0, !11, !DIExpression(), debug-location !12
; CHECK: $eax = COPY %0, debug-location !13
- ; CHECK: RETQ $eax, debug-location !13
+ ; CHECK: RET64 $eax, debug-location !13
%0 = COPY $edi
DBG_VALUE _, 0, !12, !DIExpression(), debug-location !13
; Test whether debug-use is still recognized for compatibility with old
DBG_VALUE debug-use _, 0, !12, !DIExpression(), debug-location !13
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0
$eax = COPY %0, debug-location !14
- RETQ $eax, debug-location !14
+ RET64 $eax, debug-location !14
...
---
name: test_typed_immediates
DBG_VALUE _, i128 123492148938512984928424384934328985928, !12, !DIExpression(), debug-location !13
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
---
name: test_mir_created
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0, debug-location !DILocation(line: 4, scope: !15, inlinedAt: !16)
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0, debug-location !DILocation(line: 5, scope: !15, inlinedAt: !DILocation(line: 4, scope: !15))
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:47: use of undefined constant '%const.10'
$xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.10, _
- RETQ $xmm0
+ RET64 $xmm0
...
$rax = MOV64rm $rip, 1, _, target-flags(x86-test) @G, _
$eax = MOV32rm killed $rax, 1, _, 0, _
$eax = INC32r killed $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:58: use of invalid tied-def operand index '300'; instruction has only 6 operands
INLINEASM &"$foo", 1, 2818058, def $rdi, 2147483657, killed $rdi(tied-def 300)
$rax = COPY killed $rdi
- RETQ killed $rax
+ RET64 killed $rax
...
bb.2.def:
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.3.lbl1:
$eax = MOV32ri 1
- RETQ $eax
+ RET64 $eax
bb.4.lbl2:
$eax = MOV32ri 2
- RETQ $eax
+ RET64 $eax
bb.5.lbl3:
$eax = MOV32ri 4
- RETQ $eax
+ RET64 $eax
bb.6.lbl4:
$eax = MOV32ri 8
- RETQ $eax
+ RET64 $eax
...
---
name: test_jumptable2
bb.2.def:
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.3.lbl1:
$eax = MOV32ri 1
- RETQ $eax
+ RET64 $eax
bb.4.lbl2:
$eax = MOV32ri 2
- RETQ $eax
+ RET64 $eax
bb.5.lbl3:
$eax = MOV32ri 4
- RETQ $eax
+ RET64 $eax
bb.6.lbl4:
$eax = MOV32ri 8
- RETQ $eax
+ RET64 $eax
...
bb.2.def:
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.3.lbl1:
$eax = MOV32ri 1
- RETQ $eax
+ RET64 $eax
bb.4.lbl2:
$eax = MOV32ri 2
- RETQ $eax
+ RET64 $eax
bb.5.lbl3:
$eax = MOV32ri 4
- RETQ $eax
+ RET64 $eax
bb.6.lbl4:
$eax = MOV32ri 8
- RETQ $eax
+ RET64 $eax
...
bb.1.less:
; CHECK: $eax = MOV32r0
- ; CHECK-NEXT: RETQ killed $eax
+ ; CHECK-NEXT: RET64 killed $eax
$eax = MOV32r0 implicit-def $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
; CHECK: $eax = COPY killed $edi
- ; CHECK-NEXT: RETQ killed $eax
+ ; CHECK-NEXT: RET64 killed $eax
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
; CHECK: [[@LINE+1]]:36: expected a 32 bit integer (the cfi offset is too large)
CFI_INSTRUCTION def_cfa_offset 123456789123456
$rsp = ADD64ri32 $rsp, 4040, implicit-def dead $eflags
- RETQ
+ RET64
...
bb.0.entry:
; CHECK: [[@LINE+1]]:20: integer literal is too large to be an immediate operand
$eax = MOV32ri 12346127502983478823754212949184914
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2:
- RETQ $eax
+ RET64 $eax
...
$rax = MOV64rm $rip, 1, _, @G + 123456789123456789123456789, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:53: expected 64-bit integer (too large)
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load 12345678912345678924218574857 from %ir.a)
- RETQ $eax
+ RET64 $eax
...
; CHECK: PATCHPOINT 5, 5, 0, 2, 0, $rdi, $rsi, csr_64, liveout($esp, $rsp, $sp, $spl),
PATCHPOINT 5, 5, 0, 2, 0, $rdi, $rsi, csr_64, liveout($esp, $rsp, $sp, $spl), implicit-def dead early-clobber $r11, implicit-def $rsp, implicit-def dead $rax
$rbp = POP64r implicit-def $rsp, implicit $rsp
- RETQ
+ RET64
...
liveins: $rdi
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 0, $noreg :: (load (s32) from unknown-address, align 4294967296)
- RETQ $eax
+ RET64 $eax
...
---
liveins: $rdi
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 0, $noreg :: (load (s32) from unknown-address + 4, basealign 4294967296)
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2.exit:
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: bar
$eax = MOV32r0 implicit-def $eflags
bb.3:
- RETQ $eax
+ RET64 $eax
...
body: |
bb.0.entry:
; CHECK: MOV32rr
- ; CHECK-NEXT: RETQ
+ ; CHECK-NEXT: RET64
$eax = MOV32rr $eax
- RETQ $eax
+ RET64 $eax
...
; CHECK: instruction: COPY
; CHECK: 2 operands expected, but 0 given.
COPY
- RETQ
+ RET64
...
; CHECK-NEXT: MOV32mi killed $rdi, 1, $noreg, 0, $noreg, 42 :: (store (s32) into %ir.a)
$eax = MOV32rm $rdi, 1, _, 0, _ :: (load (s32) from %ir.a)
MOV32mi killed $rdi, 1, _, 0, _, 42 :: (store (s32) into %ir.a)
- RETQ $eax
+ RET64 $eax
...
---
name: test2
liveins: $rdi
; CHECK: INC32m killed $rdi, 1, $noreg, 0, $noreg, implicit-def dead $eflags :: (store (s32) into %ir."a value"), (load (s32) from %ir."a value")
INC32m killed $rdi, 1, _, 0, _, implicit-def dead $eflags :: (store (s32) into %ir."a value"), (load (s32) from %ir."a value")
- RETQ
+ RET64
...
---
name: test3
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load (s32) from %ir.0)
$eax = INC32r killed $eax, implicit-def dead $eflags
MOV32mr $rsp, 1, _, -4, _, killed $eax :: (store (s32) into %ir.1)
- RETQ
+ RET64
...
---
name: volatile_inc
$eax = MOV32rm $rdi, 1, _, 0, _ :: (volatile load (s32) from %ir.x)
$eax = INC32r killed $eax, implicit-def dead $eflags
MOV32mr killed $rdi, 1, _, 0, _, $eax :: (volatile store (s32) into %ir.x)
- RETQ $eax
+ RET64 $eax
...
---
name: non_temporal_store
; CHECK: name: non_temporal_store
; CHECK: MOVNTImr killed $rdi, 1, $noreg, 0, $noreg, killed $esi :: (non-temporal store (s32) into %ir.a)
MOVNTImr killed $rdi, 1, _, 0, _, killed $esi :: (non-temporal store (s32) into %ir.a)
- RETQ
+ RET64
...
---
name: invariant_load
; CHECK: name: invariant_load
; CHECK: $eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg :: (invariant load (s32) from %ir.x)
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (invariant load (s32) from %ir.x)
- RETQ $eax
+ RET64 $eax
...
---
name: memory_offset
$xmm1 = MOVSSrr killed $xmm1, killed $xmm2
MOVAPSmr $rdi, 1, _, 0, _, killed $xmm0 :: (store (s128) into %ir.vec)
MOVAPSmr killed $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16)
- RETQ
+ RET64
...
---
name: memory_alignment
MOVAPSmr $rdi, 1, _, 16, _, killed $xmm1 :: (store (s128) into %ir.vec + 16, basealign 64)
MOVAPSmr $rdi, 1, _, 32, _, killed $xmm2 :: (store (s128) into %ir.vec + 32, align 32, basealign 64)
MOVAPSmr killed $rdi, 1, _, 48, _, killed $xmm3 :: (store (s128) into %ir.vec + 48, basealign 64)
- RETQ
+ RET64
...
---
name: constant_pool_psv
; CHECK-NEXT: $xmm0 = ADDSDrm killed $xmm0, $rip, 1, $noreg, %const.0, $noreg, implicit $mxcsr :: (load (s64) from constant-pool + 8)
$xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _, implicit $mxcsr :: (load (s64) from constant-pool)
$xmm0 = ADDSDrm killed $xmm0, $rip, 1, _, %const.0, _, implicit $mxcsr :: (load (s64) from constant-pool + 8)
- RETQ $xmm0
+ RET64 $xmm0
...
---
name: stack_psv
ST_FP80m $rsp, 1, _, 0, _, implicit-def dead $fpsw, implicit $fpcw :: (store (s80) into stack, align 16)
CALL64pcrel32 &cosl, csr_64, implicit $rsp, implicit-def $rsp, implicit-def $fp0
$rsp = ADD64ri8 $rsp, 24, implicit-def dead $eflags
- RETQ
+ RET64
...
---
name: got_psv
$rax = MOV64rm $rip, 1, _, @G, _ :: (load (s64) from got)
$eax = MOV32rm killed $rax, 1, _, 0, _
$eax = INC32r killed $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
name: global_value
$rcx = MOV64rm $rip, 1, _, @0, _
$ecx = MOV32rm killed $rcx, 1, _, 0, _, implicit-def $rcx :: (load (s32) from @0)
$eax = LEA64_32r killed $rax, 1, killed $rcx, 1, _
- RETQ $eax
+ RET64 $eax
...
---
name: jumptable_psv
bb.2.def:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
bb.3.lbl1:
$eax = MOV32ri 1
- RETQ $eax
+ RET64 $eax
bb.4.lbl2:
$eax = MOV32ri 2
- RETQ $eax
+ RET64 $eax
bb.5.lbl3:
$eax = MOV32ri 4
- RETQ $eax
+ RET64 $eax
bb.6.lbl4:
$eax = MOV32ri 8
- RETQ $eax
+ RET64 $eax
...
---
name: tbaa_metadata
; CHECK-NEXT: $eax = MOV32rm killed $rax, 1, $noreg, 0, $noreg :: (load (s32) from %ir.total_len2, !tbaa !6)
$eax = MOV32rm killed $rax, 1, _, 0, _, implicit-def $rax :: (load (s32) from @a, !tbaa !2)
$eax = MOV32rm killed $rax, 1, _, 0, _ :: (load (s32) from %ir.total_len2, !tbaa !6)
- RETQ $eax
+ RET64 $eax
...
---
name: aa_scope
MOVSSmr $rdi, 1, _, 20, _, killed $xmm0 :: (store (s32) into %ir.arrayidx.i, !noalias !9)
$xmm0 = MOVSSrm_alt killed $rsi, 1, _, 0, _ :: (load (s32) from %ir.c)
MOVSSmr killed $rdi, 1, _, 28, _, killed $xmm0 :: (store (s32) into %ir.arrayidx)
- RETQ
+ RET64
...
---
name: range_metadata
; CHECK-LABEL: name: range_metadata
; CHECK: $al = MOV8rm killed $rdi, 1, $noreg, 0, $noreg :: (load (s8) from %ir.x, !range !11)
$al = MOV8rm killed $rdi, 1, _, 0, _ :: (load (s8) from %ir.x, !range !11)
- RETQ $al
+ RET64 $al
...
---
name: gep_value
; CHECK-LABEL: gep_value
; CHECK: MOV32mr killed $rax, 1, $noreg, 0, $noreg, $edi, implicit killed $rdi :: (store (s32) into `i32* getelementptr inbounds ([50 x %st], [50 x %st]* @values, i64 0, i64 0, i32 0)`, align 16)
MOV32mr killed $rax, 1, _, 0, _, $edi, implicit killed $rdi :: (store (s32) into `i32* getelementptr inbounds ([50 x %st], [50 x %st]* @values, i64 0, i64 0, i32 0)`, align 16)
- RETQ
+ RET64
...
---
name: undef_value
; CHECK-LABEL: name: undef_value
; CHECK: $rax = MOV64rm undef $rax, 1, $noreg, 0, $noreg :: (load (s64) from `i8** undef`)
$rax = MOV64rm undef $rax, 1, _, 0, _ :: (load (s64) from `i8** undef`)
- RETQ $rax
+ RET64 $rax
...
---
# Test memory operand without associated value.
body: |
bb.0:
$rax = MOV64rm undef $rax, 1, _, 0, _ :: (load (s64))
- RETQ $rax
+ RET64 $rax
...
---
# Test parsing of stack references in machine memory operands.
body: |
bb.0:
$rax = MOV64rm $rsp, 1, _, 0, _ :: (load (s64) from %stack.0)
- RETQ $rax
+ RET64 $rax
...
---
# Test parsing of unknown size in machine memory operands without alignment.
body: |
bb.0:
$rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0)
- RETQ $rax
+ RET64 $rax
...
---
# Test parsing of unknown size in machine memory operands with alignment.
body: |
bb.0:
$rax = MOV64rm $rsp, 1, _, 0, _ :: (load unknown-size from %stack.0, align 4)
- RETQ $rax
+ RET64 $rax
...
DBG_VALUE _, 0, !12, !DIExpression(), debug-location !13
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:48: end of machine instruction reached before the closing '"'
$rax = MOV64rm $rip, 1, _, @"quoted name, _
$eax = MOV32rm killed $rax, 1, _, 0, _
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:25: expected ',' before the next machine operand
$eax = XOR32rr $eax $eflags
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2.exit:
- RETQ $eax
+ RET64 $eax
...
body: |
bb.0.entry:
; CHECK: $eax = MOV32r0
- ; CHECK-NEXT: RETQ $eax
+ ; CHECK-NEXT: RET64 $eax
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
# CHECK: bb.1.less:
# CHECK-NEXT: $eax = MOV32r0 implicit-def dead $eflags
-# CHECK-NEXT: RETQ killed $eax
+# CHECK-NEXT: RET64 killed $eax
# CHECK: bb.2.exit:
# CHECK-NEXT: liveins: $edi
# CHECK: $eax = COPY killed $edi
-# CHECK-NEXT: RETQ killed $eax
+# CHECK-NEXT: RET64 killed $eax
body: |
bb.0.entry:
successors: %bb.1, %bb.2
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
---
# CHECK: bb.1.less:
# CHECK-NEXT: $eax = MOV32r0 implicit-def dead $eflags
-# CHECK-NEXT: RETQ killed $eax
+# CHECK-NEXT: RET64 killed $eax
# CHECK: bb.2.exit:
# CHECK-NEXT: liveins: $edi
# CHECK: $eax = COPY killed $edi
-# CHECK-NEXT: RETQ killed $eax
+# CHECK-NEXT: RET64 killed $eax
body: |
bb.0.entry:
CMP32ri8 $edi, 10, implicit-def $eflags
JCC_1 %bb.2, 15, implicit killed $eflags
bb.1.less: $eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit: liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
body: |
bb.0.entry:
; CHECK: $eax = MOV32rm $rdi, 1, $noreg, 0, $noreg
- ; CHECK-NEXT: RETQ $eax
+ ; CHECK-NEXT: RET64 $eax
$eax = MOV32rm $rdi, 1, _, 0, $noreg
- RETQ $eax
+ RET64 $eax
...
body: |
bb.0.body:
$eax = IMUL32rri8 $edi, 11, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
---
# CHECK: name: foo
PUSH64r $rax, implicit-def $rsp, implicit $rsp
CALL64pcrel32 @compute, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp, implicit-def $eax
$rdx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
$rax = MOV64rm target-flags(x86-got) $rip, 1, _, @G, _
$eax = MOV32rm killed $rax, 1, _, 0, _
$eax = INC32r killed $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
bb.0:
; CHECK: renamable $eax = IMUL32rri8 $edi, 11, implicit-def dead $eflags
renamable $eax = IMUL32rri8 $edi, 11, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
# CHECK: %0:gr32 = MOV32r0 implicit-def $eflags
# CHECK: dead %1:gr32 = COPY %0
# CHECK: MOV32mr undef $rcx, 1, $noreg, 0, $noreg, killed %0 :: (volatile store (s32))
-# CHECK: RETQ undef $eax
+# CHECK: RET64 undef $eax
name: func0
body: |
bb.0:
%0 : gr32 = MOV32r0 implicit-def $eflags
dead %1 : gr32 = COPY %0
MOV32mr undef $rcx, 1, _, 0, _, killed %0 :: (volatile store (s32))
- RETQ undef $eax
+ RET64 undef $eax
...
%2 = COPY $edi
%2 = IMUL32rr %2, %1, implicit-def dead $eflags
$eax = COPY %2
- RETQ killed $eax
+ RET64 killed $eax
...
bb.0.entry:
MOV32mr %rsp, 1, _, -4, _, %edi
%eax = COPY %edi
- RETQ %eax
+ RET64 %eax
...
bb.0.entry:
MOV32mr %rsp, 1, _, -4, _, %edi
%eax = COPY %edi
- RETQ %eax
+ RET64 %eax
...
bb.0.entry:
MOV32mr $rsp, 1, _, -4, _, $edi
$eax = COPY $edi
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
MOV32mr $rsp, 1, _, -4, _, $edi
$eax = MOV32rm $rsp, 1, _, -4, _
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[@LINE+1]]:13: the name of the stack object '%stack.0' isn't 'x'
MOV32mr %stack.0.x, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
; CHECK: MOV32mi %stack.1, 1, $noreg, 0, $noreg, 2
; CHECK: [[MOV32rm1:%[0-9]+]]:gr32 = MOV32rm %stack.0.b, 1, $noreg, 0, $noreg
; CHECK: $eax = COPY [[MOV32rm1]]
- ; CHECK: RETL $eax
+ ; CHECK: RET32 $eax
%0 = MOV32rm %fixed-stack.0, 1, _, 0, _
MOV32mr %stack.0.b, 1, _, 0, _, %0
MOV32mi %stack.1, 1, _, 0, _, 2
%1 = MOV32rm %stack.0, 1, _, 0, _
$eax = COPY %1
- RETL $eax
+ RET32 $eax
...
MOV32mr $rsp, 1, _, -4, _, killed $edi
MOV64mi32 $rsp, 1, _, -16, _, 2
$eax = MOV32rm $rsp, 1, _, -4, _
- RETQ $eax
+ RET64 $eax
...
MOV32mr $rsp, 1, _, -4, _, $edi
MOV64mi32 $rsp, 1, _, -16, _, 2
$eax = MOV32rm $rsp, 1, _, -4, _
- RETQ $eax
+ RET64 $eax
...
%0 = COPY $edi
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
; CHECK: [[INSERT_SUBREG:%[0-9]+]]:gr32 = INSERT_SUBREG $edi, $al, %subreg.sub_8bit
; CHECK: [[EXTRACT_SUBREG:%[0-9]+]]:gr8 = EXTRACT_SUBREG $eax, %subreg.sub_8bit_hi
; CHECK: $ax = REG_SEQUENCE [[EXTRACT_SUBREG]], %subreg.sub_8bit, [[EXTRACT_SUBREG]], %subreg.sub_8bit_hi
- ; CHECK: RETQ $ax
+ ; CHECK: RET64 $ax
%0 = INSERT_SUBREG $edi, $al, %subreg.sub_8bit
%1 = EXTRACT_SUBREG $eax, %subreg.sub_8bit_hi
$ax = REG_SEQUENCE %1, %subreg.sub_8bit, %1, %subreg.sub_8bit_hi
- RETQ $ax
+ RET64 $ax
...
; CHECK: [[COPY1:%[0-9]+]]:gr8 = COPY [[COPY]].sub_8bit
; CHECK: [[AND8ri:%[0-9]+]]:gr8 = AND8ri [[COPY1]], 1, implicit-def $eflags
; CHECK: $al = COPY [[AND8ri]]
- ; CHECK: RETQ $al
+ ; CHECK: RET64 $al
%0 = COPY $edi
%1 = COPY %0.sub_8bit
%2 = AND8ri %1, 1, implicit-def $eflags
$al = COPY %2
- RETQ $al
+ RET64 $al
...
bb.1.less:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
bb.1.less:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2.exit:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
---
name: bar
bb.1:
successors:
$eax = MOV32r0 implicit-def dead $eflags
- RETQ killed $eax
+ RET64 killed $eax
bb.2:
liveins: $edi
$eax = COPY killed $edi
- RETQ killed $eax
+ RET64 killed $eax
...
; CHECK: [[@LINE+1]]:58: use of invalid tied-def operand index '0'; the operand #0 isn't a defined register
INLINEASM &"$foo", 1, 2818058, def $rdi, 2147483657, killed $rdi(tied-def 0)
$rax = COPY killed $rdi
- RETQ killed $rax
+ RET64 killed $rax
...
; CHECK: Tied physical registers must match.
$rbx = AND64rm killed $rdx, killed $rdi, 1, _, 0, _, implicit-def dead $eflags
- RETQ $rbx
+ RET64 $rbx
...
body: |
bb.0.body:
$eax = IMUL32rri8 $edi, 11, implicit-def $eflags
- RETQ $eax
+ RET64 $eax
...
---
name: foo
PUSH64r undef $rax, implicit-def $rsp, implicit $rsp
CALL64pcrel32 @compute, csr_64, implicit $rsp, implicit $edi, implicit-def $rsp, implicit-def $eax
$rdx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
MOV32mi %stack.1, 1, _, 0, _, 2
%1 = MOV32rm %stack.0, 1, _, 0, _
$eax = COPY %1
- RETL $eax
+ RET32 $eax
...
$rax = MOV64rm $rip, 1, _, @2, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax
- RETQ $eax
+ RET64 $eax
...
JMP64m $rip, 1, _, @addr, _
bb.1.block (address-taken):
- RETQ
+ RET64
...
JMP64m $rip, 1, _, @addr, _
bb.1 (address-taken):
- RETQ
+ RET64
...
bb.2.def:
$eax = MOV32r0 implicit-def $eflags
- RETQ $eax
+ RET64 $eax
bb.3.lbl1:
$eax = MOV32ri 1
- RETQ $eax
+ RET64 $eax
bb.4.lbl2:
$eax = MOV32ri 2
- RETQ $eax
+ RET64 $eax
bb.5.lbl3:
$eax = MOV32ri 4
- RETQ $eax
+ RET64 $eax
bb.6.lbl4:
$eax = MOV32ri 8
- RETQ $eax
+ RET64 $eax
...
$rax = MOV64rm $rip, 1, _, @GG, _
$eax = MOV32rm $rax, 1, _, 0, _
$eax = INC32r $eax
- RETQ $eax
+ RET64 $eax
...
- {id: 0, class: 'gr3200'}
body: |
bb.0.entry:
- RETQ %eax
+ RET64 %eax
...
; CHECK: [[@LINE+1]]:13: use of undefined stack object '%stack.2'
MOV32mr %stack.2, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi
; CHECK: [[@LINE+1]]:64: use of undefined IR value '%ir.c'
$eax = MOV32rm killed $rdi, 1, _, 0, _ :: (load (s32) from %ir.c)
- RETQ $eax
+ RET64 $eax
...
%0 = COPY $edi
; CHECK: Cannot determine class/bank of virtual register 1 in function 'test'
$eax = COPY %1
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2:
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32rm $rdi, 1, _, 0, _ :: (load (s32) from %ir.x, !tba !0)
$eax = INC32r killed $eax, implicit-def dead $eflags
MOV32mr killed $rdi, 1, _, 0, _, $eax :: (store (s32) into %ir.x)
- RETQ $eax
+ RET64 $eax
...
DBG_VALUE _, 0, !42, !13
MOV32mr %stack.0.x.addr, 1, _, 0, _, %0
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
$eax = MOV32r0 implicit-def $eflags
bb.2.exit:
- RETQ $eax
+ RET64 $eax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:5: unknown register name 'xax'
$xax = MOV32r0
- RETQ $xax
+ RET64 $xax
...
bb.0.entry:
; CHECK: [[@LINE+1]]:35: unknown subregister index 'bit8'
%0 = INSERT_SUBREG $edi, $al, %subreg.bit8
- RETQ %0
+ RET64 %0
...
%1 = COPY %0.bit8
%2 = AND8ri %1, 1, implicit-def $eflags
$al = COPY %2
- RETQ $al
+ RET64 $al
...
body: |
bb.0.entry:
; CHECK: [[@LINE+1]]:5: unexpected character '\'
- \ RETQ
+ \ RET64
...
MOV32mr %rsp, 1, _, -4, _, %edi
MOV64mi32 %rsp, 1, _, -16, _, 2
%eax = MOV32rm %rsp, 1, _, -4, _
- RETQ %eax
+ RET64 %eax
...
MOV32mr $rsp, 1, _, -4, _, $edi
MOV64mi32 $rsp, 1, _, -16, _, 2
$eax = MOV32rm $rsp, 1, _, -4, _
- RETQ $eax
+ RET64 $eax
...
%0 = COPY %edi
%eax = COPY %0
- RETQ %eax
+ RET64 %eax
...
; CHECK-NEXT: $eax = COPY %2
%2 = MOV32r0 implicit-def $eflags
$eax = COPY %2
- RETQ $eax
+ RET64 $eax
bb.2.exit:
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
---
name: foo
; CHECK-NEXT: $eax = COPY %2
%10 = MOV32r0 implicit-def $eflags
$eax = COPY %10
- RETQ $eax
+ RET64 $eax
bb.2.exit:
; CHECK: $eax = COPY %0
$eax = COPY %2
- RETQ $eax
+ RET64 $eax
...
renamable $eax = MOV32rm $rbp, 1, $noreg, -8, $noreg :: (load (s32) from %ir.2)
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp
CFI_INSTRUCTION def_cfa $rsp, 8
- RETQ implicit $eax
+ RET64 implicit $eax
...
liveins: $rdi, $eax
$rcx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
bb.2.null:
liveins: $rdi
; CHECK: $cl = IMPLICIT_DEF
; CHECK: renamable $eax = COPY renamable $edx
; CHECK: dead renamable $eax = SHRD32rrCL renamable $eax, killed renamable $edx, implicit-def dead $eflags, implicit killed $cl
- ; CHECK: RETL
+ ; CHECK: RET32
%0:gr32 = IMPLICIT_DEF
%1:gr32 = MOVZX32rm8 %0, 1, $noreg, 0, $noreg :: (load (s8) from `i168* undef` + 20, align 4, basealign 16)
%2:gr32 = MOV32rm %0, 1, $noreg, 0, $noreg :: (load (s32) from `i168* undef` + 12, basealign 16)
$cl = IMPLICIT_DEF
%8:gr32 = COPY %1
%8:gr32 = SHRD32rrCL %8, %1, implicit-def dead $eflags, implicit $cl
- RETL
+ RET32
...
bb.3.for.cond.cleanup:
liveins: $rdi, $xmm3, $xmm4, $xmm5, $xmm6, $xmm7, $xmm9, $xmm13, $xmm14
- RETQ
+ RET64
bb.4.for.body:
successors: %bb.1, %bb.5
bb.2:
$ax = COPY %1
$dx = COPY %2
- RETQ killed $ax, killed $dx
+ RET64 killed $ax, killed $dx
...
# This test case was created as a reproducer for a bug when we got incorrect
; CHECK: $ymm0 = VPERM2I128rr $ymm0, $ymm1, 32
$ymm0 = VSHUFI64X2Z256rri $ymm0, $ymm1, 228
- RETQ
+ RET64
...
---
# CHECK-LABEL: name: evex_z128_to_vex_test
; CHECK: $xmm0 = VROUNDPSr $xmm0, 15, implicit $mxcsr
$xmm0 = VRNDSCALEPSZ128rri $xmm0, 15, implicit $mxcsr
- RETQ
+ RET64
...
---
# CHECK-LABEL: name: evex_scalar_to_vex_test
; CHECK: $xmm0 = VROUNDSSr_Int $xmm0, $xmm1, 15, implicit $mxcsr
$xmm0 = VRNDSCALESSZr_Int $xmm0, $xmm1, 15, implicit $mxcsr
- RETQ
+ RET64
...
---
# CHECK-LABEL: name: evex_z256_to_evex_test
; CHECK: $ymm16 = VSHUFI64X2Z256rri $ymm16, $ymm1, 228
$ymm16 = VSHUFI64X2Z256rri $ymm16, $ymm1, 228
- RETQ
+ RET64
...
---
# CHECK-LABEL: name: evex_z128_to_evex_test
; CHECK: $xmm0 = VRNDSCALEPSZ128rri $xmm0, 31, implicit $mxcsr
$xmm0 = VRNDSCALEPSZ128rri $xmm0, 31, implicit $mxcsr
- RETQ
+ RET64
...
---
# CHECK-LABEL: name: evex_scalar_to_evex_test
; CHECK: $xmm0 = VRNDSCALESSZr_Int $xmm0, $xmm1, 31, implicit $mxcsr
$xmm0 = VRNDSCALESSZr_Int $xmm0, $xmm1, 31, implicit $mxcsr
- RETQ
+ RET64
...
# CHECK-NEXT: $rdi = MOV64rr $rax
# CHECK-NEXT: CALL64pcrel32 @objc_retainAutoreleasedReturnValue, csr_64, implicit $rsp, implicit $ssp, implicit-def $rax
# CHECK-NEXT: $rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
#
name: test_objc_retainAutoreleaseReturnedValue
# CHECK-NEXT: $rdi = MOV64rr $rax
# CHECK-NEXT: CALL64pcrel32 @objc_unsafeClaimAutoreleasedReturnValue, csr_64, implicit $rsp, implicit $ssp, implicit-def $rax
# CHECK-NEXT: $rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
#
name: test_objc_unsafeClaimAutoreleasedReturnValue
alignment: 16
# CHECK-NEXT: $rdi = MOV64rr $rax
# CHECK-NEXT: CALL64pcrel32 @objc_retainAutoreleasedReturnValue, csr_64, implicit $rsp, implicit $ssp, implicit-def dead $rax
# CHECK-NEXT: $rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
#
name: test_objc_unsafeClaimAutoreleasedReturnValue_2_args
alignment: 16
# CHECK-NEXT: $rdi = MOV64rr $rax
# CHECK-NEXT: CALL64pcrel32 @objc_retainAutoreleasedReturnValue, csr_64, implicit $rsp, implicit $ssp, implicit-def dead $rax
# CHECK-NEXT: $rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
#
name: test_ret_void
alignment: 16
MMX_MOVQ64mr $rsp, 1, $noreg, -16, $noreg, killed $mm0
$xmm0 = MOVQI2PQIrm $rsp, 1, $noreg, -16, $noreg
$xmm0 = PSHUFDri killed $xmm0, -44
- RETQ $xmm0
+ RET64 $xmm0
...
; CHECK: $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !45
; CHECK: $rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !45
; CHECK: CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !45
- ; CHECK: RETQ implicit killed $eax, debug-location !45
+ ; CHECK: RET64 implicit killed $eax, debug-location !45
bb.0.entry:
liveins: $edi
%7:gr64_nosp = IMPLICIT_DEF
%8:gr32 = MOV32rm %3, 4, %7, 0, $noreg, debug-location !44 :: (load (s32) from %ir.arrayidx3)
$eax = COPY %8, debug-location !45
- RETQ implicit $eax, debug-location !45
+ RET64 implicit $eax, debug-location !45
...
; CHECK: $eax = MOV32rr undef $edi, implicit $dil
$al = MOV8rr killed $dil
- RETQ killed $al
+ RET64 killed $al
...
; CHECK: $eax = MOV32rr undef $edi, implicit $dil
$al = MOV8rr $dil, implicit $edi
- RETQ killed $al
+ RET64 killed $al
...
; CHECK: $eax = MOV32rr undef $edi, implicit $dil, implicit-def $rax
$al = MOV8rr $dil, implicit-def $rax
- RETQ killed $al
+ RET64 killed $al
...
; CHECK: $eax = MOV32rr undef $edi, implicit $dil
$al = MOV8rr $dil, implicit-def $eax
- RETQ killed $al
+ RET64 killed $al
...
; CHECK: $eax = MOV32rr undef $edi, implicit $dil
$al = MOV8rr $dil, implicit-def $ax
- RETQ killed $al
+ RET64 killed $al
...
; CHECK: $eax = MOV32rr undef $edi, implicit $di
$ax = MOV16rr $di, implicit-def $eax
- RETQ killed $ax
+ RET64 killed $ax
...
; CHECK: $eax = MOV32rr undef $edi, implicit $di, implicit-def $rax
$ax = MOV16rr $di, implicit-def $rax
- RETQ killed $ax
+ RET64 killed $ax
...
$ax = MOV16rm killed $rax, 1, $noreg, 0, $noreg
; CHECK: $eax = MOVZX32rm16 killed $rax
- RETQ $ax
+ RET64 $ax
...
---
bb.1:
liveins: $rcx
- RETQ $cl
+ RET64 $cl
...
---
$ax = MOV16rm killed $rdi, 1, $noreg, 0, $noreg, implicit-def $eax :: (load (s16) from %ir.p)
; CHECK: $eax = MOVZX32rm16 killed $rdi, 1, $noreg, 0, $noreg, implicit-def $eax :: (load (s16) from %ir.p)
$ax = KILL $ax, implicit killed $eax
- RETQ $ax
+ RET64 $ax
bb.1:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
$ax = KILL $ax, implicit killed $eax
- RETQ $ax
+ RET64 $ax
...
---
; CHECK: $r9b = MOV8rr undef $r10b, implicit-def $r9d, implicit killed $r9d, implicit-def $eflags
$ax = OR16rr undef $ax, $r9w, implicit-def $eflags
- RETQ $ax
+ RET64 $ax
...
---
$cl = MOV8rr $bl, implicit-def $cx, implicit killed $ch, implicit-def $eflags
; CHECK: $cl = MOV8rr $bl, implicit-def $cx, implicit killed $ch, implicit-def $eflags
- RETQ $cx
+ RET64 $cx
...
bb.2.ret_200:
$eax = MOV32ri 200
- RETQ $eax
+ RET64 $eax
bb.3.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
bb.4.ret_100:
$eax = MOV32ri 100
- RETQ $eax
+ RET64 $eax
...
---
bb.3.is_null:
liveins: $eax, $ah, $al, $ax, $bh, $bl, $bp, $bpl, $bx, $eax, $ebp, $ebx, $rax, $rbp, $rbx, $r12, $r13, $r14, $r15, $r12b, $r13b, $r14b, $r15b, $r12d, $r13d, $r14d, $r15d, $r12w, $r13w, $r14w, $r15w
- RETQ $eax
+ RET64 $eax
bb.4.ret_100:
$eax = MOV32ri 100
- RETQ $eax
+ RET64 $eax
...
---
bb.2.ret_200:
$eax = MOV32ri 200
- RETQ $eax
+ RET64 $eax
bb.3.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
bb.4.ret_100:
$eax = MOV32ri 100
- RETQ $eax
+ RET64 $eax
...
---
bb.2.ret_200:
$eax = MOV32ri 200
- RETQ $eax
+ RET64 $eax
bb.3.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
bb.4.ret_100:
$eax = MOV32ri 100
- RETQ $eax
+ RET64 $eax
...
---
bb.2.ret_200:
$eax = MOV32ri 200
- RETQ $eax
+ RET64 $eax
bb.3.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
bb.4.ret_100:
$eax = MOV32ri 100
- RETQ $eax
+ RET64 $eax
...
---
CALL64pcrel32 @f, csr_64, implicit $rsp, implicit-def $rsp
$eax = MOV32rm killed $rbx, 1, $noreg, 0, $noreg :: (load (s32) from %ir.ptr)
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
bb.2.leave:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
---
$esi = MOV32ri 3076
$eax = BEXTR32rm killed $rdi, 1, $noreg, 0, $noreg, killed $esi, implicit-def dead $eflags :: (load (s32) from %ir.ptr)
$eax = ADD32rm killed $eax, killed $rcx, 1, $noreg, 0, $noreg, implicit-def dead $eflags :: (load (s32) from %ir.val)
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
$rcx = MOV64rm killed $rsi, 1, $noreg, 0, $noreg
$rcx = AND64rm killed $rcx, $rdi, 1, $noreg, 0, $noreg, implicit-def dead $eflags
$rax = MOV64rm killed $rdi, 1, $noreg, 0, $noreg
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
$rsi = ADD64rr $rsi, $rdi, implicit-def dead $eflags
$eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg, implicit-def $rax :: (load (s32) from %ir.x)
$eax = LEA64_32r killed $rax, 1, killed $rsi, 4, $noreg
- RETQ $eax
+ RET64 $eax
bb.1.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
...
---
$rsi = ADD64rr $rsi, $rdi, implicit-def dead $eflags
$esi = AND32rm killed $esi, $rdi, 1, $noreg, 0, $noreg, implicit-def dead $eflags
$eax = MOV32rr $esi
- RETQ $eax
+ RET64 $eax
bb.1.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
...
---
liveins: $rdi, $rsi
MOV64mr killed $rdi, 1, $noreg, 0, $noreg, killed $rsi
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
liveins: $rdi, $rsi
MOV64mr killed $rdi, 1, $noreg, 16, $noreg, killed $rsi
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$esi = ADD32rr killed $esi, killed $esi, implicit-def dead $eflags
MOV32mr killed $rdi, 1, $noreg, 16, $noreg, killed $esi
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$esi = ADD32rr $esi, $esi, implicit-def dead $eflags
MOV32mr killed $rdi, 1, $noreg, 0, $noreg, $esi
$eax = MOV32rr killed $esi
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
liveins: $rsi
$eax = MOV32rr killed $esi
- RETQ $eax
+ RET64 $eax
...
---
liveins: $rdi, $rsi
MOV32mr killed $rdi, 1, $noreg, 0, $noreg, killed $esi :: (volatile store (s32) into %ir.ptr)
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$esi = ADD32rr killed $esi, killed $esi, implicit-def dead $eflags
$esi = ADD32ri killed $esi, 15, implicit-def dead $eflags
MOV32mr killed $rdi, 1, $noreg, 16, $noreg, killed $esi
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$rdi = ADD64rr killed $rdi, killed $rdi, implicit-def dead $eflags
MOV32mr killed $rdi, 1, $noreg, 16, $noreg, killed $esi
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$rax = MOV64rr $rdi
MOV32mr killed $rdi, 1, $noreg, 16, $noreg, killed $esi
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$rax = XOR64rr undef $rax, undef $rax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
MOV32mi $rbx, 1, $noreg, 0, $noreg, 20
$rax = MOV64rr killed $rbx
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
$rbx = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
...
---
$eax = MOV32rr $esi
$esi = ADD32ri killed $esi, 15, implicit-def dead $eflags
MOV32mr killed $rdi, 1, $noreg, 0, $noreg, killed $esi
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
MOV32mi killed $rsi, 1, $noreg, 0, $noreg, 2
$eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
$eax = MOV32rm killed $rsi, 1, $noreg, 0, $noreg
MOV32mi killed $rdi, 1, $noreg, 0, $noreg, 2
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
MOV32mi killed $rsi, 1, $noreg, 0, $noreg, 3
MOV32mi killed $rdi, 1, $noreg, 0, $noreg, 2
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
$esi = ADD32rr $esi, $esi, implicit-def dead $eflags
ADD32mr killed $rdi, 1, $noreg, 0, $noreg, killed $esi, implicit-def dead $eflags
- RETQ
+ RET64
bb.2.is_null:
- RETQ
+ RET64
...
---
MOV32mi killed $rsi, 1, $noreg, 0, $noreg, 3 :: (store (s32) into %ir.ptr2)
$eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg :: (load (s32) from %ir.ptr)
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
MOV32mi killed $rsi, 1, $noreg, 0, $noreg, 3 :: (store (s32) into %ir.ptr2)
$eax = MOV32rm killed $rdi, 1, $noreg, 0, $noreg :: (load (s32) from %ir.ptr)
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
MOV64mr $rsp, 1, $noreg, 0, $noreg, $rdi :: (store (s64) into %stack.0)
$edi = MOV32rm $rdi, 1, $noreg, 8, $noreg :: (load (s32) from %ir.ptr)
$eax = MOV32rr $edi
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
$rcx = MOV64ri -9223372036854775808
$eax = MOV32rm killed $rdi, 2, $rcx, 0, $noreg, implicit-def $rax
- RETQ $eax
+ RET64 $eax
bb.1.is_null:
$eax = MOV32ri 42
- RETQ $eax
+ RET64 $eax
...
liveins: $rdi, $rsi
$rax = MOV64rm renamable $rdi, 1, $noreg, 4, $noreg
- RETQ $eax
+ RET64 $eax
bb.2.is_null:
$eax = MOV32ri 200
- RETQ $eax
+ RET64 $eax
...
%7:gr64 = ADD64rr killed %4, killed %5, implicit-def $eflags
%8:gr64 = ADD64rr killed %6, killed %7, implicit-def $eflags
$rax = COPY %8
- RETQ implicit $rax
+ RET64 implicit $rax
...
bb.3:
$eax = COPY %0
- RETQ $eax
+ RET64 $eax
...
; CHECK: liveins: $eax, $ebp
; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags
; CHECK: $eax = ADD32ri8 $eax, -5, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$eax = LEA32r killed $eax, 1, killed $ebp, -5, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: liveins: $eax, $ebp
; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags
; CHECK: $ebp = ADD32ri8 $ebp, -5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA32r killed $ebp, 1, killed $eax, -5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK-LABEL: name: test1add_ebp_32
; CHECK: liveins: $eax, $ebp
; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA32r killed $ebp, 1, killed $eax, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: liveins: $eax, $ebp, $esi
; CHECK: $ebx = LEA32r killed $eax, 1, killed $ebp, 0, $noreg
; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r killed $eax, 1, killed $ebp, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $eax, $ebp
; CHECK: $ebx = LEA32r killed $eax, 1, killed $ebp, 0, $noreg
; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r killed $ebp, 1, killed $eax, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: test1lea_ebp_32
; CHECK: liveins: $eax, $ebp
; CHECK: $ebx = LEA32r killed $eax, 1, killed $ebp, 0, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r killed $ebp, 1, killed $eax, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $eax, $ebp
; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags
; CHECK: $eax = ADD32ri $eax, 129, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$eax = LEA32r killed $eax, 1, killed $ebp, 129, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebx = MOV32rr $ebp
; CHECK: $ebx = ADD32rr $ebx, $ebp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r killed $ebp, 1, $ebp, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebx = LEA32r $noreg, 1, $ebp, 5, $noreg
; CHECK: $ebx = ADD32rr $ebx, $ebp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r $ebp, 1, $ebp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebx = LEA32r $noreg, 4, $ebp, 5, $noreg
; CHECK: $ebx = ADD32rr $ebx, $ebp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA32r $ebp, 4, $ebp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: test_skip_opt_32
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebp = LEA32r killed $ebp, 4, killed $ebp, 0, $noreg
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA32r killed $ebp, 4, killed $ebp, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: CMP32rr $eax, killed $ebx, implicit-def $eflags
; CHECK: $ebx = LEA32r killed $eax, 4, killed $eax, 5, $noreg
; CHECK: JCC_1 %bb.1, 4, implicit $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
; CHECK: bb.1:
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebp = LEA32r killed $ebx, 4, killed $ebx, 0, $noreg
; CHECK: $ebp = ADD32ri8 $ebp, 5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
bb.0 (%ir-block.0):
liveins: $eax, $ebp, $ebx
CMP32rr $eax, killed $ebx, implicit-def $eflags
$ebx = LEA32r killed $eax, 4, killed $eax, 5, $noreg
JCC_1 %bb.1, 4, implicit $eflags
- RETQ $ebx
+ RET64 $ebx
bb.1:
liveins: $eax, $ebp, $ebx
$ebp = LEA32r killed $ebx, 4, killed $ebx, 5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
; CHECK: liveins: $rax, $rbp
; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags, implicit $rax, implicit $rbp
; CHECK: $eax = ADD32ri8 $eax, -5, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$eax = LEA64_32r killed $rax, 1, killed $rbp, -5, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags, implicit $rbp, implicit $rax
; CHECK: $ebp = ADD32ri8 $ebp, -5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA64_32r killed $rbp, 1, killed $rax, -5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK-LABEL: name: test1lea_rbp_64_32_1
; CHECK: liveins: $rax, $rbp
; CHECK: $ebp = ADD32rr $ebp, $eax, implicit-def $eflags, implicit $rbp, implicit $rax
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA64_32r killed $rbp, 1, killed $rax, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $rax = ADD64rr $rax, $rbp, implicit-def $eflags
; CHECK: $rax = ADD64ri8 $rax, -5, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$rax = LEA64r killed $rax, 1, killed $rbp, -5, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $rbp = ADD64rr $rbp, $rax, implicit-def $eflags
; CHECK: $rbp = ADD64ri8 $rbp, -5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$rbp = LEA64r killed $rbp, 1, killed $rax, -5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK-LABEL: name: test1add_rbp_64
; CHECK: liveins: $rax, $rbp
; CHECK: $rbp = ADD64rr $rbp, $rax, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$rbp = LEA64r killed $rbp, 1, killed $rax, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $ebx = LEA64_32r killed $rax, 1, killed $rbp, 0, $noreg
; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rax, 1, killed $rbp, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $ebx = LEA64_32r killed $rax, 1, killed $rbp, 0, $noreg
; CHECK: $ebx = ADD32ri8 $ebx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rbp, 1, killed $rax, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: test1lea_rbp_64_32
; CHECK: liveins: $rax, $rbp
; CHECK: $ebx = LEA64_32r killed $rax, 1, killed $rbp, 0, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rbp, 1, killed $rax, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $rbx = LEA64r killed $rax, 1, killed $rbp, 0, $noreg
; CHECK: $rbx = ADD64ri8 $rbx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r killed $rax, 1, killed $rbp, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $rbx = LEA64r killed $rax, 1, killed $rbp, 0, $noreg
; CHECK: $rbx = ADD64ri8 $rbx, -5, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r killed $rbp, 1, killed $rax, -5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: test1lea_rbp_64
; CHECK: liveins: $rax, $rbp
; CHECK: $rbx = LEA64r killed $rax, 1, killed $rbp, 0, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r killed $rbp, 1, killed $rax, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: $r13 = KILL $rdi, implicit-def $r13
; CHECK: $r12 = LEA64r $noreg, 2, killed $r13, 5, $noreg
; CHECK: $r12 = ADD64rr $r12, killed $rbp, implicit-def $eflags
- ; CHECK: RETQ $r12
+ ; CHECK: RET64 $r12
$rbp = KILL $rbp, implicit-def $rbp
$r13 = KILL $rdi, implicit-def $r13
$r12 = LEA64r killed $rbp, 2, killed $r13, 5, $noreg
- RETQ $r12
+ RET64 $r12
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $eax = ADD32rr $eax, $ebp, implicit-def $eflags, implicit $rax, implicit $rbp
; CHECK: $eax = ADD32ri $eax, 129, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$eax = LEA64_32r killed $rax, 1, killed $rbp, 129, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK-LABEL: name: test1mov1add_rbp_64_32
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $ebx = LEA64_32r killed $rbp, 1, killed $rbp, 0, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rbp, 1, killed $rbp, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: testleaadd_rbp_index_64_32
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $ebx = LEA64_32r killed $rbp, 1, killed $rbp, 5, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rbp, 1, killed $rbp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: testleaadd_rbp_index2_64_32
; CHECK: liveins: $eax, $ebp, $ebx
; CHECK: $ebx = LEA64_32r killed $rbp, 4, killed $rbp, 5, $noreg
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$ebx = LEA64_32r killed $rbp, 4, killed $rbp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp
; CHECK: $rax = ADD64rr $rax, $rbp, implicit-def $eflags
; CHECK: $rax = ADD64ri32 $rax, 129, implicit-def $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
$rax = LEA64r killed $rax, 1, killed $rbp, 129, $noreg
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $rbx = MOV64rr $rbp
; CHECK: $rbx = ADD64rr $rbx, $rbp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r killed $rbp, 1, $rbp, 0, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $rbx = LEA64r $noreg, 1, $rbp, 5, $noreg
; CHECK: $rbx = ADD64rr $rbx, $rbp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r $rbp, 1, $rbp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $rbx = LEA64r $noreg, 4, $rbp, 5, $noreg
; CHECK: $rbx = ADD64rr $rbx, $rbp, implicit-def $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
$rbx = LEA64r $rbp, 4, $rbp, 5, $noreg
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK-LABEL: name: test_skip_opt_64
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $rbp = LEA64r killed $rbp, 4, killed $rbp, 0, $noreg
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$rbp = LEA64r killed $rbp, 4, killed $rbp, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: CMP64rr $rax, killed $rbx, implicit-def $eflags
; CHECK: $rbx = LEA64r killed $rax, 4, killed $rax, 5, $noreg
; CHECK: JCC_1 %bb.1, 4, implicit $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
; CHECK: bb.1:
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $rbp = LEA64r killed $rbx, 4, killed $rbx, 0, $noreg
; CHECK: $rbp = ADD64ri8 $rbp, 5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
bb.0 (%ir-block.0):
liveins: $rax, $rbp, $rbx
CMP64rr $rax, killed $rbx, implicit-def $eflags
$rbx = LEA64r killed $rax, 4, killed $rax, 5, $noreg
JCC_1 %bb.1, 4, implicit $eflags
- RETQ $ebx
+ RET64 $ebx
bb.1:
liveins: $rax, $rbp, $rbx
$rbp = LEA64r killed $rbx, 4, killed $rbx, 5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK-LABEL: name: test_skip_opt_64_32
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $ebp = LEA64_32r killed $rbp, 4, killed $rbp, 0, $noreg
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
$ebp = LEA64_32r killed $rbp, 4, killed $rbp, 0, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: CMP64rr $rax, killed $rbx, implicit-def $eflags
; CHECK: $ebx = LEA64_32r killed $rax, 4, killed $rax, 5, $noreg
; CHECK: JCC_1 %bb.1, 4, implicit $eflags
- ; CHECK: RETQ $ebx
+ ; CHECK: RET64 $ebx
; CHECK: bb.1:
; CHECK: liveins: $rax, $rbp, $rbx
; CHECK: $ebp = LEA64_32r killed $rbx, 4, killed $rbx, 0, $noreg
; CHECK: $ebp = ADD32ri8 $ebp, 5, implicit-def $eflags
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
bb.0 (%ir-block.0):
liveins: $rax, $rbp, $rbx
CMP64rr $rax, killed $rbx, implicit-def $eflags
$ebx = LEA64_32r killed $rax, 4, killed $rax, 5, $noreg
JCC_1 %bb.1, 4, implicit $eflags
- RETQ $ebx
+ RET64 $ebx
bb.1:
liveins: $rax, $rbp, $rbx
$ebp = LEA64_32r killed $rbx, 4, killed $rbx, 5, $noreg
- RETQ $ebp
+ RET64 $ebp
...
---
; CHECK: NOOP
; CHECK: NOOP
; CHECK: NOOP
- ; CHECK: RETQ $ebp
+ ; CHECK: RET64 $ebp
DBG_VALUE 0, $noreg
NOOP
NOOP
NOOP
NOOP
NOOP
- RETQ $ebp
+ RET64 $ebp
...
...
# CHECK-NEXT: $rax = MOV64ri 31
# CHECK-NEXT: DBG_VALUE $rax
# CHECK-NEXT: DBG_VALUE_LIST 0, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_constu, 4, DW_OP_mul, DW_OP_plus, DW_OP_stack_value), $rax, 0, 0
-# CHECK-NEXT: RETQ implicit killed $rax
+# CHECK-NEXT: RET64 implicit killed $rax
name: foo
body: |
bb.0:
DBG_VALUE $rcx, 0, 0, 0, 0
DBG_VALUE_LIST 0, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_constu, 4, DW_OP_mul, DW_OP_plus, DW_OP_stack_value), $rcx, 0, 0
$rax = COPY killed renamable $rcx
- RETQ implicit killed $rax
+ RET64 implicit killed $rax
...
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
...
---
name: bar
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
...
---
name: baz
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
...
---
name: bar
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
...
---
name: baz
$edx = MOV32ri 2
$edi = MOV32ri 3
$eax = MOV32ri 4
- RETQ
+ RET64
; CHECK-NEXT: JMP_1 %bb.3
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
- ; CHECK-NEXT: RETQ
+ ; CHECK-NEXT: RET64
bb.0:
%0:gr32 = COPY $eax
CMP32ri %0, 20, implicit-def $eflags
JMP_1 %bb.3
bb.3:
- RETQ
+ RET64
...
---
name: opt_adjusted_imm_multiple_blocks_noopt
; CHECK-NEXT: $al = SETCCr 4, implicit $eflags
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.3:
- ; CHECK-NEXT: RETQ
+ ; CHECK-NEXT: RET64
bb.0:
%0:gr32 = COPY $eax
CMP32ri %0, 20, implicit-def $eflags
$al = SETCCr 4, implicit $eflags
bb.3:
- RETQ
+ RET64
...
; CHECK: PATCHPOINT 5, 5, 0, 2, 0, $rdi, $rsi, csr_64, implicit-def dead early-clobber $r11, implicit-def $rsp, implicit-def dead $rax
PATCHPOINT 5, 5, 0, 2, 0, $rdi, $rsi, csr_64, implicit-def dead early-clobber $r11, implicit-def $rsp, implicit-def dead $rax
$rbp = POP64r implicit-def $rsp, implicit $rsp
- RETQ
+ RET64
...
; CHECK-NEXT: JMP_1 %bb.2
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.5:
- ; CHECK-NEXT: RETQ
+ ; CHECK-NEXT: RET64
; CHECK-NEXT: {{ $}}
; CHECK-NEXT: bb.6:
bb.0:
JMP_1 %bb.2
bb.6:
- RETQ
+ RET64
bb.7:
...
$rbx = POP64r implicit-def $rsp, implicit $rsp
$r14 = POP64r implicit-def $rsp, implicit $rsp
$rbp = POP64r implicit-def $rsp, implicit $rsp
- RETQ
+ RET64
...
constants:
body: |
bb.0:
- RETQ
+ RET64
...
---
constants:
body: |
bb.0:
- RETQ
+ RET64
...
---
constants:
body: |
bb.0:
- RETQ
+ RET64
...
; CHECK: NOOP implicit killed [[REG1]]
NOOP implicit %2
NOOP implicit %1
- RETQ $eax
+ RET64 $eax
...
---
# CHECK-LABEL: name: func3
; CHECK: bb.4:
; CHECK: $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
; CHECK: dead $eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, implicit-def $al
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
; CHECK: bb.6:
; CHECK: successors: %bb.1(0x30000000), %bb.7(0x50000000)
; CHECK: $rax = MOV64rm $r14, 1, $noreg, 0, $noreg :: (load (s64))
; CHECK: JCC_1 %bb.7, 5, implicit $eflags
; CHECK: bb.1:
; CHECK: $ebp = XOR32rr undef $ebp, undef $ebp, implicit-def dead $eflags
- ; CHECK: RETQ $eax
+ ; CHECK: RET64 $eax
bb.0:
successors: %bb.1(0x40000000), %bb.7(0x40000000)
bb.16:
- RETQ $eax
+ RET64 $eax
...
; Verify that XOR is untouched by the dependency breaker
; CHECK: $esi = XOR32rr undef $esi, undef $esi, implicit-def dead $eflags, implicit-def $rsi
$esi = XOR32rr undef $esi, undef $esi, implicit-def dead $eflags, implicit-def $rsi
- RETQ killed $eax
+ RET64 killed $eax
...
%5:gr32 = COPY %4
PUSH32r killed %1, implicit-def $esp, implicit $esp
$eax = COPY killed %5
- RETQ implicit killed $eax
+ RET64 implicit killed $eax
...
JMP_1 %bb.2
bb.4:
- RETQ
+ RET64
...
SEH_Epilogue
$rsp = frame-destroy ADD64ri8 $rsp, 48, implicit-def dead $eflags
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax
+ RET64 $eax
bb.1.if.then:
successors: %bb.2(0x7ffff800), %bb.7(0x00000800)
bb.0:
liveins: $edi
; CHECK: PATCHABLE_FUNCTION_ENTER
- RETQ
+ RET64
; CHECK-NEXT: PATCHABLE_RET
- RETQ
+ RET64
; CHECK-NEXT: PATCHABLE_RET
...
DBG_INSTR_REF 2, 0, !12, !DIExpression(), debug-location !13
renamable $rax = MOV64rm $rip, 1, $noreg, target-flags(x86-gotpcrel) @someglobal, $noreg, debug-location !13 :: (load (s64) from got)
MOV8mr killed renamable $rax, 1, $noreg, 0, $noreg, renamable $dil, debug-location !13 :: (store (s8) into @someglobal)
- RETQ debug-location !13
+ RET64 debug-location !13
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !26
$r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !26
CFI_INSTRUCTION def_cfa_offset 8, debug-location !26
- RETQ implicit $eax, debug-location !26
+ RET64 implicit $eax, debug-location !26
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !31
$r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !31
CFI_INSTRUCTION def_cfa_offset 8, debug-location !31
- RETQ implicit $eax, debug-location !31
+ RET64 implicit $eax, debug-location !31
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !31
$r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !31
CFI_INSTRUCTION def_cfa_offset 8, debug-location !31
- RETQ implicit $eax, debug-location !31
+ RET64 implicit $eax, debug-location !31
...
CFI_INSTRUCTION def_cfa_offset 16
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp
CFI_INSTRUCTION def_cfa_offset 8
- RETQ
+ RET64
...
; This clobber of $rax might cause LDV to re-issue a DBG_VALUE stating the
; variable location as $rbx. However, the preceeding DBG_VALUE_LIST should
; terminate the earlier location.
- RETQ implicit $rbx, debug-location !13
+ RET64 implicit $rbx, debug-location !13
...
$rbp = MOV64rr $rdi, debug-instr-number 1
dead $rcx = MOV64ri 0
CMP64ri8 renamable $rax, 1, implicit-def $eflags
- RETQ $rax
+ RET64 $rax
...
; This is instruction 10 referred to in bb.10. However, as the variable
; location/value has been modified in the meantime, no DBG_VALUE should be
; generated here.
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
; CHECK-NEXT: CALL64pcrel32
; CHECK-NEXT: DBG_VALUE $ebx
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
DBG_INSTR_REF 1, 0, !11, !DIExpression(), debug-location !12
; CHECK: DBG_INSTR_REF
; CHECK-NEXT: DBG_VALUE $esi
- RETQ $rsi, debug-location !12
+ RET64 $rsi, debug-location !12
...
; CHECK-NEXT: DBG_INSTR_REF 13, 0
; CHECK-NEXT: DBG_VALUE $noreg
$rax = MOV64rm $rsp, 1, $noreg, 8, $noreg :: (load 8 from %stack.0)
- RETQ $rax, debug-location !12
+ RET64 $rax, debug-location !12
...
; CHECK-NEXT: DBG_VALUE $noreg
$rax = MOV64rm $rsp, 1, $noreg, 8, $noreg :: (load 8 from %stack.0)
- RETQ $rax, debug-location !12
+ RET64 $rax, debug-location !12
...
$rbp = MOV64rr $rdi, debug-instr-number 1, debug-location !12
dead $rcx = MOV64ri 0, debug-instr-number 1, debug-location !12
CMP64ri8 renamable $rax, 1, implicit-def $eflags
- RETQ $rax
+ RET64 $rax
...
$ebp = KILL killed $rbp, debug-instr-number 2, debug-location !12
dead $rcx = MOV64ri 0
CMP64ri8 renamable $rax, 1, implicit-def $eflags
- RETQ $rax
+ RET64 $rax
...
ADJCALLSTACKUP64 0, 0, implicit-def $rsp, implicit-def $eflags, implicit-def $ssp, implicit $rsp, implicit $ssp, debug-location !13
%23:gr32 = MOVSX32rr16 %26, debug-location !13
$eax = COPY %23, debug-location !13
- RETQ implicit $eax, debug-location !13
+ RET64 implicit $eax, debug-location !13
...
ADJCALLSTACKUP64 0, 0, implicit-def $rsp, implicit-def $eflags, implicit-def $ssp, implicit $rsp, implicit $ssp, debug-location !13
%13:gr32 = COPY %14.sub_32bit, debug-location !13
$eax = COPY %13, debug-location !13
- RETQ implicit $eax, debug-location !13
+ RET64 implicit $eax, debug-location !13
...
JCC_1 %bb.5, 6, implicit $eflags, debug-location !22
bb.6:
- RETQ debug-location !22
+ RET64 debug-location !22
...
DBG_VALUE $rax, $noreg, !12, !DIExpression(), debug-location !13
MOV64mr $rsp, 1, $noreg, -8, $noreg, renamable $rax :: (store 8 into %stack.0)
$rsp = MOV64rm $rsp, 1, $noreg, 0, $noreg, debug-location !13 :: (load 8 from %stack.0)
- RETQ implicit $rbx, debug-location !13
+ RET64 implicit $rbx, debug-location !13
...
DBG_INSTR_REF 1, 0
dead $rcx = MOV64ri 0
CMP64ri8 renamable $rax, 1, implicit-def $eflags
- RETQ $rax
+ RET64 $rax
...
# FASTREG-NEXT: JMP_1
# FASTREG-LABEL: bb.4:
# FASTREG: DBG_INSTR_REF 5, 0
-# FASTREG-NEXT: RETQ
+# FASTREG-NEXT: RET64
--- |
; ModuleID = 'tmp.ll'
bb.4:
$eax = COPY %5, debug-location !18
DBG_INSTR_REF 5, 0, !9, !DIExpression(), debug-location !16
- RETQ implicit $eax, debug-location !18
+ RET64 implicit $eax, debug-location !18
...
$ax = MOV16rm killed $rax, 1, $noreg, 0, $noreg, debug-instr-number 1
; CHECK: $eax = MOVZX32rm16 killed $rax, {{.*}} debug-instr-number 2
- RETQ $ax
+ RET64 $ax
...
---
$ax = MOV16rm killed $rdi, 1, $noreg, 0, $noreg, implicit-def $eax, debug-instr-number 1
; CHECK: $eax = MOVZX32rm16 killed $rdi, {{.*}} debug-instr-number 2
$ax = KILL $ax, implicit killed $eax
- RETQ $ax
+ RET64 $ax
bb.1:
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags
$ax = KILL $ax, implicit killed $eax
- RETQ $ax
+ RET64 $ax
...
; CHECK: $eax = ADD32ri8 {{.*}} debug-instr-number 2
$eax = LEA32r killed $eax, 1, killed $ebp, -5, $noreg, debug-instr-number 1
- RETQ $eax
+ RET64 $eax
...
---
; CHECK: $ebx = ADD32rr {{.*}} debug-instr-number 2
$ebx = LEA32r killed $ebp, 1, $ebp, 0, $noreg, debug-instr-number 1
- RETQ $ebx
+ RET64 $ebx
...
---
; CHECK: $ebx = ADD32rr {{.*}} debug-instr-number 2
$ebx = LEA32r $ebp, 1, $ebp, 5, $noreg, debug-instr-number 1
- RETQ $ebx
+ RET64 $ebx
...
$ebp = LEA64_32r killed $rbp, 1, killed $rax, 0, $noreg, debug-instr-number 1
; COREI7: ADD32rr {{.*}} debug-instr-number 2
- RETQ $ebp
+ RET64 $ebp
...
---
renamable $eax = nsw LEA64_32r killed renamable $rdi, 4, renamable $rdi, 2, $noreg, debug-instr-number 2
; HASWELL: ADD32ri8 {{.*}} debug-instr-number 4
renamable $eax = nsw IMUL32rr killed renamable $eax, killed renamable $ecx, implicit-def dead $eflags
- RETQ $eax
+ RET64 $eax
...
---
renamable $ecx = nsw ADD32rr renamable $ecx, renamable $eax, implicit-def dead $eflags, implicit killed $rax, implicit killed $rcx, implicit-def $rcx, debug-instr-number 1
; ATOM: LEA64_32r {{.*}} debug-instr-number 2
renamable $eax = MOV32rm killed renamable $rcx, 1, $noreg, 0, $noreg :: (load (s32) from `i32 *undef`)
- RETQ $eax
+ RET64 $eax
...
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
$edi = SHR32ri killed $edi, 8, implicit-def dead $eflags, debug-location !17
$eax = MOVSX32rr8 $dil, implicit killed $edi, debug-location !20
$rbp = POP64r implicit-def $rsp, implicit $rsp, debug-location !20
- RETQ $eax, debug-location !20
+ RET64 $eax, debug-location !20
...
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !33
DBG_VALUE $rdi, $noreg, !23, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !25
CFI_INSTRUCTION def_cfa_offset 8, debug-location !33
- RETQ $eax, debug-location !33
+ RET64 $eax, debug-location !33
bb.2.if.then:
CFI_INSTRUCTION def_cfa_offset 16, debug-location !32
CALL64pcrel32 @ext2, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit killed $esi, implicit-def $rsp, implicit-def $ssp, debug-location !16
$eax = MOV32ri 123, debug-location !17
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !17
- RETQ killed $eax, debug-location !17
+ RET64 killed $eax, debug-location !17
...
CALL64pcrel32 @ext3, csr_64, implicit $rsp, implicit $ssp, implicit killed $edi, implicit $esi, implicit $edx, implicit-def $rsp, implicit-def $ssp, debug-location !20
$eax = MOV32rr killed $ebx, debug-location !20
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !20
- RETQ killed $eax, debug-location !21
+ RET64 killed $eax, debug-location !21
...
frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp
$rbp = frame-setup MOV64rr $rsp
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !16
- RETQ debug-location !16
+ RET64 debug-location !16
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !18
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !18
CFI_INSTRUCTION def_cfa_offset 8, debug-location !18
- RETQ debug-location !18
+ RET64 debug-location !18
...
$r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !20
$r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !20
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !20
- RETQ debug-location !20
+ RET64 debug-location !20
...
$rsp = frame-destroy ADD64ri8 $rsp, 16, implicit-def dead $eflags, debug-location !15
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !15
CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !15
- RETQ $eax, debug-location !15
+ RET64 $eax, debug-location !15
...
$eax = MOV32rr killed $ebx, debug-location !32
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !32
CFI_INSTRUCTION def_cfa_offset 8, debug-location !32
- RETQ killed $eax, debug-location !32
+ RET64 killed $eax, debug-location !32
...
$r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !21
CFI_INSTRUCTION def_cfa_offset 8, debug-location !21
- RETQ $eax, debug-location !21
+ RET64 $eax, debug-location !21
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !14
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !14
CFI_INSTRUCTION def_cfa_offset 8, debug-location !14
- RETQ $eax, debug-location !14
+ RET64 $eax, debug-location !14
...
CALL64pcrel32 @call, csr_64, implicit $rsp, implicit $ssp, implicit killed $edi, implicit undef $esi, implicit-def $rsp, implicit-def $ssp, debug-location !15
$rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !16
CFI_INSTRUCTION def_cfa_offset 8, debug-location !16
- RETQ debug-location !16
+ RET64 debug-location !16
...
CALL64pcrel32 @_ZN1CC2E1B, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit $rsi, implicit-def $rsp, implicit-def $ssp, debug-location !36
$rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !36
CFI_INSTRUCTION def_cfa_offset 8, debug-location !36
- RETQ debug-location !36
+ RET64 debug-location !36
...
CALL64pcrel32 @call2, csr_64, implicit $rsp, implicit $ssp, implicit $edi, implicit $esi, implicit-def $rsp, implicit-def $ssp, debug-location !15
$rax = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !16
CFI_INSTRUCTION def_cfa_offset 8, debug-location !16
- RETQ debug-location !16
+ RET64 debug-location !16
...
renamable $eax = MOV32rm $rip, 1, $noreg, @a, $noreg, debug-location !16 :: (dereferenceable load (s32) from @a)
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !16
CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !16
- RETQ $eax, debug-location !16
+ RET64 $eax, debug-location !16
...
---
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !22
- RETQ $eax, debug-location !22
+ RET64 $eax, debug-location !22
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !24
$r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !24
CFI_INSTRUCTION def_cfa_offset 8, debug-location !24
- RETQ debug-location !24
+ RET64 debug-location !24
...
MOV32mr $rip, 1, $noreg, @global, $noreg, killed renamable $edi, debug-location !18 :: (store (s32) into @global)
INLINEASM &"", 1, 12, implicit-def dead early-clobber $edi, 12, implicit-def dead early-clobber $esi, 12, implicit-def dead early-clobber $edx, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, !19, debug-location !18
$eax = MOV32ri 123, debug-location !18
- RETQ killed $eax, debug-location !18
+ RET64 killed $eax, debug-location !18
...
\r
bb.4:\r
liveins: $rbx, $rsi\r
- RETQ $rbx, debug-location !17\r
+ RET64 $rbx, debug-location !17\r
\r
...\r
\r
bb.10:\r
liveins: $rdi, $rsi\r
; Should _not_ be a live-in loc here.\r
- RETQ\r
+ RET64\r
\r
...\r
\r
\r
bb.2:\r
liveins: $rbx, $rbp\r
- RETQ $rbp, debug-location !17\r
+ RET64 $rbp, debug-location !17\r
\r
...\r
\r
$rax = COPY killed $rdi\r
$rdi = MOV64ri 0\r
$rdi = MOV64rm $rsp, 1, $noreg, -16, $noreg, debug-location !15 :: (load (s64) from %stack.0)\r
- RETQ\r
+ RET64\r
...\r
\r
\r
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit %3, implicit %5\r
\r
- RETQ\r
+ RET64\r
...\r
\r
CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit %3, implicit %5\r
\r
- RETQ\r
+ RET64\r
...\r
$rax = MOV64rm $rdi, 1, _, 0, _ :: (load (s64) from %ir.6, align 4)
$al = MOV8rm killed $rax, 1, _, 0, _ :: (load (s8) from %ir.8)
MOV8mr killed $rdi, 1, _, 8, _, killed $al, debug-location !14 :: (store (s8) into %ir.12)
- RETQ undef $eax
+ RET64 undef $eax
bb.1:
liveins: $rdi
$al = IMPLICIT_DEF debug-location !10
MOV8mr killed $rdi, 1, _, 8, _, killed $al, debug-location !14 :: (store (s8) into %ir.12)
- RETQ undef $eax
+ RET64 undef $eax
...
renamable $al = SETCCr 12, implicit killed $eflags, implicit killed $eax, implicit-def $eax, debug-location !23
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !26
CFI_INSTRUCTION def_cfa_offset 8, debug-location !26
- RETQ $eax, debug-location !26
+ RET64 $eax, debug-location !26
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !34
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !34
CFI_INSTRUCTION def_cfa_offset 8, debug-location !34
- RETQ killed $eax, debug-location !34
+ RET64 killed $eax, debug-location !34
...
$r14 = POP64r implicit-def $rsp, implicit $rsp
$r15 = POP64r implicit-def $rsp, implicit $rsp
$rbp = POP64r implicit-def $rsp, implicit $rsp
- RETQ $eax, debug-location !57
+ RET64 $eax, debug-location !57
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !34
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !34
CFI_INSTRUCTION def_cfa_offset 8, debug-location !34
- RETQ killed $eax, debug-location !34
+ RET64 killed $eax, debug-location !34
...
$ecx = IMUL32rr killed $ecx, killed $edi, implicit-def dead $eflags, debug-location !36
DBG_VALUE 0, 0, !13, !17, debug-location !25
$eax = MOV32rr killed $ecx, debug-location !50
- RETQ $eax, debug-location !50
+ RET64 $eax, debug-location !50
bb.6.if.then.4:
liveins: $ecx, $esi
$ecx = IMUL32rr killed $ecx, killed $esi, implicit-def dead $eflags, debug-location !40
DBG_VALUE 0, 0, !13, !17, debug-location !25
$eax = MOV32rr killed $ecx, debug-location !50
- RETQ $eax, debug-location !50
+ RET64 $eax, debug-location !50
bb.8.if.then.8:
successors: %bb.9.for.end(0)
DBG_VALUE 0, 0, !13, !17, debug-location !25
$eax = MOV32rr killed $ecx, debug-location !50
- RETQ $eax, debug-location !50
+ RET64 $eax, debug-location !50
...
$eax = MOV32rr killed $ebx, debug-location !10
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
CFI_INSTRUCTION def_cfa_offset 8
- RETQ $eax, debug-location !10
+ RET64 $eax, debug-location !10
...
CALL64pcrel32 @use, csr_64, implicit $rsp, implicit $ssp, implicit killed $edi, implicit-def $eax, debug-location !14
DBG_VALUE renamable $eax, $noreg, !11, !DIExpression(), debug-location !14
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !15
- RETQ implicit killed $eax, debug-location !15
+ RET64 implicit killed $eax, debug-location !15
...
$eax = MOV32rr killed $ebx
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp
CFI_INSTRUCTION def_cfa_offset 8
- RETQ $eax
+ RET64 $eax
...
# CHECK-NEXT: DBG_VALUE $eax, $noreg, !{{[0-9]+}},
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 0, 32)
# CHECK-NEXT: XOR32rr
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
#
# CHECK-LABEL: bar
# CHECK-LABEL: bb.0.entry:
# CHECK-NEXT: DBG_VALUE $ax, $noreg, !{{[0-9]+}},
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 8, 16)
# CHECK-NEXT: XOR32rr
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
# CHECK-LABEL: baz
# CHECK-LABEL: bb.0.entry:
# CHECK: DBG_VALUE $ebx, $noreg, !{{[0-9]+}},
# CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 32, 32)
# CHECK-NEXT: XOR32rr
-# CHECK-NEXT: RETQ
+# CHECK-NEXT: RET64
--- |
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
bb.3.bb3:
liveins: $eax, $ebx
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
- RETQ $eax, debug-location !8
+ RET64 $eax, debug-location !8
...
---
bb.3.bb3:
liveins: $eax, $ebx
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
- RETQ $eax, debug-location !48
+ RET64 $eax, debug-location !48
...
---
bb.3.bb3:
liveins: $eax, $ebx
$eax = XOR32rr killed $eax, killed $ebx, implicit-def $eflags
- RETQ $eax, debug-location !88
+ RET64 $eax, debug-location !88
...
; Return faff
$eax = MOV32ri 0
$rsp = frame-destroy ADD64ri8 $rsp, 24, implicit-def dead $eflags
- RETQ debug-location !10
+ RET64 debug-location !10
...
liveins: $rdi, $rbx, $r12, $r13, $r14, $r15, $rbp
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 4, $noreg, debug-location !23 :: (load (s32) from %ir.add.ptr, !tbaa !24)
- RETQ $eax, debug-location !28
+ RET64 $eax, debug-location !28
...
---
renamable $eax = MOV32rm killed renamable $rsi, 1, $noreg, 4, $noreg, debug-location !123 :: (load (s32) from %ir.add.ptr, !tbaa !24)
$rdi = MOV64ri 0
- RETQ $eax, debug-location !128
+ RET64 $eax, debug-location !128
...
---
liveins: $rdi, $rbx, $r12, $r13, $r14, $r15, $rbp
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 4, $noreg, debug-location !223 :: (load (s32) from %ir.add.ptr, !tbaa !24)
- RETQ $eax, debug-location !228
+ RET64 $eax, debug-location !228
renamable $rdi = MOV64rm $rsp, 1, $noreg, -8, $noreg :: (load (s64) from %stack.0)
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 4, $noreg, debug-location !323 :: (load (s32) from %ir.add.ptr, !tbaa !24)
- RETQ $eax, debug-location !328
+ RET64 $eax, debug-location !328
...
---
liveins: $rdi, $rbx, $r12, $r13, $r14, $r15, $rbp
renamable $eax = MOV32rm killed renamable $rdi, 1, $noreg, 4, $noreg, debug-location !414 :: (load (s32) from %ir.add.ptr, !tbaa !24)
- RETQ $eax, debug-location !415
+ RET64 $eax, debug-location !415
...
$r14 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
$r15 = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
$rbp = POP64r implicit-def $rsp, implicit $rsp, debug-location !90
- RETQ debug-location !90
+ RET64 debug-location !90
...
$r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
$r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !28
- RETQ $rax, debug-location !28
+ RET64 $rax, debug-location !28
...
CALL64pcrel32 @printf, csr_64, implicit $rsp, implicit $rdi, implicit $esi, implicit $al, implicit-def $rsp, implicit-def dead $eax, debug-location !46
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !47
$rbx = POP64r implicit-def $rsp, implicit $rsp, debug-location !47
- RETQ $eax, debug-location !47
+ RET64 $eax, debug-location !47
...
successors: %bb.3
renamable $ebx = KILL $ebx
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$ebx = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
DBG_VALUE $eax, $noreg, !16, !DIExpression(), debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
successors: %bb.3
$eax = MOV32ri 0, debug-location !17
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
liveins: $rax, $rbp
bb.6:
liveins: $rax, $rbp
- RETQ $rax, debug-location !17
+ RET64 $rax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.4.bb4:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.4.bb4:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
JCC_1 %bb.1, 4, implicit killed $eflags
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$ebx = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
JCC_1 %bb.1, 4, implicit killed $eflags
bb.3.bb3:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.4.bb4:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.4.bb4:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
$eax = MOV32ri 0, debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
DBG_VALUE $eax, $noreg, !16, !DIExpression(), debug-location !17
JCC_1 %bb.1, 4, implicit killed $eflags
bb.5.bb5:
- RETQ $eax, debug-location !17
+ RET64 $eax, debug-location !17
...
bb.18:
liveins: $rsi, $rdi, $eflags
- RETQ
+ RET64
...
bb.4.exit:
$eax = COPY %5, debug-location !18
- RETQ implicit $eax, debug-location !18
+ RET64 implicit $eax, debug-location !18
...
MOV32mr $rip, 1, $noreg, @global, $noreg, killed renamable $edi, debug-location !18 :: (store (s32) into @global)
INLINEASM &"", 1, 12, implicit-def dead early-clobber $edi, 12, implicit-def dead early-clobber $esi, 12, implicit-def dead early-clobber $edx, 12, implicit-def dead early-clobber $df, 12, implicit-def dead early-clobber $fpsw, 12, implicit-def dead early-clobber $eflags, !19, debug-location !18
$eax = MOV32ri 123, debug-location !18
- RETQ killed $eax, debug-location !18
+ RET64 killed $eax, debug-location !18
...
frame-setup PUSH64r killed $rbp, implicit-def $rsp, implicit $rsp
$rbp = frame-setup MOV64rr $rsp
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !16
- RETQ debug-location !16
+ RET64 debug-location !16
...
CFI_INSTRUCTION def_cfa_offset 16, debug-location !34
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !34
CFI_INSTRUCTION def_cfa_offset 8, debug-location !34
- RETQ killed $eax, debug-location !34
+ RET64 killed $eax, debug-location !34
...
liveins: $eax
DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
- RETQ $eax, debug-location !32
+ RET64 $eax, debug-location !32
bb.3.if.then:
liveins: $eax, $edi
renamable $eax = nsw IMUL32rr killed renamable $eax, killed renamable $edi, implicit-def dead $eflags, debug-location !28
DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
DBG_VALUE $eax, $noreg, !15, !DIExpression(), debug-location !17
- RETQ $eax, debug-location !32
+ RET64 $eax, debug-location !32
...
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
---
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
---
DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
---
DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
---
DBG_VALUE $edi, $noreg, !13, !DIExpression(DW_OP_LLVM_fragment, 0, 32), debug-location !14
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
---
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !22
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !22
CFI_INSTRUCTION def_cfa_offset 8, debug-location !22
- RETQ killed $eax, debug-location !22
+ RET64 killed $eax, debug-location !22
...
$eax = XOR32rr undef $eax, undef $eax, implicit-def dead $eflags, debug-location !18
$rcx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !18
CFI_INSTRUCTION def_cfa_offset 8, debug-location !18
- RETQ killed $eax, debug-location !18
+ RET64 killed $eax, debug-location !18
...
; CHECK: DBG_VALUE 43, $noreg, ![[X]],
; CHECK: bb.2.if.end:
; CHECK-NOT: DBG_VALUE 23, $noreg, ![[X]],
-; CHECK: RETQ $eax
+; CHECK: RET64 $eax
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.11.0"
; CHECK: [0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX)
; CHECK-NEXT: DW_AT_name ("result")
renamable $eax = KILL killed $eax, implicit-def $rax
- RETQ killed $eax, debug-location !24
+ RET64 killed $eax, debug-location !24
...
$edi = MOV32rr $eax, debug-location !24
$eax = MOV32rr $eax, debug-location !24
$edi = MOV32rr $eax, debug-location !24
- RETQ killed $eax, debug-location !24
+ RET64 killed $eax, debug-location !24
...
DBG_VALUE_LIST !12, !DIExpression(DW_OP_LLVM_arg, 0, DW_OP_LLVM_arg, 1, DW_OP_plus, DW_OP_stack_value, DW_OP_LLVM_fragment, 16, 16), $eax, $ecx, debug-location !15\r
; CHECK-NEXT: [{{.*}}): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_stack_value, DW_OP_piece 0x2, DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_breg2 RCX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_plus, DW_OP_stack_value, DW_OP_piece 0x2\r
\r
- RETQ debug-location !15\r
+ RET64 debug-location !15\r
...\r
; CHECK-NEXT: DW_AT_name ("localh")\r
; CHECK-NOT: DW_AT_location\r
\r
- RETQ debug-location !15\r
+ RET64 debug-location !15\r
...\r
$rsp = MOV64rr $rbp, debug-location !12
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !12
CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !12
- RETQ implicit killed $eax, debug-location !12
+ RET64 implicit killed $eax, debug-location !12
...
$esp = frame-destroy ADD32ri8 $esp, 4, implicit-def dead $eflags, debug-location !16
$ebp = frame-destroy POP32r implicit-def $esp, implicit $esp, debug-location !16
CFI_INSTRUCTION def_cfa $esp, 4, debug-location !16
- RETL implicit killed $eax, debug-location !16
+ RET32 implicit killed $eax, debug-location !16
...
---
$esp = frame-destroy ADD32ri8 $esp, 24, implicit-def dead $eflags, debug-location !30
$ebp = frame-destroy POP32r implicit-def $esp, implicit $esp, debug-location !30
CFI_INSTRUCTION def_cfa $esp, 4, debug-location !30
- RETL debug-location !30
+ RET32 debug-location !30
...
renamable $rcx = MOV64rm renamable $noreg, 1, $noreg, 0, $fs
DBG_VALUE renamable $rcx, 0, !9, !DIExpression(DW_OP_constu, 18446744073709551614, DW_OP_minus), debug-location !14
- RETQ debug-location !14
+ RET64 debug-location !14
bb.1: ;-------------------------- DW_OP_plus -------------------------------
renamable $rcx = MOV64rm renamable $noreg, 1, $noreg, 0, $fs
DBG_VALUE renamable $rcx, 0, !9, !DIExpression(DW_OP_constu, 18446744073709551614, DW_OP_plus), debug-location !14
- RETQ debug-location !14
+ RET64 debug-location !14
bb.2: ;-------------------------- DW_OP_plus_uconst -------------------------------
renamable $rcx = MOV64rm renamable $noreg, 1, $noreg, 0, $fs
DBG_VALUE renamable $rcx, 0, !9, !DIExpression(DW_OP_plus_uconst, 18446744073709551614), debug-location !14
- RETQ debug-location !14
+ RET64 debug-location !14
...
MOV64mr killed renamable $rax, 1, $noreg, 0, $fs, killed renamable $rcx, debug-location !18 :: (store (s64) into @__safestack_unsafe_stack_ptr)
$rsp = frame-destroy ADD64ri8 $rsp, 24, implicit-def dead $eflags, debug-location !18
CFI_INSTRUCTION def_cfa_offset 8, debug-location !18
- RETQ debug-location !18
+ RET64 debug-location !18
...
bb.3.bb3:
liveins: $rax
- RETQ $eax, debug-location !9
+ RET64 $eax, debug-location !9
...
---
bb.3.bb3:
liveins: $rax
- RETQ $eax, debug-location !42
+ RET64 $eax, debug-location !42
...
---
bb.3.bb3:
liveins: $rax
- RETQ $eax, debug-location !82
+ RET64 $eax, debug-location !82
...
---
bb.3.bb3:
liveins: $rax
- RETQ $eax, debug-location !122
+ RET64 $eax, debug-location !122
...
$rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !40
DBG_VALUE $edi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !16
CFI_INSTRUCTION def_cfa_offset 8, debug-location !40
- RETQ $eax, debug-location !40
+ RET64 $eax, debug-location !40
...
bb.1.if.then:
renamable $rax = MOV64rm $rip, 1, $noreg, @b, $noreg, debug-location !21 :: (dereferenceable load (s64) from @b)
- RETQ $rax, debug-location !27
+ RET64 $rax, debug-location !27
bb.2.if.end:
DBG_VALUE 0, $noreg, !19, !DIExpression(), debug-location !27
renamable $rax = MOV64rm $rip, 1, $noreg, @a, $noreg, debug-location !27 :: (dereferenceable load (s64) from @a)
- RETQ $rax, debug-location !27
+ RET64 $rax, debug-location !27
...
---
bb.0.entry:
$eax = MOVZX32rm16 $noreg, 1, $noreg, 0, $noreg, debug-location !48 :: (load (s16) from `i16* null`, align 1)
DBG_VALUE $ax, $noreg, !39, !DIExpression(), debug-location !51
- RETQ $ax, debug-location !51
+ RET64 $ax, debug-location !51
...
$rsp = frame-destroy ADD64ri8 $rsp, 32, implicit-def dead $eflags, debug-location !53
$rbp = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !53
CFI_INSTRUCTION def_cfa $rsp, 8, debug-location !53
- RETQ debug-location !53
+ RET64 debug-location !53
...
; CHECK: DBG_VALUE $eax
; CHECK: $eax = SHL32rCL killed renamable $eax
; CHECK: DBG_VALUE $eax
-; CHECK: RETQ $eax
+; CHECK: RET64 $eax
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
;; end scope, end location range
$esi = MOV32ri 2, debug-location !26
- RETQ debug-location !15
+ RET64 debug-location !15
...
bb.2.return:
liveins: $eax
- RETQ $eax, debug-location !36
+ RET64 $eax, debug-location !36
bb.1.if.end:
renamable $eax = MOV32ri 1
- RETQ $eax, debug-location !36
+ RET64 $eax, debug-location !36
...
TAILJMPd64 @ext, csr_64, implicit $rsp, implicit $ssp, implicit $rsp, implicit $ssp, implicit killed $al, debug-location !35
bb.1.if.end:
- RETQ debug-location !36
+ RET64 debug-location !36
...
---
TAILJMPd64 @ext, csr_64, implicit $rsp, implicit $ssp, implicit $rsp, implicit $ssp, implicit killed $al, debug-location !49
bb.1.if.end:
- RETQ debug-location !50
+ RET64 debug-location !50
...
$edi = MOV32ri 9, debug-location !26
; scope fun !7
- RETQ debug-location !15
+ RET64 debug-location !15
...
bb.2:
PSEUDO_PROBE 6699318081062747564, 3, 0, 0
PSEUDO_PROBE 6699318081062747564, 4, 0, 0
- RETQ
+ RET64
bb.1:
PSEUDO_PROBE 6699318081062747564, 2, 0, 0
PSEUDO_PROBE 6699318081062747564, 4, 0, 0
- RETQ
+ RET64
...
TEST_F(InstrRefLDVTest, MTransferDefs) {
MachineFunction *MF = readMIRBlock(
" $rax = MOV64ri 0\n"
- " RETQ $rax\n");
+ " RET64 $rax\n");
setupLDVObj(MF);
// We should start with only SP tracked.
MF = readMIRBlock(
" $rax = MOV64ri 0\n"
" $al = MOV8ri 0\n"
- " RETQ $rax\n");
+ " RET64 $rax\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rdi = MOV64ri 0\n" // instr 4
" $rsi = MOV64ri 0\n" // instr 5
" CALL64r $rax, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit $rsi, implicit-def $rsp, implicit-def $ssp, implicit-def $rax, implicit-def $esp, implicit-def $sp\n\n\n\n" // instr 6
- " RETQ $rax\n"); // instr 7
+ " RET64 $rax\n"); // instr 7
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
// When we DBG_PHI something, we should track all its subregs.
MF = readMIRBlock(
" DBG_PHI $rdi, 0\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rax = MOV64ri 0\n"
" $rax = IMPLICIT_DEF\n"
" $rax = KILL killed $rax\n"
- " RETQ $rax\n");
+ " RET64 $rax\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
MachineFunction *MF = readMIRBlock(
" $rax = MOV64ri 0\n"
" MOV64mr $rsp, 1, $noreg, 16, $noreg, $rax :: (store 8 into %stack.0)\n"
- " RETQ $rax\n");
+ " RET64 $rax\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rax = MOV64ri 0\n"
" MOV64mr $rsp, 1, $noreg, 16, $noreg, $rax :: (store 8 into %stack.0)\n"
" $rbx = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.0)\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rax = MOV64ri 0\n"
" $rcx = COPY $rax\n"
" $rbx = MOV64rr $rcx\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
MF = readMIRBlock(
" $rax = MOV64ri 0\n"
" $ecx = COPY $eax\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rax = MOV64ri 0\n"
" MOV64mr $rsp, 1, $noreg, 16, $noreg, $rax :: (store 8 into %stack.0)\n"
" $rbx = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.0)\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" MOV64mr $rsp, 1, $noreg, 16, $noreg, $rax :: (store 8 into %stack.0)\n"
" MOV32mr $rsp, 1, $noreg, 16, $noreg, $eax :: (store 4 into %stack.0)\n"
" $rbx = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.0)\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $xmm0 = IMPLICIT_DEF\n"
" MOVUPDmr $rsp, 1, $noreg, 16, $noreg, killed $xmm0 :: (store (s128) into %stack.0)\n"
" $rbx = MOV64rm $rsp, 1, $noreg, 0, $noreg :: (load 8 from %stack.0)\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
" $rax = MOV64ri 0\n"
" MOV8mr $rsp, 1, $noreg, 16, $noreg, $ah :: (store 1 into %stack.0)\n"
" $al = MOV8rm $rsp, 1, $noreg, 0, $noreg :: (load 1 from %stack.0)\n"
- " RETQ\n");
+ " RET64\n");
setupLDVObj(MF);
TransferMap.clear();
TransferMap.resize(1);
ASSERT_EQ(MF->getNumBlockIDs(), 1u);
EXPECT_THAT(MF->getBlockNumbered(0)->instrs(),
ElementsAre(HasOpcode(X86::NOOP), HasOpcode(X86::NOOP),
- HasOpcode(X86::NOOP), HasOpcode(X86::RETQ)));
+ HasOpcode(X86::NOOP), HasOpcode(X86::RET64)));
}
TEST_F(X86SnippetRepetitorTest, Loop) {
LiveReg(State.getExegesisTarget().getLoopCounterRegister(
State.getTargetMachine().getTargetTriple()))));
EXPECT_THAT(MF->getBlockNumbered(2)->instrs(),
- ElementsAre(HasOpcode(X86::RETQ)));
+ ElementsAre(HasOpcode(X86::RET64)));
}
} // namespace
projects / platform / upstream / llvm.git / commitdiff