Discussion: Darwin Sanitizers Stable ABI

[rsundahl]

Summary

Darwin Sanitizers Stable ABI

We wish to make it possible to include the AddressSanitizer (ASan) runtime implementation in OSes and for this we need a stable ASan ABI. Based on previous discussions about this topic, our understanding is that freezing the present ABI would impose an excessive burden on other sanitizer developers and for unrelated platforms. Therefore, we propose adding a secondary stable ABI for our use and anyone else in the community seeking the same. We believe that we can define a stable ABI with minimal burden on the community, expecting only to keep existing tests running and implementing stubs when new features are added. We are okay with trading performance for stability with no impact for existing users of ASan while minimizing the maintenance burden for ASan maintainers. We wish to commit this functionality to the LLVM project to maintain it there. This new and stable ABI will abstract away the implementation details allowing new and novel approaches to ASan for developers, researchers and others.

Details

Rather than adding a lot of conditional code to the LLVM instrumentation phase, which would incur excessive complexity and maintenance cost of adding conditional code into all places that emit a runtime call, we propose a “shim” layer which will map the unstable ABI to the stable ABI:

• A static library (.a library) shim that maps the existing ASan ABI to a generalized, smaller and stable ABI. The library would implement the __asan functions and call into the new ABI. For example:
  • void __asan_load1(uptr p) { __asan_abi_loadn(p, 1, true); }
  • void __asan_load2(uptr p) { __asan_abi_loadn(p, 2, true); }
  • void __asan_noabort_load16(uptr p) { __asan_abi_loadn(p, 16, false); }
  • void __asan_poison_cxx_array_cookie(uptr p) { __asan_abi_pac(p); }
• This “shim” library would only be used by people who opt in: A compilation flag in the Clang driver will be used to gate the use of the stable ABI workflow.
• Utilize the existing ability for the ASan instrumentation to prefer runtime calls instead of inlined direct shadow memory accesses.
• Pursue (under the new driver flag) a better separation of abstraction and implementation with:
  • LLVM instrumentation: Calling out for all poisoning, checking and unpoisoning.
  • Runtime: Implementing the stable ABI and being responsible of implementation details of the shadow memory.

Maintenance

Our aim is that the maintenance burden on the sanitizer developer community be negligible. Stable ABI tests will always pass for non-Darwin platforms. Changes to the existing ABI which would require a change to the shim have been infrequent as the ASan ABI is already relatively stable. Rarely, a change that impacts the contract between LLVM and the shim will occur. Among such foreseeable changes are: 1) changes to a function signature, 2) additions of new functions, or 3) deprecation of an existing function. Following are some examples of reasonable responses to those changes:

• Example: An existing ABI function is changed to return the input parameter on success or NULL on failure. In this scenario, a reasonable change to the shim would be to modify the function signature appropriately and to simply guess at a common-sense implementation.
  • uptr __asan_load1(uptr p) { __asan_abi_loadn(p, 1, true); return p; }
• Example: An additional function is added for performance reasons. It has a very similar function signature to other similarly named functions and logically is an extension of that same pattern. In this case it would make sense to apply the same logic as the existing entry points:
  • void __asan_load128(uptr p) { __asan_abi_loadn(p, 128, true); }
• Example: An entry point is added to the existing ABI for which there is no obvious stable ABI implementation: In this case, doing nothing in a no-op stub would be acceptable, assuming existing features of ASan can still work without an actual implementation of this new function.
  • void __asan_prefetch(uptr p) { }
• Example: An entrypoint in the existing ABI is deprecated and/or deleted:
  • (Delete the entrypoint from the shim.)

We’re looking for buy-in for this level of support.

(Note: Upon acceptance of the general concepts herein, we will add a controlling clang flag, cmake integration, contract for the stable ABI, and the appropriate test infrastructure.)

[eugenis]

I think this should generally work.

It sounds like you are adding a lot of overhead in the stable-abi compilation mode - not only all load/store checking is outlined, but it also goes through 2 levels of wrappers. It would be nice if at least the caller-side shim was inlined or LTO-inlined.

[rsundahl]

In D143675#4116425, @eugenis wrote:

I think this should generally work.

It sounds like you are adding a lot of overhead in the stable-abi compilation mode - not only all load/store checking is outlined, but it also goes through 2 levels of wrappers. It would be nice if at least the caller-side shim was inlined or LTO-inlined.

Thank you @eugenis. We thought we'd start with a naive implementation like this and when we have an instrumented (but essentially no-op) stack, measure the fixed overhead to see what we need and how best to get there.

[MaskRay]

Hi! For a discussion it's norm to start a topic on Discourse (https://discourse.llvm.org/c/runtimes/64). You can link the patch to it.
In other subprojects of llvm-project, an in-tree documentation is typically in llvm-project/*/docs/, not in a directory like lib/*/

For the technical side, I think asan_* functions names collide with the user namespace. It'd be good to use reserved identifiers.

Based on previous discussions about this topic,

Do you have links to previous discussions about this topic?

compiler-rt/lib/stable_abi/README.txt

1 ↗

