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

429

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.

1286

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

1303

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

429

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

1286

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.

1303

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

3543

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

3543

/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

3546–3555

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

3546–3555

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

1380

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);

clang/lib/CodeGen/CGDecl.cpp

void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
   //
   // FIXME: It is really dangerous to store this in the map; if anyone
   // RAUW's the GV uses of this constant will be invalid.
   llvm::Constant *castedAddr =
     llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(var, expectedType);
   LocalDeclMap.find(&D)->second = Address(castedAddr, elemTy, alignment);
   CGM.setStaticLocalDeclAddress(&D, castedAddr);
 
-  CGM.getSanitizerMetadata()->reportGlobalToASan(var, D);
+  CGM.getSanitizerMetadata()->reportGlobal(var, D);
 
   // Emit global variable debug descriptor for static vars.
   CGDebugInfo *DI = getDebugInfo();
   if (DI && CGM.getCodeGenOpts().hasReducedDebugInfo()) {
     DI->setLocation(D.getLocation());
     DI->EmitGlobalVariable(var, &D);
   }
 }

clang/lib/CodeGen/CodeGenModule.cpp

if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
     return NoSanitizeL.containsFile(Kind, MainFile->getName());
   }
   return false;
 }
 
 bool CodeGenModule::isInNoSanitizeList(llvm::GlobalVariable *GV,
                                        SourceLocation Loc, QualType Ty,
                                        StringRef Category) const {
-  // For now globals can be ignored only in ASan and KASan.
-  const SanitizerMask EnabledAsanMask =
-      LangOpts.Sanitize.Mask &
-      (SanitizerKind::Address | SanitizerKind::KernelAddress |
-       SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
-       SanitizerKind::MemTag);
-  if (!EnabledAsanMask)
-    return false;
   const auto &NoSanitizeL = getContext().getNoSanitizeList();
-  if (NoSanitizeL.containsGlobal(EnabledAsanMask, GV->getName(), Category))
+  if (NoSanitizeL.containsGlobal(LangOpts.Sanitize.Mask, GV->getName(), Category))
     return true;
-  if (NoSanitizeL.containsLocation(EnabledAsanMask, Loc, Category))
+  if (NoSanitizeL.containsLocation(LangOpts.Sanitize.Mask, Loc, Category))
     return true;
   // Check global type.
   if (!Ty.isNull()) {
     // Drill down the array types: if global variable of a fixed type is
     // not sanitized, we also don't instrument arrays of them.
     while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
       Ty = AT->getElementType();
     Ty = Ty.getCanonicalType().getUnqualifiedType();
     // Only record types (classes, structs etc.) are ignored.
     if (Ty->isRecordType()) {
       std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
-      if (NoSanitizeL.containsType(EnabledAsanMask, TypeStr, Category))
+      if (NoSanitizeL.containsType(LangOpts.Sanitize.Mask, TypeStr, Category))
         return true;
     }
   }
   return false;
 }
 
 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
                                    StringRef Category) const {
#endif
   }
 
   maybeSetTrivialComdat(*D, *GV);
 
   // Emit the initializer function if necessary.
   if (NeedsGlobalCtor || NeedsGlobalDtor)
     EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
 
-  SanitizerMD->reportGlobalToASan(GV, *D, NeedsGlobalCtor);
+  SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
 
   // Emit global variable debug information.
   if (CGDebugInfo *DI = getModuleDebugInfo())
     if (getCodeGenOpts().hasReducedDebugInfo())
       DI->EmitGlobalVariable(GV, D);
 }
 
 void CodeGenModule::EmitExternalVarDeclaration(const VarDecl *D) {
CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
 
   CGDebugInfo *DI = getModuleDebugInfo();
   if (DI && getCodeGenOpts().hasReducedDebugInfo())
     DI->AddStringLiteralDebugInfo(GV, S);
 
   if (Entry)
     *Entry = GV;
 
-  SanitizerMD->reportGlobalToASan(GV, S->getStrTokenLoc(0), "<string literal>",
+  SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0), "<string literal>",
                                   QualType());
 
   return ConstantAddress(castStringLiteralToDefaultAddressSpace(*this, GV),
                          GV->getValueType(), Alignment);
 }
 
 /// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
 /// array for the given ObjCEncodeExpr node.

