Created MCTargetOptions which affects assembly instrumentations.

[ygorshenin]

Summary

Created MCTargetOptions structure which affects instrumentation of inline assembly. Currently MCTargetOptions contains only type of assembly instrumentation (address for now) and is exposed to target asm parsers.

[ygorshenin]

Unfortunately "-fsanitize=*" flag is not exposed to MCTargetAsmParser. Currently investigating how to do that...

[eugenis]

Blacklist needs to live somewhere with a longer lifetime.
Also, we need a "more global" place anyway to pass down -fsanitize=(address|memory|thread) setting for top-level assembly.
I suggest looking at EmitAssemblyHelper::CreateTargetMachine() in clang.
We could add a field (or several fields) to llvm::TargetOptions to pass through the sanitizer to run (if any) and, potentially, all the information that is currently passes through *SanitizerPass constructor arguments, like blacklist pass, MSanTrackOrigins, etc.

MCCodeGenInfo also looks like a good place for blacklist to live in.

/// CodeGenInfo - Low level target information such as relocation model.
/// Non-const to allow resetting optimization level per-function.

lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

26

This would enable not yet well tested asm instrumentation by default.

I think it's better to keep the flag name positive, and off by default (for now).

lib/Target/X86/AsmParser/X86AsmParser.cpp

724

This would read and parse the blacklist anew for every machine function.

The whole AsmParser is created from scratch for every inline asm instruction, so it's not a good owner for the blacklist.

[ygorshenin]

1. Updating D3106: MachineFunction is exposed to X86AsmParser. #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Fixes.

[ygorshenin]

1. Updating D3106: MachineFunction is exposed to X86AsmParser. #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

Added const attribute to STI.

[ygorshenin]

1. Updating D3106: MachineFunction is exposed to X86AsmParser. #
2. Enter a brief description of the changes included in this update.
3. The first line is used as subject, next lines as comment. #
4. If you intended to create a new revision, use:
5. $ arc diff --create

s/blacklist/blacklisted/

[ygorshenin]

PTAL

Value of "fsanitize" option + asan blacklist should be exposed in a separate CL, as it requires changes to clang.

lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

26

Done.

lib/Target/X86/AsmParser/X86AsmParser.cpp

724

Done.

[eugenis]

include/llvm/Transforms/Utils/SpecialCaseList.h

97 ↗

