[AArch64][SVE] Asm: Add parsing/printing support for exact FP immediates.

[sdesmalen]

Summary

Some instructions require of a limited set of FP immediates as operands,
for example '#0.5 or #1.0' for SVE's FADD instruction.

This patch adds support for parsing and printing such FP immediates as
exact values (e.g. #0.499999 is not accepted for #0.5).

[SjoerdMeijer]

Hi, I might be missing something, but why do we need this? Why is this not the same as the already existing "k_FPImm" case (with perhaps an additional check somewhere to see if it is one of these 4 expected values)?

[sdesmalen]

The k_FPImm case works a little different.. Instead of it storing the APFloat value, it stores the (AArch64_AM) encoded FP imm value. If the value cannot be encoded, the parser throws an error. Also not all values can be encoded, such as '0.0', for which the parser (for k_FPImm) puts in a "#0.0" string literal into the parsed operands list. The two cases can be merged, but I think it may be better to do that in a separate patch as this will require some refactoring and changes to match e.g. the #0.0 case in existing FP instructions.

[olista01]

It looks like we currently have two ways in which floating-point operands can get parsed, and this patch adds a third, which accepts values which overlap with both of the existing ones. Instead, this seems like a good time to tidy this up, always parsing to the same AArch64Operand, and using predicate functions to check if the value is valid for each operand type, as we do for integer operands with different ranges.

[sdesmalen]

Hi @olista01 , I just tried merging this change with k_FPImm and one of the problems I'm running into is with the '#0.0' and InstAliases.
For example in SVEInstrFormats.td, class sve_int_dup_imm:

InstAlias<"fmov $Zd, #0.0", (!cast<Instruction>(NAME # _S) ZPR32:$Zd, 0, 0), 1>;

If #0.0 would be an operand of type fpimm0, say fpimm0:$imm, then TableGen tells me the operand needs to be used in the instruction. But not only would we want to pass 0 instead of $imm, the immediate for sve_int_dup_imm is of a completely different type, namely cpy_imm8_opt_lsl_i32. Do you have any suggestions how to solve that?

Also which are the other two ways you mention? (I only know of k_FPImm?)

[sdesmalen]

Merged k_ExactFPImm with k_FPImm.

[SjoerdMeijer]

Thanks, this looks a lot better IMO.

lib/Target/AArch64/AArch64SystemOperands.td

249

The only thing I am wondering is if we can easily get rid of this of these "half", "one", etc., definitions? This still feels a bit like a few special cases, a bit hacky if you like, that can perhaps be made a bit more generic. I don't have a suggestion yet how though; I would need to spend some more time looking at it.

[SjoerdMeijer]

Looks OK to me.

lib/Target/AArch64/AArch64SystemOperands.td

240

Nit: I think some comments how and why this is used (for SVE) would be good. I mean, "ExactFPImm" is kind of a generic name, but this is used a lookup table for a few instructions that only accept a few specific immediates.

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

135

Nit: perpahs a bit more descriptive name, e.g. AddFPZeroAsLiteral, or just AddZeroAsLiteral?

lib/Target/AArch64/AArch64SystemOperands.td

 def : SVEPREDPAT<"vl64",  0x0b>;
 def : SVEPREDPAT<"vl128", 0x0c>;
 def : SVEPREDPAT<"vl256", 0x0d>;
 def : SVEPREDPAT<"mul4",  0x1d>;
 def : SVEPREDPAT<"mul3",  0x1e>;
 def : SVEPREDPAT<"all",   0x1f>;
 
 //===----------------------------------------------------------------------===//
+// Named FP Immediates
+//===----------------------------------------------------------------------===//
+class ExactFPImm<string name, string repr, bits<4> enum > : SearchableTable {
+  let SearchableFields = ["Enum", "Repr"];
+  let EnumValueField = "Enum";
+
+  string Name = name;
+  bits<4> Enum = enum;
+  string Repr = repr;
+}
+
+def : ExactFPImm<"zero", "0.0", 0x0>;
+def : ExactFPImm<"half", "0.5", 0x1>;
+def : ExactFPImm<"one",  "1.0", 0x2>;
+def : ExactFPImm<"two",  "2.0", 0x3>;
+
+//===----------------------------------------------------------------------===//
 // PState instruction options.
 //===----------------------------------------------------------------------===//
 
 class PState<string name, bits<5> encoding> : SearchableTable {
   let SearchableFields = ["Name", "Encoding"];
   let EnumValueField = "Encoding";
 
   string Name = name;

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

#include "AArch64GenAsmMatcher.inc"
   OperandMatchResultTy tryParseMRSSystemRegister(OperandVector &Operands);
   OperandMatchResultTy tryParseSysReg(OperandVector &Operands);
   OperandMatchResultTy tryParseSysCROperand(OperandVector &Operands);
   template <bool IsSVEPrefetch = false>
   OperandMatchResultTy tryParsePrefetch(OperandVector &Operands);
   OperandMatchResultTy tryParsePSBHint(OperandVector &Operands);
   OperandMatchResultTy tryParseAdrpLabel(OperandVector &Operands);
   OperandMatchResultTy tryParseAdrLabel(OperandVector &Operands);
   OperandMatchResultTy tryParseFPImm(OperandVector &Operands);
+  LLVM_ATTRIBUTE_UNUSED
+  OperandMatchResultTy tryParseExactFPImm(OperandVector &Operands);
   OperandMatchResultTy tryParseImmWithOptionalShift(OperandVector &Operands);
   OperandMatchResultTy tryParseGPR64sp0Operand(OperandVector &Operands);
   bool tryParseNeonVectorRegister(OperandVector &Operands);
   OperandMatchResultTy tryParseVectorIndex(OperandVector &Operands);
   OperandMatchResultTy tryParseGPRSeqPair(OperandVector &Operands);
   template <bool ParseShiftExtend>
   OperandMatchResultTy tryParseGPROperand(OperandVector &Operands);
   template <bool ParseShiftExtend, bool ParseSuffix>
enum KindTy {
     k_VectorList,
     k_VectorIndex,
     k_Token,
     k_SysReg,
     k_SysCR,
     k_Prefetch,
     k_ShiftExtend,
     k_FPImm,
+    k_ExactFPImm,
     k_Barrier,
     k_PSBHint,
   } Kind;
 
   SMLoc StartLoc, EndLoc;
 
   struct TokOp {
     const char *Data;
private:
   struct CondCodeOp {
     AArch64CC::CondCode Code;
   };
 
   struct FPImmOp {
     unsigned Val; // Encoded 8-bit representation.
   };
 
+  struct ExactFPImmOp {
+    uint64_t Val; // APFloat value bitcasted to uint64_t.
+    bool IsExact; // describes whether parsed value was exact.
+  };
+
   struct BarrierOp {
     const char *Data;
     unsigned Length;
     unsigned Val; // Not the enum since not all values have names.
   };
 
   struct SysRegOp {
     const char *Data;
union {
     struct TokOp Tok;
     struct RegOp Reg;
     struct VectorListOp VectorList;
     struct VectorIndexOp VectorIndex;
     struct ImmOp Imm;
     struct ShiftedImmOp ShiftedImm;
     struct CondCodeOp CondCode;
     struct FPImmOp FPImm;
+    struct ExactFPImmOp ExactFPImm;
     struct BarrierOp Barrier;
     struct SysRegOp SysReg;
     struct SysCRImmOp SysCRImm;
     struct PrefetchOp Prefetch;
     struct PSBHintOp PSBHint;
     struct ShiftExtendOp ShiftExtend;
   };
 
case k_ShiftedImm:
       ShiftedImm = o.ShiftedImm;
       break;
     case k_CondCode:
       CondCode = o.CondCode;
       break;
     case k_FPImm:
       FPImm = o.FPImm;
       break;
+    case k_ExactFPImm:
+      ExactFPImm = o.ExactFPImm;
+      break;
     case k_Barrier:
       Barrier = o.Barrier;
       break;
     case k_Register:
       Reg = o.Reg;
       break;
     case k_VectorList:
       VectorList = o.VectorList;
AArch64CC::CondCode getCondCode() const {
     return CondCode.Code;
   }
 
   unsigned getFPImm() const {
     assert(Kind == k_FPImm && "Invalid access!");
     return FPImm.Val;
   }
 
+  uint64_t getExactFPImm() const {
+    assert (Kind == k_ExactFPImm && "Invalid access!");
+    return ExactFPImm.Val;
+  }
+
+  bool getExactFPImmIsExact() const {
+    assert (Kind == k_ExactFPImm && "Invalid access!");
+    return ExactFPImm.IsExact;
+  }
+
   unsigned getBarrier() const {
     assert(Kind == k_Barrier && "Invalid access!");
     return Barrier.Val;
   }
 
   StringRef getBarrierName() const {
     assert(Kind == k_Barrier && "Invalid access!");
     return StringRef(Barrier.Data, Barrier.Length);
bool isShifter() const {
     if (!isShiftExtend())
       return false;
 
     AArch64_AM::ShiftExtendType ST = getShiftExtendType();
     return (ST == AArch64_AM::LSL || ST == AArch64_AM::LSR ||
             ST == AArch64_AM::ASR || ST == AArch64_AM::ROR ||
             ST == AArch64_AM::MSL);
   }
+
+  template <unsigned ImmEnum> DiagnosticPredicate isExactFPImm() const {
+    if (Kind != k_ExactFPImm)
+      return DiagnosticPredicateTy::NoMatch;
+
+    if (getExactFPImmIsExact()) {
+      // Lookup the immediate from table of supported immediates.
+      auto *Desc = AArch64ExactFPImm::lookupExactFPImmByEnum(ImmEnum);
+      assert(Desc && "Unknown enum value");
+
+      // Calculate its FP value.
+      APFloat RealVal(APFloat::IEEEdouble());
+      auto Status =
+          RealVal.convertFromString(Desc->Repr, APFloat::rmTowardZero);
+      assert(Status == APFloat::opOK && "FP immediate is not exact");
+
+      if (getExactFPImm() == RealVal.bitcastToAPInt().getZExtValue())
+        return DiagnosticPredicateTy::Match;
+    }
+
+    return DiagnosticPredicateTy::NearMatch;
+  }
+
+  template <unsigned ImmA, unsigned ImmB>
+  DiagnosticPredicate isExactFPImm() const {
+    DiagnosticPredicate Res = DiagnosticPredicateTy::NoMatch;
+    if ((Res = isExactFPImm<ImmA>()))
+      return DiagnosticPredicateTy::Match;
+    if ((Res = isExactFPImm<ImmB>()))
+      return DiagnosticPredicateTy::Match;
+    return Res;
+  }
+
   bool isExtend() const {
     if (!isShiftExtend())
       return false;
 
     AArch64_AM::ShiftExtendType ET = getShiftExtendType();
     return (ET == AArch64_AM::UXTB || ET == AArch64_AM::SXTB ||
             ET == AArch64_AM::UXTH || ET == AArch64_AM::SXTH ||
             ET == AArch64_AM::UXTW || ET == AArch64_AM::SXTW ||
Inst.addOperand(MCOperand::createReg(FirstReg + getVectorListStart() -
                                          FirstRegs[(unsigned)RegTy][0]));
   }
 
   void addVectorIndexOperands(MCInst &Inst, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     Inst.addOperand(MCOperand::createImm(getVectorIndex()));
   }
 
+  template <unsigned ImmIs0, unsigned ImmIs1>
+  void addExactFPImmOperands(MCInst &Inst, unsigned N) const {
+    assert(N == 1 && "Invalid number of operands!");
+    assert(bool(isExactFPImm<ImmIs0, ImmIs1>()) && "Invalid operand");
+    Inst.addOperand(MCOperand::createImm(bool(isExactFPImm<ImmIs1>())));
+  }
+
   void addImmOperands(MCInst &Inst, unsigned N) const {
     assert(N == 1 && "Invalid number of operands!");
     // If this is a pageoff symrefexpr with an addend, adjust the addend
     // to be only the page-offset portion. Otherwise, just add the expr
     // as-is.
     addExpr(Inst, getImm());
   }
 
static std::unique_ptr<AArch64Operand> CreateFPImm(unsigned Val, SMLoc S,
                                                      MCContext &Ctx) {
     auto Op = make_unique<AArch64Operand>(k_FPImm, Ctx);
     Op->FPImm.Val = Val;
     Op->StartLoc = S;
     Op->EndLoc = S;
     return Op;
   }
 
+  static std::unique_ptr<AArch64Operand>
+  CreateExactFPImm(uint64_t Val, bool IsExact, SMLoc S, MCContext &Ctx) {
+    auto Op = make_unique<AArch64Operand>(k_ExactFPImm, Ctx);
+    Op->ExactFPImm.Val = Val;
+    Op->ExactFPImm.IsExact = IsExact;
+    Op->StartLoc = S;
+    Op->EndLoc = S;
+    return Op;
+  }
+
   static std::unique_ptr<AArch64Operand> CreateBarrier(unsigned Val,
                                                        StringRef Str,
                                                        SMLoc S,
                                                        MCContext &Ctx) {
     auto Op = make_unique<AArch64Operand>(k_Barrier, Ctx);
     Op->Barrier.Val = Val;
     Op->Barrier.Data = Str.data();
     Op->Barrier.Length = Str.size();

 } // end anonymous namespace.
 
 void AArch64Operand::print(raw_ostream &OS) const {
   switch (Kind) {
   case k_FPImm:
     OS << "<fpimm " << getFPImm() << "("
        << AArch64_AM::getFPImmFloat(getFPImm()) << ") >";
     break;
+  case k_ExactFPImm:
+    OS << "<exactfpimm " << getExactFPImm();
+    if (!getExactFPImmIsExact())
+      OS << " (inexact)";
+    OS << ">";
+    break;
   case k_Barrier: {
     StringRef Name = getBarrierName();
     if (!Name.empty())
       OS << "<barrier " << Name << ">";
     else
       OS << "<barrier invalid #" << getBarrier() << ">";
     break;
   }
AArch64AsmParser::tryParseFPImm(OperandVector &Operands) {
 
   if (!Hash)
     return MatchOperand_NoMatch;
 
   TokError("invalid floating point immediate");
   return MatchOperand_ParseFail;
 }
 
+/// tryParseFPImm - A floating point immediate expression operand.
+OperandMatchResultTy
+AArch64AsmParser::tryParseExactFPImm(OperandVector &Operands) {
+  MCAsmParser &Parser = getParser();
+
+  if (!Parser.getTok().is(AsmToken::Hash))
+    return MatchOperand_NoMatch;
+
+  Parser.Lex(); // Eat '#'
+
+  const AsmToken &Tok = Parser.getTok();
+  if (!Tok.is(AsmToken::Real))
+    return MatchOperand_NoMatch;
+
+  APFloat RealVal(APFloat::IEEEdouble());
+  auto Status =
+      RealVal.convertFromString(Tok.getString(), APFloat::rmTowardZero);
+  uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
+  Operands.push_back(AArch64Operand::CreateExactFPImm(
+      IntVal, Status == APFloat::opOK, getLoc(), getContext()));
+
+  Parser.Lex(); // Eat the token.
+
+  return MatchOperand_Success;
+}
+
 /// tryParseImmWithOptionalShift - Parse immediate operand, optionally with
 /// a shift suffix, for example '#1, lsl #12'.
 OperandMatchResultTy
 AArch64AsmParser::tryParseImmWithOptionalShift(OperandVector &Operands) {
   MCAsmParser &Parser = getParser();
   SMLoc S = getLoc();
 
   if (Parser.getTok().is(AsmToken::Hash))

lib/Target/AArch64/InstPrinter/AArch64InstPrinter.h

protected:
   void printSVEPattern(const MCInst *MI, unsigned OpNum,
                        const MCSubtargetInfo &STI, raw_ostream &O);
   template <char = 0>
   void printSVERegOp(const MCInst *MI, unsigned OpNum,
                     const MCSubtargetInfo &STI, raw_ostream &O);
   template <int Width>
   void printZPRasFPR(const MCInst *MI, unsigned OpNum,
                      const MCSubtargetInfo &STI, raw_ostream &O);
+  template <unsigned ImmIs0, unsigned ImmIs1>
+  void printExactFPImm(const MCInst *MI, unsigned OpNum,
+                       const MCSubtargetInfo &STI, raw_ostream &O);
 };
 
 class AArch64AppleInstPrinter : public AArch64InstPrinter {
 public:
   AArch64AppleInstPrinter(const MCAsmInfo &MAI, const MCInstrInfo &MII,
                           const MCRegisterInfo &MRI);
 
   void printInst(const MCInst *MI, raw_ostream &O, StringRef Annot,

lib/Target/AArch64/InstPrinter/AArch64InstPrinter.cpp

void AArch64InstPrinter::printZPRasFPR(const MCInst *MI, unsigned OpNum,
   case 64:  Base = AArch64::D0; break;
   case 128: Base = AArch64::Q0; break;
   default:
     llvm_unreachable("Unsupported width");
   }
   unsigned Reg = MI->getOperand(OpNum).getReg();
   O << getRegisterName(Reg - AArch64::Z0 + Base);
 }
+
+template <unsigned ImmIs0, unsigned ImmIs1>
+void AArch64InstPrinter::printExactFPImm(const MCInst *MI, unsigned OpNum,
+                                         const MCSubtargetInfo &STI,
+                                         raw_ostream  &O) {
+  auto *Imm0Desc = AArch64ExactFPImm::lookupExactFPImmByEnum(ImmIs0);
+  auto *Imm1Desc = AArch64ExactFPImm::lookupExactFPImmByEnum(ImmIs1);
+  unsigned Val = MI->getOperand(OpNum).getImm();
+  O << "#" << (Val ? Imm1Desc->Repr : Imm0Desc->Repr);
+}

lib/Target/AArch64/SVEInstrFormats.td

 }]>;
 def addsub_imm8_opt_lsl_i32 : imm8_opt_lsl<32, "uint32_t", SVEAddSubImmOperand32, [{
   return AArch64_AM::isSVEAddSubImm<int32_t>(Imm);
 }]>;
 def addsub_imm8_opt_lsl_i64 : imm8_opt_lsl<64, "uint64_t", SVEAddSubImmOperand64, [{
   return AArch64_AM::isSVEAddSubImm<int64_t>(Imm);
 }]>;
 
+class SVEExactFPImm<string Suffix, string ValA, string ValB> : AsmOperandClass {
+  let Name = "SVEExactFPImmOperand" # Suffix;
+  let DiagnosticType = "Invalid" # Name;
+  let ParserMethod = "tryParseExactFPImm";
+  let PredicateMethod = "isExactFPImm<" # ValA # ", " # ValB # ">";
+  let RenderMethod = "addExactFPImmOperands<" # ValA # ", " # ValB # ">";
+}
+
+class SVEExactFPImmOperand<string Suffix, string ValA, string ValB> : Operand<i32> {
+  let PrintMethod = "printExactFPImm<" # ValA # ", " # ValB # ">";
+  let ParserMatchClass = SVEExactFPImm<Suffix, ValA, ValB>;
+}
 
 //===----------------------------------------------------------------------===//
 // SVE PTrue - These are used extensively throughout the pattern matching so
 //             it's important we define them first.
 //===----------------------------------------------------------------------===//
 
 class sve_int_ptrue<bits<2> sz8_64, bits<3> opc, string asm, PPRRegOp pprty>
 : I<(outs pprty:$Pd), (ins sve_pred_enum:$pattern),

lib/Target/AArch64/Utils/AArch64BaseInfo.h

namespace AArch64SVEPredPattern {
   struct SVEPREDPAT {
     const char *Name;
     uint16_t Encoding;
   };
 #define GET_SVEPREDPAT_DECL
 #include "AArch64GenSystemOperands.inc"
 }
 
+namespace AArch64ExactFPImm {
+  struct ExactFPImm {
+    const char *Name;
+    int Enum;
+    const char *Repr;
+  };
+#define GET_EXACTFPIMM_DECL
+#include "AArch64GenSystemOperands.inc"
+}
+
 namespace AArch64PState {
   struct PState : SysAlias{
     using SysAlias::SysAlias;
   };
   #define GET_PSTATE_DECL
   #include "AArch64GenSystemOperands.inc"
 }
 

lib/Target/AArch64/Utils/AArch64BaseInfo.cpp

 namespace llvm {
   namespace AArch64SVEPredPattern {
 #define GET_SVEPREDPAT_IMPL
 #include "AArch64GenSystemOperands.inc"
   }
 }
 
 namespace llvm {
+  namespace AArch64ExactFPImm {
+#define GET_EXACTFPIMM_IMPL
+#include "AArch64GenSystemOperands.inc"
+  }
+}
+
+namespace llvm {
   namespace AArch64PState {
 #define GET_PSTATE_IMPL
 #include "AArch64GenSystemOperands.inc"
   }
 }
 
 namespace llvm {
   namespace AArch64PSBHint {