[MC] [IAS] Add support for the \@ .macro pseudo-variable.

[tomatabacu]

Summary

When used, it is substituted with the number of .macro instantiations we've done up to that point in time.
So if this is the 1st time we've instantiated a .macro (any .macro, regardless of name), \@ will instantiate to 0, if it's the 2nd .macro instantiation, it will instantiate to 1 etc.

It can only be used inside a .macro definition, an .irp definition or an .irpc definition (those last 2 uses are undocumented).

[• rafael]

The documentation in gas says @ is " how many macros it has executed ". Is the documentation wrong?

Expand the test a bit. In particular, can you test for a macro being undefined and the number going down? Also, you check for \@ in two locations (two ifs use EnableAtPseudoVariable), but the test only covers one of them, no?

[tomatabacu]

Fixed wrong implementation.
Updated tests.

[tomatabacu]

In D9197#160307, @rafael wrote:

The documentation in gas says @ is " how many macros it has executed ". Is the documentation wrong?

No, the documentation is right, I just got too focused on an ambiguous test-case. Sorry about that!
I think it's supposed to track the number of .macro instantiations we've made up to that point.

In particular, can you test for a macro being undefined and the number going down?

I don't think this applies anymore, as the number of instantiations can't go down.

Also, you check for \@ in two locations (two ifs use EnableAtPseudoVariable), but the test only covers one of them, no?

That second check is redundant AFAICT, as Argument can only be "@" if the first check succeeds, so I removed it.

[• rafael]

Please a test with rep showing that it increments (or doesn't) the counter for @.

lib/MC/MCParser/AsmParser.cpp

2164

rep will increment this, no? Should it?

[tomatabacu]

Added test case which checks that .irp(c) and .rep(t) do not increase \@.

[tomatabacu]

Replied to inline comment.

lib/MC/MCParser/AsmParser.cpp

2164

It turns out that .rep(t) don't increment \@ and shouldn't. The same goes for irp(c).

[• rafael]

LGTM

lib/MC/MCParser/AsmParser.cpp

 };
 
 typedef std::vector<MCAsmMacroParameter> MCAsmMacroParameters;
 
 struct MCAsmMacro {
   StringRef Name;
   StringRef Body;
   MCAsmMacroParameters Parameters;
+  unsigned AtPseudoVariableValue;
 
 public:
   MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)
       : Name(N), Body(B), Parameters(std::move(P)) {}
 };
 
 /// \brief Helper class for storing information about an active macro
 /// instantiation.
private:
   /// \brief maps directive names to handler methods in parser
   /// extensions. Extensions register themselves in this map by calling
   /// addDirectiveHandler.
   StringMap<ExtensionDirectiveHandler> ExtensionDirectiveMap;
 
   /// \brief Map of currently defined macros.
   StringMap<MCAsmMacro> MacroMap;
 
+  /// \brief Keeps track of how many .macro's have been defined.
+  unsigned NumOfMacroDefs;
+
   /// \brief Stack of active macro instantiations.
   std::vector<MacroInstantiation*> ActiveMacros;
 
   /// \brief List of bodies of anonymous macros.
   std::deque<MCAsmMacro> MacroLikeBodies;
 
   /// Boolean tracking whether macro substitution is enabled.
   unsigned MacrosEnabledFlag : 1;
bool parseStatement(ParseStatementInfo &Info,
                       MCAsmParserSemaCallback *SI);
   void eatToEndOfLine();
   bool parseCppHashLineFilenameComment(const SMLoc &L);
 
   void checkForBadMacro(SMLoc DirectiveLoc, StringRef Name, StringRef Body,
                         ArrayRef<MCAsmMacroParameter> Parameters);
   bool expandMacro(raw_svector_ostream &OS, StringRef Body,
                    ArrayRef<MCAsmMacroParameter> Parameters,
-                   ArrayRef<MCAsmMacroArgument> A,
-                   const SMLoc &L);
+                   ArrayRef<MCAsmMacroArgument> A, bool EnableAtPseudoVariable,
+                   unsigned AtPseudoVariableValue, const SMLoc &L);
 
   /// \brief Are macros enabled in the parser?
   bool areMacrosEnabled() {return MacrosEnabledFlag;}
 
   /// \brief Control a flag in the parser that enables or disables macros.
   void setMacrosEnabled(bool Flag) {MacrosEnabledFlag = Flag;}
 
   /// \brief Lookup a previously defined macro.
: Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),
       AssemblerDialect(~0U), IsDarwin(false), ParsingInlineAsm(false) {
   // Save the old handler.
   SavedDiagHandler = SrcMgr.getDiagHandler();
   SavedDiagContext = SrcMgr.getDiagContext();
   // Set our own handler which calls the saved handler.
   SrcMgr.setDiagHandler(DiagHandler, this);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
 
+  NumOfMacroDefs = 0;
+
   // Initialize the platform / file format parser.
   switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
   case MCObjectFileInfo::IsCOFF:
     PlatformParser.reset(createCOFFAsmParser());
     break;
   case MCObjectFileInfo::IsMachO:
     PlatformParser.reset(createDarwinAsmParser());
     IsDarwin = true;

 // '@' as a special case when needed.
 static bool isIdentifierChar(char c) {
   return isalnum(static_cast<unsigned char>(c)) || c == '_' || c == '$' ||
          c == '.';
 }
 
 bool AsmParser::expandMacro(raw_svector_ostream &OS, StringRef Body,
                             ArrayRef<MCAsmMacroParameter> Parameters,
-                            ArrayRef<MCAsmMacroArgument> A, const SMLoc &L) {
+                            ArrayRef<MCAsmMacroArgument> A,
+                            bool EnableAtPseudoVariable,
+                            unsigned AtPseudoVariableValue, const SMLoc &L) {
   unsigned NParameters = Parameters.size();
   bool HasVararg = NParameters ? Parameters.back().Vararg : false;
   if ((!IsDarwin || NParameters != 0) && NParameters != A.size())
     return Error(L, "Wrong number of arguments");
 
   // A macro without parameters is handled differently on Darwin:
   // gas accepts no arguments and does no substitutions
   while (!Body.empty()) {
if (IsDarwin && !NParameters) {
              it != ie; ++it)
           OS << it->getString();
         break;
       }
       }
       Pos += 2;
     } else {
       unsigned I = Pos + 1;
+
+      // Check for the \@ pseudo-variable.
+      if (EnableAtPseudoVariable && Body[I] == '@' && I + 1 != End)
+        ++I;
+      else
         while (isIdentifierChar(Body[I]) && I + 1 != End)
           ++I;
 
       const char *Begin = Body.data() + Pos + 1;
       StringRef Argument(Begin, I - (Pos + 1));
       unsigned Index = 0;
+
+      if (EnableAtPseudoVariable && Argument == "@") {
+        OS << AtPseudoVariableValue;
+        Pos += 2;
+      } else {
         for (; Index < NParameters; ++Index)
           if (Parameters[Index].Name == Argument)
             break;
 
         if (Index == NParameters) {
           if (Body[Pos + 1] == '(' && Body[Pos + 2] == ')')
             Pos += 3;
           else {
             OS << '\\' << Argument;
             Pos = I;
           }
         } else {
           bool VarargParameter = HasVararg && Index == (NParameters - 1);
           for (MCAsmMacroArgument::const_iterator it = A[Index].begin(),
                                                   ie = A[Index].end();
                it != ie; ++it)
             // We expect no quotes around the string's contents when
             // parsing for varargs.
             if (it->getKind() != AsmToken::String || VarargParameter)
               OS << it->getString();
             else
               OS << it->getStringContents();
 
           Pos += 1 + Argument.size();
         }
       }
+    }
     // Update the scan point.
     Body = Body.substr(Pos);
   }
 
   return false;
 }
 
 MacroInstantiation::MacroInstantiation(SMLoc IL, int EB, SMLoc EL,

 }
 
 const MCAsmMacro *AsmParser::lookupMacro(StringRef Name) {
   StringMap<MCAsmMacro>::iterator I = MacroMap.find(Name);
   return (I == MacroMap.end()) ? nullptr : &I->getValue();
 }
 
 void AsmParser::defineMacro(StringRef Name, MCAsmMacro Macro) {
+  Macro.AtPseudoVariableValue = NumOfMacroDefs;
+  ++NumOfMacroDefs;
+
   MacroMap.insert(std::make_pair(Name, std::move(Macro)));
 }
 
