[inline-asm] Fix scope of assembly macros

[sdmitrouk]

Summary

Currently, there is one module-level scope and one more scope per inline
assembly operator inside functions. It means that one can't use assembly
macros defined at global scope in functions as well as that macros are
not shared among assembly blocks defined at function-level. Both seems
to be wrong as the effect must be as if all assembly blocks would be
directly inserted into assembly where macros are visible everywhere
below the point of their definition.

There is not really pretty part with std::unique_ptr in AsmParser,
but it must be done that way at least temporary to do not break any
build (Clang uses this interface).

[sdmitrouk]

Replaced StringRef with std::string as related data is stored longer than before.

[sdmitrouk]

There is another problem with StringRef, which are used in AsmToken.

[sdmitrouk]

Fix second issue with StringRef by introducing a wrapper class that copies underlying string value. Better ideas are welcomed.

[sdmitrouk]

Ping.

[rnk]

I guess we need this if we want gcc compatibility. Users shouldn't have to repeat macros in every inline asm blob, which gcc will then reject, forcing them to use ifdefs. =P

lib/MC/MCParser/AsmParser.cpp

55–56

Please don't use Allman bracing, put the following open brace on the same line for ifs, fors, tag types, etc.

527

This constructor will be removed once clang is updated, right?

547–553

Please leave these in initializer lists, even at the cost of duplication. The duplication will be gone once the alternate ctor is deleted.

1913

Underscores in variable names aren't really used in LLVM. Can you name this parameter something like TokenToCopy or CopiedToken?

4797

More Allman

[sdmitrouk]

I guess we need this if we want gcc compatibility.

Not sure if it's just about "gcc compatibility". C standard says:

The asm keyword may be used to insert assembly language directly into the translator output.

Assuming that there is one "translator output" per translation unit, the statement above
makes me think that there must be one common scope for all such directives.

Thanks for reviewing this.

lib/MC/MCParser/AsmParser.cpp

55–56

Right, I know how it should be formatted from the style guide, still did it wrong.

527

Correct.

547–553

OK.

1913

I just copied style from "surrounding code" (see AsmParser constructors above), now renamed to OriginalToken.
Maybe I should make additional cleanup commit to remove leading underscores from AsmParser?

4797

I just used output of clang-format as a guide, it found a couple more formatting issues in changed code.

[sdmitrouk]

Address review comments.

[rnk]

How will macros interact with diagnostics emitted in Clang? An SMLoc is just a const char* wrapper. Clang even assumes that this pointer points to the asm buffer. Adding macros that point to strings outside the main buffer seems like it could violate that assumption, right?

See this code in Clang:

SourceLocation translateLocation(const llvm::SourceMgr &LSM, llvm::SMLoc SMLoc) {
  // Compute an offset into the inline asm buffer.
  // FIXME: This isn't right if .macro is involved (but hopefully, no
  // real-world code does that).
  const llvm::MemoryBuffer *LBuf =
      LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(SMLoc));
  unsigned Offset = SMLoc.getPointer() - LBuf->getBufferStart();

[echristo]

In D6383#15, @sdmitrouk wrote:

I guess we need this if we want gcc compatibility.

Not sure if it's just about "gcc compatibility". C standard says:

The asm keyword may be used to insert assembly language directly into the translator output.

Assuming that there is one "translator output" per translation unit, the statement above
makes me think that there must be one common scope for all such directives.

This is interesting, how does it work in the presence of LTO? One translator per previous translation unit? One per now linked set of modules?

Anyhow, going to look a bit more.

[sdmitrouk]

@rnk

How will macros interact with diagnostics emitted in Clang?

Hm, I saw some issues with diagnostics before, that's how I found broken StringRef instances.
I'm not sure how it works or whether it works correctly with this change. Not sure if SMLoc uses any of those tokens.
Thanks for the pointer, I'll look into this.

@echristo

This is interesting, how does it work in the presence of LTO? One translator per previous translation unit? One per now linked set of modules?

Didn't think about LTO, and my knowledge of its implementation isn't
enough to answer. However, there is a restriction on functions: asm-directives block
inlining, maybe the same rule applies during LTO? It would prevent possibly
bad things from happening (e.g. applying wrong set of macros).

