[compiler-rt][UBSan] Sanitization for alignment assumptions.

[lebedev.ri]

Summary

This is the compiler-rt part.
The clang part is D54589.

[lebedev.ri]

Adapt with the actual pointer no longer being provided, compute it by subtracting the offset.
While there, also display the misalignment offest (the result of the real pointer & aligment mask).

[lebedev.ri]

ping

[lebedev.ri]

Only this compiler-rt part remains.
Would be kind-of cool to have sanitization for this UB even before it is formally added to the C++ library (D54966)

[lebedev.ri]

Ping.

[lebedev.ri]

ping @filcab. Also, is there anyone else who is confident reviewing such ubsan handler patches? I do see that it is a very low activity/throughput area of code..

[lebedev.ri]

Ping.
Ping @kcc / @rsmith / @filcab / @vsk - do i have the right reviewer list here?

[rsmith]

lib/ubsan/ubsan_handlers.cc

133–141 ↗

(On Diff #174452)

ubsan's diagnostic format is intended to be "like a clang diagnostic", so should be a single sentence. How splitting this into an error pointing at the source location ("assumption [...] failed"), and a note pointing at the memory address that the pointer points to ("address is [...] aligned, misalignment offset is [...] bytes")...

149 ↗

(On Diff #174452)

... and removing this note.

[lebedev.ri]

@rsmith thank you for taking a look!
I believe i have addressed the review notes, does this look better?

[lebedev.ri]

lib/ubsan/ubsan_handlers.cc

146 ↗

(On Diff #179274)

Hmm, though one thing extra i forgot to do, is to print "address vs "offset address.
Will adjust later.

[krytarowski]

Can you test thread_local too?

[lebedev.ri]

In D54590#1340150, @krytarowski wrote:

Can you test thread_local too?

Can you please be more specific? Which test do you want to see?

[krytarowski]

In D54590#1340152, @lebedev.ri wrote:

In D54590#1340150, @krytarowski wrote:

Can you test thread_local too?

Can you please be more specific? Which test do you want to see?

It has been noted that NetBSD's ld.elf_so does not support alignment and there is a workaround in xray: D56000.

It would be helpful to test similar (harder to debug) scenarios with UBSan and its tests.

[lebedev.ri]

In D54590#1340156, @krytarowski wrote:

In D54590#1340152, @lebedev.ri wrote:

In D54590#1340150, @krytarowski wrote:

Can you test thread_local too?

Can you please be more specific? Which test do you want to see?

It has been noted that NetBSD's ld.elf_so does not support alignment and there is a workaround in xray: D56000.

It would be helpful to test similar (harder to debug) scenarios with UBSan and its tests.

I'm guessing you want me to test that this has some ubsan check, correct? https://godbolt.org/z/5xNnBu
It currently will not, and this check will not do it.

And because @_ZZ18getThreadLocalDatavE10TLDStorage is declared with align 64 attribute,
even if i emit the check, it will be trivially dropped by middle-end.
So i'm not sure how to catch this yet.

[krytarowski]

In D54590#1340166, @lebedev.ri wrote:

In D54590#1340156, @krytarowski wrote:

In D54590#1340152, @lebedev.ri wrote:

In D54590#1340150, @krytarowski wrote:

Can you test thread_local too?

Can you please be more specific? Which test do you want to see?

It has been noted that NetBSD's ld.elf_so does not support alignment and there is a workaround in xray: D56000.

It would be helpful to test similar (harder to debug) scenarios with UBSan and its tests.

I'm guessing you want me to test that this has some ubsan check, correct? https://godbolt.org/z/5xNnBu
It currently will not, and this check will not do it.

And because @_ZZ18getThreadLocalDatavE10TLDStorage is declared with align 64 attribute,
even if i emit the check, it will be trivially dropped by middle-end.
So i'm not sure how to catch this yet.

I see, pity that it's not expandable right not to TLS allocations.

There is a related workaround in the implementation of TSan for misalignment.

[lebedev.ri]

Adjust one message to state that it is talking about offset address.

[lebedev.ri]

ping

[lebedev.ri]

Happy 2019 everyone!
Last ping before 8.0 branch.

[lebedev.ri]

ping.

[morehouse]

lib/ubsan/ubsan_handlers.h

32 ↗

(On Diff #179462)

Nit: Let's move this to right before the matching RECOVERABLE line below.

test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

23 ↗

(On Diff #179462)

Any idea why the assignment doesn't trigger a report while the unused return value does?

[lebedev.ri]

Oh yay, thank you for the review!

test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

23 ↗

(On Diff #179462)

Because no alignment assumption is being emitted in that case.

The question is, given such a cast that increases the alignment,
if the run-time check is to fail, is the cast is itself UB already,
or is it UB to use the resulting mis-aligned pointer?
(CC @rjmccall, @rsmith)

Regardless, this is mainly a question for a clang side,
and i think it can be addressed as a follow-up.

[lebedev.ri]

Rebased before commit, addressed @morehouse review note.

lib/ubsan/ubsan_handlers.h

32 ↗

(On Diff #179462)

Hmm, right.

[rjmccall]

test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

23 ↗

(On Diff #179462)

The C standard says the cast is UB; q.v. C99 6.3.2.3p6:

A pointer to an object or incomplete type may be converted to a pointer to a different object or incomplete type. If the resulting pointer is not correctly aligned57) for the pointed-to type, the behavior is undefined.

The C++ standard says the cast has an unspecified result; q.v. C++ N4640 [expr.static.cast]p13:

A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. If the original pointer value represents the address A of a byte in memory and A does not satisfy the alignment requirement of T, then the resulting pointer value is unspecified.

Actually using that unspecified value would then be UB.

If UBSan enforces alignment at the point of access, that's a significantly weaker check than either standard would allow. The C++ rule is basically the C rule except that the value is allowed to inertly propagate as long as it's not used, which in practice is unlikely — the real difference is that the C rule is extremely easy to enforce and the C++ rule is extremely difficult. All that said, prudentially, I think the rule that UBSan currently enforces is probably the right balance.

[lebedev.ri]

test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

23 ↗

(On Diff #179462)

Thank you for chiming in!

I did find that C++ part, and thus didn't really consider this as a bug before.

I suppose we could either emit the check when in C mode;
or be pedantic, and specify that in C++ case a run-time diag should happen,
but indeed, i'm not sure what is best here.
Early detection would be better if you ask me though.

[rjmccall]

test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

23 ↗

(On Diff #179462)

Do we have a sanitizer that tries to propagate "poison" values? Something like an uninitialized-variable sanitizer which allows loads of uninitialized variables as long as the loaded value is unused?

[thakis]

The test seems to flakily fail sometimes:

https://logs.chromium.org/logs/chromium/bb/tryserver.chromium.win/win_upload_clang/478/+/recipes/steps/package_clang/0/stdout

Testing: 0 .. 10.. 20.. 30.. 40.. 50.. 60.. 70.. 80.. 90
FAIL: UBSan-Standalone-x86_64 :: TestCases/Pointer/alignment-assumption-attribute-assume_aligned-on-function.cpp (44397 of 46501)
******************** TEST 'UBSan-Standalone-x86_64 :: TestCases/Pointer/alignment-assumption-attribute-assume_aligned-on-function.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c   -fsanitize=alignment -O0 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 2';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c   -fsanitize=alignment -O1 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 3';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c   -fsanitize=alignment -O2 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 4';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c   -fsanitize=alignment -O3 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 6';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c++ -fsanitize=alignment -O0 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 7';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c++ -fsanitize=alignment -O1 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 8';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c++ -fsanitize=alignment -O2 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
: 'RUN: at line 9';      C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe       -x c++ -fsanitize=alignment -O3 C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp -o C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp &&  C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp 2>&1 | FileCheck C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
--
Exit Code: 1104

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe" "-x" "c" "-fsanitize=alignment" "-O0" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "-o" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
# command output:
   Creating library C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.lib and object C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.exp

$ "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
$ "FileCheck" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "--implicit-check-not= assumption " "--implicit-check-not=note:" "--implicit-check-not=error:"
$ ":" "RUN: at line 2"
$ "C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe" "-x" "c" "-fsanitize=alignment" "-O1" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "-o" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
# command output:
   Creating library C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.lib and object C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.exp

$ "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
$ "FileCheck" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "--implicit-check-not= assumption " "--implicit-check-not=note:" "--implicit-check-not=error:"
$ ":" "RUN: at line 3"
$ "C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe" "-x" "c" "-fsanitize=alignment" "-O2" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "-o" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
# command output:
   Creating library C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.lib and object C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.exp

$ "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
$ "FileCheck" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "--implicit-check-not= assumption " "--implicit-check-not=note:" "--implicit-check-not=error:"
$ ":" "RUN: at line 4"
$ "C:/b/rr/tmpeazzxh/w/src/third_party/llvm-build/Release+Asserts/./bin/clang.exe" "-x" "c" "-fsanitize=alignment" "-O3" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm\projects\compiler-rt\test\ubsan\TestCases\Pointer\alignment-assumption-attribute-assume_aligned-on-function.cpp" "-o" "C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp"
# command output:
LINK : fatal error LNK1104: cannot open file 'C:\b\rr\tmpeazzxh\w\src\third_party\llvm-build\Release+Asserts\projects\compiler-rt\test\ubsan\Standalone-x86_64\TestCases\Pointer\Output\alignment-assumption-attribute-assume_aligned-on-function.cpp.tmp'

# command stderr:
clang: error: linker command failed with exit code 1104 (use -v to see invocation)

error: command failed with exit status: 1104

[thakis]

I filed https://bugs.llvm.org/show_bug.cgi?id=40627 about the ubsan test flakes. It might not be related to this change, since several other tests that haven't been touched in a while also show these problems.

[lebedev.ri]

In D54590#1386911, @thakis wrote:

I filed https://bugs.llvm.org/show_bug.cgi?id=40627 about the ubsan test flakes. It might not be related to this change, since several other tests that haven't been touched in a while also show these problems.

Thank you.

compiler-rt/trunk/lib/ubsan/ubsan_checks.inc

 
 // UBSAN_CHECK(Name, SummaryKind, FSanitizeFlagName)
 // SummaryKind and FSanitizeFlagName should be string literals.
 
 UBSAN_CHECK(GenericUB, "undefined-behavior", "undefined")
 UBSAN_CHECK(NullPointerUse, "null-pointer-use", "null")
 UBSAN_CHECK(PointerOverflow, "pointer-overflow", "pointer-overflow")
 UBSAN_CHECK(MisalignedPointerUse, "misaligned-pointer-use", "alignment")
+UBSAN_CHECK(AlignmentAssumption, "alignment-assumption", "alignment")
 UBSAN_CHECK(InsufficientObjectSize, "insufficient-object-size", "object-size")
 UBSAN_CHECK(SignedIntegerOverflow, "signed-integer-overflow",
             "signed-integer-overflow")
 UBSAN_CHECK(UnsignedIntegerOverflow, "unsigned-integer-overflow",
             "unsigned-integer-overflow")
 UBSAN_CHECK(IntegerDivideByZero, "integer-divide-by-zero",
             "integer-divide-by-zero")
 UBSAN_CHECK(FloatDivideByZero, "float-divide-by-zero", "float-divide-by-zero")

compiler-rt/trunk/lib/ubsan/ubsan_handlers.h

#define RECOVERABLE(checkname, ...) \
   extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
     void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );
 
 /// \brief Handle a runtime type check failure, caused by either a misaligned
 /// pointer, a null pointer, or a pointer to insufficient storage for the
 /// type.
 RECOVERABLE(type_mismatch_v1, TypeMismatchData *Data, ValueHandle Pointer)
 
+struct AlignmentAssumptionData {
+  SourceLocation Loc;
+  SourceLocation AssumptionLoc;
+  const TypeDescriptor &Type;
+};
+
+/// \brief Handle a runtime alignment assumption check failure,
+/// caused by a misaligned pointer.
+RECOVERABLE(alignment_assumption, AlignmentAssumptionData *Data,
+            ValueHandle Pointer, ValueHandle Alignment, ValueHandle Offset)
+
 struct OverflowData {
   SourceLocation Loc;
   const TypeDescriptor &Type;
 };
 
 /// \brief Handle an integer addition overflow.
 RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)
 

compiler-rt/trunk/lib/ubsan/ubsan_handlers.cc

 }
 void __ubsan::__ubsan_handle_type_mismatch_v1_abort(TypeMismatchData *Data,
                                                     ValueHandle Pointer) {
   GET_REPORT_OPTIONS(true);
   handleTypeMismatchImpl(Data, Pointer, Opts);
   Die();
 }
 
+static void handleAlignmentAssumptionImpl(AlignmentAssumptionData *Data,
+                                          ValueHandle Pointer,
+                                          ValueHandle Alignment,
+                                          ValueHandle Offset,
+                                          ReportOptions Opts) {
+  Location Loc = Data->Loc.acquire();
+  SourceLocation AssumptionLoc = Data->AssumptionLoc.acquire();
+
+  ErrorType ET = ErrorType::AlignmentAssumption;
+
+  if (ignoreReport(Loc.getSourceLocation(), Opts, ET))
+    return;
+
+  ScopedReport R(Opts, Loc, ET);
+
+  uptr RealPointer = Pointer - Offset;
+  uptr LSB = LeastSignificantSetBitIndex(RealPointer);
+  uptr ActualAlignment = uptr(1) << LSB;
+
+  uptr Mask = Alignment - 1;
+  uptr MisAlignmentOffset = RealPointer & Mask;
+
+  if (!Offset) {
+    Diag(Loc, DL_Error, ET,
+         "assumption of %0 byte alignment for pointer of type %1 failed")
+        << Alignment << Data->Type;
+  } else {
+    Diag(Loc, DL_Error, ET,
+         "assumption of %0 byte alignment (with offset of %1 byte) for pointer "
+         "of type %2 failed")
+        << Alignment << Offset << Data->Type;
+  }
+
+  if (!AssumptionLoc.isInvalid())
+    Diag(AssumptionLoc, DL_Note, ET, "alignment assumption was specified here");
+
+  Diag(RealPointer, DL_Note, ET,
+       "%0address is %1 aligned, misalignment offset is %2 bytes")
+      << (Offset ? "offset " : "") << ActualAlignment << MisAlignmentOffset;
+}
+
+void __ubsan::__ubsan_handle_alignment_assumption(AlignmentAssumptionData *Data,
+                                                  ValueHandle Pointer,
+                                                  ValueHandle Alignment,
+                                                  ValueHandle Offset) {
+  GET_REPORT_OPTIONS(false);
+  handleAlignmentAssumptionImpl(Data, Pointer, Alignment, Offset, Opts);
+}
+void __ubsan::__ubsan_handle_alignment_assumption_abort(
+    AlignmentAssumptionData *Data, ValueHandle Pointer, ValueHandle Alignment,
+    ValueHandle Offset) {
+  GET_REPORT_OPTIONS(true);
+  handleAlignmentAssumptionImpl(Data, Pointer, Alignment, Offset, Opts);
+  Die();
+}
+
 /// \brief Common diagnostic emission for various forms of integer overflow.
 template <typename T>
 static void handleIntegerOverflowImpl(OverflowData *Data, ValueHandle LHS,
                                       const char *Operator, T RHS,
                                       ReportOptions Opts) {
   SourceLocation Loc = Data->Loc.acquire();
   bool IsSigned = Data->Type.isSignedIntegerTy();
   ErrorType ET = IsSigned ? ErrorType::SignedIntegerOverflow

compiler-rt/trunk/lib/ubsan_minimal/ubsan_minimal_handlers.cc

INTERFACE void __ubsan_handle_##name##_minimal_abort() {       \
     abort_with_message("ubsan: " msg);                           \
   }
 
 #define HANDLER(name, msg)                                       \
   HANDLER_RECOVER(name, msg)                                     \
   HANDLER_NORECOVER(name, msg)
 
 HANDLER(type_mismatch, "type-mismatch")
+HANDLER(alignment_assumption, "alignment-assumption")
 HANDLER(add_overflow, "add-overflow")
 HANDLER(sub_overflow, "sub-overflow")
 HANDLER(mul_overflow, "mul-overflow")
 HANDLER(negate_overflow, "negate-overflow")
 HANDLER(divrem_overflow, "divrem-overflow")
 HANDLER(shift_out_of_bounds, "shift-out-of-bounds")
 HANDLER(out_of_bounds, "out-of-bounds")
 HANDLER_RECOVER(builtin_unreachable, "builtin-unreachable")

compiler-rt/trunk/test/fuzzer/AlignmentAssumptionTest.cpp

+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+
+// Test for alignment assumption failure.
+
+#include <assert.h>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <iostream>
+
+static volatile int32_t Sink;
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
+  assert(Data);
+  if (Size > 0 && Data[0] == 'H') {
+    Sink = 1;
+    if (Size > 1 && Data[1] == 'i') {
+      Sink = 2;
+      if (Size > 2 && Data[2] == '!') {
+        __builtin_assume_aligned(Data, 0x80000000);
+      }
+    }
+  }
+  return 0;
+}

compiler-rt/trunk/test/fuzzer/fuzzer-alignment-assumption.test

+RUN: rm -f %t-AlignmentAssumptionTest-Ubsan
+RUN: %cpp_compiler -fsanitize=alignment -fno-sanitize-recover=all %S/AlignmentAssumptionTest.cpp -o %t-AlignmentAssumptionTest-Ubsan
+RUN: not %run %t-AlignmentAssumptionTest-Ubsan 2>&1 | FileCheck %s
+CHECK: AlignmentAssumptionTest.cpp:22:34:  runtime error: assumption of 2147483648 byte alignment for pointer of type 'const {{.*}} *' (aka 'const unsigned char *') failed
+CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+CHECK: Test unit written to ./crash-

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-lvalue.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+typedef char ** __attribute__((align_value(0x80000000))) aligned_char;
+
+struct ac_struct {
+  aligned_char a;
+};
+
+char **load_from_ac_struct(struct ac_struct* x) {
+  return x->a;
+}
+
+int main(int argc, char* argv[]) {
+  struct ac_struct x;
+  x.a = argv; // FIXME: it is weird that this does not also have an assumption.
+  load_from_ac_struct(&x);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-7]]:13: runtime error: assumption of 2147483648 byte alignment for pointer of type 'aligned_char' (aka 'char **') failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-15]]:32: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-align_value-on-paramvar.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+char** passthrough(__attribute__((align_value(0x80000000))) char **x) {
+  return x;
+}
+
+int main(int argc, char* argv[]) {
+  passthrough(argv);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-5]]:10: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-7]]:35: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  // FIXME: shouldn't there be an assumption on the caller's side too?
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-alloc_align-on-function-variable.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+char **__attribute__((alloc_align(2)))
+passthrough(char **x, unsigned long alignment) {
+  return x;
+}
+
+unsigned long alignment;
+
+int main(int argc, char* argv[]) {
+  alignment = 0x80000000;
+
+  passthrough(argv, alignment);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-12]]:23: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-alloc_align-on-function.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+char **__attribute__((alloc_align(2)))
+passthrough(char **x, unsigned long alignment) {
+  return x;
+}
+
+int main(int argc, char* argv[]) {
+  passthrough(argv, 0x80000000);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-8]]:23: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-assume_aligned-on-function-two-params.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+char ** __attribute__((assume_aligned(0x80000000, 42))) passthrough(char** x) {
+  return x;
+}
+
+int main(int argc, char* argv[]) {
+  passthrough(argv);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 2147483648 byte alignment (with offset of 42 byte) for pointer of type 'char **' failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-7]]:24: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: offset address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-attribute-assume_aligned-on-function.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+char ** __attribute__((assume_aligned(0x80000000))) passthrough(char** x) {
+  return x;
+}
+
+int main(int argc, char* argv[]) {
+  passthrough(argv);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:3: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-7]]:24: note: alignment assumption was specified here
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-blacklist.cpp

+// FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=316
+// I'm not sure this is actually *that* issue, but this seems oddly similar to the other XFAIL'ed cases.
+// XFAIL: android
+// UNSUPPORTED: ios
+
+// RUN: %clang -fsanitize=alignment -fno-sanitize-recover=alignment                           -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption "
+
+// RUN: rm -f %tmp
+// RUN: echo "[alignment]" >> %tmp
+// RUN: echo "fun:main" >> %tmp
+// RUN: %clang -fsanitize=alignment -fno-sanitize-recover=alignment -fsanitize-blacklist=%tmp -O0 %s -o %t && %run %t 2>&1
+
+int main(int argc, char* argv[]) {
+  __builtin_assume_aligned(argv, 0x80000000);
+  // CHECK: {{.*}}alignment-assumption-blacklist.cpp:[[@LINE-1]]:28: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-builtin_assume_aligned-three-params-variable.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+volatile long offset;
+
+int main(int argc, char* argv[]) {
+  offset = 42;
+
+  __builtin_assume_aligned(argv, 0x80000000, offset);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:28: runtime error: assumption of 2147483648 byte alignment (with offset of 42 byte) for pointer of type 'char **' failed
+  // CHECK: 0x{{.*}}: note: offset address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-builtin_assume_aligned-three-params.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+int main(int argc, char* argv[]) {
+  __builtin_assume_aligned(argv, 0x80000000, 42);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:28: runtime error: assumption of 2147483648 byte alignment (with offset of 42 byte) for pointer of type 'char **' failed
+  // CHECK: 0x{{.*}}: note: offset address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-builtin_assume_aligned-two-params.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+int main(int argc, char* argv[]) {
+  __builtin_assume_aligned(argv, 0x80000000);
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-1]]:28: runtime error: assumption of 2147483648 byte alignment for pointer of type 'char **' failed
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-openmp.cpp

