[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

2153

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

2153

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

private:
   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;
 
+  /// \brief Keeps track of how many .macro's have been instantiated.
+  unsigned NumOfMacroInstantiations;
+
   /// Flag tracking whether any errors have been encountered.
   unsigned HadError : 1;
 
   /// The values from the last parsed cpp hash file line comment if any.
   StringRef CppHashFilename;
   int64_t CppHashLineNumber;
   SMLoc CppHashLoc;
   unsigned CppHashBuf;
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,
+                   ArrayRef<MCAsmMacroArgument> A, bool EnableAtPseudoVariable,
                    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;}
 
case MCObjectFileInfo::IsMachO:
     break;
   case MCObjectFileInfo::IsELF:
     PlatformParser.reset(createELFAsmParser());
     break;
   }
 
   PlatformParser->Initialize(*this);
   initializeDirectiveKindMap();
+
+  NumOfMacroInstantiations = 0;
 }
 
 AsmParser::~AsmParser() {
   assert((HadError || ActiveMacros.empty()) &&
          "Unexpected active macro instantiation!");
 }
 
 void AsmParser::printMacroInstantiations() {

 // '@' 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, 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 (Argument == "@") {
+        OS << NumOfMacroInstantiations;
+        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,
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, 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);
 
+  ++NumOfMacroInstantiations;
+
   // 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;
 }
 
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()))
+    // Note that the AtPseudoVariable is disabled for instantiations of .rep(t).
+    if (expandMacro(OS, M->Body, None, None, false, 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()))
+    // Note that the AtPseudoVariable is enabled for instantiations of .irp.
+    // This is undocumented, but GAS seems to support it.
+    if (expandMacro(OS, M->Body, Parameter, *i, true, 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()))
+    // Note that the AtPseudoVariable is enabled for instantiations of .irpc.
+    // This is undocumented, but GAS seems to support it.
+    if (expandMacro(OS, M->Body, Parameter, Arg, true, 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
+
+.rept 2
+  addi $8, $8, \@
+.endr
+# CHECK: error: unknown token in expression
+# CHECK: :[[@LINE-4]]:1: note: while in macro instantiation
+# CHECK-NEXT: .rept 2
+
+.rep 3
+  addi $9, $9, \@
+.endr
+# CHECK: error: unknown token in expression
+# CHECK: :[[@LINE-4]]:1: note: while in macro instantiation
+# CHECK-NEXT: .rep 3

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

+# RUN: llvm-mc -triple i386-unknown-unknown %s | FileCheck %s
+
+.macro A
+  add  $1\@, %eax
+.endm
+
+.macro B
+  sub  $1\@, %eax
+.endm
+
+  A
+# CHECK: addl  $10, %eax
+  A
+# CHECK: addl  $11, %eax
+  B
+# CHECK: subl  $12, %eax
+  B
+# CHECK: subl  $13, %eax
+
+# The following uses of \@ are undocumented, but valid:
+.irpc foo,234
+  add  $\foo\@, %eax
+.endr
+# CHECK: addl  $24, %eax
+# CHECK: addl  $34, %eax
+# CHECK: addl  $44, %eax
+
+.irp reg,%eax,%ebx
+  sub  $2\@, \reg
+.endr
+# CHECK: subl  $24, %eax
+# CHECK: subl  $24, %ebx
+
+# Test that .irp(c) and .rep(t) do not increase \@.
+# Only the use of A should increase \@, so we can test that it increases by 1
+# each time.
+
+.irpc foo,123
+  sub  $\foo, %eax
+.endr
+
+  A
+# CHECK: addl  $14, %eax
+
+.irp reg,%eax,%ebx
+  sub  $4, \reg
+.endr
+
+  A
+# CHECK: addl  $15, %eax
+
+.rept 2
+  sub  $5, %eax
+.endr
+
+  A
+# CHECK: addl  $16, %eax
+
+.rep 3
+  sub  $6, %eax
+.endr
+
+  A
+# CHECK: addl  $17, %eax