This is an archive of the discontinued LLVM Phabricator instance.

Differential D26983

[xray] Add XRay support for Mach-O in CodeGen
ClosedPublic

Authored by kubamracek on Nov 22 2016, 11:01 AM.

Details

Reviewers
dberris
kcc
rnk
Commits
rG06995e866be7: [xray] Add XRay support for Mach-O in CodeGen
rL287734: [xray] Add XRay support for Mach-O in CodeGen
Summary

Currently, XRay only supports emitting the XRay table (xray_instr_map) on ELF binaries. Let's add Mach-O support.

Diff Detail

Repository
rL LLVM

Event Timeline

kubamracek updated this revision to Diff 78897.Nov 22 2016, 11:01 AM
kubamracek retitled this revision from to [xray] Add XRay support for Mach-O in CodeGen.
kubamracek updated this object.
kubamracek added reviewers: dberris, rnk, kcc.
kubamracek set the repository for this revision to rL LLVM.
kubamracek added a subscriber: llvm-commits.
dberris accepted this revision.Nov 22 2016, 3:56 PM
dberris edited edge metadata.

LGTM -- thanks Kuba!

Just out of curiosity, you're also going to do the clang and compiler-rt side changes to support XRay for Mach-O supporting systems?

This revision is now accepted and ready to land.Nov 22 2016, 3:56 PM
kubamracek added a comment.Nov 22 2016, 4:04 PM
In D26983#603467, @dberris wrote:

LGTM -- thanks Kuba!

Just out of curiosity, you're also going to do the clang and compiler-rt side changes to support XRay for Mach-O supporting systems?

I don't have time to work on that now, but I have partial and ugly patches for compiler-rt and clang. I'll try to clean those and push the out when I get a chance to.

Closed by commit rL287734: [xray] Add XRay support for Mach-O in CodeGen (authored by kuba.brecka). · Explain WhyNov 22 2016, 6:17 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 79013

llvm/trunk/lib/Target/AArch64/AArch64AsmPrinter.cpp

