lib/Analysis/EHPersonalities.cpp

   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 }