Coverage Report

Created: 2018-09-19 08:35

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