(On Diff #8012)

Please call it isSourceFileIn.

lib/Target/X86/AsmParser/X86AsmInstrumentation.h

32

This is an unrelated change, right? It should be a separate CL.
If you want, I could commit this chunk right now.

[ygorshenin]

isFileNameIn is renamed to isSourceFileIn.

[ygorshenin]

Asm instrumentation mode is exposed to MCTargetOptions. Blacklist is in progress...

[eugenis]

include/llvm/MC/MCTargetOptions.h

19

SanitizeAddress

I still think that bitfields work better here, even though there may be incompatible instrumentation modes.

25

s/sed/set/
I'd rather explain what this flag does, not how it gets set. Like "enables AddressSanitizer instrumentation at machine level".

32

Where is the definition of this constructor?

What happens to MCTargetOptions without the corresponding clang patch. They should default to no instrumentation.

include/llvm/Target/TargetMachine.h

111 ↗

(On Diff #8298)

Why? Options is a public member.

[ygorshenin]

SpecialCaseList is exposed to MCContext.

[ygorshenin]

Investigating why compilation of llvm-c-test fails.

include/llvm/MC/MCTargetOptions.h

19

Done.

25

Done.

32

Sorry, I forget to upload a source file. Fixed.

include/llvm/Target/TargetMachine.h

111 ↗

(On Diff #8298)

Done.

lib/Target/X86/AsmParser/X86AsmInstrumentation.h

32

Deleted, thanks. This class don't have an internal state now, so it's ok to omit void copy ctor and copy operator.

[eugenis]

lib/MC/MCContext.cpp

13 ↗

(On Diff #8310)

Please move it back.
http://llvm.org/docs/CodingStandards.html#include-style

386 ↗

(On Diff #8310)

Looks like we need a setter method to support -fsanitize-backlist= in clang.
Then probably ClAsmInstrumentationBlacklist flag should live somewhere else, and use the setter method, too.

[ygorshenin]

Fix.

[ygorshenin]

PTAL

lib/MC/MCContext.cpp

13 ↗

(On Diff #8310)

Done.

[eugenis]

So, this change now does 2 things:

• adds SanitizeAddress flag to TargetOptions (wrapped in MCTargetOptions)
• passes current MachineFunction to X86AsmInstrumentation

This effectively lets us take into account sanitize_address function attribute when instrumenting inline asm.
This also lets us apply blacklist when instrumenting .s files by runnning SpecialCaseList in cc1as and setting the bit in TargetOptions. That would be done in a future patch.

This patch looks OK to me.
Does anyone have any objections to the TargetOptions/MCTargetAsmParser changes?

[ygorshenin]

MCTargetOptions is exposed to assembly instrumentation instead of MachineFunction.

[• rafael]

include/llvm/MC/MCTargetAsmParser.h

102

Can this go on the asm streamer?

include/llvm/MC/MCTargetOptions.h

16

Do you expect this class to grow? Why have a class with only one field?

lib/MC/MCTargetOptions.cpp

22

We normally don't want to have command line options showing up in a binary just because it it links with MC. Can this be added to just llc and llvm-mc? Maybe add the option to CommandFlags.h or create another similar file for MC?

[ygorshenin]

Created an individual header with flags for MCTargetOptions.

[ygorshenin]

Rafael, Eugene, could you please take another look?

include/llvm/MC/MCTargetOptions.h

16

Yes, we're expecting that this class will grow. For instance, for memory sanitizer there will be additional bit about whether we need to track origins or not. Another reason is that in tools like llvm-mc this class is initialized independently from other TargetOptions's options.

lib/MC/MCTargetOptions.cpp

22

Done, I've created a separate header with flag and function for initialization from command line.

[• rafael]

include/llvm/MC/MCTargetAsmParser.h

102

The class small and would be easy to copy. The existence of the onMCTargetOptionSet also suggests value semantics, don't you want to store just a "MCTargetOptions MCOptions"?

122

This can be private. Even better, can't you also just remove setMCTargetOptions method completely and add an argument to createMCAsmParser?

[ygorshenin]

Added MCTargetOptions arg to the ctors of target asm parsers.

[ygorshenin]

PTAL

include/llvm/MC/MCTargetAsmParser.h

102

Done.

122

Done, but it required changes for all target parsers.

[• rafael]

The phabricator login doesn't seem to be working, so I will just put
the comments on the email.

setMCTargetOptions is now unused, please delete it.
onMCTargetOptionsSet is also unused, please delete it.

AsmPrinterInlineAsm.cpp:147 is now just a white space change now.

/// Current MCTargetOptions.
MCTargetOptions MCOptions;

Without a set method the comment is out of date.

Nit: maybe even better than a copy would be a const reference if that
is possible.

LGTM with that.

[ygorshenin]

Fixes.

[ygorshenin]

Done, many thanks, Rafael and Eugene!

[eugenis]

Committed in r206971.

include/llvm/CodeGen/CommandFlags.h

 // command line tools. The tools "llc" and "opt" both use this file to prevent
 // flag duplication.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_COMMANDFLAGS_H
 #define LLVM_CODEGEN_COMMANDFLAGS_H
 
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 using namespace llvm;
 
 cl::opt<std::string>
if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.DisableTailCalls = DisableTailCalls;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.TrapFuncName = TrapFuncName;
   Options.PositionIndependentExecutable = EnablePIE;
   Options.UseInitArray = UseInitArray;
+
+  Options.MCOptions = InitMCTargetOptionsFromFlags();
+
   return Options;
 }
 
 #endif

include/llvm/MC/MCTargetAsmParser.h

 //===-- llvm/MC/MCTargetAsmParser.h - Target Assembly Parser ----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_TARGETPARSER_H
 #define LLVM_MC_TARGETPARSER_H
 
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCParser/MCAsmParserExtension.h"
+#include "llvm/MC/MCTargetOptions.h"
 
 namespace llvm {
-class MCStreamer;
-class StringRef;
-class SMLoc;
 class AsmToken;
-class MCParsedAsmOperand;
 class MCInst;
+class MCParsedAsmOperand;
+class MCStreamer;
+class SMLoc;
+class StringRef;
 template <typename T> class SmallVectorImpl;
 
 enum AsmRewriteKind {
   AOK_Delete = 0,     // Rewrite should be ignored.
   AOK_Align,          // Rewrite align as .align.
   AOK_DotOperator,    // Rewrite a dot operator expression as an immediate.
                       // E.g., [eax].foo.bar -> [eax].8
   AOK_Emit,           // Rewrite _emit as .byte.
protected: // Can only create subclasses.
 
   /// ParsingInlineAsm - Are we parsing ms-style inline assembly?
   bool ParsingInlineAsm;
 
   /// SemaCallback - The Sema callback implementation.  Must be set when parsing
   /// ms-style inline assembly.
   MCAsmParserSemaCallback *SemaCallback;
 
+  /// Set of options which affects instrumentation of inline assembly.
+  MCTargetOptions MCOptions;
+
 public:
   virtual ~MCTargetAsmParser();
 
   unsigned getAvailableFeatures() const { return AvailableFeatures; }
   void setAvailableFeatures(unsigned Value) { AvailableFeatures = Value; }
 
   bool isParsingInlineAsm () { return ParsingInlineAsm; }
   void setParsingInlineAsm (bool Value) { ParsingInlineAsm = Value; }
 
   void setSemaCallback(MCAsmParserSemaCallback *Callback) {
     SemaCallback = Callback;
   }
 
   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc,
                              SMLoc &EndLoc) = 0;
 
   /// ParseInstruction - Parse one assembly instruction.
   ///
   /// The parser is positioned following the instruction name. The target
   /// specific instruction parser should parse the entire instruction and
   /// construct the appropriate MCInst, or emit an error. On success, the entire
   /// line should be parsed up to and including the end-of-statement token. On
   /// failure, the parser is not required to read to the end of the line.
   //
   /// \param Name - The instruction name.
   /// \param NameLoc - The source location of the name.
   /// \param Operands [out] - The list of parsed operands, this returns

include/llvm/MC/MCTargetOptions.h

+//===- MCTargetOptions.h - MC Target Options -------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCTARGETOPTIONS_H
+#define LLVM_MC_MCTARGETOPTIONS_H
+
+namespace llvm {
+
+class MCTargetOptions {
+public:
+  enum AsmInstrumentation {
+    AsmInstrumentationNone,
+    AsmInstrumentationAddress
+  };
+
+  /// Enables AddressSanitizer instrumentation at machine level.
+  bool SanitizeAddress : 1;
+
+  MCTargetOptions();
+};
+
+inline bool operator==(const MCTargetOptions &LHS, const MCTargetOptions &RHS) {
+#define ARE_EQUAL(X) LHS.X == RHS.X
+  return ARE_EQUAL(SanitizeAddress);
+#undef ARE_EQUAL
+}
+
+inline bool operator!=(const MCTargetOptions &LHS, const MCTargetOptions &RHS) {
+  return !(LHS == RHS);
+}
+
+} // end namespace llvm
+
+#endif

include/llvm/MC/MCTargetOptionsCommandFlags.h

+//===-- MCTargetOptionsCommandFlags.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains machine code-specific flags that are shared between
+// different command line tools.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+#define LLVM_MC_MCTARGETOPTIONSCOMMANDFLAGS_H
+
+#include "llvm/Support/CommandLine.h"
+#include "llvm/MC/MCTargetOptions.h"
+using namespace llvm;
+
+cl::opt<MCTargetOptions::AsmInstrumentation> AsmInstrumentation(
+    "asm-instrumentation",
+    cl::desc("Instrumentation of inline assembly and "
+             "assembly source files"),
+    cl::init(MCTargetOptions::AsmInstrumentationNone),
+    cl::values(clEnumValN(MCTargetOptions::AsmInstrumentationNone,
+                          "none",
+                          "no instrumentation at all"),
+               clEnumValN(MCTargetOptions::AsmInstrumentationAddress,
+                          "address",
+                          "instrument instructions with memory arguments"),
+               clEnumValEnd));
+
+static inline MCTargetOptions InitMCTargetOptionsFromFlags() {
+  MCTargetOptions Options;
+  Options.SanitizeAddress =
+      (AsmInstrumentation == MCTargetOptions::AsmInstrumentationAddress);
+  return Options;
+}
+
+#endif

include/llvm/Support/TargetRegistry.h

namespace llvm {
   class MCInstPrinter;
   class MCInstrInfo;
   class MCRegisterInfo;
   class MCStreamer;
   class MCSubtargetInfo;
   class MCSymbolizer;
   class MCRelocationInfo;
   class MCTargetAsmParser;
+  class MCTargetOptions;
   class TargetMachine;
   class TargetOptions;
   class raw_ostream;
   class formatted_raw_ostream;
 
   MCStreamer *createAsmStreamer(MCContext &Ctx, formatted_raw_ostream &OS,
                                 bool isVerboseAsm, bool useCFI,
                                 bool useDwarfDirectory,
typedef TargetMachine *(*TargetMachineCtorTy)(const Target &T,
                                                   CodeModel::Model CM,
                                                   CodeGenOpt::Level OL);
     typedef AsmPrinter *(*AsmPrinterCtorTy)(TargetMachine &TM,
                                             MCStreamer &Streamer);
     typedef MCAsmBackend *(*MCAsmBackendCtorTy)(const Target &T,
                                                 const MCRegisterInfo &MRI,
                                                 StringRef TT,
                                                 StringRef CPU);
-    typedef MCTargetAsmParser *(*MCAsmParserCtorTy)(MCSubtargetInfo &STI,
-                                                    MCAsmParser &P,
-                                                    const MCInstrInfo &MII);
+    typedef MCTargetAsmParser *(*MCAsmParserCtorTy)(
+        MCSubtargetInfo &STI,
+        const MCInstrInfo &MII,
+        const MCTargetOptions &Options);
     typedef MCDisassembler *(*MCDisassemblerCtorTy)(const Target &T,
                                                     const MCSubtargetInfo &STI,
                                                     MCContext &Ctx);
     typedef MCInstPrinter *(*MCInstPrinterCtorTy)(const Target &T,
                                                   unsigned SyntaxVariant,
                                                   const MCAsmInfo &MAI,
                                                   const MCInstrInfo &MII,
                                                   const MCRegisterInfo &MRI,
MCAsmBackend *createMCAsmBackend(const MCRegisterInfo &MRI,
         return nullptr;
       return MCAsmBackendCtorFn(*this, MRI, Triple, CPU);
     }
 
     /// createMCAsmParser - Create a target specific assembly parser.
     ///
     /// \param Parser The target independent parser implementation to use for
     /// parsing and lexing.
-    MCTargetAsmParser *createMCAsmParser(MCSubtargetInfo &STI,
-                                         MCAsmParser &Parser,
-                                         const MCInstrInfo &MII) const {
+    MCTargetAsmParser *createMCAsmParser(
+        MCSubtargetInfo &STI,
+        const MCInstrInfo &MII,
+        const MCTargetOptions &Options) const {
       if (!MCAsmParserCtorFn)
         return nullptr;
-      return MCAsmParserCtorFn(STI, Parser, MII);
+      return MCAsmParserCtorFn(STI, Parser, MII, Options);
     }
 
     /// createAsmPrinter - Create a target specific assembly printer pass.  This
     /// takes ownership of the MCStreamer object.
     AsmPrinter *createAsmPrinter(TargetMachine &TM, MCStreamer &Streamer) const{
       if (!AsmPrinterCtorFn)
         return nullptr;
       return AsmPrinterCtorFn(TM, Streamer);

   template<class MCAsmParserImpl>
   struct RegisterMCAsmParser {
     RegisterMCAsmParser(Target &T) {
       TargetRegistry::RegisterMCAsmParser(T, &Allocator);
     }
 
   private:
     static MCTargetAsmParser *Allocator(MCSubtargetInfo &STI, MCAsmParser &P,
-                                        const MCInstrInfo &MII) {
-      return new MCAsmParserImpl(STI, P, MII);
+                                        const MCInstrInfo &MII,
+                                        const MCTargetOptions &Options) {
+      return new MCAsmParserImpl(STI, P, MII, Options);
     }
   };
 
   /// RegisterAsmPrinter - Helper template for registering a target specific
   /// assembly printer, for use in the target machine initialization
   /// function. Usage:
   ///
   /// extern "C" void LLVMInitializeFooAsmPrinter() {

include/llvm/Target/TargetOptions.h

 // This file defines command line option flags that are shared across various
 // targets.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_TARGETOPTIONS_H
 #define LLVM_TARGET_TARGETOPTIONS_H
 
+#include "llvm/MC/MCTargetOptions.h"
 #include <string>
 
 namespace llvm {
   class MachineFunction;
   class StringRef;
 
   // Possible float ABI settings. Used with FloatABIType in TargetOptions.h.
   namespace FloatABI {
public:
     /// Strict mode - allow fusion only if/when it can be proven that the excess
     /// precision won't effect the result.
     ///
     /// Note: This option only controls formation of fused ops by the
     /// optimizers.  Fused operations that are explicitly specified (e.g. FMA
     /// via the llvm.fma.* intrinsic) will always be honored, regardless of
     /// the value of this option.
     FPOpFusion::FPOpFusionMode AllowFPOpFusion;
+
+    /// Machine level options.
+    MCTargetOptions MCOptions;
   };
 
 // Comparison operators:
 
 
 inline bool operator==(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
 #define ARE_EQUAL(X) LHS.X == RHS.X
return
     ARE_EQUAL(DisableTailCalls) &&
     ARE_EQUAL(StackAlignmentOverride) &&
     ARE_EQUAL(EnableFastISel) &&
     ARE_EQUAL(PositionIndependentExecutable) &&
     ARE_EQUAL(UseInitArray) &&
     ARE_EQUAL(TrapUnreachable) &&
     ARE_EQUAL(TrapFuncName) &&
     ARE_EQUAL(FloatABIType) &&
-    ARE_EQUAL(AllowFPOpFusion);
+    ARE_EQUAL(AllowFPOpFusion) &&
+    ARE_EQUAL(MCOptions);
 #undef ARE_EQUAL
 }
 
 inline bool operator!=(const TargetOptions &LHS,
                        const TargetOptions &RHS) {
   return !(LHS == RHS);
 }
 
 } // End llvm namespace
 
 #endif

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

 // This file implements the inline assembler pieces of the AsmPrinter class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCStreamer.h"
std::unique_ptr<MCSubtargetInfo> STI(TM.getTarget().createMCSubtargetInfo(
       TM.getTargetTriple(), TM.getTargetCPU(), TM.getTargetFeatureString()));
 
   // Preserve a copy of the original STI because the parser may modify it.  For
   // example, when switching between arm and thumb mode. If the target needs to
   // emit code to return to the original state it can do so in
   // emitInlineAsmEnd().
   MCSubtargetInfo STIOrig = *STI;
 
+  MCTargetOptions MCOptions;
+  if (MF)
+    MCOptions = MF->getTarget().Options.MCOptions;
   std::unique_ptr<MCTargetAsmParser> TAP(
-      TM.getTarget().createMCAsmParser(*STI, *Parser, *MII));
+      TM.getTarget().createMCAsmParser(*STI, *Parser, *MII, MCOptions));
   if (!TAP)
     report_fatal_error("Inline asm not supported by this streamer because"
                        " we don't have an asm parser for this target\n");
   Parser->setAssemblerDialect(Dialect);
   Parser->setTargetParser(*TAP.get());
 
   // Don't implicitly switch to the text section before the asm.
   int Res = Parser->Run(/*NoInitialTextSection*/ true,

lib/LTO/LTOModule.cpp

bool LTOModule::addAsmGlobalSymbols(std::string &errMsg) {
   std::unique_ptr<MCAsmParser> Parser(
       createMCAsmParser(SrcMgr, _context, *Streamer, *_target->getMCAsmInfo()));
   const Target &T = _target->getTarget();
   std::unique_ptr<MCInstrInfo> MCII(T.createMCInstrInfo());
   std::unique_ptr<MCSubtargetInfo> STI(T.createMCSubtargetInfo(
       _target->getTargetTriple(), _target->getTargetCPU(),
       _target->getTargetFeatureString()));
   std::unique_ptr<MCTargetAsmParser> TAP(
-      T.createMCAsmParser(*STI, *Parser.get(), *MCII));
+      T.createMCAsmParser(*STI, *Parser.get(), *MCII,
+                          _target->Options.MCOptions));
   if (!TAP) {
     errMsg = "target " + std::string(T.getName()) +
       " does not define AsmParser.";
     return true;
   }
 
   Parser->setTargetParser(*TAP);
   if (Parser->Run(false))

lib/MC/CMakeLists.txt

add_llvm_library(LLVMMC
   MCSection.cpp
   MCSectionCOFF.cpp
   MCSectionELF.cpp
   MCSectionMachO.cpp
   MCStreamer.cpp
   MCSubtargetInfo.cpp
   MCSymbol.cpp
   MCSymbolizer.cpp
+  MCTargetOptions.cpp
   MCValue.cpp
   MCWin64EH.cpp
   MachObjectWriter.cpp
   SubtargetFeature.cpp
   WinCOFFObjectWriter.cpp
   WinCOFFStreamer.cpp
   )
 
 add_subdirectory(MCParser)
 add_subdirectory(MCDisassembler)

lib/MC/MCTargetOptions.cpp

+//===- lib/MC/MCTargetOptions.cpp - MC Target Options --------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCTargetOptions.h"
+
+namespace llvm {
+
+MCTargetOptions::MCTargetOptions() : SanitizeAddress(false) {}
+
+} // end namespace llvm

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

 public:
   enum AArch64MatchResultTy {
     Match_FirstAArch64 = FIRST_TARGET_MATCH_RESULT_TY,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "AArch64GenAsmMatcher.inc"
   };
 
   AArch64AsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
-                   const MCInstrInfo &MII)
+                   const MCInstrInfo &MII,
+                   const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
     MCAsmParserExtension::Initialize(_Parser);
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
   }
 
   // These are the public interface of the MCTargetAsmParser

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

enum ARMMatchResultTy {
     Match_RequiresV6,
     Match_RequiresThumb2,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "ARMGenAsmMatcher.inc"
 
   };
 
   ARMAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
-               const MCInstrInfo &MII)
+               const MCInstrInfo &MII,
+               const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(_STI), Parser(_Parser), MII(MII), UC(_Parser) {
     MCAsmParserExtension::Initialize(_Parser);
 
     // Cache the MCRegisterInfo.
     MRI = getContext().getRegisterInfo();
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));

lib/Target/ARM64/AsmParser/ARM64AsmParser.cpp

 
 public:
   enum ARM64MatchResultTy {
     Match_InvalidSuffix = FIRST_TARGET_MATCH_RESULT_TY,
 #define GET_OPERAND_DIAGNOSTIC_TYPES
 #include "ARM64GenAsmMatcher.inc"
   };
   ARM64AsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
-                 const MCInstrInfo &MII)
+                 const MCInstrInfo &MII,
+                 const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(_STI), Parser(_Parser) {
     MCAsmParserExtension::Initialize(_Parser);
   }
 
   virtual bool ParseInstruction(ParseInstructionInfo &Info, StringRef Name,
                                 SMLoc NameLoc, OperandVector &Operands);
   virtual bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc);
   virtual bool ParseDirective(AsmToken DirectiveID);

lib/Target/Mips/AsmParser/MipsAsmParser.cpp

void clearFeatureBits(unsigned Feature, StringRef FeatureString) {
     if (STI.getFeatureBits() & Feature) {
       setAvailableFeatures(
           ComputeAvailableFeatures(STI.ToggleFeature(FeatureString)));
     }
   }
 
 public:
   MipsAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
-                const MCInstrInfo &MII)
+                const MCInstrInfo &MII,
+                const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(sti), Parser(parser) {
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
 
     // Assert exactly one ABI was chosen.
     assert((((STI.getFeatureBits() & Mips::FeatureO32) != 0) +
             ((STI.getFeatureBits() & Mips::FeatureEABI) != 0) +
             ((STI.getFeatureBits() & Mips::FeatureN32) != 0) +

lib/Target/PowerPC/AsmParser/PPCAsmParser.cpp

 #define GET_ASSEMBLER_HEADER
 #include "PPCGenAsmMatcher.inc"
 
   /// }
 
 
 public:
   PPCAsmParser(MCSubtargetInfo &_STI, MCAsmParser &_Parser,
-               const MCInstrInfo &_MII)
+               const MCInstrInfo &_MII,
+               const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(_STI), Parser(_Parser), MII(_MII) {
     // Check for 64-bit vs. 32-bit pointer mode.
     Triple TheTriple(STI.getTargetTriple());
     IsPPC64 = (TheTriple.getArch() == Triple::ppc64 ||
                TheTriple.getArch() == Triple::ppc64le);
     IsDarwin = TheTriple.isMacOSX();
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));

lib/Target/Sparc/AsmParser/SparcAsmParser.cpp

bool matchRegisterName(const AsmToken &Tok, unsigned &RegNo,
                          unsigned &RegKind);
 
   bool matchSparcAsmModifiers(const MCExpr *&EVal, SMLoc &EndLoc);
   bool parseDirectiveWord(unsigned Size, SMLoc L);
 
   bool is64Bit() const { return STI.getTargetTriple().startswith("sparcv9"); }
 public:
   SparcAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
-                const MCInstrInfo &MII)
+                const MCInstrInfo &MII,
+                const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(sti), Parser(parser) {
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
   }
 
 };
 
   static unsigned IntRegs[32] = {

lib/Target/SystemZ/AsmParser/SystemZAsmParser.cpp

parseAddress(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
                const unsigned *Regs, RegisterKind RegKind,
                MemoryKind MemKind);
 
   bool parseOperand(SmallVectorImpl<MCParsedAsmOperand*> &Operands,
                     StringRef Mnemonic);
 
 public:
   SystemZAsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
-                   const MCInstrInfo &MII)
+                   const MCInstrInfo &MII,
+                   const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(sti), Parser(parser) {
     MCAsmParserExtension::Initialize(Parser);
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
   }
 
   // Override MCTargetAsmParser.

lib/Target/TargetMachine.cpp

 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeGenInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/MC/MCTargetOptions.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 using namespace llvm;
 
 //---------------------------------------------------------------------------
 // Command-line options that tend to be useful on more than one back-end.
#define RESET_OPTION(X, Y)                                              \
 
   RESET_OPTION(NoFramePointerElim, "no-frame-pointer-elim");
   RESET_OPTION(LessPreciseFPMADOption, "less-precise-fpmad");
   RESET_OPTION(UnsafeFPMath, "unsafe-fp-math");
   RESET_OPTION(NoInfsFPMath, "no-infs-fp-math");
   RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math");
   RESET_OPTION(UseSoftFloat, "use-soft-float");
   RESET_OPTION(DisableTailCalls, "disable-tail-calls");
+
+  TO.MCOptions.SanitizeAddress = F->hasFnAttribute(Attribute::SanitizeAddress);
 }
 
 /// getRelocationModel - Returns the code generation relocation model. The
 /// choices are static, PIC, and dynamic-no-pic, and target default.
 Reloc::Model TargetMachine::getRelocationModel() const {
   if (!CodeGenInfo)
     return Reloc::Default;
   return CodeGenInfo->getRelocationModel();

lib/Target/X86/AsmParser/X86AsmInstrumentation.h

 
 namespace llvm {
 
 class MCContext;
 class MCInst;
 class MCParsedAsmOperand;
 class MCStreamer;
 class MCSubtargetInfo;
+class MCTargetOptions;
 
 class X86AsmInstrumentation;
 
-X86AsmInstrumentation *CreateX86AsmInstrumentation(MCSubtargetInfo &STI);
+X86AsmInstrumentation *
+CreateX86AsmInstrumentation(const MCTargetOptions &MCOptions,
+                            const MCContext &Ctx, const MCSubtargetInfo &STI);
 
 class X86AsmInstrumentation {
 public:
   virtual ~X86AsmInstrumentation();
 
   // Instruments Inst. Should be called just before the original
   // instruction is sent to Out.
   virtual void InstrumentInstruction(
       const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
       MCContext &Ctx, MCStreamer &Out);
 
 protected:
   friend X86AsmInstrumentation *
-  CreateX86AsmInstrumentation(MCSubtargetInfo &STI);
+  CreateX86AsmInstrumentation(const MCTargetOptions &MCOptions,
+                              const MCContext &Ctx, const MCSubtargetInfo &STI);
 
   X86AsmInstrumentation();
 };
 
-}  // End llvm namespace
+} // End llvm namespace
 
-#endif  // X86_ASM_INSTRUMENTATION_H
+#endif // X86_ASM_INSTRUMENTATION_H

lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

 //===-- X86AsmInstrumentation.cpp - Instrument X86 inline assembly C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/X86BaseInfo.h"
 #include "X86AsmInstrumentation.h"
 #include "X86Operand.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/IR/Function.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
+#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Compiler.h"
-#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
+#include "llvm/MC/MCTargetOptions.h"
 
 namespace llvm {
 namespace {
 
-static cl::opt<bool> ClAsanInstrumentInlineAssembly(
-    "asan-instrument-inline-assembly", cl::desc("instrument inline assembly"),
-    cl::Hidden, cl::init(false));
-
 bool IsStackReg(unsigned Reg) {
   return Reg == X86::RSP || Reg == X86::ESP || Reg == X86::SP;
 }
 
 std::string FuncName(unsigned AccessSize, bool IsWrite) {
   return std::string("__sanitizer_sanitize_") + (IsWrite ? "store" : "load") +
          (utostr(AccessSize));
 }
 
 class X86AddressSanitizer : public X86AsmInstrumentation {
 public:
-  X86AddressSanitizer(MCSubtargetInfo &sti) : STI(sti) {}
+  X86AddressSanitizer(const MCSubtargetInfo &STI) : STI(STI) {}
   virtual ~X86AddressSanitizer() {}
 
   // X86AsmInstrumentation implementation:
   virtual void InstrumentInstruction(
       const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
       MCContext &Ctx, MCStreamer &Out) override {
     InstrumentMOV(Inst, Operands, Ctx, Out);
   }
 
   // Should be implemented differently in x86_32 and x86_64 subclasses.
   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
                                         bool IsWrite, MCContext &Ctx,
                                         MCStreamer &Out) = 0;
 
   void InstrumentMemOperand(MCParsedAsmOperand *Op, unsigned AccessSize,
                             bool IsWrite, MCContext &Ctx, MCStreamer &Out);
   void InstrumentMOV(const MCInst &Inst,
                      SmallVectorImpl<MCParsedAsmOperand *> &Operands,
                      MCContext &Ctx, MCStreamer &Out);
   void EmitInstruction(MCStreamer &Out, const MCInst &Inst) {
     Out.EmitInstruction(Inst, STI);
   }
 
 protected:
-  MCSubtargetInfo &STI;
+  const MCSubtargetInfo &STI;
 };
 
 void X86AddressSanitizer::InstrumentMemOperand(
     MCParsedAsmOperand *Op, unsigned AccessSize, bool IsWrite, MCContext &Ctx,
     MCStreamer &Out) {
   assert(Op && Op->isMem() && "Op should be a memory operand.");
   assert((AccessSize & (AccessSize - 1)) == 0 && AccessSize <= 16 &&
          "AccessSize should be a power of two, less or equal than 16.");
if (OpIx >= Operands.size())
     return;
 
   const bool IsWrite = (OpIx != 1);
   InstrumentMemOperand(Operands[OpIx], AccessSize, IsWrite, Ctx, Out);
 }
 
 class X86AddressSanitizer32 : public X86AddressSanitizer {
 public:
-  X86AddressSanitizer32(MCSubtargetInfo &sti) : X86AddressSanitizer(sti) {}
+  X86AddressSanitizer32(const MCSubtargetInfo &STI)
+      : X86AddressSanitizer(STI) {}
   virtual ~X86AddressSanitizer32() {}
 
   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
                                         bool IsWrite, MCContext &Ctx,
                                         MCStreamer &Out) override;
 };
 
 void X86AddressSanitizer32::InstrumentMemOperandImpl(
void X86AddressSanitizer32::InstrumentMemOperandImpl(
   }
   EmitInstruction(Out, MCInstBuilder(X86::ADD32ri).addReg(X86::ESP)
                            .addReg(X86::ESP).addImm(4));
   EmitInstruction(Out, MCInstBuilder(X86::POP32r).addReg(X86::EAX));
 }
 
 class X86AddressSanitizer64 : public X86AddressSanitizer {
 public:
-  X86AddressSanitizer64(MCSubtargetInfo &sti) : X86AddressSanitizer(sti) {}
+  X86AddressSanitizer64(const MCSubtargetInfo &STI)
+      : X86AddressSanitizer(STI) {}
   virtual ~X86AddressSanitizer64() {}
 
   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
                                         bool IsWrite, MCContext &Ctx,
                                         MCStreamer &Out) override;
 };
 
 void X86AddressSanitizer64::InstrumentMemOperandImpl(

 
 X86AsmInstrumentation::X86AsmInstrumentation() {}
 X86AsmInstrumentation::~X86AsmInstrumentation() {}
 
 void X86AsmInstrumentation::InstrumentInstruction(
     const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
     MCContext &Ctx, MCStreamer &Out) {}
 
-X86AsmInstrumentation *CreateX86AsmInstrumentation(MCSubtargetInfo &STI) {
-  if (ClAsanInstrumentInlineAssembly) {
+X86AsmInstrumentation *
+CreateX86AsmInstrumentation(const MCTargetOptions &MCOptions, const MCContext &Ctx,
+                            const MCSubtargetInfo &STI) {
+  if (MCOptions.SanitizeAddress) {
     if ((STI.getFeatureBits() & X86::Mode32Bit) != 0)
       return new X86AddressSanitizer32(STI);
     if ((STI.getFeatureBits() & X86::Mode64Bit) != 0)
       return new X86AddressSanitizer64(STI);
   }
   return new X86AsmInstrumentation();
 }
 
 } // End llvm namespace

lib/Target/X86/AsmParser/X86AsmParser.cpp

 
 #define GET_ASSEMBLER_HEADER
 #include "X86GenAsmMatcher.inc"
 
   /// }
 
 public:
   X86AsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
-               const MCInstrInfo &MII)
+               const MCInstrInfo &MII,
+               const MCTargetOptions &Options)
       : MCTargetAsmParser(), STI(sti), Parser(parser), InstInfo(0) {
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
-    Instrumentation.reset(CreateX86AsmInstrumentation(STI));
+    Instrumentation.reset(
+        CreateX86AsmInstrumentation(Options, Parser.getContext(), STI));
   }
+
   bool ParseRegister(unsigned &RegNo, SMLoc &StartLoc, SMLoc &EndLoc) override;
 
   bool
     ParseInstruction(ParseInstructionInfo &Info, StringRef Name, SMLoc NameLoc,
                      SmallVectorImpl<MCParsedAsmOperand*> &Operands) override;
 
   bool ParseDirective(AsmToken DirectiveID) override;
 };
 } // end anonymous namespace
 