clang/lib/CodeGen/SanitizerMetadata.h

 //===--- SanitizerMetadata.h - Metadata for sanitizers ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Class which emits metadata consumed by sanitizer instrumentation passes.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_LIB_CODEGEN_SANITIZERMETADATA_H
 #define LLVM_CLANG_LIB_CODEGEN_SANITIZERMETADATA_H
 
 #include "clang/AST/Type.h"
 #include "clang/Basic/LLVM.h"
+#include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/SourceLocation.h"
 
+#include "llvm/IR/GlobalVariable.h"
+
 namespace llvm {
-class GlobalVariable;
 class Instruction;
 class MDNode;
-}
+} // namespace llvm
 
 namespace clang {
 class VarDecl;
 
 namespace CodeGen {
 
 class CodeGenModule;
 
 class SanitizerMetadata {
   SanitizerMetadata(const SanitizerMetadata &) = delete;
   void operator=(const SanitizerMetadata &) = delete;
 
   CodeGenModule &CGM;
+
 public:
   SanitizerMetadata(CodeGenModule &CGM);
-  void reportGlobalToASan(llvm::GlobalVariable *GV, const VarDecl &D,
-                          bool IsDynInit = false);
-  void reportGlobalToASan(llvm::GlobalVariable *GV, SourceLocation Loc,
-                          StringRef Name, QualType Ty, bool IsDynInit = false,
-                          bool IsExcluded = false);
+  void reportGlobal(llvm::GlobalVariable *GV, const VarDecl &D,
+  void reportGlobal(llvm::GlobalVariable *GV, SourceLocation Loc,
+                    SanitizerMask NoSanitizeMask = {});
   void disableSanitizerForGlobal(llvm::GlobalVariable *GV);
   void disableSanitizerForInstruction(llvm::Instruction *I);
+
 private:
   llvm::MDNode *getLocationMetadata(SourceLocation Loc);
+  void setASanSpecificMetadata(llvm::GlobalVariable::SanitizerMetadata &Meta,
+                               llvm::GlobalVariable *GV, SourceLocation Loc,
+                               QualType Ty, bool IsDynInit = false);
 };
-}  // end namespace CodeGen
-}  // end namespace clang
+} // end namespace CodeGen
+} // end namespace clang
 
 #endif

clang/lib/CodeGen/SanitizerMetadata.cpp

 #include "SanitizerMetadata.h"
 #include "CodeGenModule.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Constants.h"
 
+using GlobalVariable = llvm::GlobalVariable;
+using GVSanitizerMetadata = GlobalVariable::SanitizerMetadata;
+using GlobalSanitizer = GVSanitizerMetadata::GlobalSanitizer;
+
 using namespace clang;
 using namespace CodeGen;
 
 SanitizerMetadata::SanitizerMetadata(CodeGenModule &CGM) : CGM(CGM) {}
 
