AsmParser: Allow FMF on varargs call

[tpr]

Summary

D14707 added code to allow FMF on a call with a float or vector of float
return type. But it accidentally disallowed it when using (...) syntax
for a varargs call. This commit fixes that.

[spatel]

Does D69161 cover this change? If so, we could add the test there and fix the problem in 1 step.

[foad]

In D69557#1725496, @spatel wrote:

Does D69161 cover this change? If so, we could add the test there and fix the problem in 1 step.

I think this bug fix is orthogonal to D69161, which adds new functionality.

[tpr]

In D69557#1725564, @foad wrote:

In D69557#1725496, @spatel wrote:

Does D69161 cover this change? If so, we could add the test there and fix the problem in 1 step.

I think this bug fix is orthogonal to D69161, which adds new functionality.

The way you have changed the call check to !isa<FPMathOperator>(CI) means you might have accidentally fixed my bug anyway. I'll check later.

[foad]

In D69557#1725616, @tpr wrote:

In D69557#1725564, @foad wrote:

In D69557#1725496, @spatel wrote:

Does D69161 cover this change? If so, we could add the test there and fix the problem in 1 step.

I think this bug fix is orthogonal to D69161, which adds new functionality.

The way you have changed the call check to !isa<FPMathOperator>(CI) means you might have accidentally fixed my bug anyway. I'll check later.

You're right, I have accidentally fixed your bug. It would still be good to commit your test case, which LGTM.

[foad]

I committed your test in rGb136238bb4e5.

llvm/lib/AsmParser/LLParser.cpp

if (ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
       ParseValID(CalleeID) ||
       ParseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
                          PFS.getFunction().isVarArg()) ||
       ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false, BuiltinLoc) ||
       ParseOptionalOperandBundles(BundleList, PFS))
     return true;
 
-  if (FMF.any() && !RetType->isFPOrFPVectorTy())
-    return Error(CallLoc, "fast-math-flags specified for call without "
-                          "floating-point scalar or vector return type");
-
   // If RetType is a non-function pointer type, then this is the short syntax
   // for the call, which means that RetType is just the return type.  Infer the
   // rest of the function argument types from the arguments that are present.
   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
   if (!Ty) {
     // Pull out the types of all of the arguments...
     std::vector<Type*> ParamTypes;
     for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
       return Error(RetTypeLoc, "Invalid result type for LLVM function");
 
     Ty = FunctionType::get(RetType, ParamTypes, false);
-  }
+  } else
+    RetType = Ty->getReturnType();
+
+  if (FMF.any() && !RetType->isFPOrFPVectorTy())
+    return Error(CallLoc, "fast-math-flags specified for call without "
+                          "floating-point scalar or vector return type");
 
   CalleeID.FTy = Ty;
 
   // Look up the callee.
   Value *Callee;
   if (ConvertValIDToValue(PointerType::get(Ty, CallAddrSpace), CalleeID, Callee,
                           &PFS, /*IsCall=*/true))
     return true;

llvm/test/Assembler/fast-math-flags.ll

; CHECK:  %e_vec = frem nnan <3 x float> %vec, %vec
   %e_vec = frem nnan <3 x float> %vec, %vec
 ; CHECK:  %f = fneg nnan nsz float %x
   %f = fneg nnan nsz float %x
 ; CHECK:  %f_vec = fneg fast <3 x float> %vec
   %f_vec = fneg fast <3 x float> %vec
 ; CHECK:  ret float %f
   ret float %f
 }
+
+; CHECK: @fmf_calls(
+define float @fmf_calls(float %x, float %y) {
+entry:
+; CHECK:  %vec = load <3 x float>, <3 x float>* @vec
+  %vec    = load <3 x float>, <3 x float>* @vec
+; CHECK:  %select = load i1, i1* @select
+  %select = load i1, i1* @select
+; CHECK:  %arr = load [3 x float], [3 x float]* @arr
+  %arr    = load [3 x float], [3 x float]* @arr
+
+; CHECK:  %a = call nnan ninf afn float @extfunc(float %x, float %y)
+  %a = call ninf nnan afn float @extfunc(float %x, float %y)
+; CHECK:  %a_vec = call reassoc nnan <3 x float> @extfunc_vec(<3 x float> %vec, <3 x float> %vec)
+  %a_vec = call reassoc nnan <3 x float> @extfunc_vec(<3 x float> %vec, <3 x float> %vec)
+; CHECK:  %b = call nnan ninf afn float (...) @var_extfunc(float %x, float %y)
+  %b = call ninf nnan afn float (...) @var_extfunc(float %x, float %y)
+; CHECK:  %b_vec = call reassoc nnan <3 x float> (...) @var_extfunc_vec(<3 x float> %vec, <3 x float> %vec)
+  %b_vec = call reassoc nnan <3 x float> (...) @var_extfunc_vec(<3 x float> %vec, <3 x float> %vec)
+; CHECK:  ret float %a
+  ret float %a
+}
+
+declare float @extfunc(float, float)
+declare <3 x float> @extfunc_vec(<3 x float>, <3 x float>)
+declare float @var_extfunc(...)
+declare <3 x float> @var_extfunc_vec(...)
+