test/Instrumentation/AddressSanitizer/X86/asm_attr.ll

+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asm-instrumentation=address | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; CHECK-LABEL: mov_no_attr
+; CHECK-NOT: callq __sanitizer_sanitize_load8@PLT
+; CHECK-NOT: callq __sanitizer_sanitize_store8@PLT
+define void @mov_no_attr(i64* %dst, i64* %src) {
+  tail call void asm sideeffect "movq ($1), %rax  \0A\09movq %rax, ($0)  \0A\09", "r,r,~{memory},~{rax},~{dirflag},~{fpsr},~{flags}"(i64* %dst, i64* %src)
+  ret void
+}
+
+; CHECK-LABEL: mov_sanitize
+; CHECK: callq __sanitizer_sanitize_load8@PLT
+; CHECK: callq __sanitizer_sanitize_store8@PLT
+define void @mov_sanitize(i64* %dst, i64* %src) sanitize_address {
+  tail call void asm sideeffect "movq ($1), %rax  \0A\09movq %rax, ($0)  \0A\09", "r,r,~{memory},~{rax},~{dirflag},~{fpsr},~{flags}"(i64* %dst, i64* %src)
+  ret void
+}

test/Instrumentation/AddressSanitizer/X86/asm_mov.ll

-; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asan-instrument-inline-assembly | FileCheck %s
+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asm-instrumentation=address | FileCheck %s
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: mov1b
 ; CHECK: subq $128, %rsp
 ; CHECK-NEXT: pushq %rdi
 ; CHECK-NEXT: leaq {{.*}}, %rdi

 
 ; CHECK: movaps {{.*}}, {{.*}}
 define void @mov16b(<2 x i64>* %dst, <2 x i64>* %src) #0 {
 entry:
   tail call void asm sideeffect "movaps ($1), %xmm0  \0A\09movaps %xmm0, ($0)  \0A\09", "r,r,~{memory},~{xmm0},~{dirflag},~{fpsr},~{flags}"(<2 x i64>* %dst, <2 x i64>* %src) #1, !srcloc !4
   ret void
 }
 
-attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #0 = { nounwind uwtable sanitize_address "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-frame-pointer-elim-non-leaf"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" }
 attributes #1 = { nounwind }
 
 !0 = metadata !{i32 98, i32 122, i32 160}
 !1 = metadata !{i32 305, i32 329, i32 367}
 !2 = metadata !{i32 512, i32 537, i32 576}
 !3 = metadata !{i32 721, i32 746, i32 785}
 !4 = metadata !{i32 929, i32 957, i32 999}

test/Instrumentation/AddressSanitizer/X86/asm_mov.s

-# RUN: llvm-mc %s -triple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asan-instrument-inline-assembly | FileCheck %s
+# RUN: llvm-mc %s -triple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asm-instrumentation=address | FileCheck %s
 
   .text
   .globl  mov1b
   .align  16, 0x90
   .type mov1b,@function
 # CHECK-LABEL: mov1b:
 #
 # CHECK: subq $128, %rsp

test/Instrumentation/AddressSanitizer/X86/asm_mov_no_instrumentation.s

# BB#0:
   movb  %al, (%rdi)
 
   #NO_APP
   retq
 .Ltmp0:
   .size mov1b, .Ltmp0-mov1b
   .cfi_endproc
 
-  .globl  mov16b
-  .align  16, 0x90
-  .type mov16b,@function
-# CHECK-LABEL: mov16b
-# CHECK-NOT: callq __sanitizer_sanitize_load16@PLT
-# CHECK-NOT: callq __sanitizer_sanitize_store16@PLT
-mov16b:                                 # @mov16b
-  .cfi_startproc
-# BB#0:
-  #APP
-  movaps  (%rsi), %xmm0
-  movaps  %xmm0, (%rdi)
-
-  #NO_APP
-  retq
-.Ltmp1:
-  .size mov16b, .Ltmp1-mov16b
-  .cfi_endproc
-
-
   .ident  "clang version 3.5 "
   .section  ".note.GNU-stack","",@progbits

