Verifier: Reject non-float !fpmath

[arsenm]

Summary

Code already assumes this is float. getFPAccuracy() crashes on any other type.

[ab]

Add a LangRef comment?

lib/IR/Verifier.cpp

3672

Maybe something more explicit like "must have float type"?

[arsenm]

Update langref, change error message

[ab]

Thanks, LGTM

lib/IR/Verifier.cpp

3671

Looking at this again: perhaps cleaner to do CFP0->getType()->isFloatTy() ?

[arsenm]

lib/IR/Verifier.cpp

3671

Since the other condition needs the APFloat anyway maybe it's more consistent to use it to check all the conditions?

[ab]

lib/IR/Verifier.cpp

3671

Eh, fair enough; lgtm

[arsenm]

r273912

docs/LangRef.rst

 it. ULP is defined as follows:
 
     If ``x`` is a real number that lies between two finite consecutive
     floating-point numbers ``a`` and ``b``, without being equal to one
     of them, then ``ulp(x) = |b - a|``, otherwise ``ulp(x)`` is the
     distance between the two non-equal finite floating-point numbers
     nearest ``x``. Moreover, ``ulp(NaN)`` is ``NaN``.
 
-The metadata node shall consist of a single positive floating point
-number representing the maximum relative error, for example:
+The metadata node shall consist of a single positive float type number
+representing the maximum relative error, for example:
 
 .. code-block:: llvm
 
     !0 = !{ float 2.5 } ; maximum acceptable inaccuracy is 2.5 ULPs
 
 .. _range-metadata:
 
 '``range``' Metadata

lib/IR/Verifier.cpp

void Verifier::visitInstruction(Instruction &I) {
 
   if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
     Assert(I.getType()->isFPOrFPVectorTy(),
            "fpmath requires a floating point result!", &I);
     Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
     if (ConstantFP *CFP0 =
             mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) {
       const APFloat &Accuracy = CFP0->getValueAPF();
+      Assert(&Accuracy.getSemantics() == &APFloat::IEEEsingle,
+             "fpmath accuracy must have float type", &I);
       Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
              "fpmath accuracy not a positive number!", &I);
     } else {
       Assert(false, "invalid fpmath accuracy!", &I);
     }
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {

test/Verifier/fpmath.ll

; Above line is correct.
   %w2 = fadd <2 x float> %g, %g, !fpmath !0
 ; Above line is correct.
   %x = fadd float %f, %f, !fpmath !4
 ; CHECK: fpmath accuracy not a positive number!
   %y = fadd float %f, %f, !fpmath !5
 ; CHECK: fpmath accuracy not a positive number!
   %z = fadd float %f, %f, !fpmath !6
 ; CHECK: fpmath accuracy not a positive number!
+  %double.fpmath = fadd float %f, %f, !fpmath !7
+; CHECK: fpmath accuracy must have float type
   ret void
 }
 
 !0 = !{ float 1.0 }
 !1 = !{ }
 !2 = !{ float 1.0, float 1.0 }
 !3 = !{ i32 1 }
 !4 = !{ float -1.0 }
 !5 = !{ float 0.0 }
 !6 = !{ float 0x7FFFFFFF00000000 }
+!7 = !{ double 1.0 }