Fix for bug 24196: clang fails on assertion on complex doubles multiplication when EH is enabled

[• d.zobnin.bugzilla]

Summary

This patch fixes an assertion failure, caused by EmitCall function producing llvm::InvokeInst* when llvm::CallInst* is needed (when multiplication of complex arguments is being emitted).

[rjmccall]

This is an inappropriate fix for this problem. If these runtime functions can never throw, which seems to be the case, you should create the function type with a no-throw exception specification, which will make EmitCall emit the call with a CallInst. EST_BasicNoexcept should be sufficient.

[• d.zobnin.bugzilla]

This issue is fixed in http://reviews.llvm.org/rL253926.

lib/CodeGen/CGCall.cpp

void CodeGenFunction::deferPlaceholderReplacement(llvm::Instruction *Old,
   DeferredReplacements.push_back(std::make_pair(Old, New));
 }
 
 RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
                                  llvm::Value *Callee,
                                  ReturnValueSlot ReturnValue,
                                  const CallArgList &CallArgs,
                                  const Decl *TargetDecl,
-                                 llvm::Instruction **callOrInvoke) {
+                                 llvm::Instruction **callOrInvoke,
+                                 bool forceCallInstCreation) {
   // FIXME: We no longer need the types from CallArgs; lift up and simplify.
 
+  // It may be nessesary to create a CallInst* even if TargetDecl is not given
+  // (e. g. when emitting a complex operation call). Without TargetDecl there is
+  // no way to check the NoUnwind attribute required for CallInst creation. Use
+  // specific flag then, but take care of possible logical violations.
+  assert(!(TargetDecl && forceCallInstCreation) &&
+         "Should not force creation of CallInst if TargetDecl is present!");
+
   // Handle struct-return functions by passing a pointer to the
   // location that we would like to return into.
   QualType RetTy = CallInfo.getReturnType();
   const ABIArgInfo &RetAI = CallInfo.getReturnInfo();
 
   llvm::FunctionType *IRFuncTy =
     cast<llvm::FunctionType>(
                   cast<llvm::PointerType>(Callee->getType())->getElementType());
#endif
 
   llvm::BasicBlock *InvokeDest = nullptr;
   if (!Attrs.hasAttribute(llvm::AttributeSet::FunctionIndex,
                           llvm::Attribute::NoUnwind) ||
       currentFunctionUsesSEHTry())
     InvokeDest = getInvokeDest();
 
   llvm::CallSite CS;
-  if (!InvokeDest) {
+  if (!InvokeDest || forceCallInstCreation) {
     CS = Builder.CreateCall(Callee, IRCallArgs);
   } else {
     llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
     CS = Builder.CreateInvoke(Callee, Cont, InvokeDest, IRCallArgs);
     EmitBlock(Cont);
   }
   if (callOrInvoke)
     *callOrInvoke = CS.getInstruction();

lib/CodeGen/CGExprComplex.cpp

const CGFunctionInfo &FuncInfo =
     CGF.CGM.getTypes().arrangeFreeFunctionCall(
       Op.Ty, Args, FunctionType::ExtInfo(/* No CC here - will be added later */),
       RequiredArgs::All);
   llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
   llvm::Constant *Func = CGF.CGM.CreateBuiltinFunction(FTy, LibCallName);
   llvm::Instruction *Call;
 
   RValue Res = CGF.EmitCall(FuncInfo, Func, ReturnValueSlot(), Args,
-                            nullptr, &Call);
+                            nullptr, &Call, /*forceCallInstCreation =*/ true);
   cast<llvm::CallInst>(Call)->setCallingConv(CGF.CGM.getBuiltinCC());
   cast<llvm::CallInst>(Call)->setDoesNotThrow();
 
   return Res.getComplexVal();
 }
 
 /// \brief Lookup the libcall name for a given floating point type complex
 /// multiply.

lib/CodeGen/CodeGenFunction.h

public:
   ///
   /// \param TargetDecl - If given, the decl of the function in a direct call;
   /// used to set attributes on the call (noreturn, etc.).
   RValue EmitCall(const CGFunctionInfo &FnInfo,
                   llvm::Value *Callee,
                   ReturnValueSlot ReturnValue,
                   const CallArgList &Args,
                   const Decl *TargetDecl = nullptr,
-                  llvm::Instruction **callOrInvoke = nullptr);
+                  llvm::Instruction **callOrInvoke = nullptr,
+                  bool forceCallInstCreation = false);
 
   RValue EmitCall(QualType FnType, llvm::Value *Callee, const CallExpr *E,
                   ReturnValueSlot ReturnValue,
                   const Decl *TargetDecl = nullptr,
                   llvm::Value *Chain = nullptr);
   RValue EmitCallExpr(const CallExpr *E,
                       ReturnValueSlot ReturnValue = ReturnValueSlot());
 

test/CodeGenCXX/complex_mul_call.cpp

+// Check that multiplication of complex arguments is performed properly without
+// assersion fails when exceptions are enabled.
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-unknown -fexceptions -fcxx-exceptions -emit-llvm %s -o - | FileCheck %s
+
+struct A {
+  int x;
+  A() { x = 10; }
+  ~A() { x = 20; }
+};
+
+int main() {
+  {
+    A a;
+    double __complex__ d;
+    float __complex__ f;
+    // CHECK-LABEL: main
+    // CHECK-DAG: call {{.*}} @__muldc3
+    double __complex__ d1 = d * d;
+    // CHECK-DAG: call {{.*}} @__mulsc3
+    float __complex__ f1 = f * f;
+  }
+  return 0;
+}