[rnk]

For LTO, what if we make Clang responsible for using the same asm context, and have it expand macros before creating the IR? We would still have the problem that llc's .s emission would produce different object files than it produces directly. We could have LLVM's LTO infrastructure expand .macro prior to linking, but that could kill lazy linking. We could also change AsmPrinter to undefine any macros introduce with .macro at the end of an asm blob, but still have Clang ask for the expansion.

I don't like any of this. Maybe we should just reject .macro in inline asm.

[asl]

I don't like any of this. Maybe we should just reject .macro in inline asm.

I would assume that rejecting macro in inline asm will break a lot of
existing code include e.g. linux kernel, various libraries, etc. So,
this does not seem to be a user-friendly solution :(

[grosbach]

Use of assembler directives at all in inline assembly has always been an edge case that only sort-of works and is sketchily supported. The canonical answer to anyone having problems with them is "don't do that."

If we can improve the support for them with a small bit of effort, that seems reasonable to me, but if it's opening up even further the can of worms, I'd prefer a sternly worded diagnostic instead.

Use of .macro in function-level inline assembly is a pretty horrible thing. I don't mind at all saying that's completely unsupported. In module level assembly, it's a bit tougher question. If we're going to support the feature at all, the latter seems the right thing to work on.

[sdmitrouk]

@rnk:

We could also change AsmPrinter to undefine any macros introduce with .macro at the end of an asm blob, but still have Clang ask for the expansion.

Couldn't understand what you mean for a while, looks like I didn't describe well
what the patch does, sorry. Undefining anything would make sense if functions
share same context, which is still not the case (macros defined in one function
are not visible in any other function). I'm not sure if sharing declarations is
safe even without LTO as it depends on order of functions. So another variant
(next paragraph) wouldn't affect lazy linking.

We could have LLVM's LTO infrastructure expand .macro prior to linking, but that could kill lazy linking.

Tried that, the problem is with determining target machine. Correct target
detection requires all modules to be linked together, linking them requires
macro expansion, macro expansion requires target detection (loop).

Another option would be to define module-level macros at the top of all
functions, but it has quite a lot of overhead and requires parsing to
separate macros from everything else.

For LTO, what if we make Clang responsible for using the same asm context, and have it expand macros before creating the IR?

Couldn't do this before creating the IR, need Target to parse inline asm.
Instead wrote a pass, which expands inline asm before module is emitted.
Please take a look and let me know what you think: http://reviews.llvm.org/P80

I have also discovered that it's easy to make two files that compile fine
without LTO, but fail when it's used. The issue is that module-level asm is
just concatenated, which might cause conflicts. This pass makes situation
somewhat better as it removes module-level macro definitions.

We would still have the problem that llc's .s emission would produce different object files than it produces directly.

I'm not sure if it's a problem, e.g. converting IR->BC->IR can change the code
because of constant folding (at least, there might be more cases), which is in
my opinion way more unexpected than LTO vs. non-LTO output differences.

In general, I don't think that forbidding anything like this is a good idea. I
don't see any good reason that would justify such decision, in fact such
artificial constraints seem to be against users. On the other hand, supporting
every possible use case isn't the best choice as well. I guess something like
what we have here (module-level macros are visible in functions + each function
has its own scope) might be a compromise that should work fine with most of code
bases and don't harm compiler.

[sdmitrouk]

Ping. Please see my previous message with changes for LTO.

[sdmitrouk]

Ping.

[rnk]

In D6383#104321, @sdmitrouk wrote:

For LTO, what if we make Clang responsible for using the same asm context, and have it expand macros before creating the IR?

Couldn't do this before creating the IR, need Target to parse inline asm.
Instead wrote a pass, which expands inline asm before module is emitted.
Please take a look and let me know what you think: http://reviews.llvm.org/P80

For MS inline asm, Clang already constructs an llvm::Target in clang/lib/Parse/ParseStmtAsm.cpp from the triple, so it is possible to do. I think this might be a good path forwards. Once we get to LLVM IR, we've basically lost source order, since inline functions can get emitted some time after their first use.

I don't know what happens when you have inline asm with operands like this:

int global;
asm volatile ( ".macro LEA_GLOBAL\nlea %0, %%rax\n.endm" : "m"(global));
void *foo() {
  void *addr;
  asm volatile ( "LEA_GLOBAL\n\tmov %%rax, %0", : : "=m"(addr));
  return addr;
}

Clang could opt to not expand macros containing operands in a subsequent asm blob.

---

I'm not particularly in favor of the approach taken in this patch, where only module assembly can define macros which get used in functions. It's not very intuitive.

Honestly, this is all really horrible. I'm pretty content with the status quo. Maybe we can agree to not implement this? Users can this functionality with the C preprocessor.

[grosbach]

I'm not particularly in favor of the approach taken in this patch, where only module assembly can define macros which get used in functions. It's not very intuitive.

Honestly, this is all really horrible. I'm pretty content with the status quo. Maybe we can agree to not implement this? Users can this functionality with the C preprocessor.

I completely agree.

[sdmitrouk]

For MS inline asm, Clang already constructs an llvm::Target in clang/lib/Parse/ParseStmtAsm.cpp from the triple, so it is possible to do.

Yes, it's possible with triple, but there are LLVM LTO tests where at least one of modules doesn't have triple specified (don't remember which one). If you merge all modules before processing them and at least one has triple, everything is OK, if you want to preprocess each module before merging it in, it won't work unless all modules have triple defined (or result will be defined by order of modules).

I'm not particularly in favor of the approach taken in this patch, where only module assembly can define macros which get used in functions. It's not very intuitive.

Well, not being able to use even module level macros or macros defined in inline assembly, say, one line above in the body of the same function seems to be even less intuitive in my opinion, but:

Honestly, this is all really horrible. I'm pretty content with the status quo. Maybe we can agree to not implement this? Users can this functionality with the C preprocessor.

OK, I'm not insisting on anything, just want to see this either accepted or closed. Thanks.

include/llvm/CodeGen/AsmPrinter.h

 class MachineFunction;
 class MachineInstr;
 class MachineLocation;
 class MachineLoopInfo;
 class MachineLoop;
 class MachineConstantPoolValue;
 class MachineJumpTableInfo;
 class MachineModuleInfo;
+class MCAsmContext;
 class MCAsmInfo;
 class MCCFIInstruction;
 class MCContext;
 class MCInst;
 class MCInstrInfo;
 class MCSection;
 class MCStreamer;
 class MCSubtargetInfo;
public:
   /// all of the global MC-related objects for the generated translation unit.
   MCContext &OutContext;
 
   /// This is the MCStreamer object for the file we are generating. This
   /// contains the transient state for the current translation unit that we are
   /// generating (such as the current section etc).
   MCStreamer &OutStreamer;
 
+  /// Common context for inline assembly.
+  std::unique_ptr<MCAsmContext> AsmContext;
+
   /// The current machine function.
   const MachineFunction *MF;
 
   /// This is a pointer to the current MachineModuleInfo.
   MachineModuleInfo *MMI;
 
   /// Name-mangler for global names.
   ///

include/llvm/MC/MCParser/MCAsmParser.h

public:
   /// @result - False on success.
   virtual bool parseAbsoluteExpression(int64_t &Res) = 0;
 
   /// Ensure that we have a valid section set in the streamer. Otherwise, report
   /// an error and switch to .text.
   virtual void checkForValidSection() = 0;
 };
 
+/// Auxiliary context interface to allow correct destruction.
+class MCAsmContext {
+protected: // Can only create subclasses.
+  MCAsmContext();
+
+public:
+  virtual ~MCAsmContext();
+};
+
+/// \brief Allocate an instance of assembly processing context.
+MCAsmContext *createMCAsmContext();
+
 /// \brief Create an MCAsmParser instance.
 MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &,
+                               MCStreamer &, const MCAsmInfo &,
+                               MCAsmContext &AC);
+
+/// \brief Create an MCAsmParser instance with internal MCAsmContext instance.
+MCAsmParser *createMCAsmParser(SourceMgr &, MCContext &,
                                MCStreamer &, const MCAsmInfo &);
 
 } // End llvm namespace
 
 #endif

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Target/TargetFrameLowering.h"
void AsmPrinter::getAnalysisUsage(AnalysisUsage &AU) const {
   if (isVerbose())
     AU.addRequired<MachineLoopInfo>();
 }
 
 bool AsmPrinter::doInitialization(Module &M) {
   MMI = getAnalysisIfAvailable<MachineModuleInfo>();
   MMI->AnalyzeModule(M);
 
+  AsmContext.reset(createMCAsmContext());
+
   // Initialize TargetLoweringObjectFile.
   const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
     .Initialize(OutContext, TM);
 
   OutStreamer.InitSections(false);
 
   Mang = new Mangler(TM.getSubtargetImpl()->getDataLayout());
 

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

if (isNullTerminated)
     Buffer = MemoryBuffer::getMemBuffer(Str, "<inline asm>");
   else
     Buffer = MemoryBuffer::getMemBufferCopy(Str, "<inline asm>");
 
   // Tell SrcMgr about this buffer, it takes ownership of the buffer.
   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
 
   std::unique_ptr<MCAsmParser> Parser(
-      createMCAsmParser(SrcMgr, OutContext, OutStreamer, *MAI));
+      createMCAsmParser(SrcMgr, OutContext, OutStreamer, *MAI, *AsmContext));
 
   // Initialize the parser with a fresh subtarget info. It is better to use a
   // new STI here because the parser may modify it and we do not want those
   // modifications to persist after parsing the inlineasm. The modifications
   // made by the parser will be seen by the code emitters because it passes
   // the current STI down to the EncodeInstruction() method.
   std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
       TM.getTargetTriple(), TM.getTargetCPU(), TM.getTargetFeatureString()));

