LLVM  15.0.0git
Public Member Functions | List of all members
llvm::StackProtectorDescriptor Class Reference

Encapsulates all of the information needed to generate a stack protector check, and signals to isel when initialized that one needs to be generated. More...

#include "llvm/CodeGen/CodeGenCommonISel.h"

Public Member Functions

 StackProtectorDescriptor ()=default
 
bool shouldEmitStackProtector () const
 Returns true if all fields of the stack protector descriptor are initialized implying that we should/are ready to emit a stack protector. More...
 
bool shouldEmitFunctionBasedCheckStackProtector () const
 
void initialize (const BasicBlock *BB, MachineBasicBlock *MBB, bool FunctionBasedInstrumentation)
 Initialize the stack protector descriptor structure for a new basic block. More...
 
void resetPerBBState ()
 Reset state that changes when we handle different basic blocks. More...
 
void resetPerFunctionState ()
 Reset state that only changes when we switch functions. More...
 
MachineBasicBlockgetParentMBB ()
 
MachineBasicBlockgetSuccessMBB ()
 
MachineBasicBlockgetFailureMBB ()
 

Detailed Description

Encapsulates all of the information needed to generate a stack protector check, and signals to isel when initialized that one needs to be generated.

NOTE The following is a high level documentation of SelectionDAG Stack Protector Generation. This is now also ported be shared with GlobalISel, but without any significant changes.

High Level Overview of ISel Stack Protector Generation:

Previously, the "stack protector" IR pass handled stack protector generation. This necessitated splitting basic blocks at the IR level to create the success/failure basic blocks in the tail of the basic block in question. As a result of this, calls that would have qualified for the sibling call optimization were no longer eligible for optimization since said calls were no longer right in the "tail position" (i.e. the immediate predecessor of a ReturnInst instruction).

Since the sibling call optimization causes the callee to reuse the caller's stack, if we could delay the generation of the stack protector check until later in CodeGen after the sibling call decision was made, we get both the tail call optimization and the stack protector check!

A few goals in solving this problem were:

  1. Preserve the architecture independence of stack protector generation.
  2. Preserve the normal IR level stack protector check for platforms like OpenBSD for which we support platform-specific stack protector generation.

The main problem that guided the present solution is that one can not solve this problem in an architecture independent manner at the IR level only. This is because:

  1. The decision on whether or not to perform a sibling call on certain platforms (for instance i386) requires lower level information related to available registers that can not be known at the IR level.
  2. Even if the previous point were not true, the decision on whether to perform a tail call is done in LowerCallTo in SelectionDAG (or CallLowering in GlobalISel) which occurs after the Stack Protector Pass. As a result, one would need to put the relevant callinst into the stack protector check success basic block (where the return inst is placed) and then move it back later at ISel/MI time before the stack protector check if the tail call optimization failed. The MI level option was nixed immediately since it would require platform-specific pattern matching. The ISel level option was nixed because SelectionDAG only processes one IR level basic block at a time implying one could not create a DAG Combine to move the callinst.

To get around this problem:

  1. SelectionDAG can only process one block at a time, we can generate multiple machine basic blocks for one IR level basic block. This is how we handle bit tests and switches.
  2. At the MI level, tail calls are represented via a special return MIInst called "tcreturn". Thus if we know the basic block in which we wish to insert the stack protector check, we get the correct behavior by always inserting the stack protector check right before the return statement. This is a "magical transformation" since no matter where the stack protector check intrinsic is, we always insert the stack protector check code at the end of the BB.

Given the aforementioned constraints, the following solution was devised:

  1. On platforms that do not support ISel stack protector check generation, allow for the normal IR level stack protector check generation to continue.
  2. On platforms that do support ISel stack protector check generation:

    a. Use the IR level stack protector pass to decide if a stack protector is required/which BB we insert the stack protector check in by reusing the logic already therein.

    b. After we finish selecting the basic block, we produce the validation code with one of these techniques: 1) with a call to a guard check function 2) with inlined instrumentation

    1) We insert a call to the check function before the terminator.

    2) We first find a splice point in the parent basic block before the terminator and then splice the terminator of said basic block into the success basic block. Then we code-gen a new tail for the parent basic block consisting of the two loads, the comparison, and finally two branches to the success/failure basic blocks. We conclude by code-gening the failure basic block if we have not code-gened it already (all stack protector checks we generate in the same function, use the same failure basic block).

Definition at line 114 of file CodeGenCommonISel.h.

Constructor & Destructor Documentation

◆ StackProtectorDescriptor()

llvm::StackProtectorDescriptor::StackProtectorDescriptor ( )
default

Member Function Documentation

◆ getFailureMBB()

MachineBasicBlock* llvm::StackProtectorDescriptor::getFailureMBB ( )
inline

Definition at line 170 of file CodeGenCommonISel.h.

◆ getParentMBB()

MachineBasicBlock* llvm::StackProtectorDescriptor::getParentMBB ( )
inline

Definition at line 168 of file CodeGenCommonISel.h.

◆ getSuccessMBB()

MachineBasicBlock* llvm::StackProtectorDescriptor::getSuccessMBB ( )
inline

Definition at line 169 of file CodeGenCommonISel.h.

◆ initialize()

void llvm::StackProtectorDescriptor::initialize ( const BasicBlock BB,
MachineBasicBlock MBB,
bool  FunctionBasedInstrumentation 
)
inline

Initialize the stack protector descriptor structure for a new basic block.

Definition at line 130 of file CodeGenCommonISel.h.

References assert(), BB, MBB, and shouldEmitStackProtector().

◆ resetPerBBState()

void llvm::StackProtectorDescriptor::resetPerBBState ( )
inline

Reset state that changes when we handle different basic blocks.

This currently includes:

  1. The specific basic block we are generating a stack protector for (ParentMBB).
  2. The successor machine basic block that will contain the tail of parent mbb after we create the stack protector check (SuccessMBB). This BB is visited only on stack protector check success.

Definition at line 152 of file CodeGenCommonISel.h.

◆ resetPerFunctionState()

void llvm::StackProtectorDescriptor::resetPerFunctionState ( )
inline

Reset state that only changes when we switch functions.

This currently includes:

  1. FailureMBB since we reuse the failure code path for all stack protector checks created in an individual function.

2.The guard variable since the guard variable we are checking against is always the same.

Definition at line 166 of file CodeGenCommonISel.h.

◆ shouldEmitFunctionBasedCheckStackProtector()

bool llvm::StackProtectorDescriptor::shouldEmitFunctionBasedCheckStackProtector ( ) const
inline

Definition at line 124 of file CodeGenCommonISel.h.

◆ shouldEmitStackProtector()

bool llvm::StackProtectorDescriptor::shouldEmitStackProtector ( ) const
inline

Returns true if all fields of the stack protector descriptor are initialized implying that we should/are ready to emit a stack protector.

Definition at line 120 of file CodeGenCommonISel.h.

Referenced by initialize().


The documentation for this class was generated from the following files: