[MC] Allowing the use of $-prefixed integer as asm identifiers

[pratlucas]

Summary

Dollar signed prefixed integers were not allowed by the AsmParser to be
used as Identifiers, differing from the GNU assembler behavior.

This patch updates the parsing of Identifiers to consider such cases as
valid, where the identifier string includes the $ prefix itself. As the
Lexer currently splits these occurrences into separate tokens, those
need to be combined by the AsmParser itself.

[efriedma]

llvm/include/llvm/MC/MCAsmMacro.h

100 ↗

(On Diff #246419)

I'd prefer to write out the new logic at the location of the relevant caller, instead. (Anything can call getString().)

llvm/lib/MC/MCParser/AsmParser.cpp

2858

String? I don't think we want to allow $"foo".

[pratlucas]

Addressing review comments.

[jrtc27]

llvm/lib/MC/MCParser/AsmParser.cpp

2861–2862

Comment is outdated

2868

Ditto

[jrtc27]

llvm/lib/MC/MCParser/AsmParser.cpp

2868

Actually I think this one is still fine?

[pratlucas]

Updating outdated comment.

[pratlucas]

llvm/lib/MC/MCParser/AsmParser.cpp

2868

I believe this one is still fine, as it references the identifier being parsed and not the actual token.

[pratlucas]

Clang-format fixes.

[efriedma]

LGTM

llvm/lib/MC/MCParser/AsmParser.cpp

bool AsmParser::parseIdentifier(StringRef &Res) {
   if (Lexer.is(AsmToken::Dollar) || Lexer.is(AsmToken::At)) {
     SMLoc PrefixLoc = getLexer().getLoc();
 
     // Consume the prefix character, and check for a following identifier.
 
     AsmToken Buf[1];
     Lexer.peekTokens(Buf, false);
 
-    if (Buf[0].isNot(AsmToken::Identifier))
+    if (Buf[0].isNot(AsmToken::Identifier) && Buf[0].isNot(AsmToken::Integer))
       return true;
 
-    // We have a '$' or '@' followed by an identifier, make sure they are adjacent.
+    // We have a '$' or '@' followed by an identifier or integer token, make
+    // sure they are adjacent.
     if (PrefixLoc.getPointer() + 1 != Buf[0].getLoc().getPointer())
       return true;
 
     // eat $ or @
     Lexer.Lex(); // Lexer's Lex guarantees consecutive token.
     // Construct the joined identifier and consume the token.
     Res =
-        StringRef(PrefixLoc.getPointer(), getTok().getIdentifier().size() + 1);
+        StringRef(PrefixLoc.getPointer(), getTok().getString().size() + 1);
     Lex(); // Parser Lex to maintain invariants.
     return false;
   }
 
   if (Lexer.isNot(AsmToken::Identifier) && Lexer.isNot(AsmToken::String))
     return true;
 
   Res = getTok().getIdentifier();

llvm/test/MC/ARM/arm-branches.s

 @ CHECK: beq  #4                      @ encoding: [0x01,0x00,0x00,0x0a]
 @ CHECK: blx  #2                      @ encoding: [0x00,0x00,0x00,0xfb]
 
 @------------------------------------------------------------------------------
 @ Leading '$' on branch targets must not be dropped if part of symbol names
 @------------------------------------------------------------------------------
 
         .global $foo
+        .global $4
         b $foo
         bl $foo
         beq $foo
         blx $foo
         b $foo + 4
+        bl $4
+        beq $4 + 4
 
 @ CHECK: b      ($foo)                      @ encoding: [A,A,A,0xea]
 @ CHECK: bl     ($foo)                      @ encoding: [A,A,A,0xeb]
 @ CHECK: beq    ($foo)                      @ encoding: [A,A,A,0x0a]
 @ CHECK: blx    ($foo)                      @ encoding: [A,A,A,0xfa]
 @ CHECK: b      #($foo)+4                   @ encoding: [A,A,A,0xea]
+@ CHECK: bl     ($4)                        @ encoding: [A,A,A,0xeb]
+@ CHECK: beq    #($4)+4                     @ encoding: [A,A,A,0x0a]
 
 @------------------------------------------------------------------------------
 @ Leading '$' should be allowed to introduce an expression
 @------------------------------------------------------------------------------
 
         .global bar
         b $ 4
         bl $ bar + 4
         blx $ bar
 @ CHECK: b      #4                        @ encoding: [0x01,0x00,0x00,0xea]
 @ CHECK: bl     #bar+4                    @ encoding: [A,A,A,0xeb]
 @ CHECK: blx    bar                       @ encoding: [A,A,A,0xfa]

llvm/test/MC/MachO/bad-dollar.s

-// RUN: not llvm-mc -triple x86_64-apple-darwin10 %s 2> %t.err > %t
-// RUN: FileCheck --check-prefix=CHECK-ERROR < %t.err %s
-
-.long $1
-// CHECK-ERROR: 4:7: error: invalid token in expression

llvm/test/MC/MachO/dollar-identifier.s

+// RUN: llvm-mc -triple x86_64-apple-darwin10 %s | FileCheck %s
+
+.long $1
+// CHECK: .long ($1)

llvm/test/MC/Mips/cpsetup-bad.s

 # RUN: not llvm-mc %s -triple mips64-unknown-unknown 2>%t1
 # RUN:   FileCheck %s < %t1 -check-prefix=ASM
 
         .text
         .option pic2
 t1:
         .cpsetup $bar, 8, __cerror
 # ASM: :[[@LINE-1]]:18: error: expected register containing function address
         .cpsetup $33, 8, __cerror
 # ASM: :[[@LINE-1]]:18: error: invalid register
         .cpsetup $31, foo, __cerror
 # ASM: :[[@LINE-1]]:23: error: expected save register or stack offset
         .cpsetup $31, $32, __cerror
 # ASM: :[[@LINE-1]]:23: error: invalid register
-        .cpsetup $25, $2, $3
-# ASM: :[[@LINE-1]]:27: error: expected expression
         .cpsetup $25, $2, 4
 # ASM: :[[@LINE-1]]:28: error: expected symbol
         .cpsetup $25, $2, 4+65
 # ASM: :[[@LINE-1]]:31: error: expected symbol
         .cpsetup $25, $2, foo+4
 # ASM: :[[@LINE-1]]:32: error: expected symbol

llvm/test/MC/Mips/invalid-instructions-spellcheck.s

 # RUN: not llvm-mc -triple mips-unknown-linux-gnu -mcpu=mips32r2 \
 # RUN:             -mattr=+micromips %s 2>&1 \
 # RUN:   | FileCheck --check-prefixes=ALL,MMR2 %s
 # RUN: not llvm-mc -triple mips-unknown-linux-gnu -mcpu=mips32r6 \
 # RUN:             -mattr=+micromips %s 2>&1 \
 # RUN:   | FileCheck --check-prefixes=ALL,MMR6 %s
 # RUN: not llvm-mc -triple mips-unknown-linux-gnu -mcpu=mips32r6 %s 2>&1 \
 # RUN:   | FileCheck --check-prefixes=ALL,MIPS32R6 %s
 
 # This tests the mnemonic spell checker.
 
 # First check what happens when an instruction is omitted:
 
 $2, $1, $25
 
-# ALL:      error: unexpected token at start of statement
+# ALL:      error: unknown instruction
 # ALL-NEXT: $2, $1, $25
 # ALL-NEXT:  ^
 
 # We don't want to see a suggestion here; the edit distance is too large to
 # give sensible suggestions:
 
 aaaaaaaaaaaaaaa $2, $1, $25