[CIR][CodeGen] Implement tryMarkNoThrow and update wrong test (llvm#1664)

This PR introduces
[`TryMarkNoThrow`](https://github.com/llvm/clangir/blob/6e5fa09550c98f84d017873ed3e5667fd5fd909c/clang/lib/CodeGen/CodeGenFunction.cpp#L1394).
[`isInterposable`](https://github.com/llvm/clangir/blob/6e5fa09550c98f84d017873ed3e5667fd5fd909c/clang/lib/CodeGen/CodeGenFunction.cpp#L1397C10-L1397C26)
isn't fully implemented and I'm not quite sure we need it? Anyway, I
have introduced a missing feature `getSemanticInterposition` relevant
for its completion.

I have also updated an old test --
[`foo()`](https://github.com/llvm/clangir/blob/6e5fa09550c98f84d017873ed3e5667fd5fd909c/clang/test/CIR/CodeGen/try-catch-dtors.cpp#L313)
should be marked as unwind/nothrow. I have compared with the original
CodeGen and attached the llvm output for verification.

One concern I have is if the cases I have to mimic
[`mayThrow`](https://github.com/llvm/clangir/blob/6e5fa09550c98f84d017873ed3e5667fd5fd909c/llvm/lib/IR/Instruction.cpp#L1158)
from the OG are enough, please let me know your thoughts.

Author: bruteforceboy

clang/include/clang/CIR/MissingFeatures.h

@@ -239,7 +239,6 @@ struct MissingFeatures {
   static bool emitScalarRangeCheck() { return false; }
   static bool stmtExprEvaluation() { return false; }
   static bool setCallingConv() { return false; }
-  static bool tryMarkNoThrow() { return false; }
   static bool indirectBranch() { return false; }
   static bool escapedLocals() { return false; }
   static bool deferredReplacements() { return false; }
@@ -251,6 +250,7 @@ struct MissingFeatures {
   static bool createLaunderInvariantGroup() { return false; }
   static bool hipModuleCtor() { return false; }
   static bool checkMacOSXTriple() { return false; }
+  static bool getSemanticInterposition() { return false; }
 
   // Inline assembly
   static bool asmGoto() { return false; }

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -381,6 +381,7 @@ emitCallLikeOp(CIRGenFunction &CGF, mlir::Location callLoc,
           callLoc, directFuncOp, CIRCallArgs, callingConv, sideEffect);
     }
     callOpWithExceptions->setAttr("extra_attrs", extraFnAttrs);
+    CGF.mayThrow = true;
 
     CGF.callWithExceptionCtx = callOpWithExceptions;
     auto *invokeDest = CGF.getInvokeDest(tryOp);

clang/lib/CIR/CodeGen/CIRGenException.cpp

@@ -283,6 +283,7 @@ void CIRGenFunction::emitEHResumeBlock(bool isCleanup,
 
   getBuilder().create<cir::ResumeOp>(loc, mlir::Value{}, mlir::Value{});
   getBuilder().restoreInsertionPoint(ip);
+  mayThrow = true;
 }
 
 mlir::Block *CIRGenFunction::getEHResumeBlock(bool isCleanup,

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -634,6 +634,28 @@ static void eraseEmptyAndUnusedBlocks(cir::FuncOp fnOp) {
     b->erase();
 }
 
+static bool isInterposable(cir::FuncOp fn) {
+  if (isInterposableLinkage(fn.getLinkage()))
+    return true;
+
+  assert(!cir::MissingFeatures::getSemanticInterposition());
+
+  return false;
+}
+
+static void tryMarkNoThrow(CIRGenFunction &cgf, cir::FuncOp fn) {
+  // LLVM treats 'nounwind' on a function as part of the type, so we
+  // can't do this on functions that can be overwritten.
+  if (isInterposable(fn) || cgf.mayThrow)
+    return;
+
+  mlir::NamedAttrList extraAttrs{fn.getExtraAttrs().getElements().getValue()};
+  auto noThrowAttr = cir::NoThrowAttr::get(&cgf.getMLIRContext());
+  extraAttrs.set(noThrowAttr.getMnemonic(), noThrowAttr);
+  fn.setExtraAttrsAttr(cir::ExtraFuncAttributesAttr::get(
+      extraAttrs.getDictionary(&cgf.getMLIRContext())));
+}
+
 cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn,
                                          const CIRGenFunctionInfo &fnInfo) {
   assert(fn && "generating code for a null function");
@@ -780,7 +802,7 @@ cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn,
 
     // If we haven't marked the function nothrow through other means, do a quick
     // pass now to see if we can.
-    assert(!cir::MissingFeatures::tryMarkNoThrow());
+    tryMarkNoThrow(*this, fn);
   }
 
   eraseEmptyAndUnusedBlocks(fn);

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -512,6 +512,10 @@ class CIRGenFunction : public CIRGenTypeCache {
   /// the constructor, but could be overwrriten to true if this is a coroutine.
   bool ShouldEmitLifetimeMarkers;
 
+  /// True if there are any operations in the body of the function that are
+  /// likely to throw an exception.
+  bool mayThrow = false;
+
   using DeclMapTy = llvm::DenseMap<const clang::Decl *, Address>;
   /// This keeps track of the CIR allocas or globals for local C
   /// delcs.

clang/lib/CIR/CodeGen/CIRGenItaniumCXXABI.cpp

@@ -2304,6 +2304,7 @@ void CIRGenItaniumCXXABI::emitRethrow(CIRGenFunction &CGF, bool isNoReturn) {
     auto loc = *CGF.currSrcLoc;
     insertThrowAndSplit(builder, loc, mlir::Value{}, mlir::FlatSymbolRefAttr{},
                         mlir::FlatSymbolRefAttr{});
+    CGF.mayThrow = true;
   } else {
     llvm_unreachable("NYI");
   }
@@ -2370,6 +2371,8 @@ void CIRGenItaniumCXXABI::emitThrow(CIRGenFunction &CGF,
   // Now throw the exception.
   mlir::Location loc = CGF.getLoc(E->getSourceRange());
   insertThrowAndSplit(builder, loc, exceptionPtr, typeInfo.getSymbol(), dtor);
+
+  CGF.mayThrow = true;
 }
 
 mlir::Value CIRGenItaniumCXXABI::getVirtualBaseClassOffset(

clang/test/CIR/CodeGen/try-catch-dtors.cpp

@@ -324,22 +324,21 @@ void bar() {
 // CIR-LABEL: @_Z3barv
 // CIR:  %[[V0:.*]] = cir.alloca !rec_A, !cir.ptr<!rec_A>, ["a"] {alignment = 1 : i64}
 // CIR:  %[[V1:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["b", init] {alignment = 4 : i64}
-// CIR:  %[[V2:.*]] = cir.alloca !s32i, !cir.ptr<!s32i>, ["tmp.try.call.res"] {alignment = 4 : i64}
-// CIR:  cir.try synthetic cleanup {
-// CIR:    %[[V4:.*]] = cir.call exception @_Z3foov() : () -> !s32i cleanup {
-// CIR:      cir.call @_ZN1AD2Ev(%[[V0]]) : (!cir.ptr<!rec_A>) -> () extra(#fn_attr)
-// CIR:      cir.yield
-// CIR:    }
-// CIR:    cir.store{{.*}} %[[V4]], %[[V2]] : !s32i, !cir.ptr<!s32i>
-// CIR:    cir.yield
-// CIR:  } catch [#cir.unwind {
-// CIR:    cir.resume
-// CIR:  }]
-// CIR:  %[[V3:.*]] = cir.load{{.*}} %[[V2]] : !cir.ptr<!s32i>, !s32i
-// CIR:  cir.store{{.*}} %[[V3]], %[[V1]] : !s32i, !cir.ptr<!s32i>
-// CIR:  cir.call @_ZN1AD2Ev(%[[V0]]) : (!cir.ptr<!rec_A>) -> () extra(#fn_attr)
+// CIR:  %[[V2:.*]] = cir.call @_Z3foov() : () -> !s32i
+// CIR:  cir.store align(4) %[[V2]], %[[V1]] : !s32i, !cir.ptr<!s32i>
+// CIR:  cir.call @_ZN1AD2Ev(%[[V0]]) : (!cir.ptr<!rec_A>) -> ()
 // CIR:  cir.return
 
+// LLVM: ; Function Attrs: noinline nounwind optnone
+// LLVM-NEXT: _Z3foo
+// LLVM: @_Z3barv()
+// LLVM:   %[[V1:.*]] = alloca %struct.A, i64 1, align 1
+// LLVM:   %[[V2:.*]] = alloca i32, i64 1, align 4
+// LLVM:   %[[V3:.*]] = call i32 @_Z3foov()
+// LLVM:   store i32 %[[V3]], ptr %[[V2]], align 4
+// LLVM:   call void @_ZN1AD2Ev(ptr %[[V1]])
+// LLVM:   ret void
+
 class C {
 public:
   ~C();