[LLVM][inline-asm][Altmacor] Altmacro string delimiter '<..>'

[m_zuckerman]

Summary

In this patch, I introduce a new altmacro string delimiter.
This review is the second review in a series of four reviews.
(one for each altmacro feature: LOCAL, string delimiter, string '!' escape sign and absolute expression as a string '%' ).

In the alternate macro mode, you can delimit strings with matching angle brackets <..>
when using it as a part of calling macro arguments.

As described in the https://sourceware.org/binutils/docs-2.27/as/Altmacro.html
"<string>
You can delimit strings with matching angle brackets."

assumptions:

1. If an argument begins with '<' and ends with '>'. The argument is considered as a string.
2. Except adding new string mark '<..>', a regular macro behavior is expected.
3. The altmacro cannot affect the regular less/greater behavior.
4. If a comma is present inside an angle brackets it considered as a character and not as a separator.

[rengolin]

lib/MC/MCParser/AsmParser.cpp

1201

I'd add single quotes at the same time.

This seems like a simple addition, as you can pass the expected "ending char" as an argument, in addition to \r\n\0.

2500

Format else in the same line, like } else {

[rengolin]

lib/MC/MCParser/AsmParser.cpp

1201

The problem here, IIUC, is that you could start with '<' and end with single-quote (or vice-versa) and this code would accept. Also, if you start with '<', single-quote isn't actually a terminator.

To make sure this works, you have to test four overall patterns:

• <foo,bar>
• <foo'bar>
• 'foo,bar'
• 'foo>bar'

They all have to produce a single string "foo?bar".

What I meant was something like:

bool AsmParser::isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc, const char Term) {
  ...
  while ((*CharPtr != Term) && (*CharPtr != '\n') && (*CharPtr != '\r') && (*CharPtr != '\0')) {
    CharPtr++;
}

And then down there, something like:

} else if (Lexer.IsaAltMacroMode() && Lexer.is(AsmToken::Less) && Lexer.is(AsmToken::SingleQuote) &&
           isAltmacroString(StrLoc, EndLoc, Lex()) {

or something.

[m_zuckerman]

lib/MC/MCParser/AsmParser.cpp

1201

1. The code will not accept it because the last character that I check is '>'. So if the code ends with "\ '". The function returns false since it does not equal to '>' as required by the second if.

2. regard the <foo'bar>: I don't really sure what is the usage of it.

GAS doesn't really support the "\'" delimiter and the only full support that I found using https://godbolt.org/ was for the "<...>".

3. I prefer only to support '<..>' as in GCC. And I don't mind to define single quote as a string in altmacro, but it must end with a single quote.

[rengolin]

With that in mind, I think you should then go back to your original implementation (ignore quotes) and let the expression evaluation crash if there's any single quote in between (or whatever is the expected behaviour).

Maybe we should, then, add a comment on that function, saying the docs mention single-quotes but GCC doesn't support, so we won't either.

Sorry for the confusion.

cheers,
--renato

lib/MC/MCParser/AsmParser.cpp

1201

Oh, I was not aware the single quotes were unsupported in GCC. That's what I get for trusting their docs... :)

[m_zuckerman]

The behaviors are very strange when working with single quotes, so I prefer only to do partial support (strings) or not at all.

[m_zuckerman]

No worry :) we love to play with the code

[rengolin]

You seem to have lost the negative test.

lib/MC/MCParser/AsmLexer.cpp

464

Delimiter

test/MC/AsmParser/altmacro_string.s

28

Shouldn't this be $1?

[m_zuckerman]

As discussed, I have returned to the <...> implementation without the single quote and I added a negative test.

[rengolin]

LGTM. Thanks!

include/llvm/MC/MCParser/AsmLexer.h

private:
   int getNextChar();
   AsmToken ReturnError(const char *Loc, const std::string &Msg);
 
   AsmToken LexIdentifier();
   AsmToken LexSlash();
   AsmToken LexLineComment();
   AsmToken LexDigit();
   AsmToken LexSingleQuote();
-  AsmToken LexQuote();
+  AsmToken LexQuote(char Dilimiter = '"');
   AsmToken LexFloatLiteral();
   AsmToken LexHexFloatLiteral(bool NoIntDigits);
 
   StringRef LexUntilEndOfLine();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCPARSER_ASMLEXER_H

lib/MC/MCParser/AsmLexer.cpp

 
 /// LexSingleQuote: Integer: 'b'
 AsmToken AsmLexer::LexSingleQuote() {
   int CurChar = getNextChar();
 
   if (CurChar == '\\')
     CurChar = getNextChar();
 
+  if (IsaAltMacroMode())
+    return LexQuote('\'');
+
   if (CurChar == EOF)
     return ReturnError(TokStart, "unterminated single quote");
 
   CurChar = getNextChar();
 
   if (CurChar != '\'')
     return ReturnError(TokStart, "single quote way too long");
 
if (Res.startswith("\'\\")) {
     }
   } else
     Value = TokStart[1];
 
   return AsmToken(AsmToken::Integer, Res, Value);
 }
 
 /// LexQuote: String: "..."
