Add sanitizer-specific GlobalValue attributes.

[hctim]

Summary

Plan is the migrate the global variable metadata for sanitizers, that's
currently carried around generally in the 'llvm.asan.globals' section,
onto the global variable itself.

This patch adds the attribute and plumbs it through the LLVM IR and
bitcode formats, but is a no-op other than that so far.

[hctim]

Add an extra Global creation path from the frontend, and fix up a comment from Kirill on the other revision.

[hctim]

Remove extra creation path, turns out it's a duplicate of elsewhere.

[hctim]

(friendly ping)

[kstoimenov]

LGTM, but get one from vitalybuka@ too.
Sorry about delayed review, I missed it. Next time ping me if I don't respond within a day.

llvm/lib/IR/Globals.cpp

225

Do we expect that 'this' is in the map? If so could you add an assert here using 'find' for example?

[vitalybuka]

all stuff under llvm/... here needs testing, Bitcode and AsmParser have many tests usable as examples

Also probably better to separate from clang changes:
Patch 1: extends LLVM IR
Patch 2: Integrate new LLVM IR feature into clang

LangRef.rst part will probably requires wider review. I suspect there will be strong opinions.
So maybe you can extract just a document into a 3rd patch.

Also it does not really document what new attributes do.

For review context you can organize them into Stack.

[hctim]

Add round-trip tests, fork out the clang and langref changes for further commits.

[hctim]

Also, the bitset now doesn't have positive-inclusions for ASan/HWASan, and no mention of MTE yet (which will come later). Sanitizers are applied to all GVs implicitly, so we only need to carry around the exclude masks. Added a comment to the struct that clarifies this.

[vitalybuka]

llvm/include/llvm/AsmParser/LLToken.h

440

it should be next to other kw_ stuff

llvm/include/llvm/IR/GlobalValue.h

123

It's subclass data, but you keep this data in this class.

316–328

331

get/set for each flag?

llvm/lib/AsmParser/LLParser.cpp

55

you should put these inside of fuctions where it's used.

1263

it would be nice to keep existing "else if" style one per kw
with separate set/get it should be easy

1280

why it's not a part of parseFnAttributeValuePairs ?

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

3547

Why DynInit has own record?

[hctim]

llvm/include/llvm/AsmParser/LLToken.h

440

hoisted them up

llvm/include/llvm/IR/GlobalValue.h

123

this is the spare bits over for the subclass to use. because we keep an additional bit in this class, we give one less bit out to the subclass.

331

as discussed offline, no point with our nice new members.

llvm/lib/AsmParser/LLParser.cpp

1263

i think there's enough commonality with the hasSanitizerMetadata() -> getSanitizerMetadata -> set flag -> setSanitizerMetadata -> lex that i'd normally opt to factor this out anyway. cleaned up the helper function using the new method of setting attributes though.

1280

as discussed offline, global attributes have different semantics / no generalized parsing, unlike functions

[hctim]

Update from Vitaly's comments.

[vitalybuka]

llvm/include/llvm/AsmParser/LLToken.h

181

Have you considered in Attributes.inc ?

/// Can be used as global attribute.
def GvAttr : AttrProperty;

llvm/include/llvm/IR/GlobalValue.h

329

serialization should not be in this header, this bit stuff is /Bitcode/ specific, both should be there

llvm/lib/AsmParser/LLLexer.cpp

583

redundant comment, obvious from the name

llvm/lib/IR/AsmWriter.cpp

3540

AsmWriter/Parser should be tested in llvm-project/llvm/test/Assembler/
e.g. Assembler/diglobalvariable.ll

[vitalybuka]

LGTM, with Asm test and bitcode stuff moved as explained.

[hctim]

Update w/ Vitaly's comments.

llvm/include/llvm/AsmParser/LLToken.h

181

I took a look at this, but adding GV support to Attributes.inc requires a lot more plumbing. There's bits to be added to Verifier.cpp, LLParser.cpp, LLLexer.cpp, Attributes.cpp, etc. I think it's better to leave that as a future refactoring exercise, along with the rest of the GV attributes.

llvm/lib/IR/AsmWriter.cpp

3540

/s/diglobalvariable/globalvariable-attributes, done

also tested in compatibility.ll

[vitalybuka]

llvm/include/llvm/IR/GlobalValue.h

