RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-25 04:02:41 +01:00
Code Issues Projects Releases Wiki Activity

Unify clang/llvm attributes for asan/tsan/msan (LLVM part)

Browse Source 
These are two related changes (one in llvm, one in clang).
LLVM: 
- rename address_safety => sanitize_address (the enum value is the same, so we preserve binary compatibility with old bitcode)
- rename thread_safety => sanitize_thread
- rename no_uninitialized_checks -> sanitize_memory

CLANG: 
- add __attribute__((no_sanitize_address)) as a synonym for __attribute__((no_address_safety_analysis))
- add __attribute__((no_sanitize_thread))
- add __attribute__((no_sanitize_memory))

for S in address thread memory
If -fsanitize=S is present and __attribute__((no_sanitize_S)) is not
set llvm attribute sanitize_S

llvm-svn: 176075
This commit is contained in:
Kostya Serebryany 2013-02-26 06:58:09 +00:00
parent 46cd4a307a
commit f560b78692
25 changed files with 127 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
docs/LangRef.rst
View File

@ -793,9 +793,6 @@ example:
define void @f() alwaysinline optsize { ... }
define void @f() optsize { ... }
``address_safety``
This attribute indicates that the address safety analysis is enabled
for this function.
``alignstack(<n>)``
This attribute indicates that, when emitting the prologue and
epilogue, the backend should forcibly align the stack pointer.
@ -873,6 +870,15 @@ example:
``setjmp`` is an example of such a function. The compiler disables
some optimizations (like tail calls) in the caller of these
functions.
``sanitize_address``
This attribute indicates that AddressSanitizer checks
(dynamic address safety analysis) are enabled for this function.
``sanitize_memory``
This attribute indicates that MemorySanitizer checks (dynamic detection
of accesses to uninitialized memory) are enabled for this function.
``sanitize_thread``
This attribute indicates that ThreadSanitizer checks
(dynamic thread safety analysis) are enabled for this function.
``ssp``
This attribute indicates that the function should emit a stack
smashing protector. It is in the form of a "canary" --- a random value
@ -914,12 +920,6 @@ example:
If a function that has an ``sspstrong`` attribute is inlined into a
function that doesn't have an ``sspstrong`` attribute, then the
resulting function will have an ``sspstrong`` attribute.
``thread_safety``
This attribute indicates that the thread safety analysis is enabled
for this function.
``uninitialized_checks``
This attribute indicates that the checks for uses of uninitialized
memory are enabled.
``uwtable``
This attribute indicates that the ABI being targeted requires that
an unwind table entry be produce for this function even if we can

6
include/llvm/IR/Attributes.h
View File