(On Diff #496216)

Keep just README.md and delete this duplicated copy?

compiler-rt/lib/stable_abi/stable_abi_shim.c

660 ↗

(On Diff #496216)

Extra space before the type. This applies to everything below.

[rsundahl]

Addressed various suggestions from review.

[rsundahl]

Missed namespace change for stable abi (sabi)

[rsundahl]

Namespace misses.

[rsundahl]

Including stable_abi_shim.c in the rename.

[rsundahl]

In D143675#4127035, @MaskRay wrote:

Hi! For a discussion it's norm to start a topic on Discourse (https://discourse.llvm.org/c/runtimes/64). You can link the patch to it.
In other subprojects of llvm-project, an in-tree documentation is typically in llvm-project/*/docs/, not in a directory like lib/*/

Thank you @MaskRay! I think mainly that we didn't want stimulate a broader discussion for the narrow scope of our use case, at least not yet. Rather, we are looking for support from yourself, @eugenis @kcc, @vitalybuka and code owners in support of our specific situation.

For the technical side, I think asan_* functions names collide with the user namespace. It'd be good to use reserved identifiers.
I used __asabi_ as a namespace for the new entry points.

Based on previous discussions about this topic,

Do you have links to previous discussions about this topic?

This was from group memory and not from a specific discussion.

[rsundahl]

Full adoption of rename asan_stable_abi -> asabi.

[rsundahl]

Moved and renamed files using asabi namespace. Added CMake scaffolding.

[vitalybuka]

Usually freezing signatures is not a big concern, we can agree to preserve existing functions.
The stuff like ASanStackFrameLayout is the concern. compiler and runtime must agree on data layout. The same for global.

[rsundahl]

In D143675#4139881, @rsundahl wrote:

In D143675#4127035, @MaskRay wrote:

Hi! For a discussion it's norm to start a topic on Discourse (https://discourse.llvm.org/c/runtimes/64). You can link the patch to it.

Now at: https://discourse.llvm.org/t/darwin-sanitizers-stable-abi/68834
cc: @MaskRay:

[thetruestblue]

compiler-rt/cmake/config-ix.cmake

734

This was an artifact leftover from some of my cmake changes. This line needs to be removed..

[rsundahl]

In D143675#4160084, @vitalybuka wrote:

Usually freezing signatures is not a big concern, we can agree to preserve existing functions.
The stuff like ASanStackFrameLayout is the concern. compiler and runtime must agree on data layout. The same for global.

Yes. Presently, the address sanitizer code generator is very aware of the stack frame layout and how it will be poisoned up to and including the values to be stored in the shadow memory. I don't think that the runtime actually shares ASanStackFrameLayout at the moment but certainly would be supportive if under this proposed flag (where everything gets outlined), we actually passed some canonicalized/serialized ASanStackFrameLayout object to the runtime where it would be free to implement as appropriate. We're not proposing this kind of change at this time but may be worth doing in some future effort to separate instrumentation from implementation. (Similar arguments apply under this flag for globals).

[rsundahl]

Deleted extraneous line from compiler-rt/cmake/config-ix.cmake

[rsundahl]

Rebase

[thetruestblue]

Currently & ideally asabi_shim.h is unnecessary -- but we hope to use only headers from ../asan/

[kubamracek]

@kcc Any takes from you on this?

[rsundahl]

@kcc @eugenis @MaskRay @vitalybuka Ok to go with this? All new functionality is under the added flag so not expecting any surprises.

[vitalybuka]

In D143675#4281673, @rsundahl wrote:

@kcc @eugenis @MaskRay @vitalybuka Ok to go with this? All new functionality is under the added flag so not expecting any surprises.

I don't have reasons to block this.

clang/include/clang/Driver/Options.td

1794

how likely you will need thus for other sanitizers in future
should this be rather -fsanitize-stable-abi which is ignore for now for other sanitizers?

compiler-rt/lib/asabi/CMakeLists.txt

2 ↗

(On Diff #501358)

does it need to be asabi?
maybe better asan_abi, files and macro?

[rsundahl]

Rename fsanitize_address_stable_abi to fsanitize_stable_abi

[rsundahl]

clang/include/clang/Driver/Options.td

1794

Thanks @vitalybuka. I agree and made this change. For now I still only consume the flag if sanitizer=address so that we continue to get the unused option warning in the other cases and left the test for that warning intact.

[rsundahl]

compiler-rt/lib/asabi/CMakeLists.txt

2 ↗

(On Diff #501358)

The idea is that "asabi" replaces "asan" (where the "s" stands in for "stable"), but I understand the distraction of sounding like a hot condiment! I wonder what you think of "asan_stable" (over "asan_stable_abi" or "asan_abi" as you suggest). I am more at ease with emphasizing the "stable" over the "abi" since both "asan" and "asan_stable" share ABI-ness without calling it out. This might read and organize a bit more naturally with what we already have. Thanks for the input.

[rsundahl]

Rename asabi->asan_abi

[rsundahl]

@kcc @eugenis @MaskRay @vitalybuka Ok to go with this? All new functionality is under the added flag so not expecting any surprises. Rename asabi->asan_abi as suggested.

compiler-rt/lib/asabi/CMakeLists.txt

2 ↗

(On Diff #501358)

Changed "asabi" namespace to "asan_abi". Applied to files, directories and contents.

[eugenis]

I'm fine with it in general. Is asan_abi.cpp meant as a temporary stub? It's not even link anywhere in the current version.

[vitalybuka]

In D143675#4310734, @rsundahl wrote:

@kcc @eugenis @MaskRay @vitalybuka Ok to go with this? All new functionality is under the added flag so not expecting any surprises. Rename asabi->asan_abi as suggested.

Thanks, asan_abi LGTM.

I don't have good reasons to object that patch, but I suspect it's sub-optimal. But we may get a valuable expirience.

Rather than adding a lot of conditional code to the LLVM instrumentation phase

We do this for hwasan for Android, and to some extent msan for Chromium. @eugenis maybe can share more info.

Based on previous discussions about this topic, our understanding is that freezing the present ABI would impose an excessive burden on other sanitizer developers and for unrelated platforms.

I guess we just have no way to enforce that. A couple of buildbots with "stable clang" + "HEAD runtime" and "HEAD clang" + "stable runtime" which do some non-tivial build, e.g. clang bootstrap can enforce that. We can at list to enforce default set of flags.

[thetruestblue]

Small insignificant note from me: When this lands, please be sure to add me as co-author.
https://github.blog/2018-01-29-commit-together-with-co-authors/

[rsundahl]

In D143675#4310903, @eugenis wrote:

I'm fine with it in general. Is asan_abi.cpp meant as a temporary stub? It's not even link anywhere in the current version.

Right, we should be using it... We will add a test that compiles and links to it as affirmation that we have covered all of the entrypoints that ASan generates. It's also the case that asan_abi_shim.h is redundant since asan_abi_shim.cpp now gets its declarations from ../asan/asan_interface_internal.h which is of course the source of truth for what the shim should be implementing. We will remove that as well and update. Thanks.

[rsundahl]

In D143675#4330599, @thetruestblue wrote:

Small insignificant note from me: When this lands, please be sure to add me as co-author.
https://github.blog/2018-01-29-commit-together-with-co-authors/

I've not seen this before @thetruestblue! I certainly will do so!

[rsundahl]

Added testing. Removed asan_abi_shim.h.

[rsundahl]

Fixed nits (missing newlines at end of files)

[rsundahl]

In D143675#4310903, @eugenis wrote:

I'm fine with it in general. Is asan_abi.cpp meant as a temporary stub? It's not even link anywhere in the current version.

We now use it during testing to close the loop on the question of whether the file is "complete" in the sense that it satisfies the minimal "no-op" implementation of the abi. We also moved from having a hand-curated include file to using the actual interface file which should be the root truth for what needs to be in there. We discovered a few additional functions that were in asan_interface.h but aren't strictly part of the interface between the instrumentation and the runtime but rather are used intra-runtime. Some other routines living in asan_interface.h are really documented "helper" functions. Maybe these should be aggregated somewhere else and/or under a different namespace. For now we ignore those entrypoints by listing them in compiler-rt/lib/asan_abi/darwin_exclude_symbols.inc

[vitalybuka]

compiler-rt/lib/asan_abi/asan_abi_shim.cpp

63

static_assert

[MaskRay]

compiler-rt/lib/asan_abi/asan_abi_shim.cpp

15

Comments are usually a complete sentence with a period. There are exceptions, but a "Globals" needs elaboration to make it better understandable by a reader.

17

2-space indentation, here and throughout.

42

C++ prefers () instead of (void).

487

You may apply clang-format, which may turn this into (void *)0, but nullptr likely works better.

compiler-rt/test/asan_abi/TestCases/Darwin/llvm_interface_symbols.cpp

2

excess spaces

-O2 ... -O0?

5

One blank line suffices.

10

We generally prefer llvm counterparts to the system binary utilities. Use llvm-nm

16

unneeded ^//$ lines, here and throughout.

17

Does Darwin sed accept ; to combine multiple -e into one -e with ;?

22

2-space indentation for | continuation lines as well

27

sort %t.imports. See Useless use of cat

compiler-rt/test/asan_abi/TestCases/linkstaticlibrary.cpp

2

-O2 ... -O0

[MaskRay]

In D143675#4336365, @rsundahl wrote:

In D143675#4310903, @eugenis wrote:

I'm fine with it in general. Is asan_abi.cpp meant as a temporary stub? It's not even link anywhere in the current version.

We now use it during testing to close the loop on the question of whether the file is "complete" in the sense that it satisfies the minimal "no-op" implementation of the abi. We also moved from having a hand-curated include file to using the actual interface file which should be the root truth for what needs to be in there. We discovered a few additional functions that were in asan_interface.h but aren't strictly part of the interface between the instrumentation and the runtime but rather are used intra-runtime. Some other routines living in asan_interface.h are really documented "helper" functions. Maybe these should be aggregated somewhere else and/or under a different namespace. For now we ignore those entrypoints by listing them in compiler-rt/lib/asan_abi/darwin_exclude_symbols.inc

How is compiler-rt/lib/asan_abi/darwin_exclude_symbols.inc used in the upstream and downstream build system?
In this patch this file is only used by one test?

clang/include/clang/Driver/Options.td

1794

See BooleanFFlag. Some existing sanitizer options are not written with the best practice.

If -fno-sanitize-stable-abi is the default, there is usually no need to have a duplicate help message Disable .... Documenting the non-default boolean option suffices.

clang/lib/Driver/SanitizerArgs.cpp

917

Existing code unnecessarily reads the previous value (false) of the variable. No need to copy that for new code.

1289

Optional nit: I added -mllvm= as an alias in D143325. You can use -mllvm=-asan-instrumentation-with-call-threshold=0 to decrease the number/length of cc1 options.

Add some comments before if (StableABI) { why the two cl::opt options are specified.

clang/test/Driver/fsanitize.c

266 ↗

(On Diff #521482)

I think the tests should go to a new file fsanitize-stable-abi.c. The checks are different enough from the rest of fsanitize.c (which can be split).

269 ↗

(On Diff #521482)

I presume that you want to test the positive forms with Darwin triples like arm64-apple-darwin?

We can even argue that the option should lead to an error for non-Darwin triples.

compiler-rt/docs/asan_abi.md

1 ↗

(On Diff #521482)

The existing compiler-rt/docs docs use .rst. Better to use .rst to not introduce more than one format for one subproject.

.rst is used much more than .md in llvm-project anyway.

compiler-rt/lib/asan_abi/asan_abi.h

14

use clang-format to sort the headers. I'd expect that stdbool and stddef are placed together for any sorting behavior.

16

add a blank line before extern "C" {

compiler-rt/test/asan_abi/lit.cfg.py

10

This workaround is unneeded. I sent D150410 to clean up other lit.cfg.py files.

21

is None is better.

84

!=

[MaskRay]

In D143675#4310904, @vitalybuka wrote:

In D143675#4310734, @rsundahl wrote:

@kcc @eugenis @MaskRay @vitalybuka Ok to go with this? All new functionality is under the added flag so not expecting any surprises. Rename asabi->asan_abi as suggested.

Thanks, asan_abi LGTM.

I don't have good reasons to object that patch, but I suspect it's sub-optimal. But we may get a valuable expirience.

Rather than adding a lot of conditional code to the LLVM instrumentation phase

We do this for hwasan for Android, and to some extent msan for Chromium. @eugenis maybe can share more info.

Based on previous discussions about this topic, our understanding is that freezing the present ABI would impose an excessive burden on other sanitizer developers and for unrelated platforms.

I guess we just have no way to enforce that. A couple of buildbots with "stable clang" + "HEAD runtime" and "HEAD clang" + "stable runtime" which do some non-tivial build, e.g. clang bootstrap can enforce that. We can at list to enforce default set of flags.

Very sorry for my belated response. I feel that I am not a decision maker, so I am waiting on the maintainers.
I do care about driver options (as a code owner) and sanitizer maintainability (my interest), though. I have left some comments and will be happy when they are resolved.

The documentation compiler-rt/docs/asan_abi.md probably needs more polishing. The current style is like seeking for RFC, not for something already in tree.

compiler-rt/docs/asan_abi.md

3 ↗

(On Diff #521482)

The introductory paragraph is written in a style like the RFC, but not for the official documentation.
The official documentation should be written in a style that this has been accepted.
For sentences like maintenance costs, they can be moved to the Maintenance chapter.

I have an simplified introductory paragraph:

Some OSes like Darwin want to include the AddressSanitizer runtime by establishing a stable ASan ABI. lib/asan_abi contains a secondary stable ABI for our use and others in the community. This new ABI will have minimal impact on the community, prioritizing stability over performance.

Feel free to add more sentences if you feel too simplified.

Note that .rst uses two backsticks for what Markdown uses one backstick for.

7 ↗

(On Diff #521482)

Similarly, words like "propose" are RFC-style wording, not for the official documentation. For the official documentation, you just say what this is.

14 ↗

(On Diff #521482)

This “shim” library will only be used when -fsanitize-stable-abi is specified in the Clang driver.

[thetruestblue]

compiler-rt/test/asan_abi/lit.cfg.py

84

The thought here was to leave basic lit patterns in-tact to expand to other OSs if others want to in the future. But if there's no desire for that, it doesn't make a big difference to me.

[rsundahl]

Applied suggestions from reviewers

Cleaned up options parsing
Moved test into stanalone file fsanitize-stable-abi.c
Changed target triple to arm64-apple-darwin
Changed documentation style from proposal to specification
Changed format of documentation form .md to .rst
Applied clang-format to entire diff
Removed extraneous spaces and lines
Expanded comments to sentences
Switched to static_assert()

[rsundahl]

Thank you for your review and thoughtful input @eugenis, @MaskRay and @vitalybuka. I think we're close to having everything incorporated. (@MaskRay, the doc files went from .md to .rst and I implemented all of your suggestions there.

clang/include/clang/Driver/Options.td

1794

(Not sure if this is exactly what you meant @MaskRay but I think it's close.)

clang/lib/Driver/SanitizerArgs.cpp

1289

I couldn't get this one to work. Did I do it wrong? (Couldn't find example in the code to go from.)

Tried:

if (StableABI) {
  CmdArgs.push_back("-mllvm=-asan-instrumentation-with-call-threshold=0");
  CmdArgs.push_back("-mllvm=-asan-max-inline-poisoning-size=0");
}

Got:

error: unknown argument: '-mllvm=-asan-instrumentation-with-call-threshold=0'
error: unknown argument: '-mllvm=-asan-max-inline-poisoning-size=0'

compiler-rt/lib/asan_abi/asan_abi_shim.cpp

42

These are actually "C'
Added:

extern "C" {
...
}

487

clang-format left this as-is. I suspect this is because I also added the extern "C" brackets.

compiler-rt/test/asan_abi/TestCases/Darwin/llvm_interface_symbols.cpp

17

I couldn't get the same behavior out of the intersection of GNU an BSD set. Tried hard in https://reviews.llvm.org/D138824 and landed with the -e's. iirc exactly what the problem was with semicolons, just that I was relieved when I found a format that worked for all the platforms.

27

Good point!

compiler-rt/test/asan_abi/lit.cfg.py

10

Wasn't actually used anyway but good to know!

84

I landed on just an else clause. Let me know if that's ok @thetruestblue.

[rsundahl]

Suggestions for compiler-rt/docs/asan_abi.md are captured in the successor file compiler-rt/docs/ASanABI.rst and marked complete.

[rsundahl]

Suggestions for compiler-rt/docs/asan_abi.md are captured in the successor file compiler-rt/docs/ASanABI.rst and marked complete.

[rsundahl]

Missed one file in revert of combined -mllvm= change.

[rsundahl]

Renamed darwin_exclude_symbols.inc asan_abi_tbd.txt.

This file contains the entrypoints that aren't strictly in the interface
between the instrumentation and the runtime but may still be part of a
public API that needs to have a home in Stable ABI. For now we acknowledge
them in the existing ABI and explicitly list them as TBD until we have a
complete story for how the shim deals with them.

[rsundahl]

@MaskRay, thank you for your approval. @eugenis, you were added as a blocking reviewer by @vitalybuka. If you are still without objection, can we get your approval and merge? Thank you all for your input.

[rsundahl]

Ping @kcc , @yln and @kubamracek

[MaskRay]

compiler-rt/docs/ASanABI.rst

30

How does the 2-space indentation render in the built HTML? It may look good, I ask just in case.

compiler-rt/lib/asan_abi/asan_abi.h

19

asan_abi.h is C++ only (extern "C" isn't allowed in C). (void) should be replaced with ().

compiler-rt/lib/asan_abi/asan_abi_shim.cpp

15

Below there is no :. You may omit this : as well.

346

compiler-rt/test/asan_abi/lit.cfg.py

14

This file mixes single quotes and double quotes (the file it copied from does so as well). Pick one and be consistent!

[rsundahl]

compiler-rt/docs/ASanABI.rst

30

How does the 2-space indentation render in the built HTML? It may look good, I ask just in case.

IDK so I played around with it. Global search/replace 2 spaces with 4 does not affect rendering of the block above at all. In the block below there was an effect which was to indent the code blocks one more stop. The reason for this seems to be that the "current indent level" is advanced by 2 in a bulleted list, so below, the code block statement is actually aligned with the bulleted paragraph above it. After the GSR, the code block is indented and rendered further indented. Since bullets advance the "current indent level" by 2, maybe a more natural indent for the source code (.rst) is to use 2 as well. Seems to read a little easier in the source and avoids having to think about all the multiple of 4's after a bullet being "off by 2".

[rsundahl]

Implement suggestions from latest review.

[rsundahl]

Hello Egenii,

Thank you for your time and consideration of this PR. Since you last commented, @vitalybuka has approved the PR and added @MaskRay and yourself as blocking reviewers. @MaskRay has approved and we are awaiting your approval if you remain positive to it (or let us know if you have any new reservations).

Thank you,
-Roy Sundahl

[MaskRay]

LGTM.

compiler-rt/docs/ASanABI.rst

16

Delete .... Sample content implies that this is a code fragment and does not contain everything, so ... is redundant.

23

Quote all compiler driver options with double backsticks.

[rsundahl]

Apply proper backticks quotes to options. Remove redundant ellipses.

[rsundahl]

Thanks for your time and guidance getting this landed.

clang/include/clang/Driver/Options.td

def fno_sanitize_memory_track_origins : Flag<["-"], "fno-sanitize-memory-track-origins">,
                                         Flags<[CoreOption, NoXarchOption]>,
                                         HelpText<"Disable origins tracking in MemorySanitizer">;
 def fsanitize_address_outline_instrumentation : Flag<["-"], "fsanitize-address-outline-instrumentation">,
                                                 Group<f_clang_Group>,
                                                 HelpText<"Always generate function calls for address sanitizer instrumentation">;
 def fno_sanitize_address_outline_instrumentation : Flag<["-"], "fno-sanitize-address-outline-instrumentation">,
                                                    Group<f_clang_Group>,
                                                    HelpText<"Use default code inlining logic for the address sanitizer">;
+defm sanitize_stable_abi
+  : OptInCC1FFlag<"sanitize-stable-abi", "Stable  ", "Conventional ",
+    "ABI instrumentation for sanitizer runtime. Default: Conventional">;
+
 def fsanitize_memtag_mode_EQ : Joined<["-"], "fsanitize-memtag-mode=">,
                                         Group<f_clang_Group>,
                                         HelpText<"Set default MTE mode to 'sync' (default) or 'async'">;
 def fsanitize_hwaddress_experimental_aliasing
   : Flag<["-"], "fsanitize-hwaddress-experimental-aliasing">,
     Group<f_clang_Group>,
     HelpText<"Enable aliasing mode in HWAddressSanitizer">;
 def fno_sanitize_hwaddress_experimental_aliasing

clang/include/clang/Driver/SanitizerArgs.h

class SanitizerArgs {
   bool MsanUseAfterDtor = true;
   bool MsanParamRetval = true;
   bool CfiCrossDso = false;
   bool CfiICallGeneralizePointers = false;
   bool CfiICallNormalizeIntegers = false;
   bool CfiCanonicalJumpTables = false;
   int AsanFieldPadding = 0;
   bool SharedRuntime = false;
+  bool StableABI = false;
   bool AsanUseAfterScope = true;
   bool AsanPoisonCustomArrayCookie = false;
   bool AsanGlobalsDeadStripping = false;
   bool AsanUseOdrIndicator = false;
   bool AsanInvalidPointerCmp = false;
   bool AsanInvalidPointerSub = false;
   bool AsanOutlineInstrumentation = false;
   llvm::AsanDtorKind AsanDtorKind = llvm::AsanDtorKind::Invalid;

clang/lib/Driver/SanitizerArgs.cpp

if (Arg *WindowsDebugRTArg =
           D.Diag(clang::diag::err_drv_argument_not_allowed_with)
               << WindowsDebugRTArg->getAsString(Args)
               << lastArgumentForMask(D, Args, SanitizerKind::Address);
           D.Diag(clang::diag::note_drv_address_sanitizer_debug_runtime);
         }
       }
     }
 
+    StableABI = Args.hasFlag(options::OPT_fsanitize_stable_abi,
+                             options::OPT_fno_sanitize_stable_abi, false);
+
     AsanUseAfterScope = Args.hasFlag(
         options::OPT_fsanitize_address_use_after_scope,
         options::OPT_fno_sanitize_address_use_after_scope, AsanUseAfterScope);
 
     AsanPoisonCustomArrayCookie = Args.hasFlag(
         options::OPT_fsanitize_address_poison_custom_array_cookie,
         options::OPT_fno_sanitize_address_poison_custom_array_cookie,
         AsanPoisonCustomArrayCookie);
 
if (AsanInvalidPointerSub) {
     CmdArgs.push_back("-asan-detect-invalid-pointer-sub");
   }
 
   if (AsanOutlineInstrumentation) {
     CmdArgs.push_back("-mllvm");
     CmdArgs.push_back("-asan-instrumentation-with-call-threshold=0");
   }
 
+  // When emitting Stable ABI instrumentation, force outlining calls and avoid
+  // inlining shadow memory poisoning. While this is a big performance burden
+  // for now it allows full abstraction from implementation details.
+  if (StableABI) {
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back("-asan-instrumentation-with-call-threshold=0");
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back("-asan-max-inline-poisoning-size=0");
+  }
+
   // Only pass the option to the frontend if the user requested,
   // otherwise the frontend will just use the codegen default.
   if (AsanDtorKind != llvm::AsanDtorKind::Invalid) {
     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-destructor=" +
                                          AsanDtorKindToString(AsanDtorKind)));
   }
 
   if (AsanUseAfterReturn != llvm::AsanDetectStackUseAfterReturnMode::Invalid) {

clang/test/Driver/fsanitize-stable-abi.c

+// RUN: %clang --target=arm64-apple-darwin -fsanitize-stable-abi %s -### 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-ASAN-STABLE-WARN
+// CHECK-ASAN-STABLE-WARN: warning: argument unused during compilation: '-fsanitize-stable-abi'
+// RUN: %clang --target=arm64-apple-darwin -fsanitize=address -fsanitize-stable-abi %s -### 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-ASAN-STABLE-OK
+// RUN: %clang --target=arm64-apple-darwin -fsanitize=address -fno-sanitize-stable-abi -fsanitize-stable-abi %s -### 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-ASAN-STABLE-OK
+// CHECK-ASAN-STABLE-OK: "-mllvm" "-asan-instrumentation-with-call-threshold=0"
+// CHECK-ASAN-STABLE-OK: "-mllvm" "-asan-max-inline-poisoning-size=0"
+// RUN: %clang --target=arm64-apple-darwin -fsanitize=address -fno-sanitize-stable-abi %s -### 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-NO-ASAN-STABLE-OK
+// RUN: %clang --target=arm64-apple-darwin -fsanitize=address -fsanitize-stable-abi -fno-sanitize-stable-abi %s -### 2>&1 | \
+// RUN:     FileCheck %s --check-prefix=CHECK-NO-ASAN-STABLE-OK
+// CHECK-NO-ASAN-STABLE-OK-NOT: "-mllvm" "-asan-instrumentation-with-call-threshold=0"
+// CHECK-NO-ASAN-STABLE-OK-NOT: "-mllvm" "-asan-max-inline-poisoning-size=0"

compiler-rt/cmake/config-ix.cmake

 find_program(GNU_LD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.bfd ld.bfd DOC "GNU ld")
 find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold DOC "GNU gold")
 
 if(COMPILER_RT_SUPPORTED_ARCH)
   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
-set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan)
+set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo_standalone;ubsan_minimal;gwp_asan;asan_abi)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 
 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|Fuchsia|SunOS" OR
     (OS_NAME MATCHES "Windows" AND NOT CYGWIN AND
         (NOT MINGW OR CMAKE_CXX_COMPILER_ID MATCHES "Clang"))))
   set(COMPILER_RT_HAS_SANITIZER_COMMON TRUE)
 else()
   set(COMPILER_RT_HAS_SANITIZER_COMMON FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON)
   set(COMPILER_RT_HAS_INTERCEPTION TRUE)
 else()
   set(COMPILER_RT_HAS_INTERCEPTION FALSE)
 endif()
 
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH AND APPLE)
+  set(COMPILER_RT_HAS_ASAN_ABI TRUE)
+else()
+  set(COMPILER_RT_HAS_ASAN_ABI FALSE)
+endif()
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND ASAN_SUPPORTED_ARCH)
   set(COMPILER_RT_HAS_ASAN TRUE)
 else()
   set(COMPILER_RT_HAS_ASAN FALSE)
 endif()
 
 if (OS_NAME MATCHES "Linux|FreeBSD|Windows|NetBSD|SunOS")
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME TRUE)
 else()
   set(COMPILER_RT_ASAN_HAS_STATIC_RUNTIME FALSE)
 endif()

compiler-rt/docs/ASanABI.rst

+.. _BuildingCompilerRT:
+
+============================
+Darwin Sanitizers Stable ABI
+============================
+
+Some OSes like Darwin want to include the AddressSanitizer runtime by establishing a stable ASan ABI. lib/asan_abi contains a secondary stable ABI for Darwin use and potentially others. The Stable ABI has minimal impact on the community, prioritizing stability over performance.
+
+The Stable ABI is isolated by a “shim” layer which maps the unstable ABI to the stable ABI. It consists of a static library (libclang_rt.asan_abi_osx.a) that contains simple mappings of the existing ASan ABI to the smaller Stable ABI. After linking with the static shim library, only calls to the Stable ABI remain. 
+
+  Sample content of the shim:
+
+  .. code-block:: c
+
+    void __asan_load1(uptr p) { __asan_abi_loadn(p, 1, true); }
+    void __asan_load2(uptr p) { __asan_abi_loadn(p, 2, true); }
+    void __asan_noabort_load16(uptr p) { __asan_abi_loadn(p, 16, false); }
+    void __asan_poison_cxx_array_cookie(uptr p) { __asan_abi_pac(p); }
+
+The shim library is only used when ``-fsanitize-stable-abi`` is specified in the Clang driver and the emitted instrumentation favors runtime calls over inline expansion.
+
+Maintenance
+-----------
+
+The maintenance burden on the sanitizer developer community should be negligible. Stable ABI tests should always pass for non-Darwin platforms. Changes to the existing ABI requiring changes to the shim should been infrequent as the existing ASan ABI has long been relatively stable anyway. Rarely, when a change that impacts the contract between LLVM and the shim occurs, some simple responses should suffice. Among such foreseeable changes are: 1) changes to a function signature, 2) additions of new functions, or 3) deprecation of an existing function.
+
+  Following are some examples of reasonable responses to such changes:
+
+  * An existing ABI function is changed to return the input parameter on success or NULL on failure. In this scenario, a reasonable change to the shim would be to modify the function signature appropriately and to simply guess at a common-sense implementation.
+
+    .. code-block:: c
+
+      uptr __asan_load1(uptr p) { __asan_abi_loadn(p, 1, true); return p; }
+
+  * An additional function is added for performance reasons. It has a very similar function signature to other similarly named functions and logically is an extension of that same pattern. In this case it would make sense to apply the same logic as the existing entry points:
+
+    .. code-block:: c
+
+      void __asan_load128(uptr p) { __asan_abi_loadn(p, 128, true); }
+
+  * An entry point is added to the existing ABI for which there is no obvious stable ABI implementation: In this case, doing nothing in a no-op stub would be acceptable, assuming existing features of ASan can still work without an actual implementation of this new function.
+
+    .. code-block:: c
+
+      void __asan_prefetch(uptr p) { }
+
+  * An entrypoint in the existing ABI is deprecated and/or deleted:
+
+    .. code-block:: c
+
+      (Delete the entrypoint from the shim.)

compiler-rt/lib/asan_abi/CMakeLists.txt

+# Build for the ASAN Stable ABI runtime support library.
+set(ASAN_ABI_SOURCES
+  asan_abi_shim.cpp
+  )
+
+set(ASAN_ABI_HEADERS
+  ../asan/asan_interface_internal.h
+  asan_abi.h
+  )
+
+include_directories(..)
+
+add_compiler_rt_component(asan_abi)
+
+if (APPLE)
+  # TODO: set in config-ix.cmake
+  set(ASAN_ABI_SUPPORTED_OS osx)
+  set(ASAN_ABI_SUPPORTED_ARCHS ${X86_64} ${ARM64})
+  # Compile Stable API sources into an object library.
+  add_compiler_rt_object_libraries(RTASAN_ABI
+    OS ${ASAN_ABI_SUPPORTED_OS}
+    ARCHS ${ASAN_ABI_SUPPORTED_ARCHS}
+    SOURCES ${ASAN_ABI_SOURCES}
+    ADDITIONAL_HEADERS ${ASAN_ABI_HEADERS}
+    CFLAGS ${SANITIZER_COMMON_CFLAGS})
+
+  add_compiler_rt_runtime(clang_rt.asan_abi
+    STATIC
+    OS ${ASAN_ABI_SUPPORTED_OS}
+    ARCHS ${ASAN_ABI_SUPPORTED_ARCHS}
+    OBJECT_LIBS RTASAN_ABI
+    CFLAGS ${SANITIZER_COMMON_CFLAGS}
+    LINK_FLAGS ${WEAK_SYMBOL_LINK_FLAGS}
+    PARENT_TARGET asan_abi)
+endif()

compiler-rt/lib/asan_abi/asan_abi.h

+//===-asan_abi.h - ASan Stable ABI Interface-------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ASAN_ABI_H
+#define ASAN_ABI_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+extern "C" {
+// Functions concerning instrumented global variables:
+void __asan_abi_register_image_globals();
+void __asan_abi_unregister_image_globals();
+
+// Functions concerning dynamic library initialization
+void __asan_abi_before_dynamic_init(const char *module_name);
+void __asan_abi_after_dynamic_init();
+
+// Functions concerning block memory destinations
+void *__asan_abi_memcpy(void *d, const void *s, size_t n);
+void *__asan_abi_memmove(void *d, const void *s, size_t n);
+void *__asan_abi_memset(void *p, int c, size_t n);
+
+// Functions concerning RTL startup and initialization
+void __asan_abi_init();
+void __asan_abi_handle_no_return();
+
+// Functions concerning memory load and store reporting
+void __asan_abi_report_load_n(void *p, size_t n, bool abort);
+void __asan_abi_report_exp_load_n(void *p, size_t n, int exp, bool abort);
+void __asan_abi_report_store_n(void *p, size_t n, bool abort);
+void __asan_abi_report_exp_store_n(void *p, size_t n, int exp, bool abort);
+
+// Functions concerning memory load and store
+void __asan_abi_load_n(void *p, size_t n, bool abort);
+void __asan_abi_exp_load_n(void *p, size_t n, int exp, bool abort);
+void __asan_abi_store_n(void *p, size_t n, bool abort);
+void __asan_abi_exp_store_n(void *p, size_t n, int exp, bool abort);
+
+// Functions concerning query about whether memory is poisoned
+int __asan_abi_address_is_poisoned(void const volatile *p);
+void *__asan_abi_region_is_poisoned(void const volatile *p, size_t size);
+
+// Functions concerning the poisoning of memory
+void __asan_abi_unpoison_memory_region(void const volatile *p, size_t n);
+void __asan_abi_poison_memory_region(void const volatile *p, size_t n);
+
+// Functions concerning the partial poisoning of memory
+void __asan_abi_set_shadow_xx_n(void *p, unsigned char xx, size_t n);
+
+// Functions concerning stack poisoning
+void __asan_abi_poison_stack_memory(void *p, size_t n);
+void __asan_abi_unpoison_stack_memory(void *p, size_t n);
+
+// Functions concerning redzone poisoning
+void __asan_abi_poison_intra_object_redzone(void *p, size_t size);
+void __asan_abi_unpoison_intra_object_redzone(void *p, size_t size);
+
+// Functions concerning array cookie poisoning
+void __asan_abi_poison_cxx_array_cookie(void *p);
+void *__asan_abi_load_cxx_array_cookie(void **p);
+
+// Functions concerning fake stacks
+void *__asan_abi_get_current_fake_stack();
+void *__asan_abi_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
+                                       void **end);
+// Functions concerning poisoning and unpoisoning fake stack alloca
+void __asan_abi_alloca_poison(void *addr, size_t size);
+void __asan_abi_allocas_unpoison(void *top, void *bottom);
+
+// Functions concerning fake stack malloc
+void *__asan_abi_stack_malloc_n(size_t scale, size_t size);
+void *__asan_abi_stack_malloc_always_n(size_t scale, size_t size);
+
+// Functions concerning fake stack free
+void __asan_abi_stack_free_n(int scale, void *p, size_t n);
+}
+#endif // ASAN_ABI_H

