Adding altmacro support in integrated assembler.

[m_zuckerman]

Summary

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.

[• rafael]

include/llvm/MC/MCParser/AsmLexer.h

58

Variable name starts with uppercase.

73

Function name starts with a lowercase. You can just update the existing ones in a cleanup patch first if you want.

lib/MC/MCParser/AsmLexer.cpp

367

Handel?

419

Using LastChar you can have a single ReturnError, no?

498–631

Don't repeat name in comment.

This description should probably be at the declaration.

582

Please commit the format only changes first and rebase.

lib/MC/MCParser/AsmParser.cpp

1242

The old formatting looks like the more common one.

[m_zuckerman]

include/llvm/MC/MCParser/AsmLexer.h

58

accept

73

accept

lib/MC/MCParser/AsmLexer.cpp

367

accept
was spelling mistake handel -> handle

419

accept

498–631

accept

582

accept

lib/MC/MCParser/AsmParser.cpp

1242

accept

[m_zuckerman]

this is the update file after first review

[m_zuckerman]

there is some not my changes from base.
use compere to see the new patch(diff2) with the diff1
and diff1 with base
thanks

[• rafael]

I tried applying the patch on current trunk but it fails. Please rebase.

include/llvm/MC/MCParser/AsmLexer.h

58

Don't repeat name in comment.

lib/MC/MCParser/AsmLexer.cpp

427

What is this for? Is <> delimited strings only valid if followed by , or newline?!

[m_zuckerman]

rebase in :
This is the new review: http://reviews.llvm.org/D10692

include/llvm/MC/MCParser/AsmLexer.h

58

accept

lib/MC/MCParser/AsmLexer.cpp

427

for the <>I use the same output as the "" of llvm use empty string
example:
run: llvm-mc filename.asm
.altmacro
.macro mksym, name, number

.long \name\number

.long \name
.endm
mksym "",1
mksym <>,2
output
.text

.long 1

.long 2

[compnerd]

This seems extremely under-tested. I remember looking into this, and holding off on the implementation, since it needed some reworking of the expression evaluation, since there are differences in the different modes.

lib/MC/MCParser/AsmLexer.cpp

502

Space before the '{'.

556

Space around the 'else'

604

Why leave LexQuote in a comment?

609

Space after the colon

619

Space after colon

lib/MC/MCParser/AsmParser.cpp

180

Variables start with a CapitalLetter.

250

Partial Redundancy Elimination?

421–423

The comment is unnecessary and misleading.

799

Isn't this equivalent to:

case AsmToken::Percent:
  return !AltMacroMode;

1241

unnecessary whitespace change

