diff --git a/llvm/include/llvm/CodeGen/AsmPrinter.h b/llvm/include/llvm/CodeGen/AsmPrinter.h index 581a1213d713..1e78ac9b33a2 100644 --- a/llvm/include/llvm/CodeGen/AsmPrinter.h +++ b/llvm/include/llvm/CodeGen/AsmPrinter.h @@ -235,15 +235,13 @@ public: // The table will contain these structs that point to the sled, the function // containing the sled, and what kind of sled (and whether they should always - // be instrumented). We also use a version identifier that the runtime can use - // to decide what to do with the sled, depending on the version of the sled. + // be instrumented). struct XRayFunctionEntry { const MCSymbol *Sled; const MCSymbol *Function; SledKind Kind; bool AlwaysInstrument; const class Function *Fn; - uint8_t Version; void emit(int, MCStreamer *, const MCSymbol *) const; }; @@ -251,12 +249,8 @@ public: // All the sleds to be emitted. SmallVector Sleds; - // A unique ID used for ELF sections associated with a particular function. - unsigned XRayFnUniqueID = 0; - // Helper function to record a given XRay sled. - void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind, - uint8_t Version = 0); + void recordSled(MCSymbol *Sled, const MachineInstr &MI, SledKind Kind); /// Emit a table with all XRay instrumentation points. void emitXRayTable(); diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp index 87399354945a..5e002e709290 100644 --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -2767,13 +2767,10 @@ void AsmPrinter::XRayFunctionEntry::emit(int Bytes, MCStreamer *Out, Out->EmitSymbolValue(Sled, Bytes); Out->EmitSymbolValue(CurrentFnSym, Bytes); auto Kind8 = static_cast(Kind); - Out->EmitBinaryData(StringRef(reinterpret_cast(&Kind8), 1)); - Out->EmitBinaryData( + Out->EmitBytes(StringRef(reinterpret_cast(&Kind8), 1)); + Out->EmitBytes( StringRef(reinterpret_cast(&AlwaysInstrument), 1)); - Out->EmitBinaryData(StringRef(reinterpret_cast(&Version), 1)); - auto Padding = (4 * Bytes) - ((2 * Bytes) + 3); - assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size"); - Out->EmitZeros(Padding); + Out->EmitZeros(2 * Bytes - 2); // Pad the previous two entries } void AsmPrinter::emitXRayTable() { @@ -2785,22 +2782,19 @@ void AsmPrinter::emitXRayTable() { MCSection *InstMap = nullptr; MCSection *FnSledIndex = nullptr; if (MF->getSubtarget().getTargetTriple().isOSBinFormatELF()) { - auto Associated = dyn_cast(PrevSection->getBeginSymbol()); - assert(Associated != nullptr); - auto Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER; - std::string GroupName; if (Fn->hasComdat()) { - Flags |= ELF::SHF_GROUP; - GroupName = Fn->getComdat()->getName(); + InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, + ELF::SHF_ALLOC | ELF::SHF_GROUP, 0, + Fn->getComdat()->getName()); + FnSledIndex = OutContext.getELFSection("xray_fn_idx", ELF::SHT_PROGBITS, + ELF::SHF_ALLOC | ELF::SHF_GROUP, 0, + Fn->getComdat()->getName()); + } else { + InstMap = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, + ELF::SHF_ALLOC); + FnSledIndex = OutContext.getELFSection("xray_fn_idx", ELF::SHT_PROGBITS, + ELF::SHF_ALLOC); } - - auto UniqueID = ++XRayFnUniqueID; - InstMap = - OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, Flags, 0, - GroupName, UniqueID, Associated); - FnSledIndex = - OutContext.getELFSection("xray_fn_idx", ELF::SHT_PROGBITS, Flags, 0, - GroupName, UniqueID, Associated); } else if (MF->getSubtarget().getTargetTriple().isOSBinFormatMachO()) { InstMap = OutContext.getMachOSection("__DATA", "xray_instr_map", 0, SectionKind::getReadOnlyWithRel()); @@ -2810,7 +2804,15 @@ void AsmPrinter::emitXRayTable() { llvm_unreachable("Unsupported target"); } + // Before we switch over, we force a reference to a label inside the + // xray_fn_idx sections. This makes sure that the xray_fn_idx section is kept + // live by the linker if the function is not garbage-collected. Since this + // function is always called just before the function's end, we assume that + // this is happening after the last return instruction. auto WordSizeBytes = MAI->getCodePointerSize(); + MCSymbol *IdxRef = OutContext.createTempSymbol("xray_fn_idx_synth_", true); + OutStreamer->EmitCodeAlignment(16); + OutStreamer->EmitSymbolValue(IdxRef, WordSizeBytes, false); // Now we switch to the instrumentation map section. Because this is done // per-function, we are able to create an index entry that will represent the @@ -2829,14 +2831,15 @@ void AsmPrinter::emitXRayTable() { // pointers. This should work for both 32-bit and 64-bit platforms. OutStreamer->SwitchSection(FnSledIndex); OutStreamer->EmitCodeAlignment(2 * WordSizeBytes); - OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes, false); - OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes, false); + OutStreamer->EmitLabel(IdxRef); + OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes); + OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes); OutStreamer->SwitchSection(PrevSection); Sleds.clear(); } void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI, - SledKind Kind, uint8_t Version) { + SledKind Kind) { auto Fn = MI.getParent()->getParent()->getFunction(); auto Attr = Fn->getFnAttribute("function-instrument"); bool LogArgs = Fn->hasFnAttribute("xray-log-args"); @@ -2844,8 +2847,8 @@ void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI, Attr.isStringAttribute() && Attr.getValueAsString() == "xray-always"; if (Kind == SledKind::FUNCTION_ENTER && LogArgs) Kind = SledKind::LOG_ARGS_ENTER; - Sleds.emplace_back(XRayFunctionEntry{Sled, CurrentFnSym, Kind, - AlwaysInstrument, Fn, Version}); + Sleds.emplace_back( + XRayFunctionEntry{ Sled, CurrentFnSym, Kind, AlwaysInstrument, Fn }); } uint16_t AsmPrinter::getDwarfVersion() const { diff --git a/llvm/lib/Target/X86/X86MCInstLower.cpp b/llvm/lib/Target/X86/X86MCInstLower.cpp index 3ee1cf710c89..fd2837b79103 100644 --- a/llvm/lib/Target/X86/X86MCInstLower.cpp +++ b/llvm/lib/Target/X86/X86MCInstLower.cpp @@ -1047,20 +1047,20 @@ void X86AsmPrinter::LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI, // We want to emit the following pattern, which follows the x86 calling // convention to prepare for the trampoline call to be patched in. // + // // .p2align 1, ... // .Lxray_event_sled_N: - // jmp +N // jump across the instrumentation sled - // ... // set up arguments in register - // callq __xray_CustomEvent // force dependency to symbol - // ... - // + // jmp +N // jump across the call instruction + // callq __xray_CustomEvent // force relocation to symbol + // + // + // The relative jump needs to jump forward 24 bytes: + // 10 (args) + 5 (nops) + 9 (cleanup) // // After patching, it would look something like: // // nopw (2-byte nop) - // ... // callq __xrayCustomEvent // already lowered - // ... // // --- // First we emit the label and the jump. @@ -1072,55 +1072,49 @@ void X86AsmPrinter::LowerPATCHABLE_EVENT_CALL(const MachineInstr &MI, // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as // an operand (computed as an offset from the jmp instruction). // FIXME: Find another less hacky way do force the relative jump. - OutStreamer->EmitBinaryData("\xeb\x0f"); + OutStreamer->EmitBytes("\xeb\x14"); // The default C calling convention will place two arguments into %rcx and // %rdx -- so we only work with those. - unsigned UsedRegs[] = {X86::RDI, X86::RSI}; - bool UsedMask[] = {false, false}; + unsigned UsedRegs[] = {X86::RDI, X86::RSI, X86::RAX}; - // Then we put the operands in the %rdi and %rsi registers. We spill the - // values in the register before we clobber them, and mark them as used in - // UsedMask. In case the arguments are already in the correct register, we use - // emit nops appropriately sized to keep the sled the same size in every - // situation. + // Because we will use %rax, we preserve that across the call. + EmitAndCountInstruction(MCInstBuilder(X86::PUSH64r).addReg(X86::RAX)); + + // Then we put the operands in the %rdi and %rsi registers. for (unsigned I = 0; I < MI.getNumOperands(); ++I) if (auto Op = MCIL.LowerMachineOperand(&MI, MI.getOperand(I))) { - assert(Op->isReg() && "Only support arguments in registers"); - if (Op->getReg() != UsedRegs[I]) { - UsedMask[I] = true; - EmitAndCountInstruction( - MCInstBuilder(X86::PUSH64r).addReg(UsedRegs[I])); - EmitAndCountInstruction(MCInstBuilder(X86::MOV64rr) + if (Op->isImm()) + EmitAndCountInstruction(MCInstBuilder(X86::MOV64ri) .addReg(UsedRegs[I]) - .addReg(Op->getReg())); - } else { - EmitNops(*OutStreamer, 4, Subtarget->is64Bit(), getSubtargetInfo()); + .addImm(Op->getImm())); + else if (Op->isReg()) { + if (Op->getReg() != UsedRegs[I]) + EmitAndCountInstruction(MCInstBuilder(X86::MOV64rr) + .addReg(UsedRegs[I]) + .addReg(Op->getReg())); + else + EmitNops(*OutStreamer, 3, Subtarget->is64Bit(), getSubtargetInfo()); } } // We emit a hard dependency on the __xray_CustomEvent symbol, which is the - // name of the trampoline to be implemented by the XRay runtime. + // name of the trampoline to be implemented by the XRay runtime. We put this + // explicitly in the %rax register. auto TSym = OutContext.getOrCreateSymbol("__xray_CustomEvent"); MachineOperand TOp = MachineOperand::CreateMCSymbol(TSym); - - // Emit the call instruction. - EmitAndCountInstruction(MCInstBuilder(X86::CALL64pcrel32) + EmitAndCountInstruction(MCInstBuilder(X86::MOV64ri) + .addReg(X86::RAX) .addOperand(MCIL.LowerSymbolOperand(TOp, TSym))); + // Emit the call instruction. + EmitAndCountInstruction(MCInstBuilder(X86::CALL64r).addReg(X86::RAX)); + // Restore caller-saved and used registers. - for (unsigned I = sizeof UsedMask; I-- > 0;) - if (UsedMask[I]) - EmitAndCountInstruction(MCInstBuilder(X86::POP64r).addReg(UsedRegs[I])); - else - EmitNops(*OutStreamer, 1, Subtarget->is64Bit(), getSubtargetInfo()); - OutStreamer->AddComment("xray custom event end."); + EmitAndCountInstruction(MCInstBuilder(X86::POP64r).addReg(X86::RAX)); - // Record the sled version. Older versions of this sled were spelled - // differently, so we let the runtime handle the different offsets we're - // using. - recordSled(CurSled, MI, SledKind::CUSTOM_EVENT, 1); + recordSled(CurSled, MI, SledKind::CUSTOM_EVENT); } void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI, @@ -1131,6 +1125,7 @@ void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI, // .Lxray_sled_N: // jmp .tmpN // # 9 bytes worth of noops + // .tmpN // // We need the 9 bytes because at runtime, we'd be patching over the full 11 // bytes with the following pattern: @@ -1141,12 +1136,14 @@ void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI, auto CurSled = OutContext.createTempSymbol("xray_sled_", true); OutStreamer->EmitCodeAlignment(2); OutStreamer->EmitLabel(CurSled); + auto Target = OutContext.createTempSymbol(); // Use a two-byte `jmp`. This version of JMP takes an 8-bit relative offset as // an operand (computed as an offset from the jmp instruction). // FIXME: Find another less hacky way do force the relative jump. OutStreamer->EmitBytes("\xeb\x09"); EmitNops(*OutStreamer, 9, Subtarget->is64Bit(), getSubtargetInfo()); + OutStreamer->EmitLabel(Target); recordSled(CurSled, MI, SledKind::FUNCTION_ENTER); } diff --git a/llvm/test/CodeGen/AArch64/xray-attribute-instrumentation.ll b/llvm/test/CodeGen/AArch64/xray-attribute-instrumentation.ll index 651130414bef..5f01c7c8be84 100644 --- a/llvm/test/CodeGen/AArch64/xray-attribute-instrumentation.ll +++ b/llvm/test/CodeGen/AArch64/xray-attribute-instrumentation.ll @@ -24,7 +24,9 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" ; CHECK-LABEL: Ltmp1: ; CHECK-NEXT: ret } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4 +; CHECK-NEXT: .xword .Lxray_fn_idx_synth_0 +; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-LABEL: Lxray_sleds_start0 ; CHECK: .xword .Lxray_sled_0 ; CHECK: .xword .Lxray_sled_1 diff --git a/llvm/test/CodeGen/AArch64/xray-tail-call-sled.ll b/llvm/test/CodeGen/AArch64/xray-tail-call-sled.ll index f966362b805e..a7e993b3dbac 100644 --- a/llvm/test/CodeGen/AArch64/xray-tail-call-sled.ll +++ b/llvm/test/CodeGen/AArch64/xray-tail-call-sled.ll @@ -27,12 +27,15 @@ define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-alway ; CHECK-LABEL: .Ltmp1: ; CHECK-NEXT: ret } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4 +; CHECK-NEXT: .xword .Lxray_fn_idx_synth_0 +; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .xword .Lxray_sled_0 ; CHECK: .xword .Lxray_sled_1 ; CHECK-LABEL: Lxray_sleds_end0: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section xray_fn_idx,{{.*}} +; CHECK-LABEL: Lxray_fn_idx_synth_0: ; CHECK: .xword .Lxray_sleds_start0 ; CHECK-NEXT: .xword .Lxray_sleds_end0 @@ -63,11 +66,14 @@ define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-alway ; CHECK: b callee ret i32 %retval } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4 +; CHECK-NEXT: .xword .Lxray_fn_idx_synth_1 +; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-LABEL: Lxray_sleds_start1: ; CHECK: .xword .Lxray_sled_2 ; CHECK: .xword .Lxray_sled_3 ; CHECK-LABEL: Lxray_sleds_end1: ; CHECK: .section xray_fn_idx,{{.*}} +; CHECK-LABEL: Lxray_fn_idx_synth_1: ; CHECK: .xword .Lxray_sleds_start1 ; CHECK-NEXT: .xword .Lxray_sleds_end1 diff --git a/llvm/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll b/llvm/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll index 3cec7cd699ad..5017de835b5d 100644 --- a/llvm/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll +++ b/llvm/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll @@ -23,11 +23,14 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" ; CHECK-LABEL: Ltmp1: ; CHECK-NEXT: bx lr } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4 +; CHECK-NEXT: .long {{.*}}Lxray_fn_idx_synth_0 +; CHECK-NEXT: .section {{.*}}xray_instr_map{{.*}} ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .long {{.*}}Lxray_sled_0 ; CHECK: .long {{.*}}Lxray_sled_1 ; CHECK-LABEL: Lxray_sleds_end0: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section {{.*}}xray_fn_idx{{.*}} +; CHECK-LABEL: Lxray_fn_idx_synth_0: ; CHECK: .long {{.*}}Lxray_sleds_start0 ; CHECK-NEXT: .long {{.*}}Lxray_sleds_end0 diff --git a/llvm/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll b/llvm/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll index e10746d33001..118c02adeb8a 100644 --- a/llvm/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll +++ b/llvm/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll @@ -23,12 +23,15 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" ; CHECK-LABEL: Ltmp1: ; CHECK-NEXT: bx lr } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4 +; CHECK-NEXT: .long {{.*}}Lxray_fn_idx_synth_0 +; CHECK-NEXT: .section {{.*}}xray_instr_map{{.*}} ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .long {{.*}}Lxray_sled_0 ; CHECK: .long {{.*}}Lxray_sled_1 ; CHECK-LABEL: Lxray_sleds_end0: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section {{.*}}xray_fn_idx{{.*}} +; CHECK-LABEL: Lxray_fn_idx_synth_0: ; CHECK: .long {{.*}}xray_sleds_start0 ; CHECK-NEXT: .long {{.*}}xray_sleds_end0 diff --git a/llvm/test/CodeGen/Mips/xray-section-group.ll b/llvm/test/CodeGen/Mips/xray-section-group.ll index f122215c6415..d87f178ec4be 100644 --- a/llvm/test/CodeGen/Mips/xray-section-group.ll +++ b/llvm/test/CodeGen/Mips/xray-section-group.ll @@ -14,7 +14,7 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .section .text.foo,"ax",@progbits ret i32 0 -; CHECK: .section xray_instr_map,"awo",@progbits,.text.foo,unique,1 +; CHECK: .section xray_instr_map,"a",@progbits } ; CHECK-OBJ: Section { @@ -24,7 +24,7 @@ $bar = comdat any define i32 @bar() nounwind noinline uwtable "function-instrument"="xray-always" comdat($bar) { ; CHECK: .section .text.bar,"axG",@progbits,bar,comdat ret i32 1 -; CHECK: .section xray_instr_map,"aGwo",@progbits,bar,comdat,.text.bar,unique,2 +; CHECK: .section xray_instr_map,"aG",@progbits,bar,comdat } ; CHECK-OBJ: Section { diff --git a/llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll b/llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll index 7fa2c0e11805..00b45f8d95b7 100644 --- a/llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll +++ b/llvm/test/CodeGen/X86/xray-attribute-instrumentation.ll @@ -1,25 +1,27 @@ ; RUN: llc -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu < %s | FileCheck %s -; RUN: llc -filetype=asm -o - -mtriple=x86_64-unknown-linux-gnu \ -; RUN: -relocation-model=pic < %s | FileCheck %s ; RUN: llc -filetype=asm -o - -mtriple=x86_64-darwin-unknown < %s | FileCheck %s define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_0: -; CHECK: .ascii "\353\t" +; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp0: ret i32 0 ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_1: -; CHECK: retq +; CHECK-NEXT: retq ; CHECK-NEXT: nopw %cs:512(%rax,%rax) } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4, 0x90 +; CHECK-NEXT: .quad {{.*}}xray_fn_idx_synth_0 +; CHECK-NEXT: .section {{.*}}xray_instr_map ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .quad {{.*}}xray_sled_0 ; CHECK: .quad {{.*}}xray_sled_1 ; CHECK-LABEL: Lxray_sleds_end0: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section {{.*}}xray_fn_idx +; CHECK-LABEL: Lxray_fn_idx_synth_0: ; CHECK: .quad {{.*}}xray_sleds_start0 ; CHECK-NEXT: .quad {{.*}}xray_sleds_end0 @@ -29,8 +31,9 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" define i32 @bar(i32 %i) nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_2: -; CHECK: .ascii "\353\t" +; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp1: Test: %cond = icmp eq i32 %i, 0 br i1 %cond, label %IsEqual, label %NotEqual @@ -38,21 +41,24 @@ IsEqual: ret i32 0 ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_3: -; CHECK: retq +; CHECK-NEXT: retq ; CHECK-NEXT: nopw %cs:512(%rax,%rax) NotEqual: ret i32 1 ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_4: -; CHECK: retq +; CHECK-NEXT: retq ; CHECK-NEXT: nopw %cs:512(%rax,%rax) } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4, 0x90 +; CHECK-NEXT: .quad {{.*}}xray_fn_idx_synth_1 +; CHECK-NEXT: .section {{.*}}xray_instr_map ; CHECK-LABEL: Lxray_sleds_start1: ; CHECK: .quad {{.*}}xray_sled_2 ; CHECK: .quad {{.*}}xray_sled_3 ; CHECK: .quad {{.*}}xray_sled_4 ; CHECK-LABEL: Lxray_sleds_end1: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section {{.*}}xray_fn_idx +; CHECK-LABEL: Lxray_fn_idx_synth_1: ; CHECK: .quad {{.*}}xray_sleds_start1 ; CHECK-NEXT: .quad {{.*}}xray_sleds_end1 diff --git a/llvm/test/CodeGen/X86/xray-custom-log.ll b/llvm/test/CodeGen/X86/xray-custom-log.ll index c9eff5818842..69fd0f3e9f77 100644 --- a/llvm/test/CodeGen/X86/xray-custom-log.ll +++ b/llvm/test/CodeGen/X86/xray-custom-log.ll @@ -7,17 +7,16 @@ define i32 @fn() nounwind noinline uwtable "function-instrument"="xray-always" { %val = load i32, i32* %eventsize call void @llvm.xray.customevent(i8* %eventptr, i32 %val) ; CHECK-LABEL: Lxray_event_sled_0: - ; CHECK: .byte 0xeb, 0x0f - ; CHECK-NEXT: pushq %rdi + ; CHECK-NEXT: .ascii "\353\024 + ; CHECK-NEXT: pushq %rax ; CHECK-NEXT: movq {{.*}}, %rdi - ; CHECK-NEXT: pushq %rsi ; CHECK-NEXT: movq {{.*}}, %rsi - ; CHECK-NEXT: callq __xray_CustomEvent - ; CHECK-NEXT: popq %rsi - ; CHECK-NEXT: popq %rdi + ; CHECK-NEXT: movabsq $__xray_CustomEvent, %rax + ; CHECK-NEXT: callq *%rax + ; CHECK-NEXT: popq %rax ret i32 0 } -; CHECK-LABEL: xray_instr_map +; CHECK: .section {{.*}}xray_instr_map ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .quad {{.*}}xray_event_sled_0 diff --git a/llvm/test/CodeGen/X86/xray-log-args.ll b/llvm/test/CodeGen/X86/xray-log-args.ll index 09d2b10f3d71..6fe450ac8ad3 100644 --- a/llvm/test/CodeGen/X86/xray-log-args.ll +++ b/llvm/test/CodeGen/X86/xray-log-args.ll @@ -7,33 +7,29 @@ define i32 @callee(i32 %arg) nounwind noinline uwtable "function-instrument"="xr ret i32 %arg } ; CHECK-LABEL: Lxray_sleds_start0: -; CHECK: .quad {{\.?}}Lxray_sled_0 -; CHECK: .quad {{_?}}callee -; CHECK: .byte 0x03 -; CHECK: .byte 0x01 -; CHECK: .byte 0x00 -; CHECK: .{{(zero|space)}} 13 -; CHECK: .quad {{\.?}}Lxray_sled_1 -; CHECK: .quad {{_?}}callee -; CHECK: .byte 0x01 -; CHECK: .byte 0x01 -; CHECK: .byte 0x00 -; CHECK: .{{(zero|space)}} 13 +; CHECK: .quad {{\.?}}Lxray_sled_0 +; CHECK: .quad {{_?}}callee +; CHECK: .byte 3 +; CHECK: .byte 1 +; CHECK: .{{(zero|space)}} 14 +; CHECK: .quad {{\.?}}Lxray_sled_1 +; CHECK: .quad {{_?}}callee +; CHECK: .byte 1 +; CHECK: .byte 1 +; CHECK: .{{(zero|space)}} 14 define i32 @caller(i32 %arg) nounwind noinline uwtable "function-instrument"="xray-always" "xray-log-args"="1" { %retval = tail call i32 @callee(i32 %arg) ret i32 %retval } ; CHECK-LABEL: Lxray_sleds_start1: -; CHECK: .quad {{\.?}}Lxray_sled_2 -; CHECK: .quad {{_?}}caller -; CHECK: .byte 0x03 -; CHECK: .byte 0x01 -; CHECK: .byte 0x00 -; CHECK: .{{(zero|space)}} 13 -; CHECK: .quad {{\.?}}Lxray_sled_3 -; CHECK: .quad {{_?}}caller -; CHECK: .byte 0x02 -; CHECK: .byte 0x01 -; CHECK: .byte 0x00 -; CHECK: .{{(zero|space)}} 13 +; CHECK: .quad {{\.?}}Lxray_sled_2 +; CHECK: .quad {{_?}}caller +; CHECK: .byte 3 +; CHECK: .byte 1 +; CHECK: .{{(zero|space)}} 14 +; CHECK: .quad {{\.?}}Lxray_sled_3 +; CHECK: .quad {{_?}}caller +; CHECK: .byte 2 +; CHECK: .byte 1 +; CHECK: .{{(zero|space)}} 14 diff --git a/llvm/test/CodeGen/X86/xray-loop-detection.ll b/llvm/test/CodeGen/X86/xray-loop-detection.ll index 12904d76770b..3cd6b4aa6f8c 100644 --- a/llvm/test/CodeGen/X86/xray-loop-detection.ll +++ b/llvm/test/CodeGen/X86/xray-loop-detection.ll @@ -19,4 +19,5 @@ Exit: ; CHECK-LABEL: xray_sled_0: ; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp0: diff --git a/llvm/test/CodeGen/X86/xray-section-group.ll b/llvm/test/CodeGen/X86/xray-section-group.ll index a4c45a0893ef..7dab8c2ebf77 100644 --- a/llvm/test/CodeGen/X86/xray-section-group.ll +++ b/llvm/test/CodeGen/X86/xray-section-group.ll @@ -5,14 +5,14 @@ define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .section .text.foo,"ax",@progbits ret i32 0 -; CHECK: .section xray_instr_map,"awo",@progbits,.text.foo,unique,1 +; CHECK: .section xray_instr_map,"a",@progbits } $bar = comdat any define i32 @bar() nounwind noinline uwtable "function-instrument"="xray-always" comdat($bar) { ; CHECK: .section .text.bar,"axG",@progbits,bar,comdat ret i32 1 -; CHECK: .section xray_instr_map,"aGwo",@progbits,bar,comdat,.text.bar,unique,2 +; CHECK: .section xray_instr_map,"aG",@progbits,bar,comdat } ; CHECK-OBJ: section xray_instr_map: diff --git a/llvm/test/CodeGen/X86/xray-tail-call-sled.ll b/llvm/test/CodeGen/X86/xray-tail-call-sled.ll index 59ab8ea5995b..c4a973e529f4 100644 --- a/llvm/test/CodeGen/X86/xray-tail-call-sled.ll +++ b/llvm/test/CodeGen/X86/xray-tail-call-sled.ll @@ -4,41 +4,49 @@ define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_0: -; CHECK: .ascii "\353\t" +; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp0: ret i32 0 ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_1: -; CHECK: retq +; CHECK-NEXT: retq ; CHECK-NEXT: nopw %cs:512(%rax,%rax) } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4, 0x90 +; CHECK-NEXT: .quad {{.*}}xray_fn_idx_synth_0{{.*}} +; CHECK-NEXT: .section {{.*}}xray_instr_map ; CHECK-LABEL: Lxray_sleds_start0: ; CHECK: .quad {{.*}}xray_sled_0 ; CHECK: .quad {{.*}}xray_sled_1 ; CHECK-LABEL: Lxray_sleds_end0: -; CHECK-LABEL: xray_fn_idx +; CHECK-NEXT: .section {{.*}}xray_fn_idx +; CHECK-LABEL: Lxray_fn_idx_synth_0: ; CHECK: .quad {{.*}}xray_sleds_start0 ; CHECK-NEXT: .quad {{.*}}xray_sleds_end0 define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" { ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_2: -; CHECK: .ascii "\353\t" +; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp1: ; CHECK: .p2align 1, 0x90 ; CHECK-LABEL: Lxray_sled_3: ; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: nopw 512(%rax,%rax) +; CHECK-LABEL: Ltmp2: %retval = tail call i32 @callee() ; CHECK: jmp {{.*}}callee {{.*}}# TAILCALL ret i32 %retval } -; CHECK-LABEL: xray_instr_map +; CHECK: .p2align 4, 0x90 +; CHECK-NEXT: .quad {{.*}}xray_fn_idx_synth_1{{.*}} ; CHECK-LABEL: Lxray_sleds_start1: ; CHECK: .quad {{.*}}xray_sled_2 ; CHECK: .quad {{.*}}xray_sled_3 ; CHECK-LABEL: Lxray_sleds_end1: -; CHECK-LABEL: xray_fn_idx +; CHECK: .section {{.*}}xray_fn_idx +; CHECK-LABEL: Lxray_fn_idx_synth_1: ; CHECK: .quad {{.*}}xray_sleds_start1 ; CHECK: .quad {{.*}}xray_sleds_end1