diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
--- a/clang/lib/CodeGen/BackendUtil.cpp
+++ b/clang/lib/CodeGen/BackendUtil.cpp
@@ -633,12 +633,13 @@
   std::unique_ptr<TargetLibraryInfoImpl> TLII(
       createTLII(TargetTriple, CodeGenOpts));
 
-  // If we reached here with a non-empty index file name, then the index file
-  // was empty and we are not performing ThinLTO backend compilation (used in
-  // testing in a distributed build environment). Drop any the type test
-  // assume sequences inserted for whole program vtables so that codegen doesn't
-  // complain.
-  if (!CodeGenOpts.ThinLTOIndexFile.empty())
+  // If we reached here with a non-empty index file name, then the index
+  // file was empty and we are not performing ThinLTO backend compilation
+  // (used in testing in a distributed build environment).
+  bool IsDistributedThinLTOTesting = !CodeGenOpts.ThinLTOIndexFile.empty();
+  // Drop any the type test assume sequences inserted for whole program
+  // vtables so that codegen doesn't complain.
+  if (IsDistributedThinLTOTesting)
     MPM.add(createLowerTypeTestsPass(/*ExportSummary=*/nullptr,
                                      /*ImportSummary=*/nullptr,
                                      /*DropTypeTests=*/true));
@@ -702,83 +703,86 @@
   if (LangOpts.Coroutines)
     addCoroutinePassesToExtensionPoints(PMBuilder);
 
-  if (!CodeGenOpts.MemoryProfileOutput.empty()) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addMemProfilerPasses);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addMemProfilerPasses);
-  }
+  if (!IsDistributedThinLTOTesting) {
+    // IsDistributedThinLTOTesting instrumented on ThinLTOPreLink.
+    if (!CodeGenOpts.MemoryProfileOutput.empty()) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addMemProfilerPasses);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addMemProfilerPasses);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
-                           addBoundsCheckingPass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addBoundsCheckingPass);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
+                             addBoundsCheckingPass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addBoundsCheckingPass);
+    }
 
-  if (CodeGenOpts.SanitizeCoverageType ||
-      CodeGenOpts.SanitizeCoverageIndirectCalls ||
-      CodeGenOpts.SanitizeCoverageTraceCmp) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addSanitizerCoveragePass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addSanitizerCoveragePass);
-  }
+    if (CodeGenOpts.SanitizeCoverageType ||
+        CodeGenOpts.SanitizeCoverageIndirectCalls ||
+        CodeGenOpts.SanitizeCoverageTraceCmp) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addSanitizerCoveragePass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addSanitizerCoveragePass);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addAddressSanitizerPasses);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addAddressSanitizerPasses);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addAddressSanitizerPasses);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addAddressSanitizerPasses);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addKernelAddressSanitizerPasses);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addKernelAddressSanitizerPasses);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::KernelAddress)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addKernelAddressSanitizerPasses);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addKernelAddressSanitizerPasses);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addHWAddressSanitizerPasses);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addHWAddressSanitizerPasses);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::HWAddress)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addHWAddressSanitizerPasses);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addHWAddressSanitizerPasses);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addKernelHWAddressSanitizerPasses);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addKernelHWAddressSanitizerPasses);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::KernelHWAddress)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addKernelHWAddressSanitizerPasses);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addKernelHWAddressSanitizerPasses);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addMemorySanitizerPass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addMemorySanitizerPass);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addMemorySanitizerPass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addMemorySanitizerPass);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addKernelMemorySanitizerPass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addKernelMemorySanitizerPass);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::KernelMemory)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addKernelMemorySanitizerPass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addKernelMemorySanitizerPass);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addThreadSanitizerPass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addThreadSanitizerPass);
-  }
+    if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addThreadSanitizerPass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addThreadSanitizerPass);
+    }
 
-  if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
-    PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
-                           addDataFlowSanitizerPass);
-    PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
-                           addDataFlowSanitizerPass);
+    if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
+      PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
+                             addDataFlowSanitizerPass);
+      PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
+                             addDataFlowSanitizerPass);
+    }
   }
 
   // Set up the per-function pass manager.
@@ -1222,10 +1226,11 @@
 
     // If we reached here with a non-empty index file name, then the index
     // file was empty and we are not performing ThinLTO backend compilation