include/llvm/MC/MCParser/AsmLexer.h

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:
+  /// isAtString 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();
-  AsmToken LexSingleQuote();
-  AsmToken LexQuote();
+  AsmToken LexSingleQuote(bool AltMacroMode = false);
+  AsmToken LexQuote(char FirstChar = '"');
+  AsmToken lexStringHandle(char FirstChar = '"');
   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.
   const AsmToken &getTok() const {
     return CurTok;

lib/MC/MCParser/AsmLexer.cpp

 /// location.  This is defined to always return AsmToken::Error.
 AsmToken AsmLexer::ReturnError(const char *Loc, const std::string &Msg) {
   SetError(SMLoc::getFromPointer(Loc), Msg);
 
   return AsmToken(AsmToken::Error, StringRef(Loc, 0));
 }
 
 int AsmLexer::getNextChar() {
-  char CurChar = *CurPtr++;
   switch (CurChar) {
   default:
     return (unsigned char)CurChar;
   case 0:
     // A nul character in the stream is either the end of the current buffer or
     // a random nul in the file.  Disambiguate that here.
     if (CurPtr - 1 != CurBuf.end())
       return 0;  // Just whitespace.
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() {
-  int CurChar = getNextChar();
-  // TODO: does gas allow multiline string constants?
-  while (CurChar != '"') {
-    if (CurChar == '\\') {
-      // Allow \", etc.
-      CurChar = getNextChar();
-    }
-
-    if (CurChar == EOF)
-      return ReturnError(TokStart, "unterminated string constant");
-
-    CurChar = getNextChar();
-  }
-
-  return AsmToken(AsmToken::String, StringRef(TokStart, CurPtr - TokStart));
+/// lexStringHandle: String: "..."  in altmacro also <...> and '...' string. 
+
+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 != lastChar) {
+    if (CurChar == '\\') {
+      // Allow \", etc.
+      CurChar = getNextChar();
+    }
+    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;
 
   while (!isAtStartOfComment(CurPtr) &&     // Start of line comment.
          !isAtStatementSeparator(CurPtr) && // End of statement marker.
          *CurPtr != '\n' && *CurPtr != '\r' &&
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() {
-  TokStart = CurPtr;
-  // This always consumes at least one character.
-  int CurChar = getNextChar();
+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.
-    if (CurChar == '#' && isAtStartOfLine)
-      return AsmToken(AsmToken::Hash, StringRef(TokStart, 1));
-    isAtStartOfLine = true;
-    return LexLineComment();
-  }
-  if (isAtStatementSeparator(TokStart)) {
-    CurPtr += strlen(MAI.getSeparatorString()) - 1;
-    return AsmToken(AsmToken::EndOfStatement,
-                    StringRef(TokStart, strlen(MAI.getSeparatorString())));
-  }
+  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.
+    if (CurChar == '#' && isAtStartOfLine)
+      return AsmToken(AsmToken::Hash, StringRef(TokStart, 1));
+    isAtStartOfLine = true;
+    return LexLineComment();
+  }
+  if (isAtStatementSeparator(TokStart)) {
+    CurPtr += strlen(MAI.getSeparatorString()) - 1;
+    return AsmToken(AsmToken::EndOfStatement,
+      StringRef(TokStart, strlen(MAI.getSeparatorString())));
+  }
 
-  // If we're missing a newline at EOF, make sure we still get an
-  // EndOfStatement token before the Eof token.
-  if (CurChar == EOF && !isAtStartOfLine) {
-    isAtStartOfLine = true;
-    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 1));
-  }
+  // If we're missing a newline at EOF, make sure we still get an
+  // EndOfStatement token before the Eof token.
+  if (CurChar == EOF && !isAtStartOfLine) {
+    isAtStartOfLine = true;
+    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 1));
+  }
 
