[hwasan] Use stack safety analysis.

[fmayer]

Summary

This avoids unnecessary instrumentation.

[fmayer]

Formatting again.

[fmayer]

Formatting.

[fmayer]

update

[eugenis]

The analysis should not run at -O0.
Otherwise, LGTM.
What kind of code size improvement do you see?

[vitalybuka]

clang/test/CodeGen/hwasan-stack-safety-analysis-asm.c

5

this patch mostly change code under llvm/ so tests should be also there, as IR tests

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

Why not from M.getTargetTriple() ?

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

200

Could you please extract these function in a separate patch?
LLVM likes small close to NFC patches.

392

why we need to check TargetTriple for that?

1278

Instead of // clang-format off
could you replace this with

# comment1
if (...)
  return false;

# comment2
if (...)
  return false;
...

in a separate patch?

[fmayer]

Address some comments.

[fmayer]

fixup

[fmayer]

rebase

[fmayer]

fixup

[fmayer]

Addressed inline comments.

clang/test/CodeGen/hwasan-stack-safety-analysis-asm.c

5

I don't have strong feelings, but clang/test/CodeGen/lifetime-sanitizer.c is a very similar test, so I think we should either move all of these to llvm/ or add the new ones here to clang/. What do you think?

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

Mostly for consistency with the legacy pass. Either way is fine for me though, what do you prefer?

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

392

Because we only need the stack safety analysis if we instrument the stack, which we do not do on x86_64 (see shouldInstrumentStack).

1278

OK, will do in a followup (or see how I can get clang-tidy to do the right thing here).

[fmayer]

rebase

[vitalybuka]

Other than missing llvm test is LGTM

clang/test/CodeGen/hwasan-stack-safety-analysis-asm.c

5

That lifetime tests how clang inserts lifetime markers. So it must be in clang/ this is from https://reviews.llvm.org/D20759 which is clang only patch.
Here the only change for clang is forwarded BuilderWrapper.getTargetTriple().
I don't mind if you keep your tests here, but we also need something which tests llvm without clang as you change llvm tranformation.
Usually if contributor changes code in llvm/, expectation is that check-llvm should discover regression. It's not always possible, but that's the goal and easy to do with this patch.

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

I don't know if will cause any issues, but usually most passes get triple from the module.
I prefer we stay consistent with the rest of the code if possible.

39

!IsOptNull -> Optimize
or
IsOptNull -> DisableOptimization

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

392

I see, I forgot about this limitation.
LGTM, but unconditional is fine as well, assuming we are going to have stack instrumentation at some point?

433

we usually don't use {} for single line
also maybe good candidate for ?: operator

[fmayer]

address comments

[fmayer]

Thanks!

clang/test/CodeGen/hwasan-stack-safety-analysis-asm.c

5

Thanks for the explanation. Moved to llvm/.

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

I'll leave it as is, for consistency within this file, as we need to do it this way for the new pass manager.

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

392

I am not sure we will ever add it for non-LAM x86_64.

433

I think this would make a bit of a long tenary expression.

[fmayer]

fixup

[eugenis]

llvm/test/CodeGen/hwasan-stack-safety-analysis-asm.c

1 ↗