compiler-rt/lib/asan_abi/asan_abi.cpp

+//===-asan_abi.cpp - ASan Stable ABI---------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "asan_abi.h"
+
+extern "C" {
+// Functions concerning instrumented global variables:
+void __asan_abi_register_image_globals(void) {}
+void __asan_abi_unregister_image_globals(void) {}
+
+// Functions concerning dynamic library initialization
+void __asan_abi_before_dynamic_init(const char *module_name) {}
+void __asan_abi_after_dynamic_init(void) {}
+
+// Functions concerning block memory destinations
+void *__asan_abi_memcpy(void *d, const void *s, size_t n) { return NULL; }
+void *__asan_abi_memmove(void *d, const void *s, size_t n) { return NULL; }
+void *__asan_abi_memset(void *p, int c, size_t n) { return NULL; }
+
+// Functions concerning RTL startup and initialization
+void __asan_abi_init(void) {}
+void __asan_abi_handle_no_return(void) {}
+
+// Functions concerning memory load and store reporting
+void __asan_abi_report_load_n(void *p, size_t n, bool abort) {}
+void __asan_abi_report_exp_load_n(void *p, size_t n, int exp, bool abort) {}
+void __asan_abi_report_store_n(void *p, size_t n, bool abort) {}
+void __asan_abi_report_exp_store_n(void *p, size_t n, int exp, bool abort) {}
+
+// Functions concerning memory load and store
+void __asan_abi_load_n(void *p, size_t n, bool abort) {}
+void __asan_abi_exp_load_n(void *p, size_t n, int exp, bool abort) {}
+void __asan_abi_store_n(void *p, size_t n, bool abort) {}
+void __asan_abi_exp_store_n(void *p, size_t n, int exp, bool abort) {}
+
+// Functions concerning query about whether memory is poisoned
+int __asan_abi_address_is_poisoned(void const volatile *p) { return 0; }
+void *__asan_abi_region_is_poisoned(void const volatile *p, size_t size) {
+  return NULL;
+}
+
+// Functions concerning the poisoning of memory
+void __asan_abi_poison_memory_region(void const volatile *p, size_t n) {}
+void __asan_abi_unpoison_memory_region(void const volatile *p, size_t n) {}
+
+// Functions concerning the partial poisoning of memory
+void __asan_abi_set_shadow_xx_n(void *p, unsigned char xx, size_t n) {}
+
+// Functions concerning stack poisoning
+void __asan_abi_poison_stack_memory(void *p, size_t n) {}
+void __asan_abi_unpoison_stack_memory(void *p, size_t n) {}
+
+// Functions concerning redzone poisoning
+void __asan_abi_poison_intra_object_redzone(void *p, size_t size) {}
+void __asan_abi_unpoison_intra_object_redzone(void *p, size_t size) {}
+
+// Functions concerning array cookie poisoning
+void __asan_abi_poison_cxx_array_cookie(void *p) {}
+void *__asan_abi_load_cxx_array_cookie(void **p) { return NULL; }
+
+// Functions concerning fake stacks
+void *__asan_abi_get_current_fake_stack(void) { return NULL; }
+void *__asan_abi_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
+                                       void **end) {
+  return NULL;
+}
+
+// Functions concerning poisoning and unpoisoning fake stack alloca
+void __asan_abi_alloca_poison(void *addr, size_t size) {}
+void __asan_abi_allocas_unpoison(void *top, void *bottom) {}
+
+// Functions concerning fake stack malloc
+void *__asan_abi_stack_malloc_n(size_t scale, size_t size) { return NULL; }
+void *__asan_abi_stack_malloc_always_n(size_t scale, size_t size) {
+  return NULL;
+}
+
+// Functions concerning fake stack free
+void __asan_abi_stack_free_n(int scale, void *p, size_t n) {}
+}

