[eh-simplify] SelfReview

[GorNishanov]

Summary

!WORK IN PROGRESS!

[xbolva00]

Nice work!

Similar PR: https://bugs.llvm.org/show_bug.cgi?id=17467

include/llvm/InitializePasses.h

 void initializeCFGOnlyPrinterLegacyPassPass(PassRegistry&);
 void initializeCFGOnlyViewerLegacyPassPass(PassRegistry&);
 void initializeCFGPrinterLegacyPassPass(PassRegistry&);
 void initializeCFGSimplifyPassPass(PassRegistry&);
 void initializeCFGViewerLegacyPassPass(PassRegistry&);
 void initializeCFIInstrInserterPass(PassRegistry&);
 void initializeCFLAndersAAWrapperPassPass(PassRegistry&);
 void initializeCFLSteensAAWrapperPassPass(PassRegistry&);
+void initializeCXXSimplifyEHPass(PassRegistry&);
 void initializeCallGraphDOTPrinterPass(PassRegistry&);
 void initializeCallGraphPrinterLegacyPassPass(PassRegistry&);
 void initializeCallGraphViewerPass(PassRegistry&);
 void initializeCallGraphWrapperPassPass(PassRegistry&);
 void initializeCallSiteSplittingLegacyPassPass(PassRegistry&);
 void initializeCalledValuePropagationLegacyPassPass(PassRegistry &);
 void initializeCodeGenPreparePass(PassRegistry&);
 void initializeConstantHoistingLegacyPassPass(PassRegistry&);

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createScopedNoAliasAAWrapperPass();
       (void) llvm::createBoundsCheckingLegacyPass();
       (void) llvm::createBreakCriticalEdgesPass();
       (void) llvm::createCallGraphDOTPrinterPass();
       (void) llvm::createCallGraphViewerPass();
       (void) llvm::createCFGSimplificationPass();
       (void) llvm::createCFLAndersAAWrapperPass();
       (void) llvm::createCFLSteensAAWrapperPass();
+      (void) llvm::createCXXExceptionSimplificationPass();
       (void) llvm::createStructurizeCFGPass();
       (void) llvm::createLibCallsShrinkWrapPass();
       (void) llvm::createCalledValuePropagationPass();
       (void) llvm::createConstantMergePass();
       (void) llvm::createConstantPropagationPass();
       (void) llvm::createControlHeightReductionLegacyPass();
       (void) llvm::createCostModelAnalysisPass();
       (void) llvm::createDeadArgEliminationPass();

include/llvm/Transforms/Scalar.h

 //===----------------------------------------------------------------------===//
 //
 // CallSiteSplitting - This pass split call-site based on its known argument
 // values.
 FunctionPass *createCallSiteSplittingPass();
 
 //===----------------------------------------------------------------------===//
 //
+// CXXSimplifyEH - This pass simplifies some C++ EH code patterns. 
+//
+FunctionPass *createCXXExceptionSimplificationPass();
+
+//===----------------------------------------------------------------------===//
+//
 // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm.  This
 // algorithm assumes instructions are dead until proven otherwise, which makes
 // it more successful are removing non-obviously dead instructions.
 //
 FunctionPass *createAggressiveDCEPass();
 
 //===----------------------------------------------------------------------===//
 //