tools/llvm-mc/llvm-mc.cpp

 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/AsmLexer.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetAsmParser.h"
+#include "llvm/MC/MCTargetOptionsCommandFlags.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileUtilities.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
static int AsLexInput(SourceMgr &SrcMgr, MCAsmInfo &MAI, tool_output_file *Out) {
   }
 
   return Error;
 }
 
 static int AssembleInput(const char *ProgName, const Target *TheTarget,
                          SourceMgr &SrcMgr, MCContext &Ctx, MCStreamer &Str,
                          MCAsmInfo &MAI, MCSubtargetInfo &STI, MCInstrInfo &MCII) {
-  std::unique_ptr<MCAsmParser> Parser(createMCAsmParser(SrcMgr, Ctx, Str, MAI));
+  std::unique_ptr<MCAsmParser> Parser(
+      createMCAsmParser(SrcMgr, Ctx, Str, MAI));
   std::unique_ptr<MCTargetAsmParser> TAP(
-      TheTarget->createMCAsmParser(STI, *Parser, MCII));
+      TheTarget->createMCAsmParser(STI, *Parser, MCII,
+                                   InitMCTargetOptionsFromFlags()));
   if (!TAP) {
     errs() << ProgName
            << ": error: this target does not support assembly parsing.\n";
     return 1;
   }
 
   Parser->setShowParsedOperands(ShowInstOperands);
   Parser->setTargetParser(*TAP.get());