summaryrefslogtreecommitdiffstats
path: root/llvm/lib
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib')
-rw-r--r--llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp53
-rw-r--r--llvm/lib/Target/X86/X86MCInstLower.cpp73
2 files changed, 63 insertions, 63 deletions
diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
index 5e002e70929..87399354945 100644
--- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp
@@ -2767,10 +2767,13 @@ void AsmPrinter::XRayFunctionEntry::emit(int Bytes, MCStreamer *Out,
Out->EmitSymbolValue(Sled, Bytes);
Out->EmitSymbolValue(CurrentFnSym, Bytes);
auto Kind8 = static_cast<uint8_t>(Kind);
- Out->EmitBytes(StringRef(reinterpret_cast<const char *>(&Kind8), 1));
- Out->EmitBytes(
+ Out->EmitBinaryData(StringRef(reinterpret_cast<const char *>(&Kind8), 1));
+ Out->EmitBinaryData(
StringRef(reinterpret_cast<const char *>(&AlwaysInstrument), 1));
- Out->EmitZeros(2 * Bytes - 2); // Pad the previous two entries
+ Out->EmitBinaryData(StringRef(reinterpret_cast<const char *>(&Version), 1));
+ auto Padding = (4 * Bytes) - ((2 * Bytes) + 3);
+ assert(Padding >= 0 && "Instrumentation map entry > 4 * Word Size");
+ Out->EmitZeros(Padding);
}
void AsmPrinter::emitXRayTable() {
@@ -2782,19 +2785,22 @@ void AsmPrinter::emitXRayTable() {
MCSection *InstMap = nullptr;
MCSection *FnSledIndex = nullptr;
if (MF->getSubtarget().getTargetTriple().isOSBinFormatELF()) {
+ auto Associated = dyn_cast<MCSymbolELF>(PrevSection->getBeginSymbol());
+ assert(Associated != nullptr);
+ auto Flags = ELF::SHF_WRITE | ELF::SHF_ALLOC | ELF::SHF_LINK_ORDER;
+ std::string GroupName;
if (Fn->hasComdat()) {
- 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);
+ Flags |= ELF::SHF_GROUP;
+ GroupName = Fn->getComdat()->getName();
}
+
+ 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());
@@ -2804,15 +2810,7 @@ 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
@@ -2831,15 +2829,14 @@ void AsmPrinter::emitXRayTable() {
// pointers. This should work for both 32-bit and 64-bit platforms.
OutStreamer->SwitchSection(FnSledIndex);
OutStreamer->EmitCodeAlignment(2 * WordSizeBytes);
- OutStreamer->EmitLabel(IdxRef);
- OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes);
- OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes);
+ OutStreamer->EmitSymbolValue(SledsStart, WordSizeBytes, false);
+ OutStreamer->EmitSymbolValue(SledsEnd, WordSizeBytes, false);
OutStreamer->SwitchSection(PrevSection);
Sleds.clear();
}
void AsmPrinter::recordSled(MCSymbol *Sled, const MachineInstr &MI,
- SledKind Kind) {
+ SledKind Kind, uint8_t Version) {
auto Fn = MI.getParent()->getParent()->getFunction();
auto Attr = Fn->getFnAttribute("function-instrument");
bool LogArgs = Fn->hasFnAttribute("xray-log-args");
@@ -2847,8 +2844,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 });
+ Sleds.emplace_back(XRayFunctionEntry{Sled, CurrentFnSym, Kind,
+ AlwaysInstrument, Fn, Version});
}
uint16_t AsmPrinter::getDwarfVersion() const {
diff --git a/llvm/lib/Target/X86/X86MCInstLower.cpp b/llvm/lib/Target/X86/X86MCInstLower.cpp
index fd2837b7910..3ee1cf710c8 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.
//
- // <args placement according SysV64 calling convention>
// .p2align 1, ...
// .Lxray_event_sled_N:
- // jmp +N // jump across the call instruction
- // callq __xray_CustomEvent // force relocation to symbol
- // <args cleanup, jump to here>
- //
- // The relative jump needs to jump forward 24 bytes:
- // 10 (args) + 5 (nops) + 9 (cleanup)
+ // jmp +N // jump across the instrumentation sled
+ // ... // set up arguments in register
+ // callq __xray_CustomEvent // force dependency to symbol
+ // ...
+ // <jump here>
//
// After patching, it would look something like:
//
// nopw (2-byte nop)
+ // ...
// callq __xrayCustomEvent // already lowered
+ // ...
//
// ---
// First we emit the label and the jump.
@@ -1072,49 +1072,55 @@ 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->EmitBytes("\xeb\x14");
+ OutStreamer->EmitBinaryData("\xeb\x0f");
// 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, X86::RAX};
-
- // 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.
+ unsigned UsedRegs[] = {X86::RDI, X86::RSI};
+ bool UsedMask[] = {false, false};
+
+ // 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.
for (unsigned I = 0; I < MI.getNumOperands(); ++I)
if (auto Op = MCIL.LowerMachineOperand(&MI, MI.getOperand(I))) {
- if (Op->isImm())
- EmitAndCountInstruction(MCInstBuilder(X86::MOV64ri)
+ 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)
.addReg(UsedRegs[I])
- .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());
+ .addReg(Op->getReg()));
+ } else {
+ EmitNops(*OutStreamer, 4, 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. We put this
- // explicitly in the %rax register.
+ // name of the trampoline to be implemented by the XRay runtime.
auto TSym = OutContext.getOrCreateSymbol("__xray_CustomEvent");
MachineOperand TOp = MachineOperand::CreateMCSymbol(TSym);
- EmitAndCountInstruction(MCInstBuilder(X86::MOV64ri)
- .addReg(X86::RAX)
- .addOperand(MCIL.LowerSymbolOperand(TOp, TSym)));
// Emit the call instruction.
- EmitAndCountInstruction(MCInstBuilder(X86::CALL64r).addReg(X86::RAX));
+ EmitAndCountInstruction(MCInstBuilder(X86::CALL64pcrel32)
+ .addOperand(MCIL.LowerSymbolOperand(TOp, TSym)));
// 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));
- recordSled(CurSled, MI, SledKind::CUSTOM_EVENT);
+ // 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);
}
void X86AsmPrinter::LowerPATCHABLE_FUNCTION_ENTER(const MachineInstr &MI,
@@ -1125,7 +1131,6 @@ 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:
@@ -1136,14 +1141,12 @@ 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);
}
OpenPOWER on IntegriCloud