-  isAtStartOfLine = false;
-  switch (CurChar) {
-  default:
-    // Handle identifier: [a-zA-Z_.][a-zA-Z0-9_$.@]*
-    if (isalpha(CurChar) || CurChar == '_' || CurChar == '.')
-      return LexIdentifier();
+  isAtStartOfLine = false;
+  switch (CurChar) {
+  default:
+    // Handle identifier: [a-zA-Z_.][a-zA-Z0-9_$.@]*
+    if (isalpha(CurChar) || CurChar == '_' || CurChar == '.')
+      return LexIdentifier();
 
-    // 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();
-    } else {
-      int len = 1;
-      while (*CurPtr==' ' || *CurPtr=='\t') {
-        CurPtr++;
-        len++;
-      }
-      return AsmToken(AsmToken::Space, StringRef(TokStart, len));
-    }
-  case '\n': // FALL THROUGH.
-  case '\r':
-    isAtStartOfLine = true;
-    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 1));
-  case ':': return AsmToken(AsmToken::Colon, StringRef(TokStart, 1));
-  case '+': return AsmToken(AsmToken::Plus, StringRef(TokStart, 1));
-  case '-': return AsmToken(AsmToken::Minus, StringRef(TokStart, 1));
-  case '~': return AsmToken(AsmToken::Tilde, StringRef(TokStart, 1));
-  case '(': return AsmToken(AsmToken::LParen, StringRef(TokStart, 1));
-  case ')': return AsmToken(AsmToken::RParen, StringRef(TokStart, 1));
-  case '[': return AsmToken(AsmToken::LBrac, StringRef(TokStart, 1));
-  case ']': return AsmToken(AsmToken::RBrac, StringRef(TokStart, 1));
-  case '{': return AsmToken(AsmToken::LCurly, StringRef(TokStart, 1));
-  case '}': return AsmToken(AsmToken::RCurly, StringRef(TokStart, 1));
-  case '*': return AsmToken(AsmToken::Star, StringRef(TokStart, 1));
-  case ',': return AsmToken(AsmToken::Comma, StringRef(TokStart, 1));
-  case '$': return AsmToken(AsmToken::Dollar, StringRef(TokStart, 1));
-  case '@': return AsmToken(AsmToken::At, StringRef(TokStart, 1));
-  case '\\': return AsmToken(AsmToken::BackSlash, StringRef(TokStart, 1));
-  case '=':
-    if (*CurPtr == '=')
-      return ++CurPtr, AsmToken(AsmToken::EqualEqual, StringRef(TokStart, 2));
-    return AsmToken(AsmToken::Equal, StringRef(TokStart, 1));
-  case '|':
-    if (*CurPtr == '|')
-      return ++CurPtr, AsmToken(AsmToken::PipePipe, StringRef(TokStart, 2));
-    return AsmToken(AsmToken::Pipe, StringRef(TokStart, 1));
-  case '^': return AsmToken(AsmToken::Caret, StringRef(TokStart, 1));
-  case '&':
-    if (*CurPtr == '&')
-      return ++CurPtr, AsmToken(AsmToken::AmpAmp, StringRef(TokStart, 2));
-    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 '0': case '1': case '2': case '3': case '4':
-  case '5': case '6': case '7': case '8': case '9':
-    return LexDigit();
-  case '<':
-    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.
-  }
-}
+    // 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(AltMacro);
+    }else{
+      int len = 1;
+      while (*CurPtr == ' ' || *CurPtr == '\t') {
+        CurPtr++;
+        len++;
+      }
+      return AsmToken(AsmToken::Space, StringRef(TokStart, len));
+    }
+  case '\n': // FALL THROUGH.
+  case '\r':
+    isAtStartOfLine = true;
+    return AsmToken(AsmToken::EndOfStatement, StringRef(TokStart, 1));
+  case ':': return AsmToken(AsmToken::Colon, StringRef(TokStart, 1));
+  case '+': return AsmToken(AsmToken::Plus, StringRef(TokStart, 1));
+  case '-': return AsmToken(AsmToken::Minus, StringRef(TokStart, 1));
+  case '~': return AsmToken(AsmToken::Tilde, StringRef(TokStart, 1));
+  case '(': return AsmToken(AsmToken::LParen, StringRef(TokStart, 1));
+  case ')': return AsmToken(AsmToken::RParen, StringRef(TokStart, 1));
+  case '[': return AsmToken(AsmToken::LBrac, StringRef(TokStart, 1));
+  case ']': return AsmToken(AsmToken::RBrac, StringRef(TokStart, 1));
+  case '{': return AsmToken(AsmToken::LCurly, StringRef(TokStart, 1));
+  case '}': return AsmToken(AsmToken::RCurly, StringRef(TokStart, 1));
+  case '*': return AsmToken(AsmToken::Star, StringRef(TokStart, 1));
+  case ',': return AsmToken(AsmToken::Comma, StringRef(TokStart, 1));
+  case '$': return AsmToken(AsmToken::Dollar, StringRef(TokStart, 1));
+  case '@': return AsmToken(AsmToken::At, StringRef(TokStart, 1));
+  case '\\': return AsmToken(AsmToken::BackSlash, StringRef(TokStart, 1));
+  case '=':
+    if (*CurPtr == '=')
+      return ++CurPtr, AsmToken(AsmToken::EqualEqual, StringRef(TokStart, 2));
+    return AsmToken(AsmToken::Equal, StringRef(TokStart, 1));
+  case '|':
+    if (*CurPtr == '|')
+      return ++CurPtr, AsmToken(AsmToken::PipePipe, StringRef(TokStart, 2));
+    return AsmToken(AsmToken::Pipe, StringRef(TokStart, 1));
+  case '^': return AsmToken(AsmToken::Caret, StringRef(TokStart, 1));
+  case '&':
+    if (*CurPtr == '&')
+      return ++CurPtr, AsmToken(AsmToken::AmpAmp, StringRef(TokStart, 2));
+    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(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 '<':{
+    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.
+  }
+}
 No newline at end of file