compiler-rt/lib/asan_abi/asan_abi_shim.cpp

+//===-asan_abi_shim.cpp - ASan Stable ABI Shim-----------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "../asan/asan_interface_internal.h"
+#include "asan_abi.h"
+#include <assert.h>
+
+extern "C" {
+// Functions concerning instrumented global variables
+void __asan_register_image_globals(uptr *flag) {
+  __asan_abi_register_image_globals();
+}
+
+void __asan_unregister_image_globals(uptr *flag) {
+  __asan_abi_unregister_image_globals();
+}
+void __asan_register_elf_globals(uptr *flag, void *start, void *stop) {}
+void __asan_unregister_elf_globals(uptr *flag, void *start, void *stop) {}
+void __asan_register_globals(__asan_global *globals, uptr n) {}
+void __asan_unregister_globals(__asan_global *globals, uptr n) {}
+
+// Functions concerning dynamic library initialization
+void __asan_before_dynamic_init(const char *module_name) {
+  __asan_abi_before_dynamic_init(module_name);
+}
+void __asan_after_dynamic_init(void) { __asan_abi_after_dynamic_init(); }
+
+// Functions concerning block memory destinations
+void *__asan_memcpy(void *dst, const void *src, uptr size) {
+  return __asan_abi_memcpy(dst, src, size);
+}
+void *__asan_memset(void *s, int c, uptr n) {
+  return __asan_abi_memset(s, c, n);
+}
+void *__asan_memmove(void *dest, const void *src, uptr n) {
+  return __asan_abi_memmove(dest, src, n);
+}
+
+// Functions concerning RTL startup and initialization
+void __asan_init(void) {
+  static_assert(sizeof(uptr) == 8);
+  static_assert(sizeof(u64) == 8);
+  static_assert(sizeof(u32) == 4);
+
+  __asan_abi_init();
+}
+void __asan_version_mismatch_check_v8(void) {}
+void __asan_handle_no_return(void) { __asan_abi_handle_no_return(); }
+
+// Variables concerning RTL state. These provisionally exist for completeness
+// but will likely move into the Stable ABI implementation and not in the shim.
+uptr __asan_shadow_memory_dynamic_address = (uptr)0xdeaddeaddeadbeaf;
+int __asan_option_detect_stack_use_after_return = 0;
+
+// Functions concerning memory load and store reporting
+void __asan_report_load1(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 1, true);
+}
+void __asan_report_load2(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 2, true);
+}
+void __asan_report_load4(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 4, true);
+}
+void __asan_report_load8(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 8, true);
+}
+void __asan_report_load16(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 16, true);
+}
+void __asan_report_load_n(uptr addr, uptr size) {
+  __asan_abi_report_load_n((void *)addr, size, true);
+}
+void __asan_report_store1(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 1, true);
+}
+void __asan_report_store2(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 2, true);
+}
+void __asan_report_store4(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 4, true);
+}
+void __asan_report_store8(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 8, true);
+}
+void __asan_report_store16(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 16, true);
+}
+void __asan_report_store_n(uptr addr, uptr size) {
+  __asan_abi_report_store_n((void *)addr, size, true);
+}
+
+// Functions concerning memory load and store reporting (experimental variants)
+void __asan_report_exp_load1(uptr addr, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, exp, 1, true);
+}
+void __asan_report_exp_load2(uptr addr, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, exp, 2, true);
+}
+void __asan_report_exp_load4(uptr addr, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, exp, 4, true);
+}
+void __asan_report_exp_load8(uptr addr, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, exp, 8, true);
+}
+void __asan_report_exp_load16(uptr addr, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, exp, 16, true);
+}
+void __asan_report_exp_load_n(uptr addr, uptr size, u32 exp) {
+  __asan_abi_report_exp_load_n((void *)addr, size, exp, true);
+}
+void __asan_report_exp_store1(uptr addr, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, exp, 1, true);
+}
+void __asan_report_exp_store2(uptr addr, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, exp, 2, true);
+}
+void __asan_report_exp_store4(uptr addr, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, exp, 4, true);
+}
+void __asan_report_exp_store8(uptr addr, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, exp, 8, true);
+}
+void __asan_report_exp_store16(uptr addr, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, exp, 16, true);
+}
+void __asan_report_exp_store_n(uptr addr, uptr size, u32 exp) {
+  __asan_abi_report_exp_store_n((void *)addr, size, exp, true);
+}
+
+// Functions concerning memory load and store reporting (noabort variants)
+void __asan_report_load1_noabort(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 1, false);
+}
+void __asan_report_load2_noabort(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 2, false);
+}
+void __asan_report_load4_noabort(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 4, false);
+}
+void __asan_report_load8_noabort(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 8, false);
+}
+void __asan_report_load16_noabort(uptr addr) {
+  __asan_abi_report_load_n((void *)addr, 16, false);
+}
+void __asan_report_load_n_noabort(uptr addr, uptr size) {
+  __asan_abi_report_load_n((void *)addr, size, false);
+}
+void __asan_report_store1_noabort(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 1, false);
+}
+void __asan_report_store2_noabort(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 2, false);
+}
+void __asan_report_store4_noabort(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 4, false);
+}
+void __asan_report_store8_noabort(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 8, false);
+}
+void __asan_report_store16_noabort(uptr addr) {
+  __asan_abi_report_store_n((void *)addr, 16, false);
+}
+void __asan_report_store_n_noabort(uptr addr, uptr size) {
+  __asan_abi_report_store_n((void *)addr, size, false);
+}
+
+// Functions concerning memory load and store
+void __asan_load1(uptr addr) { __asan_abi_load_n((void *)addr, 1, true); }
+void __asan_load2(uptr addr) { __asan_abi_load_n((void *)addr, 2, true); }
+void __asan_load4(uptr addr) { __asan_abi_load_n((void *)addr, 4, true); }
+void __asan_load8(uptr addr) { __asan_abi_load_n((void *)addr, 8, true); }
+void __asan_load16(uptr addr) { __asan_abi_load_n((void *)addr, 16, true); }
+void __asan_loadN(uptr addr, uptr size) {
+  __asan_abi_load_n((void *)addr, size, true);
+}
+void __asan_store1(uptr addr) { __asan_abi_store_n((void *)addr, 1, true); }
+void __asan_store2(uptr addr) { __asan_abi_store_n((void *)addr, 2, true); }
+void __asan_store4(uptr addr) { __asan_abi_store_n((void *)addr, 4, true); }
+void __asan_store8(uptr addr) { __asan_abi_store_n((void *)addr, 8, true); }
+void __asan_store16(uptr addr) { __asan_abi_store_n((void *)addr, 16, true); }
+void __asan_storeN(uptr addr, uptr size) {
+  __asan_abi_store_n((void *)addr, size, true);
+}
+
+// Functions concerning memory load and store (experimental variants)
+void __asan_exp_load1(uptr addr, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, 1, exp, true);
+}
+void __asan_exp_load2(uptr addr, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, 2, exp, true);
+}
+void __asan_exp_load4(uptr addr, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, 4, exp, true);
+}
+void __asan_exp_load8(uptr addr, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, 8, exp, true);
+}
+void __asan_exp_load16(uptr addr, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, 16, exp, true);
+}
+void __asan_exp_loadN(uptr addr, uptr size, u32 exp) {
+  __asan_abi_exp_load_n((void *)addr, size, exp, true);
+}
+void __asan_exp_store1(uptr addr, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, 1, exp, true);
+}
+void __asan_exp_store2(uptr addr, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, 2, exp, true);
+}
+void __asan_exp_store4(uptr addr, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, 4, exp, true);
+}
+void __asan_exp_store8(uptr addr, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, 8, exp, true);
+}
+void __asan_exp_store16(uptr addr, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, 16, exp, true);
+}
+void __asan_exp_storeN(uptr addr, uptr size, u32 exp) {
+  __asan_abi_exp_store_n((void *)addr, size, exp, true);
+}
+
+// Functions concerning memory load and store (noabort variants)
+void __asan_load1_noabort(uptr addr) {
+  __asan_abi_load_n((void *)addr, 1, false);
+}
+void __asan_load2_noabort(uptr addr) {
+  __asan_abi_load_n((void *)addr, 2, false);
+}
+void __asan_load4_noabort(uptr addr) {
+  __asan_abi_load_n((void *)addr, 4, false);
+}
+void __asan_load8_noabort(uptr addr) {
+  __asan_abi_load_n((void *)addr, 8, false);
+}
+void __asan_load16_noabort(uptr addr) {
+  __asan_abi_load_n((void *)addr, 16, false);
+}
+void __asan_loadN_noabort(uptr addr, uptr size) {
+  __asan_abi_load_n((void *)addr, size, false);
+}
+void __asan_store1_noabort(uptr addr) {
+  __asan_abi_store_n((void *)addr, 1, false);
+}
+void __asan_store2_noabort(uptr addr) {
+  __asan_abi_store_n((void *)addr, 2, false);
+}
+void __asan_store4_noabort(uptr addr) {
+  __asan_abi_store_n((void *)addr, 4, false);
+}
+void __asan_store8_noabort(uptr addr) {
+  __asan_abi_store_n((void *)addr, 8, false);
+}
+void __asan_store16_noabort(uptr addr) {
+  __asan_abi_store_n((void *)addr, 16, false);
+}
+void __asan_storeN_noabort(uptr addr, uptr size) {
+  __asan_abi_store_n((void *)addr, size, false);
+}
+
+// Functions concerning query about whether memory is poisoned
+int __asan_address_is_poisoned(void const volatile *addr) {
+  return __asan_abi_address_is_poisoned(addr);
+}
+uptr __asan_region_is_poisoned(uptr beg, uptr size) {
+  return (uptr)__asan_abi_region_is_poisoned((void *)beg, size);
+}
+
+// Functions concerning the poisoning of memory
+void __asan_poison_memory_region(void const volatile *addr, uptr size) {
+  __asan_abi_poison_memory_region(addr, size);
+}
+void __asan_unpoison_memory_region(void const volatile *addr, uptr size) {
+  __asan_abi_unpoison_memory_region(addr, size);
+}
+
+// Functions concerning the partial poisoning of memory
+void __asan_set_shadow_00(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x00, size);
+}
+void __asan_set_shadow_01(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x01, size);
+}
+void __asan_set_shadow_02(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x02, size);
+}
+void __asan_set_shadow_03(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x03, size);
+}
+void __asan_set_shadow_04(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x04, size);
+}
+void __asan_set_shadow_05(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x05, size);
+}
+void __asan_set_shadow_06(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x06, size);
+}
+void __asan_set_shadow_07(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0x07, size);
+}
+void __asan_set_shadow_f1(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0xf1, size);
+}
+void __asan_set_shadow_f2(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0xf2, size);
+}
+void __asan_set_shadow_f3(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0xf3, size);
+}
+void __asan_set_shadow_f5(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0xf5, size);
+}
+void __asan_set_shadow_f8(uptr addr, uptr size) {
+  __asan_abi_set_shadow_xx_n((void *)addr, 0xf8, size);
+}
+
+// Functions concerning stack poisoning
+void __asan_poison_stack_memory(uptr addr, uptr size) {
+  __asan_abi_poison_stack_memory((void *)addr, size);
+}
+void __asan_unpoison_stack_memory(uptr addr, uptr size) {
+  __asan_abi_unpoison_stack_memory((void *)addr, size);
+}
+
+// Functions concerning redzone poisoning
+void __asan_poison_intra_object_redzone(uptr p, uptr size) {}
+void __asan_unpoison_intra_object_redzone(uptr p, uptr size) {}
+
+// Functions concerning array cookie poisoning
+void __asan_poison_cxx_array_cookie(uptr p) {}
+uptr __asan_load_cxx_array_cookie(uptr *p) {
+  // TBD: Fail here
+  return (uptr)0;
+}
+
+// Functions concerning fake stacks
+void *__asan_get_current_fake_stack(void) {
+  // TBD: Fail here
+  return (void *)0;
+}
+void *__asan_addr_is_in_fake_stack(void *fake_stack, void *addr, void **beg,
+                                   void **end) {
+  // TBD: Fail here
+  return (void *)0;
+}
+
+// Functions concerning poisoning and unpoisoning fake stack alloca
+void __asan_alloca_poison(uptr addr, uptr size) {
+  __asan_abi_alloca_poison((void *)addr, size);
+}
+void __asan_allocas_unpoison(uptr top, uptr bottom) {
+  __asan_abi_allocas_unpoison((void *)top, (void *)bottom);
+}
+
+// Functions concerning fake stack malloc
+uptr __asan_stack_malloc_0(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(0, size);
+}
+uptr __asan_stack_malloc_1(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(1, size);
+}
+uptr __asan_stack_malloc_2(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(2, size);
+}
+uptr __asan_stack_malloc_3(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(3, size);
+}
+uptr __asan_stack_malloc_4(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(4, size);
+}
+uptr __asan_stack_malloc_5(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(5, size);
+}
+uptr __asan_stack_malloc_6(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(6, size);
+}
+uptr __asan_stack_malloc_7(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(7, size);
+}
+uptr __asan_stack_malloc_8(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(8, size);
+}
+uptr __asan_stack_malloc_9(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(9, size);
+}
+uptr __asan_stack_malloc_10(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_n(10, size);
+}
+
+// Functions concerning fake stack malloc (always variants)
+uptr __asan_stack_malloc_always_0(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(0, size);
+}
+uptr __asan_stack_malloc_always_1(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(1, size);
+}
+uptr __asan_stack_malloc_always_2(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(2, size);
+}
+uptr __asan_stack_malloc_always_3(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(3, size);
+}
+uptr __asan_stack_malloc_always_4(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(4, size);
+}
+uptr __asan_stack_malloc_always_5(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(5, size);
+}
+uptr __asan_stack_malloc_always_6(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(6, size);
+}
+uptr __asan_stack_malloc_always_7(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(7, size);
+}
+uptr __asan_stack_malloc_always_8(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(8, size);
+}
+uptr __asan_stack_malloc_always_9(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(9, size);
+}
+uptr __asan_stack_malloc_always_10(uptr size) {
+  return (uptr)__asan_abi_stack_malloc_always_n(10, size);
+}
+
+// Functions concerning fake stack free
+void __asan_stack_free_0(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(0, (void *)ptr, size);
+}
+void __asan_stack_free_1(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(1, (void *)ptr, size);
+}
+void __asan_stack_free_2(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(2, (void *)ptr, size);
+}
+void __asan_stack_free_3(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(3, (void *)ptr, size);
+}
+void __asan_stack_free_4(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(4, (void *)ptr, size);
+}
+void __asan_stack_free_5(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(5, (void *)ptr, size);
+}
+void __asan_stack_free_6(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(6, (void *)ptr, size);
+}
+void __asan_stack_free_7(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(7, (void *)ptr, size);
+}
+void __asan_stack_free_8(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(8, (void *)ptr, size);
+}
+void __asan_stack_free_9(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(9, (void *)ptr, size);
+}
+void __asan_stack_free_10(uptr ptr, uptr size) {
+  __asan_abi_stack_free_n(10, (void *)ptr, size);
+}
+
+// Functions concerning introspection (including lldb support)
+uptr __asan_get_alloc_stack(uptr addr, uptr *trace, uptr size, u32 *thread_id) {
+  // TBD: Fail here
+  return (uptr)0;
+}
+void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
+                         uptr access_size, u32 exp) {}
+void __asan_set_error_report_callback(void (*callback)(const char *)) {}
+void __asan_describe_address(uptr addr) {}
+int __asan_report_present(void) { return (int)0; }
+uptr __asan_get_report_pc(void) { return (uptr)0; }
+uptr __asan_get_report_bp(void) { return (uptr)0; }
+uptr __asan_get_report_sp(void) { return (uptr)0; }
+uptr __asan_get_report_address(void) { return (uptr)0; }
+int __asan_get_report_access_type(void) { return (int)0; }
+uptr __asan_get_report_access_size(void) { return (uptr)0; }
+const char *__asan_get_report_description(void) { return (const char *)0; }
+}