Show All 33 Lines
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstBuilder.h" #include "llvm/MC/MCInstBuilder.h"
#include "llvm/MC/MCLinkerOptimizationHint.h" #include "llvm/MC/MCLinkerOptimizationHint.h"
#include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCSymbolELF.h" #include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/MCSectionELF.h" #include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace llvm; using namespace llvm;
#define DEBUG_TYPE "asm-printer" #define DEBUG_TYPE "asm-printer"
namespace { namespace {
▲ Show 20 Lines • Show All 100 Lines • ▼ Show 20 Lines
} }
void AArch64AsmPrinter::EmitXRayTable() void AArch64AsmPrinter::EmitXRayTable()
{ {
//TODO: merge the logic for ELF XRay sleds at a higher level, so to avoid //TODO: merge the logic for ELF XRay sleds at a higher level, so to avoid
// code duplication as it is now for x86_64, ARM32 and AArch64. // code duplication as it is now for x86_64, ARM32 and AArch64.
if (Sleds.empty()) if (Sleds.empty())
return; return;
if (STI->isTargetELF()) {
auto PrevSection = OutStreamer->getCurrentSectionOnly(); auto PrevSection = OutStreamer->getCurrentSectionOnly();
auto Fn = MF->getFunction(); auto Fn = MF->getFunction();
MCSection *Section; MCSection *Section;
if (STI->isTargetELF()) {
if (Fn->hasComdat()) if (Fn->hasComdat())
Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
ELF::SHF_ALLOC | ELF::SHF_GROUP, 0, ELF::SHF_ALLOC | ELF::SHF_GROUP, 0,
Fn->getComdat()->getName()); Fn->getComdat()->getName());
else else
Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
ELF::SHF_ALLOC); ELF::SHF_ALLOC);
} else if (STI->isTargetMachO()) {
Section = OutContext.getMachOSection("__DATA", "xray_instr_map", 0,
SectionKind::getReadOnlyWithRel());
} else {
llvm_unreachable("Unsupported target");
}
// Before we switch over, we force a reference to a label inside the // Before we switch over, we force a reference to a label inside the
// xray_instr_map section. Since EmitXRayTable() is always called just // xray_instr_map section. Since EmitXRayTable() is always called just
// before the function's end, we assume that this is happening after the // before the function's end, we assume that this is happening after the
// last return instruction. // last return instruction.
// //
// We then align the reference to 16 byte boundaries, which we determined // We then align the reference to 16 byte boundaries, which we determined
// experimentally to be beneficial to avoid causing decoder stalls. // experimentally to be beneficial to avoid causing decoder stalls.
MCSymbol *Tmp = OutContext.createTempSymbol("xray_synthetic_", true); MCSymbol *Tmp = OutContext.createTempSymbol("xray_synthetic_", true);
OutStreamer->EmitCodeAlignment(16); OutStreamer->EmitCodeAlignment(16);
OutStreamer->EmitSymbolValue(Tmp, 8, false); OutStreamer->EmitSymbolValue(Tmp, 8, false);
OutStreamer->SwitchSection(Section); OutStreamer->SwitchSection(Section);
OutStreamer->EmitLabel(Tmp); OutStreamer->EmitLabel(Tmp);
for (const auto &Sled : Sleds) { for (const auto &Sled : Sleds) {
OutStreamer->EmitSymbolValue(Sled.Sled, 8); OutStreamer->EmitSymbolValue(Sled.Sled, 8);
OutStreamer->EmitSymbolValue(CurrentFnSym, 8); OutStreamer->EmitSymbolValue(CurrentFnSym, 8);
auto Kind = static_cast<uint8_t>(Sled.Kind); auto Kind = static_cast<uint8_t>(Sled.Kind);
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Kind), 1)); StringRef(reinterpret_cast<const char *>(&Kind), 1));
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1)); StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1));
OutStreamer->EmitZeros(14); OutStreamer->EmitZeros(14);
} }
OutStreamer->SwitchSection(PrevSection); OutStreamer->SwitchSection(PrevSection);
}
Sleds.clear(); Sleds.clear();
} }
void AArch64AsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind) void AArch64AsmPrinter::EmitSled(const MachineInstr &MI, SledKind Kind)
{ {
static const int8_t NoopsInSledCount = 7; static const int8_t NoopsInSledCount = 7;
// We want to emit the following pattern: // We want to emit the following pattern:
// //
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/ARM/ARMMCInstLower.cpp

Show All 18 Lines
#include "llvm/CodeGen/MachineBasicBlock.h" #include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/Mangler.h" #include "llvm/IR/Mangler.h"
#include "llvm/MC/MCExpr.h" #include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCContext.h" #include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSymbolELF.h" #include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/MCSectionELF.h" #include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCInstBuilder.h" #include "llvm/MC/MCInstBuilder.h"
#include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCStreamer.h"
using namespace llvm; using namespace llvm;
MCOperand ARMAsmPrinter::GetSymbolRef(const MachineOperand &MO, MCOperand ARMAsmPrinter::GetSymbolRef(const MachineOperand &MO,
const MCSymbol *Symbol) { const MCSymbol *Symbol) {
const MCExpr *Expr = const MCExpr *Expr =
▲ Show 20 Lines • Show All 188 Lines • ▼ Show 20 Lines
{ {
EmitSled(MI, SledKind::TAIL_CALL); EmitSled(MI, SledKind::TAIL_CALL);
} }
void ARMAsmPrinter::EmitXRayTable() void ARMAsmPrinter::EmitXRayTable()
{ {
if (Sleds.empty()) if (Sleds.empty())
return; return;
MCSection *Section = nullptr;
if (Subtarget->isTargetELF()) { if (Subtarget->isTargetELF()) {
auto *Section = OutContext.getELFSection( Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
"xray_instr_map", ELF::SHT_PROGBITS, ELF::SHF_ALLOC | ELF::SHF_GROUP |
ELF::SHF_ALLOC | ELF::SHF_GROUP | ELF::SHF_MERGE, 0, ELF::SHF_MERGE,
CurrentFnSym->getName()); 0, CurrentFnSym->getName());
} else if (Subtarget->isTargetMachO()) {
Section = OutContext.getMachOSection("__DATA", "xray_instr_map", 0,
SectionKind::getReadOnlyWithRel());
} else {
llvm_unreachable("Unsupported target");
}
auto PrevSection = OutStreamer->getCurrentSectionOnly(); auto PrevSection = OutStreamer->getCurrentSectionOnly();
OutStreamer->SwitchSection(Section); OutStreamer->SwitchSection(Section);
for (const auto &Sled : Sleds) { for (const auto &Sled : Sleds) {
OutStreamer->EmitSymbolValue(Sled.Sled, 4); OutStreamer->EmitSymbolValue(Sled.Sled, 4);
OutStreamer->EmitSymbolValue(CurrentFnSym, 4); OutStreamer->EmitSymbolValue(CurrentFnSym, 4);
auto Kind = static_cast<uint8_t>(Sled.Kind); auto Kind = static_cast<uint8_t>(Sled.Kind);
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Kind), 1)); StringRef(reinterpret_cast<const char *>(&Kind), 1));
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1)); StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1));
OutStreamer->EmitZeros(6); OutStreamer->EmitZeros(6);
} }
OutStreamer->SwitchSection(PrevSection); OutStreamer->SwitchSection(PrevSection);
}
Sleds.clear(); Sleds.clear();
} }