lib/MC/MCParser/AsmParser.cpp

 #include <deque>
 #include <set>
 #include <string>
 #include <vector>
 using namespace llvm;
 
 MCAsmParserSemaCallback::~MCAsmParserSemaCallback() {}
 
+class MCAsmParserContext;
+
 namespace {
+/// \brief Helper wrapper around AsmToken to ensure that lifetime of the token
+/// string is independent from its creator.
+class MCAsmMacroArgToken {
+  /// Storage for token value.
+  std::string Value;
+
+  /// Token kind.
+  AsmToken::TokenKind Kind;
+
+  /// Wrapped token.
+  AsmToken Token;
+
+public:
+  MCAsmMacroArgToken(const AsmToken &_Token);
+
+  AsmToken::TokenKind getKind() const { return Kind; }
+
+  StringRef getStringContents() const { return Token.getStringContents(); }
+
+  StringRef getString() const { return Token.getString(); }
+};
+
 /// \brief Helper types for tracking macro definitions.
-typedef std::vector<AsmToken> MCAsmMacroArgument;
+typedef std::vector<MCAsmMacroArgToken> MCAsmMacroArgument;
 typedef std::vector<MCAsmMacroArgument> MCAsmMacroArguments;
 
 struct MCAsmMacroParameter {
-  StringRef Name;
+  std::string Name;
   MCAsmMacroArgument Value;
   bool Required;
   bool Vararg;
 
   MCAsmMacroParameter() : Required(false), Vararg(false) {}
 };
 
 typedef std::vector<MCAsmMacroParameter> MCAsmMacroParameters;
 
 struct MCAsmMacro {
-  StringRef Name;
-  StringRef Body;
+  std::string Name;
+  std::string Body;
   MCAsmMacroParameters Parameters;
 
 public:
   MCAsmMacro(StringRef N, StringRef B, MCAsmMacroParameters P)
       : Name(N), Body(B), Parameters(std::move(P)) {}
 };
 
 /// \brief Helper class for storing information about an active macro
struct ParseStatementInfo {
 
   /// \brief Was there an error parsing the inline assembly?
   bool ParseError;
 
   SmallVectorImpl<AsmRewrite> *AsmRewrites;
 
   ParseStatementInfo() : Opcode(~0U), ParseError(false), AsmRewrites(nullptr) {}
   ParseStatementInfo(SmallVectorImpl<AsmRewrite> *rewrites)
       : Opcode(~0), ParseError(false), AsmRewrites(rewrites) {}
 };
 
 /// \brief The concrete assembly parser instance.
 class AsmParser : public MCAsmParser {
   AsmParser(const AsmParser &) LLVM_DELETED_FUNCTION;
   void operator=(const AsmParser &) LLVM_DELETED_FUNCTION;
 private:
   AsmLexer Lexer;
   MCContext &Ctx;
   MCStreamer &Out;
   const MCAsmInfo &MAI;
+  MCAsmParserContext *AC;
+  std::unique_ptr<MCAsmParserContext> OwnedAC;
   SourceMgr &SrcMgr;
   SourceMgr::DiagHandlerTy SavedDiagHandler;
   void *SavedDiagContext;
   std::unique_ptr<MCAsmParserExtension> PlatformParser;
 
   /// This is the current buffer index we're lexing from as managed by the
   /// SourceMgr object.
   unsigned CurBuffer;
 
   AsmCond TheCondState;
   std::vector<AsmCond> TheCondStack;
 
   /// \brief maps directive names to handler methods in parser
   /// extensions. Extensions register themselves in this map by calling
   /// addDirectiveHandler.
   StringMap<ExtensionDirectiveHandler> ExtensionDirectiveMap;
 
-  /// \brief Map of currently defined macros.
-  StringMap<MCAsmMacro> MacroMap;
-
   /// \brief Stack of active macro instantiations.
   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;
private:
   bool IsDarwin;
 
   /// \brief Are we parsing ms-style inline assembly?
   bool ParsingInlineAsm;
 
 public:
   AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
             const MCAsmInfo &MAI);
+  AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
+            const MCAsmInfo &MAI, MCAsmParserContext *AC);
   virtual ~AsmParser();
 
   bool Run(bool NoInitialTextSection, bool NoFinalize = false) override;
 
   void addDirectiveHandler(StringRef Directive,
                            ExtensionDirectiveHandler Handler) override {
     ExtensionDirectiveMap[Directive] = Handler;
   }