lib/MC/MCParser/AsmParser.cpp

 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/AsmCond.h"
 #include "llvm/MC/MCParser/AsmLexer.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
-#include "llvm/MC/MCParser/MCAsmParserUtils.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCTargetAsmParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
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,
public:
   /// and set \p Res to the identifier contents.
   bool parseIdentifier(StringRef &Res) override;
   void eatToEndOfStatement() override;
 
   void checkForValidSection() override;
   /// }
 
 private:
-
+  bool PRE = false;
   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,
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);
-
-  // ".bundle_align_mode"
+  // AltMacros
+  bool parseDirectiveAltMacrosOnOff(StringRef Directive);
+  // ".bundle_align_mode"
   bool parseDirectiveBundleAlignMode();
   // ".bundle_lock"
   bool parseDirectiveBundleLock();
   // ".bundle_unlock"
   bool parseDirectiveBundleUnlock();
 
   // ".space", ".skip"
   bool parseDirectiveSpace(StringRef IDVal);

 
 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 (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();
+      jumpToLoc(ParentIncludeLoc);
+      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()) {
if (LocalLabelVal < 0) {
         if (!TheCondState.Ignore)
           return TokError("unexpected token at start of statement");
       }
     }
   } else if (Lexer.is(AsmToken::Dot)) {
     // Treat '.' as a valid identifier in this context.
     Lex();
     IDVal = ".";
-  } else if (parseIdentifier(IDVal)) {
+  }else if (parseIdentifier(IDVal)) {
     if (!TheCondState.Ignore)
       return TokError("unexpected token at start of statement");
     IDVal = "";
   }
 
   // Handle conditional assembly here before checking for skipping.  We
   // have to do this so that .endif isn't skipped in a ".if 0" block for
   // example.
   StringMap<DirectiveKind>::const_iterator DirKindIt =
