Use emitCallOrInvoke for all calls

Since it handles adding the operand bundles.
dotnet · Sep 18, 2023 · 8f157fe · 8f157fe
1 parent 36a6d1c
commit 8f157fe
Show file tree

Hide file tree

Showing 3 changed files with 26 additions and 19 deletions.
diff --git a/src/coreclr/jit/llvm.h b/src/coreclr/jit/llvm.h
@@ -504,7 +504,8 @@ class Llvm
     void emitJumpToThrowHelper(Value* jumpCondValue, SpecialCodeKind throwKind);
     Value* emitCheckedArithmeticOperation(llvm::Intrinsic::ID intrinsicId, Value* op1Value, Value* op2Value);
     llvm::CallBase* emitHelperCall(CorInfoHelpFunc helperFunc, ArrayRef<Value*> sigArgs = {});
-    llvm::CallBase* emitCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<Value*> args = {});
+    llvm::CallBase* emitCallOrInvoke(llvm::Function* callee, ArrayRef<Value*> args = {});
+    llvm::CallBase* emitCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<Value*> args, bool isThrowingCall);
 
     FunctionType* createFunctionType();
     llvm::FunctionCallee consumeCallTarget(GenTreeCall* call);

diff --git a/src/coreclr/jit/llvmcodegen.cpp b/src/coreclr/jit/llvmcodegen.cpp
@@ -1765,19 +1765,7 @@ void Llvm::buildCall(GenTreeCall* call)
     }
 
     llvm::FunctionCallee llvmFuncCallee = consumeCallTarget(call);
-    Value* callValue;
-    if (call->IsUnmanaged())
-    {
-        // We do not support exceptions propagating through native<->managed boundaries.
-        llvm::CallInst* callInst = _builder.CreateCall(llvmFuncCallee, argVec);
-        callInst->addFnAttr(llvm::Attribute::NoUnwind);
-
-        callValue = callInst;
-    }
-    else
-    {
-        callValue = emitCallOrInvoke(llvmFuncCallee, argVec);
-    }
+    Value* callValue = emitCallOrInvoke(llvmFuncCallee, argVec, mayPhysicallyThrow(call));
 
     mapGenTreeToValue(call, callValue);
 }
@@ -2471,10 +2459,14 @@ llvm::CallBase* Llvm::emitHelperCall(CorInfoHelpFunc helperFunc, ArrayRef<Value*
     return call;
 }
 
-llvm::CallBase* Llvm::emitCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<Value*> args)
+llvm::CallBase* Llvm::emitCallOrInvoke(llvm::Function* callee, ArrayRef<Value*> args)
+{
+    return emitCallOrInvoke(callee, args, !callee->doesNotThrow());
+}
+
+llvm::CallBase* Llvm::emitCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<Value*> args, bool isThrowingCall)
 {
     Function* llvmFunc = llvm::dyn_cast<Function>(callee.getCallee());
-    bool isThrowingCall = (llvmFunc == nullptr) || !llvmFunc->doesNotThrow();
     llvm::BasicBlock* catchLlvmBlock = getUnwindLlvmBlockForCurrentInvoke();
 
     llvm::SmallVector<llvm::OperandBundleDef, 1> bundles{};
@@ -2497,6 +2489,11 @@ llvm::CallBase* Llvm::emitCallOrInvoke(llvm::FunctionCallee callee, ArrayRef<Val
     else
     {
         callInst = _builder.CreateCall(callee, args, bundles);
+
+        if (!isThrowingCall)
+        {
+            callInst->setDoesNotThrow();
+        }
     }
 
     if (isThrowingCall && (m_ehModel == CorInfoLlvmEHModel::Emulated))
@@ -2569,7 +2566,7 @@ llvm::FunctionCallee Llvm::consumeCallTarget(GenTreeCall* call)
         {
             FunctionType* callFuncType = createFunctionTypeForCall(call);
             Function* calleeAccessorFunc = getOrCreateExternalLlvmFunctionAccessor(symbolName);
-            Value* calleeValue = _builder.CreateCall(calleeAccessorFunc);
+            Value* calleeValue = emitCallOrInvoke(calleeAccessorFunc);
 
             callee = {callFuncType, calleeValue};
         }

diff --git a/src/coreclr/jit/llvmlower.cpp b/src/coreclr/jit/llvmlower.cpp
@@ -1898,9 +1898,18 @@ CORINFO_GENERIC_HANDLE Llvm::generateUnwindTable()
 //
 bool Llvm::mayPhysicallyThrow(GenTree* node)
 {
-    if (node->IsHelperCall())
+    if (node->IsCall())
     {
-        return helperCallMayPhysicallyThrow(node->AsCall()->GetHelperNum());
+        if (node->IsHelperCall())
+        {
+            return helperCallMayPhysicallyThrow(node->AsCall()->GetHelperNum());
+        }
+
+        // We do not support exceptions propagating through native<->managed boundaries.
+        if (node->AsCall()->IsUnmanaged())
+        {
+            return false;
+        }
     }
 
     return node->OperMayThrow(_compiler);