-    // (used in testing in a distributed build environment). Drop any the type
-    // test assume sequences inserted for whole program vtables so that
-    // codegen doesn't complain.
-    if (!CodeGenOpts.ThinLTOIndexFile.empty())
+    // (used in testing in a distributed build environment).
+    bool IsDistributedThinLTOTesting = !CodeGenOpts.ThinLTOIndexFile.empty();
+    // Drop any the type test assume sequences inserted for whole program
+    // vtables so that codegen doesn't complain.
+    if (IsDistributedThinLTOTesting)
       PB.registerPipelineStartEPCallback(
           [](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
             MPM.addPass(LowerTypeTestsPass(/*ExportSummary=*/nullptr,
@@ -1241,88 +1246,95 @@
           });
     }
 
-    // Register callbacks to schedule sanitizer passes at the appropriate part
-    // of the pipeline.
-    if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
-      PB.registerScalarOptimizerLateEPCallback(
-          [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
-            FPM.addPass(BoundsCheckingPass());
-          });
-
-    if (CodeGenOpts.SanitizeCoverageType ||
-        CodeGenOpts.SanitizeCoverageIndirectCalls ||
-        CodeGenOpts.SanitizeCoverageTraceCmp) {
-      PB.registerOptimizerLastEPCallback(
-          [this](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
-            auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);
-            MPM.addPass(ModuleSanitizerCoveragePass(
-                SancovOpts, CodeGenOpts.SanitizeCoverageAllowlistFiles,
-                CodeGenOpts.SanitizeCoverageBlocklistFiles));
-          });
-    }
+    // IsDistributedThinLTOTesting instrumented on ThinLTOPreLink.
+    if (!IsDistributedThinLTOTesting) {
+      // Register callbacks to schedule sanitizer passes at the appropriate part
+      // of the pipeline.
+      if (LangOpts.Sanitize.has(SanitizerKind::LocalBounds))
+        PB.registerScalarOptimizerLateEPCallback(
+            [](FunctionPassManager &FPM, PassBuilder::OptimizationLevel Level) {
+              FPM.addPass(BoundsCheckingPass());
+            });
 
-    if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
-      int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;
-      bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::Memory);
-      PB.registerOptimizerLastEPCallback(
-          [TrackOrigins, Recover](ModulePassManager &MPM,
-                                  PassBuilder::OptimizationLevel Level) {
-            MPM.addPass(MemorySanitizerPass({TrackOrigins, Recover, false}));
-            MPM.addPass(createModuleToFunctionPassAdaptor(
-                MemorySanitizerPass({TrackOrigins, Recover, false})));
-          });
-    }
-    if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
-      PB.registerOptimizerLastEPCallback(
-          [](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
-            MPM.addPass(ThreadSanitizerPass());
-            MPM.addPass(
-                createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
-          });
-    }
+      if (CodeGenOpts.SanitizeCoverageType ||
+          CodeGenOpts.SanitizeCoverageIndirectCalls ||
+          CodeGenOpts.SanitizeCoverageTraceCmp) {
+        PB.registerOptimizerLastEPCallback(
+            [this](ModulePassManager &MPM,
+                   PassBuilder::OptimizationLevel Level) {
+              auto SancovOpts = getSancovOptsFromCGOpts(CodeGenOpts);
+              MPM.addPass(ModuleSanitizerCoveragePass(
+                  SancovOpts, CodeGenOpts.SanitizeCoverageAllowlistFiles,
+                  CodeGenOpts.SanitizeCoverageBlocklistFiles));
+            });
+      }
 
-    auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
-      if (LangOpts.Sanitize.has(Mask)) {
-        bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
-        bool UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
-        bool ModuleUseAfterScope = asanUseGlobalsGC(TargetTriple, CodeGenOpts);
-        bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
+      if (LangOpts.Sanitize.has(SanitizerKind::Memory)) {
+        int TrackOrigins = CodeGenOpts.SanitizeMemoryTrackOrigins;
+        bool Recover = CodeGenOpts.SanitizeRecover.has(SanitizerKind::Memory);
         PB.registerOptimizerLastEPCallback(
-            [CompileKernel, Recover, UseAfterScope, ModuleUseAfterScope,
-             UseOdrIndicator](ModulePassManager &MPM,
-                              PassBuilder::OptimizationLevel Level) {
-              MPM.addPass(
-                  RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
-              MPM.addPass(ModuleAddressSanitizerPass(CompileKernel, Recover,
-                                                     ModuleUseAfterScope,
-                                                     UseOdrIndicator));
+            [TrackOrigins, Recover](ModulePassManager &MPM,
+                                    PassBuilder::OptimizationLevel Level) {
+              MPM.addPass(MemorySanitizerPass({TrackOrigins, Recover, false}));
               MPM.addPass(createModuleToFunctionPassAdaptor(
-                  AddressSanitizerPass(CompileKernel, Recover, UseAfterScope)));
+                  MemorySanitizerPass({TrackOrigins, Recover, false})));
             });
       }
-    };
-    ASanPass(SanitizerKind::Address, false);
-    ASanPass(SanitizerKind::KernelAddress, true);
-
-    auto HWASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
-      if (LangOpts.Sanitize.has(Mask)) {
-        bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
+      if (LangOpts.Sanitize.has(SanitizerKind::Thread)) {
         PB.registerOptimizerLastEPCallback(
-            [CompileKernel, Recover](ModulePassManager &MPM,
-                                     PassBuilder::OptimizationLevel Level) {
-              MPM.addPass(HWAddressSanitizerPass(CompileKernel, Recover));
+            [](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
+              MPM.addPass(ThreadSanitizerPass());
+              MPM.addPass(
+                  createModuleToFunctionPassAdaptor(ThreadSanitizerPass()));
             });
       }
-    };
-    HWASanPass(SanitizerKind::HWAddress, false);
-    HWASanPass(SanitizerKind::KernelHWAddress, true);
 
-    if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
-      PB.registerOptimizerLastEPCallback(
-          [this](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
-            MPM.addPass(
-                DataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
-          });
+      auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
+        if (LangOpts.Sanitize.has(Mask)) {
+          bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
+          bool UseAfterScope = CodeGenOpts.SanitizeAddressUseAfterScope;
+          bool ModuleUseAfterScope =
+              asanUseGlobalsGC(TargetTriple, CodeGenOpts);
+          bool UseOdrIndicator = CodeGenOpts.SanitizeAddressUseOdrIndicator;
+          PB.registerOptimizerLastEPCallback(
+              [CompileKernel, Recover, UseAfterScope, ModuleUseAfterScope,
+               UseOdrIndicator](ModulePassManager &MPM,
+                                PassBuilder::OptimizationLevel Level) {
+                MPM.addPass(
+                    RequireAnalysisPass<ASanGlobalsMetadataAnalysis, Module>());
+                MPM.addPass(ModuleAddressSanitizerPass(CompileKernel, Recover,
+                                                       ModuleUseAfterScope,
+                                                       UseOdrIndicator));
+                MPM.addPass(
+                    createModuleToFunctionPassAdaptor(AddressSanitizerPass(
+                        CompileKernel, Recover, UseAfterScope)));
+              });
+        }
+      };
+      ASanPass(SanitizerKind::Address, false);
+      ASanPass(SanitizerKind::KernelAddress, true);
+
+      auto HWASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
+        if (LangOpts.Sanitize.has(Mask)) {
+          bool Recover = CodeGenOpts.SanitizeRecover.has(Mask);
+          PB.registerOptimizerLastEPCallback(
+              [CompileKernel, Recover](ModulePassManager &MPM,
+                                       PassBuilder::OptimizationLevel Level) {
+                MPM.addPass(HWAddressSanitizerPass(CompileKernel, Recover));
+              });
+        }
+      };
+      HWASanPass(SanitizerKind::HWAddress, false);
+      HWASanPass(SanitizerKind::KernelHWAddress, true);
+
+      if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
+        PB.registerOptimizerLastEPCallback(
+            [this](ModulePassManager &MPM,
+                   PassBuilder::OptimizationLevel Level) {
+              MPM.addPass(
+                  DataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
+            });
+      }
     }
 
     if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts, LangOpts))
