[NewPM] Port Msan: Alternative approach using a module to create the global constructor

[philip.pfaffe]

Summary

Changes in particular:

• Pull sanitizer and wrapper pass apart
• Add a newpm msan and msan-init pass
• Update tests

Caveats:

• Getting the original msan behavior back requires scheduling both msan and msan-init.
• msan now tries to add a few global variables and function declaration everytime it runs, i.e. for every function. I deduplicate the global variables by name and type, do I need more?
• I skip annotating the msan init function created by the init pass by name, which also might not suffice.

[fedor.sergeev]

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

1077

While generally sympathetic to desire for organization of assorted booleans into a MSanOptions struct,
seeing how 86% of this patch is just a replacement of MS.* with MS.MSanOptions.* I would rather like
to see it come separately (as a preceeding, or perhaps followup, NFC refactoring).

[vitalybuka]

llvm/include/llvm/Transforms/Instrumentation.h

252

please move MSanOptions into separate patch and rename MSanOptions into just Options

[philip.pfaffe]

I dropped MSanOptions over in D55647 (or didn't need it there), which will likely supersede this change here.

[chandlerc]

Marking as needing changes so it doesn't show up in my queue, but maybe you want to abandon the revision if the other design is working now?

[philip.pfaffe]

Abandoning in favor of D55647.

[fedor.sergeev]

In D55605#1340379, @philip.pfaffe wrote:

Abandoning in favor of D55605.

I bet you meant D55647 here :)

[philip.pfaffe]

Absolutely :)

Edited.

[glider]

A couple of nits.
I also think the newly added classes should be marked as such, not as structs, but YMMV.

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

576

A comment explaining why there's "Legacy" in the name would be nice. We'll also need a precondition for removing this legacy from the code.

llvm/test/Instrumentation/MemorySanitizer/PowerPC/vararg-ppc64le.ll

1

This command line duplication is fragile. Can it be somehow done in lit?

llvm/test/Instrumentation/MemorySanitizer/X86/vararg-too-large.ll

1

Nit: I think it's more readable if you break the lines before pipes and indent the continued lines, e.g.:

; RUN: opt < %s -msan-check-access-address=0 ... \
; RUN:   | FileCheck %s

[philip.pfaffe]

In D55605#1340583, @glider wrote:

A couple of nits.
I also think the newly added classes should be marked as such, not as structs, but YMMV.

@glider: I closed this revision. Did you want to raise your concerns on D55647 instead?

clang/lib/CodeGen/BackendUtil.cpp

 static void addGeneralOptsForMemorySanitizer(const PassManagerBuilder &Builder,
                                              legacy::PassManagerBase &PM,
                                              bool CompileKernel) {
   const PassManagerBuilderWrapper &BuilderWrapper =
       static_cast<const PassManagerBuilderWrapper&>(Builder);
   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
   int TrackOrigins = CGOpts.SanitizeMemoryTrackOrigins;
   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::Memory);
-  PM.add(createMemorySanitizerPass(TrackOrigins, Recover, CompileKernel));
+  PM.add(createMemorySanitizerLegacyPassPass(TrackOrigins, Recover, CompileKernel));
 
   // MemorySanitizer inserts complex instrumentation that mostly follows
   // the logic of the original code, but operates on "shadow" values.
   // It can benefit from re-running some general purpose optimization passes.
   if (Builder.OptLevel > 0) {
     PM.add(createEarlyCSEPass());
     PM.add(createReassociatePass());
     PM.add(createLICMPass());

llvm/bindings/go/llvm/InstrumentationBindings.h

 
 // FIXME: These bindings shouldn't be Go-specific and should eventually move to
 // a (somewhat) less stable collection of C APIs for use in creating bindings of
 // LLVM in other languages.
 
 void LLVMAddAddressSanitizerFunctionPass(LLVMPassManagerRef PM);
 void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM);
 void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM);
-void LLVMAddMemorySanitizerPass(LLVMPassManagerRef PM);
+void LLVMAddMemorySanitizerLegacyPassPass(LLVMPassManagerRef PM);
 void LLVMAddDataFlowSanitizerPass(LLVMPassManagerRef PM, int ABIListFilesNum,
                                   const char **ABIListFiles);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif

llvm/bindings/go/llvm/InstrumentationBindings.cpp

 void LLVMAddAddressSanitizerModulePass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createAddressSanitizerModulePass());
 }
 
 void LLVMAddThreadSanitizerPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createThreadSanitizerPass());
 }
 