329

serialization should not be in this header, this bit stuff is /Bitcode/ specific, both should be there

I don't see it's done

llvm/lib/IR/AsmWriter.cpp

3543–3552

even if it looks redundant I would not recommend to optimize here,
AsmWriter should not care about semantics. if you let SanitizerMetadata assign this way, then AsmWriter should store it as is.

llvm/lib/IR/Globals.cpp

70

It should copy unconditionally.
E.g. if "this" had Metadata, but src does not , it must be reset here.

231

[vitalybuka]

llvm/include/llvm/AsmParser/LLToken.h

397

do we need no_sanitize on IR level?
We should map it to particular no_sanitize_nnnnn

[vitalybuka]

rebase

[vitalybuka]

fix rebase (mostly undo)
I didn't plan to update anything here, and somehow uploaded D126929 here by mistake

[hctim]

llvm/include/llvm/AsmParser/LLToken.h

397

Removed and mapped it to the no_sanitize_*.

llvm/include/llvm/IR/GlobalValue.h

329

hmm, yeah, sorry bout that. bad upload i guess.

llvm/lib/IR/AsmWriter.cpp

3543–3552

roger, done

llvm/lib/IR/Globals.cpp

70

thanks for the catch.

we do have an invariant about "don't call getSanitizerMetadata when HasSanitizerMetada is false", and i'd rather not force these structs to be stored if there's no metadata, but i have fixed the issue.

231

as above, rather not waste memory on structs if they don't exist, so keeping the invariant

[hctim]

Update.

[vitalybuka]

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

1379

I guess VBR encoding does not like UINT_MAX, it will occupy more space then unconditional pushback.
Please use the same approach as: Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);

llvm/include/llvm/AsmParser/LLParser.h

private:
     // Constant Parsing.
     bool parseValID(ValID &ID, PerFunctionState *PFS,
                     Type *ExpectedTy = nullptr);
     bool parseGlobalValue(Type *Ty, Constant *&C);
     bool parseGlobalTypeAndValue(Constant *&V);
     bool parseGlobalValueVector(SmallVectorImpl<Constant *> &Elts,
                                 Optional<unsigned> *InRangeOp = nullptr);
     bool parseOptionalComdat(StringRef GlobalName, Comdat *&C);
+    bool parseSanitizer(GlobalVariable *GV);
     bool parseMetadataAsValue(Value *&V, PerFunctionState &PFS);
     bool parseValueAsMetadata(Metadata *&MD, const Twine &TypeMsg,
                               PerFunctionState *PFS);
     bool parseMetadata(Metadata *&MD, PerFunctionState *PFS);
     bool parseMDTuple(MDNode *&MD, bool IsDistinct = false);
     bool parseMDNode(MDNode *&N);
     bool parseMDNodeTail(MDNode *&N);
     bool parseMDNodeVector(SmallVectorImpl<Metadata *> &Elts);

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_amdgpu_gfx,
   kw_tailcc,
 
   // Attributes:
   kw_attributes,
   kw_sync,
   kw_async,
 #define GET_ATTR_NAMES
 #define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
   kw_##DISPLAY_NAME,
 #include "llvm/IR/Attributes.inc"
 
   kw_type,
   kw_opaque,
 
   kw_comdat,
 
#include "llvm/IR/Attributes.inc"
   kw_uniformRetVal,
   kw_uniqueRetVal,
   kw_virtualConstProp,
   kw_info,
   kw_byte,
   kw_bit,
   kw_varFlags,
 
+  // Extra sanitizer attributes that are used for global variables (GV's).
+  // GV's mentioned in -fsanitize-ignorelist=<file>.
+  kw_no_sanitize,
+  // GV's with __attribute__((no_sanitize("address"))).
+  kw_no_sanitize_address,
+  // GV's where the clang++ frontend (when ASan is used) notes that this is
+  // dynamically initialized, and thus needs ODR detection.
+  kw_sanitize_address_dyninit,
+  // GV's with __attribute__((no_sanitize("hwaddress"))).
+  kw_no_sanitize_hwaddress,
+
   // Unsigned Valued tokens (UIntVal).
   LabelID,    // 42:
   GlobalID,   // @42
   LocalVarID, // %42
   AttrGrpID,  // #42
   SummaryID,  // ^42
 
   // String valued tokens (StrVal).
