LLVM  8.0.0svn
EHPersonalities.cpp
Go to the documentation of this file.
1 //===- EHPersonalities.cpp - Compute EH-related information ---------------===//
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 
11 #include "llvm/ADT/StringSwitch.h"
12 #include "llvm/IR/CFG.h"
13 #include "llvm/IR/Constants.h"
14 #include "llvm/IR/Function.h"
15 #include "llvm/IR/Instructions.h"
16 #include "llvm/Support/Debug.h"
18 using namespace llvm;
19 
20 /// See if the given exception handling personality function is one that we
21 /// understand. If so, return a description of it; otherwise return Unknown.
23  const Function *F =
24  Pers ? dyn_cast<Function>(Pers->stripPointerCasts()) : nullptr;
25  if (!F)
28  .Case("__gnat_eh_personality", EHPersonality::GNU_Ada)
29  .Case("__gxx_personality_v0", EHPersonality::GNU_CXX)
30  .Case("__gxx_personality_seh0", EHPersonality::GNU_CXX)
31  .Case("__gxx_personality_sj0", EHPersonality::GNU_CXX_SjLj)
32  .Case("__gcc_personality_v0", EHPersonality::GNU_C)
33  .Case("__gcc_personality_seh0", EHPersonality::GNU_C)
34  .Case("__gcc_personality_sj0", EHPersonality::GNU_C_SjLj)
35  .Case("__objc_personality_v0", EHPersonality::GNU_ObjC)
36  .Case("_except_handler3", EHPersonality::MSVC_X86SEH)
37  .Case("_except_handler4", EHPersonality::MSVC_X86SEH)
38  .Case("__C_specific_handler", EHPersonality::MSVC_Win64SEH)
39  .Case("__CxxFrameHandler3", EHPersonality::MSVC_CXX)
40  .Case("ProcessCLRException", EHPersonality::CoreCLR)
41  .Case("rust_eh_personality", EHPersonality::Rust)
42  .Case("__gxx_wasm_personality_v0", EHPersonality::Wasm_CXX)
44 }
45 
47  switch (Pers) {
48  case EHPersonality::GNU_Ada: return "__gnat_eh_personality";
49  case EHPersonality::GNU_CXX: return "__gxx_personality_v0";
50  case EHPersonality::GNU_CXX_SjLj: return "__gxx_personality_sj0";
51  case EHPersonality::GNU_C: return "__gcc_personality_v0";
52  case EHPersonality::GNU_C_SjLj: return "__gcc_personality_sj0";
53  case EHPersonality::GNU_ObjC: return "__objc_personality_v0";
54  case EHPersonality::MSVC_X86SEH: return "_except_handler3";
55  case EHPersonality::MSVC_Win64SEH: return "__C_specific_handler";
56  case EHPersonality::MSVC_CXX: return "__CxxFrameHandler3";
57  case EHPersonality::CoreCLR: return "ProcessCLRException";
58  case EHPersonality::Rust: return "rust_eh_personality";
59  case EHPersonality::Wasm_CXX: return "__gxx_wasm_personality_v0";
60  case EHPersonality::Unknown: llvm_unreachable("Unknown EHPersonality!");
61  }
62 
63  llvm_unreachable("Invalid EHPersonality!");
64 }
65 
67  return EHPersonality::GNU_C;
68 }
69 
72  // We can't simplify any invokes to nounwind functions if the personality
73  // function wants to catch asynch exceptions. The nounwind attribute only
74  // implies that the function does not throw synchronous exceptions.
75  return !isAsynchronousEHPersonality(Personality);
76 }
77 
80  BasicBlock *EntryBlock = &F.getEntryBlock();
82 
83  // Build up the color map, which maps each block to its set of 'colors'.
84  // For any block B the "colors" of B are the set of funclets F (possibly
85  // including a root "funclet" representing the main function) such that
86  // F will need to directly contain B or a copy of B (where the term "directly
87  // contain" is used to distinguish from being "transitively contained" in
88  // a nested funclet).
89  //
90  // Note: Despite not being a funclet in the truest sense, a catchswitch is
91  // considered to belong to its own funclet for the purposes of coloring.
92 
93  DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for "
94  << F.getName() << "\n");
95 
96  Worklist.push_back({EntryBlock, EntryBlock});
97 
98  while (!Worklist.empty()) {
99  BasicBlock *Visiting;
100  BasicBlock *Color;
101  std::tie(Visiting, Color) = Worklist.pop_back_val();
102  DEBUG_WITH_TYPE("winehprepare-coloring",
103  dbgs() << "Visiting " << Visiting->getName() << ", "
104  << Color->getName() << "\n");
105  Instruction *VisitingHead = Visiting->getFirstNonPHI();
106  if (VisitingHead->isEHPad()) {
107  // Mark this funclet head as a member of itself.
108  Color = Visiting;
109  }
110  // Note that this is a member of the given color.
111  ColorVector &Colors = BlockColors[Visiting];
112  if (!is_contained(Colors, Color))
113  Colors.push_back(Color);
114  else
115  continue;
116 
117  DEBUG_WITH_TYPE("winehprepare-coloring",
118  dbgs() << " Assigned color \'" << Color->getName()
119  << "\' to block \'" << Visiting->getName()
120  << "\'.\n");
121 
122  BasicBlock *SuccColor = Color;
123  TerminatorInst *Terminator = Visiting->getTerminator();
124  if (auto *CatchRet = dyn_cast<CatchReturnInst>(Terminator)) {
125  Value *ParentPad = CatchRet->getCatchSwitchParentPad();
126  if (isa<ConstantTokenNone>(ParentPad))
127  SuccColor = EntryBlock;
128  else
129  SuccColor = cast<Instruction>(ParentPad)->getParent();
130  }
131 
132  for (BasicBlock *Succ : successors(Visiting))
133  Worklist.push_back({Succ, SuccColor});
134  }
135  return BlockColors;
136 }
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
F(f)
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:31
#define DEBUG_WITH_TYPE(TYPE, X)
DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug information.
Definition: Debug.h:65
bool canSimplifyInvokeNoUnwind(const Function *F)
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(T Value)
Definition: StringSwitch.h:203
const BasicBlock & getEntryBlock() const
Definition: Function.h:640
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:43
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:189
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:55
LLVM Basic Block Representation.
Definition: BasicBlock.h:59
void push_back(EltTy NewVal)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
EHPersonality getDefaultEHPersonality(const Triple &T)
const Value * stripPointerCasts() const
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:539
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Color
A "color", which is either even or odd.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:381
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:70
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
StringRef getEHPersonalityName(EHPersonality Pers)
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
LLVM Value Representation.
Definition: Value.h:73
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1302
succ_range successors(Instruction *I)
Definition: CFG.h:262
static const Function * getParent(const Value *V)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
const TerminatorInst * getTerminator() const LLVM_READONLY
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:138
DenseMap< BasicBlock *, ColorVector > colorEHFunclets(Function &F)
If an EH funclet personality is in use (see isFuncletEHPersonality), this will recompute which blocks...
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1101