[LLVM][inline-asm] Altmacro string escape character '!'

[m_zuckerman]

Summary

This patch is the fourth patch in a series of reviews for the Altmacro feature. This patch introduces a new escape character '!' and it depends on D32701.

according to https://sourceware.org/binutils/docs/as/Altmacro.html:
"single-character string escape
To include any single character literally in a string (even if the character would otherwise have some special meaning), you can prefix the character with !' (an exclamation mark). For example, you can write <4.3 !> 5.4!!>' to get the literal text `4.3 > 5.4!'. "

[m_zuckerman]

Ping

[rengolin]

lib/MC/MCParser/AsmParser.cpp

1211–1214

This could be:

while ( ((...) && (*CharPtr != '\0')) || (*CharPtr == '!')) {
  CharPtr++;

1224

This should really use isAltmacroString to make sure it really is a string, or it could have the same problems you detect on the other cases. But doing that, the same logic would need to be implemented twice.

A better approach would be if isAltmacroString was actually just altMacroString and, if the result is not empty, it "is an alt-macro string".

test/MC/AsmParser/altmacro_string_escape.s

4

put the check lines near where they make sense, for instance, near the macro definition, or its use.

[m_zuckerman]

lib/MC/MCParser/AsmParser.cpp

1211–1214

It will not work since you need double promotion.
Consider the following code <5!>4> you want to jump into the '4' char. For that, you will need double promotion.

1224

This function called after "isAltMacroString" validates the string D32701.
How the flow works:

1. One of the argument contains the '<' sign (parseMacroArguments).
2. This argument is then validated by the second "else if" in the "parseMacroArguments" function(D32701)
3. If the string begins with '<' and ends with '>' the function(parseMacroArguments) marks him as a string.
4. Only token that begins with '<' and marked as a string can enter to this function.

The problem with your approach is that we need to create a new string that not contain the '!'. This we can't do unless we will create a new global string in the begin of the main function "handleMacroEntry". Since the Stringref only contains the reference. We can't modify him and only mark him.

What you think, Do you prefer to create a new global string in the begin of the function and then use it?

[m_zuckerman]

Ping :)

[rengolin]

As parsers go, simplicity and elegance are usually mutually exclusive.

I agree with you that, in this case, simplicity is more important, even if that generates a bit of redundancy, which isn't really that much.

LGTM. Thanks!

lib/MC/MCParser/AsmParser.cpp

1211–1214

of course!

1224

Dang, I hate parsers! They're always full of chickens and eggs.

[m_zuckerman]

Thanks a lot :)

lib/MC/MCParser/AsmParser.cpp

public:
   void eatToEndOfStatement() override;
 
   bool checkForValidSection() override;
 
   /// }
 
 private:
   bool isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc);
+  void altMacroString(StringRef AltMacroStr, std::string &Res);
   bool parseStatement(ParseStatementInfo &Info,
                       MCAsmParserSemaCallback *SI);
   bool parseCurlyBlockScope(SmallVectorImpl<AsmRewrite>& AsmStrRewrites);
   bool parseCppHashLineFilenameComment(SMLoc L);
 
   void checkForBadMacro(SMLoc DirectiveLoc, StringRef Name, StringRef Body,
                         ArrayRef<MCAsmMacroParameter> Parameters);
   bool expandMacro(raw_svector_ostream &OS, StringRef Body,

 
 /// There is a gap between the AltMacro's documentation and the single quote implementation. 
 /// GCC does not fully support this feature and so we will not support it.
 /// TODO: Adding single quote as a string.
 bool AsmParser::isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc) {
   assert((StrLoc.getPointer() != NULL) &&
          "Argument to the function cannot be a NULL value");
   const char *CharPtr = StrLoc.getPointer();
   while ((*CharPtr != '>') && (*CharPtr != '\n') &&
          (*CharPtr != '\r') && (*CharPtr != '\0')){
+    if(*CharPtr == '!')
+      CharPtr++;
     CharPtr++;
   }
   if (*CharPtr == '>') {
     EndLoc = StrLoc.getFromPointer(CharPtr + 1);
     return true;
   }
   return false;
 }
 
+/// \brief creating a string without the escape characters '!'.
+void AsmParser::altMacroString(StringRef AltMacroStr,std::string &Res) {
+  for (int Pos = 0; Pos < AltMacroStr.size(); Pos++) {
+    if (AltMacroStr[Pos] == '!')
+      Pos++;
+    Res += AltMacroStr[Pos];
+  }
+}
+
 /// \brief Parse an expression and return it.
 ///
 ///  expr ::= expr &&,|| expr               -> lowest.
 ///  expr ::= expr |,^,&,! expr
 ///  expr ::= expr ==,!=,<>,<,<=,>,>= expr
 ///  expr ::= expr <<,>> expr
 ///  expr ::= expr +,- expr
 ///  expr ::= expr *,/,% expr               -> highest.
if (IsDarwin && !NParameters) {
             // The prefix '%' evaluates the expression 'expr'
             // and uses the result as a string (e.g. replace %(1+2) with the string "3").
             // Here, we identify the integer token which is the result of the
             // absolute expression evaluation and replace it with its string representation.
             if ((Lexer.IsaAltMacroMode()) &&
                  (*(Token.getString().begin()) == '%') && Token.is(AsmToken::Integer))
               // Emit an integer value to the buffer.
               OS << Token.getIntVal();
+            // Only Token that was validated as a string and begins with '<'
+            // is considered altMacroString!!!
+            else if ((Lexer.IsaAltMacroMode()) &&
+                     (*(Token.getString().begin()) == '<') &&
+                     Token.is(AsmToken::String)) {
+              std::string Res;
+              altMacroString(Token.getStringContents(), Res);
+              OS << Res;
+            }
             // We expect no quotes around the string's contents when
             // parsing for varargs.
             else if (Token.isNot(AsmToken::String) || VarargParameter)
               OS << Token.getString();
             else
               OS << Token.getStringContents();
 
           Pos += 1 + Argument.size();

test/MC/AsmParser/altmacro_string_escape.s

+# RUN: llvm-mc %s| FileCheck %s
+
+.altmacro
+# single-character string escape
+# To include any single character literally in a string
+# (even if the character would otherwise have some special meaning),
+# you can prefix the character with `!'.
+# For example, you can write `<4.3 !> 5.4!!>' to get the literal text `4.3 > 5.4!'.
+
+# CHECK: workForFun:
+.macro fun1 number
+  .if \number=5
+    lableNotWork:
+  .else
+    workForFun:
+  .endif
+.endm
+
+# CHECK: workForFun2:
+.macro fun2 string
+  .if \string
+    workForFun2:
+  .else
+    notworkForFun2:
+  .endif
+.endm
+
+fun1 <5!!>
+fun2 <5!>4>