[ms] [llvm-ml] Add REAL10 support (x87 extended precision)

[epastor]

Summary

Add MASM support for 80-bit reals in the x87 extended precision format.

[epastor]

Rebase on parent

[epastor]

Fix rebase

[epastor]

Rebase on parent

[epastor]

Rebase on parent

llvm/include/llvm/MC/MCStreamer.h

 //===- MCStreamer.h - High-level Streaming Machine Code Output --*- C++ -*-===//
 //
 // 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 file declares the MCStreamer class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
+#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
public:
   virtual void emitValueImpl(const MCExpr *Value, unsigned Size,
                              SMLoc Loc = SMLoc());
 
   void emitValue(const MCExpr *Value, unsigned Size, SMLoc Loc = SMLoc());
 
   /// Special case of EmitValue that avoids the client having
   /// to pass in a MCExpr for constant integers.
   virtual void emitIntValue(uint64_t Value, unsigned Size);
+  virtual void emitIntValue(APInt Value);
 
   /// Special case of EmitValue that avoids the client having to pass
   /// in a MCExpr for constant integers & prints in Hex format for certain
   /// modes.
   virtual void emitIntValueInHex(uint64_t Value, unsigned Size) {
     emitIntValue(Value, Size);
   }
 

llvm/lib/MC/MCParser/MasmParser.cpp

enum DirectiveKind {
     DK_SQWORD,
     DK_DB,
     DK_DD,
     DK_DF,
     DK_DQ,
     DK_DW,
     DK_REAL4,
     DK_REAL8,
+    DK_REAL10,
     DK_ALIGN,
     DK_ORG,
     DK_ENDR,
     DK_EXTERN,
     DK_PUBLIC,
     DK_COMM,
     DK_COMMENT,
     DK_INCLUDE,
bool parseScalarInstList(
       unsigned Size, SmallVectorImpl<const MCExpr *> &Values,
       const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
   bool emitIntegralValues(unsigned Size, unsigned *Count = nullptr);
   bool addIntegralField(StringRef Name, unsigned Size);
   bool parseDirectiveValue(StringRef IDVal, unsigned Size);
   bool parseDirectiveNamedValue(StringRef TypeName, unsigned Size,
                                 StringRef Name, SMLoc NameLoc);
 
-  // "real4", "real8"
+  // "real4", "real8", "real10"
   bool emitRealValues(const fltSemantics &Semantics, unsigned *Count = nullptr);
   bool addRealField(StringRef Name, const fltSemantics &Semantics, size_t Size);
   bool parseDirectiveRealValue(StringRef IDVal, const fltSemantics &Semantics,
                                size_t Size);
   bool parseRealInstList(
       const fltSemantics &Semantics, SmallVectorImpl<APInt> &Values,
       const AsmToken::TokenKind EndToken = AsmToken::EndOfStatement);
   bool parseDirectiveNamedRealValue(StringRef TypeName,
if (DirKind != DK_NO_DIRECTIVE) {
     case DK_QWORD:
     case DK_SQWORD:
     case DK_DQ:
       return parseDirectiveValue(IDVal, 8);
     case DK_REAL4:
       return parseDirectiveRealValue(IDVal, APFloat::IEEEsingle(), 4);
     case DK_REAL8:
       return parseDirectiveRealValue(IDVal, APFloat::IEEEdouble(), 8);
+    case DK_REAL10:
+      return parseDirectiveRealValue(IDVal, APFloat::x87DoubleExtended(), 10);
     case DK_STRUCT:
     case DK_UNION:
       return parseDirectiveNestedStruct(IDVal, DirKind);
     case DK_ENDS:
       return parseDirectiveNestedEnds();
     case DK_ALIGN:
       return parseDirectiveAlign();
     case DK_ORG:
bool MasmParser::parseStatement(ParseStatementInfo &Info,
   case DK_REAL4:
     Lex();
     return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEsingle(), 4,
                                         IDVal, IDLoc);
   case DK_REAL8:
     Lex();
     return parseDirectiveNamedRealValue(nextVal, APFloat::IEEEdouble(), 8,
                                         IDVal, IDLoc);
+  case DK_REAL10:
+    Lex();
+    return parseDirectiveNamedRealValue(nextVal, APFloat::x87DoubleExtended(),
+                                        10, IDVal, IDLoc);
   case DK_STRUCT:
   case DK_UNION:
     Lex();
     return parseDirectiveStruct(nextVal, DirKind, IDVal, IDLoc);
   case DK_ENDS:
     Lex();
     return parseDirectiveEnds(IDVal, IDLoc);
   }
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))
+    unsigned SizeInBits = Value.getSizeInBits(Semantics);
+    if (SizeInBits != (IDVal.size() << 2))
       return TokError("invalid floating point literal");
 