-void AsmParser::undefineMacro(StringRef Name) { MacroMap.erase(Name); }
+void AsmParser::undefineMacro(StringRef Name) {
+  MacroMap.erase(Name);
+
+  assert(NumOfMacroDefs > 0 && "There are no .macros to undefine!");
+  --NumOfMacroDefs;
+}
 
 bool AsmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc) {
   // Arbitrarily limit macro nesting depth, to match 'as'. We can eliminate
   // this, although we should protect against infinite loops.
   if (ActiveMacros.size() == 20)
     return TokError("macros cannot be nested more than 20 levels deep");
 
   MCAsmMacroArguments A;
   if (parseMacroArguments(M, A))
     return true;
 
   // Macro instantiation is lexical, unfortunately. We construct a new buffer
   // to hold the macro body with substitutions.
   SmallString<256> Buf;
   StringRef Body = M->Body;
   raw_svector_ostream OS(Buf);
 
-  if (expandMacro(OS, Body, M->Parameters, A, getTok().getLoc()))
+  if (expandMacro(OS, Body, M->Parameters, A, true, M->AtPseudoVariableValue,
+                  getTok().getLoc()))
     return true;
 
   // We include the .endmacro in the buffer as our cue to exit the macro
   // instantiation.
   OS << ".endmacro\n";
 
   std::unique_ptr<MemoryBuffer> Instantiation =
       MemoryBuffer::getMemBufferCopy(OS.str(), "<instantiation>");
 
   // Create the macro instantiation object and add to the current macro
   // instantiation stack.
   MacroInstantiation *MI = new MacroInstantiation(
       NameLoc, CurBuffer, getTok().getLoc(), TheCondStack.size());
   ActiveMacros.push_back(MI);
 
   // Jump to the macro instantiation and prime the lexer.
   CurBuffer = SrcMgr.AddNewSourceBuffer(std::move(Instantiation), SMLoc());
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
   Lex();
 
   return false;
 }
 
 void AsmParser::handleMacroExit() {
bool AsmParser::parseDirectiveRept(SMLoc DirectiveLoc, StringRef Dir) {
   if (!M)
     return true;
 
   // Macro instantiation is lexical, unfortunately. We construct a new buffer
   // to hold the macro body with substitutions.
   SmallString<256> Buf;
   raw_svector_ostream OS(Buf);
   while (Count--) {
-    if (expandMacro(OS, M->Body, None, None, getTok().getLoc()))
+    if (expandMacro(OS, M->Body, None, None, false, 0, getTok().getLoc()))
       return true;
   }
   instantiateMacroLikeBody(M, DirectiveLoc, OS);
 
   return false;
 }
 
 /// parseDirectiveIrp
if (!M)
     return true;
 
   // Macro instantiation is lexical, unfortunately. We construct a new buffer
   // to hold the macro body with substitutions.
   SmallString<256> Buf;
   raw_svector_ostream OS(Buf);
 
   for (MCAsmMacroArguments::iterator i = A.begin(), e = A.end(); i != e; ++i) {
-    if (expandMacro(OS, M->Body, Parameter, *i, getTok().getLoc()))
+    if (expandMacro(OS, M->Body, Parameter, *i, false, 0, getTok().getLoc()))
       return true;
   }
 
   instantiateMacroLikeBody(M, DirectiveLoc, OS);
 
   return false;
 }
 
bool AsmParser::parseDirectiveIrpc(SMLoc DirectiveLoc) {
   SmallString<256> Buf;
   raw_svector_ostream OS(Buf);
 
   StringRef Values = A.front().front().getString();
   for (std::size_t I = 0, End = Values.size(); I != End; ++I) {
     MCAsmMacroArgument Arg;
     Arg.push_back(AsmToken(AsmToken::Identifier, Values.slice(I, I + 1)));
 
-    if (expandMacro(OS, M->Body, Parameter, Arg, getTok().getLoc()))
+    if (expandMacro(OS, M->Body, Parameter, Arg, false, 0,  getTok().getLoc()))
       return true;
   }
 
   instantiateMacroLikeBody(M, DirectiveLoc, OS);
 
   return false;
 }
 

test/MC/AsmParser/at-pseudo-variable-bad.s

+# RUN: not llvm-mc -triple i386-unknown-unknown < %s 2>&1 | FileCheck %s
+
+add  $1\@, %eax
+# CHECK: :[[@LINE-1]]:8: error: unexpected token in argument list
+
+.macro A @
+  mov  %eax, %eax
+.endm
+# CHECK: :[[@LINE-3]]:11: error: expected identifier in '.macro' directive

test/MC/AsmParser/at-pseudo-variable.s

+# RUN: llvm-mc -triple i386-unknown-unknown %s | FileCheck %s
+
+.macro A
+  mov  $1\@, %eax
+.endm
+
+.macro B
+  add  $1\@, %eax
+.endm
+
+.macro C
+  sub  $1\@, %eax
+.endm
+
+  A
+# CHECK: movl  $10, %eax
+  B
+# CHECK: addl  $11, %eax
+  C
+# CHECK: subl  $12, %eax