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

34

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

723

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

34

Done.

lib/Target/X86/AsmParser/X86AsmParser.cpp

723

Done.

[eugenis]

include/llvm/Transforms/Utils/SpecialCaseList.h

97

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

18

SanitizeAddress

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

24

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

31

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

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

18

Done.

24

Done.

31

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

include/llvm/Target/TargetMachine.h

111

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

21 ↗

(On Diff #8574)

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

21 ↗

(On Diff #8574)

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

static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.DisableTailCalls = DisableTailCalls;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.TrapFuncName = TrapFuncName;
   Options.PositionIndependentExecutable = EnablePIE;
   Options.EnableSegmentedStacks = SegmentedStacks;
   Options.UseInitArray = UseInitArray;
+
+  Options.MCOptions.InitFromFlags();
+
   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"
 
 namespace llvm {
-class MCStreamer;
-class StringRef;
-class SMLoc;
 class AsmToken;
-class MCParsedAsmOperand;
 class MCInst;
+class MCParsedAsmOperand;
+class MCStreamer;
+class MachineFunction;
+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;
 
+  /// Current MachineFunction.
+  const MachineFunction *MF;
+
 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;
   }
 
+  void setMachineFunction(const MachineFunction *MF) {
+    this->MF = MF;
+    onMachineFunctionSet();
+  }
+
+  virtual void onMachineFunctionSet() {}
+
   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

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 {
+
+namespace AsmInstrumentation {
+enum AsmInstrumentationMode {
+  None,   // No instrumentation at all.
+  Address // Instrument instructions with memory arguments.
+};
+}
+
+class MCTargetOptions {
+public:
+  /// AsmInstrumentationMode - This flag is sed by the
+  /// asm-instrumentation=mode option is specified on the command
+  /// line. This settings my either be None or Address.  None selects
+  /// no instrumentation at all. Address selects AddressSanitizer
+  /// instrumentation.
+  AsmInstrumentation::AsmInstrumentationMode AsmInstrumentationMode;
+
+  MCTargetOptions();
+  void InitFromFlags();
+};
+
+inline bool operator==(const MCTargetOptions &LHS, const MCTargetOptions &RHS) {
+#define ARE_EQUAL(X) LHS.X == RHS.X
+  return ARE_EQUAL(AsmInstrumentationMode);
+#undef ARE_EQUAL
+}
+
+inline bool operator!=(const MCTargetOptions &LHS, const MCTargetOptions &RHS) {
+  return !(LHS == RHS);
+}
+
+} // end namespace llvm
+
+#endif

include/llvm/Target/TargetMachine.h

public:
   /// getSubtargetImpl - virtual method implemented by subclasses that returns
   /// a reference to that target's TargetSubtargetInfo-derived member variable.
   virtual const TargetSubtargetInfo *getSubtargetImpl() const { return 0; }
 
   mutable TargetOptions Options;
 
   /// \brief Reset the target options based on the function's attributes.
   void resetTargetOptions(const MachineFunction *MF) const;
+  const TargetOptions &getTargetOptions() const { return Options; }
 
   // Interfaces to the major aspects of target machine information:
   //
   // -- Instruction opcode and operand information
   // -- Pipelines and scheduling information
   // -- Stack frame information
   // -- Selection DAG lowering information
   //

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(EnableSegmentedStacks) &&
     ARE_EQUAL(UseInitArray) &&
     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

include/llvm/Transforms/Utils/SpecialCaseList.h

public:
   /// would be.  Similarly, aliases of globals are matched like globals.
   bool isIn(const GlobalAlias &GA,
             const StringRef Category = StringRef()) const;
 
   /// Returns whether this module is listed in the given category, which may be
   /// omitted to search the empty category.
   bool isIn(const Module &M, const StringRef Category = StringRef()) const;
 
+  bool isSourceFileIn(const StringRef FileName) const;
+
  private:
   SpecialCaseList(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
   SpecialCaseList &operator=(SpecialCaseList const &) LLVM_DELETED_FUNCTION;
 
   struct Entry;
   StringMap<StringMap<Entry> > Entries;
 
   SpecialCaseList();

lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp

void AsmPrinter::EmitInlineAsm(StringRef Str, const MDNode *LocMDNode,
   // emitInlineAsmEnd().
   MCSubtargetInfo STIOrig = *STI;
 
   std::unique_ptr<MCTargetAsmParser> TAP(
       TM.getTarget().createMCAsmParser(*STI, *Parser, *MII));
   if (!TAP)
     report_fatal_error("Inline asm not supported by this streamer because"
                        " we don't have an asm parser for this target\n");
+  TAP->setMachineFunction(MF);
   Parser->setAssemblerDialect(Dialect);
   Parser->setTargetParser(*TAP.get());
 
   // Don't implicitly switch to the text section before the asm.
   int Res = Parser->Run(/*NoInitialTextSection*/ true,
                         /*NoFinalize*/ true);
   emitInlineAsmEnd(STIOrig, STI.get());
   if (Res && !HasDiagHandler)

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/MCParser/MCTargetAsmParser.cpp

 //===-- MCTargetAsmParser.cpp - Target Assembly Parser ---------------------==//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCTargetAsmParser.h"
 using namespace llvm;
 
 MCTargetAsmParser::MCTargetAsmParser()
-  : AvailableFeatures(0), ParsingInlineAsm(false)
+  : AvailableFeatures(0), ParsingInlineAsm(false), MF(NULL)
 {
 }
 
 MCTargetAsmParser::~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");
+
+  if (F->hasFnAttribute(Attribute::SanitizeAddress))
+    TO.MCOptions.AsmInstrumentationMode = AsmInstrumentation::Address;
+  else
+    TO.MCOptions.AsmInstrumentationMode = AsmInstrumentation::None;
 }
 
 /// 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

 //===- X86AsmInstrumentation.h - 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.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef X86_ASM_INSTRUMENTATION_H
 #define X86_ASM_INSTRUMENTATION_H
 
 #include "llvm/ADT/SmallVector.h"
 
 namespace llvm {
 
+class MachineFunction;
 class MCContext;
 class MCInst;
 class MCParsedAsmOperand;
 class MCStreamer;
 class MCSubtargetInfo;
 
 class X86AsmInstrumentation;
 
-X86AsmInstrumentation *CreateX86AsmInstrumentation(MCSubtargetInfo &STI);
+X86AsmInstrumentation *
+CreateX86AsmInstrumentation(const MachineFunction *MF, 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 MachineFunction *MF, 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/CodeGen/MachineFunction.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/MC/MCTargetOptions.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/MC/MCParser/MCParsedAsmOperand.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/Transforms/Utils/SpecialCaseList.h"
+#include <memory>
 
 namespace llvm {
 namespace {
 
-static cl::opt<bool> ClAsanInstrumentInlineAssembly(
-    "asan-instrument-inline-assembly", cl::desc("instrument inline assembly"),
-    cl::Hidden, cl::init(false));
+static cl::opt<std::string>
+ClAsanAsmBlacklist("asan-asm-blacklist",
+                   cl::desc("File containing the list of objects to ignore "
+                            "during asan instrumentation"),
+                   cl::Hidden);
 
 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 MachineFunction *MF, const MCContext &Ctx,
+                            const MCSubtargetInfo &STI) {
+  MCTargetOptions Options;
+  if (MF)
+    Options = MF->getTarget().getTargetOptions().MCOptions;
+  else
+    Options.InitFromFlags();
+  const Function *F = MF ? MF->getFunction() : 0;
+  if (Options.AsmInstrumentationMode == AsmInstrumentation::Address) {
+    std::unique_ptr<SpecialCaseList> BL(
+        SpecialCaseList::createOrDie(ClAsanAsmBlacklist));
+    if (BL->isSourceFileIn(Ctx.getMainFileName()))
+      ;
+    else if (F && BL->isIn(*F))
+      ;
+    else {
       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

 
 public:
   X86AsmParser(MCSubtargetInfo &sti, MCAsmParser &parser,
                const MCInstrInfo &MII)
       : MCTargetAsmParser(), STI(sti), Parser(parser), InstInfo(0) {
 
     // Initialize the set of available features.
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
-    Instrumentation.reset(CreateX86AsmInstrumentation(STI));
+    Instrumentation.reset(
+        CreateX86AsmInstrumentation(MF, Parser.getContext(), STI));
   }
+
+  void onMachineFunctionSet() override {
+    Instrumentation.reset(CreateX86AsmInstrumentation(MF, 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;
 };

lib/Transforms/Utils/SpecialCaseList.cpp

bool SpecialCaseList::isIn(const GlobalAlias &GA,
   return inSectionCategory("global", GA.getName(), Category) ||
          inSectionCategory("type", GetGlobalTypeString(GA), Category);
 }
 
 bool SpecialCaseList::isIn(const Module &M, const StringRef Category) const {
   return inSectionCategory("src", M.getModuleIdentifier(), Category);
 }
 
+bool SpecialCaseList::isSourceFileIn(const StringRef FileName) const {
+  return inSectionCategory("src", FileName, StringRef());
+}
+
 bool SpecialCaseList::inSectionCategory(const StringRef Section,
                                         const StringRef Query,
                                         const StringRef Category) const {
   StringMap<StringMap<Entry> >::const_iterator I = Entries.find(Section);
   if (I == Entries.end()) return false;
   StringMap<Entry>::const_iterator II = I->second.find(Category);
   if (II == I->second.end()) return false;
 
   return II->getValue().match(Query);
 }
 
 }  // namespace llvm

test/Instrumentation/AddressSanitizer/X86/asm_attr.ll

+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asm-instrumentation=address -asan-asm-blacklist=%s.blacklist | 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_blacklisted
+; CHECK-NOT: callq __sanitizer_sanitize_load8@PLT
+; CHECK-NOT: callq __sanitizer_sanitize_store8@PLT
+define void @mov_blacklisted(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
+}
+
+; 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_attr.ll.blacklist

+fun:*_blacklisted

test/Instrumentation/AddressSanitizer/X86/asm_blacklisted.s

-# RUN: llvm-mc %s -triple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 | FileCheck %s
+# RUN: llvm-mc %s -triple=x86_64-unknown-linux-gnu -mcpu=corei7 -mattr=+sse2 -asm-instrumentation=address -asan-asm-blacklist=%s.blacklist | FileCheck %s
 
   .text
   .globl  mov1b
   .align  16, 0x90
   .type mov1b,@function
 # CHECK-LABEL: mov1b
 # CHECK-NOT: callq __sanitizer_sanitize_load1@PLT
 # CHECK-NOT: callq __sanitizer_sanitize_store1@PLT
 mov1b:                                  # @mov1b
   .cfi_startproc
 # BB#0:
   #APP
   movb  (%rsi), %al
   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

test/Instrumentation/AddressSanitizer/X86/asm_blacklisted.s.blacklist

+src:*_blacklisted.s

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