LLVM 19.0.0git
X86AvoidTrailingCall.cpp
Go to the documentation of this file.
1//===----- X86AvoidTrailingCall.cpp - Insert int3 after trailing calls ----===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// The Windows x64 unwinder decodes the instruction stream during unwinding.
10// The unwinder decodes forward from the current PC to detect epilogue code
11// patterns.
12//
13// First, this means that there must be an instruction after every
14// call instruction for the unwinder to decode. LLVM must maintain the invariant
15// that the last instruction of a function or funclet is not a call, or the
16// unwinder may decode into the next function. Similarly, a call may not
17// immediately precede an epilogue code pattern. As of this writing, the
18// SEH_Epilogue pseudo instruction takes care of that.
19//
20// Second, all non-tail call jump targets must be within the *half-open*
21// interval of the bounds of the function. The unwinder distinguishes between
22// internal jump instructions and tail calls in an epilogue sequence by checking
23// the jump target against the function bounds from the .pdata section. This
24// means that the last regular MBB of an LLVM function must not be empty if
25// there are regular jumps targeting it.
26//
27// This pass upholds these invariants by ensuring that blocks at the end of a
28// function or funclet are a) not empty and b) do not end in a CALL instruction.
29//
30// Unwinder implementation for reference:
31// https://github.com/dotnet/coreclr/blob/a9f3fc16483eecfc47fb79c362811d870be02249/src/unwinder/amd64/unwinder_amd64.cpp#L1015
32//
33//===----------------------------------------------------------------------===//
34
35#include "X86.h"
36#include "X86InstrInfo.h"
37#include "X86Subtarget.h"
40
41#define AVOIDCALL_DESC "X86 avoid trailing call pass"
42#define AVOIDCALL_NAME "x86-avoid-trailing-call"
43
44#define DEBUG_TYPE AVOIDCALL_NAME
45
46using namespace llvm;
47
48namespace {
49class X86AvoidTrailingCallPass : public MachineFunctionPass {
50public:
51 X86AvoidTrailingCallPass() : MachineFunctionPass(ID) {}
52
53 bool runOnMachineFunction(MachineFunction &MF) override;
54
55 static char ID;
56
57private:
58 StringRef getPassName() const override { return AVOIDCALL_DESC; }
59};
60} // end anonymous namespace
61
62char X86AvoidTrailingCallPass::ID = 0;
63
65 return new X86AvoidTrailingCallPass();
66}
67
68INITIALIZE_PASS(X86AvoidTrailingCallPass, AVOIDCALL_NAME, AVOIDCALL_DESC, false, false)
69
70// A real instruction is a non-meta, non-pseudo instruction. Some pseudos
71// expand to nothing, and some expand to code. This logic conservatively assumes
72// they might expand to nothing.
74 return MI.isCall() || (!MI.isPseudo() && !MI.isMetaInstruction());
75}
76
77// Return true if this is a call instruction, but not a tail call.
78static bool isCallInstruction(const MachineInstr &MI) {
79 return MI.isCall() && !MI.isReturn();
80}
81
82bool X86AvoidTrailingCallPass::runOnMachineFunction(MachineFunction &MF) {
83 const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>();
84 const X86InstrInfo &TII = *STI.getInstrInfo();
85 assert(STI.isTargetWin64() && "pass only runs on Win64");
86
87 // We don't need to worry about any of the invariants described above if there
88 // is no unwind info (CFI).
89 if (!MF.hasWinCFI())
90 return false;
91
92 // FIXME: Perhaps this pass should also replace SEH_Epilogue by inserting nops
93 // before epilogues.
94
95 bool Changed = false;
96 for (MachineBasicBlock &MBB : MF) {
97 // Look for basic blocks that precede funclet entries or are at the end of
98 // the function.
100 if (NextMBB && !NextMBB->isEHFuncletEntry())
101 continue;
102
103 // Find the last real instruction in this block.
104 auto LastRealInstr = llvm::find_if(reverse(MBB), isCallOrRealInstruction);
105
106 // If the block is empty or the last real instruction is a call instruction,
107 // insert an int3. If there is a call instruction, insert the int3 between
108 // the call and any labels or other meta instructions. If the block is
109 // empty, insert at block end.
110 bool IsEmpty = LastRealInstr == MBB.rend();
111 bool IsCall = !IsEmpty && isCallInstruction(*LastRealInstr);
112 if (IsEmpty || IsCall) {
113 LLVM_DEBUG({
114 if (IsCall) {
115 dbgs() << "inserting int3 after trailing call instruction:\n";
116 LastRealInstr->dump();
117 dbgs() << '\n';
118 } else {
119 dbgs() << "inserting int3 in trailing empty MBB:\n";
120 MBB.dump();
121 }
122 });
123
125 DebugLoc DL;
126 if (IsCall) {
127 MBBI = std::next(LastRealInstr.getReverse());
128 DL = LastRealInstr->getDebugLoc();
129 }
130 BuildMI(MBB, MBBI, DL, TII.get(X86::INT3));
131 Changed = true;
132 }
133 }
134
135 return Changed;
136}
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
#define LLVM_DEBUG(X)
Definition: Debug.h:101
const HexagonInstrInfo * TII
IRTranslator LLVM IR MI
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:38
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static bool isCallOrRealInstruction(MachineInstr &MI)
#define AVOIDCALL_NAME
static bool isCallInstruction(const MachineInstr &MI)
#define AVOIDCALL_DESC
A debug info location.
Definition: DebugLoc.h:33
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:311
reverse_iterator rend()
bool isEHFuncletEntry() const
Returns true if this is the entry block of an EH funclet.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
virtual bool runOnMachineFunction(MachineFunction &MF)=0
runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
Representation of each machine instruction.
Definition: MachineInstr.h:69
virtual StringRef getPassName() const
getPassName - Return a nice clean name for a pass.
Definition: Pass.cpp:81
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
bool isTargetWin64() const
Definition: X86Subtarget.h:336
const X86InstrInfo * getInstrInfo() const override
Definition: X86Subtarget.h:129
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:316
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
auto reverse(ContainerTy &&C)
Definition: STLExtras.h:419
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
FunctionPass * createX86AvoidTrailingCallPass()
Return a pass that inserts int3 at the end of the function if it ends with a CALL instruction.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1749