llvm/trunk/lib/Target/X86/X86MCInstLower.cpp

Show All 35 Lines
#include "llvm/MC/MCFixup.h" #include "llvm/MC/MCFixup.h"
#include "llvm/MC/MCInst.h" #include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstBuilder.h" #include "llvm/MC/MCInstBuilder.h"
#include "llvm/MC/MCSection.h" #include "llvm/MC/MCSection.h"
#include "llvm/MC/MCStreamer.h" #include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h" #include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCSymbolELF.h" #include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/MCSectionELF.h" #include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/Support/TargetRegistry.h" #include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/ELF.h" #include "llvm/Support/ELF.h"
#include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetLoweringObjectFile.h"
using namespace llvm; using namespace llvm;
namespace { namespace {
▲ Show 20 Lines • Show All 1,059 Lines • ▼ Show 20 Lines for (auto &MO : make_range(MI.operands_begin() + 1, MI.operands_end()))
if (auto MaybeOperand = MCIL.LowerMachineOperand(&MI, MO)) if (auto MaybeOperand = MCIL.LowerMachineOperand(&MI, MO))
TC.addOperand(MaybeOperand.getValue()); TC.addOperand(MaybeOperand.getValue());
OutStreamer->EmitInstruction(TC, getSubtargetInfo()); OutStreamer->EmitInstruction(TC, getSubtargetInfo());
} }
void X86AsmPrinter::EmitXRayTable() { void X86AsmPrinter::EmitXRayTable() {
if (Sleds.empty()) if (Sleds.empty())
return; return;
if (Subtarget->isTargetELF()) {
auto PrevSection = OutStreamer->getCurrentSectionOnly(); auto PrevSection = OutStreamer->getCurrentSectionOnly();
auto Fn = MF->getFunction(); auto Fn = MF->getFunction();
MCSection *Section = nullptr; MCSection *Section = nullptr;
if (Subtarget->isTargetELF()) {
if (Fn->hasComdat()) { if (Fn->hasComdat()) {
Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
ELF::SHF_ALLOC | ELF::SHF_GROUP, 0, ELF::SHF_ALLOC | ELF::SHF_GROUP, 0,
Fn->getComdat()->getName()); Fn->getComdat()->getName());
} else { } else {
Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS, Section = OutContext.getELFSection("xray_instr_map", ELF::SHT_PROGBITS,
ELF::SHF_ALLOC); ELF::SHF_ALLOC);
} }
} else if (Subtarget->isTargetMachO()) {
Section = OutContext.getMachOSection("__DATA", "xray_instr_map", 0,
SectionKind::getReadOnlyWithRel());
} else {
llvm_unreachable("Unsupported target");
}
// Before we switch over, we force a reference to a label inside the // Before we switch over, we force a reference to a label inside the
// xray_instr_map section. Since EmitXRayTable() is always called just // xray_instr_map section. Since EmitXRayTable() is always called just
// before the function's end, we assume that this is happening after the // before the function's end, we assume that this is happening after the
// last return instruction. // last return instruction.
// //
// We then align the reference to 16 byte boundaries, which we determined // We then align the reference to 16 byte boundaries, which we determined
// experimentally to be beneficial to avoid causing decoder stalls. // experimentally to be beneficial to avoid causing decoder stalls.
MCSymbol *Tmp = OutContext.createTempSymbol("xray_synthetic_", true); MCSymbol *Tmp = OutContext.createTempSymbol("xray_synthetic_", true);
OutStreamer->EmitCodeAlignment(16); OutStreamer->EmitCodeAlignment(16);
OutStreamer->EmitSymbolValue(Tmp, 8, false); OutStreamer->EmitSymbolValue(Tmp, 8, false);
OutStreamer->SwitchSection(Section); OutStreamer->SwitchSection(Section);
OutStreamer->EmitLabel(Tmp); OutStreamer->EmitLabel(Tmp);
for (const auto &Sled : Sleds) { for (const auto &Sled : Sleds) {
OutStreamer->EmitSymbolValue(Sled.Sled, 8); OutStreamer->EmitSymbolValue(Sled.Sled, 8);
OutStreamer->EmitSymbolValue(CurrentFnSym, 8); OutStreamer->EmitSymbolValue(CurrentFnSym, 8);
auto Kind = static_cast<uint8_t>(Sled.Kind); auto Kind = static_cast<uint8_t>(Sled.Kind);
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Kind), 1)); StringRef(reinterpret_cast<const char *>(&Kind), 1));
OutStreamer->EmitBytes( OutStreamer->EmitBytes(
StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1)); StringRef(reinterpret_cast<const char *>(&Sled.AlwaysInstrument), 1));
OutStreamer->EmitZeros(14); OutStreamer->EmitZeros(14);
} }
OutStreamer->SwitchSection(PrevSection); OutStreamer->SwitchSection(PrevSection);
}
Sleds.clear(); Sleds.clear();
} }
// Returns instruction preceding MBBI in MachineFunction. // Returns instruction preceding MBBI in MachineFunction.
// If MBBI is the first instruction of the first basic block, returns null. // If MBBI is the first instruction of the first basic block, returns null.
static MachineBasicBlock::const_iterator static MachineBasicBlock::const_iterator
PrevCrossBBInst(MachineBasicBlock::const_iterator MBBI) { PrevCrossBBInst(MachineBasicBlock::const_iterator MBBI) {
const MachineBasicBlock *MBB = MBBI->getParent(); const MachineBasicBlock *MBB = MBBI->getParent();
▲ Show 20 Lines • Show All 615 Lines • Show Last 20 Lines

llvm/trunk/test/CodeGen/ARM/xray-armv6-attribute-instrumentation.ll

; RUN: llc -filetype=asm -o - -mtriple=armv6-unknown-linux-gnu < %s | FileCheck %s ; RUN: llc -filetype=asm -o - -mtriple=armv6-unknown-linux-gnu < %s | FileCheck %s
; RUN: llc -filetype=asm -o - -mtriple=armv6-apple-ios6.0.0 < %s | FileCheck %s
define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK-LABEL: Lxray_sled_0: ; CHECK-LABEL: Lxray_sled_0:
; CHECK-NEXT: b #20 ; CHECK-NEXT: b #20
; CHECK-NEXT: mov r0, r0 ; CHECK-NEXT: mov r0, r0
; CHECK-NEXT: mov r0, r0 ; CHECK-NEXT: mov r0, r0
; CHECK-NEXT: mov r0, r0 ; CHECK-NEXT: mov r0, r0
; CHECK-NEXT: mov r0, r0 ; CHECK-NEXT: mov r0, r0
Show All 15 Lines

llvm/trunk/test/CodeGen/ARM/xray-armv7-attribute-instrumentation.ll

; RUN: llc -filetype=asm -o - -mtriple=armv7-unknown-linux-gnu < %s | FileCheck %s ; RUN: llc -filetype=asm -o - -mtriple=armv7-unknown-linux-gnu < %s | FileCheck %s
; RUN: llc -filetype=asm -o - -mtriple=armv7-apple-ios6.0.0 < %s | FileCheck %s
define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK-LABEL: Lxray_sled_0: ; CHECK-LABEL: Lxray_sled_0:
; CHECK-NEXT: b #20 ; CHECK-NEXT: b #20
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
Show All 15 Lines

llvm/trunk/test/CodeGen/ARM/xray-tail-call-sled.ll

; RUN: llc -filetype=asm -o - -mtriple=armv7-unknown-linux-gnu < %s | FileCheck %s ; RUN: llc -filetype=asm -o - -mtriple=armv7-unknown-linux-gnu < %s | FileCheck %s
; RUN: llc -filetype=asm -o - -mtriple=armv7-apple-ios6.0.0 < %s | FileCheck %s
define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK: .p2align 2 ; CHECK: .p2align 2
; CHECK-LABEL: Lxray_sled_0: ; CHECK-LABEL: Lxray_sled_0:
; CHECK-NEXT: b #20 ; CHECK-NEXT: b #20
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
Show All 33 Lines
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-NEXT: nop ; CHECK-NEXT: nop
; CHECK-LABEL: Ltmp3: ; CHECK-LABEL: Ltmp3:
%retval = tail call i32 @callee() %retval = tail call i32 @callee()
; CHECK: b callee ; CHECK: b {{.*}}callee
ret i32 %retval ret i32 %retval
} }

