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. 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 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 65 EHPersonality llvm::getDefaultEHPersonality(const Triple &T) { 66 return EHPersonality::GNU_C; 67 } 68 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 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