@ -63,7 +63,6 @@ public:
enum AttrKind {
// IR-Level Attributes
None, ///< No attributes have been set
AddressSafety, ///< Address safety checking is on.
Alignment, ///< Alignment of parameter (5 bits)
///< stored as log2 of alignment with +1 bias
///< 0 means unaligned (different from align(1))
@ -98,8 +97,9 @@ public:
StackProtectReq, ///< Stack protection required.
StackProtectStrong, ///< Strong Stack protection.
StructRet, ///< Hidden pointer to structure to return
ThreadSafety, ///< Thread safety checking is on.
UninitializedChecks, ///< Checking for uses of uninitialized memory is on.
SanitizeAddress, ///< AddressSanitizer is on.
SanitizeThread, ///< ThreadSanitizer is on.
SanitizeMemory, ///< MemorySanitizer is on.
UWTable, ///< Function must be in a unwind table
ZExt, ///< Zero extended before/after call

4
lib/Analysis/MemoryDependenceAnalysis.cpp
View File

@ -287,7 +287,7 @@ getLoadLoadClobberFullWidthSize(const Value *MemLocBase, int64_t MemLocOffs,
// Load widening is hostile to ThreadSanitizer: it may cause false positives
// or make the reports more cryptic (access sizes are wrong).
if (LI->getParent()->getParent()->getAttributes().
hasAttribute(AttributeSet::FunctionIndex, Attribute::ThreadSafety))
hasAttribute(AttributeSet::FunctionIndex, Attribute::SanitizeThread))
return 0;
// Get the base of this load.
@ -334,7 +334,7 @@ getLoadLoadClobberFullWidthSize(const Value *MemLocBase, int64_t MemLocOffs,
if (LIOffs+NewLoadByteSize > MemLocEnd &&
LI->getParent()->getParent()->getAttributes().
hasAttribute(AttributeSet::FunctionIndex, Attribute::AddressSafety))
hasAttribute(AttributeSet::FunctionIndex, Attribute::SanitizeAddress))
// We will be reading past the location accessed by the original program.
// While this is safe in a regular build, Address Safety analysis tools
// may start reporting false warnings. So, don't do widening.

6
lib/AsmParser/LLLexer.cpp
View File

@ -562,7 +562,6 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(attributes);
KEYWORD(address_safety);
KEYWORD(alwaysinline);
KEYWORD(byval);
KEYWORD(inlinehint);
@ -589,8 +588,9 @@ lltok::Kind LLLexer::LexIdentifier() {
KEYWORD(ssp);
KEYWORD(sspreq);
KEYWORD(sspstrong);
KEYWORD(thread_safety);
KEYWORD(uninitialized_checks);
KEYWORD(sanitize_address);
KEYWORD(sanitize_thread);
KEYWORD(sanitize_memory);
KEYWORD(uwtable);
KEYWORD(zeroext);

94
lib/AsmParser/LLParser.cpp
View File

@ -907,29 +907,29 @@ bool LLParser::ParseFnAttributeValuePairs(AttrBuilder &B,
B.addStackAlignmentAttr(Alignment);
continue;
}
case lltok::kw_address_safety: B.addAttribute(Attribute::AddressSafety); break;
case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
case lltok::kw_noimplicitfloat: B.addAttribute(Attribute::NoImplicitFloat); break;
case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
case lltok::kw_returns_twice: B.addAttribute(Attribute::ReturnsTwice); break;
case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
case lltok::kw_sspstrong: B.addAttribute(Attribute::StackProtectStrong); break;
case lltok::kw_thread_safety: B.addAttribute(Attribute::ThreadSafety); break;
case lltok::kw_uninitialized_checks: B.addAttribute(Attribute::UninitializedChecks); break;
case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
case lltok::kw_alwaysinline: B.addAttribute(Attribute::AlwaysInline); break;
case lltok::kw_inlinehint: B.addAttribute(Attribute::InlineHint); break;
case lltok::kw_minsize: B.addAttribute(Attribute::MinSize); break;
case lltok::kw_naked: B.addAttribute(Attribute::Naked); break;
case lltok::kw_nobuiltin: B.addAttribute(Attribute::NoBuiltin); break;
case lltok::kw_noduplicate: B.addAttribute(Attribute::NoDuplicate); break;
case lltok::kw_noimplicitfloat: B.addAttribute(Attribute::NoImplicitFloat); break;
case lltok::kw_noinline: B.addAttribute(Attribute::NoInline); break;
case lltok::kw_nonlazybind: B.addAttribute(Attribute::NonLazyBind); break;
case lltok::kw_noredzone: B.addAttribute(Attribute::NoRedZone); break;
case lltok::kw_noreturn: B.addAttribute(Attribute::NoReturn); break;
case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break;
case lltok::kw_optsize: B.addAttribute(Attribute::OptimizeForSize); break;
case lltok::kw_readnone: B.addAttribute(Attribute::ReadNone); break;
case lltok::kw_readonly: B.addAttribute(Attribute::ReadOnly); break;
case lltok::kw_returns_twice: B.addAttribute(Attribute::ReturnsTwice); break;
case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
case lltok::kw_sspstrong: B.addAttribute(Attribute::StackProtectStrong); break;
case lltok::kw_sanitize_address: B.addAttribute(Attribute::SanitizeAddress); break;
case lltok::kw_sanitize_thread: B.addAttribute(Attribute::SanitizeThread); break;
case lltok::kw_sanitize_memory: B.addAttribute(Attribute::SanitizeMemory); break;
case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
// Error handling.
case lltok::kw_inreg:
@ -1159,17 +1159,17 @@ bool LLParser::ParseOptionalParamAttrs(AttrBuilder &B) {
case lltok::kw_sret: B.addAttribute(Attribute::StructRet); break;
case lltok::kw_zeroext: B.addAttribute(Attribute::ZExt); break;
case lltok::kw_noreturn: case lltok::kw_nounwind:
case lltok::kw_uwtable: case lltok::kw_returns_twice:
case lltok::kw_noinline: case lltok::kw_readnone:
case lltok::kw_readonly: case lltok::kw_inlinehint:
case lltok::kw_alwaysinline: case lltok::kw_optsize:
case lltok::kw_ssp: case lltok::kw_sspreq:
case lltok::kw_noredzone: case lltok::kw_noimplicitfloat:
case lltok::kw_naked: case lltok::kw_nonlazybind:
case lltok::kw_address_safety: case lltok::kw_minsize:
case lltok::kw_alignstack: case lltok::kw_thread_safety:
case lltok::kw_nobuiltin: case lltok::kw_uninitialized_checks:
case lltok::kw_alignstack: case lltok::kw_nounwind:
case lltok::kw_alwaysinline: case lltok::kw_optsize:
case lltok::kw_inlinehint: case lltok::kw_readnone:
case lltok::kw_minsize: case lltok::kw_readonly:
case lltok::kw_naked: case lltok::kw_returns_twice:
case lltok::kw_nobuiltin: case lltok::kw_sanitize_address:
case lltok::kw_noimplicitfloat: case lltok::kw_sanitize_memory:
case lltok::kw_noinline: case lltok::kw_sanitize_thread:
case lltok::kw_nonlazybind: case lltok::kw_ssp:
case lltok::kw_noredzone: case lltok::kw_sspreq:
case lltok::kw_noreturn: case lltok::kw_uwtable:
HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
break;
}
@ -1200,19 +1200,19 @@ bool LLParser::ParseOptionalReturnAttrs(AttrBuilder &B) {
HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
break;
case lltok::kw_noreturn: case lltok::kw_nounwind:
case lltok::kw_uwtable: case lltok::kw_returns_twice:
case lltok::kw_noinline: case lltok::kw_readnone:
case lltok::kw_readonly: case lltok::kw_inlinehint:
case lltok::kw_alwaysinline: case lltok::kw_optsize:
case lltok::kw_ssp: case lltok::kw_sspreq:
case lltok::kw_sspstrong: case lltok::kw_noimplicitfloat:
case lltok::kw_noredzone: case lltok::kw_naked:
case lltok::kw_nonlazybind: case lltok::kw_address_safety:
case lltok::kw_minsize: case lltok::kw_alignstack:
case lltok::kw_align: case lltok::kw_noduplicate:
case lltok::kw_thread_safety: case lltok::kw_uninitialized_checks:
case lltok::kw_nobuiltin:
case lltok::kw_align: case lltok::kw_noreturn:
case lltok::kw_alignstack: case lltok::kw_nounwind:
case lltok::kw_alwaysinline: case lltok::kw_optsize:
case lltok::kw_inlinehint: case lltok::kw_readnone:
case lltok::kw_minsize: case lltok::kw_readonly:
case lltok::kw_naked: case lltok::kw_returns_twice:
case lltok::kw_nobuiltin: case lltok::kw_sanitize_address:
case lltok::kw_noduplicate: case lltok::kw_sanitize_memory:
case lltok::kw_noimplicitfloat: case lltok::kw_sanitize_thread:
case lltok::kw_noinline: case lltok::kw_ssp:
case lltok::kw_nonlazybind: case lltok::kw_sspreq:
case lltok::kw_noredzone: case lltok::kw_sspstrong:
case lltok::kw_uwtable:
HaveError |= Error(Lex.getLoc(), "invalid use of function-only attribute");
break;
}

6
lib/AsmParser/LLToken.h
View File

@ -94,7 +94,7 @@ namespace lltok {
// Attributes:
kw_attributes,
kw_alwaysinline,
kw_address_safety,
kw_sanitize_address,
kw_byval,
kw_inlinehint,
kw_inreg,
@ -120,8 +120,8 @@ namespace lltok {
kw_sspreq,
kw_sspstrong,
kw_sret,
kw_thread_safety,
kw_uninitialized_checks,
kw_sanitize_thread,
kw_sanitize_memory,
kw_uwtable,
kw_zeroext,

24
lib/IR/Attributes.cpp
View File

@ -153,8 +153,8 @@ unsigned Attribute::getStackAlignment() const {
std::string Attribute::getAsString(bool InAttrGrp) const {
if (!pImpl) return "";
if (hasAttribute(Attribute::AddressSafety))
return "address_safety";
if (hasAttribute(Attribute::SanitizeAddress))
return "sanitize_address";
if (hasAttribute(Attribute::AlwaysInline))
return "alwaysinline";
if (hasAttribute(Attribute::ByVal))
@ -207,10 +207,10 @@ std::string Attribute::getAsString(bool InAttrGrp) const {
return "sspstrong";
if (hasAttribute(Attribute::StructRet))
return "sret";
if (hasAttribute(Attribute::ThreadSafety))
return "thread_safety";
if (hasAttribute(Attribute::UninitializedChecks))
return "uninitialized_checks";
if (hasAttribute(Attribute::SanitizeThread))
return "sanitize_thread";
if (hasAttribute(Attribute::SanitizeMemory))
return "sanitize_memory";
if (hasAttribute(Attribute::UWTable))
return "uwtable";
if (hasAttribute(Attribute::ZExt))
@ -386,12 +386,12 @@ uint64_t AttributeImpl::getAttrMask(Attribute::AttrKind Val) {
case Attribute::ReturnsTwice: return 1 << 29;
case Attribute::UWTable: return 1 << 30;
case Attribute::NonLazyBind: return 1U << 31;
case Attribute::AddressSafety: return 1ULL << 32;
case Attribute::SanitizeAddress: return 1ULL << 32;
case Attribute::MinSize: return 1ULL << 33;
case Attribute::NoDuplicate: return 1ULL << 34;
case Attribute::StackProtectStrong: return 1ULL << 35;
case Attribute::ThreadSafety: return 1ULL << 36;
case Attribute::UninitializedChecks: return 1ULL << 37;
case Attribute::SanitizeThread: return 1ULL << 36;
case Attribute::SanitizeMemory: return 1ULL << 37;
case Attribute::NoBuiltin: return 1ULL << 38;
}
llvm_unreachable("Unsupported attribute type");
@ -1119,9 +1119,9 @@ void AttrBuilder::removeFunctionOnlyAttrs() {
.removeAttribute(Attribute::UWTable)
.removeAttribute(Attribute::NonLazyBind)
.removeAttribute(Attribute::ReturnsTwice)
.removeAttribute(Attribute::AddressSafety)
.removeAttribute(Attribute::ThreadSafety)
.removeAttribute(Attribute::UninitializedChecks)
.removeAttribute(Attribute::SanitizeAddress)
.removeAttribute(Attribute::SanitizeThread)
.removeAttribute(Attribute::SanitizeMemory)
.removeAttribute(Attribute::MinSize)
.removeAttribute(Attribute::NoDuplicate)
.removeAttribute(Attribute::NoBuiltin);

6
lib/IR/Verifier.cpp
View File

@ -650,9 +650,9 @@ void Verifier::VerifyParameterAttrs(AttributeSet Attrs, uint64_t Idx, Type *Ty,
!Attrs.hasAttribute(Idx, Attribute::UWTable) &&
!Attrs.hasAttribute(Idx, Attribute::NonLazyBind) &&
!Attrs.hasAttribute(Idx, Attribute::ReturnsTwice) &&
!Attrs.hasAttribute(Idx, Attribute::AddressSafety) &&
!Attrs.hasAttribute(Idx, Attribute::ThreadSafety) &&
!Attrs.hasAttribute(Idx, Attribute::UninitializedChecks) &&
!Attrs.hasAttribute(Idx, Attribute::SanitizeAddress) &&
!Attrs.hasAttribute(Idx, Attribute::SanitizeThread) &&
!Attrs.hasAttribute(Idx, Attribute::SanitizeMemory) &&
!Attrs.hasAttribute(Idx, Attribute::MinSize) &&
!Attrs.hasAttribute(Idx, Attribute::NoBuiltin),
"Some attributes in '" + Attrs.getAsString(Idx) +

4
lib/Transforms/Instrumentation/AddressSanitizer.cpp
View File

@ -1098,11 +1098,11 @@ bool AddressSanitizer::runOnFunction(Function &F) {
DEBUG(dbgs() << "ASAN instrumenting:\n" << F << "\n");
initializeCallbacks(*F.getParent());
// If needed, insert __asan_init before checking for AddressSafety attr.
// If needed, insert __asan_init before checking for SanitizeAddress attr.
maybeInsertAsanInitAtFunctionEntry(F);
if (!F.getAttributes().hasAttribute(AttributeSet::FunctionIndex,
Attribute::AddressSafety))
Attribute::SanitizeAddress))
return false;
if (!ClDebugFunc.empty() && ClDebugFunc != F.getName())

12
test/Bitcode/attributes.ll
View File

@ -157,17 +157,17 @@ define void @f26() nonlazybind
ret void;
}
define void @f27() address_safety
define void @f27() sanitize_address
; CHECK: define void @f27() #17
{
ret void;
}
define void @f28() thread_safety
define void @f28() sanitize_thread
; CHECK: define void @f28() #18
{
ret void;
}
define void @f29() uninitialized_checks
define void @f29() sanitize_memory
; CHECK: define void @f29() #19
{
ret void;
@ -196,7 +196,7 @@ define void @f30() "cpu"="cortex-a8"
; CHECK: attributes #14 = { returns_twice }
; CHECK: attributes #15 = { uwtable }
; CHECK: attributes #16 = { nonlazybind }
; CHECK: attributes #17 = { address_safety }
; CHECK: attributes #18 = { thread_safety }
; CHECK: attributes #19 = { uninitialized_checks }
; CHECK: attributes #17 = { sanitize_address }
; CHECK: attributes #18 = { sanitize_thread }
; CHECK: attributes #19 = { sanitize_memory }
; CHECK: attributes #20 = { "cpu"="cortex-a8" }

2
test/CodeGen/X86/crash.ll
View File

@ -431,7 +431,7 @@ return: ; preds = %entry
; uitofp expands to an FCMOV instruction which splits the basic block.
; Make sure the live range of %AL isn't split.
@.str = private unnamed_addr constant { [1 x i8], [63 x i8] } zeroinitializer, align 32
define void @pr13188(i64* nocapture %this) uwtable ssp address_safety align 2 {
define void @pr13188(i64* nocapture %this) uwtable ssp sanitize_address align 2 {
entry:
%x7 = load i64* %this, align 8
%sub = add i64 %x7, -1

4
test/Instrumentation/AddressSanitizer/X86/bug_11395.ll
View File

@ -36,14 +36,14 @@ target triple = "i386-unknown-linux-gnu"
@ff_mlp_firorder_7 = external global i8
@ff_mlp_firorder_8 = external global i8
define void @ff_mlp_init_x86(%struct.DSPContext* nocapture %c, %struct.AVCodecContext* nocapture %avctx) nounwind address_safety {
define void @ff_mlp_init_x86(%struct.DSPContext* nocapture %c, %struct.AVCodecContext* nocapture %avctx) nounwind sanitize_address {
entry:
%mlp_filter_channel = getelementptr inbounds %struct.DSPContext* %c, i32 0, i32 131
store void (i32*, i32*, i32, i32, i32, i32, i32, i32*)* @mlp_filter_channel_x86, void (i32*, i32*, i32, i32, i32, i32, i32, i32*)** %mlp_filter_channel, align 4, !tbaa !0
ret void
}
define internal void @mlp_filter_channel_x86(i32* %state, i32* %coeff, i32 %firorder, i32 %iirorder, i32 %filter_shift, i32 %mask, i32 %blocksize, i32* %sample_buffer) nounwind address_safety {
define internal void @mlp_filter_channel_x86(i32* %state, i32* %coeff, i32 %firorder, i32 %iirorder, i32 %filter_shift, i32 %mask, i32 %blocksize, i32* %sample_buffer) nounwind sanitize_address {
entry:
%filter_shift.addr = alloca i32, align 4
%mask.addr = alloca i32, align 4

6
test/Instrumentation/AddressSanitizer/asan-vs-gvn.ll
View File

@ -11,9 +11,9 @@ target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f3
@f = global %struct_of_7_bytes_4_aligned zeroinitializer, align 4
; Accessing bytes 4 and 6, not ok to widen to i32 if address_safety is set.
; Accessing bytes 4 and 6, not ok to widen to i32 if sanitize_address is set.
define i32 @test_widening_bad(i8* %P) nounwind ssp noredzone address_safety {
define i32 @test_widening_bad(i8* %P) nounwind ssp noredzone sanitize_address {
entry:
%tmp = load i8* getelementptr inbounds (%struct_of_7_bytes_4_aligned* @f, i64 0, i32 1), align 4
%conv = zext i8 %tmp to i32
@ -36,7 +36,7 @@ define void @end_test_widening_bad() {
;; Accessing bytes 4 and 5. Ok to widen to i16.
define i32 @test_widening_ok(i8* %P) nounwind ssp noredzone address_safety {
define i32 @test_widening_ok(i8* %P) nounwind ssp noredzone sanitize_address {
entry:
%tmp = load i8* getelementptr inbounds (%struct_of_7_bytes_4_aligned* @f, i64 0, i32 1), align 4
%conv = zext i8 %tmp to i32

12
test/Instrumentation/AddressSanitizer/basic.ll
View File

@ -5,7 +5,7 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu"
define i32 @test_load(i32* %a) address_safety {
define i32 @test_load(i32* %a) sanitize_address {
; CHECK: @test_load
; CHECK-NOT: load
; CHECK: %[[LOAD_ADDR:[^ ]*]] = ptrtoint i32* %a to i64
@ -38,7 +38,7 @@ entry:
ret i32 %tmp1
}
define void @test_store(i32* %a) address_safety {
define void @test_store(i32* %a) sanitize_address {
; CHECK: @test_store
; CHECK-NOT: store
; CHECK: %[[STORE_ADDR:[^ ]*]] = ptrtoint i32* %a to i64
@ -73,7 +73,7 @@ entry:
; Check that asan leaves just one alloca.
declare void @alloca_test_use([10 x i8]*)
define void @alloca_test() address_safety {
define void @alloca_test() sanitize_address {
entry:
%x = alloca [10 x i8], align 1
%y = alloca [10 x i8], align 1
@ -89,7 +89,7 @@ entry:
; CHECK-NOT: = alloca
; CHECK: ret void
define void @LongDoubleTest(x86_fp80* nocapture %a) nounwind uwtable address_safety {
define void @LongDoubleTest(x86_fp80* nocapture %a) nounwind uwtable sanitize_address {
entry:
store x86_fp80 0xK3FFF8000000000000000, x86_fp80* %a, align 16
ret void
@ -101,7 +101,7 @@ entry:
; CHECK: ret void
define void @i40test(i40* %a, i40* %b) nounwind uwtable address_safety {
define void @i40test(i40* %a, i40* %b) nounwind uwtable sanitize_address {
entry:
%t = load i40* %a
store i40 %t, i40* %b, align 8
@ -115,7 +115,7 @@ define void @i40test(i40* %a, i40* %b) nounwind uwtable address_safety {
; CHECK: __asan_report_store_n{{.*}}, i64 5)
; CHECK: ret void
define void @i80test(i80* %a, i80* %b) nounwind uwtable address_safety {
define void @i80test(i80* %a, i80* %b) nounwind uwtable sanitize_address {
entry:
%t = load i80* %a
store i80 %t, i80* %b, align 8

2
test/Instrumentation/AddressSanitizer/debug_info.ll
View File

@ -6,7 +6,7 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define i32 @_Z3zzzi(i32 %p) nounwind uwtable address_safety {
define i32 @_Z3zzzi(i32 %p) nounwind uwtable sanitize_address {
entry:
%p.addr = alloca i32, align 4
%r = alloca i32, align 4

2
test/Instrumentation/AddressSanitizer/different_scale_and_offset.ll
View File

@ -9,7 +9,7 @@ target triple = "x86_64-unknown-linux-gnu"
; CHECK: @__asan_mapping_offset = linkonce_odr constant i64 0
; CHECK: @__asan_mapping_scale = linkonce_odr constant i64 2
define i32 @test_load(i32* %a) address_safety {
define i32 @test_load(i32* %a) sanitize_address {
; CHECK: @test_load
; CHECK-NOT: load
; CHECK: %[[LOAD_ADDR:[^ ]*]] = ptrtoint i32* %a to i64

2
test/Instrumentation/AddressSanitizer/do-not-instrument-internal-globals.ll
View File

@ -5,7 +5,7 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"
define void @_Z3barv() uwtable address_safety {
define void @_Z3barv() uwtable sanitize_address {
entry:
%a = alloca i32, align 4
call void @_Z3fooPi(i32* %a)

6
test/Instrumentation/AddressSanitizer/instrument-no-return.ll
View File

@ -7,7 +7,7 @@ target triple = "x86_64-unknown-linux-gnu"
declare void @MyNoReturnFunc(i32) noreturn
define i32 @Call1(i8* nocapture %arg) uwtable address_safety {
define i32 @Call1(i8* nocapture %arg) uwtable sanitize_address {
entry:
call void @MyNoReturnFunc(i32 1) noreturn ; The call insn has noreturn attr.
; CHECK: @Call1
@ -17,7 +17,7 @@ entry:
unreachable
}
define i32 @Call2(i8* nocapture %arg) uwtable address_safety {
define i32 @Call2(i8* nocapture %arg) uwtable sanitize_address {
entry:
call void @MyNoReturnFunc(i32 1) ; No noreturn attribure on the call.
; CHECK: @Call2
@ -29,7 +29,7 @@ entry:
declare i32 @__gxx_personality_v0(...)
define i64 @Invoke1(i8** %esc) nounwind uwtable ssp address_safety {
define i64 @Invoke1(i8** %esc) nounwind uwtable ssp sanitize_address {
entry:
invoke void @MyNoReturnFunc(i32 1)
to label %invoke.cont unwind label %lpad

10
test/Instrumentation/AddressSanitizer/instrument_initializer_metadata.ll
View File

@ -23,7 +23,7 @@ entry:
ret void
}
define internal void @_GLOBAL__I_a() address_safety section ".text.startup" {
define internal void @_GLOBAL__I_a() sanitize_address section ".text.startup" {
entry:
call void @__cxx_global_var_init()
ret void
@ -40,7 +40,7 @@ entry:
; CHECK: ret
; Check that xxx is instrumented.
define void @touch_xxx() address_safety {
define void @touch_xxx() sanitize_address {
store i32 0, i32 *@xxx, align 4
ret void
; CHECK: define void @touch_xxx
@ -49,7 +49,7 @@ define void @touch_xxx() address_safety {
}
; Check that XXX is instrumented.
define void @touch_XXX() address_safety {
define void @touch_XXX() sanitize_address {
store i32 0, i32 *@XXX, align 4
ret void
; CHECK: define void @touch_XXX
@ -59,7 +59,7 @@ define void @touch_XXX() address_safety {
; Check that yyy is NOT instrumented (as it does not have dynamic initializer).
define void @touch_yyy() address_safety {
define void @touch_yyy() sanitize_address {
store i32 0, i32 *@yyy, align 4
ret void
; CHECK: define void @touch_yyy
@ -68,7 +68,7 @@ define void @touch_yyy() address_safety {
}
; Check that YYY is NOT instrumented (as it does not have dynamic initializer).
define void @touch_YYY() address_safety {
define void @touch_YYY() sanitize_address {
store i32 0, i32 *@YYY, align 4
ret void
; CHECK: define void @touch_YYY

2
test/Instrumentation/AddressSanitizer/instrument_load_then_store.ll
View File

@ -4,7 +4,7 @@
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu"
define void @IncrementMe(i32* %a) address_safety {
define void @IncrementMe(i32* %a) sanitize_address {
entry:
%tmp1 = load i32* %a, align 4
%tmp2 = add i32 %tmp1, 1

6
test/Instrumentation/AddressSanitizer/lifetime.ll
View File

@ -7,7 +7,7 @@ target triple = "x86_64-unknown-linux-gnu"
declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind
declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
define void @lifetime_no_size() address_safety {
define void @lifetime_no_size() sanitize_address {
entry:
%i = alloca i32, align 4
%i.ptr = bitcast i32* %i to i8*
@ -23,7 +23,7 @@ entry:
}
; Generic case of lifetime analysis.
define void @lifetime() address_safety {
define void @lifetime() sanitize_address {
; CHECK: @lifetime
; Regular variable lifetime intrinsics.
@ -61,7 +61,7 @@ define void @lifetime() address_safety {
}
; Check that arguments of lifetime may come from phi nodes.
define void @phi_args(i1 %x) address_safety {
define void @phi_args(i1 %x) sanitize_address {
; CHECK: @phi_args
entry:

6
test/Instrumentation/AddressSanitizer/test64.ll
View File

@ -1,7 +1,7 @@
; RUN: opt < %s -asan -S | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu"
define i32 @read_4_bytes(i32* %a) address_safety {
define i32 @read_4_bytes(i32* %a) sanitize_address {
entry:
%tmp1 = load i32* %a, align 4
ret i32 %tmp1
@ -13,7 +13,7 @@ entry:
; CHECK-NEXT: {{17592186044416|2147450880}}
; CHECK: ret
define void @example_atomicrmw(i64* %ptr) nounwind uwtable address_safety {
define void @example_atomicrmw(i64* %ptr) nounwind uwtable sanitize_address {
entry:
%0 = atomicrmw add i64* %ptr, i64 1 seq_cst
ret void
@ -24,7 +24,7 @@ entry:
; CHECK: atomicrmw
; CHECK: ret
define void @example_cmpxchg(i64* %ptr, i64 %compare_to, i64 %new_value) nounwind uwtable address_safety {
define void @example_cmpxchg(i64* %ptr, i64 %compare_to, i64 %new_value) nounwind uwtable sanitize_address {
entry:
%0 = cmpxchg i64* %ptr, i64 %compare_to, i64 %new_value seq_cst
ret void

4
test/Instrumentation/ThreadSanitizer/tsan-vs-gvn.ll
View File

@ -8,9 +8,9 @@ target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f3
@f = global %struct_of_8_bytes_4_aligned zeroinitializer, align 4
; Accessing bytes 4 and 6, not ok to widen to i32 if thread_safety is set.
; Accessing bytes 4 and 6, not ok to widen to i32 if sanitize_thread is set.
define i32 @test_widening_bad(i8* %P) nounwind ssp noredzone thread_safety {
define i32 @test_widening_bad(i8* %P) nounwind ssp noredzone sanitize_thread {
entry:
%tmp = load i8* getelementptr inbounds (%struct_of_8_bytes_4_aligned* @f, i64 0, i32 1), align 4
%conv = zext i8 %tmp to i32

6
utils/llvm.grm
View File

@ -174,9 +174,9 @@ FuncAttr ::= noreturn
| sspreq
| returns_twice
| nonlazybind
| address_safety
| thread_safety
| uninitialized_checks
| sanitize_address
| sanitize_thread
| sanitize_memory
;
OptFuncAttrs ::= + _ | OptFuncAttrs FuncAttr ;

4
utils/vim/llvm.vim
View File

@ -35,7 +35,7 @@ syn keyword llvmStatement uitofp ule ult umax umin une uno unreachable unwind
syn keyword llvmStatement urem va_arg xchg xor zext
" Keywords.
syn keyword llvmKeyword acq_rel acquire address_safety addrspace alias align
syn keyword llvmKeyword acq_rel acquire sanitize_address addrspace alias align
syn keyword llvmKeyword alignstack alwaysinline appending arm_aapcs_vfpcc
syn keyword llvmKeyword arm_aapcscc arm_apcscc asm atomic available_externally
syn keyword llvmKeyword blockaddress byval c catch cc ccc cleanup coldcc common
@ -55,7 +55,7 @@ syn keyword llvmKeyword singlethread spir_func spir_kernel sret ssp sspreq
syn keyword llvmKeyword sspstrong tail target thread_local to triple
syn keyword llvmKeyword unnamed_addr unordered uwtable volatile weak weak_odr
syn keyword llvmKeyword x86_fastcallcc x86_stdcallcc x86_thiscallcc zeroext
syn keyword llvmKeyword thread_safety uninitialized_checks
syn keyword llvmKeyword sanitize_thread sanitize_memory
" Obsolete keywords.
syn keyword llvmError getresult begin end