[ms] [llvm-ml] Add MASM hex float support

[epastor]

Summary

Implement MASM's syntax for specifying floats in raw hexadecimal bytes.

[thakis]

llvm/lib/MC/MCParser/MasmParser.cpp

3458

Should we at least warn about an explicit sign with a hexfloat?

[epastor]

Warn on explicit sign preceding MASM-style hex float (which is ignored for compatibility)

[epastor]

llvm/lib/MC/MCParser/MasmParser.cpp

3458

Warning sounds like a good idea. Added.

[epastor]

Rebase on relanded parent

[epastor]

Rebase on parent

llvm/include/llvm/MC/MCParser/MCAsmLexer.h

class MCAsmLexer {
   SMLoc ErrLoc;
   std::string Err;
 
 protected: // Can only create subclasses.
   const char *TokStart = nullptr;
   bool SkipSpace = true;
   bool AllowAtInIdentifier;
   bool IsAtStartOfStatement = true;
+  bool LexMasmHexFloats = false;
   bool LexMasmIntegers = false;
   unsigned DefaultRadix = 10;
   AsmCommentConsumer *CommentConsumer = nullptr;
 
   MCAsmLexer();
 
   virtual AsmToken LexToken() = 0;
 
public:
 
   void setCommentConsumer(AsmCommentConsumer *CommentConsumer) {
     this->CommentConsumer = CommentConsumer;
   }
 