lib/Transforms/Scalar/CMakeLists.txt

 add_llvm_library(LLVMScalarOpts
   ADCE.cpp
   AlignmentFromAssumptions.cpp
   BDCE.cpp
   CallSiteSplitting.cpp
   ConstantHoisting.cpp
   ConstantProp.cpp
   CorrelatedValuePropagation.cpp
+  CXXSimplifyEH.cpp
   DCE.cpp
   DeadStoreElimination.cpp
   DivRemPairs.cpp
   EarlyCSE.cpp
   FlattenCFGPass.cpp
   Float2Int.cpp
   GuardWidening.cpp
   GVN.cpp

lib/Transforms/Scalar/CXXSimplifyEH.cpp

+//===- CXXSimplifyEH.cpp - Code to simplify C++ EH patterns -------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===--------------------------------------------------------------===//
+
+#include "llvm/Analysis/EHPersonalities.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/circular_raw_ostream.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "cxx-eh-simplify"
+
+// At the moment, C++ exception simplification is limited to removal of try catch
+// in the following pattern:  try { whatever } catch(...) { throw; }
+
+// On GNU GCC EH Look for the pattern:
+//
+//    %4 = call i8* @__cxa_BeginCatch(i8* %3)
+//    invoke void @__cxa_rethrow() #6 to label % unreachable unwind label %lpad1
+//
+//  lpad1:;
+//    landingpad{i8 *, i32} cleanup
+//    invoke void @__cxa_end_catch() to label %invoke.cont2
+//
+// and replace it with:
+//    br %invoke.cont2
+
+namespace {
+  struct RethrowSimplifier {
+    InvokeInst *Rethrow;
+    CallInst *BeginCatch;
+    LandingPadInst *Lpad;
+    InvokeInst *EndCatch;
+
+    RethrowSimplifier(RethrowSimplifier const&) = default;
+
+    explicit RethrowSimplifier(BasicBlock &BB)
+      : Rethrow(getRethrow(BB))
+    {
+      if (Rethrow)
+        if ((BeginCatch = getBeginCatch(Rethrow)))
+          if ((Lpad = getLpad(Rethrow)))
+            if ((EndCatch = getEndCatch(Lpad)))
+              return;
+      Rethrow = nullptr;
+    }
+
+    explicit operator bool() const { return Rethrow; }
+
+    static InvokeInst *getRethrow(BasicBlock &BB) {
+      if (auto Inv = dyn_cast<InvokeInst>(BB.getTerminator()))
+        if (auto *CalledF = Inv->getCalledFunction())
+          if (CalledF->getName() == "__cxa_rethrow")
+            return Inv;
+
+      return nullptr;
+    }
+
+    static CallInst *getBeginCatch(InvokeInst *Rethrow) {
+      if (auto *CI = dyn_cast_or_null<CallInst>(Rethrow->getPrevNode()))
+        if (auto *CalledFn = CI->getCalledFunction())
+          if (CalledFn->getName() == "__cxa_begin_catch")
+            if (CI->user_empty()) // If it has uses cannot simplify.
+            return CI;
+
+      return nullptr;
+    }
+
+    static InvokeInst *getEndCatch(LandingPadInst *Lpad) {
+      if (auto *CI = dyn_cast_or_null<InvokeInst>(Lpad->getNextNode()))
+        if (auto *CalledFn = CI->getCalledFunction())
+          if (CalledFn->getName() == "__cxa_end_catch")
+            return CI;
+
+      return nullptr;
+    }
+
+    static LandingPadInst *getLpad(InvokeInst *Rethrow) {
+      if (auto *Lpad = Rethrow->getUnwindDest()->getLandingPadInst())
+        if (Lpad->isCleanup() && Lpad->getNumClauses() == 0)
+          if (Lpad->getParent()->getSinglePredecessor())
+            return Lpad;
+
+      return nullptr;
+    }
+
+    bool simplify() {
+      auto *BB = BeginCatch->getParent();
+      auto *CatchAll = BB->getLandingPadInst();
+      if (!CatchAll)
+        return false;
+
+      ExtractValueInst *Extract = nullptr;
+      for (Use &U: CatchAll->uses())
+        if (Extract)
+          return false;
+        else if (auto EVI = dyn_cast<ExtractValueInst>(U.getUser()))
+          Extract = EVI;
+        else
+          return false; // don't know how to handle this.
+
+      BeginCatch->eraseFromParent();
+      BranchInst::Create(EndCatch->getNormalDest(), Rethrow);
+      Rethrow->eraseFromParent();
+
+      auto *LpadClone = Lpad->clone();
+      LpadClone->insertBefore(CatchAll);
+      Lpad->replaceAllUsesWith(LpadClone);
+
+      auto *Undef = UndefValue::get(CatchAll->getType());
+      CatchAll->replaceAllUsesWith(Undef);
+      CatchAll->eraseFromParent();
+
+      if (Extract->user_empty())
+        Extract->eraseFromParent();
+
+      return true;
+    }
+  };
+}
+
+static bool simplifyGNU_CXX(Function& F) {
+  SmallVector<RethrowSimplifier, 4> Rethrows;
+  for (auto &BB: F)
+    if (RethrowSimplifier RS{BB})
+      Rethrows.push_back(RS);
+
+  if (Rethrows.empty())
+    return false;
+
+  bool changed = false;
+
+  for (auto &RS: Rethrows)
+    changed |= RS.simplify();
+
+  return changed;
+}
+
+//===----------------------------------------------------------------------===//
+//                              Top Level Driver
+//===----------------------------------------------------------------------===//
+
+namespace {
+
+struct CXXSimplifyEH : public FunctionPass {
+  static char ID; // Pass identification, replacement for typeid.
+  CXXSimplifyEH() : FunctionPass(ID) {
+    initializeCXXSimplifyEHPass(*PassRegistry::getPassRegistry());
+  }
+
+  bool runOnFunction(Function &F) override {
+    if (!F.hasPersonalityFn())
+      return false;
+
+    auto Personality = classifyEHPersonality(F.getPersonalityFn());
+    if (Personality == EHPersonality::GNU_CXX)
+      return simplifyGNU_CXX(F);
+
+    return false;
+  }
+
+  StringRef getPassName() const override {
+    return "Simplify C++ EH patterns";
+  }
+};
+}
+
+char CXXSimplifyEH::ID = 0;
+INITIALIZE_PASS(CXXSimplifyEH, "cxx-simplify-eh", "Simplify C++ EH patterns",
+                false, false)
+
+FunctionPass *llvm::createCXXExceptionSimplificationPass() { return new CXXSimplifyEH(); }
+
+

lib/Transforms/Scalar/Scalar.cpp

 void llvm::initializeScalarOpts(PassRegistry &Registry) {
   initializeADCELegacyPassPass(Registry);
   initializeBDCELegacyPassPass(Registry);
   initializeAlignmentFromAssumptionsPass(Registry);
   initializeCallSiteSplittingLegacyPassPass(Registry);
   initializeConstantHoistingLegacyPassPass(Registry);
   initializeConstantPropagationPass(Registry);
   initializeCorrelatedValuePropagationPass(Registry);
+  initializeCXXSimplifyEHPass(Registry);
   initializeDCELegacyPassPass(Registry);
   initializeDeadInstEliminationPass(Registry);
   initializeDivRemPairsLegacyPassPass(Registry);
   initializeScalarizerLegacyPassPass(Registry);
   initializeDSELegacyPassPass(Registry);
   initializeGuardWideningLegacyPassPass(Registry);
   initializeLoopGuardWideningLegacyPassPass(Registry);
   initializeGVNLegacyPassPass(Registry);