[ms] [llvm-ml] Allow arbitrary strings as integer constants

[epastor]

Summary

MASM interprets strings in expression contexts as integers expressed in big-endian base-256, treating each character as its ASCII representation.

This completely eliminates the need to special-case single-character strings.

llvm/lib/MC/MCParser/MasmParser.cpp

 }
 
 /// Parse a primary expression and return it.
 ///  primaryexpr ::= (parenexpr
 ///  primaryexpr ::= symbol
 ///  primaryexpr ::= number
 ///  primaryexpr ::= '.'
 ///  primaryexpr ::= ~,+,-,'not' primaryexpr
+///  primaryexpr ::= string
+///          (a string is interpreted as a 64-bit number in big-endian base-256)
 bool MasmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc,
                                   AsmTypeInfo *TypeInfo) {
   SMLoc FirstTokenLoc = getLexer().getLoc();
   AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
   switch (FirstTokenKind) {
   default:
     return TokError("unknown token in expression");
   // If we have an error assume that we've already handled it.
   case AsmToken::Error:
     return true;
   case AsmToken::Exclaim:
     Lex(); // Eat the operator.
     if (parsePrimaryExpr(Res, EndLoc, nullptr))
       return true;
     Res = MCUnaryExpr::createLNot(Res, getContext(), FirstTokenLoc);
     return false;
   case AsmToken::Dollar:
   case AsmToken::At:
-  case AsmToken::String:
   case AsmToken::Identifier: {
     StringRef Identifier;
     if (parseIdentifier(Identifier)) {
       // We may have failed but $ may be a valid token.
       if (getTok().is(AsmToken::Dollar)) {
         if (Lexer.getMAI().getDollarIsPC()) {
           Lex();
           // This is a '$' reference, which references the current PC.  Emit a
if (Lexer.getKind() == AsmToken::Identifier) {
           return Error(Loc, "directional label undefined");
         DirLabels.push_back(std::make_tuple(Loc, CppHashInfo, Sym));
         EndLoc = Lexer.getTok().getEndLoc();
         Lex(); // Eat identifier.
       }
     }
     return false;
   }
+  case AsmToken::String: {
+    // MASM strings (used as constants) are interpreted as big-endian base-256.
+    SMLoc ValueLoc = getTok().getLoc();
+    std::string Value;
+    if (parseEscapedString(Value))
+      return true;
+    if (Value.size() > 8)
+      return Error(ValueLoc, "literal value out of range");
+    uint64_t IntValue = 0;
+    for (const unsigned char CharVal : Value)
+      IntValue = (IntValue << 8) | CharVal;
+    Res = MCConstantExpr::create(IntValue, getContext());
+    return false;
+  }
   case AsmToken::Real: {
     APFloat RealVal(APFloat::IEEEdouble(), getTok().getString());
     uint64_t IntVal = RealVal.bitcastToAPInt().getZExtValue();
     Res = MCConstantExpr::create(IntVal, getContext());
     EndLoc = Lexer.getTok().getEndLoc();
     Lex(); // Eat token.
     return false;
   }
if (const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value)) {
     }
   }
   return false;
 }
 
 bool MasmParser::parseScalarInitializer(unsigned Size,
                                         SmallVectorImpl<const MCExpr *> &Values,
                                         unsigned StringPadLength) {
-  if (getTok().is(AsmToken::String)) {
+  if (Size == 1 && getTok().is(AsmToken::String)) {
     std::string Value;
     if (parseEscapedString(Value))
       return true;
-    if (Size == 1) {
-      // Treat each character as an initializer.
-      for (const char CharVal : Value)
-        Values.push_back(MCConstantExpr::create(CharVal, getContext()));
+    for (const unsigned char CharVal : Value)
 
-      // Pad the string with spaces to the specified length.
-      for (size_t i = Value.size(); i < StringPadLength; ++i)
-        Values.push_back(MCConstantExpr::create(' ', getContext()));
-    } else {
-      // Treat the string as an initial value in big-endian representation.
-      if (Value.size() > Size)
-        return Error(getTok().getLoc(), "out of range literal value");
-
-      uint64_t IntValue = 0;
-      for (const unsigned char CharVal : Value)
-        IntValue = (IntValue << 8) | CharVal;
-      Values.push_back(MCConstantExpr::create(IntValue, getContext()));
-    }
-  } else {
     const MCExpr *Value;
     if (parseExpression(Value))
       return true;
     if (getTok().is(AsmToken::Identifier) &&
         getTok().getString().equals_lower("dup")) {
       Lex(); // Eat 'dup'.
       const MCConstantExpr *MCE = dyn_cast<MCConstantExpr>(Value);
       if (!MCE)

llvm/lib/Target/X86/AsmParser/X86AsmParser.cpp

case AsmToken::Dot:
       break;
     case AsmToken::Dollar:
       if (!Parser.isParsingMasm()) {
         if ((Done = SM.isValidEndState()))
           break;
         return Error(Tok.getLoc(), "unknown token in expression");
       }
       LLVM_FALLTHROUGH;
-    case AsmToken::At:
-    case AsmToken::String:
-    case AsmToken::Identifier: {
-      if (Parser.isParsingMasm() && Tok.is(AsmToken::String)) {
-        // Single-character strings should be treated as integer constants. This
-        // includes MASM escapes for quotes.
-        char Quote = Tok.getString().front();
-        StringRef Contents = Tok.getStringContents();
-        if (Contents.size() == 1 || Contents == std::string(2, Quote)) {
-          if (SM.onInteger(Contents.front(), ErrMsg))
-            return Error(Tok.getLoc(), ErrMsg);
-          break;
-        }
-      }
+    case AsmToken::String: {
+      if (Parser.isParsingMasm()) {
+        // MASM parsers handle strings in expressions as constants.
+        SMLoc ValueLoc = Tok.getLoc();
+        int64_t Res;
+        const MCExpr *Val;
+        if (Parser.parsePrimaryExpr(Val, End, nullptr))
+          return true;
+        UpdateLocLex = false;
+        if (!Val->evaluateAsAbsolute(Res, getStreamer().getAssemblerPtr()))
+          return Error(ValueLoc, "expected absolute value");
+        if (SM.onInteger(Res, ErrMsg))
+          return Error(ValueLoc, ErrMsg);
+      LLVM_FALLTHROUGH;
+    case AsmToken::At:
+    case AsmToken::Identifier: {
       SMLoc IdentLoc = Tok.getLoc();
       StringRef Identifier = Tok.getString();
       UpdateLocLex = false;
       if (Parser.isParsingMasm()) {
         size_t DotOffset = Identifier.find_first_of('.');
         if (DotOffset != StringRef::npos) {
           consumeToken();
           StringRef LHS = Identifier.slice(0, DotOffset);

llvm/test/tools/llvm-ml/strings.test

 ; CHECK: mov eax, 34
 
   mov eax, "'"
 ; CHECK: mov eax, 39
 
   ret
 dq_char_test ENDP
 
+string_constant_test PROC
+; CHECK-LABEL: string_constant_test:
+
+  mov eax, 'ab'
+  mov eax, "ab"
+; CHECK: mov eax, 24930
+; CHECK: mov eax, 24930
+
+  mov eax, "abc"
+  mov eax, 'abc'
+; CHECK: mov eax, 6382179
+; CHECK: mov eax, 6382179
+
+  mov eax, "abc"""
+  mov eax, 'abc'''
+; CHECK: mov eax, 1633837858
+; CHECK: mov eax, 1633837863
+
+  ret
+string_constant_test ENDP
+
 end

llvm/test/tools/llvm-ml/strings_errors.test

+; RUN: not llvm-ml -filetype=asm %s 2>&1 | FileCheck %s --implicit-check-not=error:
+
+.code
+
+oversize_string_test PROC
+
+  mov rax, "abcdefghi"
+  mov rax, 'abcdefghi'
+; CHECK: error: literal value out of range
+; CHECK: error: literal value out of range
+
+  ret
+oversize_string_test ENDP
+
+end