[MC] Allow targets to control whether '?' can be used in identifiers

[barannikov88]

Summary

GNU assembler does not allow '?' in (unquoted) identifiers.
MC assembler allows it as an extension (D1978). '?' can be disabled at
the start of an identifier by setting AllowQuestionAtStartOfIdentifier
to false. This patch adds another knob, AllowQuestionInName, that
controls whether '?' can appear in the middle of an identifier.

With the knob turned off, something like "a?b" is now lexed as three
distinct tokens instead of one.

Unfortunately, there are no in-tree targets that need the new behavior,
so no tests.

[barannikov88]

Call the correct method

llvm/include/llvm/MC/MCAsmInfo.h

protected:
 
   /// Which dialect of an assembler variant to use.  Defaults to 0
   unsigned AssemblerDialect = 0;
 
   /// This is true if the assembler allows @ characters in symbol names.
   /// Defaults to false.
   bool AllowAtInName = false;
 
+  /// This is true if the assembler allows '?' characters in symbol names.
+  bool AllowQuestionInName = true;
+
   /// This is true if the assembler allows the "?" character at the start of
   /// of a string to be lexed as an AsmToken::Identifier.
   /// If the AsmLexer determines that the string can be lexed as a possible
   /// comment, setting this option will have no effect, and the string will
   /// still be lexed as a comment.
   bool AllowQuestionAtStartOfIdentifier = false;
 
   /// This is true if the assembler allows the "$" character at the start of
public:
   const char *getInlineAsmStart() const { return InlineAsmStart; }
   const char *getInlineAsmEnd() const { return InlineAsmEnd; }
   const char *getCode16Directive() const { return Code16Directive; }
   const char *getCode32Directive() const { return Code32Directive; }
   const char *getCode64Directive() const { return Code64Directive; }
   unsigned getAssemblerDialect() const { return AssemblerDialect; }
   bool doesAllowAtInName() const { return AllowAtInName; }
   void setAllowAtInName(bool V) { AllowAtInName = V; }
+  bool doesAllowQuestionInName() const { return AllowQuestionInName; }
   bool doesAllowQuestionAtStartOfIdentifier() const {
     return AllowQuestionAtStartOfIdentifier;
   }
   bool doesAllowAtAtStartOfIdentifier() const {
     return AllowAtAtStartOfIdentifier;
   }
   bool doesAllowDollarAtStartOfIdentifier() const {
     return AllowDollarAtStartOfIdentifier;

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 = false;
   bool AllowHashInIdentifier = false;
+  bool AllowQuestionInIdentifier = false;
   bool IsAtStartOfStatement = true;
   bool LexMasmHexFloats = false;
   bool LexMasmIntegers = false;
   bool LexMasmStrings = false;
   bool LexMotorolaIntegers = false;
   bool UseMasmDefaultRadix = false;
   unsigned DefaultRadix = 10;
   bool LexHLASMIntegers = false;

llvm/lib/MC/MCParser/AsmLexer.cpp

 #include <string>
 #include <tuple>
 #include <utility>
 
 using namespace llvm;
 
 AsmLexer::AsmLexer(const MCAsmInfo &MAI) : MAI(MAI) {
   AllowAtInIdentifier = !StringRef(MAI.getCommentString()).startswith("@");
+  AllowQuestionInIdentifier = MAI.doesAllowAtInName();
   LexMotorolaIntegers = MAI.shouldUseMotorolaIntegers();
 }
 
 AsmLexer::~AsmLexer() = default;
 
 void AsmLexer::setBuffer(StringRef Buf, const char *ptr,
                          bool EndStatementAtEOF) {
   CurBuf = Buf;
AsmToken AsmLexer::LexHexFloatLiteral(bool NoIntDigits) {
   if (CurPtr == ExpStart)
     return ReturnError(TokStart, "invalid hexadecimal floating-point constant: "
                                  "expected at least one exponent digit");
 
   return AsmToken(AsmToken::Real, StringRef(TokStart, CurPtr - TokStart));
 }
 
 /// LexIdentifier: [a-zA-Z_$.@?][a-zA-Z0-9_$.@#?]*
-static bool isIdentifierChar(char C, bool AllowAt, bool AllowHash) {
-  return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '?' ||
-         (AllowAt && C == '@') || (AllowHash && C == '#');
+static bool isIdentifierChar(char C, bool AllowAt, bool AllowHash,
+                             bool AllowQuestion) {
+  return isAlnum(C) || C == '_' || C == '$' || C == '.' ||
+         (AllowAt && C == '@') || (AllowHash && C == '#') ||
+         (AllowQuestion && C == '?');
 }
 
 AsmToken AsmLexer::LexIdentifier() {
   // Check for floating point literals.
   if (CurPtr[-1] == '.' && isDigit(*CurPtr)) {
     // Disambiguate a .1243foo identifier from a floating literal.
     while (isDigit(*CurPtr))
       ++CurPtr;
 
-    if (!isIdentifierChar(*CurPtr, AllowAtInIdentifier,
-                          AllowHashInIdentifier) ||
+    if (!isIdentifierChar(*CurPtr, AllowAtInIdentifier, AllowHashInIdentifier,
+                          AllowQuestionInIdentifier) ||
         *CurPtr == 'e' || *CurPtr == 'E')
       return LexFloatLiteral();
   }
 
-  while (isIdentifierChar(*CurPtr, AllowAtInIdentifier, AllowHashInIdentifier))
+  while (isIdentifierChar(*CurPtr, AllowAtInIdentifier, AllowHashInIdentifier,
+                          AllowQuestionInIdentifier))
     ++CurPtr;
 
   // Handle . as a special case.
   if (CurPtr == TokStart+1 && TokStart[0] == '.')
     return AsmToken(AsmToken::Dot, StringRef(TokStart, 1));
 
   return AsmToken(AsmToken::Identifier, StringRef(TokStart, CurPtr - TokStart));
 }