#include "llvm/IR/Attributes.inc"
 
   // Type valued tokens (TyVal).
   Type,
 
   APFloat, // APFloatVal
   APSInt   // APSInt
 };
 } // end namespace lltok
 } // end namespace llvm
 
 #endif

llvm/include/llvm/IR/GlobalValue.h

 
 protected:
   GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
               LinkageTypes Linkage, const Twine &Name, unsigned AddressSpace)
       : Constant(PointerType::get(Ty, AddressSpace), VTy, Ops, NumOps),
         ValueType(Ty), Visibility(DefaultVisibility),
         UnnamedAddrVal(unsigned(UnnamedAddr::None)),
         DllStorageClass(DefaultStorageClass), ThreadLocal(NotThreadLocal),
-        HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false) {
+        HasLLVMReservedName(false), IsDSOLocal(false), HasPartition(false),
+        HasSanitizerMetadata(false) {
     setLinkage(Linkage);
     setName(Name);
   }
 
   Type *ValueType;
 
-  static const unsigned GlobalValueSubClassDataBits = 16;
+  static const unsigned GlobalValueSubClassDataBits = 15;
 
   // All bitfields use unsigned as the underlying type so that MSVC will pack
   // them.
   unsigned Linkage : 4;       // The linkage of this global
   unsigned Visibility : 2;    // The visibility style of this global
   unsigned UnnamedAddrVal : 2; // This value's address is not significant
   unsigned DllStorageClass : 2; // DLL storage class
 
   unsigned ThreadLocal : 3; // Is this symbol "Thread Local", if so, what is
                             // the desired model?
 
   /// True if the function's name starts with "llvm.".  This corresponds to the
   /// value of Function::isIntrinsic(), which may be true even if
   /// Function::intrinsicID() returns Intrinsic::not_intrinsic.
   unsigned HasLLVMReservedName : 1;
 
   /// If true then there is a definition within the same linkage unit and that
   /// definition cannot be runtime preempted.
   unsigned IsDSOLocal : 1;
 
   /// True if this symbol has a partition name assigned (see
   /// https://lld.llvm.org/Partitions.html).
   unsigned HasPartition : 1;
 
+  /// True if this symbol has sanitizer metadata available. Should only happen
+  /// if sanitizers were enabled when building the translation unit which
+  /// contains this GV.
+  unsigned HasSanitizerMetadata : 1;
+
 private:
   // Give subclasses access to what otherwise would be wasted padding.
-  // (16 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1) == 32.
+  // (15 + 4 + 2 + 2 + 2 + 3 + 1 + 1 + 1 + 1) == 32.
   unsigned SubClassData : GlobalValueSubClassDataBits;
 
   friend class Constant;
 
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To);
 
   /// Returns true if the definition of this global may be replaced by a
   /// differently optimized variant of the same source level function at link
public:
   }
 
   bool hasPartition() const {
     return HasPartition;
   }
   StringRef getPartition() const;
   void setPartition(StringRef Part);
 