public:
   bool parseIdentifier(StringRef &Res) override;
   void eatToEndOfStatement() override;
 
   void checkForValidSection() override;
   /// }
 
 private:
 
+  void initialize();
+
   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,
                    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;}
 
-  /// \brief Lookup a previously defined macro.
-  /// \param Name Macro name.
-  /// \returns Pointer to macro. NULL if no such macro was defined.
-  const MCAsmMacro* lookupMacro(StringRef Name);
-
-  /// \brief Define a new macro with the given name and information.
-  void defineMacro(StringRef Name, MCAsmMacro Macro);
-
-  /// \brief Undefine a macro. If no such macro was defined, it's a no-op.
-  void undefineMacro(StringRef Name);
-
   /// \brief Are we inside a macro instantiation?
   bool isInsideMacroInstantiation() {return !ActiveMacros.empty();}
 
   /// \brief Handle entry to macro instantiation.
   ///
   /// \param M The macro.
   /// \param NameLoc Instantiation location.
   bool handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc);
bool parseAssignment(StringRef Name, bool allow_redef,
                        bool NoDeadStrip = false);
 
   bool parseBinOpRHS(unsigned Precedence, const MCExpr *&Res, SMLoc &EndLoc);
   bool parseParenExpr(const MCExpr *&Res, SMLoc &EndLoc);
   bool parseBracketExpr(const MCExpr *&Res, SMLoc &EndLoc);
 
   bool parseRegisterOrRegisterNumber(int64_t &Register, SMLoc DirectiveLoc);
 