compiler-rt/lib/asan_abi/asan_abi_tbd.txt

+__asan_default_options
+__asan_default_suppressions
+__asan_get_free_stack
+__asan_get_shadow_mapping
+__asan_handle_vfork
+__asan_locate_address
+__asan_on_error
+__asan_print_accumulated_stats
+__asan_set_death_callback
+__asan_update_allocation_context

compiler-rt/test/asan_abi/CMakeLists.txt

+set(ASAN_ABI_LIT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(ASAN_ABI_TESTSUITES)
+
+macro(get_bits_for_arch arch bits)
+  if (${arch} MATCHES "arm64")
+    set(${bits} 64)
+  else()
+    message(FATAL_ERROR "Unknown target architecture: ${arch}")
+  endif()
+endmacro()
+
+set(ASAN_ABI_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND ASAN_ABI_TEST_DEPS asan_abi)
+endif()
+set(ASAN_ABI_DYNAMIC_TEST_DEPS ${ASAN_ABI_TEST_DEPS})
+
+set(ASAN_ABI_TEST_ARCH arm64)
+
+foreach(arch ${ASAN_ABI_TEST_ARCH})
+  set(ASAN_ABI_TEST_TARGET_ARCH ${arch})
+  set(ASAN_ABI_TEST_APPLE_PLATFORM "osx")
+  set(ASAN_ABI_TEST_MIN_DEPLOYMENT_TARGET_FLAG "${DARWIN_osx_MIN_VER_FLAG}")
+  string(TOLOWER "-${arch}-${OS_NAME}" ASAN_ABI_TEST_CONFIG_SUFFIX)
+  get_bits_for_arch(${arch} ASAN_ABI_TEST_BITS)
+  get_test_cc_for_arch(${arch} ASAN_ABI_TEST_TARGET_CC ASAN_ABI_TEST_TARGET_CFLAGS)
+  if(ANDROID OR APPLE)
+    set(ASAN_ABI_TEST_DYNAMIC True)
+  else()
+    set(ASAN_ABI_TEST_DYNAMIC False)
+  endif()
+  string(TOUPPER ${arch} ARCH_UPPER_CASE)
+  set(CONFIG_NAME ${ARCH_UPPER_CASE}${OS_NAME}Config)
+
+  list(APPEND ASAN_ABI_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py
+    )
+endforeach()
+
+add_lit_testsuite(check-asan-abi "Running the AddressSanitizerABI tests"
+  ${ASAN_ABI_TESTSUITES}
+  ${exclude_from_check_all}
+  DEPENDS ${ASAN_ABI_TEST_DEPS})
+set_target_properties(check-asan-abi PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/test/asan_abi/TestCases/Darwin/llvm_interface_symbols.cpp

+// RUN: %clang_asan_abi -O0 -c -fsanitize-stable-abi -fsanitize=address %s -o %t.o
+// RUN: %clangxx -c %p/../../../../lib/asan_abi/asan_abi.cpp -o asan_abi.o
+// RUN: %clangxx -dead_strip -o %t %t.o %libasan_abi asan_abi.o && %run %t 2>&1
+// RUN: %clangxx -x c++-header -o - -E %p/../../../../lib/asan/asan_interface.inc \
+// RUN: | sed "s/INTERFACE_FUNCTION/\nINTERFACE_FUNCTION/g" > %t.asan_interface.inc
+// RUN: llvm-nm -g %libasan_abi                                   \
+// RUN: | grep " [TU] "                                           \
+// RUN: | grep -o "\(__asan\)[^ ]*"                               \
+// RUN: | grep -v "\(__asan_abi\)[^ ]*"                           \
+// RUN: | sed -e "s/__asan_version_mismatch_check_v[0-9]+/__asan_version_mismatch_check/" \
+// RUN: > %t.exports
+// RUN: sed -e ':a' -e 'N' -e '$!ba'                              \
+// RUN:     -e 's/ //g'                                           \
+// RUN:     -e ':b' -e 's/\n\n/\n/g' -e 'tb'                      \
+// RUN:     -e 's/(\n/(/g'                                        \
+// RUN: %t.asan_interface.inc                                     \
+// RUN: | grep -v -f %p/../../../../lib/asan_abi/asan_abi_tbd.txt \
+// RUN: | grep -e "INTERFACE_\(WEAK_\)\?FUNCTION"                 \
+// RUN: | grep -v "__sanitizer[^ ]*"                              \
+// RUN: | sed -e "s/.*(//" -e "s/).*//" > %t.imports
+// RUN: sort %t.imports | uniq > %t.imports-sorted
+// RUN: sort %t.exports | uniq > %t.exports-sorted
+// RUN: diff %t.imports-sorted %t.exports-sorted
+
+// UNSUPPORTED: ios
+
+int main() { return 0; }

compiler-rt/test/asan_abi/TestCases/linkstaticlibrary.cpp

+// RUN: %clang_asan_abi  -O2 -c -fsanitize-stable-abi -fsanitize=address -O0 %s -o %t.o
+// RUN: %clangxx -c %p/../../../lib/asan_abi/asan_abi.cpp -o asan_abi.o
+// RUN: %clangxx -o %t %t.o %libasan_abi asan_abi.o && %run %t 2>&1
+
+int main() { return 0; }

compiler-rt/test/asan_abi/lit.cfg.py

+# -*- Python -*-
+
+import os
+import platform
+import re
+
+import lit.formats
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if attr_value is None:
+    lit_config.fatal(
+      'No attribute %r in test configuration! You may need to run '
+      'tests from your build directory or add this attribute '
+      'to lit.site.cfg.py ' % attr_name)
+  return attr_value
+
+# Setup config name.
+config.name = 'AddressSanitizerABI' + config.name_suffix
+
+# Platform-specific default ASAN_ABI_OPTIONS for lit tests.
+default_asan_abi_opts = list(config.default_sanitizer_opts)
+
+default_asan_abi_opts_str = ':'.join(default_asan_abi_opts)
+if default_asan_abi_opts_str:
+  config.environment['ASAN_ABI_OPTIONS'] = default_asan_abi_opts_str
+  default_asan_abi_opts_str += ':'
+config.substitutions.append(('%env_asan_abi_opts=',
+                             'env ASAN_ABI_OPTIONS=' + default_asan_abi_opts_str))
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# GCC-ASan doesn't link in all the necessary libraries automatically, so
+# we have to do it ourselves.
+extra_link_flags = []
+
+# Setup default compiler flags used with -fsanitize=address option.
+# FIXME: Review the set of required flags and check if it can be reduced.
+target_cflags = [get_required_attr(config, 'target_cflags')] + extra_link_flags
+target_cxxflags = config.cxx_mode_flags + target_cflags
+clang_asan_abi_static_cflags = (['-fsanitize=address',
+                            '-fsanitize-stable-abi',
+                            '-mno-omit-leaf-frame-pointer',
+                            '-fno-omit-frame-pointer',
+                            '-fno-optimize-sibling-calls'] +
+                            config.debug_info_flags + target_cflags)
+clang_asan_abi_static_cxxflags = config.cxx_mode_flags + clang_asan_abi_static_cflags
+
+config.available_features.add('asan_abi-static-runtime')
+clang_asan_abi_cflags = clang_asan_abi_static_cflags
+clang_asan_abi_cxxflags = clang_asan_abi_static_cxxflags
+
+def build_invocation(compile_flags):
+  return ' ' + ' '.join([config.clang] + compile_flags) + ' '
+
+config.substitutions.append( ('%clang ', build_invocation(target_cflags)) )
+config.substitutions.append( ('%clangxx ', build_invocation(target_cxxflags)) )
+config.substitutions.append( ('%clang_asan_abi ', build_invocation(clang_asan_abi_cflags)) )
+config.substitutions.append( ('%clangxx_asan_abi ', build_invocation(clang_asan_abi_cxxflags)) )
+
+libasan_abi_path = os.path.join(config.compiler_rt_libdir, 'libclang_rt.asan_abi_osx.a'.format(config.apple_platform))
+
+if libasan_abi_path is not None:
+  config.substitutions.append( ('%libasan_abi', libasan_abi_path) )
+  config.substitutions.append( ('%clang_asan_abi_static ', build_invocation(clang_asan_abi_static_cflags)) )
+  config.substitutions.append( ('%clangxx_asan_abi_static ', build_invocation(clang_asan_abi_static_cxxflags)) )
+
+config.suffixes = ['.c', '.cpp']
+
+if config.host_os == 'Darwin':
+  config.suffixes.append('.mm')
+else:
+  config.unsupported = True

compiler-rt/test/asan_abi/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+# Tool-specific config options.
+config.name_suffix = "@ASAN_ABI_TEST_CONFIG_SUFFIX@"
+config.target_cflags = "@ASAN_ABI_TEST_TARGET_CFLAGS@"
+config.clang = "@ASAN_ABI_TEST_TARGET_CC@"
+config.bits = "@ASAN_ABI_TEST_BITS@"
+config.arm_thumb = "@COMPILER_RT_ARM_THUMB@"
+config.apple_platform = "@ASAN_ABI_TEST_APPLE_PLATFORM@"
+config.apple_platform_min_deployment_target_flag = "@ASAN_ABI_TEST_MIN_DEPLOYMENT_TARGET_FLAG@"
+config.asan_abi_dynamic = @ASAN_ABI_TEST_DYNAMIC@
+config.target_arch = "@ASAN_ABI_TEST_TARGET_ARCH@"
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@ASAN_ABI_LIT_SOURCE_DIR@/lit.cfg.py")