1 //===- EHPersonalities.cpp - Compute EH-related information ---------------===//
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 #include "llvm/Analysis/EHPersonalities.h"
10 #include "llvm/ADT/StringSwitch.h"
11 #include "llvm/IR/CFG.h"
12 #include "llvm/IR/Constants.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/Support/Debug.h"
16 #include "llvm/Support/raw_ostream.h"
17 using namespace llvm;
18
19 /// See if the given exception handling personality function is one that we
20 /// understand. If so, return a description of it; otherwise return Unknown.
classifyEHPersonality(const Value * Pers)21 EHPersonality llvm::classifyEHPersonality(const Value *Pers) {
22 const Function *F =
23 Pers ? dyn_cast<Function>(Pers->stripPointerCasts()) : nullptr;
24 if (!F)
25 return EHPersonality::Unknown;
26 return StringSwitch<EHPersonality>(F->getName())
27 .Case("__gnat_eh_personality", EHPersonality::GNU_Ada)
28 .Case("__gxx_personality_v0", EHPersonality::GNU_CXX)
29 .Case("__gxx_personality_seh0", EHPersonality::GNU_CXX)
30 .Case("__gxx_personality_sj0", EHPersonality::GNU_CXX_SjLj)
31 .Case("__gcc_personality_v0", EHPersonality::GNU_C)
32 .Case("__gcc_personality_seh0", EHPersonality::GNU_C)
33 .Case("__gcc_personality_sj0", EHPersonality::GNU_C_SjLj)
34 .Case("__objc_personality_v0", EHPersonality::GNU_ObjC)
35 .Case("_except_handler3", EHPersonality::MSVC_X86SEH)
36 .Case("_except_handler4", EHPersonality::MSVC_X86SEH)
37 .Case("__C_specific_handler", EHPersonality::MSVC_Win64SEH)
38 .Case("__CxxFrameHandler3", EHPersonality::MSVC_CXX)
39 .Case("ProcessCLRException", EHPersonality::CoreCLR)
40 .Case("rust_eh_personality", EHPersonality::Rust)
41 .Case("__gxx_wasm_personality_v0", EHPersonality::Wasm_CXX)
42 .Default(EHPersonality::Unknown);
43 }
44
getEHPersonalityName(EHPersonality Pers)45 StringRef llvm::getEHPersonalityName(EHPersonality Pers) {
46 switch (Pers) {
47 case EHPersonality::GNU_Ada: return "__gnat_eh_personality";
48 case EHPersonality::GNU_CXX: return "__gxx_personality_v0";
49 case EHPersonality::GNU_CXX_SjLj: return "__gxx_personality_sj0";
50 case EHPersonality::GNU_C: return "__gcc_personality_v0";
51 case EHPersonality::GNU_C_SjLj: return "__gcc_personality_sj0";
52 case EHPersonality::GNU_ObjC: return "__objc_personality_v0";
53 case EHPersonality::MSVC_X86SEH: return "_except_handler3";
54 case EHPersonality::MSVC_Win64SEH: return "__C_specific_handler";
55 case EHPersonality::MSVC_CXX: return "__CxxFrameHandler3";
56 case EHPersonality::CoreCLR: return "ProcessCLRException";
57 case EHPersonality::Rust: return "rust_eh_personality";
58 case EHPersonality::Wasm_CXX: return "__gxx_wasm_personality_v0";
59 case EHPersonality::Unknown: llvm_unreachable("Unknown EHPersonality!");
60 }
61
62 llvm_unreachable("Invalid EHPersonality!");
63 }
64
getDefaultEHPersonality(const Triple & T)65 EHPersonality llvm::getDefaultEHPersonality(const Triple &T) {
66 return EHPersonality::GNU_C;
67 }
68
canSimplifyInvokeNoUnwind(const Function * F)69 bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
70 EHPersonality Personality = classifyEHPersonality(F->getPersonalityFn());
71 // We can't simplify any invokes to nounwind functions if the personality
72 // function wants to catch asynch exceptions. The nounwind attribute only
73 // implies that the function does not throw synchronous exceptions.
74 return !isAsynchronousEHPersonality(Personality);
75 }
76
colorEHFunclets(Function & F)77 DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
78 SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;
79 BasicBlock *EntryBlock = &F.getEntryBlock();
80 DenseMap<BasicBlock *, ColorVector> BlockColors;
81
82 // Build up the color map, which maps each block to its set of 'colors'.
83 // For any block B the "colors" of B are the set of funclets F (possibly
84 // including a root "funclet" representing the main function) such that
85 // F will need to directly contain B or a copy of B (where the term "directly
86 // contain" is used to distinguish from being "transitively contained" in
87 // a nested funclet).
88 //
89 // Note: Despite not being a funclet in the truest sense, a catchswitch is
90 // considered to belong to its own funclet for the purposes of coloring.
91
92 DEBUG_WITH_TYPE("winehprepare-coloring", dbgs() << "\nColoring funclets for "
93 << F.getName() << "\n");
94
95 Worklist.push_back({EntryBlock, EntryBlock});
96
97 while (!Worklist.empty()) {
98 BasicBlock *Visiting;
99 BasicBlock *Color;
100 std::tie(Visiting, Color) = Worklist.pop_back_val();
101 DEBUG_WITH_TYPE("winehprepare-coloring",
102 dbgs() << "Visiting " << Visiting->getName() << ", "
103 << Color->getName() << "\n");
104 Instruction *VisitingHead = Visiting->getFirstNonPHI();
105 if (VisitingHead->isEHPad()) {
106 // Mark this funclet head as a member of itself.
107 Color = Visiting;
108 }
109 // Note that this is a member of the given color.
110 ColorVector &Colors = BlockColors[Visiting];
111 if (!is_contained(Colors, Color))
112 Colors.push_back(Color);
113 else
114 continue;
115
116 DEBUG_WITH_TYPE("winehprepare-coloring",
117 dbgs() << " Assigned color \'" << Color->getName()
118 << "\' to block \'" << Visiting->getName()
119 << "\'.\n");
120
121 BasicBlock *SuccColor = Color;
122 Instruction *Terminator = Visiting->getTerminator();
123 if (auto *CatchRet = dyn_cast<CatchReturnInst>(Terminator)) {
124 Value *ParentPad = CatchRet->getCatchSwitchParentPad();
125 if (isa<ConstantTokenNone>(ParentPad))
126 SuccColor = EntryBlock;
127 else
128 SuccColor = cast<Instruction>(ParentPad)->getParent();
129 }
130
131 for (BasicBlock *Succ : successors(Visiting))
132 Worklist.push_back({Succ, SuccColor});
133 }
134 return BlockColors;
135 }
136