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/IR/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/IR/Module.h"
16#include "llvm/Support/Debug.h"
17#include "llvm/Support/raw_ostream.h"
18#include "llvm/TargetParser/Triple.h"
19using namespace llvm;
20
21/// See if the given exception handling personality function is one that we
22/// understand. If so, return a description of it; otherwise return Unknown.
23EHPersonality llvm::classifyEHPersonality(const Value *Pers) {
24 const GlobalValue *F =
25 Pers ? dyn_cast<GlobalValue>(Val: Pers->stripPointerCasts()) : nullptr;
26 if (!F || !F->getValueType() || !F->getValueType()->isFunctionTy())
27 return EHPersonality::Unknown;
28
29 StringRef Name = F->getName();
30 if (F->getParent()->getTargetTriple().isWindowsArm64EC()) {
31 // ARM64EC function symbols are mangled by prefixing them with "#".
32 // Demangle them by skipping this prefix.
33 Name.consume_front(Prefix: "#");
34 }
35
36 return StringSwitch<EHPersonality>(Name)
37 .Case(S: "__gnat_eh_personality", Value: EHPersonality::GNU_Ada)
38 .Case(S: "__gxx_personality_v0", Value: EHPersonality::GNU_CXX)
39 .Case(S: "__gxx_personality_seh0", Value: EHPersonality::GNU_CXX)
40 .Case(S: "__gxx_personality_sj0", Value: EHPersonality::GNU_CXX_SjLj)
41 .Case(S: "__gcc_personality_v0", Value: EHPersonality::GNU_C)
42 .Case(S: "__gcc_personality_seh0", Value: EHPersonality::GNU_C)
43 .Case(S: "__gcc_personality_sj0", Value: EHPersonality::GNU_C_SjLj)
44 .Case(S: "__objc_personality_v0", Value: EHPersonality::GNU_ObjC)
45 .Case(S: "_except_handler3", Value: EHPersonality::MSVC_X86SEH)
46 .Case(S: "_except_handler4", Value: EHPersonality::MSVC_X86SEH)
47 .Case(S: "__C_specific_handler", Value: EHPersonality::MSVC_TableSEH)
48 .Case(S: "__CxxFrameHandler3", Value: EHPersonality::MSVC_CXX)
49 .Case(S: "ProcessCLRException", Value: EHPersonality::CoreCLR)
50 // Rust mangles its personality function, so we can't test exact equality.
51 .EndsWith(S: "rust_eh_personality", Value: EHPersonality::Rust)
52 .Case(S: "__gxx_wasm_personality_v0", Value: EHPersonality::Wasm_CXX)
53 .Case(S: "__xlcxx_personality_v1", Value: EHPersonality::XL_CXX)
54 .Case(S: "__zos_cxx_personality_v2", Value: EHPersonality::ZOS_CXX)
55 .Case(S: "_d_eh_personality_wasm", Value: EHPersonality::Wasm_D)
56 .Default(Value: EHPersonality::Unknown);
57}
58
59StringRef llvm::getEHPersonalityName(EHPersonality Pers) {
60 switch (Pers) {
61 case EHPersonality::GNU_Ada:
62 return "__gnat_eh_personality";
63 case EHPersonality::GNU_CXX:
64 return "__gxx_personality_v0";
65 case EHPersonality::GNU_CXX_SjLj:
66 return "__gxx_personality_sj0";
67 case EHPersonality::GNU_C:
68 return "__gcc_personality_v0";
69 case EHPersonality::GNU_C_SjLj:
70 return "__gcc_personality_sj0";
71 case EHPersonality::GNU_ObjC:
72 return "__objc_personality_v0";
73 case EHPersonality::MSVC_X86SEH:
74 return "_except_handler3";
75 case EHPersonality::MSVC_TableSEH:
76 return "__C_specific_handler";
77 case EHPersonality::MSVC_CXX:
78 return "__CxxFrameHandler3";
79 case EHPersonality::CoreCLR:
80 return "ProcessCLRException";
81 case EHPersonality::Rust:
82 llvm_unreachable(
83 "Cannot get personality name of Rust personality, since it is mangled");
84 case EHPersonality::Wasm_CXX:
85 return "__gxx_wasm_personality_v0";
86 case EHPersonality::XL_CXX:
87 return "__xlcxx_personality_v1";
88 case EHPersonality::ZOS_CXX:
89 return "__zos_cxx_personality_v2";
90 case EHPersonality::Wasm_D:
91 return "_d_eh_personality_wasm";
92 case EHPersonality::Unknown:
93 llvm_unreachable("Unknown EHPersonality!");
94 }
95
96 llvm_unreachable("Invalid EHPersonality!");
97}
98
99EHPersonality llvm::getDefaultEHPersonality(const Triple &T) {
100 if (T.isPS5())
101 return EHPersonality::GNU_CXX;
102 else
103 return EHPersonality::GNU_C;
104}
105
106bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
107 EHPersonality Personality = classifyEHPersonality(Pers: F->getPersonalityFn());
108 // We can't simplify any invokes to nounwind functions if the personality
109 // function wants to catch asynch exceptions. The nounwind attribute only
110 // implies that the function does not throw synchronous exceptions.
111
112 // Cannot simplify CXX Personality under AsynchEH
113 const llvm::Module *M = (const llvm::Module *)F->getParent();
114 bool EHa = M->getModuleFlag(Key: "eh-asynch");
115 return !EHa && !isAsynchronousEHPersonality(Pers: Personality);
116}
117
118DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
119 SmallVector<std::pair<BasicBlock *, BasicBlock *>, 16> Worklist;
120 BasicBlock *EntryBlock = &F.getEntryBlock();
121 DenseMap<BasicBlock *, ColorVector> BlockColors;
122
123 // Build up the color map, which maps each block to its set of 'colors'.
124 // For any block B the "colors" of B are the set of funclets F (possibly
125 // including a root "funclet" representing the main function) such that
126 // F will need to directly contain B or a copy of B (where the term "directly
127 // contain" is used to distinguish from being "transitively contained" in
128 // a nested funclet).
129 //
130 // Note: Despite not being a funclet in the truest sense, a catchswitch is
131 // considered to belong to its own funclet for the purposes of coloring.
132
133 DEBUG_WITH_TYPE("win-eh-prepare-coloring",
134 dbgs() << "\nColoring funclets for " << F.getName() << "\n");
135
136 Worklist.push_back(Elt: {EntryBlock, EntryBlock});
137
138 while (!Worklist.empty()) {
139 BasicBlock *Visiting;
140 BasicBlock *Color;
141 std::tie(args&: Visiting, args&: Color) = Worklist.pop_back_val();
142 DEBUG_WITH_TYPE("win-eh-prepare-coloring",
143 dbgs() << "Visiting " << Visiting->getName() << ", "
144 << Color->getName() << "\n");
145 BasicBlock::iterator VisitingHead = Visiting->getFirstNonPHIIt();
146 if (VisitingHead->isEHPad()) {
147 // Mark this funclet head as a member of itself.
148 Color = Visiting;
149 }
150 // Note that this is a member of the given color.
151 ColorVector &Colors = BlockColors[Visiting];
152 if (!is_contained(Range&: Colors, Element: Color))
153 Colors.push_back(NewVal: Color);
154 else
155 continue;
156
157 DEBUG_WITH_TYPE("win-eh-prepare-coloring",
158 dbgs() << " Assigned color \'" << Color->getName()
159 << "\' to block \'" << Visiting->getName()
160 << "\'.\n");
161
162 BasicBlock *SuccColor = Color;
163 Instruction *Terminator = Visiting->getTerminator();
164 if (auto *CatchRet = dyn_cast<CatchReturnInst>(Val: Terminator)) {
165 Value *ParentPad = CatchRet->getCatchSwitchParentPad();
166 if (isa<ConstantTokenNone>(Val: ParentPad))
167 SuccColor = EntryBlock;
168 else
169 SuccColor = cast<Instruction>(Val: ParentPad)->getParent();
170 }
171
172 for (BasicBlock *Succ : successors(BB: Visiting))
173 Worklist.push_back(Elt: {Succ, SuccColor});
174 }
175 return BlockColors;
176}
177