     // Consume the numeric token.
     Lex();
 
-    Res = APInt(Size, IDVal, 16);
+    Res = APInt(SizeInBits, 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");
   }
bool MasmParser::emitRealValues(const fltSemantics &Semantics,
   if (checkForValidSection())
     return true;
 
   SmallVector<APInt, 1> ValuesAsInt;
   if (parseRealInstList(Semantics, ValuesAsInt))
     return true;
 
   for (const APInt &AsInt : ValuesAsInt) {
-    getStreamer().emitIntValue(AsInt.getLimitedValue(),
-                               AsInt.getBitWidth() / 8);
+    getStreamer().emitIntValue(AsInt);
   }
   if (Count)
     *Count = ValuesAsInt.size();
   return false;
 }
 
 // Add a real field to the current struct.
 bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics,
bool MasmParser::addRealField(StringRef Name, const fltSemantics &Semantics,
   if (Struct.IsUnion)
     Struct.Size = std::max(Struct.Size, Field.SizeOf);
   else
     Struct.Size += Field.SizeOf;
   return false;
 }
 
 /// parseDirectiveRealValue
-///  ::= (real4 | real8) [ expression (, expression)* ]
+///  ::= (real4 | real8 | real10) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveRealValue(StringRef IDVal,
                                          const fltSemantics &Semantics,
                                          size_t Size) {
   if (StructInProgress.empty()) {
     // Initialize data value.
     if (emitRealValues(Semantics))
       return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   } else if (addRealField("", Semantics, Size)) {
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
   }
   return false;
 }
 
 /// parseDirectiveNamedRealValue