+  // ASan, HWASan and Memtag sanitizers have some instrumentation that applies
+  // specifically to global variables. This instrumentation is implicitly
+  // applied to all global variables when built with -fsanitize=*. What we need
+  // is a way to persist the information that a certain global variable should
+  // *not* have sanitizers applied, which occurs if:
+  //   1. The global variable is in the sanitizer ignore list, or
+  //   2. The global variable is created by the sanitizers itself for internal
+  //      usage, or
+  //   3. The global variable has __attribute__((no_sanitize("..."))) or
+  //      __attribute__((disable_sanitizer_instrumentation)).
+  //
+  // This is important, a some IR passes like GlobalMerge can delete global
+  // variables and replace them with new ones. If the old variables were marked
+  // to be unsanitized, then the new ones should also be.
+  struct SanitizerMetadata {
+    SanitizerMetadata()
+        : NoSanitize(false), NoAddress(false), NoHWAddress(false),
+          NoMemtag(false), IsDynInit(false) {}
+    unsigned NoSanitize : 1;
+    unsigned NoAddress : 1;
+    unsigned NoHWAddress : 1;
+    unsigned NoMemtag : 1;
+
+    // ASan-specific metadata. Is this global variable dynamically initialized
+    // (from a C++ language perspective), and should therefore be checked for
+    // ODR violations.
+    unsigned IsDynInit : 1;
+
+    unsigned serialize() const {
+      return NoSanitize | (NoAddress << 1) | (NoHWAddress << 2) |
+             (NoMemtag << 3) | (IsDynInit << 4);
+    }
+    void deserialize(unsigned V) {
+      if (V & (1 << 0)) NoSanitize = true;
+      if (V & (1 << 1)) NoAddress = true;
+      if (V & (1 << 2)) NoHWAddress = true;
+      if (V & (1 << 3)) NoMemtag = true;
+      if (V & (1 << 4)) IsDynInit = true;
+    }
+  };
+  static_assert(sizeof(SanitizerMetadata) <= sizeof(unsigned),
+                "Sanitizer Metadata is too large for naive serialization.");
+
+  bool hasSanitizerMetadata() const { return HasSanitizerMetadata; }
+  const SanitizerMetadata &getSanitizerMetadata() const;
+  void setSanitizerMetadata(const SanitizerMetadata &Meta);
+
   static LinkageTypes getLinkOnceLinkage(bool ODR) {
     return ODR ? LinkOnceODRLinkage : LinkOnceAnyLinkage;
   }
   static LinkageTypes getWeakLinkage(bool ODR) {
     return ODR ? WeakODRLinkage : WeakAnyLinkage;
   }
 
   static bool isExternalLinkage(LinkageTypes Linkage) {

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(module);
   KEYWORD(asm);
   KEYWORD(sideeffect);
   KEYWORD(inteldialect);
   KEYWORD(gc);
   KEYWORD(prefix);
   KEYWORD(prologue);
 
+  // Sanitizer keywords.
+  KEYWORD(no_sanitize);
+  KEYWORD(no_sanitize_address);
+  KEYWORD(no_sanitize_hwaddress);
+  KEYWORD(sanitize_address_dyninit);
+
   KEYWORD(ccc);
   KEYWORD(fastcc);
   KEYWORD(coldcc);
   KEYWORD(cfguard_checkcc);
   KEYWORD(x86_stdcallcc);
   KEYWORD(x86_fastcallcc);
   KEYWORD(x86_thiscallcc);
   KEYWORD(x86_vectorcallcc);

llvm/lib/AsmParser/LLParser.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
 #include <vector>
 
 using namespace llvm;
 
 static std::string getTypeString(Type *T) {
   std::string Result;
   raw_string_ostream Tmp(Result);
   Tmp << *T;
   return Tmp.str();
 }
 
 static void setContextOpaquePointers(LLLexer &L, LLVMContext &C) {
   while (true) {
if (IsAlias)
     M->getAliasList().push_back(GA.release());
   else
     M->getIFuncList().push_back(GI.release());
   assert(GV->getName() == Name && "Should not be a name conflict!");
 
   return false;
 }
 
+static bool isSanitizer(lltok::Kind Kind) {
+  switch (Kind) {
+  case lltok::kw_no_sanitize:
+  case lltok::kw_no_sanitize_address:
+  case lltok::kw_no_sanitize_hwaddress:
+  case lltok::kw_sanitize_address_dyninit:
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool LLParser::parseSanitizer(GlobalVariable *GV) {
+  using SanitizerMetadata = GlobalValue::SanitizerMetadata;
+  SanitizerMetadata Meta;
+  if (GV->hasSanitizerMetadata())
+    Meta = GV->getSanitizerMetadata();
+
+  switch (Lex.getKind()) {
+  case lltok::kw_no_sanitize:
+    Meta.NoSanitize = true;
+    break;
+  case lltok::kw_no_sanitize_address:
+    Meta.NoAddress = true;
+    break;
+  case lltok::kw_no_sanitize_hwaddress:
+    Meta.NoHWAddress = true;
+    break;
+  case lltok::kw_sanitize_address_dyninit:
+    Meta.IsDynInit = true;
+    break;
+  default:
+    return tokError("non-sanitizer token passed to LLParser::parseSanitizer()");
+  }
+  GV->setSanitizerMetadata(Meta);
+  Lex.Lex();
+  return false;
+}
+
 /// parseGlobal
 ///   ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
 ///       OptionalVisibility OptionalDLLStorageClass
 ///       OptionalThreadLocal OptionalUnnamedAddr OptionalAddrSpace
 ///       OptionalExternallyInitialized GlobalType Type Const OptionalAttrs
 ///   ::= OptionalLinkage OptionalPreemptionSpecifier OptionalVisibility
 ///       OptionalDLLStorageClass OptionalThreadLocal OptionalUnnamedAddr
 ///       OptionalAddrSpace OptionalExternallyInitialized GlobalType Type
while (Lex.getKind() == lltok::comma) {
     } else if (Lex.getKind() == lltok::kw_align) {
       MaybeAlign Alignment;
       if (parseOptionalAlignment(Alignment))
         return true;
       GV->setAlignment(Alignment);
     } else if (Lex.getKind() == lltok::MetadataVar) {
       if (parseGlobalObjectMetadataAttachment(*GV))
         return true;
+    } else if (isSanitizer(Lex.getKind())) {
+      if (parseSanitizer(GV))
+        return true;
     } else {
       Comdat *C;
       if (parseOptionalComdat(Name, C))
         return true;
       if (C)
         GV->setComdat(C);
       else
         return tokError("unknown global variable property!");
     }
   }
 
   AttrBuilder Attrs(M->getContext());
   LocTy BuiltinLoc;
   std::vector<unsigned> FwdRefAttrGrps;
   if (parseFnAttributeValuePairs(Attrs, FwdRefAttrGrps, false, BuiltinLoc))
     return true;
   if (Attrs.hasAttributes() || !FwdRefAttrGrps.empty()) {
     GV->setAttributes(AttributeSet::get(Context, Attrs));
     ForwardRefAttrGroups[GV] = FwdRefAttrGrps;
   }
 
   return false;
 }

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

if (Record.size() > 13) {
     NewGV->setDSOLocal(getDecodedDSOLocal(Record[13]));
   }
   inferDSOLocal(NewGV);
 
   // Check whether we have enough values to read a partition name.
   if (Record.size() > 15)
     NewGV->setPartition(StringRef(Strtab.data() + Record[14], Record[15]));
 
+  if (Record.size() > 16 && Record[16] != UINT_MAX) {
+    llvm::GlobalValue::SanitizerMetadata Meta;
+    Meta.deserialize(Record[16]);
+    NewGV->setSanitizerMetadata(Meta);
+  }
+
   return Error::success();
 }
 
 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
   // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
   // prefixdata,  personalityfn, preemption specifier, addrspace] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeModuleInfo() {
 
   // Emit the global variable information.
   for (const GlobalVariable &GV : M.globals()) {
     unsigned AbbrevToUse = 0;
 
     // GLOBALVAR: [strtab offset, strtab size, type, isconst, initid,
     //             linkage, alignment, section, visibility, threadlocal,
     //             unnamed_addr, externally_initialized, dllstorageclass,
-    //             comdat, attributes, DSO_Local]
+    //             comdat, attributes, DSO_Local, GlobalSanitizer]
     Vals.push_back(addToStrtab(GV.getName()));
     Vals.push_back(GV.getName().size());
     Vals.push_back(VE.getTypeID(GV.getValueType()));
     Vals.push_back(GV.getType()->getAddressSpace() << 2 | 2 | GV.isConstant());
     Vals.push_back(GV.isDeclaration() ? 0 :
                    (VE.getValueID(GV.getInitializer()) + 1));
     Vals.push_back(getEncodedLinkage(GV));
     Vals.push_back(getEncodedAlign(GV.getAlign()));
     Vals.push_back(GV.hasSection() ? SectionMap[std::string(GV.getSection())]
                                    : 0);
     if (GV.isThreadLocal() ||
         GV.getVisibility() != GlobalValue::DefaultVisibility ||
         GV.getUnnamedAddr() != GlobalValue::UnnamedAddr::None ||
         GV.isExternallyInitialized() ||
         GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
-        GV.hasComdat() ||
-        GV.hasAttributes() ||
-        GV.isDSOLocal() ||
-        GV.hasPartition()) {
+        GV.hasComdat() || GV.hasAttributes() || GV.isDSOLocal() ||
+        GV.hasPartition() || GV.hasSanitizerMetadata()) {
       Vals.push_back(getEncodedVisibility(GV));
       Vals.push_back(getEncodedThreadLocalMode(GV));
       Vals.push_back(getEncodedUnnamedAddr(GV));
       Vals.push_back(GV.isExternallyInitialized());
       Vals.push_back(getEncodedDLLStorageClass(GV));
       Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
 
       auto AL = GV.getAttributesAsList(AttributeList::FunctionIndex);
       Vals.push_back(VE.getAttributeListID(AL));
 
       Vals.push_back(GV.isDSOLocal());
       Vals.push_back(addToStrtab(GV.getPartition()));
       Vals.push_back(GV.getPartition().size());
+
+      if (GV.hasSanitizerMetadata())
+        Vals.push_back(GV.getSanitizerMetadata().serialize());
+      else
+        Vals.push_back(UINT_MAX);
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 

llvm/lib/IR/AsmWriter.cpp

if (GV->hasSection()) {
     Out << '"';
   }
   if (GV->hasPartition()) {
     Out << ", partition \"";
     printEscapedString(GV->getPartition(), Out);
     Out << '"';
   }
 
+  using SanitizerMetadata = llvm::GlobalValue::SanitizerMetadata;
+  if (GV->hasSanitizerMetadata()) {
+    SanitizerMetadata MD = GV->getSanitizerMetadata();
+    if (MD.NoSanitize) {
+      Out << ", no_sanitize";
+    } else {
+      if (MD.NoAddress)
+        Out << ", no_sanitize_address";
+      if (MD.NoHWAddress)
+        Out << ", no_sanitize_hwaddress";
+      if (MD.IsDynInit)
+        Out << ", sanitize_address_dyninit";
+    }
+  }
+
   maybePrintComdat(Out, *GV);
   if (MaybeAlign A = GV->getAlign())
     Out << ", align " << A->value();
 
   SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
   GV->getAllMetadata(MDs);
   printMetadataAttachments(MDs, ", ");
 

llvm/lib/IR/Globals.cpp

 /// create a GlobalValue) from the GlobalValue Src to this one.
 void GlobalValue::copyAttributesFrom(const GlobalValue *Src) {
   setVisibility(Src->getVisibility());
   setUnnamedAddr(Src->getUnnamedAddr());
   setThreadLocalMode(Src->getThreadLocalMode());
   setDLLStorageClass(Src->getDLLStorageClass());
   setDSOLocal(Src->isDSOLocal());
   setPartition(Src->getPartition());
+  if (Src->hasSanitizerMetadata())
+    setSanitizerMetadata(Src->getSanitizerMetadata());
 }
 
 void GlobalValue::removeFromParent() {
   switch (getValueID()) {
 #define HANDLE_GLOBAL_VALUE(NAME)                                              \
   case Value::NAME##Val:                                                       \
     return static_cast<NAME *>(this)->removeFromParent();
 #include "llvm/IR/Value.def"
if (!S.empty())
     S = getContext().pImpl->Saver.save(S);
   getContext().pImpl->GlobalValuePartitions[this] = S;
 
   // Update the HasPartition field. Setting the partition to the empty string
   // means this global no longer has a partition.
   HasPartition = !S.empty();
 }
 
+using SanitizerMetadata = GlobalValue::SanitizerMetadata;
+const SanitizerMetadata &GlobalValue::getSanitizerMetadata() const {
+  assert(hasSanitizerMetadata());
+  assert(getContext().pImpl->GlobalValueSanitizerMetadata.count(this));
+  return getContext().pImpl->GlobalValueSanitizerMetadata[this];
+}
+
+void GlobalValue::setSanitizerMetadata(const SanitizerMetadata &Meta) {
+  getContext().pImpl->GlobalValueSanitizerMetadata[this] = Meta;
+  HasSanitizerMetadata = true;
+}
+
 StringRef GlobalObject::getSectionImpl() const {
   assert(hasSection());
   return getContext().pImpl->GlobalObjectSections[this];
 }
 
 void GlobalObject::setSection(StringRef S) {
   // Do nothing if we're clearing the section and it is already empty.
   if (!hasSection() && S.empty())

llvm/lib/IR/LLVMContextImpl.h

#include "llvm/IR/Metadata.def"
   DenseMap<const Value *, MDAttachments> ValueMetadata;
 
   /// Collection of per-GlobalObject sections used in this context.
   DenseMap<const GlobalObject *, StringRef> GlobalObjectSections;
 
   /// Collection of per-GlobalValue partitions used in this context.
   DenseMap<const GlobalValue *, StringRef> GlobalValuePartitions;
 
+  DenseMap<const GlobalValue *, GlobalValue::SanitizerMetadata>
+      GlobalValueSanitizerMetadata;
+
   /// DiscriminatorTable - This table maps file:line locations to an
   /// integer representing the next DWARF path discriminator to assign to
   /// instructions in different blocks at the same location.
   DenseMap<std::pair<const char *, unsigned>, unsigned> DiscriminatorTable;
 
   /// A set of interned tags for operand bundles.  The StringMap maps
   /// bundle tags to their IDs.
   ///

llvm/test/Assembler/globalvariable-attributes.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 
 @g1 = global i32 7 "key" = "value" "key2" = "value2"
 @g2 = global i32 2, align 4 "key3" = "value3"
 @g3 = global i32 2 #0
 @g4 = global i32 2, align 4 "key5" = "value5" #0
+@g5 = global i32 2, no_sanitize, align 4
+@g6 = global i32 2, no_sanitize_address, align 4
+@g7 = global i32 2, no_sanitize_hwaddress, align 4
+@g8 = global i32 2, no_sanitize_address, no_sanitize_hwaddress, align 4
+@g9 = global i32 2, no_sanitize, no_sanitize_address, no_sanitize_hwaddress, align 4
 
 attributes #0 = { "string" = "value" nobuiltin norecurse }
 
 ; CHECK: @g1 = global i32 7 #0
 ; CHECK: @g2 = global i32 2, align 4 #1
 ; CHECK: @g3 = global i32 2 #2
 ; CHECK: @g4 = global i32 2, align 4 #3
+; CHECK: @g5 = global i32 2, no_sanitize, align 4
+; CHECK: @g6 = global i32 2, no_sanitize_address, align 4
+; CHECK: @g7 = global i32 2, no_sanitize_hwaddress, align 4
+; CHECK: @g8 = global i32 2, no_sanitize_address, no_sanitize_hwaddress, align 4
+
+;; no_sanitize attribute should override and turncate other sanitize_* attrs.
+; CHECK: @g9 = global i32 2, no_sanitize, align 4
+; CHECK-NOT: no_sanitize_address
+; CHECK-NOT: no_sanitize_hwaddress
 
 ; CHECK: attributes #0 = { "key"="value" "key2"="value2" }
 ; CHECK: attributes #1 = { "key3"="value3" }
 ; CHECK: attributes #2 = { nobuiltin norecurse "string"="value" }
 ; CHECK: attributes #3 = { nobuiltin norecurse "key5"="value5" "string"="value" }
 

llvm/test/Bitcode/compatibility.ll

 ; CHECK: @llvm.used = appending global [1 x i32*] [i32* @g.used1], section "llvm.metadata"
 @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 ; CHECK: @llvm.compiler.used = appending global [1 x i32*] [i32* @g.used2], section "llvm.metadata"
 @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_ctors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 ; CHECK: @llvm.global_dtors = appending global [1 x %pri.func.data] [%pri.func.data { i32 0, void ()* @g.f1, i8* @g.used3 }], section "llvm.metadata"
 
+; Global Variables -- sanitizers
[e-mail]_sanitize = global i32 0, no_sanitize
[e-mail]_sanitize_address = global i32 0, no_sanitize_address
[e-mail]_sanitize_hwaddress = global i32 0, no_sanitize_hwaddress
[e-mail]_address_dyninit = global i32 0, sanitize_address_dyninit
+; CHECK: @g.no_sanitize = global i32 0, no_sanitize
+; CHECK: @g.no_sanitize_address = global i32 0, no_sanitize_address
+; CHECK: @g.no_sanitize_hwaddress = global i32 0, no_sanitize_hwaddress
+; CHECK: @g.sanitize_address_dyninit = global i32 0, sanitize_address_dyninit
+
 ;; Aliases
 ; Format: @<Name> = [Linkage] [Visibility] [DLLStorageClass] [ThreadLocal]
 ;                   [unnamed_addr] alias <AliaseeTy> @<Aliasee>
 
 ; Aliases -- Linkage
 @a.private = private alias i32, i32* @g.private
 ; CHECK: @a.private = private alias i32, i32* @g.private
 @a.internal = internal alias i32, i32* @g.internal