[ms] [llvm-ml] Add support for numeric built-in symbols

[epastor]

Summary

Support @Version and @Line as built-in symbols. For now, resolves @Version to 1427 (the same as for the VS 2019 release of ML.EXE).

[thakis]

Can you check if ml.exe allows defining a local variable overriding e.g. @Line? What happens then? Does it error? Can you add a test for that?

[thakis]

(…other that that, lg)

[epastor]

Error on redefinition of built-in symbols (matching ML.EXE)

[epastor]

In D104964#2853790, @thakis wrote:

Can you check if ml.exe allows defining a local variable overriding e.g. @Line? What happens then? Does it error? Can you add a test for that?

Confirmed that ml.exe errors in this case; matched this behavior, and added corresponding test.

[epastor]

Rebase on parent

[epastor]

Rebase on parent

[epastor]

Fix an accidental import of MasmParser.cpp from a child commit

[epastor]

Fix accidental fold with the child commit

[epastor]

Fix symbol usage bug

[thakis]

lg

llvm/lib/MC/MCParser/MasmParser.cpp

3516

Why is this changing? If it's intentional, nit: Named parameter comment style in LLVM is /*SetUsed=*/false (ie with = and without space)

llvm/test/tools/llvm-ml/variable_redef_errors.asm

11

Can you add a line for @Version too?

[epastor]

Addressed feedback (and rebased on HEAD)

[epastor]

llvm/lib/MC/MCParser/MasmParser.cpp

3516

We're removing Var.NumericValue because it breaks the parallels between Variables and BuiltinSymbols. Instead, we rely on the value stored in the symbol itself as authoritative - and if it's not an MCConstantExpr, then it's definitely not a MASM variable.

Fixed the named parameter comment style, though I believe this was copied from AsmParser.cpp originally...

llvm/lib/MC/MCParser/MasmParser.cpp

private:
 
   /// maps assembly-time variable names to variables.
   struct Variable {
     enum RedefinableKind { NOT_REDEFINABLE, WARN_ON_REDEFINITION, REDEFINABLE };
 
     StringRef Name;
     RedefinableKind Redefinable = REDEFINABLE;
     bool IsText = false;
-    int64_t NumericValue = 0;
     std::string TextValue;
   };
   StringMap<Variable> Variables;
 
   /// Stack of active struct definitions.
   SmallVector<StructInfo, 1> StructInProgress;
 
   /// Maps struct tags to struct definitions.
enum CVDefRangeType {
     CVDR_DEFRANGE_SUBFIELD_REGISTER,
     CVDR_DEFRANGE_REGISTER_REL
   };
 
   /// Maps Codeview def_range types --> CVDefRangeType enum, for Codeview
   /// def_range types parsed by this class.
   StringMap<CVDefRangeType> CVDefRangeTypeMap;
 
+  // Generic (target and platform independent) directive parsing.
+  enum BuiltinSymbol {
+    BI_NO_SYMBOL, // Placeholder
+    BI_DATE,
+    BI_TIME,
+    BI_VERSION,
+    BI_FILECUR,
+    BI_FILENAME,
+    BI_LINE,
+    BI_CURSEG,
+    BI_CPU,
+    BI_INTERFACE,
+    BI_CODE,
+    BI_DATA,
+    BI_FARDATA,
+    BI_WORDSIZE,
+    BI_CODESIZE,
+    BI_DATASIZE,
+    BI_MODEL,
+    BI_STACK,
+  };
+
+  /// Maps builtin name --> BuiltinSymbol enum, for builtins handled by this
+  /// class.
+  StringMap<BuiltinSymbol> BuiltinSymbolMap;
+
+  const MCExpr *evaluateBuiltinValue(BuiltinSymbol Symbol, SMLoc StartLoc);
+
   // ".ascii", ".asciz", ".string"
   bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
 
   // "byte", "word", ...
   bool emitIntValue(const MCExpr *Value, unsigned Size);
   bool parseScalarInitializer(unsigned Size,
                               SmallVectorImpl<const MCExpr *> &Values,
                               unsigned StringPadLength = 0);
private:
   // ".radix"
   bool parseDirectiveRadix(SMLoc DirectiveLoc);
 
   // "echo"
   bool parseDirectiveEcho(SMLoc DirectiveLoc);
 
   void initializeDirectiveKindMap();
   void initializeCVDefRangeTypeMap();
+  void initializeBuiltinSymbolMap();
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
 extern MCAsmParserExtension *createCOFFMasmParser();
 
MasmParser::MasmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
   default:
     report_fatal_error("llvm-ml currently supports only COFF output.");
     break;
   }
 
   initializeDirectiveKindMap();
   PlatformParser->Initialize(*this);
   initializeCVDefRangeTypeMap();