(On Diff #358885)

You can't use %clang in LLVM tests. There may be no clang. Use opt to invoke the hwasan pass in isolation, see the tests under test/Instrumentation/HWAddressSanitizer/.

The reason I did not say anything about the tests was because only in clang we can test this thing end-to-end.
Perhaps an LLVM test for instrumentation + a clang test for the passmanager (use -fdebug-pass-manager and -mllvm -debug-pass=Structure for new/old).

[vitalybuka]

llvm/test/CodeGen/hwasan-stack-safety-analysis-asm.c

8 ↗

(On Diff #358885)

these tests do not work because %clang is not defined here, in LLVM
you can keep them but they need to stay in clang/

my request was to add new tests in llvm-project/llvm/test/Instrumentation/HWAddressSanitizer/
and they need to be *.ll tests
you probably can generate them from C and cleanup manually
or close existing *.ll tests and CHECK for expected difference if analysis is enabled

Also try to generated CHECK statements with llvm/utils/update_test_checks.py, often result is quite useful.

[vitalybuka]

Remove triple

[vitalybuka]

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

That's what I don't like, passing Triple from BackendUtil.cpp
I've updated the patch. You can download it with "arc patch D105703"

[vitalybuka]

Please create *.ll tests, the rest is LGTM

[fmayer]

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

OK, no strong feelings but now we addRequire the pass even if we don't need it, so there isn't much point turning it off anymore, no?

[fmayer]

update

[fmayer]

add llvm test

[fmayer]

llvm/test/CodeGen/hwasan-stack-safety-analysis-asm.c

1 ↗

(On Diff #358885)

added an extra llvm test to check from IR, and left the existing clang end to end tests..

8 ↗

(On Diff #358885)

added llvm test.

[eugenis]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

402

No need to pass this down, just look at OptimizeNone function attribute.

[fmayer]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

402

Interesting, the Aarch64StackTagging code does pass this down, do you know why?

[fmayer]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

402

Also we really should be using this at least in the getAnalysisUsage, which Vitaly's change made unconditional. Correct?

[fmayer]

don't use stack analysis for opt null

[eugenis]

LGTM

clang/lib/CodeGen/BackendUtil.cpp

1172

DisableOptimization=

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

402

Ah right. Legacy pass needs to declare its analysis dependencies in advance.

[fmayer]

fix comment.

[eugenis]

Btw Vitaly, will this work with LTO out of the box? I think we used to add pre-LTO StackSafety pass explicitly for memtag only, but it looks like that code is gone.

[vitalybuka]

In D105703#2883666, @eugenis wrote:

Btw Vitaly, will this work with LTO out of the box? I think we used to add pre-LTO StackSafety pass explicitly for memtag only, but it looks like that code is gone.

What do you mean gone? Can you show me the patch?

We probably needs something to add analysis for HWASAN as well.

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

32

In case of legacy pass? Correct. I don't think we need to over optimize this deprecated case which is going to be removed at some point anyway.
Let's check DisableOptimization as we have it here anyway, but avoid forwarding Triple.

For new PM it's irrelevant as it's does not declare requirements in advance.

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

421

@eugenis unrelated to the patch, but why do we this args if then we assert(!CompileKernel || Recover);

llvm/test/Instrumentation/HWAddressSanitizer/stack-safety-analysis.ll

5 ↗

(On Diff #359376)

you don't need to hardcode local path here

10 ↗

(On Diff #359376)

would be nice to have also function which have __hwasan_generate_tag in either case to make sure
-hwasan-use-stack-safety=1 does not disable tagging completely.

27 ↗

(On Diff #359376)

usually we remove irrelevant attributes #* and module flags !* to make test simpler

[eugenis]

In D105703#2884056, @vitalybuka wrote:

In D105703#2883666, @eugenis wrote:

Btw Vitaly, will this work with LTO out of the box? I think we used to add pre-LTO StackSafety pass explicitly for memtag only, but it looks like that code is gone.

What do you mean gone? Can you show me the patch?

We probably needs something to add analysis for HWASAN as well.

https://reviews.llvm.org/D80771

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

421

why not? This forbids CompileKernel && !Recover, how else would you represent the 3 remaining combinations?

[vitalybuka]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

421

why not? This forbids CompileKernel && !Recover, how else would you represent the 3 remaining combinations?

Thanks. I've misread the expression.

[fmayer]

improve test.

[fmayer]

style fix

[fmayer]

update

llvm/test/Instrumentation/HWAddressSanitizer/stack-safety-analysis.ll

27 ↗

(On Diff #359376)

Removed all sorts of unneeded stuff. Thanks.

[fmayer]

rebase.

[fmayer]

Broke some postsubmit bot.

[fmayer]

remove stack safety asm test.

[fmayer]

I removed the stack-safety-analysis-asm.c test because I don't think it really adds anything and it caused problems. SGTY?

[eugenis]

In D105703#2887005, @fmayer wrote:

I removed the stack-safety-analysis-asm.c test because I don't think it really adds anything and it caused problems. SGTY?

Absolutely.

LGTM

[fmayer]

format

[fmayer]

Made some buildbot unhappy again. Sorry :(

[fmayer]

fix required analysis logic

[vitalybuka]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

394

I like this even less than "plumbing", if you need shouldUseStackSafetyAnalysis please just pass Triple as in earlier versions.

Why do you need to avoid loading analysis? Revert does not explain what is broken.

[fmayer]

This broke https://lab.llvm.org/buildbot/#/builders/105/builds/12584.

[fmayer]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

394

I am still looking at the breakage. But if you looked at the logic before, there was the case DisableOptimization BUT ClUseStackAnalysis being explicitly set, which made us try to getAnalysis without having required it here.

I also like the plumbing more than this, but changed to this to see what you think.

[vitalybuka]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

398

Why not just:

if (!DisableOptimization || ClUseStackSafety)
  AU.addRequired<StackSafetyGlobalInfoWrapperPass>();

[fmayer]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

398

Because ClUseStackSafety defaults to true, so this will be quite useless except if the user explicitly sets it to false. So then you end up duplicating the logic in shouldUseStackSafetyAnalysis, which is why I went for the Dummy (thinking about it, we don't actually need to setArch on it).

[fmayer]

more flag parsing.

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

398

How about this (mightUseStackSafetyAnalysis)? This seems like a nice tradeoff without duplication of the logic.

[vitalybuka]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

395

I think this function without comment is clear enough. But up to you.

398

LGTM

[fmayer]

formatting.

[fmayer]

Sorry. broke a buildbot again: https://lab.llvm.org/buildbot/#/builders/139/builds/7613/steps/6/logs/FAIL__Clang__asan_c

I am not sure why I cannot reproduce this locally.

Pass 'HWAddressSanitizer' is not initialized.
Verify if there is a pass dependency cycle.
Required Passes:
clang: /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:715: void llvm::PMTopLevelManager::schedulePass(llvm::Pass*): Assertion `PI && "Expected required passes to be initialized"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.

[vitalybuka]

Do you build with assertions enabled (-DLLVM_ENABLE_ASSERTIONS=ON")?

In D105703#2896056, @fmayer wrote:

Sorry. broke a buildbot again: https://lab.llvm.org/buildbot/#/builders/139/builds/7613/steps/6/logs/FAIL__Clang__asan_c

I am not sure why I cannot reproduce this locally.

Pass 'HWAddressSanitizer' is not initialized.
Verify if there is a pass dependency cycle.
Required Passes:
clang: /home/buildbot/buildbot-root/llvm-clang-x86_64-sie-ubuntu-fast/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:715: void llvm::PMTopLevelManager::schedulePass(llvm::Pass*): Assertion `PI && "Expected required passes to be initialized"' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.

[vitalybuka]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

409

To fix that revert you need to add

INITIALIZE_PASS_DEPENDENCY(StackSafetyGlobalInfoWrapperPass)

[vitalybuka]

fix crash

[vitalybuka]

In D105703#2898343, @vitalybuka wrote:

fix crash

weird, my config with -DLLVM_ENABLE_ASSERTIONS=ON does not reproduce, however exact cmake from bot does

[vitalybuka]

In D105703#2898350, @vitalybuka wrote:

In D105703#2898343, @vitalybuka wrote:

fix crash

weird, my config with -DLLVM_ENABLE_ASSERTIONS=ON does not reproduce, however exact cmake from bot does

-DLLVM_TARGETS_TO_BUILD=X86 was needed as well

clang/lib/CodeGen/BackendUtil.cpp

 }
 
 static void addHWAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                             legacy::PassManagerBase &PM) {
   const PassManagerBuilderWrapper &BuilderWrapper =
       static_cast<const PassManagerBuilderWrapper &>(Builder);
   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
   bool Recover = CGOpts.SanitizeRecover.has(SanitizerKind::HWAddress);
-  PM.add(
-      createHWAddressSanitizerLegacyPassPass(/*CompileKernel*/ false, Recover));
+  PM.add(createHWAddressSanitizerLegacyPassPass(
+      /*CompileKernel*/ false, Recover, BuilderWrapper.getTargetTriple()));
 }
 
 static void addKernelHWAddressSanitizerPasses(const PassManagerBuilder &Builder,
                                             legacy::PassManagerBase &PM) {
+  const PassManagerBuilderWrapper &BuilderWrapper =
+      static_cast<const PassManagerBuilderWrapper &>(Builder);
   PM.add(createHWAddressSanitizerLegacyPassPass(
-      /*CompileKernel*/ true, /*Recover*/ true));
+      /*CompileKernel*/ true, /*Recover*/ true,
+      BuilderWrapper.getTargetTriple()));
 }
 
 static void addGeneralOptsForMemorySanitizer(const PassManagerBuilder &Builder,
                                              legacy::PassManagerBase &PM,
                                              bool CompileKernel) {
   const PassManagerBuilderWrapper &BuilderWrapper =
       static_cast<const PassManagerBuilderWrapper&>(Builder);
   const CodeGenOptions &CGOpts = BuilderWrapper.getCGOpts();
auto ASanPass = [&](SanitizerMask Mask, bool CompileKernel) {
       }
     };
     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);
-        MPM.addPass(HWAddressSanitizerPass(CompileKernel, Recover));
+        MPM.addPass(
+            HWAddressSanitizerPass(CompileKernel, Recover, TargetTriple));
       }
     };
     HWASanPass(SanitizerKind::HWAddress, false);
     HWASanPass(SanitizerKind::KernelHWAddress, true);
 
     if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
       MPM.addPass(DataFlowSanitizerPass(LangOpts.NoSanitizeFiles));
     }
   });

