[IRGen] Prevent mergeable traps from being created

PR #14729 made more calls to llvm.trap() non-mergeable. This follow-up
adds asserts to IRBuilder which make it harder to accidentally introduce
mergeable calls to llvm.trap() in the future.

The newly-added assertions exposed an issue in GenBuiltin while
compiling parts of the stdlib. This PR fixes the issue.

Suggested by Adrian Prantl!

rdar://32772768

Author: vedantk

lib/IRGen/GenBuiltin.cpp

@@ -194,6 +194,12 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   const IntrinsicInfo &IInfo = IGF.getSILModule().getIntrinsicInfo(FnId);
   llvm::Intrinsic::ID IID = IInfo.ID;
 
+  // Emit non-mergeable traps only.
+  if (IGF.Builder.isTrapIntrinsic(IID)) {
+    IGF.Builder.CreateNonMergeableTrap(IGF.IGM);
+    return;
+  }
+
   // Calls to the int_instrprof_increment intrinsic are emitted during SILGen.
   // At that stage, the function name GV used by the profiling pass is hidden.
   // Fix the intrinsic call here by pointing it to the correct GV.

lib/IRGen/GenCall.cpp

@@ -1601,6 +1601,7 @@ llvm::CallSite CallEmission::emitCallSite() {
 
 llvm::CallInst *IRBuilder::CreateCall(const FunctionPointer &fn,
                                       ArrayRef<llvm::Value*> args) {
+  assert(!isTrapIntrinsic(fn.getPointer()) && "Use CreateNonMergeableTrap");
   llvm::CallInst *call = IRBuilderBase::CreateCall(fn.getPointer(), args);
   call->setAttributes(fn.getAttributes());
   call->setCallingConv(fn.getCallingConv());

lib/IRGen/IRBuilder.h

@@ -27,6 +27,7 @@
 namespace swift {
 namespace irgen {
 class FunctionPointer;
+class IRGenModule;
 
 typedef llvm::IRBuilder<> IRBuilderBase;
 
@@ -41,6 +42,7 @@ class IRBuilder : public IRBuilderBase {
   /// point was last cleared.  Used only for preserving block
   /// ordering.
   llvm::BasicBlock *ClearedIP;
+  unsigned NumTrapBarriers = 0;
 
 #ifndef NDEBUG
   /// Whether debug information is requested. Only used in assertions.
@@ -300,6 +302,14 @@ class IRBuilder : public IRBuilderBase {
   // llvm::IRBuilder::CreateCall in order to push code towards using
   // FunctionPointer.
 
+  bool isTrapIntrinsic(llvm::Value *Callee) {
+    return Callee == llvm::Intrinsic::getDeclaration(getModule(),
+                                                     llvm::Intrinsic::ID::trap);
+  }
+  bool isTrapIntrinsic(llvm::Intrinsic::ID intrinsicID) {
+    return intrinsicID == llvm::Intrinsic::ID::trap;
+  }
+
   llvm::CallInst *CreateCall(llvm::Value *Callee, ArrayRef<llvm::Value *> Args,
                              const Twine &Name = "",
                              llvm::MDNode *FPMathTag = nullptr) = delete;
@@ -309,6 +319,7 @@ class IRBuilder : public IRBuilderBase {
                              const Twine &Name = "",
                              llvm::MDNode *FPMathTag = nullptr) {
     assert((!DebugInfo || getCurrentDebugLocation()) && "no debugloc on call");
+    assert(!isTrapIntrinsic(Callee) && "Use CreateNonMergeableTrap");
     auto Call = IRBuilderBase::CreateCall(FTy, Callee, Args, Name, FPMathTag);
     setCallingConvUsingCallee(Call);
     return Call;
@@ -320,6 +331,7 @@ class IRBuilder : public IRBuilderBase {
                              llvm::MDNode *FPMathTag = nullptr) {
     // assert((!DebugInfo || getCurrentDebugLocation()) && "no debugloc on
     // call");
+    assert(!isTrapIntrinsic(Callee) && "Use CreateNonMergeableTrap");
     auto Call = IRBuilderBase::CreateCall(Callee, Args, Name, FPMathTag);
     setCallingConvUsingCallee(Call);
     return Call;
@@ -337,6 +349,7 @@ class IRBuilder : public IRBuilderBase {
   llvm::CallInst *CreateIntrinsicCall(llvm::Intrinsic::ID intrinsicID,
                                       ArrayRef<llvm::Value *> args,
                                       const Twine &name = "") {
+    assert(!isTrapIntrinsic(intrinsicID) && "Use CreateNonMergeableTrap");
     auto intrinsicFn =
       llvm::Intrinsic::getDeclaration(getModule(), intrinsicID);
     return CreateCall(intrinsicFn, args, name);
@@ -347,10 +360,16 @@ class IRBuilder : public IRBuilderBase {
                                       ArrayRef<llvm::Type*> typeArgs,
                                       ArrayRef<llvm::Value *> args,
                                       const Twine &name = "") {
+    assert(!isTrapIntrinsic(intrinsicID) && "Use CreateNonMergeableTrap");
     auto intrinsicFn =
       llvm::Intrinsic::getDeclaration(getModule(), intrinsicID, typeArgs);
     return CreateCall(intrinsicFn, args, name);
   }
+
+  /// Call the trap intrinsic. If optimizations are enabled, an inline asm
+  /// gadget is emitted before the trap. The gadget inhibits transforms which
+  /// merge trap calls together, which makes debugging crashes easier.
+  llvm::CallInst *CreateNonMergeableTrap(IRGenModule &IGM);
 };
 
 } // end namespace irgen

lib/IRGen/IRGenFunction.cpp

@@ -432,7 +432,7 @@ Address IRGenFunction::emitAddressAtOffset(llvm::Value *base, Offset offset,
   return Address(slotPtr, objectAlignment);
 }
 
-void IRGenFunction::emitTrap(bool EmitUnreachable) {
+llvm::CallInst *IRBuilder::CreateNonMergeableTrap(IRGenModule &IGM) {
   if (IGM.IRGen.Opts.shouldOptimize()) {
     // Emit unique side-effecting inline asm calls in order to eliminate
     // the possibility that an LLVM optimization or code generation pass
@@ -445,14 +445,20 @@ void IRGenFunction::emitTrap(bool EmitUnreachable) {
         llvm::FunctionType::get(IGM.VoidTy, argTys, false /* = isVarArg */);
     llvm::InlineAsm *inlineAsm =
         llvm::InlineAsm::get(asmFnTy, "", "n", true /* = SideEffects */);
-    Builder.CreateAsmCall(inlineAsm,
-                          llvm::ConstantInt::get(asmArgTy, NumTrapBarriers++));
+    CreateAsmCall(inlineAsm,
+                  llvm::ConstantInt::get(asmArgTy, NumTrapBarriers++));
   }
 
   // Emit the trap instruction.
   llvm::Function *trapIntrinsic =
       llvm::Intrinsic::getDeclaration(&IGM.Module, llvm::Intrinsic::ID::trap);
-  Builder.CreateCall(trapIntrinsic, {});
+  auto Call = IRBuilderBase::CreateCall(trapIntrinsic, {});
+  setCallingConvUsingCallee(Call);
+  return Call;
+}
+
+void IRGenFunction::emitTrap(bool EmitUnreachable) {
+  Builder.CreateNonMergeableTrap(IGM);
   if (EmitUnreachable)
     Builder.CreateUnreachable();
 }

lib/IRGen/IRGenFunction.h

@@ -280,7 +280,6 @@ class IRGenFunction {
   void emitTrap(bool EmitUnreachable);
 
 private:
-  unsigned NumTrapBarriers = 0;
   llvm::Instruction *AllocaIP;
   const SILDebugScope *DbgScope;