================ @@ -0,0 +1,243 @@ +//===---- X86FixupStackProtector.cpp Fix Stack Protector Call ----------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// Stack Protector implementation inserts platform specific callback into code. +// For windows __security_check_cookie call gets call everytime function is +// return without fixup. Since this function is defined in runtime library, it +// incures cost of call in dll which simply does comparison and returns most +// time. With Fixup, We selective move to call in DLL only if comparison fails. +//===----------------------------------------------------------------------===// + +#include "X86.h" +#include "X86FrameLowering.h" +#include "X86InstrInfo.h" +#include "X86Subtarget.h" +#include "llvm/CodeGen/LivePhysRegs.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineInstrBuilder.h" +#include "llvm/CodeGen/MachineRegisterInfo.h" +#include "llvm/IR/Module.h" +#include <iterator> + +using namespace llvm; + +#define DEBUG_TYPE "x86-fixup-spcall" + +namespace { + +class X86FixupStackProtectorPass : public MachineFunctionPass { +public: + static char ID; + + X86FixupStackProtectorPass() : MachineFunctionPass(ID) {} + + StringRef getPassName() const override { return "X86 Fixup Stack Protector"; } + + bool runOnMachineFunction(MachineFunction &MF) override; + + std::pair<MachineBasicBlock *, MachineInstr *> + getSecurityCheckerBasicBlock(MachineFunction &MF); + + void getGuardCheckSequence(MachineBasicBlock *CurMBB, MachineInstr *CheckCall, + MachineInstr *SeqMI[5]); + + void SplitBasicBlock(MachineBasicBlock *CurMBB, MachineBasicBlock *NewRetMBB, + MachineBasicBlock::iterator SplitIt); + + void FinishBlock(MachineBasicBlock *MBB); + + void FinishFunction(MachineBasicBlock *FailMBB, MachineBasicBlock *NewRetMBB); + + std::pair<MachineInstr *, MachineInstr *> + CreateFailCheckSequence(MachineBasicBlock *CurMBB, MachineBasicBlock *FailMBB, + MachineInstr *SeqMI[5]); +}; +} // end anonymous namespace + +char X86FixupStackProtectorPass::ID = 0; + +INITIALIZE_PASS(X86FixupStackProtectorPass, DEBUG_TYPE, DEBUG_TYPE, false, + false) + +FunctionPass *llvm::createX86FixupStackProtectorPass() { + return new X86FixupStackProtectorPass(); +} + +void X86FixupStackProtectorPass::SplitBasicBlock( + MachineBasicBlock *CurMBB, MachineBasicBlock *NewRetMBB, + MachineBasicBlock::iterator SplitIt) { + NewRetMBB->splice(NewRetMBB->end(), CurMBB, SplitIt, CurMBB->end()); +} + +std::pair<MachineBasicBlock *, MachineInstr *> +X86FixupStackProtectorPass::getSecurityCheckerBasicBlock(MachineFunction &MF) { + MachineBasicBlock::reverse_iterator RBegin, REnd; + + for (auto &MBB : llvm::reverse(MF)) { + for (RBegin = MBB.rbegin(), REnd = MBB.rend(); RBegin != REnd; RBegin++) { + auto &MI = *RBegin; + if (MI.getOpcode() == X86::CALL64pcrel32 && + MI.getNumExplicitOperands() == 1) { + auto MO = MI.getOperand(0); + if (MO.isGlobal()) { + auto Callee = dyn_cast<Function>(MO.getGlobal()); + if (Callee && Callee->getName() == "__security_check_cookie") { + return std::make_pair(&MBB, &MI); + break; + } + } + } + } + } + return std::make_pair(nullptr, nullptr); +} + +void X86FixupStackProtectorPass::getGuardCheckSequence( + MachineBasicBlock *CurMBB, MachineInstr *CheckCall, + MachineInstr *SeqMI[5]) { + + MachineBasicBlock::iterator UIt(CheckCall); + MachineBasicBlock::reverse_iterator DIt(CheckCall); + // Seq From StackUp to Stack Down Is fixed. + // ADJCALLSTACKUP64 + UIt++; ---------------- MaskRay wrote:
https://llvm.org/docs/CodingStandards.html#prefer-preincrement https://github.com/llvm/llvm-project/pull/95904 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
