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" 38#include "llvm/CodeGen/MachineInstrBuilder.h" 39 40#define AVOIDCALL_DESC "X86 avoid trailing call pass" 41#define AVOIDCALL_NAME "x86-avoid-trailing-call" 42 43#define DEBUG_TYPE AVOIDCALL_NAME 44 45using namespace llvm; 46 47namespace { 48class X86AvoidTrailingCallPass : public MachineFunctionPass { 49public: 50 X86AvoidTrailingCallPass() : MachineFunctionPass(ID) {} 51 52 bool runOnMachineFunction(MachineFunction &MF) override; 53 54 static char ID; 55 56private: 57 StringRef getPassName() const override { return AVOIDCALL_DESC; } 58}; 59} // end anonymous namespace 60 61char X86AvoidTrailingCallPass::ID = 0; 62 63FunctionPass *llvm::createX86AvoidTrailingCallPass() { 64 return new X86AvoidTrailingCallPass(); 65} 66 67INITIALIZE_PASS(X86AvoidTrailingCallPass, AVOIDCALL_NAME, AVOIDCALL_DESC, false, false) 68 69// A real instruction is a non-meta, non-pseudo instruction. Some pseudos 70// expand to nothing, and some expand to code. This logic conservatively assumes 71// they might expand to nothing. 72static bool isRealInstruction(MachineInstr &MI) { 73 return !MI.isPseudo() && !MI.isMetaInstruction(); 74} 75 76// Return true if this is a call instruction, but not a tail call. 77static bool isCallInstruction(const MachineInstr &MI) { 78 return MI.isCall() && !MI.isReturn(); 79} 80 81bool X86AvoidTrailingCallPass::runOnMachineFunction(MachineFunction &MF) { 82 const X86Subtarget &STI = MF.getSubtarget<X86Subtarget>(); 83 const X86InstrInfo &TII = *STI.getInstrInfo(); 84 assert(STI.isTargetWin64() && "pass only runs on Win64"); 85 86 // We don't need to worry about any of the invariants described above if there 87 // is no unwind info (CFI). 88 if (!MF.hasWinCFI()) 89 return false; 90 91 // FIXME: Perhaps this pass should also replace SEH_Epilogue by inserting nops 92 // before epilogues. 93 94 bool Changed = false; 95 for (MachineBasicBlock &MBB : MF) { 96 // Look for basic blocks that precede funclet entries or are at the end of 97 // the function. 98 MachineBasicBlock *NextMBB = MBB.getNextNode(); 99 if (NextMBB && !NextMBB->isEHFuncletEntry()) 100 continue; 101 102 // Find the last real instruction in this block. 103 auto LastRealInstr = llvm::find_if(reverse(MBB), isRealInstruction); 104 105 // If the block is empty or the last real instruction is a call instruction, 106 // insert an int3. If there is a call instruction, insert the int3 between 107 // the call and any labels or other meta instructions. If the block is 108 // empty, insert at block end. 109 bool IsEmpty = LastRealInstr == MBB.rend(); 110 bool IsCall = !IsEmpty && isCallInstruction(*LastRealInstr); 111 if (IsEmpty || IsCall) { 112 LLVM_DEBUG({ 113 if (IsCall) { 114 dbgs() << "inserting int3 after trailing call instruction:\n"; 115 LastRealInstr->dump(); 116 dbgs() << '\n'; 117 } else { 118 dbgs() << "inserting int3 in trailing empty MBB:\n"; 119 MBB.dump(); 120 } 121 }); 122 123 MachineBasicBlock::iterator MBBI = MBB.end(); 124 DebugLoc DL; 125 if (IsCall) { 126 MBBI = std::next(LastRealInstr.getReverse()); 127 DL = LastRealInstr->getDebugLoc(); 128 } 129 BuildMI(MBB, MBBI, DL, TII.get(X86::INT3)); 130 Changed = true; 131 } 132 } 133 134 return Changed; 135} 136