llvm/trunk/test/CodeGen/X86/xray-attribute-instrumentation.ll

; 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 < %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" { define i32 @foo() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_0: ; CHECK-LABEL: Lxray_sled_0:
; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: .ascii "\353\t"
; CHECK-NEXT: nopw 512(%rax,%rax) ; CHECK-NEXT: nopw 512(%rax,%rax)
; CHECK-LABEL: Ltmp0: ; CHECK-LABEL: Ltmp0:
ret i32 0 ret i32 0
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_1: ; CHECK-LABEL: Lxray_sled_1:
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; CHECK-NEXT: nopw %cs:512(%rax,%rax) ; CHECK-NEXT: nopw %cs:512(%rax,%rax)
} }
; CHECK: .p2align 4, 0x90 ; CHECK: .p2align 4, 0x90
; CHECK-NEXT: .quad .Lxray_synthetic_0 ; CHECK-NEXT: .quad {{.*}}xray_synthetic_0
; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-NEXT: .section {{.*}}xray_instr_map
; CHECK-LABEL: Lxray_synthetic_0: ; CHECK-LABEL: Lxray_synthetic_0:
; CHECK: .quad .Lxray_sled_0 ; CHECK: .quad {{.*}}xray_sled_0
; CHECK: .quad .Lxray_sled_1 ; CHECK: .quad {{.*}}xray_sled_1
; We test multiple returns in a single function to make sure we're getting all ; We test multiple returns in a single function to make sure we're getting all
; of them with XRay instrumentation. ; of them with XRay instrumentation.
define i32 @bar(i32 %i) nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @bar(i32 %i) nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_2: ; CHECK-LABEL: Lxray_sled_2:
; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: .ascii "\353\t"
; CHECK-NEXT: nopw 512(%rax,%rax) ; CHECK-NEXT: nopw 512(%rax,%rax)
Show All 10 Lines
NotEqual: NotEqual:
ret i32 1 ret i32 1
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_4: ; CHECK-LABEL: Lxray_sled_4:
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; CHECK-NEXT: nopw %cs:512(%rax,%rax) ; CHECK-NEXT: nopw %cs:512(%rax,%rax)
} }
; CHECK: .p2align 4, 0x90 ; CHECK: .p2align 4, 0x90
; CHECK-NEXT: .quad .Lxray_synthetic_1 ; CHECK-NEXT: .quad {{.*}}xray_synthetic_1
; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-NEXT: .section {{.*}}xray_instr_map
; CHECK-LABEL: Lxray_synthetic_1: ; CHECK-LABEL: Lxray_synthetic_1:
; CHECK: .quad .Lxray_sled_2 ; CHECK: .quad {{.*}}xray_sled_2
; CHECK: .quad .Lxray_sled_3 ; CHECK: .quad {{.*}}xray_sled_3
; CHECK: .quad .Lxray_sled_4 ; CHECK: .quad {{.*}}xray_sled_4