+// RUN: %clang   -x c   -fsanitize=alignment -fopenmp-simd -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -fopenmp-simd -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -fopenmp-simd -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c   -fsanitize=alignment -fopenmp-simd -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+// RUN: %clang   -x c++ -fsanitize=alignment -fopenmp-simd -O0 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -fopenmp-simd -O1 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -fopenmp-simd -O2 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+// RUN: %clang   -x c++ -fsanitize=alignment -fopenmp-simd -O3 %s -o %t && %run %t 2>&1 | FileCheck %s --implicit-check-not=" assumption " --implicit-check-not="note:" --implicit-check-not="error:"
+
+int main(int argc, char* argv[]) {
+#pragma omp for simd aligned(argv : 0x40000000)
+  for(int x = 0; x < 1; x++)
+    argv[x] = argv[x];
+  // CHECK: {{.*}}alignment-assumption-{{.*}}.cpp:[[@LINE-3]]:30: runtime error: assumption of 1073741824 byte alignment for pointer of type 'char **' failed
+  // CHECK: 0x{{.*}}: note: address is {{.*}} aligned, misalignment offset is {{.*}} byte
+
+  return 0;
+}

compiler-rt/trunk/test/ubsan/TestCases/Pointer/alignment-assumption-summary.cpp

+// RUN: %clangxx -fsanitize=alignment %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-NOTYPE
+// RUN: %env_ubsan_opts=report_error_type=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-TYPE
+// REQUIRES: !ubsan-standalone && !ubsan-standalone-static
+
+int main(int argc, char* argv[]) {
+  __builtin_assume_aligned(argv, 0x80000000);
+  // CHECK-NOTYPE: SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior {{.*}}summary.cpp:[[@LINE-1]]:28
+  // CHECK-TYPE: SUMMARY: UndefinedBehaviorSanitizer: alignment-assumption {{.*}}summary.cpp:[[@LINE-2]]:28
+  return 0;
+}

compiler-rt/trunk/test/ubsan_minimal/TestCases/alignment-assumption.c

+// RUN: %clang -fsanitize=alignment %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+int main(int argc, char* argv[]) {
+// CHECK-NOT: alignment-assumption
+
+  __builtin_assume_aligned(argv, 0x80000000);
+// CHECK: alignment-assumption
+// CHECK-NOT: alignment-assumption
+
+  return 0;
+}