[BoundsSafety] Remove -funique-traps flag and its implementation

The implementation was a bit hacky and interacted badly with the
hot-cold splitting pass. So it is going to be removed in favor of a
different implementation that's simpler.

I also investated why
`clang/test/BoundsSafety/CodeGen/unique-trap-blocks-O2.c` broke (rdar://150559639).
It turns outthat the "trap blocks" started being unintentionally split
by the hot-cold splitting pass because in upstream we started adding
branch profiling weights
(llvm#134310) which the hot-cold
splitting pass used as a signal to split the "trap blocks" into their
own function (by-passing the logic I originally added to prevent the
splitting). While we could fix this it would be very fragile and given
that we are removing the implementation anyway it doesn't matter
anymore.

rdar://158088410

Author: delcypher

clang/include/clang/Basic/CodeGenOptions.def

@@ -336,10 +336,6 @@ CODEGENOPT(ProfileSampleAccurate, 1, 0, Benign) ///< Sample profile is accurate.
 /* TO_UPSTREAM(BoundsSafety) ON*/
 CODEGENOPT(TrapFuncReturns   , 1, 0, Benign) ///< When true, the function specified with
                                              ///< -ftrap-function may return normally
-CODEGENOPT(
-    UniqueTrapBlocks, 1,
-    0, Benign) ///< When true, basic blocks that contain traps they will be prevented
-               ///< from being merged by optimization passes and the backends.
 /* TO_UPSTREAM(BoundsSafety) OFF*/
 
 /// Treat loops as finite: language, always, never.

clang/include/clang/Driver/Options.td

@@ -4445,16 +4445,6 @@ defm trap_function_returns : BoolFOption<"trap-function-returns",
           "The trap function specified by -ftrap-function may return normally">,
   NegFlag<SetFalse, [], [ClangOption, CC1Option],
           "The trap function specified by -ftrap-function never returns">>;
-defm unique_traps : BoolFOption<"unique-traps",
-  CodeGenOpts<"UniqueTrapBlocks">, DefaultFalse,
-  PosFlag<SetTrue, [], [CC1Option],
-    "Make trap instructions unique by preventing traps from being merged by the"
-    " optimizer. This is useful for preserving the debug information on traps "
-    "in optimized code. This makes it easier to debug programs at the cost of "
-    "increased code size">,
-  NegFlag<SetFalse, [], [CC1Option],
-    "Don't try to make trap instructions unique. This allows trap instructions "
-    "to be merged by the optimizer.">>;
 /* TO_UPSTREAM(BoundsSafety) OFF */
 def funroll_loops : Flag<["-"], "funroll-loops">, Group<f_Group>,
   HelpText<"Turn on loop unroller">, Visibility<[ClangOption, CC1Option, FlangOption, FC1Option]>;

clang/lib/CodeGen/CGExpr.cpp

@@ -4712,7 +4712,6 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
 
   /*TO_UPSTREAM(BoundsSafety) ON*/
   NoMerge |= CGM.getCodeGenOpts().TrapFuncReturns;
-  NoMerge |= CGM.getCodeGenOpts().UniqueTrapBlocks;
   /*TO_UPSTREAM(BoundsSafety) OFF*/
 
   if (TrapBB && !NoMerge) {
@@ -4741,11 +4740,7 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
     /* TO_UPSTREAM(BoundsSafety) OFF*/
   } else {
     /*TO_UPSTREAM(BoundsSafety) ON*/
-    if (CGM.getCodeGenOpts().UniqueTrapBlocks &&
-        !CGM.getCodeGenOpts().TrapFuncReturns)
-      TrapBB = createUnmergeableBasicBlock("trap");
-    else
-      TrapBB = createBasicBlock("trap");
+    TrapBB = createBasicBlock("trap");
     auto *BrInst = Builder.CreateCondBr(Checked, Cont, TrapBB,
                          MDHelper.createLikelyBranchWeights());
 

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -41,8 +41,6 @@
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/FPEnv.h"
-// TO_UPSTREAM(BoundsSafety) ON
-#include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
@@ -320,43 +318,6 @@ TypeEvaluationKind CodeGenFunction::getEvaluationKind(QualType type) {
   }
 }
 
-/* TO_UPSTREAM(BoundsSafety) ON*/
-llvm::BasicBlock *CodeGenFunction::createUnmergeableBasicBlock(
-    const Twine &name, llvm::Function *parent, llvm::BasicBlock *before) {
-  auto *BB = createBasicBlock(name, parent, before);
-  // This approach is the same approach used by Swift.
-  // TODO: Find a better way to do this (rdar://137627723).
-
-  // Emit unique side-effecting inline asm calls in order to eliminate
-  // the possibility that an LLVM optimization or code generation pass
-  // will merge these blocks back together again. We emit an empty asm
-  // string with the side-effect flag set, and with a unique integer
-  // argument.
-  llvm::IntegerType *asmArgTy = CGM.Int64Ty;
-  llvm::Type *argTys = {asmArgTy};
-  llvm::FunctionType *asmFnTy =
-      llvm::FunctionType::get(CGM.VoidTy, argTys, /* isVarArg=*/false);
-  // "n" is an input constraint stating that the first argument to the call
-  // will be an integer literal.
-  llvm::InlineAsm *inlineAsm =
-      llvm::InlineAsm::get(asmFnTy, /*AsmString=*/"", /*Constraints=*/"n",
-                           /*hasSideEffects=*/true);
-
-  // Use the builder so that any opt-remarks and attributes are automatically
-  // applied by the builder. The current state of the builder is saved so it
-  // can be used for creating the asm call and then the builder is reset to
-  // its previous state.
-  auto OldInsertPoint = Builder.GetInsertPoint();
-  auto* OldInsertBB = Builder.GetInsertBlock();
-  Builder.SetInsertPoint(BB);
-  Builder.CreateCall(
-      inlineAsm,
-      llvm::ConstantInt::get(asmArgTy, CGM.getAndIncrementUniqueTrapCount()));
-  Builder.SetInsertPoint(OldInsertBB, OldInsertPoint);
-  return BB;
-}
-/* TO_UPSTREAM(BoundsSafety) OFF*/
-
 llvm::DebugLoc CodeGenFunction::EmitReturnBlock() {
   // For cleanliness, we try to avoid emitting the return block for
   // simple cases.

clang/lib/CodeGen/CodeGenFunction.h

@@ -2659,13 +2659,6 @@ class CodeGenFunction : public CodeGenTypeCache {
     return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
   }
 
-  /* TO_UPSTREM(BoundsSafety) ON*/
-  llvm::BasicBlock *
-  createUnmergeableBasicBlock(const Twine &name = "",
-                              llvm::Function *parent = nullptr,
-                              llvm::BasicBlock *before = nullptr);
-  /* TO_UPSTREM(BoundsSafety) OFF*/
-
   /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
   /// label maps to.
   JumpDest getJumpDestForLabel(const LabelDecl *S);

clang/lib/CodeGen/CodeGenModule.h

@@ -682,9 +682,6 @@ class CodeGenModule : public CodeGenTypeCache {
   std::optional<PointerAuthQualifier>
   computeVTPointerAuthentication(const CXXRecordDecl *ThisClass);
 
-  // TO_UPSTREAM(BoundsSafety)
-  uint64_t UniqueTrapCount = 0;
-
   AtomicOptions AtomicOpts;
 
   // A set of functions which should be hot-patched; see
@@ -1159,11 +1156,6 @@ class CodeGenModule : public CodeGenTypeCache {
   /// Fetches the global unique block count.
   int getUniqueBlockCount() { return ++Block.GlobalUniqueCount; }
 
-  /* TO_UPSTREAM(BoundsSafety) ON*/
-  /// Fetches and increments unique trap count
-  uint64_t getAndIncrementUniqueTrapCount() { return UniqueTrapCount++; }
-  /* TO_UPSTREAM(BoundsSafety) OFF*/
-
   /// Fetches the type of a generic block descriptor.
   llvm::Type *getBlockDescriptorType();
 

clang/lib/Driver/ToolChains/Clang.cpp

@@ -7041,9 +7041,6 @@ void Clang::ConstructJob(Compilation &C, const JobAction &Job,
         D.Diag(diag::err_drv_option_requires_option)
           << "-ftrap-function-returns" << "-ftrap-function=";
     }
-
-  Args.addOptInFlag(CmdArgs, options::OPT_funique_traps,
-                    options::OPT_fno_unique_traps);
   /* TO_UPSTREAM(BoundsSafety) OFF*/
 
   // Handle -f[no-]wrapv and -f[no-]strict-overflow, which are used by both