llvm/trunk/test/CodeGen/X86/xray-tail-call-sled.ll

; 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 < %s | FileCheck %s
; RUN: llc -filetype=asm -o - -mtriple=x86_64-darwin-unknown < %s | FileCheck %s
define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @callee() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_0: ; CHECK-LABEL: Lxray_sled_0:
; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: .ascii "\353\t"
; CHECK-NEXT: nopw 512(%rax,%rax) ; CHECK-NEXT: nopw 512(%rax,%rax)
; CHECK-LABEL: Ltmp0: ; CHECK-LABEL: Ltmp0:
ret i32 0 ret i32 0
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_1: ; CHECK-LABEL: Lxray_sled_1:
; CHECK-NEXT: retq ; CHECK-NEXT: retq
; CHECK-NEXT: nopw %cs:512(%rax,%rax) ; CHECK-NEXT: nopw %cs:512(%rax,%rax)
} }
; CHECK: .p2align 4, 0x90 ; CHECK: .p2align 4, 0x90
; CHECK-NEXT: .quad .Lxray_synthetic_0 ; CHECK-NEXT: .quad {{.*}}xray_synthetic_0
; CHECK-NEXT: .section xray_instr_map,{{.*}} ; CHECK-NEXT: .section {{.*}}xray_instr_map
; CHECK-LABEL: Lxray_synthetic_0: ; CHECK-LABEL: Lxray_synthetic_0:
; CHECK: .quad .Lxray_sled_0 ; CHECK: .quad {{.*}}xray_sled_0
; CHECK: .quad .Lxray_sled_1 ; CHECK: .quad {{.*}}xray_sled_1
define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" { define i32 @caller() nounwind noinline uwtable "function-instrument"="xray-always" {
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_2: ; CHECK-LABEL: Lxray_sled_2:
; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: .ascii "\353\t"
; CHECK-NEXT: nopw 512(%rax,%rax) ; CHECK-NEXT: nopw 512(%rax,%rax)
; CHECK-LABEL: Ltmp1: ; CHECK-LABEL: Ltmp1:
; CHECK: .p2align 1, 0x90 ; CHECK: .p2align 1, 0x90
; CHECK-LABEL: Lxray_sled_3: ; CHECK-LABEL: Lxray_sled_3:
; CHECK-NEXT: .ascii "\353\t" ; CHECK-NEXT: .ascii "\353\t"
; CHECK-NEXT: nopw 512(%rax,%rax) ; CHECK-NEXT: nopw 512(%rax,%rax)
; CHECK-LABEL: Ltmp2: ; CHECK-LABEL: Ltmp2:
%retval = tail call i32 @callee() %retval = tail call i32 @callee()
; CHECK: jmp callee # TAILCALL ; CHECK: jmp {{.*}}callee {{.*}}# TAILCALL
ret i32 %retval ret i32 %retval
} }
; CHECK: .p2align 4, 0x90 ; CHECK: .p2align 4, 0x90
; CHECK-NEXT: .quad .Lxray_synthetic_1 ; CHECK-NEXT: .quad {{.*}}xray_synthetic_1
; CHECK-LABEL: Lxray_synthetic_1: ; CHECK-LABEL: Lxray_synthetic_1:
; CHECK: .quad .Lxray_sled_2 ; CHECK: .quad {{.*}}xray_sled_2
; CHECK: .quad .Lxray_sled_3 ; CHECK: .quad {{.*}}xray_sled_3