   /// Set whether to lex masm-style binary and hex literals. They look like
   /// 0b1101 and 0ABCh respectively.
   void setLexMasmIntegers(bool V) { LexMasmIntegers = V; }
+
+  /// Set whether to lex masm-style hex float literals, such as 3f800000r.
+  void setLexMasmHexFloats(bool V) { LexMasmHexFloats = V; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCPARSER_MCASMLEXER_H

llvm/lib/MC/MCParser/AsmLexer.cpp

 //===- AsmLexer.cpp - Lexer for Assembly Files ----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This class implements the lexer for assembly files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCParser/AsmLexer.h"
 #include "third_party/llvm/llvm-project/llvm/include/llvm/Support/Compiler.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/Support/SMLoc.h"
if (LexMasmIntegers && isdigit(CurPtr[-1])) {
     }
     if (*FirstNonDecimal == '.') {
       // MASM float literals (other than hex floats) always contain a ".", and
       // are always written in decimal.
       CurPtr = FirstNonDecimal + 1;
       return LexFloatLiteral();
     }
 
+    if (LexMasmHexFloats && (*CurPtr == 'r' || *CurPtr == 'R')) {
+      ++CurPtr;
+      return AsmToken(AsmToken::Real, StringRef(TokStart, CurPtr - TokStart));
+    }
+
     unsigned Radix = 0;
     if (*CurPtr == 'h' || *CurPtr == 'H') {
       // hexadecimal number
       ++CurPtr;
       Radix = 16;
     } else if (*CurPtr == 't' || *CurPtr == 'T') {
       // decimal number
       ++CurPtr;

llvm/lib/MC/MCParser/MasmParser.cpp

static bool parseHexOcta(MasmParser &Asm, uint64_t &hi, uint64_t &lo) {
   }
   return false;
 }
 
 bool MasmParser::parseRealValue(const fltSemantics &Semantics, APInt &Res) {
   // We don't truly support arithmetic on floating point expressions, so we
   // have to manually parse unary prefixes.
   bool IsNeg = false;
+  SMLoc SignLoc;
   if (getLexer().is(AsmToken::Minus)) {
+    SignLoc = getLexer().getLoc();
     Lexer.Lex();
     IsNeg = true;
   } else if (getLexer().is(AsmToken::Plus)) {
+    SignLoc = getLexer().getLoc();
     Lexer.Lex();
   }
 
   if (Lexer.is(AsmToken::Error))
     return TokError(Lexer.getErr());
   if (Lexer.isNot(AsmToken::Integer) && Lexer.isNot(AsmToken::Real) &&
       Lexer.isNot(AsmToken::Identifier))
     return TokError("unexpected token in directive");
 
   // Convert to an APFloat.
   APFloat Value(Semantics);
   StringRef IDVal = getTok().getString();
   if (getLexer().is(AsmToken::Identifier)) {
     if (IDVal.equals_lower("infinity") || IDVal.equals_lower("inf"))
       Value = APFloat::getInf(Semantics);
     else if (IDVal.equals_lower("nan"))
       Value = APFloat::getNaN(Semantics, false, ~0);
     else if (IDVal.equals_lower("?"))
       Value = APFloat::getZero(Semantics);
     else
       return TokError("invalid floating point literal");
+  } else if (IDVal.consume_back("r") || IDVal.consume_back("R")) {
+    // MASM hexadecimal floating-point literal; no APFloat conversion needed.
+    // To match ML64.exe, ignore the initial sign.
+    unsigned Size = Value.getSizeInBits(Semantics);
+    if (Size != (IDVal.size() << 2))
+      return TokError("invalid floating point literal");
+
+    // Consume the numeric token.
+    Lex();
+
+    Res = APInt(Size, IDVal, 16);
+    if (SignLoc.isValid())
+      return Warning(SignLoc, "MASM-style hex floats ignore explicit sign");
+    return false;
   } else if (errorToBool(
                  Value.convertFromString(IDVal, APFloat::rmNearestTiesToEven)
                      .takeError())) {
     return TokError("invalid floating point literal");
   }
   if (IsNeg)
     Value.changeSign();
 

llvm/test/tools/llvm-ml/builtin_types.test

 t6_single REAL4 1.3
 t6_double REAL8 1.3
 
 ; CHECK-LABEL: t6_single:
 ; CHECK-NEXT: .long 1067869798
 ; CHECK-LABEL: t6_double:
 ; CHECK-NEXT: .quad 4608533498688228557
 
+t7_single_hex REAL4 3f800000r
+t7_double_hex REAL8 3FF0000000000000R
+
+; CHECK-LABEL: t7_single_hex:
+; CHECK-NEXT: .long 1065353216
+; CHECK-LABEL: t7_double_hex:
+; CHECK-NEXT: .quad 4607182418800017408
+
 .code
 
 END

llvm/tools/llvm-mc/llvm-mc.cpp

 
 static cl::opt<bool> SaveTempLabels("save-temp-labels",
                                     cl::desc("Don't discard temporary labels"));
 
 static cl::opt<bool> LexMasmIntegers(
     "masm-integers",
     cl::desc("Enable binary and hex masm integers (0b110 and 0ABCh)"));
 
+static cl::opt<bool> LexMasmHexFloats(
+    "masm-hexfloats",
+    cl::desc("Enable MASM-style hex float initializers (3F800000r)"));
+
 static cl::opt<bool> NoExecStack("no-exec-stack",
                                  cl::desc("File doesn't need an exec stack"));
 
 enum ActionType {
   AC_AsLex,
   AC_Assemble,
   AC_Disassemble,
   AC_MDisassemble,
static int AssembleInput(const char *ProgName, const Target *TheTarget,
   }
 
   int SymbolResult = fillCommandLineSymbols(*Parser);
   if(SymbolResult)
     return SymbolResult;
   Parser->setShowParsedOperands(ShowInstOperands);
   Parser->setTargetParser(*TAP);
   Parser->getLexer().setLexMasmIntegers(LexMasmIntegers);
+  Parser->getLexer().setLexMasmHexFloats(LexMasmHexFloats);
 
   int Res = Parser->Run(NoInitialTextSection);
 
   return Res;
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);

llvm/tools/llvm-ml/llvm-ml.cpp

static std::unique_ptr<ToolOutputFile> GetOutputStream(StringRef Path) {
 
   return Out;
 }
 
 static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, raw_ostream &OS) {
   AsmLexer Lexer(MAI);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(SrcMgr.getMainFileID())->getBuffer());
   Lexer.setLexMasmIntegers(true);
+  Lexer.setLexMasmHexFloats(true);
 
   bool Error = false;
   while (Lexer.Lex().isNot(AsmToken::Eof)) {
     Lexer.getTok().dump(OS);
     OS << "\n";
     if (Lexer.getTok().getKind() == AsmToken::Error)
       Error = true;
   }
if (!TAP) {
     WithColor::error(errs(), ProgName)
         << "this target does not support assembly parsing.\n";
     return 1;
   }
 
   Parser->setShowParsedOperands(ShowInstOperands);
   Parser->setTargetParser(*TAP);
   Parser->getLexer().setLexMasmIntegers(true);
+  Parser->getLexer().setLexMasmHexFloats(true);
 
   int Res = Parser->Run(/*NoInitialTextSection=*/true);
 
   return Res;
 }
 
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);