clang/test/CodeGen/hwasan-stack-safety-analysis-asm.c

+// RUN: %clang -fsanitize=hwaddress -target aarch64-linux-gnu -S -mllvm -hwasan-use-stack-safety=true -mllvm -hwasan-generate-tags-with-calls -O2 %s -o - | FileCheck %s --check-prefix=SAFETY
+// RUN: %clang -fsanitize=hwaddress -target aarch64-linux-gnu -S -mllvm -hwasan-use-stack-safety=false -mllvm -hwasan-generate-tags-with-calls -O2 %s -o - | FileCheck %s --check-prefix=NOSAFETY
+
+int main(int argc, char **argv) {
+  char buf[10];
+  volatile char *x = buf;
+  *x = 0;
+  return buf[0];
+  // NOSAFETY: __hwasan_generate_tag
+  // SAFETY-NOT: __hwasan_generate_tag
+}

clang/test/CodeGen/hwasan-stack-safety-analysis.c

+// RUN: %clang -fsanitize=hwaddress -target aarch64-linux-gnu -S -emit-llvm -mllvm -hwasan-use-stack-safety=true -mllvm -hwasan-generate-tags-with-calls -O2 %s -o - | FileCheck %s --check-prefix=SAFETY
+// RUN: %clang -fsanitize=hwaddress -target aarch64-linux-gnu -S -emit-llvm -mllvm -hwasan-use-stack-safety=false -mllvm -hwasan-generate-tags-with-calls -O2 %s -o - | FileCheck %s --check-prefix=NOSAFETY
+
+int main(int argc, char **argv) {
+  char buf[10];
+  volatile char *x = buf;
+  *x = 0;
+  return buf[0];
+  // NOSAFETY: __hwasan_generate_tag
+  // SAFETY-NOT: __hwasan_generate_tag
+}