-///  ::= name (real4 | real8) [ expression (, expression)* ]
+///  ::= name (real4 | real8 | real10) [ expression (, expression)* ]
 bool MasmParser::parseDirectiveNamedRealValue(StringRef TypeName,
                                               const fltSemantics &Semantics,
                                               unsigned Size, StringRef Name,
                                               SMLoc NameLoc) {
   if (StructInProgress.empty()) {
     // Initialize named data value.
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
     getStreamer().emitLabel(Sym);
bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
 
   Initializer = FieldInitializer(std::move(Values));
   return false;
 }
 
 bool MasmParser::parseFieldInitializer(const FieldInfo &Field,
                                        const RealFieldInfo &Contents,
                                        FieldInitializer &Initializer) {
-  const fltSemantics &Semantics =
-      (Field.Type == 4) ? APFloat::IEEEsingle() : APFloat::IEEEdouble();
+  const fltSemantics *Semantics;
+  switch (Field.Type) {
+  case 4:
+    Semantics = &APFloat::IEEEsingle();
+    break;
+  case 8:
+    Semantics = &APFloat::IEEEdouble();
+    break;
+  case 10:
+    Semantics = &APFloat::x87DoubleExtended();
+    break;
+  default:
+    llvm_unreachable("unknown real field type");
+  }
 
   SMLoc Loc = getTok().getLoc();
 
   SmallVector<APInt, 1> AsIntValues;
   if (parseOptionalToken(AsmToken::LCurly)) {
     if (Field.LengthOf == 1)
       return Error(Loc, "Cannot initialize scalar field with array value");
-    if (parseRealInstList(Semantics, AsIntValues, AsmToken::RCurly) ||
+    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::RCurly) ||
         parseToken(AsmToken::RCurly))
       return true;
   } else if (parseOptionalAngleBracketOpen()) {
     if (Field.LengthOf == 1)
       return Error(Loc, "Cannot initialize scalar field with array value");
-    if (parseRealInstList(Semantics, AsIntValues, AsmToken::Greater) ||
+    if (parseRealInstList(*Semantics, AsIntValues, AsmToken::Greater) ||
         parseAngleBracketClose())
       return true;
   } else if (Field.LengthOf > 1) {
     return Error(Loc, "Cannot initialize array field with scalar value");
   } else {
     AsIntValues.emplace_back();
-    if (parseRealValue(Semantics, AsIntValues.back()))
+    if (parseRealValue(*Semantics, AsIntValues.back()))
       return true;
   }
 
   if (AsIntValues.size() > Field.LengthOf) {
     return Error(Loc, "Initializer too long for field; expected at most " +
                           std::to_string(Field.LengthOf) + " elements, got " +
                           std::to_string(AsIntValues.size()));
   }
void MasmParser::initializeDirectiveKindMap() {
   DirectiveKindMap["sword"] = DK_SWORD;
   DirectiveKindMap["dword"] = DK_DWORD;
   DirectiveKindMap["sdword"] = DK_SDWORD;
   DirectiveKindMap["fword"] = DK_FWORD;
   DirectiveKindMap["qword"] = DK_QWORD;
   DirectiveKindMap["sqword"] = DK_SQWORD;
   DirectiveKindMap["real4"] = DK_REAL4;
   DirectiveKindMap["real8"] = DK_REAL8;
+  DirectiveKindMap["real10"] = DK_REAL10;
   DirectiveKindMap["align"] = DK_ALIGN;
   // DirectiveKindMap[".org"] = DK_ORG;
   DirectiveKindMap["extern"] = DK_EXTERN;
   DirectiveKindMap["public"] = DK_PUBLIC;
   // DirectiveKindMap[".comm"] = DK_COMM;
   DirectiveKindMap["comment"] = DK_COMMENT;
   DirectiveKindMap["include"] = DK_INCLUDE;
   // DirectiveKindMap[".rept"] = DK_REPT;
bool MasmParser::lookUpType(StringRef Name, AsmTypeInfo &Info) const {
   unsigned Size = StringSwitch<unsigned>(Name)
                       .CasesLower("byte", "db", "sbyte", 1)
                       .CasesLower("word", "dw", "sword", 2)
                       .CasesLower("dword", "dd", "sdword", 4)
                       .CasesLower("fword", "df", 6)
                       .CasesLower("qword", "dq", "sqword", 8)
                       .CaseLower("real4", 4)
                       .CaseLower("real8", 8)
+                      .CaseLower("real10", 10)
                       .Default(0);
   if (Size) {
     Info.Name = Name;
     Info.ElementSize = Size;
     Info.Length = 1;
     Info.Size = Size;
     return false;
   }

llvm/lib/MC/MCStreamer.cpp

void MCStreamer::emitIntValue(uint64_t Value, unsigned Size) {
   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
          "Invalid size");
   const bool IsLittleEndian = Context.getAsmInfo()->isLittleEndian();
   uint64_t Swapped = support::endian::byte_swap(
       Value, IsLittleEndian ? support::little : support::big);
   unsigned Index = IsLittleEndian ? 0 : 8 - Size;
   emitBytes(StringRef(reinterpret_cast<char *>(&Swapped) + Index, Size));
 }
+void MCStreamer::emitIntValue(APInt Value) {
+  if (Value.getNumWords() == 1) {
+    emitIntValue(Value.getLimitedValue(), Value.getBitWidth() / 8);
+    return;
+  }
+
+  const bool IsLittleEndianTarget = Context.getAsmInfo()->isLittleEndian();
+  const bool ShouldSwap = sys::IsLittleEndianHost != IsLittleEndianTarget;
+  const APInt Swapped = ShouldSwap ? Value.byteSwap() : Value;
+  const unsigned Size = Value.getBitWidth() / 8;
+  SmallString<10> Tmp;
+  Tmp.resize(Size);
+  StoreIntToMemory(Swapped, reinterpret_cast<uint8_t *>(Tmp.data()), Size);
+  emitBytes(Tmp.str());
+}
 
 /// EmitULEB128IntValue - Special case of EmitULEB128Value that avoids the
 /// client having to pass in a MCExpr for constant integers.
 void MCStreamer::emitULEB128IntValue(uint64_t Value, unsigned PadTo) {
   SmallString<128> Tmp;
   raw_svector_ostream OSE(Tmp);
   encodeULEB128(Value, OSE, PadTo);
   emitBytes(OSE.str());

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

 ; CHECK-LABEL: t5_long:
 ; CHECK-NEXT: .quad 4611686018427387904
 ; CHECK-LABEL: t5_short:
 ; CHECK-NEXT: .quad 4611686018427387904
 ; CHECK-LABEL: t5_signed:
 ; CHECK-NEXT: .quad -4611686018427387904
 
 t6_single REAL4 1.3
-t6_double REAL8 1.3
+t6_single_hex REAL4 3fa66666r
 
 ; CHECK-LABEL: t6_single:
 ; CHECK-NEXT: .long 1067869798
-; CHECK-LABEL: t6_double:
-; CHECK-NEXT: .quad 4608533498688228557
+; CHECK-LABEL: t6_single_hex:
+; CHECK-NEXT: .long 1067869798
 
-t7_single_hex REAL4 3f800000r
-t7_double_hex REAL8 3FF0000000000000R
+t7_double REAL8 1.3
+t7_double_hex REAL8 3FF4CCCCCCCCCCCDR
 
-; CHECK-LABEL: t7_single_hex:
-; CHECK-NEXT: .long 1065353216
+; CHECK-LABEL: t7_double:
+; CHECK-NEXT: .quad 4608533498688228557
 ; CHECK-LABEL: t7_double_hex:
-; CHECK-NEXT: .quad 4607182418800017408
+; CHECK-NEXT: .quad 4608533498688228557
+
+t8_extended REAL10 1.3
+t8_extended_hex REAL10 3FFFA666666666666666r
+
+; CHECK-LABEL: t8_extended:
+; CHECK-NEXT: .ascii "fffffff\246\377?"
+; CHECK-LABEL: t8_extended_hex:
+; CHECK-NEXT: .ascii "fffffff\246\377?"
 
 .code
 
 END

llvm/test/tools/llvm-ml/type_operators.test

 mov eax, type(t6_signed)
 ; CHECK: mov eax, 24
 ; CHECK: mov eax, 3
 ; CHECK: mov eax, 8
 
 
 t7_single REAL4 2 DUP (?)
 t7_double REAL8 ?
+t7_extended REAL10 3 DUP (?)
 
 t7:
 ; CHECK-LABEL: t7:
 
 mov eax, sizeof(t7_single)
 mov eax, lengthof(t7_single)
 mov eax, type(t7_single)
 ; CHECK: mov eax, 8
 ; CHECK: mov eax, 2
 ; CHECK: mov eax, 4
 
 mov eax, sizeof(t7_double)
 mov eax, lengthof(t7_double)
 mov eax, type(t7_double)
 ; CHECK: mov eax, 8
 ; CHECK: mov eax, 1
 ; CHECK: mov eax, 8
 
+mov eax, sizeof(t7_extended)
+mov eax, lengthof(t7_extended)
+mov eax, type(t7_extended)
+; CHECK: mov eax, 30
+; CHECK: mov eax, 3
+; CHECK: mov eax, 10
+
 
 t8_var FOO <>, <>
 
 t8:
 ; CHECK-LABEL: t8:
 
 mov eax, sizeof(t8_var)
 mov eax, lengthof(t8_var)