mirror of
https://github.com/RPCS3/llvm.git
synced 2025-04-08 08:21:54 +00:00
d17ccfb980
Summary: This change promotes the 'isTailCall(...)' member function to TargetInstrInfo as a query interface for determining on a per-target basis whether a given MachineInstr is a tail call instruction. We build upon this in the XRay instrumentation pass to emit special sleds for tail call optimisations, where we emit the correct kind of sled. The tail call sleds look like a mix between the function entry and function exit sleds. Form-wise, the sled comes before the "jmp" instruction that implements the tail call similar to how we do it for the function entry sled. Functionally, because we know this is a tail call, it behaves much like an exit sled -- i.e. at runtime we may use the exit trampolines instead of a different kind of trampoline. A follow-up change to recognise these sleds will be done in compiler-rt, so that we can start intercepting these initially as exits, but also have the option to have different log entries to more accurately reflect that this is actually a tail call. Reviewers: echristo, rSerge, majnemer Subscribers: mehdi_amini, dberris, llvm-commits Differential Revision: https://reviews.llvm.org/D23986 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@280334 91177308-0d34-0410-b5e6-96231b3b80d8
103 lines
3.7 KiB
C++
103 lines
3.7 KiB
C++
//===-- XRayInstrumentation.cpp - Adds XRay instrumentation to functions. -===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements a MachineFunctionPass that inserts the appropriate
|
|
// XRay instrumentation instructions. We look for XRay-specific attributes
|
|
// on the function to determine whether we should insert the replacement
|
|
// operations.
|
|
//
|
|
//===---------------------------------------------------------------------===//
|
|
|
|
#include "llvm/CodeGen/Analysis.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
#include "llvm/CodeGen/Passes.h"
|
|
#include "llvm/Support/TargetRegistry.h"
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
struct XRayInstrumentation : public MachineFunctionPass {
|
|
static char ID;
|
|
|
|
XRayInstrumentation() : MachineFunctionPass(ID) {
|
|
initializeXRayInstrumentationPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
|
};
|
|
}
|
|
|
|
bool XRayInstrumentation::runOnMachineFunction(MachineFunction &MF) {
|
|
auto &F = *MF.getFunction();
|
|
auto InstrAttr = F.getFnAttribute("function-instrument");
|
|
bool AlwaysInstrument = !InstrAttr.hasAttribute(Attribute::None) &&
|
|
InstrAttr.isStringAttribute() &&
|
|
InstrAttr.getValueAsString() == "xray-always";
|
|
Attribute Attr = F.getFnAttribute("xray-instruction-threshold");
|
|
unsigned XRayThreshold = 0;
|
|
if (!AlwaysInstrument) {
|
|
if (Attr.hasAttribute(Attribute::None) || !Attr.isStringAttribute())
|
|
return false; // XRay threshold attribute not found.
|
|
if (Attr.getValueAsString().getAsInteger(10, XRayThreshold))
|
|
return false; // Invalid value for threshold.
|
|
if (F.size() < XRayThreshold)
|
|
return false; // Function is too small.
|
|
}
|
|
|
|
// FIXME: Do the loop triviality analysis here or in an earlier pass.
|
|
|
|
// First, insert an PATCHABLE_FUNCTION_ENTER as the first instruction of the
|
|
// MachineFunction.
|
|
auto &FirstMBB = *MF.begin();
|
|
auto &FirstMI = *FirstMBB.begin();
|
|
auto *TII = MF.getSubtarget().getInstrInfo();
|
|
BuildMI(FirstMBB, FirstMI, FirstMI.getDebugLoc(),
|
|
TII->get(TargetOpcode::PATCHABLE_FUNCTION_ENTER));
|
|
|
|
// Then we look for *all* terminators and returns, then replace those with
|
|
// PATCHABLE_RET instructions.
|
|
SmallVector<MachineInstr *, 4> Terminators;
|
|
for (auto &MBB : MF) {
|
|
for (auto &T : MBB.terminators()) {
|
|
unsigned Opc = 0;
|
|
if (T.isReturn() && T.getOpcode() == TII->getReturnOpcode()) {
|
|
// Replace return instructions with:
|
|
// PATCHABLE_RET <Opcode>, <Operand>...
|
|
Opc = TargetOpcode::PATCHABLE_RET;
|
|
}
|
|
if (TII->isTailCall(T)) {
|
|
// Treat the tail call as a return instruction, which has a
|
|
// different-looking sled than the normal return case.
|
|
Opc = TargetOpcode::PATCHABLE_TAIL_CALL;
|
|
}
|
|
if (Opc != 0) {
|
|
auto MIB = BuildMI(MBB, T, T.getDebugLoc(), TII->get(Opc))
|
|
.addImm(T.getOpcode());
|
|
for (auto &MO : T.operands())
|
|
MIB.addOperand(MO);
|
|
Terminators.push_back(&T);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (auto &I : Terminators)
|
|
I->eraseFromParent();
|
|
|
|
return true;
|
|
}
|
|
|
|
char XRayInstrumentation::ID = 0;
|
|
char &llvm::XRayInstrumentationID = XRayInstrumentation::ID;
|
|
INITIALIZE_PASS(XRayInstrumentation, "xray-instrumentation", "Insert XRay ops",
|
|
false, false)
|