-static bool isAsanHwasanOrMemTag(const SanitizerSet& SS) {
+static bool isAsanHwasanOrMemTag(const SanitizerSet &SS) {
   return SS.hasOneOf(SanitizerKind::Address | SanitizerKind::KernelAddress |
                      SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
                      SanitizerKind::MemTag);
 }
 
-void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
-                                           SourceLocation Loc, StringRef Name,
-                                           QualType Ty, bool IsDynInit,
-                                           bool IsExcluded) {
-  if (!isAsanHwasanOrMemTag(CGM.getLangOpts().Sanitize))
-    return;
+void SanitizerMetadata::setASanSpecificMetadata(GVSanitizerMetadata &Meta,
+                                                GlobalVariable *GV,
+                                                SourceLocation Loc, QualType Ty,
+                                                bool IsDynInit) {
   IsDynInit &= !CGM.isInNoSanitizeList(GV, Loc, Ty, "init");
-  IsExcluded |= CGM.isInNoSanitizeList(GV, Loc, Ty);
+  Meta.IsDynInit = IsDynInit;
+}
+
+void SanitizerMetadata::reportGlobal(GlobalVariable *GV, SourceLocation Loc,
+                                     StringRef Name, QualType Ty,
+                                     bool IsDynInit,
+                                     SanitizerMask NoSanitizeMask) {
+
+  GVSanitizerMetadata Meta;
+  if (GV->hasSanitizerMetadata())
+    Meta = GV->getSanitizerMetadata();
+
+  bool IsExcluded = false;
+  if (CGM.isInNoSanitizeList(GV, Loc, Ty) ||
+      NoSanitizeMask == SanitizerKind::All) {
+    Meta.AddSanitizer(GlobalSanitizer::NoSanitize);
+    IsExcluded = true;
+  }
+
+  auto &SanTarget = CGM.getLangOpts().Sanitize;
+
+  if (!isAsanHwasanOrMemTag(SanTarget))
+    return;
+
+  SanitizerSet NoSanitizeSet;
+  NoSanitizeSet.Mask = NoSanitizeMask;
+
+  llvm::LLVMContext &VMContext = CGM.getLLVMContext();
+
+  if (SanTarget.hasOneOf(SanitizerKind::Address |
+                         SanitizerKind::KernelAddress)) {
+    if (NoSanitizeSet.hasOneOf(SanitizerKind::Address |
+                               SanitizerKind::KernelAddress) ||
+        Meta.HasSanitizer(GlobalSanitizer::NoAddress)) {
+      Meta.AddSanitizer(GlobalSanitizer::NoAddress);
+      IsExcluded = true;
+    } else if (!IsExcluded) {
+      Meta.AddSanitizer(GlobalSanitizer::Address);
+    }
+    setASanSpecificMetadata(Meta, GV, Loc, Ty, IsDynInit);
+  }
+  if (SanTarget.hasOneOf(SanitizerKind::HWAddress |
+                         SanitizerKind::KernelHWAddress)) {
+    if (NoSanitizeSet.hasOneOf(SanitizerKind::HWAddress |
+                               SanitizerKind::KernelHWAddress) ||
+        Meta.HasSanitizer(GlobalSanitizer::NoHWAddress)) {
+      Meta.AddSanitizer(GlobalSanitizer::NoHWAddress);
+      IsExcluded = true;
+    } else if (!IsExcluded) {
+      Meta.AddSanitizer(GlobalSanitizer::HWAddress);
+    }
+  }
+  if (SanTarget.hasOneOf(SanitizerKind::MemTag)) {
+    if (NoSanitizeSet.hasOneOf(SanitizerKind::MemTag) ||
+        Meta.HasSanitizer(GlobalSanitizer::NoMemtag)) {
+      Meta.AddSanitizer(GlobalSanitizer::NoMemtag);
+      IsExcluded = true;
+    } else if (!IsExcluded) {
+      Meta.AddSanitizer(GlobalSanitizer::Memtag);
+    }
+  }
+
+  GV->setSanitizerMetadata(Meta);
 
   llvm::Metadata *LocDescr = nullptr;
   llvm::Metadata *GlobalName = nullptr;
-  llvm::LLVMContext &VMContext = CGM.getLLVMContext();
   if (!IsExcluded) {
     // Don't generate source location and global name if it is on
     // the NoSanitizeList - it won't be instrumented anyway.
     LocDescr = getLocationMetadata(Loc);
     if (!Name.empty())
       GlobalName = llvm::MDString::get(VMContext, Name);
   }
 
   llvm::Metadata *GlobalMetadata[] = {
       llvm::ConstantAsMetadata::get(GV), LocDescr, GlobalName,
-      llvm::ConstantAsMetadata::get(
-          llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsDynInit)),
+      llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
+          llvm::Type::getInt1Ty(VMContext), Meta.IsDynInit)),
       llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
           llvm::Type::getInt1Ty(VMContext), IsExcluded))};
 
   llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalMetadata);
   llvm::NamedMDNode *AsanGlobals =
       CGM.getModule().getOrInsertNamedMetadata("llvm.asan.globals");
   AsanGlobals->addOperand(ThisGlobal);
 }
 