+  initializeBuiltinSymbolMap();
 
   NumOfMacroInstantiations = 0;
 }
 
 MasmParser::~MasmParser() {
   assert((HadError || ActiveMacros.empty()) &&
          "Unexpected active macro instantiation!");
 
if (Split.second.empty()) {
         // This is actually a reference to a field offset.
         Res = MCConstantExpr::create(Info.Offset, getContext());
         return false;
       }
     }
 
     MCSymbol *Sym = getContext().getInlineAsmLabel(SymbolName);
     if (!Sym) {
+      // If this is a built-in numeric value, treat it as a constant.
+      auto BuiltinIt = BuiltinSymbolMap.find(SymbolName.lower());
+      const BuiltinSymbol Symbol = (BuiltinIt == BuiltinSymbolMap.end())
+                                       ? BI_NO_SYMBOL
+                                       : BuiltinIt->getValue();
+      if (Symbol != BI_NO_SYMBOL) {
+        const MCExpr *Value = evaluateBuiltinValue(Symbol, FirstTokenLoc);
+        if (Value) {
+          Res = Value;
+          return false;
+        }
+      }
+
       // Variables use case-insensitive symbol names; if this is a variable, we
       // find the symbol using its canonical name.
       auto VarIt = Variables.find(SymbolName.lower());
       if (VarIt != Variables.end())
         SymbolName = VarIt->second.Name;
       Sym = getContext().getOrCreateSymbol(SymbolName);
     }
 
     // If this is an absolute variable reference, substitute it now to preserve
     // semantics in the face of reassignment.
     if (Sym->isVariable()) {
-      auto V = Sym->getVariableValue(/*SetUsed*/ false);
+      auto V = Sym->getVariableValue(/*SetUsed=*/false);
       bool DoInline = isa<MCConstantExpr>(V) && !Variant;
       if (auto TV = dyn_cast<MCTargetExpr>(V))
         DoInline = TV->inlineAssignedExpr();
       if (DoInline) {
         if (Variant)
           return Error(EndLoc, "unexpected modifier on variable reference");
-        Res = Sym->getVariableValue(/*SetUsed*/ false);
+        Res = Sym->getVariableValue(/*SetUsed=*/false);
         return false;
       }
     }
 
     // Otherwise create a symbol ref.
     const MCExpr *SymRef =
         MCSymbolRefExpr::create(Sym, Variant, getContext(), FirstTokenLoc);
     if (Info.Offset) {

 
 /// parseDirectiveEquate:
 ///  ::= name "=" expression
 ///    | name "equ" expression    (not redefinable)
 ///    | name "equ" text-list
 ///    | name "textequ" text-list (redefinability unspecified)
 bool MasmParser::parseDirectiveEquate(StringRef IDVal, StringRef Name,
                                       DirectiveKind DirKind, SMLoc NameLoc) {
+  auto BuiltinIt = BuiltinSymbolMap.find(Name.lower());
+  if (BuiltinIt != BuiltinSymbolMap.end())
+    return Error(NameLoc, "cannot redefine a built-in symbol");
+
   Variable &Var = Variables[Name.lower()];
   if (Var.Name.empty()) {
     Var.Name = Name;
   }
 
   SMLoc StartLoc = Lexer.getLoc();
   if (DirKind == DK_EQU || DirKind == DK_TEXTEQU) {
     // "equ" and "textequ" both allow text expressions.
bool MasmParser::parseDirectiveEquate(StringRef IDVal, StringRef Name,
   if (DirKind == DK_TEXTEQU)
     return TokError("expected <text> in '" + Twine(IDVal) + "' directive");
 
   // Parse as expression assignment.
   const MCExpr *Expr;
   SMLoc EndLoc;
   if (parseExpression(Expr, EndLoc))
     return addErrorSuffix(" in '" + Twine(IDVal) + "' directive");
+  StringRef ExprAsString = StringRef(
+      StartLoc.getPointer(), EndLoc.getPointer() - StartLoc.getPointer());
 
   int64_t Value;
   if (!Expr->evaluateAsAbsolute(Value, getStreamer().getAssemblerPtr())) {
+    if (DirKind == DK_ASSIGN)
+      return Error(
+          StartLoc,
+          "expected absolute expression; not all symbols have known values",
+          {StartLoc, EndLoc});
+
     // Not an absolute expression; define as a text replacement.
-    StringRef ExprAsString = StringRef(
-        StartLoc.getPointer(), EndLoc.getPointer() - StartLoc.getPointer());
     if (!Var.IsText || Var.TextValue != ExprAsString) {
       switch (Var.Redefinable) {
       case Variable::NOT_REDEFINABLE:
         return Error(getTok().getLoc(), "invalid variable redefinition");
       case Variable::WARN_ON_REDEFINITION:
         if (Warning(NameLoc, "redefining '" + Name +
                                  "', already defined on the command line")) {
           return true;
         }
         break;
       default:
         break;
       }
     }
+
     Var.IsText = true;
     Var.TextValue = ExprAsString.str();
-  } else {
-    if (Var.IsText || Var.NumericValue != Value) {
-      switch (Var.Redefinable) {
-      case Variable::NOT_REDEFINABLE:
-        return Error(getTok().getLoc(), "invalid variable redefinition");
-      case Variable::WARN_ON_REDEFINITION:
-        if (Warning(NameLoc, "redefining '" + Name +
-                                 "', already defined on the command line")) {
-          return true;
-        }
-        break;
-      default:
-        break;
-      }
-    }
-    Var.NumericValue = Value;
-  }
+    Var.Redefinable = Variable::REDEFINABLE;
+
+    return false;
+  }
+
+  MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name);
+
+  const MCConstantExpr *PrevValue =
+      Sym->isVariable() ? dyn_cast_or_null<MCConstantExpr>(
+                              Sym->getVariableValue(/*SetUsed=*/false))
+                        : nullptr;
+  if (Var.IsText || !PrevValue || PrevValue->getValue() != Value) {
+
+  Var.IsText = false;
+  Var.TextValue.clear();
   Var.Redefinable = (DirKind == DK_ASSIGN) ? Variable::REDEFINABLE
                                            : Variable::NOT_REDEFINABLE;
 
-  MCSymbol *Sym = getContext().getOrCreateSymbol(Var.Name);
   Sym->setRedefinable(Var.Redefinable != Variable::NOT_REDEFINABLE);
   Sym->setVariableValue(Expr);
   Sym->setExternal(false);
 
   return false;
 }
 
 bool MasmParser::parseEscapedString(std::string &Data) {
if (TheCondState.Ignore) {
     is_defined = (getTargetParser().tryParseRegister(
                       RegNo, StartLoc, EndLoc) == MatchOperand_Success);
     if (!is_defined) {
       StringRef Name;
       if (check(parseIdentifier(Name), "expected identifier after 'ifdef'") ||
           parseToken(AsmToken::EndOfStatement, "unexpected token in 'ifdef'"))
         return true;
 
-      if (Variables.find(Name.lower()) != Variables.end()) {
+      if (BuiltinSymbolMap.find(Name.lower()) != BuiltinSymbolMap.end()) {
+        is_defined = true;
+      } else if (Variables.find(Name.lower()) != Variables.end()) {
         is_defined = true;
       } else {
         MCSymbol *Sym = getContext().lookupSymbol(Name.lower());
         is_defined = (Sym && !Sym->isUndefined(false));
       }
     }
 
     TheCondState.CondMet = (is_defined == expect_defined);
if (LastIgnoreState || TheCondState.CondMet) {
     if (!is_defined) {
       StringRef Name;
       if (check(parseIdentifier(Name),
                 "expected identifier after 'elseifdef'") ||
           parseToken(AsmToken::EndOfStatement,
                      "unexpected token in 'elseifdef'"))
         return true;
 
-      if (Variables.find(Name.lower()) != Variables.end()) {
+      if (BuiltinSymbolMap.find(Name.lower()) != BuiltinSymbolMap.end()) {
+        is_defined = true;
+      } else if (Variables.find(Name.lower()) != Variables.end()) {
         is_defined = true;
       } else {
         MCSymbol *Sym = getContext().lookupSymbol(Name);
         is_defined = (Sym && !Sym->isUndefined(false));
       }
     }
 
     TheCondState.CondMet = (is_defined == expect_defined);
bool MasmParser::parseDirectiveErrorIfdef(SMLoc DirectiveLoc,
   SMLoc StartLoc, EndLoc;
   IsDefined = (getTargetParser().tryParseRegister(RegNo, StartLoc, EndLoc) ==
                MatchOperand_Success);
   if (!IsDefined) {
     StringRef Name;
     if (check(parseIdentifier(Name), "expected identifier after '.errdef'"))
       return true;
 
-    if (Variables.find(Name.lower()) != Variables.end()) {
+    if (BuiltinSymbolMap.find(Name.lower()) != BuiltinSymbolMap.end()) {
+      IsDefined = true;
+    } else if (Variables.find(Name.lower()) != Variables.end()) {
       IsDefined = true;
     } else {
       MCSymbol *Sym = getContext().lookupSymbol(Name);
       IsDefined = (Sym && !Sym->isUndefined(false));
     }
   }
 
   std::string Message = ".errdef directive invoked in source file";
bool MasmParser::parseMSInlineAsm(
   // Emit the remainder of the asm string.
   if (AsmStart != AsmEnd)
     OS << StringRef(AsmStart, AsmEnd - AsmStart);
 
   AsmString = OS.str();
   return false;
 }
 
+void MasmParser::initializeBuiltinSymbolMap() {
+  // Numeric built-ins (supported in all versions)
+  BuiltinSymbolMap["@version"] = BI_VERSION;
+  BuiltinSymbolMap["@line"] = BI_LINE;
+
+  // Text built-ins (supported in all versions)
+  // BuiltinSymbolMap["@date"] = BI_DATE;
+  // BuiltinSymbolMap["@time"] = BI_TIME;
+  // BuiltinSymbolMap["@filecur"] = BI_FILECUR;
+  // BuiltinSymbolMap["@filename"] = BI_FILENAME;
+  // BuiltinSymbolMap["@curseg"] = BI_CURSEG;
+
+  // Some built-ins exist only for MASM32 (32-bit x86)
+  if (getContext().getSubtargetInfo()->getTargetTriple().getArch() ==
+      Triple::x86) {
+    // Numeric built-ins
+    // BuiltinSymbolMap["@cpu"] = BI_CPU;
+    // BuiltinSymbolMap["@interface"] = BI_INTERFACE;
+    // BuiltinSymbolMap["@wordsize"] = BI_WORDSIZE;
+    // BuiltinSymbolMap["@codesize"] = BI_CODESIZE;
+    // BuiltinSymbolMap["@datasize"] = BI_DATASIZE;
+    // BuiltinSymbolMap["@model"] = BI_MODEL;
+
+    // Text built-ins
+    // BuiltinSymbolMap["@code"] = BI_CODE;
+    // BuiltinSymbolMap["@data"] = BI_DATA;
+    // BuiltinSymbolMap["@fardata?"] = BI_FARDATA;
+    // BuiltinSymbolMap["@stack"] = BI_STACK;
+  }
+}
+
+const MCExpr *MasmParser::evaluateBuiltinValue(BuiltinSymbol Symbol,
+                                               SMLoc StartLoc) {
+  switch (Symbol) {
+  default:
+    return nullptr;
+  case BI_VERSION:
+    // Match a recent version of ML.EXE.
+    return MCConstantExpr::create(1427, getContext());
+  case BI_LINE: {
+    int64_t Line;
+    if (ActiveMacros.empty())
+      Line = SrcMgr.FindLineNumber(StartLoc, CurBuffer);
+    else
+      Line = SrcMgr.FindLineNumber(ActiveMacros.front()->InstantiationLoc,
+                                   ActiveMacros.front()->ExitBuffer);
+    return MCConstantExpr::create(Line, getContext());
+  }
+  }
+  llvm_unreachable("unhandled built-in symbol");
+}
+
 /// Create an MCAsmParser instance.
 MCAsmParser *llvm::createMCMasmParser(SourceMgr &SM, MCContext &C,
                                       MCStreamer &Out, const MCAsmInfo &MAI,
                                       unsigned CB) {
   return new MasmParser(SM, C, Out, MAI, CB);
 }

llvm/test/tools/llvm-ml/builtin_symbols.asm

+; RUN: llvm-ml -filetype=s %s /Fo /dev/null 2>&1 | FileCheck %s
+
+version_val TEXTEQU %@Version
+
+ECHO t1:
+%ECHO @Version = version_val
+; CHECK-LABEL: t1:
+; CHECK-NEXT: 1427
+
+ECHO
+
+ECHO t2:
+if @Version gt 510
+ECHO @Version gt 510
+endif
+; CHECK-LABEL: t2:
+; CHECK-NEXT: @Version gt 510
+
+ECHO
+
+ECHO t3:
+if @Version le 510
+ECHO le 510
+endif
+; CHECK-LABEL: t3:
+; CHECK-NOT: @Version le 510
+
+ECHO
+
+line_val TEXTEQU %@Line
+
+ECHO t4:
+%ECHO @Line = line_val
+; CHECK-LABEL: t4:
+; CHECK-NEXT: @Line = [[# @LINE - 5]]

llvm/test/tools/llvm-ml/variable_redef_errors.asm

 ; RUN: not llvm-ml -filetype=s %s /Fo - 2>&1 | FileCheck %s --implicit-check-not=error:
 
 .data
 
 ; <var> EQU <expression> can't be redefined to a new value
 equated_number equ 3
 ; CHECK: :[[# @LINE + 1]]:21: error: invalid variable redefinition
 equated_number equ 4
 
+; CHECK: :[[# @LINE + 1]]:1: error: cannot redefine a built-in symbol
+@Line equ 5
+
+; CHECK: :[[# @LINE + 1]]:1: error: cannot redefine a built-in symbol
+@Version equ 6
+
 .code
 
 end