+  /// \brief Wrapper for parseIdentifier to support argument of type
+  ///  std::string.
+  bool parseIdentifier(std::string &Res);
+
   // Generic (target and platform independent) directive parsing.
   enum DirectiveKind {
     DK_NO_DIRECTIVE, // Placeholder
     DK_SET, DK_EQU, DK_EQUIV, DK_ASCII, DK_ASCIZ, DK_STRING, DK_BYTE, DK_SHORT,
     DK_VALUE, DK_2BYTE, DK_LONG, DK_INT, DK_4BYTE, DK_QUAD, DK_8BYTE, DK_OCTA,
     DK_SINGLE, DK_FLOAT, DK_DOUBLE, DK_ALIGN, DK_ALIGN32, DK_BALIGN, DK_BALIGNW,
     DK_BALIGNL, DK_P2ALIGN, DK_P2ALIGNW, DK_P2ALIGNL, DK_ORG, DK_FILL, DK_ENDR,
     DK_BUNDLE_ALIGN_MODE, DK_BUNDLE_LOCK, DK_BUNDLE_UNLOCK,

 namespace llvm {
 
 extern MCAsmParserExtension *createDarwinAsmParser();
 extern MCAsmParserExtension *createELFAsmParser();
 extern MCAsmParserExtension *createCOFFAsmParser();
 
 }
 
+class MCAsmParserContext : public MCAsmContext {
+private:
+  /// \brief Map of currently defined macros.
+  StringMap<MCAsmMacro> MacroMap;
+
+public:
+  /// \brief Lookup a previously defined macro.
+  /// \param Name Macro name.
+  /// \returns Pointer to macro. NULL if no such macro was defined.
+  const MCAsmMacro *lookupMacro(StringRef Name);
+
+  /// \brief Define a new macro with the given name and information.
+  void defineMacro(StringRef Name, MCAsmMacro Macro);
+
+  /// \brief Undefine a macro. If no such macro was defined, it's a no-op.
+  void undefineMacro(StringRef Name);
+};
+
 enum { DEFAULT_ADDRSPACE = 0 };
 
 AsmParser::AsmParser(SourceMgr &_SM, MCContext &_Ctx, MCStreamer &_Out,
                      const MCAsmInfo &_MAI)
     : Lexer(_MAI), Ctx(_Ctx), Out(_Out), MAI(_MAI), SrcMgr(_SM),
       PlatformParser(nullptr), CurBuffer(_SM.getMainFileID()),
       MacrosEnabledFlag(true), HadError(false), CppHashLineNumber(0),
       AssemblerDialect(~0U), IsDarwin(false), ParsingInlineAsm(false) {
+  OwnedAC.reset(new MCAsmParserContext());
+  AC = OwnedAC.get();
+
+  initialize();
+}
+
+AsmParser::AsmParser(SourceMgr &_SM, MCContext &_Ctx, MCStreamer &_Out,
+                     const MCAsmInfo &_MAI, MCAsmParserContext *_AC)
+    : Lexer(_MAI), Ctx(_Ctx), Out(_Out), MAI(_MAI), AC(_AC), SrcMgr(_SM),
+      PlatformParser(nullptr), CurBuffer(_SM.getMainFileID()),
+      MacrosEnabledFlag(true), HadError(false), CppHashLineNumber(0),
+      AssemblerDialect(~0U), IsDarwin(false), ParsingInlineAsm(false) {
+  initialize();
+}
+
+void AsmParser::initialize() {
   // Save the old handler.
   SavedDiagHandler = SrcMgr.getDiagHandler();
   SavedDiagContext = SrcMgr.getDiagContext();
   // Set our own handler which calls the saved handler.
   SrcMgr.setDiagHandler(DiagHandler, this);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
 
   // Initialize the platform / file format parser.
-  switch (_Ctx.getObjectFileInfo()->getObjectFileType()) {
+  switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
   case MCObjectFileInfo::IsCOFF:
     PlatformParser.reset(createCOFFAsmParser());
     break;
   case MCObjectFileInfo::IsMachO:
     PlatformParser.reset(createDarwinAsmParser());
     IsDarwin = true;
     break;
   case MCObjectFileInfo::IsELF:
case AsmToken::Equal:
     return parseAssignment(IDVal, true);
 
   default: // Normal instruction or directive.
     break;
   }
 
   // If macros are enabled, check to see if this is a macro instantiation.
   if (areMacrosEnabled())
-    if (const MCAsmMacro *M = lookupMacro(IDVal)) {
+    if (const MCAsmMacro *M = AC->lookupMacro(IDVal)) {
       return handleMacroEntry(M, IDLoc);
     }
 
   // Otherwise, we have a normal instruction or directive.
 
   // Directives start with "."
   if (IDVal[0] == '.' && IDVal != ".") {
     // There are several entities interested in parsing directives:
while (!Body.empty()) {
     }
     // Update the scan point.
     Body = Body.substr(Pos);
   }
 
   return false;
 }
 
+MCAsmMacroArgToken::MCAsmMacroArgToken(const AsmToken &OriginalToken) {
+  Value = OriginalToken.getString();
+
+  Kind = OriginalToken.getKind();
+  switch (Kind) {
+  default:
+    Token = AsmToken(Kind, Value);
+    break;
+  case AsmToken::BigNum:
+    Token = AsmToken(Kind, Value, OriginalToken.getAPIntVal());
+    break;
+  case AsmToken::Integer:
+    Token = AsmToken(Kind, Value, OriginalToken.getIntVal());
+    break;
+  }
+}
+
 MacroInstantiation::MacroInstantiation(SMLoc IL, int EB, SMLoc EL,
                                        size_t CondStackDepth)
     : InstantiationLoc(IL), ExitBuffer(EB), ExitLoc(EL),
       CondStackDepth(CondStackDepth) {}
 
 static bool isOperator(AsmToken::TokenKind kind) {
   switch (kind) {
   default:
for (unsigned Parameter = 0; !NParameters || Parameter < NParameters;
 
     if (Lexer.is(AsmToken::Comma))
       Lex();
   }
 
   return TokError("too many positional arguments");
 }
 
-const MCAsmMacro *AsmParser::lookupMacro(StringRef Name) {
-  StringMap<MCAsmMacro>::iterator I = MacroMap.find(Name);
-  return (I == MacroMap.end()) ? nullptr : &I->getValue();
-}
-
-void AsmParser::defineMacro(StringRef Name, MCAsmMacro Macro) {
-  MacroMap.insert(std::make_pair(Name, std::move(Macro)));
-}
-
-void AsmParser::undefineMacro(StringRef Name) { MacroMap.erase(Name); }
-
 bool AsmParser::handleMacroEntry(const MCAsmMacro *M, SMLoc NameLoc) {
   // Arbitrarily limit macro nesting depth, to match 'as'. We can eliminate
   // this, although we should protect against infinite loops.
   if (ActiveMacros.size() == 20)
     return TokError("macros cannot be nested more than 20 levels deep");
 
   MCAsmMacroArguments A;
   if (parseMacroArguments(M, A))
bool AsmParser::parseIdentifier(StringRef &Res) {
 
   Res = getTok().getIdentifier();
 
   Lex(); // Consume the identifier token.
 
   return false;
 }
 
+bool AsmParser::parseIdentifier(std::string &Res) {
+  StringRef StringRefRes;
+  bool Result = parseIdentifier(StringRefRes);
+  Res = StringRefRes;
+
+  return Result;
+}
+
 /// parseDirectiveSet:
 ///   ::= .equ identifier ',' expression
 ///   ::= .equiv identifier ',' expression
 ///   ::= .set identifier ',' expression
 bool AsmParser::parseDirectiveSet(StringRef IDVal, bool allow_redef) {
   StringRef Name;
 
   if (parseIdentifier(Name))
if (getLexer().is(AsmToken::Identifier)) {
         ++MacroDepth;
       }
     }
 
     // Otherwise, scan til the end of the statement.
     eatToEndOfStatement();
   }
 
-  if (lookupMacro(Name)) {
+  if (AC->lookupMacro(Name)) {
     return Error(DirectiveLoc, "macro '" + Name + "' is already defined");
   }
 
   const char *BodyStart = StartToken.getLoc().getPointer();
   const char *BodyEnd = EndToken.getLoc().getPointer();
   StringRef Body = StringRef(BodyStart, BodyEnd - BodyStart);
   checkForBadMacro(DirectiveLoc, Name, Body, Parameters);
-  defineMacro(Name, MCAsmMacro(Name, Body, std::move(Parameters)));
+  AC->defineMacro(Name, MCAsmMacro(Name, Body, std::move(Parameters)));
   return false;
 }
 
 /// checkForBadMacro
 ///
 /// With the support added for named parameters there may be code out there that
 /// is transitioning from positional parameters.  In versions of gas that did
 /// not support named parameters they would be ignored on the macro definition.

 bool AsmParser::parseDirectivePurgeMacro(SMLoc DirectiveLoc) {
   StringRef Name;
   if (parseIdentifier(Name))
     return TokError("expected identifier in '.purgem' directive");
 
   if (getLexer().isNot(AsmToken::EndOfStatement))
     return TokError("unexpected token in '.purgem' directive");
 
-  if (!lookupMacro(Name))
+  if (!AC->lookupMacro(Name))
     return Error(DirectiveLoc, "macro '" + Name + "' is not defined");
 
-  undefineMacro(Name);
+  AC->undefineMacro(Name);
   return false;
 }
 
 /// parseDirectiveBundleAlignMode
 /// ::= {.bundle_align_mode} expression
 bool AsmParser::parseDirectiveBundleAlignMode() {
   checkForValidSection();
 
bool AsmParser::parseMSInlineAsm(
   // Emit the remainder of the asm string.
   if (AsmStart != AsmEnd)
     OS << StringRef(AsmStart, AsmEnd - AsmStart);
 
   AsmString = OS.str();
   return false;
 }
 
+const MCAsmMacro *MCAsmParserContext::lookupMacro(StringRef Name) {
+  StringMap<MCAsmMacro>::iterator I = MacroMap.find(Name);
+  return (I == MacroMap.end()) ? nullptr : &I->getValue();
+}
+
+void MCAsmParserContext::defineMacro(StringRef Name, MCAsmMacro Macro) {
+  MacroMap.insert(std::make_pair(Name, std::move(Macro)));
+}
+
+void MCAsmParserContext::undefineMacro(StringRef Name) { MacroMap.erase(Name); }
+
+MCAsmContext::MCAsmContext() {}
+
+MCAsmContext::~MCAsmContext() {}
+
+MCAsmContext *llvm::createMCAsmContext() { return new MCAsmParserContext(); }
+
 /// \brief Create an MCAsmParser instance.
 MCAsmParser *llvm::createMCAsmParser(SourceMgr &SM, MCContext &C,
+                                     MCStreamer &Out, const MCAsmInfo &MAI,
+                                     MCAsmContext &AC) {
+  return new AsmParser(SM, C, Out, MAI, static_cast<MCAsmParserContext *>(&AC));
+}
+
+/// \brief Create an MCAsmParser instance with internal MCAsmContext instance.
+MCAsmParser *llvm::createMCAsmParser(SourceMgr &SM, MCContext &C,
                                      MCStreamer &Out, const MCAsmInfo &MAI) {
   return new AsmParser(SM, C, Out, MAI);
 }

test/CodeGen/Generic/inline-asm-macros-global-and-local.ll

+; RUN: not llc < %s 2>&1 > /dev/null | FileCheck %s
+
+; All macros defined in inline assembly should have module scope.
+
+; CHECK: error: macro 'MACRO' is already defined
+
+module asm ".macro  MACRO"
+module asm "\09.endm"
+
+define void @global_vs_local() {
+entry:
+  call void asm sideeffect ".macro  MACRO\0A\09.endm", ""()
+  call void asm sideeffect "MACRO", ""()
+  ret void
+}

test/CodeGen/Generic/inline-asm-macros-local-and-local.ll

+; RUN: not llc < %s 2>&1 > /dev/null | FileCheck %s
+
+; All macros defined in inline assembly should have module scope.
+
+; CHECK: error: macro 'MACRO' is already defined
+
+define void @local_and_local() {
+entry:
+  call void asm sideeffect ".macro  MACRO\0A\09.endm", ""()
+  call void asm sideeffect ".macro  MACRO\0A\09.endm", ""()
+  ret void
+}