1 //===-- XRayInstrumentation.cpp - Adds XRay instrumentation to functions. -===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements a MachineFunctionPass that inserts the appropriate
11 // XRay instrumentation instructions. We look for XRay-specific attributes
12 // on the function to determine whether we should insert the replacement
15 //===---------------------------------------------------------------------===//
17 #include "llvm/CodeGen/Analysis.h"
18 #include "llvm/CodeGen/MachineFunction.h"
19 #include "llvm/CodeGen/MachineFunctionPass.h"
20 #include "llvm/CodeGen/MachineInstrBuilder.h"
21 #include "llvm/CodeGen/Passes.h"
22 #include "llvm/Support/TargetRegistry.h"
23 #include "llvm/Target/TargetInstrInfo.h"
24 #include "llvm/Target/TargetSubtargetInfo.h"
29 struct XRayInstrumentation : public MachineFunctionPass {
32 XRayInstrumentation() : MachineFunctionPass(ID) {
33 initializeXRayInstrumentationPass(*PassRegistry::getPassRegistry());
36 bool runOnMachineFunction(MachineFunction &MF) override;
39 // Replace the original RET instruction with the exit sled code ("patchable
40 // ret" pseudo-instruction), so that at runtime XRay can replace the sled
41 // with a code jumping to XRay trampoline, which calls the tracing handler
42 // and, in the end, issues the RET instruction.
43 // This is the approach to go on CPUs which have a single RET instruction,
45 void replaceRetWithPatchableRet(MachineFunction &MF,
46 const TargetInstrInfo *TII);
48 // Prepend the original return instruction with the exit sled code ("patchable
49 // function exit" pseudo-instruction), preserving the original return
50 // instruction just after the exit sled code.
51 // This is the approach to go on CPUs which have multiple options for the
52 // return instruction, like ARM. For such CPUs we can't just jump into the
53 // XRay trampoline and issue a single return instruction there. We rather
54 // have to call the trampoline and return from it to the original return
55 // instruction of the function being instrumented.
56 void prependRetWithPatchableExit(MachineFunction &MF,
57 const TargetInstrInfo *TII);
59 } // anonymous namespace
61 void XRayInstrumentation::replaceRetWithPatchableRet(MachineFunction &MF,
62 const TargetInstrInfo *TII)
64 // We look for *all* terminators and returns, then replace those with
65 // PATCHABLE_RET instructions.
66 SmallVector<MachineInstr *, 4> Terminators;
67 for (auto &MBB : MF) {
68 for (auto &T : MBB.terminators()) {
70 if (T.isReturn() && T.getOpcode() == TII->getReturnOpcode()) {
71 // Replace return instructions with:
72 // PATCHABLE_RET <Opcode>, <Operand>...
73 Opc = TargetOpcode::PATCHABLE_RET;
75 if (TII->isTailCall(T)) {
76 // Treat the tail call as a return instruction, which has a
77 // different-looking sled than the normal return case.
78 Opc = TargetOpcode::PATCHABLE_TAIL_CALL;
81 auto MIB = BuildMI(MBB, T, T.getDebugLoc(), TII->get(Opc))
82 .addImm(T.getOpcode());
83 for (auto &MO : T.operands())
85 Terminators.push_back(&T);
90 for (auto &I : Terminators)
94 void XRayInstrumentation::prependRetWithPatchableExit(MachineFunction &MF,
95 const TargetInstrInfo *TII)
97 for (auto &MBB : MF) {
98 for (auto &T : MBB.terminators()) {
101 Opc = TargetOpcode::PATCHABLE_FUNCTION_EXIT;
103 if (TII->isTailCall(T)) {
104 Opc = TargetOpcode::PATCHABLE_TAIL_CALL;
107 // Prepend the return instruction with PATCHABLE_FUNCTION_EXIT or
108 // PATCHABLE_TAIL_CALL .
109 BuildMI(MBB, T, T.getDebugLoc(),TII->get(Opc));
115 bool XRayInstrumentation::runOnMachineFunction(MachineFunction &MF) {
116 auto &F = *MF.getFunction();
117 auto InstrAttr = F.getFnAttribute("function-instrument");
118 bool AlwaysInstrument = !InstrAttr.hasAttribute(Attribute::None) &&
119 InstrAttr.isStringAttribute() &&
120 InstrAttr.getValueAsString() == "xray-always";
121 Attribute Attr = F.getFnAttribute("xray-instruction-threshold");
122 unsigned XRayThreshold = 0;
123 if (!AlwaysInstrument) {
124 if (Attr.hasAttribute(Attribute::None) || !Attr.isStringAttribute())
125 return false; // XRay threshold attribute not found.
126 if (Attr.getValueAsString().getAsInteger(10, XRayThreshold))
127 return false; // Invalid value for threshold.
128 if (F.size() < XRayThreshold)
129 return false; // Function is too small.
132 // We look for the first non-empty MachineBasicBlock, so that we can insert
133 // the function instrumentation in the appropriate place.
135 find_if(MF, [&](const MachineBasicBlock &MBB) { return !MBB.empty(); });
137 return false; // The function is empty.
139 auto *TII = MF.getSubtarget().getInstrInfo();
140 auto &FirstMBB = *MBI;
141 auto &FirstMI = *FirstMBB.begin();
143 if (!MF.getSubtarget().isXRaySupported()) {
144 FirstMI.emitError("An attempt to perform XRay instrumentation for an"
145 " unsupported target.");
149 // FIXME: Do the loop triviality analysis here or in an earlier pass.
151 // First, insert an PATCHABLE_FUNCTION_ENTER as the first instruction of the
153 BuildMI(FirstMBB, FirstMI, FirstMI.getDebugLoc(),
154 TII->get(TargetOpcode::PATCHABLE_FUNCTION_ENTER));
156 switch (MF.getTarget().getTargetTriple().getArch()) {
157 case Triple::ArchType::arm:
158 case Triple::ArchType::thumb:
159 case Triple::ArchType::aarch64:
160 // For the architectures which don't have a single return instruction
161 prependRetWithPatchableExit(MF, TII);
164 // For the architectures that have a single return instruction (such as
166 replaceRetWithPatchableRet(MF, TII);
172 char XRayInstrumentation::ID = 0;
173 char &llvm::XRayInstrumentationID = XRayInstrumentation::ID;
174 INITIALIZE_PASS(XRayInstrumentation, "xray-instrumentation", "Insert XRay ops",