-void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
-                                           const VarDecl &D, bool IsDynInit) {
-  if (!isAsanHwasanOrMemTag(CGM.getLangOpts().Sanitize))
-    return;
+void SanitizerMetadata::reportGlobal(GlobalVariable *GV, const VarDecl &D,
+                                     bool IsDynInit) {
+  SanitizerMask NoSanitizeMask;
+  for (auto *Attr : D.specific_attrs<NoSanitizeAttr>()) {
+    NoSanitizeMask |= Attr->getMask();
+  }
+
+  if (D.hasAttr<DisableSanitizerInstrumentationAttr>()) {
+    NoSanitizeMask = SanitizerKind::All;
+  }
+
   std::string QualName;
   llvm::raw_string_ostream OS(QualName);
   D.printQualifiedName(OS);
 
-  bool IsExcluded = false;
-  for (auto Attr : D.specific_attrs<NoSanitizeAttr>())
-    if (Attr->getMask() & SanitizerKind::Address)
-      IsExcluded = true;
-  if (D.hasAttr<DisableSanitizerInstrumentationAttr>())
-    IsExcluded = true;
-  reportGlobalToASan(GV, D.getLocation(), OS.str(), D.getType(), IsDynInit,
-                     IsExcluded);
+  reportGlobal(GV, D.getLocation(), OS.str(), D.getType(), IsDynInit,
+               NoSanitizeMask);
 }
 
-void SanitizerMetadata::disableSanitizerForGlobal(llvm::GlobalVariable *GV) {
-  // For now, just make sure the global is not modified by the ASan
-  // instrumentation.
-  if (isAsanHwasanOrMemTag(CGM.getLangOpts().Sanitize))
-    reportGlobalToASan(GV, SourceLocation(), "", QualType(), false, true);
+void SanitizerMetadata::disableSanitizerForGlobal(GlobalVariable *GV) {
+  reportGlobal(GV, SourceLocation(), "", QualType(), false, SanitizerKind::All);
 }
 
 void SanitizerMetadata::disableSanitizerForInstruction(llvm::Instruction *I) {
   I->setMetadata(CGM.getModule().getMDKindID("nosanitize"),
                  llvm::MDNode::get(CGM.getLLVMContext(), None));
 }
 
 llvm::MDNode *SanitizerMetadata::getLocationMetadata(SourceLocation Loc) {

clang/test/CodeGen/asan-globals-alias.cpp

 // Potential indirect alias:
 struct input_device_id {
   unsigned long keybit[24];
   unsigned long driver_info;
 };
 struct input_device_id joydev_ids[] = { { {1}, 1234 } }; // KASAN ignored
 extern struct input_device_id __attribute__((alias("joydev_ids"))) __mod_joydev_ids_device_table;
 
-// ASAN: @aliased_global{{.*}} global { i32, [28 x i8] }{{.*}}, align 32
-// ASAN: @aliased_global_2{{.*}} global { i32, [28 x i8] }{{.*}}, align 32
-// ASAN: @joydev_ids{{.*}} global { {{.*}}[56 x i8] zeroinitializer }, align 32
+// ASAN: @aliased_global{{.*}} global { i32, [28 x i8] }{{.*}}, sanitize_address, align 32
+// ASAN: @aliased_global_2{{.*}} global { i32, [28 x i8] }{{.*}}, sanitize_address, align 32
+// ASAN: @joydev_ids{{.*}} global { {{.*}}[56 x i8] zeroinitializer }, sanitize_address, align 32
 // KASAN: @aliased_global{{.*}} global i32
 // KASAN: @aliased_global_2{{.*}} global i32
-// KASAN: @joydev_ids{{.*}} global [1 x {{.*}}i64 1234 }], align 16
+// KASAN: @joydev_ids{{.*}} global [1 x {{.*}}i64 1234 }], sanitize_address, align 16
 
 // Check the aliases exist:
 // CHECK: @__global_alias ={{.*}} alias
 // CHECK: @global_alias_2 ={{.*}} alias
 // CHECK: @__global_alias_2_alias ={{.*}} alias
 // CHECK: @__mod_joydev_ids_device_table ={{.*}} alias
 
 // CHECK-LABEL: define internal void @asan.module_ctor
 // ASAN: call void @__asan_register_globals({{.*}}, i{{32|64}} 4)
 // KASAN: call void @__asan_register_globals({{.*}}, i{{32|64}} 1)
 // CHECK-NEXT: ret void
 
 // CHECK-LABEL: define internal void @asan.module_dtor
 // CHECK-NEXT: call void @__asan_unregister_globals
 // CHECK-NEXT: ret void

clang/test/CodeGen/asan-globals-odr.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefixes=CHECK,INDICATOR0,GLOB_VAR,ALIAS0
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -fsanitize-address-use-odr-indicator -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefixes=CHECK,INDICATOR1,GLOB_ALIAS_INDICATOR,ALIAS1
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -fno-sanitize-address-use-odr-indicator -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefixes=CHECK,INDICATOR0,GLOB_VAR,ALIAS0
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -fno-sanitize-address-use-odr-indicator -fsanitize-address-use-odr-indicator -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefixes=CHECK,INDICATOR1,GLOB_ALIAS_INDICATOR,ALIAS1
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -fsanitize-address-use-odr-indicator -fno-sanitize-address-use-odr-indicator -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s --check-prefixes=CHECK,INDICATOR0,GLOB_VAR,ALIAS0
 
 // No alias on Windows but indicators should work.
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -emit-llvm -o - -triple x86_64-windows-msvc %s | FileCheck %s --check-prefixes=CHECK,GLOB_VAR,ALIAS0
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -fsanitize-address-use-odr-indicator -emit-llvm -o - -triple x86_64-windows-msvc %s | FileCheck %s --check-prefixes=CHECK,INDICATOR1,GLOB_VAR_INDICATOR,ALIAS0
 
 int global;
 
 int main() {
   return global;
 }
 
-// CHECK: [[VAR:@.*global.*]] ={{.*}} global { i32, [28 x i8] } zeroinitializer, align 32
+// CHECK: [[VAR:@.*global.*]] ={{.*}} global { i32, [28 x i8] } zeroinitializer, sanitize_address, align 32
 
 // INDICATOR0-NOT: __odr_asan_gen
 // INDICATOR1: [[ODR:@.*__odr_asan_gen_.*global.*]] = global i8 0, align 1
 
 // GLOB_VAR: @0 = internal global {{.*}} [[VAR]] to i64), {{.*}}, i64 0 }]
 // GLOB_VAR_INDICATOR: @0 = internal global {{.*}} [[VAR]] to i64), {{.*}}, i64 ptrtoint (i8* [[ODR]] to i64) }]
 // GLOB_ALIAS_INDICATOR: @0 = internal global {{.*}} @1 to i64), {{.*}}, i64 ptrtoint (i8* [[ODR]] to i64) }]
 
 // ALIAS0-NOT: private alias
 // ALIAS1: @1 = private alias {{.*}} [[VAR]]
 
 // CHECK: call void @__asan_register_globals(i64 ptrtoint ([1 x { i64, i64, i64, i64, i64, i64, i64, i64 }]* @0 to i64), i64 1)
 // CHECK: call void @__asan_unregister_globals(i64 ptrtoint ([1 x { i64, i64, i64, i64, i64, i64, i64, i64 }]* @0 to i64), i64 1)

clang/test/CodeGen/asan-static-odr.cpp

 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -emit-llvm -o - -triple x86_64-linux %s | FileCheck %s
 
 // No alias on Windows but indicators should work.
 // RUN: %clang_cc1 -no-opaque-pointers -fsanitize=address -emit-llvm -o - -triple x86_64-windows-msvc %s | FileCheck %s
 
 static int global;
 
 int main() {
   return global;
 }
 
 // CHECK-NOT: __odr_asan_gen
 // CHECK-NOT: private alias
-// CHECK: [[VAR:@.*global.*]] ={{.*}} global { i32, [28 x i8] } zeroinitializer, align 32
+// CHECK: [[VAR:@.*global.*]] ={{.*}} global { i32, [28 x i8] } zeroinitializer, sanitize_address, align 32
 // CHECK: @0 = internal global {{.*}} [[VAR]] to i64), {{.*}}, i64 -1 }]
 // CHECK: call void @__asan_register_globals(i64 ptrtoint ([1 x { i64, i64, i64, i64, i64, i64, i64, i64 }]* @0 to i64), i64 1)
 // CHECK: call void @__asan_unregister_globals(i64 ptrtoint ([1 x { i64, i64, i64, i64, i64, i64, i64, i64 }]* @0 to i64), i64 1)

clang/test/CodeGen/asan-strings.c

 // RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=address -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefix=LINUX
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -fsanitize=address -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefix=WINDOWS
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -fsanitize=address -fwritable-strings -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefix=WINWRITE
 
 // On Linux (and basically every non-MS target) string literals are emitted with
 // private linkage, which means ASan can freely instrument them. On Windows,
 // they are emitted with comdats. ASan's global instrumentation code for COFF
 // knows how to make the metadata comdat associative, so the string literal
 // global is only registered if the instrumented global prevails during linking.
 
 const char *foo(void) { return "asdf"; }
 
-// LINUX: @.str = private unnamed_addr constant [5 x i8] c"asdf\00", align 1
+// LINUX: @.str = private unnamed_addr constant [5 x i8] c"asdf\00", sanitize_address, align 1
 
-// WINDOWS: @"??_C@_04JIHMPGLA@asdf?$AA@" = linkonce_odr dso_local unnamed_addr constant [5 x i8] c"asdf\00", comdat, align 1
+// WINDOWS: @"??_C@_04JIHMPGLA@asdf?$AA@" = linkonce_odr dso_local unnamed_addr constant [5 x i8] c"asdf\00", sanitize_address, comdat, align 1
 
-// WINWRITE: @.str = private unnamed_addr global [5 x i8] c"asdf\00", align 1
+// WINWRITE: @.str = private unnamed_addr global [5 x i8] c"asdf\00", sanitize_address, align 1

llvm/docs/LangRef.rst

Syntax::
 
       @<GlobalVarName> = [Linkage] [PreemptionSpecifier] [Visibility]
                          [DLLStorageClass] [ThreadLocal]
                          [(unnamed_addr|local_unnamed_addr)] [AddrSpace]
                          [ExternallyInitialized]
                          <global | constant> <Type> [<InitializerConstant>]
                          [, section "name"] [, partition "name"]
                          [, comdat [($name)]] [, align <Alignment>]
+                         [, no_sanitize] [, sanitize_address]
+                         [, no_sanitize_address] [, sanitize_hwaddress]
+                         [, no_sanitize_hwaddress] [, sanitize_memtag]
+                         [, no_sanitize_memtag] [, sanitize_address_dyninit]
                          (, !name !N)*
 
 For example, the following defines a global in a numbered address space
 with an initializer, section, and alignment:
 
 .. code-block:: llvm
 
     @G = addrspace(5) constant float 1.0, section "foo", align 4
.. code-block:: llvm
     define void @f() optsize { ... }
 
 ``alignstack(<n>)``
     This attribute indicates that, when emitting the prologue and
     epilogue, the backend should forcibly align the stack pointer.
     Specify the desired alignment, which must be a power of two, in
     parentheses.
 ``"alloc-family"="FAMILY"``
-    This indicates which "family" an allocator function is part of. To avoid 
-    collisions, the family name should match the mangled name of the primary 
-    allocator function, that is "malloc" for malloc/calloc/realloc/free, 
+    This indicates which "family" an allocator function is part of. To avoid
+    collisions, the family name should match the mangled name of the primary
+    allocator function, that is "malloc" for malloc/calloc/realloc/free,
     "_Znwm" for ``::operator::new`` and ``::operator::delete``, and
     "_ZnwmSt11align_val_t" for aligned ``::operator::new`` and
     ``::operator::delete``. Matching malloc/realloc/free calls within a family
     can be optimized, but mismatched ones will be left alone.
 ``allocsize(<EltSizeParam>[, <NumEltsParam>])``
     This attribute indicates that the annotated function will always return at
     least a given number of bytes (or null). Its arguments are zero-indexed
     parameter numbers; if one argument is provided, then it's assumed that at

 the operation.
 
 Semantics:
 """"""""""
 
 The '``llvm.vp.fpext``' intrinsic extends the ``value`` from a smaller
 :ref:`floating-point <t_floating>` type to a larger :ref:`floating-point
 <t_floating>` type. The '``llvm.vp.fpext``' cannot be used to make a
-*no-op cast* because it always changes bits. Use ``bitcast`` to make a 
+*no-op cast* because it always changes bits. Use ``bitcast`` to make a
 *no-op cast* for a floating-point cast.
 The conversion is performed on lane positions below the explicit vector length
 and where the vector mask is true.  Masked-off lanes are undefined.
 
 Examples:
 """""""""
 
 .. code-block:: llvm

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_virtualConstProp,
   kw_info,
   kw_byte,
   kw_bit,
   kw_varFlags,
 
   // Unsigned Valued tokens (UIntVal).
   LabelID,    // 42:
   GlobalID,   // @42
   LocalVarID, // %42
   AttrGrpID,  // #42
   SummaryID,  // ^42
 
   // String valued tokens (StrVal).
   LabelStr,         // foo:
   GlobalVar,        // @foo @"foo"
   ComdatVar,        // $foo
#include "llvm/IR/Attributes.inc"
   DISPFlag,         // DISPFlagFoo
   DwarfMacinfo,     // DW_MACINFO_foo
   ChecksumKind,     // CSK_foo
 
   // Type valued tokens (TyVal).
   Type,
 
   APFloat, // APFloatVal
-  APSInt   // APSInt
+  APSInt,  // APSInt
+
+// Extra sanitizer attributes that are used for global variables (GV's). Some
+// of the attributes are inherited from Attributes.td, but we have some
+// GV-specific additions.
+#define DEFINED_IN_ATTRIBUTES_TD_NO_OP(var)
+  // GV's mentioned in -fsanitize-ignorelist=<file>.
+  kw_no_sanitize,
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(kw_sanitize_address)
+  // 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,
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(kw_sanitize_hwaddress)
+  // GV's with __attribute__((no_sanitize("hwaddress"))).
+  kw_no_sanitize_hwaddress,
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(kw_sanitize_memtag)
+  // GV's with __attribute__((no_sanitize("memtag"))).
+  kw_no_sanitize_memtag,
+
 };
 } // 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);
 
+  struct SanitizerMetadata {
+    enum GlobalSanitizer : unsigned {
+      NoSanitize = 1 << 0,
+      Address = 1 << 1,
+      HWAddress = 1 << 2,
+      Memtag = 1 << 3,
+      NoAddress = 1 << 4,
+      NoHWAddress = 1 << 5,
+      NoMemtag = 1 << 6,
+    };
+    // Bitset of sanitizer options.
+    std::underlying_type<GlobalSanitizer>::type Sanitizer = 0;
+
+    void AddSanitizer(GlobalSanitizer S) { Sanitizer |= S; }
+    void RemoveSanitizer(GlobalSanitizer S) { Sanitizer &= ~S; }
+    bool HasSanitizer(GlobalSanitizer S) const {
+      if (Sanitizer == GlobalSanitizer::NoSanitize)
+        return S == GlobalSanitizer::NoSanitize;
+      switch (S) {
+      case GlobalSanitizer::Address:
+        return (Sanitizer & S) && !(Sanitizer & GlobalSanitizer::NoAddress);
+      case GlobalSanitizer::HWAddress:
+        return (Sanitizer & S) && !(Sanitizer & GlobalSanitizer::NoHWAddress);
+      case GlobalSanitizer::Memtag:
+        return (Sanitizer & S) && !(Sanitizer & GlobalSanitizer::NoMemtag);
+      case GlobalSanitizer::NoSanitize: // clang doesn't see the handling above.
+      case GlobalSanitizer::NoAddress:
+      case GlobalSanitizer::NoHWAddress:
+      case GlobalSanitizer::NoMemtag:
+        return Sanitizer & S;
+      }
+    }
+
+    // Metadata specific to ASan.
+    bool IsDynInit = false;
+  };
+
+  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. Some are inherited from Attributes.td. See LLToken.h
+  // for more information.
+#define DEFINED_IN_ATTRIBUTES_TD_NO_OP(var)
+  KEYWORD(no_sanitize);
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(sanitize_address);
+  KEYWORD(no_sanitize_address);
+  KEYWORD(sanitize_address_dyninit);
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(sanitize_hwaddress);
+  KEYWORD(no_sanitize_hwaddress);
+  DEFINED_IN_ATTRIBUTES_TD_NO_OP(sanitize_memtag);
+  KEYWORD(no_sanitize_memtag);
+
   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;
 
+using SanitizerMetadata = GlobalValue::SanitizerMetadata;
+using GlobalSanitizer = SanitizerMetadata::GlobalSanitizer;
+
 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) {
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_sanitize_address:
+  case lltok::kw_no_sanitize_address:
+  case lltok::kw_sanitize_hwaddress:
+  case lltok::kw_no_sanitize_hwaddress:
+  case lltok::kw_sanitize_memtag:
+  case lltok::kw_no_sanitize_memtag:
+  case lltok::kw_sanitize_address_dyninit:
+    return true;
+  default:
+    return false;
+  }
+}
+
+bool LLParser::parseSanitizer(GlobalVariable *GV) {
+  SanitizerMetadata Meta;
+  if (GV->hasSanitizerMetadata())
+    Meta = GV->getSanitizerMetadata();
+
+  switch (Lex.getKind()) {
+  case lltok::kw_no_sanitize:
+    Meta.AddSanitizer(GlobalSanitizer::NoSanitize);
+    break;
+  case lltok::kw_sanitize_address:
+    Meta.AddSanitizer(GlobalSanitizer::Address);
+    break;
+  case lltok::kw_no_sanitize_address:
+    Meta.AddSanitizer(GlobalSanitizer::NoAddress);
+    break;
+  case lltok::kw_sanitize_hwaddress:
+    Meta.AddSanitizer(GlobalSanitizer::HWAddress);
+    break;
+  case lltok::kw_no_sanitize_hwaddress:
+    Meta.AddSanitizer(GlobalSanitizer::NoHWAddress);
+    break;
+  case lltok::kw_sanitize_memtag:
+    Meta.AddSanitizer(GlobalSanitizer::Memtag);
+    break;
+  case lltok::kw_no_sanitize_memtag:
+    Meta.AddSanitizer(GlobalSanitizer::NoMemtag);
+    break;
+  case lltok::kw_sanitize_address_dyninit:
+    if (!GV->hasSanitizerMetadata() ||
+        !Meta.HasSanitizer(SanitizerMetadata::Address)) {
+      return tokError(
+          "sanitize_address_dyninit must only occur after sanitize_address");
+    }
+    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() > 17 && Record[16] != UINT_MAX && Record[17] != UINT_MAX) {
+    llvm::GlobalValue::SanitizerMetadata Meta;
+    Meta.Sanitizer =
+        static_cast<llvm::GlobalValue::SanitizerMetadata::GlobalSanitizer>(
+            Record[16]);
+    Meta.IsDynInit = static_cast<bool>(Record[17]);
+    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::Sanitizer,
+    //             GlobalSanitizer::IsDynInit]
     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(UINT_MAX);
+        Vals.push_back(UINT_MAX);
+      } else {
+        const auto &MD = GV.getSanitizerMetadata();
+        Vals.push_back(static_cast<int>(MD.Sanitizer));
+        Vals.push_back(MD.IsDynInit);
+      }
     } else {
       AbbrevToUse = SimpleGVarAbbrev;
     }
 
     Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
     Vals.clear();
   }
 