@@ -1349,7 +1361,9 @@
       MPM = PB.buildPerModuleDefaultPipeline(Level);
     }
 
-    if (!CodeGenOpts.MemoryProfileOutput.empty()) {
+    // IsDistributedThinLTOTesting instrumented on ThinLTOPreLink.
+    if (!IsDistributedThinLTOTesting &&
+        !CodeGenOpts.MemoryProfileOutput.empty()) {
       MPM.addPass(createModuleToFunctionPassAdaptor(MemProfilerPass()));
       MPM.addPass(ModuleMemProfilerPass());
     }
diff --git a/clang/test/CodeGen/thinlto-distributed-backend-skip-sanitizer.ll b/clang/test/CodeGen/thinlto-distributed-backend-skip-sanitizer.ll
new file mode 100644
--- /dev/null
+++ b/clang/test/CodeGen/thinlto-distributed-backend-skip-sanitizer.ll
@@ -0,0 +1,109 @@
+; REQUIRES: x86-registered-target
+
+; Check that ThinLTO backend respects "SkipModuleByDistributedBackend"
+; flag which can be set by indexing.
+
+; RUN: opt -thinlto-bc -o %t.o %s
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fmemory-profile=/dev/null \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=memprof
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=local-bounds \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=trap
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize-coverage-type=1 \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=sanitizer_cov
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=address \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-address \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=hwaddress \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-hwaddress \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=thread \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=tsan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=memory \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=msan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-memory \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=msan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=dataflow \
+; RUN:   -fthinlto-index=/dev/null \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=dfsan
+
+; Lagacy PM
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fmemory-profile=/dev/null \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=memprof
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=local-bounds \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=trap
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize-coverage-type=1 \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=sanitizer_cov
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=address \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-address \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=hwaddress \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-hwaddress \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=asan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=thread \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=tsan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=memory \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=msan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=kernel-memory \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=msan
+
+; RUN: %clang_cc1 -triple x86_64-grtev4-linux-gnu -fsanitize=dataflow \
+; RUN:   -fthinlto-index=/dev/null -flegacy-pass-manager \
+; RUN:   -emit-llvm -o - -x ir %t.o | FileCheck %s --implicit-check-not=dfsan
+
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-grtev4-linux-gnu"
+
+define void @test(i64 %i) sanitize_address sanitize_thread sanitize_hwaddress {
+; CHECK-LABEL: entry:
+entry:
+  %a = alloca [2 x i8], align 1
+  %0 = getelementptr inbounds [2 x i8], [2 x i8]* %a, i64 0, i64 0
+  %arrayidx = getelementptr inbounds [2 x i8], [2 x i8]* %a, i64 0, i64 %i
+  store i8 3, i8* %arrayidx, align 1
+; CHECK: ret
+  ret void
+}
\ No newline at end of file