case AsmToken::Colon: {
     // Diagnose attempt to use a variable as a label.
     //
     // FIXME: Diagnostics. Note the location of the definition as a label.
     // FIXME: This doesn't diagnose assignment to a symbol which has been
     // implicitly marked as external.
     MCSymbol *Sym;
     if (LocalLabelVal == -1) {
       if (ParsingInlineAsm && SI) {
-        StringRef RewrittenLabel =
-            SI->LookupInlineAsmLabel(IDVal, getSourceManager(), IDLoc, true);
-        assert(RewrittenLabel.size() &&
-               "We should have an internal name here.");
+        StringRef RewrittenLabel = SI->LookupInlineAsmLabel(IDVal, getSourceManager(), IDLoc, true);
+        assert(RewrittenLabel.size() && "We should have an internal name here.");
         Info.AsmRewrites->push_back(AsmRewrite(AOK_Label, IDLoc,
                                                IDVal.size(), RewrittenLabel));
         IDVal = RewrittenLabel;
       }
       Sym = getContext().getOrCreateSymbol(IDVal);
     } else
       Sym = Ctx.createDirectionalLocalSymbol(LocalLabelVal);
 
if (IDVal[0] == '.' && IDVal != ".") {
     // registered itself to parse this directive.
     std::pair<MCAsmParserExtension *, DirectiveHandler> Handler =
         ExtensionDirectiveMap.lookup(IDVal);
     if (Handler.first)
       return (*Handler.second)(Handler.first, IDVal, IDLoc);
 
     // Finally, if no one else is interested in this directive, it must be
     // generic and familiar to this class.
-    switch (DirKind) {
+    switch (DirKind) {
     default:
       break;
     case DK_SET:
     case DK_EQU:
       return parseDirectiveSet(IDVal, true);
     case DK_EQUIV:
       return parseDirectiveSet(IDVal, false);
     case DK_ASCII:
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 HasVararg = NParameters ? Parameters.back().Vararg : false;
+  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);
-          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();
-
+          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);
   }
 
bool AsmParser::parseMacroArguments(const MCAsmMacro *M,
   SmallVector<SMLoc, 4> FALocs;
 
   A.resize(NParameters);
   FALocs.resize(NParameters);
 
   // Parse two kinds of macro invocations:
   // - macros defined without any parameters accept an arbitrary number of them
   // - macros defined with parameters accept at most that many of them
-  bool HasVararg = NParameters ? M->Parameters.back().Vararg : false;
+  
+  bool HasVararg = NParameters ? M->Parameters.back().Vararg : false;
   for (unsigned Parameter = 0; !NParameters || Parameter < NParameters;
        ++Parameter) {
     SMLoc IDLoc = Lexer.getLoc();
     MCAsmMacroParameter FA;
-
     if (Lexer.is(AsmToken::Identifier) && Lexer.peekTok().is(AsmToken::Equal)) {
       if (parseIdentifier(FA.Name)) {
         Error(IDLoc, "invalid argument identifier for formal argument");
         eatToEndOfStatement();
         return true;
       }
 
       if (!Lexer.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))
void AsmParser::handleMacroExit() {
   jumpToLoc(ActiveMacros.back()->ExitLoc, ActiveMacros.back()->ExitBuffer);
   Lex();
 
   // Pop the instantiation entry.
   delete ActiveMacros.back();
   ActiveMacros.pop_back();
 }
 
+static bool isUsedIn(const MCSymbol *Sym, const MCExpr *Value) {
+  switch (Value->getKind()) {
+  case MCExpr::Binary: {
+    const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Value);
+    return isUsedIn(Sym, BE->getLHS()) || isUsedIn(Sym, BE->getRHS());
+  }
+  case MCExpr::Target:
+  case MCExpr::Constant:
+    return false;
+  case MCExpr::SymbolRef: {
+    const MCSymbol &S =
+        static_cast<const MCSymbolRefExpr *>(Value)->getSymbol();
+    if (S.isVariable())
+      return isUsedIn(Sym, S.getVariableValue());
+    return &S == Sym;
+  }
+  case MCExpr::Unary:
+    return isUsedIn(Sym, static_cast<const MCUnaryExpr *>(Value)->getSubExpr());
+  }
+
+  llvm_unreachable("Unknown expr kind!");
+}
+
 bool AsmParser::parseAssignment(StringRef Name, bool allow_redef,
                                 bool NoDeadStrip) {
-  MCSymbol *Sym;
+  // FIXME: Use better location, we should use proper tokens.
+  SMLoc EqualLoc = Lexer.getLoc();
+
   const MCExpr *Value;
-  if (MCParserUtils::parseAssignmentExpression(Name, allow_redef, *this, Sym,
-                                               Value))
+  if (parseExpression(Value))
     return true;
 
-  if (!Sym) {
-    // In the case where we parse an expression starting with a '.', we will
-    // not generate an error, nor will we create a symbol.  In this case we
-    // should just return out.
-    return false;
+  // Note: we don't count b as used in "a = b". This is to allow
+  // a = b
+  // b = c
+
+  if (Lexer.isNot(AsmToken::EndOfStatement))
+    return TokError("unexpected token in assignment");
+
+  // Eat the end of statement marker.
+  Lex();
+
+  // Validate that the LHS is allowed to be a variable (either it has not been
+  // used as a symbol, or it is an absolute symbol).
+  MCSymbol *Sym = getContext().lookupSymbol(Name);
+  if (Sym) {
+    // Diagnose assignment to a label.
+    //
+    // FIXME: Diagnostics. Note the location of the definition as a label.
+    // FIXME: Diagnose assignment to protected identifier (e.g., register name).
+    if (isUsedIn(Sym, Value))
+      return Error(EqualLoc, "Recursive use of '" + Name + "'");
+    else if (Sym->isUndefined() && !Sym->isUsed() && !Sym->isVariable())
+      ; // Allow redefinitions of undefined symbols only used in directives.
+    else if (Sym->isVariable() && !Sym->isUsed() && allow_redef)
+      ; // Allow redefinitions of variables that haven't yet been used.
+    else if (!Sym->isUndefined() && (!Sym->isVariable() || !allow_redef))
+      return Error(EqualLoc, "redefinition of '" + Name + "'");
+    else if (!Sym->isVariable())
+      return Error(EqualLoc, "invalid assignment to '" + Name + "'");
+    else if (!isa<MCConstantExpr>(Sym->getVariableValue()))
+      return Error(EqualLoc, "invalid reassignment of non-absolute variable '" +
+                                 Name + "'");
+
+    // Don't count these checks as uses.
+    Sym->setUsed(false);
+  } else if (Name == ".") {
+    if (Out.EmitValueToOffset(Value, 0)) {
+      Error(EqualLoc, "expected absolute expression");
+      eatToEndOfStatement();
     }
+    return false;
+  } else
+    Sym = getContext().getOrCreateSymbol(Name);
+
+  Sym->setRedefinable(allow_redef);
 
   // Do the assignment.
   Out.EmitAssignment(Sym, Value);
   if (NoDeadStrip)
     Out.EmitSymbolAttribute(Sym, MCSA_NoDeadStrip);
 
   return false;
 }
bool AsmParser::parseDirectiveCFIUndefined(SMLoc DirectiveLoc) {
   int64_t Register = 0;
 
   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");
 
   setMacrosEnabled(Directive == ".macros_on");
   return false;
 }
 
 /// parseDirectiveMacro
 /// ::= .macro name[,] [parameters]
 bool AsmParser::parseDirectiveMacro(SMLoc DirectiveLoc) {
   StringRef Name;
+  
   if (parseIdentifier(Name))
     return TokError("expected identifier in '.macro' directive");
 
   if (getLexer().is(AsmToken::Comma))
     Lex();
   
   MCAsmMacroParameters Parameters;
   while (getLexer().isNot(AsmToken::EndOfStatement)) {
 
     if (!Parameters.empty() && Parameters.back().Vararg)
       return Error(Lexer.getLoc(),
                    "Vararg parameter '" + Parameters.back().Name +
                    "' should be last one in the list of parameters.");
 
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.
bool AsmParser::parseMSInlineAsm(
   // Emit the remainder of the asm string.
   if (AsmStart != AsmEnd)
     OS << StringRef(AsmStart, AsmEnd - AsmStart);
 
   AsmString = OS.str();
   return false;
 }
 
-namespace llvm {
-namespace MCParserUtils {
-
-/// Returns whether the given symbol is used anywhere in the given expression,
-/// or subexpressions.
-static bool isSymbolUsedInExpression(const MCSymbol *Sym, const MCExpr *Value) {
-  switch (Value->getKind()) {
-  case MCExpr::Binary: {
-    const MCBinaryExpr *BE = static_cast<const MCBinaryExpr *>(Value);
-    return isSymbolUsedInExpression(Sym, BE->getLHS()) ||
-           isSymbolUsedInExpression(Sym, BE->getRHS());
-  }
-  case MCExpr::Target:
-  case MCExpr::Constant:
-    return false;
-  case MCExpr::SymbolRef: {
-    const MCSymbol &S =
-        static_cast<const MCSymbolRefExpr *>(Value)->getSymbol();
-    if (S.isVariable())
-      return isSymbolUsedInExpression(Sym, S.getVariableValue());
-    return &S == Sym;
-  }
-  case MCExpr::Unary:
-    return isSymbolUsedInExpression(
-        Sym, static_cast<const MCUnaryExpr *>(Value)->getSubExpr());
-  }
-
-  llvm_unreachable("Unknown expr kind!");
-}
-
-bool parseAssignmentExpression(StringRef Name, bool allow_redef,
-                               MCAsmParser &Parser, MCSymbol *&Sym,
-                               const MCExpr *&Value) {
-  MCAsmLexer &Lexer = Parser.getLexer();
-
-  // FIXME: Use better location, we should use proper tokens.
-  SMLoc EqualLoc = Lexer.getLoc();
-
-  if (Parser.parseExpression(Value)) {
-    Parser.TokError("missing expression");
-    Parser.eatToEndOfStatement();
-    return true;
-  }
-
-  // Note: we don't count b as used in "a = b". This is to allow
-  // a = b
-  // b = c
-
-  if (Lexer.isNot(AsmToken::EndOfStatement))
-    return Parser.TokError("unexpected token in assignment");
-
-  // Eat the end of statement marker.
-  Parser.Lex();
-
-  // Validate that the LHS is allowed to be a variable (either it has not been
-  // used as a symbol, or it is an absolute symbol).
-  Sym = Parser.getContext().lookupSymbol(Name);
-  if (Sym) {
-    // Diagnose assignment to a label.
-    //
-    // FIXME: Diagnostics. Note the location of the definition as a label.
-    // FIXME: Diagnose assignment to protected identifier (e.g., register name).
-    if (isSymbolUsedInExpression(Sym, Value))
-      return Parser.Error(EqualLoc, "Recursive use of '" + Name + "'");
-    else if (Sym->isUndefined() && !Sym->isUsed() && !Sym->isVariable())
-      ; // Allow redefinitions of undefined symbols only used in directives.
-    else if (Sym->isVariable() && !Sym->isUsed() && allow_redef)
-      ; // Allow redefinitions of variables that haven't yet been used.
-    else if (!Sym->isUndefined() && (!Sym->isVariable() || !allow_redef))
-      return Parser.Error(EqualLoc, "redefinition of '" + Name + "'");
-    else if (!Sym->isVariable())
-      return Parser.Error(EqualLoc, "invalid assignment to '" + Name + "'");
-    else if (!isa<MCConstantExpr>(Sym->getVariableValue()))
-      return Parser.Error(EqualLoc,
-                          "invalid reassignment of non-absolute variable '" +
-                              Name + "'");
-
-    // Don't count these checks as uses.
-    Sym->setUsed(false);
-  } else if (Name == ".") {
-    if (Parser.getStreamer().EmitValueToOffset(Value, 0)) {
-      Parser.Error(EqualLoc, "expected absolute expression");
-      Parser.eatToEndOfStatement();
-      return true;
-    }
-    return false;
-  } else
-    Sym = Parser.getContext().getOrCreateSymbol(Name);
-
-  Sym->setRedefinable(allow_redef);
-
-  return false;
-}
-
-} // namespace MCParserUtils
-} // namespace llvm
-
 /// \brief Create an MCAsmParser instance.
 MCAsmParser *llvm::createMCAsmParser(SourceMgr &SM, MCContext &C,
                                      MCStreamer &Out, const MCAsmInfo &MAI) {
   return new AsmParser(SM, C, Out, MAI);
 }

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