Adding altmacro support in integrated assembler. continue of D10591

[m_zuckerman]

Summary

There was a problem with compere to base I did rebase.
you can find more comments in link [[ URL | http://reviews.llvm.org/D10591 ]]
D10591
The asm parser now support the altmacro and noaltmacro directives.
This is flow the bug in link: https://llvm.org/bugs/show_bug.cgi?id=18918
You can find information about altmacro in this link :https://sourceware.org/binutils/docs/as/Altmacro.html.
In this part of the work we support the three type of string "..." , '...' ,<...>.
You can now use '%' char to write `%expr’ to evaluate the expression expr and use the result as a string.
In the future we will add the local directive and additional string support.

[m_zuckerman]

I create a new diff without any extra reindents part.

[• rafael]

Please git-clang-format. The patch has trailing spaces

Don't repeat names in comments.

include/llvm/MC/MCParser/AsmLexer.h

59

spelling/grammar issues:
"must to end"
"no a string"

lib/MC/MCParser/AsmLexer.cpp

499

EOF is not a character.

What exactly is this function doing?

[m_zuckerman]

Hi all I want to continue with this review. can you please continue the review.

lib/MC/MCParser/AsmLexer.cpp

499

When there '<' in the start of a token. You don't know if the token is a string or an arithmetic OP.
The function is looking for the char '>'.
If in the end of the statement there is a '>' char.
The function returns string else return not a string

[jannau]

gnu as seems to evaluate '%' expressions in macro parameters before it instantiate the macro. small example which doesn't work (even segfaults with diff 30357 for me) currently below:

.macro do_test num
    .macro test_\num x
        .long (\num * \x)
    .endm
.endm

.altmacro
        do_test %(10 + 7)
.noaltmacro

        test_17 3

This is the minimizations of Libav's arm PIC in assembler support macros.

[compnerd]

IIRC, there were some interesting cases that would require pulling the expression parser out of the environment, but I may have incorrectly analyzed what was needed to make all the cases to work.

include/llvm/MC/MCParser/AsmLexer.h

9–1

Please don't do this AltMacroMode parameter. Switch the entire state of the Lexer. Introduce a Mode enumeration, as there are at least three different modes (normal, which we currently support, Alternate, which we do not, and MRI, which I currently think that we are unlikely to support).

[m_zuckerman]

In D11215#218879, @jannau wrote:

gnu as seems to evaluate '%' expressions in macro parameters before it instantiate the macro. small example which doesn't work (even segfaults with diff 30357 for me) currently below:

.macro do_test num
    .macro test_\num x
        .long (\num * \x)
    .endm
.endm

.altmacro
        do_test %(10 + 7)
.noaltmacro

        test_17 3

This is the minimizations of Libav's arm PIC in assembler support macros.

As I said in the preview .
"This part of the work we support the three type of string "..." , '...' ,<...>. You can now use '%' char to write `%expr’ to evaluate the expression expr and use the result as a string."

In this part of work we support the specific bug: https://llvm.org/bugs/show_bug.cgi?id=18918 . We support directory "altmacro" and the basic feature of the directory.

In the future we will add additional string support.

[m_zuckerman]

Hi all I want to continue with this review. can you please continue the review.

[grosbach]

The linked documentation is very vague. There needs to be a lot more clarity on the design before this goes in. For example, what expressions are legal for %expr? It can't be anything, as an expression which requires a relocation would obviously not be reasonable. So what are the constraints? This introduces really nasty layering issues between the parser, lexer, and layout engines, to put it mildly. Before we can realistically talk about the code itself, those design issues need sorted out.

Please start a thread on llvmdev to discuss this.

include/llvm/MC/MCParser/AsmLexer.h

 //===- AsmLexer.h - Lexer for Assembly Files --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
class AsmLexer : public MCAsmLexer {
   StringRef CurBuf;
   bool isAtStartOfLine;
 
   void operator=(const AsmLexer&) = delete;
   AsmLexer(const AsmLexer&) = delete;
 
 protected:
   /// LexToken - Read the next token and return its code.
-  AsmToken LexToken() override;
+  AsmToken LexToken(bool AltMacroMode = false) override;
 
 public:
   AsmLexer(const MCAsmInfo &MAI);
   ~AsmLexer() override;
 
   void setBuffer(StringRef Buf, const char *ptr = nullptr);
 
   StringRef LexUntilEndOfStatement() override;
   StringRef LexUntilEndOfLine();
 
   const AsmToken peekTok(bool ShouldSkipSpace = true) override;
 
   bool isAtStartOfComment(const char *Ptr);
   bool isAtStatementSeparator(const char *Ptr);
 
   const MCAsmInfo &getMAI() const { return MAI; }
 
 private:
+  /// This function check if the next token is <string> type or arithmetic.
+  /// string that begin with char '<' must to end with char '>' otherwise it is no a string. 
+  /// True - <string>
+  /// false- a<b 
+  bool isAtString(const char* StringLine);
   int getNextChar();
   AsmToken ReturnError(const char *Loc, const std::string &Msg);
 
   AsmToken LexIdentifier();
   AsmToken LexSlash();
   AsmToken LexLineComment();
   AsmToken LexDigit();
+  /// lexStringHandle: String: "..."  in altmacro also <...> and '...' string. 
+  AsmToken LexSingleQuote(bool AltMacroMode = false);
+  AsmToken LexQuote(char FirstChar = '"');
+  AsmToken lexStringHandle(char FirstChar = '"');
   AsmToken LexSingleQuote();
   AsmToken LexQuote();
   AsmToken LexFloatLiteral();
   AsmToken LexHexFloatLiteral(bool NoIntDigits);
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/MC/MCParser/MCAsmLexer.h

class MCAsmLexer {
   void operator=(const MCAsmLexer &) = delete;
 protected: // Can only create subclasses.
   const char *TokStart;
   bool SkipSpace;
   bool AllowAtInIdentifier;
 
   MCAsmLexer();
 
-  virtual AsmToken LexToken() = 0;
+  virtual AsmToken LexToken(bool AltMacroMode = false) = 0;
 
   void SetError(const SMLoc &errLoc, const std::string &err) {
     ErrLoc = errLoc;
     Err = err;
   }
 
 public:
   virtual ~MCAsmLexer();
 
   /// Consume the next token from the input stream and return it.
   ///
   /// The lexer will continuosly return the end-of-file token once the end of
   /// the main input file has been reached.
-  const AsmToken &Lex() {
-    return CurTok = LexToken();
+  const AsmToken &Lex(bool AltMacroMode = false) {
+    return CurTok = LexToken(AltMacroMode);
   }
 
   virtual StringRef LexUntilEndOfStatement() = 0;
 
   /// Get the current source location.
   SMLoc getLoc() const;
 
   /// Get the current (last) lexed token.

lib/MC/MCParser/AsmLexer.cpp

AsmToken AsmLexer::LexDigit() {
 
   // The darwin/x86 (and x86-64) assembler accepts and ignores ULL and LL
   // suffixes on integer literals.
   SkipIgnoredIntegerSuffix(CurPtr);
 
   return intToken(Result, Value);
 }
 
-/// LexSingleQuote: Integer: 'b'
-AsmToken AsmLexer::LexSingleQuote() {
+/// LexSingleQuote:
+/// If AltMacro = true 'string'
+/// Else only one character Integer: 'b'
+AsmToken AsmLexer::LexSingleQuote(bool AltMacroMode) {
+  if (AltMacroMode)
+    return lexStringHandle('\'');
   int CurChar = getNextChar();
 
   if (CurChar == '\\')
     CurChar = getNextChar();
 
   if (CurChar == EOF)
     return ReturnError(TokStart, "unterminated single quote");
 
if (Res.startswith("\'\\")) {
     }
   } else
     Value = TokStart[1];
 
   return AsmToken(AsmToken::Integer, Res, Value);
 }
 
 
-/// LexQuote: String: "..."
-AsmToken AsmLexer::LexQuote() {
+
+AsmToken AsmLexer::lexStringHandle(char FirstChar){
+  char lastChar;
+  if (FirstChar == '<')
+    lastChar = '>';
+  else
+    lastChar = FirstChar;
   int CurChar = getNextChar();
   // TODO: does gas allow multiline string constants?
-  while (CurChar != '"') {
+  while (CurChar != lastChar) {
     if (CurChar == '\\') {
       // Allow \", etc.
       CurChar = getNextChar();
     }
-
-    if (CurChar == EOF)
-      return ReturnError(TokStart, "unterminated string constant");
-
+    if (CurChar == EOF){
+      std::string StrError = "unterminated string constant - missing" + lastChar;
+      StrError += " at the end";
+      return ReturnError(TokStart, StrError);
+    }
+    CurChar = getNextChar();
+    if ((CurChar == '>') && (lastChar == '>')){
       CurChar = getNextChar();
+    if (CurChar == EOF)
+        break;
+      if ((CurChar == ',') || (CurChar == '\n')){
+        CurPtr--;
+        break;
+      }
+    }
   }
 
   return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart));
 }
 
 StringRef AsmLexer::LexUntilEndOfStatement() {
   TokStart = CurPtr;
 
bool AsmLexer::isAtStartOfComment(const char *Ptr) {
   return strncmp(Ptr, CommentString, strlen(CommentString)) == 0;
 }
 
 bool AsmLexer::isAtStatementSeparator(const char *Ptr) {
   return strncmp(Ptr, MAI.getSeparatorString(),
                  strlen(MAI.getSeparatorString())) == 0;
 }
 
-AsmToken AsmLexer::LexToken() {
+bool AsmLexer::isAtString(const char* currentPtr){
+  while ((*currentPtr != ',') && (*currentPtr != '\n') && (*currentPtr != EOF) && (*currentPtr != '\0'))
+    currentPtr++;
+  while (*(currentPtr - 1) == ' ')
+    currentPtr--;
+  if (*(currentPtr - 1) == '>')
+    return true;
+  else
+    return false;
+}
+
+AsmToken AsmLexer::LexToken(bool AltMacro){
   TokStart = CurPtr;
   // This always consumes at least one character.
   int CurChar = getNextChar();
 
   if (isAtStartOfComment(TokStart)) {
     // If this comment starts with a '#', then return the Hash token and let
     // the assembler parser see if it can be parsed as a cpp line filename
     // comment. We do this only if we are at the start of a line.
default:
     // Unknown character, emit an error.
     return ReturnError(TokStart, "invalid character in input");
   case EOF: return AsmToken(AsmToken::Eof, StringRef(TokStart, 0));
   case 0:
   case ' ':
   case '\t':
     if (SkipSpace) {
       // Ignore whitespace.
-      return LexToken();
+      return LexToken(AltMacro);
     } else {
       int len = 1;
       while (*CurPtr==' ' || *CurPtr=='\t') {
         CurPtr++;
         len++;
       }
       return AsmToken(AsmToken::Space, StringRef(TokStart, len));
     }
case '&':
     return AsmToken(AsmToken::Amp, StringRef(TokStart, 1));
   case '!':
     if (*CurPtr == '=')
       return ++CurPtr, AsmToken(AsmToken::ExclaimEqual, StringRef(TokStart, 2));
     return AsmToken(AsmToken::Exclaim, StringRef(TokStart, 1));
   case '%': return AsmToken(AsmToken::Percent, StringRef(TokStart, 1));
   case '/': return LexSlash();
   case '#': return AsmToken(AsmToken::Hash, StringRef(TokStart, 1));
-  case '\'': return LexSingleQuote();
-  case '"': return LexQuote();
+  case '\'': return LexSingleQuote(AltMacro);
+  case '"': return  lexStringHandle();//LexQuote();
   case '0': case '1': case '2': case '3': case '4':
   case '5': case '6': case '7': case '8': case '9':
     return LexDigit();
-  case '<':
+  case '<':{
+    if (isAtString(CurPtr) && AltMacro)
+      return lexStringHandle('<');
     switch (*CurPtr) {
     case '<': return ++CurPtr, AsmToken(AsmToken::LessLess,
-                                        StringRef(TokStart, 2));
     case '=': return ++CurPtr, AsmToken(AsmToken::LessEqual,
-                                        StringRef(TokStart, 2));
     case '>': return ++CurPtr, AsmToken(AsmToken::LessGreater,
-                                        StringRef(TokStart, 2));
     default: return AsmToken(AsmToken::Less, StringRef(TokStart, 1));
     }
+  }
   case '>':
     switch (*CurPtr) {
     case '>': return ++CurPtr, AsmToken(AsmToken::GreaterGreater,
                                         StringRef(TokStart, 2));
     case '=': return ++CurPtr, AsmToken(AsmToken::GreaterEqual,
                                         StringRef(TokStart, 2));
     default: return AsmToken(AsmToken::Greater, StringRef(TokStart, 1));
     }
 
   // TODO: Quoted identifiers (objc methods etc)
   // local labels: [0-9][:]
   // Forward/backward labels: [0-9][fb]
   // Integers, fp constants, character constants.
   }
 }

lib/MC/MCParser/AsmParser.cpp

private:
   /// AssemblerDialect. ~OU means unset value and use value provided by MAI.
   unsigned AssemblerDialect;
 
   /// \brief is Darwin compatibility enabled?
   bool IsDarwin;
 
   /// \brief Are we parsing ms-style inline assembly?
   bool ParsingInlineAsm;
-
+  /// \ this is for the .altmode use.
+  bool AltMacroMode = false;
+  bool AltMacroPresent = false;
+  int64_t valueForTheAltMacro;
 public:
   AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
             const MCAsmInfo &MAI);
   ~AsmParser() override;
 
   bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
 
   void addDirectiveHandler(StringRef Directive,
enum DirectiveKind {
     DK_IFNOTDEF, DK_ELSEIF, DK_ELSE, DK_ENDIF,
     DK_SPACE, DK_SKIP, DK_FILE, DK_LINE, DK_LOC, DK_STABS,
     DK_CFI_SECTIONS, DK_CFI_STARTPROC, DK_CFI_ENDPROC, DK_CFI_DEF_CFA,
     DK_CFI_DEF_CFA_OFFSET, DK_CFI_ADJUST_CFA_OFFSET, DK_CFI_DEF_CFA_REGISTER,
     DK_CFI_OFFSET, DK_CFI_REL_OFFSET, DK_CFI_PERSONALITY, DK_CFI_LSDA,
     DK_CFI_REMEMBER_STATE, DK_CFI_RESTORE_STATE, DK_CFI_SAME_VALUE,
     DK_CFI_RESTORE, DK_CFI_ESCAPE, DK_CFI_SIGNAL_FRAME, DK_CFI_UNDEFINED,
     DK_CFI_REGISTER, DK_CFI_WINDOW_SAVE,
-    DK_MACROS_ON, DK_MACROS_OFF,
+    DK_MACROS_ON, DK_MACROS_OFF, DK_ALTMACRO_ON, DK_NOALTMACRO,
     DK_MACRO, DK_EXITM, DK_ENDM, DK_ENDMACRO, DK_PURGEM,
     DK_SLEB128, DK_ULEB128,
     DK_ERR, DK_ERROR, DK_WARNING,
     DK_END
   };
 
   /// \brief Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
private:
   bool parseDirectiveCFIUndefined(SMLoc DirectiveLoc);
 
   // macro directives
   bool parseDirectivePurgeMacro(SMLoc DirectiveLoc);
   bool parseDirectiveExitMacro(StringRef Directive);
   bool parseDirectiveEndMacro(StringRef Directive);
   bool parseDirectiveMacro(SMLoc DirectiveLoc);
   bool parseDirectiveMacrosOnOff(StringRef Directive);
-
+  // AltMacros
+  bool parseDirectiveAltMacrosOnOff(StringRef Directive);
   // ".bundle_align_mode"
   bool parseDirectiveBundleAlignMode();
   // ".bundle_lock"
   bool parseDirectiveBundleLock();
   // ".bundle_unlock"
   bool parseDirectiveBundleUnlock();
 
   // ".space", ".skip"

 
 void AsmParser::jumpToLoc(SMLoc Loc, unsigned InBuffer) {
   CurBuffer = InBuffer ? InBuffer : SrcMgr.FindBufferContainingLoc(Loc);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer(),
                   Loc.getPointer());
 }
 
 const AsmToken &AsmParser::Lex() {
-  const AsmToken *tok = &Lexer.Lex();
+  const AsmToken *tok = &Lexer.Lex(AltMacroMode);
 
   if (tok->is(AsmToken::Eof)) {
     // If this is the end of an included file, pop the parent file off the
     // include stack.
     SMLoc ParentIncludeLoc = SrcMgr.getParentIncludeLoc(CurBuffer);
     if (ParentIncludeLoc != SMLoc()) {
       jumpToLoc(ParentIncludeLoc);
-      tok = &Lexer.Lex();
+      tok = &Lexer.Lex(AltMacroMode);
     }
   }
 
   if (tok->is(AsmToken::Error))
     Error(Lexer.getErrLoc(), Lexer.getErr());
 
   return *tok;
 }

 }
 
 /// \brief Parse a primary expression and return it.
 ///  primaryexpr ::= (parenexpr
 ///  primaryexpr ::= symbol
 ///  primaryexpr ::= number
 ///  primaryexpr ::= '.'
 ///  primaryexpr ::= ~,+,- primaryexpr
+///  primaryezpr ::= '%'
 bool AsmParser::parsePrimaryExpr(const MCExpr *&Res, SMLoc &EndLoc) {
   SMLoc FirstTokenLoc = getLexer().getLoc();
   AsmToken::TokenKind FirstTokenKind = Lexer.getKind();
   switch (FirstTokenKind) {
   default:
     return TokError("unknown token in expression");
   // If we have an error assume that we've already handled it.
   case AsmToken::Error:
     return true;
   case AsmToken::Exclaim:
     Lex(); // Eat the operator.
     if (parsePrimaryExpr(Res, EndLoc))
       return true;
     Res = MCUnaryExpr::createLNot(Res, getContext());
     return false;
+  case AsmToken::Percent:{
+    if (AltMacroMode)
+      return false;
+    else
+      return true;
+  }
   case AsmToken::Dollar:
   case AsmToken::At:
   case AsmToken::String:
   case AsmToken::Identifier: {
     StringRef Identifier;
     if (parseIdentifier(Identifier)) {
       if (FirstTokenKind == AsmToken::Dollar) {
         if (Lexer.getMAI().getDollarIsPC()) {
case DK_CFI_REGISTER:
       return parseDirectiveCFIRegister(IDLoc);
     case DK_CFI_WINDOW_SAVE:
       return parseDirectiveCFIWindowSave();
     case DK_MACROS_ON:
     case DK_MACROS_OFF:
       return parseDirectiveMacrosOnOff(IDVal);
     case DK_MACRO:
       return parseDirectiveMacro(IDLoc);
+    case DK_ALTMACRO_ON:
+      return parseDirectiveAltMacrosOnOff(IDVal);
+    case DK_NOALTMACRO:
+      return parseDirectiveAltMacrosOnOff(IDVal);
     case DK_EXITM:
       return parseDirectiveExitMacro(IDVal);
     case DK_ENDM:
     case DK_ENDMACRO:
       return parseDirectiveEndMacro(IDVal);
     case DK_PURGEM:
       return parseDirectivePurgeMacro(IDLoc);
     case DK_END:
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,
                             bool EnableAtPseudoVariable, const SMLoc &L) {
   unsigned NParameters = Parameters.size();
+  bool Percent = false;
   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()) {
     // Scan for the next substitution.
     std::size_t End = Body.size(), Pos = 0;
     for (; Pos != End; ++Pos) {
       // Check for a substitution or escape.
       if (IsDarwin && !NParameters) {
         // This macro has no parameters, look for $0, $1, etc.
         if (Body[Pos] != '$' || Pos + 1 == End)
           continue;
 
         char Next = Body[Pos + 1];
         if (Next == '$' || Next == 'n' ||
             isdigit(static_cast<unsigned char>(Next)))
           break;
       } else {
         // This macro has parameters, look for \foo, \bar, etc.
         if (Body[Pos] == '\\' && Pos + 1 != End)
           break;
+        if (Body[Pos] == '%' && Pos + 1 != End && AltMacroMode){
+          Percent = true;
+          break;
+        }
       }
     }
 
     // Add the prefix.
     OS << Body.slice(0, Pos);
 
     // Check if we reached the end.
     if (Pos == End)
if (IsDarwin && !NParameters) {
           if (Body[Pos + 1] == '(' && Body[Pos + 2] == ')')
             Pos += 3;
           else {
             OS << '\\' << Argument;
             Pos = I;
           }
         } else {
           bool VarargParameter = HasVararg && Index == (NParameters - 1);
+          if (Percent&&AltMacroPresent){
+            AltMacroPresent = false;
+            OS << valueForTheAltMacro;
+          }
+          else {
           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);
   }
 
if (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) {
         TokError("expected '=' after formal parameter identifier");
         eatToEndOfStatement();
         return true;
       }
       Lex();
 
       NamedParametersFound = true;
     }
-
+    if (Lexer.is(AsmToken::LParen) && AltMacroMode){
+      AltMacroPresent = true;
+      parseAbsoluteExpression(valueForTheAltMacro);
+    }
     if (NamedParametersFound && FA.Name.empty()) {
       Error(IDLoc, "cannot mix positional and keyword arguments");
       eatToEndOfStatement();
       return true;
     }
 
     bool Vararg = HasVararg && Parameter == (NParameters - 1);
     if (parseMacroArgument(FA.Value, Vararg))
bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
 
   if (parseRegisterOrRegisterNumber(Register, DirectiveLoc))
     return true;
 
   getStreamer().EmitCFIUndefined(Register);
   return false;
 }
 
+/// parseDirectiveAltMacrosOnOff
+/// ::= .altmacro_on
+/// ::= .altmacro_off
+bool AsmParser::parseDirectiveAltMacrosOnOff(StringRef Directive) {
+  if (getLexer().isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in '" + Directive + "' directive");
+  AltMacroMode = (Directive == ".altmacro");
+  return false;
+}
+
 /// parseDirectiveMacrosOnOff
 /// ::= .macros_on
 /// ::= .macros_off
 bool AsmParser::parseDirectiveMacrosOnOff(StringRef Directive) {
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return Error(getLexer().getLoc(),
                  "unexpected token in '" + Directive + "' directive");
 
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".macro"] = DK_MACRO;
   DirectiveKindMap[".exitm"] = DK_EXITM;
   DirectiveKindMap[".endm"] = DK_ENDM;
   DirectiveKindMap[".endmacro"] = DK_ENDMACRO;
   DirectiveKindMap[".purgem"] = DK_PURGEM;
   DirectiveKindMap[".err"] = DK_ERR;
   DirectiveKindMap[".error"] = DK_ERROR;
   DirectiveKindMap[".warning"] = DK_WARNING;
+  DirectiveKindMap[".altmacro"] = DK_ALTMACRO_ON;
+  DirectiveKindMap[".noaltmacro"] = DK_NOALTMACRO;
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   for (;;) {
     // Check whether we have reached the end of the file.

test/MC/AsmParser/altMacroTest.s

+# RUN: llvm-mc -triple i386-unknown-unknown %s | FileCheck %s
+
+.altmacro
+.macro test1 name num
+  \name\num\():
+    .long \name\num
+.endm
+test1 'b',1
+test1 'ab',1
+test1 "a",1
+test1 "ba",1
+test1 <bac>,1
+.noaltmacro
+# CHECK: b1
+# CHECK: .long b1
+# CHECK: ab1:
+# CHECK: .long ab1
+# CHECK: a1:
+# CHECK: .long a1
+# CHECK: ba1:
+# CHECK: .long ba1
+# CHECK: bac1:
+# CHECK: .long bac1 
+
+.altmacro
+.macro  test2 name, number
+__mksym \name, %number
+.endm
+ 
+.macro  __mksym, name, number
+\name\number\():
+    .long \number
+.endm
+
+.section    .rodata
+ 
+/* now define symbols by hand...  */
+test2   bar, 1
+test2   bar, (9/3 + (7-1))
+ 
+/* ...or use other pseudo ops to do it in a loop */
+.irp    i, 3, 2, 1
+test2   foobar, (\i * 2 + 1)
+.endr
+
+# CHECK: bar1:
+# CHECK: .long 1
+# CHECK: bar9:
+# CHECK: .long 9
+# CHECK: foobar7:
+# CHECK: .long 7
+# CHECK: foobar5:
+# CHECK: .long 5
+# CHECK: foobar3:
+# CHECK: .long 3
 No newline at end of file

test/MC/AsmParser/altMacroTestFail.s

+# RUN: not llvm-mc -triple i386 -o /dev/null %s 2>&1 | FileCheck %s
+
+.macro lableRun name num
+  \name\num\():
+    .long \name\num
+.endm
+.altmacro
+.noaltmacro
+lableRun 'bc',1
+# CHECK: error: single quote way too long
 No newline at end of file