-void LLVMAddMemorySanitizerPass(LLVMPassManagerRef PM) {
-  unwrap(PM)->add(createMemorySanitizerPass());
+void LLVMAddMemorySanitizerLegacyPassPass(LLVMPassManagerRef PM) {
+  unwrap(PM)->add(createMemorySanitizerLegacyPassPass());
 }
 
 void LLVMAddDataFlowSanitizerPass(LLVMPassManagerRef PM,
                                   int ABIListFilesNum,
                                   const char **ABIListFiles) {
   std::vector<std::string> ABIListFilesVec;
   for (int i = 0; i != ABIListFilesNum; ++i) {
     ABIListFilesVec.push_back(ABIListFiles[i]);
   }
   unwrap(PM)->add(createDataFlowSanitizerPass(ABIListFilesVec));
 }

llvm/bindings/go/llvm/transforms_instrumentation.go

 func (pm PassManager) AddAddressSanitizerModulePass() {
   C.LLVMAddAddressSanitizerModulePass(pm.C)
 }
 
 func (pm PassManager) AddThreadSanitizerPass() {
   C.LLVMAddThreadSanitizerPass(pm.C)
 }
 
-func (pm PassManager) AddMemorySanitizerPass() {
-  C.LLVMAddMemorySanitizerPass(pm.C)
+func (pm PassManager) AddMemorySanitizerLegacyPassPass() {
+  C.LLVMAddMemorySanitizerLegacyPassPass(pm.C)
 }
 
 func (pm PassManager) AddDataFlowSanitizerPass(abilist []string) {
   abiliststrs := make([]*C.char, len(abilist))
   for i, arg := range abilist {
     abiliststrs[i] = C.CString(arg)
     defer C.free(unsafe.Pointer(abiliststrs[i]))
   }
   C.LLVMAddDataFlowSanitizerPass(pm.C, C.int(len(abilist)), &abiliststrs[0])
 }

llvm/include/llvm/InitializePasses.h

 void initializeMachineTraceMetricsPass(PassRegistry&);
 void initializeMachineVerifierPassPass(PassRegistry&);
 void initializeMemCpyOptLegacyPassPass(PassRegistry&);
 void initializeMemDepPrinterPass(PassRegistry&);
 void initializeMemDerefPrinterPass(PassRegistry&);
 void initializeMemoryDependenceWrapperPassPass(PassRegistry&);
 void initializeMemorySSAPrinterLegacyPassPass(PassRegistry&);
 void initializeMemorySSAWrapperPassPass(PassRegistry&);
-void initializeMemorySanitizerPass(PassRegistry&);
+void initializeMemorySanitizerLegacyPassPass(PassRegistry&);
 void initializeMergeFunctionsPass(PassRegistry&);
 void initializeMergeICmpsPass(PassRegistry&);
 void initializeMergedLoadStoreMotionLegacyPassPass(PassRegistry&);
 void initializeMetaRenamerPass(PassRegistry&);
 void initializeModuleDebugInfoPrinterPass(PassRegistry&);
 void initializeModuleSummaryIndexWrapperPassPass(PassRegistry&);
 void initializeMustExecutePrinterPass(PassRegistry&);
 void initializeNameAnonGlobalLegacyPassPass(PassRegistry&);

llvm/include/llvm/Transforms/Instrumentation.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/PassManager.h"
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
FunctionPass *createAddressSanitizerFunctionPass(bool CompileKernel = false,
                                                  bool Recover = false,
                                                  bool UseAfterScope = false);
 ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false,
                                              bool Recover = false,
                                              bool UseGlobalsGC = true,
                                              bool UseOdrIndicator = true);
 
 // Insert MemorySanitizer instrumentation (detection of uninitialized reads)
-FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0,
+FunctionPass *createMemorySanitizerLegacyPassPass(int TrackOrigins = 0,
                                         bool Recover = false,
                                         bool EnableKmsan = false);
 
 FunctionPass *createHWAddressSanitizerPass(bool CompileKernel = false,
                                            bool Recover = false);
 
 // Insert ThreadSanitizer (race detection) instrumentation
 FunctionPass *createThreadSanitizerPass();

 /// Scale a 64-bit weight down to 32-bits using \c Scale.
 ///
 static inline uint32_t scaleBranchCount(uint64_t Count, uint64_t Scale) {
   uint64_t Scaled = Count / Scale;
   assert(Scaled <= std::numeric_limits<uint32_t>::max() && "overflow 32-bits");
   return Scaled;
 }
 
+struct MemorySanitizerOptions {
+  MemorySanitizerOptions(int TrackOrigins = 0, bool Recover = false,
+                         bool EnableKmsan = false);
+
+  /// Track origins (allocation points) of uninitialized values.
+  int TrackOrigins;
+  bool Recover;
+  /// True if we're compiling the Linux kernel.
+  bool CompileKernel;
+};
+
+struct MemorySanitizerInitPass : public PassInfoMixin<MemorySanitizerInitPass> {
+  MemorySanitizerInitPass(int TrackOrigins = 0, bool Recover = false,
+                          bool EnableKmsan = false)
+      : MSanOptions(TrackOrigins, Recover, EnableKmsan) {}
+
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
+  MemorySanitizerOptions MSanOptions;
+};
+
+struct MemorySanitizerPass : public PassInfoMixin<MemorySanitizerPass> {
+  MemorySanitizerPass(int TrackOrigins = 0, bool Recover = false,
+                      bool EnableKmsan = false)
+      : MSanOptions(TrackOrigins, Recover, EnableKmsan) {}
+
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
+  MemorySanitizerOptions MSanOptions;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_TRANSFORMS_INSTRUMENTATION_H

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Transforms/IPO/LowerTypeTests.h"
 #include "llvm/Transforms/IPO/PartialInlining.h"
 #include "llvm/Transforms/IPO/SCCP.h"
 #include "llvm/Transforms/IPO/SampleProfile.h"
 #include "llvm/Transforms/IPO/StripDeadPrototypes.h"
 #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h"
 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
 #include "llvm/Transforms/InstCombine/InstCombine.h"
+#include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
 #include "llvm/Transforms/Instrumentation/CGProfile.h"
 #include "llvm/Transforms/Instrumentation/ControlHeightReduction.h"
 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
 #include "llvm/Transforms/Scalar/ADCE.h"
 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"

llvm/lib/Passes/PassRegistry.def

 MODULE_PASS("rewrite-statepoints-for-gc", RewriteStatepointsForGC())
 MODULE_PASS("rewrite-symbols", RewriteSymbolPass())
 MODULE_PASS("rpo-functionattrs", ReversePostOrderFunctionAttrsPass())
 MODULE_PASS("sample-profile", SampleProfileLoaderPass())
 MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
 MODULE_PASS("synthetic-counts-propagation", SyntheticCountsPropagation())
 MODULE_PASS("wholeprogramdevirt", WholeProgramDevirtPass(nullptr, nullptr))
 MODULE_PASS("verify", VerifierPass())
+MODULE_PASS("msan-init", MemorySanitizerInitPass())
 #undef MODULE_PASS
 
 #ifndef CGSCC_ANALYSIS
 #define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 #endif
 CGSCC_ANALYSIS("no-op-cgscc", NoOpCGSCCAnalysis())
 CGSCC_ANALYSIS("fam-proxy", FunctionAnalysisManagerCGSCCProxy())
 CGSCC_ANALYSIS("pass-instrumentation", PassInstrumentationAnalysis(PIC))

 FUNCTION_PASS("unroll<peeling;no-runtime>",LoopUnrollPass(LoopUnrollOptions().setPeeling(true).setRuntime(false)))
 FUNCTION_PASS("verify", VerifierPass())
 FUNCTION_PASS("verify<domtree>", DominatorTreeVerifierPass())
 FUNCTION_PASS("verify<loops>", LoopVerifierPass())
 FUNCTION_PASS("verify<memoryssa>", MemorySSAVerifierPass())
 FUNCTION_PASS("verify<regions>", RegionInfoVerifierPass())
 FUNCTION_PASS("view-cfg", CFGViewerPass())
 FUNCTION_PASS("view-cfg-only", CFGOnlyViewerPass())
+FUNCTION_PASS("msan", MemorySanitizerPass())
 #undef FUNCTION_PASS
 
 #ifndef LOOP_ANALYSIS
 #define LOOP_ANALYSIS(NAME, CREATE_PASS)
 #endif
 LOOP_ANALYSIS("no-op-loop", NoOpLoopAnalysis())
 LOOP_ANALYSIS("access-info", LoopAccessAnalysis())
 LOOP_ANALYSIS("ivusers", IVUsersAnalysis())

llvm/lib/Transforms/Instrumentation/Instrumentation.cpp

void llvm::initializeInstrumentation(PassRegistry &Registry) {
   initializeBoundsCheckingLegacyPassPass(Registry);
   initializeControlHeightReductionLegacyPassPass(Registry);
   initializeGCOVProfilerLegacyPassPass(Registry);
   initializePGOInstrumentationGenLegacyPassPass(Registry);
   initializePGOInstrumentationUseLegacyPassPass(Registry);
   initializePGOIndirectCallPromotionLegacyPassPass(Registry);
   initializePGOMemOPSizeOptLegacyPassPass(Registry);
   initializeInstrProfilingLegacyPassPass(Registry);
-  initializeMemorySanitizerPass(Registry);
+  initializeMemorySanitizerLegacyPassPass(Registry);
   initializeHWAddressSanitizerPass(Registry);
   initializeThreadSanitizerPass(Registry);
   initializeSanitizerCoverageModulePass(Registry);
   initializeDataFlowSanitizerPass(Registry);
   initializeEfficiencySanitizerPass(Registry);
 }
 
 /// LLVMInitializeInstrumentation - C binding for
 /// initializeInstrumentation.
 void LLVMInitializeInstrumentation(LLVMPassRegistryRef R) {
   initializeInstrumentation(*unwrap(R));
 }

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

 
 namespace {
 
 /// An instrumentation pass implementing detection of uninitialized
 /// reads.
 ///
 /// MemorySanitizer: instrument the code in module to find
 /// uninitialized reads.
-class MemorySanitizer : public FunctionPass {
+class MemorySanitizer {
 public:
-  // Pass identification, replacement for typeid.
-  static char ID;
-
-  MemorySanitizer(int TrackOrigins = 0, bool Recover = false,
-                  bool EnableKmsan = false)
-      : FunctionPass(ID) {
-    this->CompileKernel =
-        ClEnableKmsan.getNumOccurrences() > 0 ? ClEnableKmsan : EnableKmsan;
-    if (ClTrackOrigins.getNumOccurrences() > 0)
-      this->TrackOrigins = ClTrackOrigins;
-    else
-      this->TrackOrigins = this->CompileKernel ? 2 : TrackOrigins;
-    this->Recover = ClKeepGoing.getNumOccurrences() > 0
-                        ? ClKeepGoing
-                        : (this->CompileKernel | Recover);
+  MemorySanitizer(Module &M, MemorySanitizerOptions MSanOptions)
+      : MSanOptions(MSanOptions) {
+    initializeModule(M);
   }
-  StringRef getPassName() const override { return "MemorySanitizer"; }
+  MemorySanitizer(Module &M, int TrackOrigins = 0, bool Recover = false,
+                  bool EnableKmsan = false)
+      : MemorySanitizer(M, {TrackOrigins, Recover, EnableKmsan}) {}
 
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<TargetLibraryInfoWrapperPass>();
-  }
-
-  bool runOnFunction(Function &F) override;
-  bool doInitialization(Module &M) override;
+  bool sanitizeFunction(Function &F, TargetLibraryInfo &TLI);
 
 private:
+  friend struct MemorySanitizerLegacyPass;
   friend struct MemorySanitizerVisitor;
   friend struct VarArgAMD64Helper;
   friend struct VarArgMIPS64Helper;
   friend struct VarArgAArch64Helper;
   friend struct VarArgPowerPC64Helper;
 
+  void initializeModule(Module &M);
   void initializeCallbacks(Module &M);
   void createKernelApi(Module &M);
   void createUserspaceApi(Module &M);
 
-  /// True if we're compiling the Linux kernel.
-  bool CompileKernel;
-
-  /// Track origins (allocation points) of uninitialized values.
-  int TrackOrigins;
-  bool Recover;
+  MemorySanitizerOptions MSanOptions;
 
   LLVMContext *C;
   Type *IntptrTy;
   Type *OriginTy;
 
   // XxxTLS variables represent the per-thread state in MSan and per-task state
   // in KMSAN.
   // For the userspace these point to thread-local globals. In the kernel land
private:
 
   MDNode *ColdCallWeights;
 
   /// Branch weights for origin store.
   MDNode *OriginStoreWeights;
 
   /// An empty volatile inline asm that prevents callback merge.
   InlineAsm *EmptyAsm;
+};
+
+struct MemorySanitizerLegacyPass : public FunctionPass {
+  // Pass identification, replacement for typeid.
+  static char ID;
+
+  MemorySanitizerLegacyPass(int TrackOrigins = 0, bool Recover = false,
+                            bool EnableKmsan = false)
+      : FunctionPass(ID), TrackOrigins(TrackOrigins), Recover(Recover),
+        EnableKmsan(EnableKmsan) {}
+  StringRef getPassName() const override { return "MemorySanitizerLegacyPass"; }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<TargetLibraryInfoWrapperPass>();
+  }
+
+  bool runOnFunction(Function &F) override {
+    return MSan->sanitizeFunction(
+        F, getAnalysis<TargetLibraryInfoWrapperPass>().getTLI());
+  }
+  bool doInitialization(Module &M) override;
 
-  Function *MsanCtorFunction;
+  std::unique_ptr<MemorySanitizer> MSan;
+  int TrackOrigins;
+  bool Recover;
+  bool EnableKmsan;
 };
 
 } // end anonymous namespace
 
-char MemorySanitizer::ID = 0;
+PreservedAnalyses MemorySanitizerPass::run(Function &F,
+                                           FunctionAnalysisManager &FAM) {
+  MemorySanitizer Msan(*F.getParent(), MSanOptions);
+  if (Msan.sanitizeFunction(F, FAM.getResult<TargetLibraryAnalysis>(F)))
+    return PreservedAnalyses::none();
+  return PreservedAnalyses::all();
+}
 
-INITIALIZE_PASS_BEGIN(
-    MemorySanitizer, "msan",
-    "MemorySanitizer: detects uninitialized reads.", false, false)
+char MemorySanitizerLegacyPass::ID = 0;
+
+INITIALIZE_PASS_BEGIN(MemorySanitizerLegacyPass, "msan",
+                      "MemorySanitizer: detects uninitialized reads.", false,
+                      false)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
-INITIALIZE_PASS_END(
-    MemorySanitizer, "msan",
-    "MemorySanitizer: detects uninitialized reads.", false, false)
+INITIALIZE_PASS_END(MemorySanitizerLegacyPass, "msan",
+                    "MemorySanitizer: detects uninitialized reads.", false,
+                    false)
 
-FunctionPass *llvm::createMemorySanitizerPass(int TrackOrigins, bool Recover,
+FunctionPass *llvm::createMemorySanitizerLegacyPassPass(int TrackOrigins,
+                                                        bool Recover,
                                                         bool CompileKernel) {
-  return new MemorySanitizer(TrackOrigins, Recover, CompileKernel);
+  return new MemorySanitizerLegacyPass(TrackOrigins, Recover, CompileKernel);
 }
 
 /// Create a non-const global initialized with the given string.
 ///
 /// Creates a writable global for Str so that we can pass it to the
 /// run-time lib. Runtime uses first 4 bytes of the string to store the
 /// frame ID, so the string needs to be mutable.
 static GlobalVariable *createPrivateNonConstGlobalForString(Module &M,
void MemorySanitizer::createKernelApi(Module &M) {
   // Functions for poisoning and unpoisoning memory.
   MsanPoisonAllocaFn =
       M.getOrInsertFunction("__msan_poison_alloca", IRB.getVoidTy(),
                             IRB.getInt8PtrTy(), IntptrTy, IRB.getInt8PtrTy());
   MsanUnpoisonAllocaFn = M.getOrInsertFunction(
       "__msan_unpoison_alloca", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy);
 }
 
+static GlobalVariable *getOrCreateGlobalVariable(
+    Module &M, Type *Ty, bool isConstant, GlobalValue::LinkageTypes Linkage,
+    Constant *Initializer, const Twine &Name = "",
+    GlobalVariable *InsertBefore = nullptr,
+    GlobalValue::ThreadLocalMode TLM = GlobalValue::NotThreadLocal,
+    unsigned AddressSpace = 0, bool isExternallyInitialized = false) {
+  std::string GVName = Name.str();
+  if (!GVName.empty())
+    if (auto *GV = M.getGlobalVariable(GVName))
+      if (GV->getType()->getPointerElementType() == Ty)
+        return GV;
+  return new GlobalVariable(M, Ty, isConstant, Linkage, Initializer, Name,
+                            InsertBefore, TLM, AddressSpace,
+                            isExternallyInitialized);
+}
+
 /// Insert declarations for userspace-specific functions and globals.
 void MemorySanitizer::createUserspaceApi(Module &M) {
   IRBuilder<> IRB(*C);
   // Create the callback.
   // FIXME: this function should have "Cold" calling conv,
   // which is not yet implemented.
-  StringRef WarningFnName = Recover ? "__msan_warning"
-                                    : "__msan_warning_noreturn";
+  StringRef WarningFnName =
+      MSanOptions.Recover ? "__msan_warning" : "__msan_warning_noreturn";
   WarningFn = M.getOrInsertFunction(WarningFnName, IRB.getVoidTy());
 
   // Create the global TLS variables.
-  RetvalTLS = new GlobalVariable(
+  RetvalTLS = getOrCreateGlobalVariable(
       M, ArrayType::get(IRB.getInt64Ty(), kRetvalTLSSize / 8), false,
       GlobalVariable::ExternalLinkage, nullptr, "__msan_retval_tls", nullptr,
       GlobalVariable::InitialExecTLSModel);
 
-  RetvalOriginTLS = new GlobalVariable(
+  RetvalOriginTLS = getOrCreateGlobalVariable(
       M, OriginTy, false, GlobalVariable::ExternalLinkage, nullptr,
       "__msan_retval_origin_tls", nullptr, GlobalVariable::InitialExecTLSModel);
 
-  ParamTLS = new GlobalVariable(
+  ParamTLS = getOrCreateGlobalVariable(
       M, ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8), false,
       GlobalVariable::ExternalLinkage, nullptr, "__msan_param_tls", nullptr,
       GlobalVariable::InitialExecTLSModel);
 
-  ParamOriginTLS = new GlobalVariable(
+  ParamOriginTLS = getOrCreateGlobalVariable(
       M, ArrayType::get(OriginTy, kParamTLSSize / 4), false,
       GlobalVariable::ExternalLinkage, nullptr, "__msan_param_origin_tls",
       nullptr, GlobalVariable::InitialExecTLSModel);
 
-  VAArgTLS = new GlobalVariable(
+  VAArgTLS = getOrCreateGlobalVariable(
       M, ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8), false,
       GlobalVariable::ExternalLinkage, nullptr, "__msan_va_arg_tls", nullptr,
       GlobalVariable::InitialExecTLSModel);
 
-  VAArgOriginTLS = new GlobalVariable(
+  VAArgOriginTLS = getOrCreateGlobalVariable(
       M, ArrayType::get(OriginTy, kParamTLSSize / 4), false,
       GlobalVariable::ExternalLinkage, nullptr, "__msan_va_arg_origin_tls",
       nullptr, GlobalVariable::InitialExecTLSModel);
 
-  VAArgOverflowSizeTLS = new GlobalVariable(
+  VAArgOverflowSizeTLS = getOrCreateGlobalVariable(
       M, IRB.getInt64Ty(), false, GlobalVariable::ExternalLinkage, nullptr,
       "__msan_va_arg_overflow_size_tls", nullptr,
       GlobalVariable::InitialExecTLSModel);
-  OriginTLS = new GlobalVariable(
+  OriginTLS = getOrCreateGlobalVariable(
       M, IRB.getInt32Ty(), false, GlobalVariable::ExternalLinkage, nullptr,
       "__msan_origin_tls", nullptr, GlobalVariable::InitialExecTLSModel);
 
   for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
        AccessSizeIndex++) {
     unsigned AccessSize = 1 << AccessSizeIndex;
     std::string FunctionName = "__msan_maybe_warning_" + itostr(AccessSize);
     MaybeWarningFn[AccessSizeIndex] = M.getOrInsertFunction(
void MemorySanitizer::initializeCallbacks(Module &M) {
 
   MsanInstrumentAsmLoadFn =
       M.getOrInsertFunction("__msan_instrument_asm_load", IRB.getVoidTy(),
                             PointerType::get(IRB.getInt8Ty(), 0), IntptrTy);
   MsanInstrumentAsmStoreFn =
       M.getOrInsertFunction("__msan_instrument_asm_store", IRB.getVoidTy(),
                             PointerType::get(IRB.getInt8Ty(), 0), IntptrTy);
 
-  if (CompileKernel) {
+  if (MSanOptions.CompileKernel) {
     createKernelApi(M);
   } else {
     createUserspaceApi(M);
   }
   CallbacksInitialized = true;
 }
 
 Value *MemorySanitizer::getKmsanShadowOriginAccessFn(bool isStore, int size) {
Value *MemorySanitizer::getKmsanShadowOriginAccessFn(bool isStore, int size) {
   case 8:
     return Fns[3];
   default:
     return nullptr;
   }
 }
 
 /// Module-level initialization.
-///
-/// inserts a call to __msan_init to the module's constructor list.
-bool MemorySanitizer::doInitialization(Module &M) {
+void MemorySanitizer::initializeModule(Module &M) {
   auto &DL = M.getDataLayout();
 
   bool ShadowPassed = ClShadowBase.getNumOccurrences() > 0;
   bool OriginPassed = ClOriginBase.getNumOccurrences() > 0;
   // Check the overrides first
   if (ShadowPassed || OriginPassed) {
     CustomMapParams.AndMask = ClAndMask;
     CustomMapParams.XorMask = ClXorMask;
void MemorySanitizer::initializeModule(Module &M) {
 
   C = &(M.getContext());
   IRBuilder<> IRB(*C);
   IntptrTy = IRB.getIntPtrTy(DL);
   OriginTy = IRB.getInt32Ty();
 
   ColdCallWeights = MDBuilder(*C).createBranchWeights(1, 1000);
   OriginStoreWeights = MDBuilder(*C).createBranchWeights(1, 1000);
+}
 
-  if (!CompileKernel) {
-    std::tie(MsanCtorFunction, std::ignore) =
-        createSanitizerCtorAndInitFunctions(M, kMsanModuleCtorName,
-                                            kMsanInitName,
-                                            /*InitArgTypes=*/{},
-                                            /*InitArgs=*/{});
-    if (ClWithComdat) {
-      Comdat *MsanCtorComdat = M.getOrInsertComdat(kMsanModuleCtorName);
-      MsanCtorFunction->setComdat(MsanCtorComdat);
-      appendToGlobalCtors(M, MsanCtorFunction, 0, MsanCtorFunction);
-    } else {
-      appendToGlobalCtors(M, MsanCtorFunction, 0);
-    }
+static bool createGlobals(Module &M,
+                          const MemorySanitizerOptions &MSanOptions) {
+  if (MSanOptions.CompileKernel)
+    return false;
+  Function *MsanCtorFunction = nullptr;
+      createSanitizerCtorAndInitFunctions(M, kMsanModuleCtorName, kMsanInitName,
 
-    if (TrackOrigins)
-      new GlobalVariable(M, IRB.getInt32Ty(), true, GlobalValue::WeakODRLinkage,
-                         IRB.getInt32(TrackOrigins), "__msan_track_origins");
-
-    if (Recover)
-      new GlobalVariable(M, IRB.getInt32Ty(), true, GlobalValue::WeakODRLinkage,
-                         IRB.getInt32(Recover), "__msan_keep_going");
-  }
+  IRBuilder<> IRB(M.getContext());
+  if (MSanOptions.TrackOrigins)
+    getOrCreateGlobalVariable(
+        M, IRB.getInt32Ty(), true, GlobalValue::WeakODRLinkage,
+        IRB.getInt32(MSanOptions.TrackOrigins), "__msan_track_origins");
+
+  if (MSanOptions.Recover)
+    getOrCreateGlobalVariable(
+        M, IRB.getInt32Ty(), true, GlobalValue::WeakODRLinkage,
+        IRB.getInt32(MSanOptions.Recover), "__msan_keep_going");
+  return true;
+
+MemorySanitizerOptions::MemorySanitizerOptions(int TrackOrigins, bool Recover,
+                                               bool EnableKmsan) {
+  this->CompileKernel =
+      ClEnableKmsan.getNumOccurrences() > 0 ? ClEnableKmsan : EnableKmsan;
+  if (ClTrackOrigins.getNumOccurrences() > 0)
+    this->TrackOrigins = ClTrackOrigins;
+  else
+    this->TrackOrigins = this->CompileKernel ? 2 : TrackOrigins;
+  this->Recover = ClKeepGoing.getNumOccurrences() > 0
+                      ? ClKeepGoing
+                      : (this->CompileKernel | Recover);
+}
+
+PreservedAnalyses MemorySanitizerInitPass::run(Module &M,
+                                               ModuleAnalysisManager &MAM) {
+  if (createGlobals(M, MSanOptions))
+    return PreservedAnalyses::none();
+  return PreservedAnalyses::all();
+}
+
+bool MemorySanitizerLegacyPass::doInitialization(Module &M) {
+  MSan = make_unique<MemorySanitizer>(M, TrackOrigins, Recover, EnableKmsan);
+  createGlobals(M, MSan->MSanOptions);
   return true;
 }
 
 namespace {
 
 /// A helper class that handles instrumentation of VarArg
 /// functions on a particular platform.
 ///
struct ShadowOriginAndInsertPoint {
     Instruction *OrigIns;
 
     ShadowOriginAndInsertPoint(Value *S, Value *O, Instruction *I)
       : Shadow(S), Origin(O), OrigIns(I) {}
   };
   SmallVector<ShadowOriginAndInsertPoint, 16> InstrumentationList;
   SmallVector<StoreInst *, 16> StoreList;
 
-  MemorySanitizerVisitor(Function &F, MemorySanitizer &MS)
-      : F(F), MS(MS), VAHelper(CreateVarArgHelper(F, MS, *this)) {
+  MemorySanitizerVisitor(Function &F, MemorySanitizer &MS,
+                         const TargetLibraryInfo &TLI)
+      : F(F), MS(MS), VAHelper(CreateVarArgHelper(F, MS, *this)), TLI(&TLI) {
     bool SanitizeFunction = F.hasFnAttribute(Attribute::SanitizeMemory);
     InsertChecks = SanitizeFunction;
     PropagateShadow = SanitizeFunction;
     PoisonStack = SanitizeFunction && ClPoisonStack;
     PoisonUndef = SanitizeFunction && ClPoisonUndef;
     // FIXME: Consider using SpecialCaseList to specify a list of functions that
     // must always return fully initialized values. For now, we hardcode "main".
     CheckReturnValue = SanitizeFunction && (F.getName() == "main");
-    TLI = &MS.getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
 
     MS.initializeCallbacks(*F.getParent());
-    if (MS.CompileKernel)
+    if (MS.MSanOptions.CompileKernel)
       ActualFnStart = insertKmsanPrologue(F);
     else
       ActualFnStart = &F.getEntryBlock();
 
     LLVM_DEBUG(if (!InsertChecks) dbgs()
                << "MemorySanitizer is not inserting checks into '"
                << F.getName() << "'\n");
   }
 
   Value *updateOrigin(Value *V, IRBuilder<> &IRB) {
-    if (MS.TrackOrigins <= 1) return V;
+    if (MS.MSanOptions.TrackOrigins <= 1)
+      return V;
     return IRB.CreateCall(MS.MsanChainOriginFn, V);
   }
 
   Value *originToIntptr(IRBuilder<> &IRB, Value *Origin) {
     const DataLayout &DL = F.getParent()->getDataLayout();
     unsigned IntptrSize = DL.getTypeStoreSize(MS.IntptrTy);
     if (IntptrSize == kOriginSize) return Origin;
     assert(IntptrSize == kOriginSize * 2);
if (Shadow->getType()->isAggregateType()) {
           paintOrigin(IRB, updateOrigin(Origin, IRB), OriginPtr, StoreSize,
                       OriginAlignment);
         return;
       }
 
       unsigned TypeSizeInBits =
           DL.getTypeSizeInBits(ConvertedShadow->getType());
       unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits);
-      if (AsCall && SizeIndex < kNumberOfAccessSizes && !MS.CompileKernel) {
+      if (AsCall && SizeIndex < kNumberOfAccessSizes &&
+          !MS.MSanOptions.CompileKernel) {
         Value *Fn = MS.MaybeStoreOriginFn[SizeIndex];
         Value *ConvertedShadow2 = IRB.CreateZExt(
             ConvertedShadow, IRB.getIntNTy(8 * (1 << SizeIndex)));
         IRB.CreateCall(Fn, {ConvertedShadow2,
                             IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()),
                             Origin});
       } else {
         Value *Cmp = IRB.CreateICmpNE(
for (StoreInst *SI : StoreList) {
 
       StoreInst *NewSI = IRB.CreateAlignedStore(Shadow, ShadowPtr, Alignment);
       LLVM_DEBUG(dbgs() << "  STORE: " << *NewSI << "\n");
       (void)NewSI;
 
       if (SI->isAtomic())
         SI->setOrdering(addReleaseOrdering(SI->getOrdering()));
 
-      if (MS.TrackOrigins && !SI->isAtomic())
+      if (MS.MSanOptions.TrackOrigins && !SI->isAtomic())
         storeOrigin(IRB, Addr, Shadow, getOrigin(Val), OriginPtr,
                     OriginAlignment, InstrumentWithCalls);
     }
   }
 
   /// Helper function to insert a warning at IRB's current insert point.
   void insertWarningFn(IRBuilder<> &IRB, Value *Origin) {
     if (!Origin)
       Origin = (Value *)IRB.getInt32(0);
-    if (MS.CompileKernel) {
+    if (MS.MSanOptions.CompileKernel) {
       IRB.CreateCall(MS.WarningFn, Origin);
     } else {
-      if (MS.TrackOrigins) {
+      if (MS.MSanOptions.TrackOrigins) {
         IRB.CreateStore(Origin, MS.OriginTLS);
       }
       IRB.CreateCall(MS.WarningFn, {});
     }
     IRB.CreateCall(MS.EmptyAsm, {});
     // FIXME: Insert UnreachableInst if !MS.Recover?
     // This may invalidate some of the following checks and needs to be done
     // at the very end.
if (ConstantShadow) {
       }
       return;
     }
 
     const DataLayout &DL = OrigIns->getModule()->getDataLayout();
 
     unsigned TypeSizeInBits = DL.getTypeSizeInBits(ConvertedShadow->getType());
     unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits);
-    if (AsCall && SizeIndex < kNumberOfAccessSizes && !MS.CompileKernel) {
+    if (AsCall && SizeIndex < kNumberOfAccessSizes &&
+        !MS.MSanOptions.CompileKernel) {
       Value *Fn = MS.MaybeWarningFn[SizeIndex];
       Value *ConvertedShadow2 =
           IRB.CreateZExt(ConvertedShadow, IRB.getIntNTy(8 * (1 << SizeIndex)));
-      IRB.CreateCall(Fn, {ConvertedShadow2, MS.TrackOrigins && Origin
-                                                ? Origin
-                                                : (Value *)IRB.getInt32(0)});
+      IRB.CreateCall(Fn,
+                     {ConvertedShadow2, MS.MSanOptions.TrackOrigins && Origin
     } else {
       Value *Cmp = IRB.CreateICmpNE(ConvertedShadow,
                                     getCleanShadow(ConvertedShadow), "_mscmp");
       Instruction *CheckTerm = SplitBlockAndInsertIfThen(
           Cmp, OrigIns,
-          /* Unreachable */ !MS.Recover, MS.ColdCallWeights);
+          /* Unreachable */ !MS.MSanOptions.Recover, MS.ColdCallWeights);
 
       IRB.SetInsertPoint(CheckTerm);
       insertWarningFn(IRB, Origin);
       LLVM_DEBUG(dbgs() << "  CHECK: " << *Cmp << "\n");
     }
   }
 
   void materializeChecks(bool InstrumentWithCalls) {
bool runOnFunction() {
     // for all instructions (where applicable).
     // For PHI nodes we create dummy shadow PHIs which will be finalized later.
     for (BasicBlock *BB : depth_first(ActualFnStart))
       visit(*BB);
 
     // Finalize PHI nodes.
     for (PHINode *PN : ShadowPHINodes) {
       PHINode *PNS = cast<PHINode>(getShadow(PN));
-      PHINode *PNO = MS.TrackOrigins ? cast<PHINode>(getOrigin(PN)) : nullptr;
+      PHINode *PNO =
+          MS.MSanOptions.TrackOrigins ? cast<PHINode>(getOrigin(PN)) : nullptr;
       size_t NumValues = PN->getNumIncomingValues();
       for (size_t v = 0; v < NumValues; v++) {
         PNS->addIncoming(getShadow(PN, v), PN->getIncomingBlock(v));
         if (PNO) PNO->addIncoming(getOrigin(PN, v), PN->getIncomingBlock(v));
       }
     }
 
     VAHelper->finalizeInstrumentation();
std::pair<Value *, Value *> getShadowOriginPtrUserspace(Value *Addr,
                                                           IRBuilder<> &IRB,
                                                           Type *ShadowTy,
                                                           unsigned Alignment) {
     Value *ShadowOffset = getShadowPtrOffset(Addr, IRB);
     Value *ShadowLong = ShadowOffset;
     uint64_t ShadowBase = MS.MapParams->ShadowBase;
     if (ShadowBase != 0) {
       ShadowLong =
-        IRB.CreateAdd(ShadowLong,
-                      ConstantInt::get(MS.IntptrTy, ShadowBase));
+          IRB.CreateAdd(ShadowLong, ConstantInt::get(MS.IntptrTy, ShadowBase));
     }
     Value *ShadowPtr =
         IRB.CreateIntToPtr(ShadowLong, PointerType::get(ShadowTy, 0));
     Value *OriginPtr = nullptr;
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       Value *OriginLong = ShadowOffset;
       uint64_t OriginBase = MS.MapParams->OriginBase;
       if (OriginBase != 0)
         OriginLong = IRB.CreateAdd(OriginLong,
                                    ConstantInt::get(MS.IntptrTy, OriginBase));
       if (Alignment < kMinOriginAlignment) {
         uint64_t Mask = kMinOriginAlignment - 1;
         OriginLong =
getShadowOriginPtrKernel(Value *Addr, IRBuilder<> &IRB, Type *ShadowTy,
     return std::make_pair(ShadowPtr, OriginPtr);
   }
 
   std::pair<Value *, Value *> getShadowOriginPtr(Value *Addr, IRBuilder<> &IRB,
                                                  Type *ShadowTy,
                                                  unsigned Alignment,
                                                  bool isStore) {
     std::pair<Value *, Value *> ret;
-    if (MS.CompileKernel)
+    if (MS.MSanOptions.CompileKernel)
       ret = getShadowOriginPtrKernel(Addr, IRB, ShadowTy, Alignment, isStore);
     else
       ret = getShadowOriginPtrUserspace(Addr, IRB, ShadowTy, Alignment);
     return ret;
   }
 
   /// Compute the shadow address for a given function argument.
   ///
   /// Shadow = ParamTLS+ArgOffset.
   Value *getShadowPtrForArgument(Value *A, IRBuilder<> &IRB,
                                  int ArgOffset) {
     Value *Base = IRB.CreatePointerCast(MS.ParamTLS, MS.IntptrTy);
     if (ArgOffset)
       Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
     return IRB.CreateIntToPtr(Base, PointerType::get(getShadowTy(A), 0),
                               "_msarg");
   }
 
   /// Compute the origin address for a given function argument.
-  Value *getOriginPtrForArgument(Value *A, IRBuilder<> &IRB,
-                                 int ArgOffset) {
-    if (!MS.TrackOrigins)
+  Value *getOriginPtrForArgument(Value *A, IRBuilder<> &IRB, int ArgOffset) {
+    if (!MS.MSanOptions.TrackOrigins)
       return nullptr;
     Value *Base = IRB.CreatePointerCast(MS.ParamOriginTLS, MS.IntptrTy);
     if (ArgOffset)
       Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
     return IRB.CreateIntToPtr(Base, PointerType::get(MS.OriginTy, 0),
                               "_msarg_o");
   }
 
struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
   /// Set SV to be the shadow value for V.
   void setShadow(Value *V, Value *SV) {
     assert(!ShadowMap.count(V) && "Values may only have one shadow");
     ShadowMap[V] = PropagateShadow ? SV : getCleanShadow(V);
   }
 
   /// Set Origin to be the origin value for V.
   void setOrigin(Value *V, Value *Origin) {
-    if (!MS.TrackOrigins) return;
+    if (!MS.MSanOptions.TrackOrigins)
+      return;
     assert(!OriginMap.count(V) && "Values may only have one origin");
     LLVM_DEBUG(dbgs() << "ORIGIN: " << *V << "  ==> " << *Origin << "\n");
     OriginMap[V] = Origin;
   }
 
   Constant *getCleanShadow(Type *OrigTy) {
     Type *ShadowTy = getShadowTy(OrigTy);
     if (!ShadowTy)
if (Argument *A = dyn_cast<Argument>(V)) {
               *ShadowPtr = getCleanShadow(V);
             } else {
               *ShadowPtr =
                   EntryIRB.CreateAlignedLoad(Base, kShadowTLSAlignment);
             }
           }
           LLVM_DEBUG(dbgs()
                      << "  ARG:    " << FArg << " ==> " << **ShadowPtr << "\n");
-          if (MS.TrackOrigins && !Overflow) {
+          if (MS.MSanOptions.TrackOrigins && !Overflow) {
             Value *OriginPtr =
                 getOriginPtrForArgument(&FArg, EntryIRB, ArgOffset);
             setOrigin(A, EntryIRB.CreateLoad(OriginPtr));
           } else {
             setOrigin(A, getCleanOrigin());
           }
         }
         ArgOffset += alignTo(Size, kShadowTLSAlignment);
       }
       assert(*ShadowPtr && "Could not find shadow for an argument");
       return *ShadowPtr;
     }
     // For everything else the shadow is zero.
     return getCleanShadow(V);
   }
 
   /// Get the shadow for i-th argument of the instruction I.
   Value *getShadow(Instruction *I, int i) {
     return getShadow(I->getOperand(i));
   }
 
   /// Get the origin for a value.
   Value *getOrigin(Value *V) {
-    if (!MS.TrackOrigins) return nullptr;
+    if (!MS.MSanOptions.TrackOrigins)
+      return nullptr;
     if (!PropagateShadow) return getCleanOrigin();
     if (isa<Constant>(V)) return getCleanOrigin();
     assert((isa<Instruction>(V) || isa<Argument>(V)) &&
            "Unexpected value type in getOrigin()");
     if (Instruction *I = dyn_cast<Instruction>(V)) {
       if (I->getMetadata("nosanitize"))
         return getCleanOrigin();
     }
void visitLoadInst(LoadInst &I) {
     }
 
     if (ClCheckAccessAddress)
       insertShadowCheck(I.getPointerOperand(), &I);
 
     if (I.isAtomic())
       I.setOrdering(addAcquireOrdering(I.getOrdering()));
 
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       if (PropagateShadow) {
         unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment);
         setOrigin(&I, IRB.CreateAlignedLoad(OriginPtr, OriginAlignment));
       } else {
         setOrigin(&I, getCleanOrigin());
       }
     }
   }
Combiner &Add(Value *OpShadow, Value *OpOrigin) {
         if (!Shadow)
           Shadow = OpShadow;
         else {
           OpShadow = MSV->CreateShadowCast(IRB, OpShadow, Shadow->getType());
           Shadow = IRB.CreateOr(Shadow, OpShadow, "_msprop");
         }
       }
 
-      if (MSV->MS.TrackOrigins) {
+      if (MSV->MS.MSanOptions.TrackOrigins) {
         assert(OpOrigin);
         if (!Origin) {
           Origin = OpOrigin;
         } else {
           Constant *ConstOrigin = dyn_cast<Constant>(OpOrigin);
           // No point in adding something that might result in 0 origin value.
           if (!ConstOrigin || !ConstOrigin->isNullValue()) {
             Value *FlatShadow = MSV->convertToShadowTyNoVec(OpShadow, IRB);
             Value *Cond =
                 IRB.CreateICmpNE(FlatShadow, MSV->getCleanShadow(FlatShadow));
             Origin = IRB.CreateSelect(Cond, OpOrigin, Origin);
           }
         }
       }
       return *this;
     }
 
     /// Add an application value to the mix.
     Combiner &Add(Value *V) {
       Value *OpShadow = MSV->getShadow(V);
-      Value *OpOrigin = MSV->MS.TrackOrigins ? MSV->getOrigin(V) : nullptr;
+      Value *OpOrigin =
+          MSV->MS.MSanOptions.TrackOrigins ? MSV->getOrigin(V) : nullptr;
       return Add(OpShadow, OpOrigin);
     }
 
     /// Set the current combined values as the given instruction's shadow
     /// and origin.
     void Done(Instruction *I) {
       if (CombineShadow) {
         assert(Shadow);
         Shadow = MSV->CreateShadowCast(IRB, Shadow, MSV->getShadowTy(I));
         MSV->setShadow(I, Shadow);
       }
-      if (MSV->MS.TrackOrigins) {
+      if (MSV->MS.MSanOptions.TrackOrigins) {
         assert(Origin);
         MSV->setOrigin(I, Origin);
       }
     }
   };
 
   using ShadowAndOriginCombiner = Combiner<true>;
   using OriginCombiner = Combiner<false>;
 
   /// Propagate origin for arbitrary operation.
   void setOriginForNaryOp(Instruction &I) {
-    if (!MS.TrackOrigins) return;
+    if (!MS.MSanOptions.TrackOrigins)
+      return;
     IRBuilder<> IRB(&I);
     OriginCombiner OC(this, IRB);
     for (Instruction::op_iterator OI = I.op_begin(); OI != I.op_end(); ++OI)
       OC.Add(OI->get());
     OC.Done(&I);
   }
 
   size_t VectorOrPrimitiveTypeSizeInBits(Type *Ty) {
bool handleVectorStoreIntrinsic(IntrinsicInst &I) {
     std::tie(ShadowPtr, OriginPtr) = getShadowOriginPtr(
         Addr, IRB, Shadow->getType(), /*Alignment*/ 1, /*isStore*/ true);
     IRB.CreateAlignedStore(Shadow, ShadowPtr, 1);
 
     if (ClCheckAccessAddress)
       insertShadowCheck(Addr, &I);
 
     // FIXME: factor out common code from materializeStores
-    if (MS.TrackOrigins) IRB.CreateStore(getOrigin(&I, 1), OriginPtr);
+    if (MS.MSanOptions.TrackOrigins)
+      IRB.CreateStore(getOrigin(&I, 1), OriginPtr);
     return true;
   }
 
   /// Handle vector load-like intrinsics.
   ///
   /// Instrument intrinsics that look like a simple SIMD load: reads memory,
   /// has 1 pointer argument, returns a vector.
   bool handleVectorLoadIntrinsic(IntrinsicInst &I) {
if (PropagateShadow) {
       setShadow(&I, IRB.CreateAlignedLoad(ShadowPtr, Alignment, "_msld"));
     } else {
       setShadow(&I, getCleanShadow(&I));
     }
 
     if (ClCheckAccessAddress)
       insertShadowCheck(Addr, &I);
 
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       if (PropagateShadow)
         setOrigin(&I, IRB.CreateLoad(OriginPtr));
       else
         setOrigin(&I, getCleanOrigin());
     }
     return true;
   }
 
void handleLdmxcsr(IntrinsicInst &I) {
     Value *ShadowPtr, *OriginPtr;
     std::tie(ShadowPtr, OriginPtr) =
         getShadowOriginPtr(Addr, IRB, Ty, Alignment, /*isStore*/ false);
 
     if (ClCheckAccessAddress)
       insertShadowCheck(Addr, &I);
 
     Value *Shadow = IRB.CreateAlignedLoad(ShadowPtr, Alignment, "_ldmxcsr");
-    Value *Origin =
-        MS.TrackOrigins ? IRB.CreateLoad(OriginPtr) : getCleanOrigin();
+    Value *Origin = MS.MSanOptions.TrackOrigins ? IRB.CreateLoad(OriginPtr)
+                                                : getCleanOrigin();
     insertShadowCheck(Shadow, Origin, &I);
   }
 
   void handleMaskedStore(IntrinsicInst &I) {
     IRBuilder<> IRB(&I);
     Value *V = I.getArgOperand(0);
     Value *Addr = I.getArgOperand(1);
     unsigned Align = cast<ConstantInt>(I.getArgOperand(2))->getZExtValue();
if (ClCheckAccessAddress) {
       insertShadowCheck(Addr, &I);
       // Uninitialized mask is kind of like uninitialized address, but not as
       // scary.
       insertShadowCheck(Mask, &I);
     }
 
     IRB.CreateMaskedStore(Shadow, ShadowPtr, Align, Mask);
 
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       auto &DL = F.getParent()->getDataLayout();
       paintOrigin(IRB, getOrigin(V), OriginPtr,
                   DL.getTypeStoreSize(Shadow->getType()),
                   std::max(Align, kMinOriginAlignment));
     }
   }
 
   bool handleMaskedLoad(IntrinsicInst &I) {
if (PropagateShadow) {
       setShadow(&I, getCleanShadow(&I));
     }
 
     if (ClCheckAccessAddress) {
       insertShadowCheck(Addr, &I);
       insertShadowCheck(Mask, &I);
     }
 
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       if (PropagateShadow) {
         // Choose between PassThru's and the loaded value's origins.
         Value *MaskedPassThruShadow = IRB.CreateAnd(
             getShadow(PassThru), IRB.CreateSExt(IRB.CreateNeg(Mask), ShadowTy));
 
         Value *Acc = IRB.CreateExtractElement(
             MaskedPassThruShadow, ConstantInt::get(IRB.getInt32Ty(), 0));
         for (int i = 1, N = PassThru->getType()->getVectorNumElements(); i < N;
void visitCallSite(CallSite CS) {
     assert((CS.isCall() || CS.isInvoke()) && "Unknown type of CallSite");
     if (CS.isCall()) {
       CallInst *Call = cast<CallInst>(&I);
 
       // For inline asm, do the usual thing: check argument shadow and mark all
       // outputs as clean. Note that any side effects of the inline asm that are
       // not immediately visible in its constraints are not handled.
       if (Call->isInlineAsm()) {
-        if (ClHandleAsmConservative && MS.CompileKernel)
+        if (ClHandleAsmConservative && MS.MSanOptions.CompileKernel)
           visitAsmInstruction(I);
         else
           visitInstruction(I);
         return;
       }
 
       assert(!isa<IntrinsicInst>(&I) && "intrinsics are handled elsewhere");
 
for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
                                /*isStore*/ false)
                 .first;
 
         Store = IRB.CreateMemCpy(ArgShadowBase, Alignment, AShadowPtr,
                                  Alignment, Size);
         // TODO(glider): need to copy origins.
       } else {
         Size = DL.getTypeAllocSize(A->getType());
-        if (ArgOffset + Size > kParamTLSSize) break;
+        if (ArgOffset + Size > kParamTLSSize)
+          break;
         Store = IRB.CreateAlignedStore(ArgShadow, ArgShadowBase,
                                        kShadowTLSAlignment);
         Constant *Cst = dyn_cast<Constant>(ArgShadow);
-        if (Cst && Cst->isNullValue()) ArgIsInitialized = true;
+        if (Cst && Cst->isNullValue())
+          ArgIsInitialized = true;
       }
-      if (MS.TrackOrigins && !ArgIsInitialized)
+      if (MS.MSanOptions.TrackOrigins && !ArgIsInitialized)
         IRB.CreateStore(getOrigin(A),
                         getOriginPtrForArgument(A, IRB, ArgOffset));
       (void)Store;
       assert(Size != 0 && Store != nullptr);
       LLVM_DEBUG(dbgs() << "  Param:" << *Store << "\n");
       ArgOffset += alignTo(Size, 8);
     }
     LLVM_DEBUG(dbgs() << "  done with call args\n");
if (CS.isCall()) {
       if (!NormalDest->getSinglePredecessor()) {
         // FIXME: this case is tricky, so we are just conservative here.
         // Perhaps we need to split the edge between this BB and NormalDest,
         // but a naive attempt to use SplitEdge leads to a crash.
         setShadow(&I, getCleanShadow(&I));
         setOrigin(&I, getCleanOrigin());
         return;
       }
-      // FIXME: NextInsn is likely in a basic block that has not been visited yet.
-      // Anything inserted there will be instrumented by MSan later!
+      // FIXME: NextInsn is likely in a basic block that has not been visited
+      // yet. Anything inserted there will be instrumented by MSan later!
       NextInsn = NormalDest->getFirstInsertionPt();
       assert(NextInsn != NormalDest->end() &&
              "Could not find insertion point for retval shadow load");
     }
     IRBuilder<> IRBAfter(&*NextInsn);
-    Value *RetvalShadow =
-      IRBAfter.CreateAlignedLoad(getShadowPtrForRetval(&I, IRBAfter),
-                                 kShadowTLSAlignment, "_msret");
+    Value *RetvalShadow = IRBAfter.CreateAlignedLoad(
+        getShadowPtrForRetval(&I, IRBAfter), kShadowTLSAlignment, "_msret");
     setShadow(&I, RetvalShadow);
-    if (MS.TrackOrigins)
+    if (MS.MSanOptions.TrackOrigins)
       setOrigin(&I, IRBAfter.CreateLoad(getOriginPtrForRetval(IRBAfter)));
   }
 
   bool isAMustTailRetVal(Value *RetVal) {
     if (auto *I = dyn_cast<BitCastInst>(RetVal)) {
       RetVal = I->getOperand(0);
     }
     if (auto *I = dyn_cast<CallInst>(RetVal)) {
void visitReturnInst(ReturnInst &I) {
     Value *ShadowPtr = getShadowPtrForRetval(RetVal, IRB);
     if (CheckReturnValue) {
       insertShadowCheck(RetVal, &I);
       Value *Shadow = getCleanShadow(RetVal);
       IRB.CreateAlignedStore(Shadow, ShadowPtr, kShadowTLSAlignment);
     } else {
       Value *Shadow = getShadow(RetVal);
       IRB.CreateAlignedStore(Shadow, ShadowPtr, kShadowTLSAlignment);
-      if (MS.TrackOrigins)
+      if (MS.MSanOptions.TrackOrigins)
         IRB.CreateStore(getOrigin(RetVal), getOriginPtrForRetval(IRB));
     }
   }
 
   void visitPHINode(PHINode &I) {
     IRBuilder<> IRB(&I);
     if (!PropagateShadow) {
       setShadow(&I, getCleanShadow(&I));
       setOrigin(&I, getCleanOrigin());
       return;
     }
 
     ShadowPHINodes.push_back(&I);
     setShadow(&I, IRB.CreatePHI(getShadowTy(&I), I.getNumIncomingValues(),
                                 "_msphi_s"));
-    if (MS.TrackOrigins)
+    if (MS.MSanOptions.TrackOrigins)
       setOrigin(&I, IRB.CreatePHI(MS.OriginTy, I.getNumIncomingValues(),
                                   "_msphi_o"));
   }
 
   Value *getLocalVarDescription(AllocaInst &I) {
     SmallString<2048> StackDescriptionStorage;
     raw_svector_ostream StackDescription(StackDescriptionStorage);
     // We create a string with a description of the stack allocation and
if (PoisonStack && ClPoisonStackWithCall) {
       Value *ShadowBase, *OriginBase;
       std::tie(ShadowBase, OriginBase) =
           getShadowOriginPtr(&I, IRB, IRB.getInt8Ty(), 1, /*isStore*/ true);
 
       Value *PoisonValue = IRB.getInt8(PoisonStack ? ClPoisonStackPattern : 0);
       IRB.CreateMemSet(ShadowBase, PoisonValue, Len, I.getAlignment());
     }
 
-    if (PoisonStack && MS.TrackOrigins) {
+    if (PoisonStack && MS.MSanOptions.TrackOrigins) {
       Value *Descr = getLocalVarDescription(I);
       IRB.CreateCall(MS.MsanSetAllocaOrigin4Fn,
                      {IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len,
                       IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy()),
                       IRB.CreatePointerCast(&F, MS.IntptrTy)});
     }
   }
 
void visitAllocaInst(AllocaInst &I) {
     setOrigin(&I, getCleanOrigin());
     IRBuilder<> IRB(I.getNextNode());
     const DataLayout &DL = F.getParent()->getDataLayout();
     uint64_t TypeSize = DL.getTypeAllocSize(I.getAllocatedType());
     Value *Len = ConstantInt::get(MS.IntptrTy, TypeSize);
     if (I.isArrayAllocation())
       Len = IRB.CreateMul(Len, I.getArraySize());
 
-    if (MS.CompileKernel)
+    if (MS.MSanOptions.CompileKernel)
       instrumentAllocaKmsan(I, IRB, Len);
     else
       instrumentAllocaUserspace(I, IRB, Len);
   }
 
   void visitSelectInst(SelectInst& I) {
     IRBuilder<> IRB(&I);
     // a = select b, c, d
if (I.getType()->isAggregateType()) {
       C = CreateAppToShadowCast(IRB, C);
       D = CreateAppToShadowCast(IRB, D);
 
       // Result shadow if condition shadow is 1.
       Sa1 = IRB.CreateOr(IRB.CreateXor(C, D), IRB.CreateOr(Sc, Sd));
     }
     Value *Sa = IRB.CreateSelect(Sb, Sa1, Sa0, "_msprop_select");
     setShadow(&I, Sa);
-    if (MS.TrackOrigins) {
+    if (MS.MSanOptions.TrackOrigins) {
       // Origins are always i32, so any vector conditions must be flattened.
       // FIXME: consider tracking vector origins for app vectors?
       if (B->getType()->isVectorTy()) {
         Type *FlatTy = getShadowTyNoVec(B->getType());
         B = IRB.CreateICmpNE(IRB.CreateBitCast(B, FlatTy),
                                 ConstantInt::getNullValue(FlatTy));
         Sb = IRB.CreateICmpNE(IRB.CreateBitCast(Sb, FlatTy),
                                       ConstantInt::getNullValue(FlatTy));
for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
         if (IsFixed)
           continue;
         assert(A->getType()->isPointerTy());
         Type *RealTy = A->getType()->getPointerElementType();
         uint64_t ArgSize = DL.getTypeAllocSize(RealTy);
         Value *ShadowBase = getShadowPtrForVAArgument(
             RealTy, IRB, OverflowOffset, alignTo(ArgSize, 8));
         Value *OriginBase = nullptr;
-        if (MS.TrackOrigins)
+        if (MS.MSanOptions.TrackOrigins)
           OriginBase = getOriginPtrForVAArgument(RealTy, IRB, OverflowOffset);
         OverflowOffset += alignTo(ArgSize, 8);
         if (!ShadowBase)
           continue;
         Value *ShadowPtr, *OriginPtr;
         std::tie(ShadowPtr, OriginPtr) =
             MSV.getShadowOriginPtr(A, IRB, IRB.getInt8Ty(), kShadowTLSAlignment,
                                    /*isStore*/ false);
 
         IRB.CreateMemCpy(ShadowBase, kShadowTLSAlignment, ShadowPtr,
                          kShadowTLSAlignment, ArgSize);
-        if (MS.TrackOrigins)
+        if (MS.MSanOptions.TrackOrigins)
           IRB.CreateMemCpy(OriginBase, kShadowTLSAlignment, OriginPtr,
                            kShadowTLSAlignment, ArgSize);
       } else {
         ArgKind AK = classifyArgument(A);
         if (AK == AK_GeneralPurpose && GpOffset >= AMD64GpEndOffset)
           AK = AK_Memory;
         if (AK == AK_FloatingPoint && FpOffset >= AMD64FpEndOffset)
           AK = AK_Memory;
         Value *ShadowBase, *OriginBase = nullptr;
         switch (AK) {
           case AK_GeneralPurpose:
             ShadowBase =
                 getShadowPtrForVAArgument(A->getType(), IRB, GpOffset, 8);
-            if (MS.TrackOrigins)
+            if (MS.MSanOptions.TrackOrigins)
               OriginBase =
                   getOriginPtrForVAArgument(A->getType(), IRB, GpOffset);
             GpOffset += 8;
             break;
           case AK_FloatingPoint:
             ShadowBase =
                 getShadowPtrForVAArgument(A->getType(), IRB, FpOffset, 16);
-            if (MS.TrackOrigins)
+            if (MS.MSanOptions.TrackOrigins)
               OriginBase =
                   getOriginPtrForVAArgument(A->getType(), IRB, FpOffset);
             FpOffset += 16;
             break;
           case AK_Memory:
             if (IsFixed)
               continue;
             uint64_t ArgSize = DL.getTypeAllocSize(A->getType());
             ShadowBase =
                 getShadowPtrForVAArgument(A->getType(), IRB, OverflowOffset, 8);
-            if (MS.TrackOrigins)
+            if (MS.MSanOptions.TrackOrigins)
               OriginBase =
                   getOriginPtrForVAArgument(A->getType(), IRB, OverflowOffset);
             OverflowOffset += alignTo(ArgSize, 8);
         }
         // Take fixed arguments into account for GpOffset and FpOffset,
         // but don't actually store shadows for them.
         // TODO(glider): don't call get*PtrForVAArgument() for them.
         if (IsFixed)
           continue;
         if (!ShadowBase)
           continue;
         Value *Shadow = MSV.getShadow(A);
         IRB.CreateAlignedStore(Shadow, ShadowBase, kShadowTLSAlignment);
-        if (MS.TrackOrigins) {
+        if (MS.MSanOptions.TrackOrigins) {
           Value *Origin = MSV.getOrigin(A);
           unsigned StoreSize = DL.getTypeStoreSize(Shadow->getType());
           MSV.paintOrigin(IRB, Origin, OriginBase, StoreSize,
                           std::max(kShadowTLSAlignment, kMinOriginAlignment));
         }
       }
     }
     Constant *OverflowSize =
if (!VAStartInstrumentationList.empty()) {
       // va_arg_tls somewhere in the function entry block.
       IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI());
       VAArgOverflowSize = IRB.CreateLoad(MS.VAArgOverflowSizeTLS);
       Value *CopySize =
         IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AMD64FpEndOffset),
                       VAArgOverflowSize);
       VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
       IRB.CreateMemCpy(VAArgTLSCopy, 8, MS.VAArgTLS, 8, CopySize);
-      if (MS.TrackOrigins) {
+      if (MS.MSanOptions.TrackOrigins) {
         VAArgTLSOriginCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
         IRB.CreateMemCpy(VAArgTLSOriginCopy, 8, MS.VAArgOriginTLS, 8, CopySize);
       }
     }
 
     // Instrument va_start.
     // Copy va_list shadow from the backup copy of the TLS contents.
     for (size_t i = 0, n = VAStartInstrumentationList.size(); i < n; i++) {
       CallInst *OrigInst = VAStartInstrumentationList[i];
       IRBuilder<> IRB(OrigInst->getNextNode());
       Value *VAListTag = OrigInst->getArgOperand(0);
 
       Value *RegSaveAreaPtrPtr = IRB.CreateIntToPtr(
           IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy),
                         ConstantInt::get(MS.IntptrTy, 16)),
           PointerType::get(Type::getInt64PtrTy(*MS.C), 0));
       Value *RegSaveAreaPtr = IRB.CreateLoad(RegSaveAreaPtrPtr);
       Value *RegSaveAreaShadowPtr, *RegSaveAreaOriginPtr;
       unsigned Alignment = 16;
       std::tie(RegSaveAreaShadowPtr, RegSaveAreaOriginPtr) =
           MSV.getShadowOriginPtr(RegSaveAreaPtr, IRB, IRB.getInt8Ty(),
                                  Alignment, /*isStore*/ true);
       IRB.CreateMemCpy(RegSaveAreaShadowPtr, Alignment, VAArgTLSCopy, Alignment,
                        AMD64FpEndOffset);
-      if (MS.TrackOrigins)
+      if (MS.MSanOptions.TrackOrigins)
         IRB.CreateMemCpy(RegSaveAreaOriginPtr, Alignment, VAArgTLSOriginCopy,
                          Alignment, AMD64FpEndOffset);
       Value *OverflowArgAreaPtrPtr = IRB.CreateIntToPtr(
           IRB.CreateAdd(IRB.CreatePtrToInt(VAListTag, MS.IntptrTy),
                         ConstantInt::get(MS.IntptrTy, 8)),
           PointerType::get(Type::getInt64PtrTy(*MS.C), 0));
       Value *OverflowArgAreaPtr = IRB.CreateLoad(OverflowArgAreaPtrPtr);
       Value *OverflowArgAreaShadowPtr, *OverflowArgAreaOriginPtr;
       std::tie(OverflowArgAreaShadowPtr, OverflowArgAreaOriginPtr) =
           MSV.getShadowOriginPtr(OverflowArgAreaPtr, IRB, IRB.getInt8Ty(),
                                  Alignment, /*isStore*/ true);
       Value *SrcPtr = IRB.CreateConstGEP1_32(IRB.getInt8Ty(), VAArgTLSCopy,
                                              AMD64FpEndOffset);
       IRB.CreateMemCpy(OverflowArgAreaShadowPtr, Alignment, SrcPtr, Alignment,
                        VAArgOverflowSize);
-      if (MS.TrackOrigins) {
+      if (MS.MSanOptions.TrackOrigins) {
         SrcPtr = IRB.CreateConstGEP1_32(IRB.getInt8Ty(), VAArgTLSOriginCopy,
                                         AMD64FpEndOffset);
         IRB.CreateMemCpy(OverflowArgAreaOriginPtr, Alignment, SrcPtr, Alignment,
                          VAArgOverflowSize);
       }
     }
   }
 };
 
 /// MIPS64-specific implementation of VarArgHelper.
 struct VarArgMIPS64Helper : public VarArgHelper {
   Function &F;
   MemorySanitizer &MS;
   MemorySanitizerVisitor &MSV;
   Value *VAArgTLSCopy = nullptr;
   Value *VAArgSize = nullptr;
 
   SmallVector<CallInst*, 16> VAStartInstrumentationList;
 
   VarArgMIPS64Helper(Function &F, MemorySanitizer &MS,
-                    MemorySanitizerVisitor &MSV) : F(F), MS(MS), MSV(MSV) {}
+                     MemorySanitizerVisitor &MSV)
+      : F(F), MS(MS), MSV(MSV) {}
 
   void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
     unsigned VAArgOffset = 0;
     const DataLayout &DL = F.getParent()->getDataLayout();
     for (CallSite::arg_iterator ArgIt = CS.arg_begin() +
          CS.getFunctionType()->getNumParams(), End = CS.arg_end();
          ArgIt != End; ++ArgIt) {
       Triple TargetTriple(F.getParent()->getTargetTriple());
struct VarArgAArch64Helper : public VarArgHelper {
   Value *VAArgTLSCopy = nullptr;
   Value *VAArgOverflowSize = nullptr;
 
   SmallVector<CallInst*, 16> VAStartInstrumentationList;
 
   enum ArgKind { AK_GeneralPurpose, AK_FloatingPoint, AK_Memory };
 
   VarArgAArch64Helper(Function &F, MemorySanitizer &MS,
-                    MemorySanitizerVisitor &MSV) : F(F), MS(MS), MSV(MSV) {}
+                      MemorySanitizerVisitor &MSV)
+      : F(F), MS(MS), MSV(MSV) {}
 
   ArgKind classifyArgument(Value* arg) {
     Type *T = arg->getType();
     if (T->isFPOrFPVectorTy())
       return AK_FloatingPoint;
     if ((T->isIntegerTy() && T->getPrimitiveSizeInBits() <= 64)
         || (T->isPointerTy()))
       return AK_GeneralPurpose;
struct VarArgPowerPC64Helper : public VarArgHelper {
   MemorySanitizer &MS;
   MemorySanitizerVisitor &MSV;
   Value *VAArgTLSCopy = nullptr;
   Value *VAArgSize = nullptr;
 
   SmallVector<CallInst*, 16> VAStartInstrumentationList;
 
   VarArgPowerPC64Helper(Function &F, MemorySanitizer &MS,
-                    MemorySanitizerVisitor &MSV) : F(F), MS(MS), MSV(MSV) {}
+                        MemorySanitizerVisitor &MSV)
+      : F(F), MS(MS), MSV(MSV) {}
 
   void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
     // For PowerPC, we need to deal with alignment of stack arguments -
     // they are mostly aligned to 8 bytes, but vectors and i128 arrays
     // are aligned to 16 bytes, byvals can be aligned to 8 or 16 bytes,
     // and QPX vectors are aligned to 32 bytes.  For that reason, we
     // compute current offset from stack pointer (which is always properly
     // aligned), and offset for the first vararg, then subtract them.
else if (TargetTriple.getArch() == Triple::aarch64)
     return new VarArgAArch64Helper(Func, Msan, Visitor);
   else if (TargetTriple.getArch() == Triple::ppc64 ||
            TargetTriple.getArch() == Triple::ppc64le)
     return new VarArgPowerPC64Helper(Func, Msan, Visitor);
   else
     return new VarArgNoOpHelper(Func, Msan, Visitor);
 }
 
-bool MemorySanitizer::runOnFunction(Function &F) {
-  if (!CompileKernel && (&F == MsanCtorFunction))
+bool MemorySanitizer::sanitizeFunction(Function &F, TargetLibraryInfo &TLI) {
+  if (!MSanOptions.CompileKernel && (F.getName() == kMsanModuleCtorName))
     return false;
-  MemorySanitizerVisitor Visitor(F, *this);
+  MemorySanitizerVisitor Visitor(F, *this, TLI);
 
   // Clear out readonly/readnone attributes.
   AttrBuilder B;
-  B.addAttribute(Attribute::ReadOnly)
-    .addAttribute(Attribute::ReadNone);
+  B.addAttribute(Attribute::ReadOnly).addAttribute(Attribute::ReadNone);
   F.removeAttributes(AttributeList::FunctionIndex, B);
 
   return Visitor.runOnFunction();
 }

llvm/test/Instrumentation/MemorySanitizer/AArch64/vararg.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux-gnu"
 
 %struct.__va_list = type { i8*, i8*, i8*, i32, i32 }
 
 define i32 @foo(i32 %guard, ...) {

llvm/test/Instrumentation/MemorySanitizer/Mips/vararg-mips64.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 
 target datalayout = "E-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"
 target triple = "mips64--linux"
 
 define i32 @foo(i32 %guard, ...) {
   %vl = alloca i8*, align 8
   %1 = bitcast i8** %vl to i8*

llvm/test/Instrumentation/MemorySanitizer/Mips/vararg-mips64el.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 
 target datalayout = "e-m:m-i8:8:32-i16:16:32-i64:64-n32:64-S128"
 target triple = "mips64el--linux"
 
 define i32 @foo(i32 %guard, ...) {
   %vl = alloca i8*, align 8
   %1 = bitcast i8** %vl to i8*

llvm/test/Instrumentation/MemorySanitizer/PowerPC/vararg-ppc64.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64--linux"
 
 define i32 @foo(i32 %guard, ...) {
   %vl = alloca i8*, align 8
   %1 = bitcast i8** %vl to i8*

llvm/test/Instrumentation/MemorySanitizer/PowerPC/vararg-ppc64le.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-n32:64"
 target triple = "powerpc64le--linux"
 
 define i32 @foo(i32 %guard, ...) {
   %vl = alloca i8*, align 8
   %1 = bitcast i8** %vl to i8*

llvm/test/Instrumentation/MemorySanitizer/X86/vararg-too-large.ll

+; RUN: opt < %s -msan-check-access-address=0 -S 2>&1 -passes='msan-init,function(msan)' | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S 2>&1 | FileCheck %s
 
 ; Test that MSan doesn't generate code overflowing __msan_va_arg_tls when too many arguments are
 ; passed to a variadic function.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 

llvm/test/Instrumentation/MemorySanitizer/X86/vararg.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S
 ; Test that code using va_start can be compiled on i386.
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32-S128"
 target triple = "i386-unknown-linux-gnu"
 
 define void @VaStart(i8* %s, ...) {
 entry:
   %vl = alloca i8*, align 4
   %vl1 = bitcast i8** %vl to i8*
   call void @llvm.va_start(i8* %vl1)
   ret void
 }
 
 declare void @llvm.va_start(i8*)

llvm/test/Instrumentation/MemorySanitizer/X86/vararg_call.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,CHECK-ORIGIN"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s --check-prefixes=CHECK,CHECK-ORIGIN
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,CHECK-ORIGIN"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s --check-prefixes=CHECK,CHECK-ORIGIN
 
 ; Test that shadow and origin are stored for variadic function params.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.__va_list_tag = type { i32, i32, i8*, i8* }

llvm/test/Instrumentation/MemorySanitizer/alloca.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s "--check-prefixes=CHECK,INLINE"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s --check-prefixes=CHECK,INLINE
+; RUN: opt < %s -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,CALL"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S | FileCheck %s --check-prefixes=CHECK,CALL
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,ORIGIN"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s --check-prefixes=CHECK,ORIGIN
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,ORIGIN"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s --check-prefixes=CHECK,ORIGIN
+; RUN: opt < %s -msan-kernel=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s             \
+; RUN: "--check-prefixes=CHECK,KMSAN"
 ; RUN: opt < %s -msan -msan-kernel=1 -S | FileCheck %s --check-prefixes=CHECK,KMSAN
 
 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"
 
 define void @static() sanitize_memory {
 entry:
   %x = alloca i32, align 4

llvm/test/Instrumentation/MemorySanitizer/array_types.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS %s --allow-empty
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %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"
 
 define [2 x i32] @InsertValue(i32 %x, i32 %y) sanitize_memory {
 entry:
   %a = insertvalue [2 x i32] undef, i32 %x, 0

llvm/test/Instrumentation/MemorySanitizer/atomics.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | 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"
 
 ; atomicrmw xchg: store clean shadow, return clean shadow
 
 define i32 @AtomicRmwXchg(i32* %p, i32 %x) sanitize_memory {

llvm/test/Instrumentation/MemorySanitizer/byval-alignment.ll

 ; Test that copy alignment for byval arguments is limited by param-tls slot alignment.
 
+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.S = type { i64, i64, i64, [8 x i8] }
 
 ; CHECK: [[A:%.*]] = bitcast i64* {{.*}} add {{.*}} ptrtoint {{.*}} @__msan_param_tls {{.*}} i64 8)

llvm/test/Instrumentation/MemorySanitizer/check-constant-shadow.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-check-constant-shadow=1     \
+; RUN: -msan-track-origins=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-check-constant-shadow=1 -msan-track-origins=1 -S | 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"
 
 ; Test that returning a literal undef from main() triggers an MSan warning.
 
 ; main() is special: it inserts check for the return value

llvm/test/Instrumentation/MemorySanitizer/check_access_address.ll

+; RUN: opt < %s -msan-check-access-address=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=1 -S | 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"
 
 
 ; Test byval argument shadow alignment
 

llvm/test/Instrumentation/MemorySanitizer/csr.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s --check-prefix=ADDR
 ; RUN: opt < %s -msan -msan-check-access-address=1 -S | FileCheck %s --check-prefix=ADDR
 ; REQUIRES: x86-registered-target
 
 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"
 
 declare void @llvm.x86.sse.stmxcsr(i8*)
 declare void @llvm.x86.sse.ldmxcsr(i8*)

llvm/test/Instrumentation/MemorySanitizer/global_ctors_2to3.ll

 ; MSan converts 2-element global_ctors to 3-element when adding the new entry.
+; RUN: opt < %s -msan-with-comdat -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-with-comdat -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: $msan.module_ctor = comdat any
 ; CHECK: @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }] [{ i32, void ()*, i8* } { i32 65535, void ()* @f, i8* null }, { i32, void ()*, i8* } { i32 0, void ()* @msan.module_ctor, i8* bitcast (void ()* @msan.module_ctor to i8*) }]
 
 @llvm.global_ctors = appending global [1 x { i32, void ()* }] [{ i32, void ()* } { i32 65535, void ()* @f }]
 
 define internal void @f() {
 entry:
   ret void
 }
 
 ; CHECK: define internal void @msan.module_ctor() comdat {

llvm/test/Instrumentation/MemorySanitizer/instrumentation-with-call-threshold.ll

 ; Test -msan-instrumentation-with-call-threshold
 ; Test that in with-calls mode there are no calls to __msan_chain_origin - they
 ; are done from __msan_maybe_store_origin_*.
 
+; RUN: opt < %s -msan-check-access-address=0                                   \
+; RUN: -msan-instrumentation-with-call-threshold=0 -S -passes='msan-init,function(msan)' 2>&1 |      \
+; RUN: FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0                                   \
+; RUN: -msan-instrumentation-with-call-threshold=0 -msan-track-origins=1 -S    \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s
+; RUN: opt < %s -msan-check-access-address=0                                   \
+; RUN: -msan-instrumentation-with-call-threshold=0 -msan-track-origins=2 -S    \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-instrumentation-with-call-threshold=0 -msan-track-origins=2 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %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"
 
 define void @LoadAndCmp(i32* nocapture %a) nounwind uwtable sanitize_memory {
 entry:
   %0 = load i32, i32* %a, align 4

llvm/test/Instrumentation/MemorySanitizer/manual-shadow.ll

 ; Test that the msan layout customization options work as expected
 ;
+; RUN: opt < %s -msan-shadow-base 3735928559 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: --check-prefix=CHECK-BASE %s
 ; RUN: opt < %s -msan -msan-shadow-base 3735928559 -S | FileCheck --check-prefix=CHECK-BASE %s
+; RUN: opt < %s -msan-shadow-base 3735928559 -msan-and-mask 4294901760 -S      \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck --check-prefix=CHECK-AND %s
 ; RUN: opt < %s -msan -msan-shadow-base 3735928559 -msan-and-mask 4294901760 -S | FileCheck --check-prefix=CHECK-AND %s
+; RUN: opt < %s -msan-shadow-base 3735928559 -msan-xor-mask 48879 -S           \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck --check-prefix=CHECK-XOR %s
 ; RUN: opt < %s -msan -msan-shadow-base 3735928559 -msan-xor-mask 48879 -S | FileCheck --check-prefix=CHECK-XOR %s
+; RUN: opt < %s -msan-shadow-base 3735928559 -msan-xor-mask 48879              \
+; RUN: -msan-and-mask 4294901760 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck              \
+; RUN: --check-prefix=CHECK-XOR-AND %s
 ; RUN: opt < %s -msan -msan-shadow-base 3735928559 -msan-xor-mask 48879 -msan-and-mask 4294901760 -S | FileCheck --check-prefix=CHECK-XOR-AND %s
+; RUN: opt < %s -msan-track-origins 1 -msan-origin-base 1777777 -S -passes='msan-init,function(msan)'\
+; RUN: 2>&1 | FileCheck --check-prefix=CHECK-ORIGIN-BASE %s
 ; RUN: opt < %s -msan -msan-track-origins 1 -msan-origin-base 1777777 -S | FileCheck --check-prefix=CHECK-ORIGIN-BASE %s
 
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @read_value(i32* %a) sanitize_memory {
 entry:
   %tmp1 = load i32, i32* %a, align 4
   ret i32 %tmp1

llvm/test/Instrumentation/MemorySanitizer/masked-store-load.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s "--check-prefixes=CHECK,CHECK-ORIGIN"
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s --check-prefixes=CHECK,CHECK-ORIGIN
+; RUN: opt < %s -msan-check-access-address=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s --check-prefix=ADDR
 ; RUN: opt < %s -msan -msan-check-access-address=1 -S | FileCheck %s --check-prefix=ADDR
 
 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"
 
 declare void @llvm.masked.store.v4i64.p0v4i64(<4 x i64>, <4 x i64>*, i32, <4 x i1>)
 declare <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>*, i32, <4 x i1>, <4 x double>)
 

llvm/test/Instrumentation/MemorySanitizer/missing_origin.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | 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"
 
 ; Test that result origin is directy propagated from the argument,
 ; and is not affected by all the literal undef operands.
 ; https://github.com/google/sanitizers/issues/559

llvm/test/Instrumentation/MemorySanitizer/msan_asm_conservative.ll

 ; Test for handling of asm constraints in MSan instrumentation.
+; RUN: opt < %s -msan-kernel=1 -msan-check-access-address=0                    \
+; RUN: -msan-handle-asm-conservative=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck        \
+; RUN: "-check-prefixes=CHECK,CHECK-NONCONS" %s
 ; RUN: opt < %s -msan -msan-kernel=1 -msan-check-access-address=0 -msan-handle-asm-conservative=0 -S | FileCheck -check-prefixes=CHECK,CHECK-NONCONS %s
+; RUN: opt < %s -msan-kernel=1 -msan-check-access-address=0                    \
+; RUN: -msan-handle-asm-conservative=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck        \
+; RUN: "-check-prefixes=CHECK,CHECK-CONS" %s
 ; RUN: opt < %s -msan -msan-kernel=1 -msan-check-access-address=0 -msan-handle-asm-conservative=1 -S | FileCheck -check-prefixes=CHECK,CHECK-CONS %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 %struct.pair = type { i32, i32 }
 
 @id1 = common dso_local global i32 0, align 4

llvm/test/Instrumentation/MemorySanitizer/msan_basic.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: -allow-deprecated-dag-overlap %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck -allow-deprecated-dag-overlap %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -allow-deprecated-dag-overlap             \
+; RUN: -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -allow-deprecated-dag-overlap -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %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: @llvm.global_ctors {{.*}} { i32 0, void ()* @msan.module_ctor, i8* null }
 
 ; Check the presence and the linkage type of __msan_track_origins and

llvm/test/Instrumentation/MemorySanitizer/msan_kernel_basic.ll

 ; KMSAN instrumentation tests
+; RUN: opt < %s -msan-kernel=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s             \
+; RUN: -check-prefixes=CHECK
 ; RUN: opt < %s -msan -msan-kernel=1 -S | FileCheck %s -check-prefixes=CHECK
 
 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 the instrumentation prologue.
 define void @Empty() nounwind uwtable sanitize_memory {
 entry:

llvm/test/Instrumentation/MemorySanitizer/msan_x86_bts_asm.ll

 ; Test for the conservative assembly handling mode used by KMSAN.
+; RUN: opt < %s -msan-kernel=1 -msan-check-access-address=0                    \
+; RUN: -msan-handle-asm-conservative=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck        \
+; RUN: "-check-prefixes=CHECK,CHECK-NONCONS" %s
 ; RUN: opt < %s -msan -msan-kernel=1 -msan-check-access-address=0 -msan-handle-asm-conservative=0 -S | FileCheck -check-prefixes=CHECK,CHECK-NONCONS %s
+; RUN: opt < %s -msan-kernel=1 -msan-check-access-address=0                    \
+; RUN: -msan-handle-asm-conservative=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck        \
+; RUN: "-check-prefixes=CHECK,CHECK-CONS" %s
 ; RUN: opt < %s -msan -msan-kernel=1 -msan-check-access-address=0 -msan-handle-asm-conservative=1 -S | FileCheck -check-prefixes=CHECK,CHECK-CONS %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; The IR below was generated from the following source:
 ;  int main() {
 ;    bool bit;

llvm/test/Instrumentation/MemorySanitizer/msan_x86intrinsics.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS %s
 ; REQUIRES: x86-registered-target
 
 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"
 
 ; Store intrinsic.
 

llvm/test/Instrumentation/MemorySanitizer/mul_by_constant.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | 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 instrumentation mul when one of the operands is a constant.
 
 define i64 @MulConst(i64 %x) sanitize_memory {

llvm/test/Instrumentation/MemorySanitizer/nosanitize.ll

 ; Verify that calls with !nosanitize are not instrumented by MSan.
+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
+; RUN: opt < %s -msan-track-origins=1 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-track-origins=1 -S | FileCheck %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @bar(i32 %x)
 
 define void @foo() {
   call void @bar(i32 7), !nosanitize !{}

llvm/test/Instrumentation/MemorySanitizer/origin-alignment.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS1 %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS1 %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck -check-prefix=CHECK                       \
+; RUN: -check-prefix=CHECK-ORIGINS2 %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-ORIGINS2 %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 origin instrumentation of stores.
 ; Check that debug info for origin propagation code is set correctly.

llvm/test/Instrumentation/MemorySanitizer/origin-array.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
 target triple = "aarch64-unknown-linux-gnu"
 
 ; Check origin handling of array types.
 
 define void @foo([2 x i64] %v, [2 x i64]* %p) sanitize_memory {

llvm/test/Instrumentation/MemorySanitizer/pr32842.ll

 ; Regression test for https://bugs.llvm.org/show_bug.cgi?id=32842
 ;
+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | FileCheck %s
 ;target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define zeroext i1 @_Z1fii(i32 %x, i32 %y) sanitize_memory {
 entry:
   %cmp = icmp slt i32 %x, %y
   ret i1 %cmp

llvm/test/Instrumentation/MemorySanitizer/return_from_main.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | 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"
 
 define i32 @main() sanitize_memory {
 entry:
   %call = tail call i32 @f()
   ret i32 %call

llvm/test/Instrumentation/MemorySanitizer/store-long-origin.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | 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"
 
 
 ; Test origin for longer stores.
 

llvm/test/Instrumentation/MemorySanitizer/store-origin.ll

+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck                                           \
+; RUN: "-check-prefixes=CHECK,CHECK-MSAN,CHECK-ORIGINS1" %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck -check-prefixes=CHECK,CHECK-MSAN,CHECK-ORIGINS1 %s
+; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S          \
+; RUN: -passes='msan-init,function(msan)' 2>&1 | FileCheck                                           \
+; RUN: "-check-prefixes=CHECK,CHECK-MSAN,CHECK-ORIGINS2" %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck -check-prefixes=CHECK,CHECK-MSAN,CHECK-ORIGINS2 %s
+; RUN: opt < %s -msan-kernel=1 -msan-check-access-address=0 -S -passes='msan-init,function(msan)'    \
+; RUN: 2>&1 | FileCheck "-check-prefixes=CHECK,CHECK-KMSAN,CHECK-ORIGINS2" %s
 ; RUN: opt < %s -msan -msan-kernel=1 -msan-check-access-address=0 -S | FileCheck -check-prefixes=CHECK,CHECK-KMSAN,CHECK-ORIGINS2 %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 origin instrumentation of stores.
 ; Check that debug info for origin propagation code is set correctly.

llvm/test/Instrumentation/MemorySanitizer/str-nobuiltin.ll

 ; Test marking string functions as nobuiltin in memory sanitizer.
 ;
+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | 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"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i8* @memchr(i8* %a, i32 %b, i64 %c)
 declare i32 @memcmp(i8* %a, i8* %b, i64 %c)
 declare i32 @strcmp(i8* %a, i8* %b)
 declare i8* @strcpy(i8* %a, i8* %b)

llvm/test/Instrumentation/MemorySanitizer/unreachable.ll

+; RUN: opt < %s -S -passes='msan-init,function(msan)' 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -S | 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"
 
 
 ; Test that MemorySanitizer correctly handles unreachable blocks.
 
 define i32 @Func(i32* %p) nounwind uwtable {

llvm/test/Instrumentation/MemorySanitizer/unsized_type.ll

 ; Check that unsized token types used by coroutine intrinsics do not cause
 ; assertion failures.
+; RUN: opt < %s -S 2>&1 -passes='msan-init,function(msan)' | FileCheck %s
 ; RUN: opt < %s -msan -S 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare token @llvm.coro.id(i32, i8* readnone, i8* nocapture readonly, i8*)
 declare i1 @llvm.coro.alloc(token)
 

llvm/test/Instrumentation/MemorySanitizer/vector_arith.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 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"
 
 declare <4 x i32> @llvm.x86.sse2.pmadd.wd(<8 x i16>, <8 x i16>) nounwind readnone
 declare x86_mmx @llvm.x86.ssse3.pmadd.ub.sw(x86_mmx, x86_mmx) nounwind readnone

llvm/test/Instrumentation/MemorySanitizer/vector_cmp.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 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"
 
 declare <4 x float> @llvm.x86.sse.cmp.ss(<4 x float>, <4 x float>, i8) nounwind readnone
 declare <4 x float> @llvm.x86.sse.cmp.ps(<4 x float>, <4 x float>, i8) nounwind readnone

llvm/test/Instrumentation/MemorySanitizer/vector_cvt.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 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"
 
 declare i32 @llvm.x86.sse2.cvtsd2si(<2 x double>) nounwind readnone
 declare <2 x double> @llvm.x86.sse2.cvtsi2sd(<2 x double>, i32) nounwind readnone

llvm/test/Instrumentation/MemorySanitizer/vector_pack.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 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"
 
 declare <8 x i16> @llvm.x86.sse2.packssdw.128(<4 x i32>, <4 x i32>) nounwind readnone
 declare <32 x i8> @llvm.x86.avx2.packuswb(<16 x i16> %a, <16 x i16> %b) nounwind readnone

llvm/test/Instrumentation/MemorySanitizer/vector_shift.ll

+; RUN: opt < %s -msan-check-access-address=0 -S -passes='msan-init,function(msan)' 2>&1 | FileCheck  \
+; RUN: %s
 ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s
 ; REQUIRES: x86-registered-target
 
 ; Test instrumentation of vector shift instructions.
 
 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"
 

llvm/test/Instrumentation/MemorySanitizer/with-call-type-size.ll

+; RUN: opt < %s -msan-instrumentation-with-call-threshold=0 -S -passes='msan-init,function(msan)'    \
+; RUN: 2>&1 | FileCheck %s
 ; RUN: opt < %s -msan -msan-instrumentation-with-call-threshold=0 -S | 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"
 
 define <4 x i32> @test1(<4 x i32> %vec, i1 %idx, i32 %x) sanitize_memory {
   %vec1 = insertelement <4 x i32> %vec, i32 %x, i1 %idx
   ret <4 x i32> %vec1

 define <4 x i32> @test65(<4 x i32> %vec, i65 %idx, i32 %x) sanitize_memory {
   %vec1 = insertelement <4 x i32> %vec, i32 %x, i65 %idx
   ret <4 x i32> %vec1
 }
 ; CHECK-LABEL: @test65(
 ; CHECK-NOT:     call void @__msan_maybe_warning_
 ; CHECK:         icmp ne i65 %{{.*}}, 0
 ; CHECK-NOT:     call void @__msan_maybe_warning_
-; CHECK:         ret <4 x i32>
+; CHECK:         ret <4 x i32>