llvm/lib/IR/AsmWriter.cpp

 // Helper Functions
 //===----------------------------------------------------------------------===//
 
 using OrderMap = MapVector<const Value *, unsigned>;
 
 using UseListOrderMap =
     DenseMap<const Function *, MapVector<const Value *, std::vector<unsigned>>>;
 
+using SanitizerMetadata = llvm::GlobalValue::SanitizerMetadata;
+using GlobalSanitizer = SanitizerMetadata::GlobalSanitizer;
+
 /// Look for a value that might be wrapped as metadata, e.g. a value in a
 /// metadata operand. Returns the input value as-is if it is not wrapped.
 static const Value *skipMetadataWrapper(const Value *V) {
   if (const auto *MAV = dyn_cast<MetadataAsValue>(V))
     if (const auto *VAM = dyn_cast<ValueAsMetadata>(MAV->getMetadata()))
       return VAM->getValue();
   return V;
 }
if (GV->hasSection()) {
     Out << '"';
   }
   if (GV->hasPartition()) {
     Out << ", partition \"";
     printEscapedString(GV->getPartition(), Out);
     Out << '"';
   }
 
+  if (GV->hasSanitizerMetadata()) {
+    SanitizerMetadata MD = GV->getSanitizerMetadata();
+    if (MD.HasSanitizer(SanitizerMetadata::NoSanitize)) {
+      Out << ", no_sanitize";
+    } else {
+      if (MD.HasSanitizer(SanitizerMetadata::Address))
+        Out << ", sanitize_address";
+      if (MD.HasSanitizer(SanitizerMetadata::HWAddress))
+        Out << ", sanitize_hwaddress";
+      if (MD.HasSanitizer(SanitizerMetadata::Memtag))
+        Out << ", sanitize_address";
+      if (MD.HasSanitizer(SanitizerMetadata::NoAddress))
+        Out << ", no_sanitize_address";
+      if (MD.HasSanitizer(SanitizerMetadata::NoHWAddress))
+        Out << ", no_sanitize_hwaddress";
+      if (MD.HasSanitizer(SanitizerMetadata::NoMemtag))
+        Out << ", no_sanitize_memtag";
+      if (MD.HasSanitizer(GlobalSanitizer::Address) && 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;
+using GlobalSanitizer = GlobalValue::SanitizerMetadata::GlobalSanitizer;
+const SanitizerMetadata &GlobalValue::getSanitizerMetadata() const {
+  assert(hasSanitizerMetadata());
+  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.
   ///