llvm/include/llvm/Transforms/Instrumentation/HWAddressSanitizer.h

 //===--------- Definition of the HWAddressSanitizer class -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the Hardware AddressSanitizer class which is a port of the
 // legacy HWAddressSanitizer pass to use the new PassManager infrastructure.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TRANSFORMS_INSTRUMENTATION_HWADDRESSSANITIZER_H
 #define LLVM_TRANSFORMS_INSTRUMENTATION_HWADDRESSSANITIZER_H
 
+#include "llvm/ADT/Triple.h"
+
 #include "llvm/IR/Function.h"
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
 /// This is a public interface to the hardware address sanitizer pass for
 /// instrumenting code to check for various memory errors at runtime, similar to
 /// AddressSanitizer but based on partial hardware assistance.
 class HWAddressSanitizerPass : public PassInfoMixin<HWAddressSanitizerPass> {
 public:
   explicit HWAddressSanitizerPass(bool CompileKernel = false,
-                                  bool Recover = false);
+                                  bool Recover = false,
+                                  Triple TargetTriple = {});
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
   static bool isRequired() { return true; }
 
 private:
   bool CompileKernel;
   bool Recover;
+  Triple TargetTriple;
 };
 
 FunctionPass *createHWAddressSanitizerLegacyPassPass(bool CompileKernel = false,
-                                                     bool Recover = false);
+                                                     bool Recover = false,
+                                                     Triple TargetTriple = {});
 
 namespace HWASanAccessInfo {
 
 // Bit field positions for the accessinfo parameter to
 // llvm.hwasan.check.memaccess. Shared between the pass and the backend. Bits
 // 0-15 are also used by the runtime.
 enum {
   AccessSizeShift = 0, // 4 bits

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
static cl::opt<bool>
     ClRecover("hwasan-recover",
               cl::desc("Enable recovery mode (continue-after-error)."),
               cl::Hidden, cl::init(false));
 
 static cl::opt<bool> ClInstrumentStack("hwasan-instrument-stack",
                                        cl::desc("instrument stack (allocas)"),
                                        cl::Hidden, cl::init(true));
 
+static cl::opt<bool>
+    ClUseStackSafety("hwasan-use-stack-safety", cl::Hidden, cl::init(true),
+                     cl::Hidden, cl::desc("Use Stack Safety analysis results"));
+
 static cl::opt<bool> ClUARRetagToZero(
     "hwasan-uar-retag-to-zero",
     cl::desc("Clear alloca tags before returning from the function to allow "
              "non-instrumented and instrumented function calls mix. When set "
              "to false, allocas are retagged before returning from the "
              "function to detect use after return."),
     cl::Hidden, cl::init(true));
 

 
 // Enabled from clang by "-fsanitize-hwaddress-experimental-aliasing".
 static cl::opt<bool> ClUsePageAliases("hwasan-experimental-use-page-aliases",
                                       cl::desc("Use page aliasing in HWASan"),
                                       cl::Hidden, cl::init(false));
 
 namespace {
 
+bool shouldUsePageAliases(const Triple &TargetTriple) {
+  bool IsX86_64 = TargetTriple.getArch() == Triple::x86_64;
+  return ClUsePageAliases && IsX86_64;
+// No one should use the option directly.
+#pragma GCC poison ClUsePageAliases
+}
+
+bool shouldInstrumentStack(const Triple &TargetTriple) {
+  return shouldUsePageAliases(TargetTriple) ? false : ClInstrumentStack;
+// No one should use the option directly.
+#pragma GCC poison ClInstrumentStack
+}
+
+bool shouldUseStackSafetyAnalysis(const Triple &TargetTriple) {
+  return shouldInstrumentStack(TargetTriple) && ClUseStackSafety;
+// No one should use the option directly.
+#pragma GCC poison ClUseStackSafety
+}
 /// An instrumentation pass implementing detection of addressability bugs
 /// using tagged pointers.
 class HWAddressSanitizer {
 public:
   explicit HWAddressSanitizer(Module &M, bool CompileKernel = false,
-                              bool Recover = false)
-      : M(M) {
+                              bool Recover = false,
+                              const StackSafetyGlobalInfo *SSI = nullptr)
+      : M(M), SSI(SSI) {
     this->Recover = ClRecover.getNumOccurrences() > 0 ? ClRecover : Recover;
     this->CompileKernel = ClEnableKhwasan.getNumOccurrences() > 0
                               ? ClEnableKhwasan
                               : CompileKernel;
 
     initializeModule();
   }
 
+  void setSSI(const StackSafetyGlobalInfo *S) { SSI = S; }
+
   bool sanitizeFunction(Function &F);
   void initializeModule();
   void createHwasanCtorComdat();
 
   void initializeCallbacks(Module &M);
 
   Value *getOpaqueNoopCast(IRBuilder<> &IRB, Value *Val);
 
public:
   void instrumentGlobal(GlobalVariable *GV, uint8_t Tag);
   void instrumentGlobals();
 
   void instrumentPersonalityFunctions();
 
 private:
   LLVMContext *C;
   Module &M;
+  const StackSafetyGlobalInfo *SSI;
   Triple TargetTriple;
   FunctionCallee HWAsanMemmove, HWAsanMemcpy, HWAsanMemset;
   FunctionCallee HWAsanHandleVfork;
 
   /// This struct defines the shadow mapping using the rule:
   ///   shadow = (mem >> Scale) + Offset.
   /// If InGlobal is true, then
   ///   extern char __hwasan_shadow[];

 };
 
 class HWAddressSanitizerLegacyPass : public FunctionPass {
 public:
   // Pass identification, replacement for typeid.
   static char ID;
 
   explicit HWAddressSanitizerLegacyPass(bool CompileKernel = false,
-                                        bool Recover = false)
-      : FunctionPass(ID), CompileKernel(CompileKernel), Recover(Recover) {
+                                        bool Recover = false,
+                                        Triple TargetTriple = {})
+      : FunctionPass(ID), CompileKernel(CompileKernel), Recover(Recover),
+        TargetTriple(TargetTriple) {
     initializeHWAddressSanitizerLegacyPassPass(
         *PassRegistry::getPassRegistry());
   }
 
   StringRef getPassName() const override { return "HWAddressSanitizer"; }
 
   bool doInitialization(Module &M) override {
-    HWASan = std::make_unique<HWAddressSanitizer>(M, CompileKernel, Recover);
+    const StackSafetyGlobalInfo *SSI = nullptr;
+    HWASan =
+        std::make_unique<HWAddressSanitizer>(M, CompileKernel, Recover, SSI);
     return true;
   }
 
   bool runOnFunction(Function &F) override {
+    if (shouldUseStackSafetyAnalysis(TargetTriple)) {
+      // We cannot call getAnalysis in doInitialization, that would cause a
+      // crash as the required analyses are not initialized yet.
+      HWASan->setSSI(
+          &getAnalysis<StackSafetyGlobalInfoWrapperPass>().getResult());
+    }
     return HWASan->sanitizeFunction(F);
   }
 
   bool doFinalization(Module &M) override {
     HWASan.reset();
     return false;
   }
 
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesCFG();
+    if (shouldUseStackSafetyAnalysis(TargetTriple)) {
+      AU.addRequired<StackSafetyGlobalInfoWrapperPass>();
+    }
+  }
+
 private:
   std::unique_ptr<HWAddressSanitizer> HWASan;
   bool CompileKernel;
   bool Recover;
+  Triple TargetTriple;
 };
 
 } // end anonymous namespace
 
 char HWAddressSanitizerLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(
     HWAddressSanitizerLegacyPass, "hwasan",
     "HWAddressSanitizer: detect memory bugs using tagged addressing.", false,
     false)
 INITIALIZE_PASS_END(
     HWAddressSanitizerLegacyPass, "hwasan",
     "HWAddressSanitizer: detect memory bugs using tagged addressing.", false,
     false)
 
-FunctionPass *llvm::createHWAddressSanitizerLegacyPassPass(bool CompileKernel,
-                                                           bool Recover) {
+FunctionPass *
+llvm::createHWAddressSanitizerLegacyPassPass(bool CompileKernel, bool Recover,
+                                             Triple TargetTriple) {
   assert(!CompileKernel || Recover);
-  return new HWAddressSanitizerLegacyPass(CompileKernel, Recover);
+  return new HWAddressSanitizerLegacyPass(CompileKernel, Recover, TargetTriple);
 }
 
-HWAddressSanitizerPass::HWAddressSanitizerPass(bool CompileKernel, bool Recover)
-    : CompileKernel(CompileKernel), Recover(Recover) {}
+HWAddressSanitizerPass::HWAddressSanitizerPass(bool CompileKernel, bool Recover,
+                                               Triple TargetTriple)
+    : CompileKernel(CompileKernel), Recover(Recover),
+      TargetTriple(TargetTriple) {}
 
 PreservedAnalyses HWAddressSanitizerPass::run(Module &M,
                                               ModuleAnalysisManager &MAM) {
-  HWAddressSanitizer HWASan(M, CompileKernel, Recover);
+  const StackSafetyGlobalInfo *SSI = nullptr;
+  if (shouldUseStackSafetyAnalysis(TargetTriple)) {
+    SSI = &MAM.getResult<StackSafetyGlobalAnalysis>(M);
+  }
+  HWAddressSanitizer HWASan(M, CompileKernel, Recover, SSI);
   bool Modified = false;
   for (Function &F : M)
     Modified |= HWASan.sanitizeFunction(F);
   if (Modified)
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
 
void HWAddressSanitizer::initializeModule() {
   auto &DL = M.getDataLayout();
 
   TargetTriple = Triple(M.getTargetTriple());
 
   // x86_64 currently has two modes:
   // - Intel LAM (default)
   // - pointer aliasing (heap only)
   bool IsX86_64 = TargetTriple.getArch() == Triple::x86_64;
-  UsePageAliases = ClUsePageAliases && IsX86_64;
+  UsePageAliases = shouldUsePageAliases(TargetTriple);
   InstrumentWithCalls = IsX86_64 ? true : ClInstrumentWithCalls;
-  InstrumentStack = UsePageAliases ? false : ClInstrumentStack;
+  InstrumentStack = shouldInstrumentStack(TargetTriple);
   PointerTagShift = IsX86_64 ? 57 : 56;
   TagMaskByte = IsX86_64 ? 0x3F : 0xFF;
 
   Mapping.init(TargetTriple, InstrumentWithCalls);
 
   C = &(M.getContext());
   IRBuilder<> IRB(*C);
   IntptrTy = IRB.getIntPtrTy(DL);
for (auto RI : RetVec) {
       tagAlloca(IRB, AI, Tag, alignTo(Size, Mapping.getObjectAlignment()));
     }
   }
 
   return true;
 }
 
 bool HWAddressSanitizer::isInterestingAlloca(const AllocaInst &AI) {
   return (AI.getAllocatedType()->isSized() &&
           // FIXME: instrument dynamic allocas, too
           AI.isStaticAlloca() &&
           // alloca() may be called with 0 size, ignore it.
           getAllocaSizeInBytes(AI) > 0 &&
           // We are only interested in allocas not promotable to registers.
           // Promotable allocas are common under -O0.
           !isAllocaPromotable(&AI) &&
           // inalloca allocas are not treated as static, and we don't want
           // dynamic alloca instrumentation for them as well.
           !AI.isUsedWithInAlloca() &&
           // swifterror allocas are register promoted by ISel
-          !AI.isSwiftError());
+          !AI.isSwiftError()) &&
+          // safe allocas are not interesting
+          !(SSI && SSI->isSafe(AI));
 }
 
 bool HWAddressSanitizer::sanitizeFunction(Function &F) {
   if (&F == HwasanCtorFunction)
     return false;
 
   if (!F.hasFnAttribute(Attribute::SanitizeHWAddress))
     return false;