1 //===- StackProtector.h - Stack Protector Insertion -------------*- C++ -*-===// 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 // This pass inserts stack protectors into functions which need them. A variable 10 // with a random value in it is stored onto the stack before the local variables 11 // are allocated. Upon exiting the block, the stored value is checked. If it's 12 // changed, then there was some sort of violation and the program aborts. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_CODEGEN_STACKPROTECTOR_H 17 #define LLVM_CODEGEN_STACKPROTECTOR_H 18 19 #include "llvm/ADT/SmallPtrSet.h" 20 #include "llvm/ADT/Triple.h" 21 #include "llvm/CodeGen/MachineFrameInfo.h" 22 #include "llvm/IR/Instructions.h" 23 #include "llvm/IR/ValueMap.h" 24 #include "llvm/Pass.h" 25 26 namespace llvm { 27 28 class BasicBlock; 29 class DominatorTree; 30 class Function; 31 class Instruction; 32 class Module; 33 class TargetLoweringBase; 34 class TargetMachine; 35 class Type; 36 37 class StackProtector : public FunctionPass { 38 private: 39 /// A mapping of AllocaInsts to their required SSP layout. 40 using SSPLayoutMap = DenseMap<const AllocaInst *, 41 MachineFrameInfo::SSPLayoutKind>; 42 43 const TargetMachine *TM = nullptr; 44 45 /// TLI - Keep a pointer of a TargetLowering to consult for determining 46 /// target type sizes. 47 const TargetLoweringBase *TLI = nullptr; 48 Triple Trip; 49 50 Function *F; 51 Module *M; 52 53 DominatorTree *DT; 54 55 /// Layout - Mapping of allocations to the required SSPLayoutKind. 56 /// StackProtector analysis will update this map when determining if an 57 /// AllocaInst triggers a stack protector. 58 SSPLayoutMap Layout; 59 60 /// The minimum size of buffers that will receive stack smashing 61 /// protection when -fstack-protection is used. 62 unsigned SSPBufferSize = 0; 63 64 // A prologue is generated. 65 bool HasPrologue = false; 66 67 // IR checking code is generated. 68 bool HasIRCheck = false; 69 70 /// InsertStackProtectors - Insert code into the prologue and epilogue of 71 /// the function. 72 /// 73 /// - The prologue code loads and stores the stack guard onto the stack. 74 /// - The epilogue checks the value stored in the prologue against the 75 /// original value. It calls __stack_chk_fail if they differ. 76 bool InsertStackProtectors(); 77 78 /// CreateFailBB - Create a basic block to jump to when the stack protector 79 /// check fails. 80 BasicBlock *CreateFailBB(); 81 82 /// ContainsProtectableArray - Check whether the type either is an array or 83 /// contains an array of sufficient size so that we need stack protectors 84 /// for it. 85 /// \param [out] IsLarge is set to true if a protectable array is found and 86 /// it is "large" ( >= ssp-buffer-size). In the case of a structure with 87 /// multiple arrays, this gets set if any of them is large. 88 bool ContainsProtectableArray(Type *Ty, bool &IsLarge, bool Strong = false, 89 bool InStruct = false) const; 90 91 /// Check whether a stack allocation has its address taken. 92 bool HasAddressTaken(const Instruction *AI, 93 SmallPtrSetImpl<const PHINode *> &VisitedPHIs); 94 95 /// RequiresStackProtector - Check whether or not this function needs a 96 /// stack protector based upon the stack protector level. 97 bool RequiresStackProtector(); 98 99 public: 100 static char ID; // Pass identification, replacement for typeid. 101 102 StackProtector() : FunctionPass(ID), SSPBufferSize(8) { 103 initializeStackProtectorPass(*PassRegistry::getPassRegistry()); 104 } 105 106 void getAnalysisUsage(AnalysisUsage &AU) const override; 107 108 // Return true if StackProtector is supposed to be handled by SelectionDAG. 109 bool shouldEmitSDCheck(const BasicBlock &BB) const; 110 111 bool runOnFunction(Function &Fn) override; 112 113 void copyToMachineFrameInfo(MachineFrameInfo &MFI) const; 114 }; 115 116 } // end namespace llvm 117 118 #endif // LLVM_CODEGEN_STACKPROTECTOR_H 119