-AsmToken AsmLexer::LexQuote() {
+AsmToken AsmLexer::LexQuote(char Dilimiter) {
   int CurChar = getNextChar();
   // TODO: does gas allow multiline string constants?
-  while (CurChar != '"') {
+  while (CurChar != Dilimiter) {
     if (CurChar == '\\') {
       // Allow \", etc.
       CurChar = getNextChar();
     }
 
     if (CurChar == EOF)
       return ReturnError(TokStart, "unterminated string constant");
 

lib/MC/MCParser/AsmParser.cpp

public:
   bool parseIdentifier(StringRef &Res) override;
   void eatToEndOfStatement() override;
 
   bool checkForValidSection() override;
 
   /// }
 
 private:
+  bool isAltmacroString(SMLoc &StrLoc, SMLoc &EndLoc);
   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,
case MCExpr::Binary: {
 
     return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, getContext());
   }
   }
 
   llvm_unreachable("Invalid expression kind!");
 }
 
+/// This function checks if the next token is <string> type or arithmetic.
+/// string that begin with character '<' must end with character '>'.
+/// otherwise it is arithmetics.
+/// If the function returns a 'true' value,
+/// the End argument will be filled with the last location pointed to the '>'
+/// character.
+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')){
+    CharPtr++;
+  }
+  if (*CharPtr == '>') {
+    EndLoc = StrLoc.getFromPointer(CharPtr + 1);
+    return true;
+  }
+  return false;
+}
+
 /// \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 (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) {
 
       NamedParametersFound = true;
     }
     bool Vararg = HasVararg && Parameter == (NParameters - 1);
 
     if (NamedParametersFound && FA.Name.empty())
       return Error(IDLoc, "cannot mix positional and keyword arguments");
 
-    if (Lexer.IsaAltMacroMode() && Lexer.is(AsmToken::Percent)) {
-        SMLoc StrLoc = Lexer.getLoc();
-        SMLoc EndLoc;
+    if (Lexer.IsaAltMacroMode() && Lexer.is(AsmToken::Percent)) {
         const MCExpr *AbsoluteExp;
         int64_t Value;
         /// Eat '%'
         Lex();
         if (parseExpression(AbsoluteExp, EndLoc))
           return false;
         if (!AbsoluteExp->evaluateAsAbsolute(Value))
           return Error(StrLoc, "expected absolute expression");
         const char *StrChar = StrLoc.getPointer();
         const char *EndChar = EndLoc.getPointer();
         AsmToken newToken(AsmToken::Integer, StringRef(StrChar , EndChar - StrChar), Value);
         FA.Value.push_back(newToken);
-    }
-    else if(parseMacroArgument(FA.Value, Vararg))
+    } else if (Lexer.IsaAltMacroMode() && Lexer.is(AsmToken::Less) &&
+             isAltmacroString(StrLoc, EndLoc)) {
+        const char *StrChar = StrLoc.getPointer();
+        const char *EndChar = EndLoc.getPointer();
+        jumpToLoc(EndLoc, CurBuffer);
+        /// Eat from '<' to '>'
+        Lex();
+        AsmToken newToken(AsmToken::String, StringRef(StrChar, EndChar - StrChar));
+        FA.Value.push_back(newToken);
+    } else if(parseMacroArgument(FA.Value, Vararg))
         return true;
 
     unsigned PI = Parameter;
     if (!FA.Name.empty()) {
       unsigned FAI = 0;
       for (FAI = 0; FAI < NParameters; ++FAI)
         if (M->Parameters[FAI].Name == FA.Name)
           break;

test/MC/AsmParser/altmacro_string.s

+# RUN: llvm-mc %s| FileCheck %s
+
+# This test checks the altmacro string delimiter '<' and '>'.
+
+.altmacro
+
+# Test #1:
+# You can delimit strings with matching angle brackets '<' '>'
+# or with matching '\''.
+# If an argument begins with '<' and ends with '>'.
+# Or an argument begins with '\'' and ends with '\''.
+# The argument is considered as a string.
+
+# CHECK: simpleCheck:
+# CHECK: simpleCheck0:
+.macro simple_check_0 name
+    \name:
+  addl $5,%eax
+.endm
+
+simple_check_0 <simpleCheck>
+simple_check_0 'simpleCheck0'
+
+# Test #2:
+# Except adding new string marks '<..>', a regular macro behavior is expected.
+
+# CHECK:  simpleCheck1:
+# CHECK: addl    $0, %eax
+.macro concat string1 string2 string3
+  \string1\string2\string3:
+        addl $\string3, %eax
+.endm
+
+concat <simple>,<Check>,<1>
+
+# Test #3:
+# The altmacro cannot affect the regular less/greater behavior.
+
+# CHECK: addl $1, %eax
+# CHECK: addl $0, %eax
+
+.macro fun3 arg1 arg2
+  addl $\arg1,%eax
+  addl $\arg2,%eax
+.endm
+
+fun3 5<6 , 5>8
+
+# Test #4:
+# If a comma is present inside an angle brackets,
+# the comma considered as a character and not as a separator.
+# This check checks the ability to split the string to different
+# arguments according to the use of the comma.
+# Fun2 sees the comma as a character.
+# Fun3 sees the comma as a separator.
+
+# CHECK: addl $5, %eax
+# CHECK: addl $6, %eax
+# CHECK: addl $6, %eax
+# CHECK: addl $7, %eax
+.macro fun2 arg
+  fun3 \arg
+.endm
+
+fun2 <5,6>
+fun2 '6,7'
+
+# Test #5:
+# If argument begin with '<' and there is no '>' to close it.
+# A regular macro behavior is expected.
+
+# CHECK: addl $4, %eax
+# CHECK: addl $3, %eax
+.macro fun4 arg1 arg2
+  .if \arg2\arg1
+  addl $\arg2,%eax
+  .endif
+.endm
+
+fun4 <5,4
+fun4 '<5',3
+
+.noaltmacro
 No newline at end of file