[AArch64] Fix handling of integer fp immediates

[john.brawn]

Summary

When an integer is used as an fp immediate we're failing to check the return value of getFP64Imm, so invalid values are silently permitted. Fix this by merging together the integer and real handling.

[john.brawn]

Add diff context.

[john.brawn]

Accidentally used the wrong diff, attach the correct one.

[rengolin]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

2118

Why you don't need to "eat the token" anymore?

[john.brawn]

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

2118

It's now handled down on line 2127.

[john.brawn]

Ping.

[rengolin]

Sorry, LGTM. Thanks!

[john.brawn]

Committed r300828.

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

AArch64AsmParser::tryParseFPImm(OperandVector &Operands) {
   SMLoc S = getLoc();
 
   bool Hash = parseOptionalToken(AsmToken::Hash);
 
   // Handle negation, as that still comes through as a separate token.
   bool isNegative = parseOptionalToken(AsmToken::Minus);
 
   const AsmToken &Tok = Parser.getTok();
-  if (Tok.is(AsmToken::Real)) {
+  if (Tok.is(AsmToken::Real) || Tok.is(AsmToken::Integer)) {
+    int64_t Val;
+    if (Tok.is(AsmToken::Integer) && !isNegative && Tok.getString().startswith("0x")) {
+      Val = Tok.getIntVal();
+      if (Val > 255 || Val < 0) {
+        TokError("encoded floating point value out of range");
+        return MatchOperand_ParseFail;
+      }
+    } else {
       APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
       if (isNegative)
         RealVal.changeSign();
 
       uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
-    int Val = AArch64_AM::getFP64Imm(APInt(64, IntVal));
-    Parser.Lex(); // Eat the token.
+      Val = AArch64_AM::getFP64Imm(APInt(64, IntVal));
+
       // Check for out of range values. As an exception, we let Zero through,
       // as we handle that special case in post-processing before matching in
       // order to use the zero register for it.
       if (Val == -1 && !RealVal.isPosZero()) {
         TokError("expected compatible register or floating-point constant");
         return MatchOperand_ParseFail;
       }
-    Operands.push_back(AArch64Operand::CreateFPImm(Val, S, getContext()));
-    return MatchOperand_Success;
-  }
-  if (Tok.is(AsmToken::Integer)) {
-    int64_t Val;
-    if (!isNegative && Tok.getString().startswith("0x")) {
-      Val = Tok.getIntVal();
-      if (Val > 255 || Val < 0) {
-        TokError("encoded floating point value out of range");
-        return MatchOperand_ParseFail;
-      }
-    } else {
-      APFloat RealVal(APFloat::IEEEdouble(), Tok.getString());
-      uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
-      // If we had a '-' in front, toggle the sign bit.
-      IntVal ^= (uint64_t)isNegative << 63;
-      Val = AArch64_AM::getFP64Imm(APInt(64, IntVal));
     }
     Parser.Lex(); // Eat the token.
     Operands.push_back(AArch64Operand::CreateFPImm(Val, S, getContext()));
     return MatchOperand_Success;
   }
 
   if (!Hash)
     return MatchOperand_NoMatch;

test/MC/AArch64/basic-a64-diagnostics.s

 // CHECK-ERROR-NEXT:              ^
 
 //------------------------------------------------------------------------------
 // Floating-point immediate
 //------------------------------------------------------------------------------
         ;; Exponent too large
         fmov d3, #0.0625
         fmov s2, #32.0
+        fmov s2, #32
+        fmov v0.4s, #-32
 // CHECK-ERROR: error: expected compatible register or floating-point constant
 // CHECK-ERROR-NEXT:           fmov d3, #0.0625
 // CHECK-ERROR-NEXT:                    ^
 // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
 // CHECK-ERROR-NEXT:           fmov s2, #32.0
 // CHECK-ERROR-NEXT:                    ^
+// CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
+// CHECK-ERROR-NEXT:           fmov s2, #32
+// CHECK-ERROR-NEXT:                    ^
+// CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
+// CHECK-ERROR-NEXT:           fmov v0.4s, #-32
+// CHECK-ERROR-NEXT:                       ^
 
         ;; Fraction too precise
         fmov s9, #1.03125
         fmov s28, #1.96875
 // CHECK-ERROR: error: expected compatible register or floating-point constant
 // CHECK-ERROR-NEXT:           fmov s9, #1.03125
 // CHECK-ERROR-NEXT:                    ^
 // CHECK-ERROR-NEXT: error: expected compatible register or floating-point constant
 // CHECK-ERROR-NEXT:           fmov s28, #1.96875
 // CHECK-ERROR-NEXT:                     ^
 
+        ;; Explicitly encoded value too large
+        fmov s15, #0x100
+// CHECK-ERROR: error: encoded floating point value out of range
+// CHECK-ERROR-NEXT:           fmov s15, #0x100
+// CHECK-ERROR-NEXT:                     ^
+
         ;; No particular reason, but a striking omission
         fmov d0, #0.0
 // CHECK-ERROR-AARCH64: error: expected compatible register or floating-point constant
 // CHECK-ERROR-AARCH64-NEXT:           fmov d0, #0.0
 // CHECK-ERROR-AARCH64-NEXT:                    ^
 
 //------------------------------------------------------------------------------
 // Floating-point <-> integer conversion