This is an archive of the discontinued LLVM Phabricator instance.

Differential D40932

Hardware-assisted AddressSanitizer (llvm part).
ClosedPublic

Authored by eugenis on Dec 6 2017, 4:57 PM.

Details

Reviewers
kcc
pcc
alekseyshl
Commits
rGc667c1f47a8e: Hardware-assisted AddressSanitizer (llvm part).
rL320217: Hardware-assisted AddressSanitizer (llvm part).
Summary

This is LLVM instrumentation for the new HWASan tool. It is basically
a stripped down copy of ASan at this point, w/o stack or global
support. Instrumenation adds a global constructor + runtime callbacks
for every load and store.

HWASan comes with its own IR attribute.

A brief design document can be found in
clang/docs/HardwareAssistedAddressSanitizerDesign.rst (submitted earlier).

Diff Detail

Repository
rL LLVM

Event Timeline

eugenis created this revision.Dec 6 2017, 4:57 PM
Herald added subscribers: hiraditya, eraman, javed.absar and 3 others. · View Herald TranscriptDec 6 2017, 4:57 PM
Harbormaster completed remote builds in B12843: Diff 125849.Dec 6 2017, 4:57 PM
kcc edited edge metadata.Dec 6 2017, 5:06 PM

Please document the new attribute and explain why the old attribute doesn't work for us (there are cases when we need one, but not the other, in both directions)

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
15 ↗(On Diff #125849)

Do you really need all these includes?

102 ↗(On Diff #125849)

update comment

eugenis updated this revision to Diff 125866.Dec 6 2017, 5:54 PM
eugenis marked an inline comment as done.

Documented the new attribute.

Harbormaster completed remote builds in B12850: Diff 125866.Dec 6 2017, 5:54 PM
eugenis added inline comments.Dec 6 2017, 5:54 PM
llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
15 ↗(On Diff #125849)

I'm not sure how to find the ones that are unused.

kcc added inline comments.Dec 6 2017, 6:11 PM
llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
15 ↗(On Diff #125849)

I don't think we have a tool for that.
I've done it like this:

given e.g. #include "llvm/IR/MDBuilder.h" search for MDBuilder in the code. 
If none found, remove the include and rebuild. If build passes, you don't need the header.

There is clearly a risk that some other file actually includes MDBuilder and this code will break
with further refactoring of header files. But that's tolerable IMHO.

226 ↗(On Diff #125866)

do you need this section of code at all?
If not, I'd suggest to remove it and reinstate if needed, with a test.

256 ↗(On Diff #125866)

Do you need this? Do you have a test?
I'd prefer if we don't add code from asan/msan that we might not need in hwasan

336 ↗(On Diff #125866)

no {}

eugenis updated this revision to Diff 125867.Dec 6 2017, 6:27 PM
eugenis marked 2 inline comments as done.

removed some extra code and includes

Harbormaster completed remote builds in B12851: Diff 125867.Dec 6 2017, 6:27 PM
eugenis marked an inline comment as done.Dec 6 2017, 6:27 PM
eugenis added inline comments.
llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
256 ↗(On Diff #125866)

added a test

kcc added a comment.Dec 7 2017, 11:21 AM

LGTM, please wait for (at least) Aleksey's review.

alekseyshl accepted this revision.Dec 7 2017, 4:22 PM
This revision is now accepted and ready to land.Dec 7 2017, 4:22 PM
Closed by commit rL320217: Hardware-assisted AddressSanitizer (llvm part). (authored by eugenis). · Explain WhyDec 8 2017, 4:22 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
trunk/
docs/
1 line
4 lines
include/
llvm/
Bitcode/
1 line
IR/
4 lines
1 line
Transforms/
2 lines
lib/
Analysis/
6 lines
3 lines
AsmParser/
1 line
4 lines
1 line
Bitcode/
Reader/
3 lines
Writer/
2 lines
CodeGen/
21 lines
IR/
2 lines
1 line
Transforms/
IPO/
1 line
InstCombine/
3 lines
Instrumentation/
1 line
282 lines
1 line
Scalar/
5 lines
test/
Bitcode/
11 lines
Instrumentation/
HWAddressSanitizer/
26 lines
190 lines
Transforms/
GVN/
27 lines
Inline/
30 lines
InstCombine/
14 lines
NewGVN/
26 lines
SimplifyCFG/
19 lines

Diff 126231

llvm/trunk/docs/BitCodeFormat.rst

Show First 20 Lines • Show All 1,048 Lines • ▼ Show 20 Lines
* code 47: ``swifterror`` * code 47: ``swifterror``
* code 48: ``norecurse`` * code 48: ``norecurse``
* code 49: ``inaccessiblememonly`` * code 49: ``inaccessiblememonly``
* code 50: ``inaccessiblememonly_or_argmemonly`` * code 50: ``inaccessiblememonly_or_argmemonly``
* code 51: ``allocsize(<EltSizeParam>[, <NumEltsParam>])`` * code 51: ``allocsize(<EltSizeParam>[, <NumEltsParam>])``
* code 52: ``writeonly`` * code 52: ``writeonly``
* code 53: ``speculatable`` * code 53: ``speculatable``
* code 54: ``strictfp`` * code 54: ``strictfp``
* code 55: ``sanitize_hwaddress``
.. note:: .. note::
The ``allocsize`` attribute has a special encoding for its arguments. Its two The ``allocsize`` attribute has a special encoding for its arguments. Its two
arguments, which are 32-bit integers, are packed into one 64-bit integer value arguments, which are 32-bit integers, are packed into one 64-bit integer value
(i.e. ``(EltSizeParam << 32) | NumEltsParam``), with ``NumEltsParam`` taking on (i.e. ``(EltSizeParam << 32) | NumEltsParam``), with ``NumEltsParam`` taking on
the sentinel value -1 if it is not specified. the sentinel value -1 if it is not specified.
.. _TYPE_BLOCK: .. _TYPE_BLOCK:
▲ Show 20 Lines • Show All 287 Lines • Show Last 20 Lines

llvm/trunk/docs/LangRef.rst

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,591 Lines • ▼ Show 20 Lines``sanitize_address``
This attribute indicates that AddressSanitizer checks This attribute indicates that AddressSanitizer checks
(dynamic address safety analysis) are enabled for this function. (dynamic address safety analysis) are enabled for this function.
``sanitize_memory`` ``sanitize_memory``
This attribute indicates that MemorySanitizer checks (dynamic detection This attribute indicates that MemorySanitizer checks (dynamic detection
of accesses to uninitialized memory) are enabled for this function. of accesses to uninitialized memory) are enabled for this function.
``sanitize_thread`` ``sanitize_thread``
This attribute indicates that ThreadSanitizer checks This attribute indicates that ThreadSanitizer checks
(dynamic thread safety analysis) are enabled for this function. (dynamic thread safety analysis) are enabled for this function.
``sanitize_hwaddress``
This attribute indicates that HWAddressSanitizer checks
(dynamic address safety analysis based on tagged pointers) are enabled for
this function.
``speculatable`` ``speculatable``
This function attribute indicates that the function does not have any This function attribute indicates that the function does not have any
effects besides calculating its result and does not have undefined behavior. effects besides calculating its result and does not have undefined behavior.
Note that ``speculatable`` is not enough to conclude that along any Note that ``speculatable`` is not enough to conclude that along any
particular execution path the number of calls to this function will not be particular execution path the number of calls to this function will not be
externally observable. This attribute is only valid on functions externally observable. This attribute is only valid on functions
and declarations, not on individual call sites. If a function is and declarations, not on individual call sites. If a function is
incorrectly marked as speculatable and really does exhibit incorrectly marked as speculatable and really does exhibit
▲ Show 20 Lines • Show All 12,933 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/Bitcode/LLVMBitCodes.h

Show First 20 Lines • Show All 554 Lines • ▼ Show 20 Linesenum AttributeKindCodes {
ATTR_KIND_SWIFT_ERROR = 47, ATTR_KIND_SWIFT_ERROR = 47,
ATTR_KIND_NO_RECURSE = 48, ATTR_KIND_NO_RECURSE = 48,
ATTR_KIND_INACCESSIBLEMEM_ONLY = 49, ATTR_KIND_INACCESSIBLEMEM_ONLY = 49,
ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY = 50, ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY = 50,
ATTR_KIND_ALLOC_SIZE = 51, ATTR_KIND_ALLOC_SIZE = 51,
ATTR_KIND_WRITEONLY = 52, ATTR_KIND_WRITEONLY = 52,
ATTR_KIND_SPECULATABLE = 53, ATTR_KIND_SPECULATABLE = 53,
ATTR_KIND_STRICT_FP = 54, ATTR_KIND_STRICT_FP = 54,
ATTR_KIND_SANITIZE_HWADDRESS = 55,
}; };
enum ComdatSelectionKindCodes { enum ComdatSelectionKindCodes {
COMDAT_SELECTION_KIND_ANY = 1, COMDAT_SELECTION_KIND_ANY = 1,
COMDAT_SELECTION_KIND_EXACT_MATCH = 2, COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
COMDAT_SELECTION_KIND_LARGEST = 3, COMDAT_SELECTION_KIND_LARGEST = 3,
COMDAT_SELECTION_KIND_NO_DUPLICATES = 4, COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
COMDAT_SELECTION_KIND_SAME_SIZE = 5, COMDAT_SELECTION_KIND_SAME_SIZE = 5,
Show All 14 Lines

llvm/trunk/include/llvm/IR/Attributes.td

Show First 20 Lines • Show All 158 Lines • ▼ Show 20 Lines
def SanitizeAddress : EnumAttr<"sanitize_address">; def SanitizeAddress : EnumAttr<"sanitize_address">;
/// ThreadSanitizer is on. /// ThreadSanitizer is on.
def SanitizeThread : EnumAttr<"sanitize_thread">; def SanitizeThread : EnumAttr<"sanitize_thread">;
/// MemorySanitizer is on. /// MemorySanitizer is on.
def SanitizeMemory : EnumAttr<"sanitize_memory">; def SanitizeMemory : EnumAttr<"sanitize_memory">;
/// HWAddressSanitizer is on.
def SanitizeHWAddress : EnumAttr<"sanitize_hwaddress">;
/// Argument is swift error. /// Argument is swift error.
def SwiftError : EnumAttr<"swifterror">; def SwiftError : EnumAttr<"swifterror">;
/// Argument is swift self/context. /// Argument is swift self/context.
def SwiftSelf : EnumAttr<"swiftself">; def SwiftSelf : EnumAttr<"swiftself">;
/// Function must be in a unwind table. /// Function must be in a unwind table.
def UWTable : EnumAttr<"uwtable">; def UWTable : EnumAttr<"uwtable">;
Show All 20 Linesclass CompatRule<string F> {
// the reference to the callee. It must return false if the attributes of the // the reference to the callee. It must return false if the attributes of the
// caller and callee are incompatible, and true otherwise. // caller and callee are incompatible, and true otherwise.
string CompatFunc = F; string CompatFunc = F;
} }
def : CompatRule<"isEqual<SanitizeAddressAttr>">; def : CompatRule<"isEqual<SanitizeAddressAttr>">;
def : CompatRule<"isEqual<SanitizeThreadAttr>">; def : CompatRule<"isEqual<SanitizeThreadAttr>">;
def : CompatRule<"isEqual<SanitizeMemoryAttr>">; def : CompatRule<"isEqual<SanitizeMemoryAttr>">;
def : CompatRule<"isEqual<SanitizeHWAddressAttr>">;
def : CompatRule<"isEqual<SafeStackAttr>">; def : CompatRule<"isEqual<SafeStackAttr>">;
class MergeRule<string F> { class MergeRule<string F> {
// The name of the function called to merge the attributes of the caller and // The name of the function called to merge the attributes of the caller and
// callee. The function's signature must match // callee. The function's signature must match
// "void(Function&, const Function &)", where the first parameter is the // "void(Function&, const Function &)", where the first parameter is the
// reference to the caller and the second parameter is the reference to the // reference to the caller and the second parameter is the reference to the
// callee. // callee.
Show All 13 Lines

llvm/trunk/include/llvm/InitializePasses.h

Show First 20 Lines • Show All 354 Lines • ▼ Show 20 Lines
void initializeStripDeadDebugInfoPass(PassRegistry&); void initializeStripDeadDebugInfoPass(PassRegistry&);
void initializeStripDeadPrototypesLegacyPassPass(PassRegistry&); void initializeStripDeadPrototypesLegacyPassPass(PassRegistry&);
void initializeStripDebugDeclarePass(PassRegistry&); void initializeStripDebugDeclarePass(PassRegistry&);
void initializeStripGCRelocatesPass(PassRegistry&); void initializeStripGCRelocatesPass(PassRegistry&);
void initializeStripNonDebugSymbolsPass(PassRegistry&); void initializeStripNonDebugSymbolsPass(PassRegistry&);
void initializeStripNonLineTableDebugInfoPass(PassRegistry&); void initializeStripNonLineTableDebugInfoPass(PassRegistry&);
void initializeStripSymbolsPass(PassRegistry&); void initializeStripSymbolsPass(PassRegistry&);
void initializeStructurizeCFGPass(PassRegistry&); void initializeStructurizeCFGPass(PassRegistry&);
void initializeHWAddressSanitizerPass(PassRegistry&);
void initializeTailCallElimPass(PassRegistry&); void initializeTailCallElimPass(PassRegistry&);
void initializeTailDuplicatePassPass(PassRegistry&); void initializeTailDuplicatePassPass(PassRegistry&);
void initializeTargetLibraryInfoWrapperPassPass(PassRegistry&); void initializeTargetLibraryInfoWrapperPassPass(PassRegistry&);
void initializeTargetPassConfigPass(PassRegistry&); void initializeTargetPassConfigPass(PassRegistry&);
void initializeTargetTransformInfoWrapperPassPass(PassRegistry&); void initializeTargetTransformInfoWrapperPassPass(PassRegistry&);
void initializeThreadSanitizerPass(PassRegistry&); void initializeThreadSanitizerPass(PassRegistry&);
void initializeTwoAddressInstructionPassPass(PassRegistry&); void initializeTwoAddressInstructionPassPass(PassRegistry&);
void initializeTypeBasedAAWrapperPassPass(PassRegistry&); void initializeTypeBasedAAWrapperPassPass(PassRegistry&);
Show All 17 Lines

llvm/trunk/include/llvm/Transforms/Instrumentation.h

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false, ModulePass *createAddressSanitizerModulePass(bool CompileKernel = false,
bool Recover = false, bool Recover = false,
bool UseGlobalsGC = true); bool UseGlobalsGC = true);
// Insert MemorySanitizer instrumentation (detection of uninitialized reads) // Insert MemorySanitizer instrumentation (detection of uninitialized reads)
FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0, FunctionPass *createMemorySanitizerPass(int TrackOrigins = 0,
bool Recover = false); bool Recover = false);
FunctionPass *createHWAddressSanitizerPass();
// Insert ThreadSanitizer (race detection) instrumentation // Insert ThreadSanitizer (race detection) instrumentation
FunctionPass *createThreadSanitizerPass(); FunctionPass *createThreadSanitizerPass();
// Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation // Insert DataFlowSanitizer (dynamic data flow analysis) instrumentation
ModulePass *createDataFlowSanitizerPass( ModulePass *createDataFlowSanitizerPass(
const std::vector<std::string> &ABIListFiles = std::vector<std::string>(), const std::vector<std::string> &ABIListFiles = std::vector<std::string>(),
void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr); void *(*getArgTLS)() = nullptr, void *(*getRetValTLS)() = nullptr);
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp

Show First 20 Lines • Show All 300 Lines • ▼ Show 20 Linesunsigned MemoryDependenceResults::getLoadLoadClobberFullWidthSize(
while (true) { while (true) {
// If this load size is bigger than our known alignment or would not fit // If this load size is bigger than our known alignment or would not fit
// into a native integer register, then we fail. // into a native integer register, then we fail.
if (NewLoadByteSize > LoadAlign || if (NewLoadByteSize > LoadAlign ||
!DL.fitsInLegalInteger(NewLoadByteSize * 8)) !DL.fitsInLegalInteger(NewLoadByteSize * 8))
return 0; return 0;
if (LIOffs + NewLoadByteSize > MemLocEnd && if (LIOffs + NewLoadByteSize > MemLocEnd &&
(LI->getParent()->getParent()->hasFnAttribute(
Attribute::SanitizeAddress) ||
LI->getParent()->getParent()->hasFnAttribute( LI->getParent()->getParent()->hasFnAttribute(
Attribute::SanitizeAddress)) Attribute::SanitizeHWAddress)))
// We will be reading past the location accessed by the original program. // We will be reading past the location accessed by the original program.
// While this is safe in a regular build, Address Safety analysis tools // While this is safe in a regular build, Address Safety analysis tools
// may start reporting false warnings. So, don't do widening. // may start reporting false warnings. So, don't do widening.
return 0; return 0;
// If a load of this width would include all of MemLoc, then we succeed. // If a load of this width would include all of MemLoc, then we succeed.
if (LIOffs + NewLoadByteSize >= MemLocEnd) if (LIOffs + NewLoadByteSize >= MemLocEnd)
return NewLoadByteSize; return NewLoadByteSize;
▲ Show 20 Lines • Show All 1,460 Lines • Show Last 20 Lines

llvm/trunk/lib/Analysis/ValueTracking.cpp

Show First 20 Lines • Show All 3,505 Lines • ▼ Show 20 Lines case Instruction::SRem: {
return false; return false;
} }
case Instruction::Load: { case Instruction::Load: {
const LoadInst *LI = cast<LoadInst>(Inst); const LoadInst *LI = cast<LoadInst>(Inst);
if (!LI->isUnordered() || if (!LI->isUnordered() ||
// Speculative load may create a race that did not exist in the source. // Speculative load may create a race that did not exist in the source.
LI->getFunction()->hasFnAttribute(Attribute::SanitizeThread) || LI->getFunction()->hasFnAttribute(Attribute::SanitizeThread) ||
// Speculative load may load data from dirty regions. // Speculative load may load data from dirty regions.
LI->getFunction()->hasFnAttribute(Attribute::SanitizeAddress)) LI->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
LI->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
return false; return false;
const DataLayout &DL = LI->getModule()->getDataLayout(); const DataLayout &DL = LI->getModule()->getDataLayout();
return isDereferenceableAndAlignedPointer(LI->getPointerOperand(), return isDereferenceableAndAlignedPointer(LI->getPointerOperand(),
LI->getAlignment(), DL, CtxI, DT); LI->getAlignment(), DL, CtxI, DT);
} }
case Instruction::Call: { case Instruction::Call: {
auto *CI = cast<const CallInst>(Inst); auto *CI = cast<const CallInst>(Inst);
const Function *Callee = CI->getCalledFunction(); const Function *Callee = CI->getCalledFunction();
▲ Show 20 Lines • Show All 1,187 Lines • Show Last 20 Lines

llvm/trunk/lib/AsmParser/LLLexer.cpp

Show First 20 Lines • Show All 658 Lines • ▼ Show 20 Lines#define KEYWORD(STR) \
KEYWORD(speculatable); KEYWORD(speculatable);
KEYWORD(sret); KEYWORD(sret);
KEYWORD(ssp); KEYWORD(ssp);
KEYWORD(sspreq); KEYWORD(sspreq);
KEYWORD(sspstrong); KEYWORD(sspstrong);
KEYWORD(strictfp); KEYWORD(strictfp);
KEYWORD(safestack); KEYWORD(safestack);
KEYWORD(sanitize_address); KEYWORD(sanitize_address);
KEYWORD(sanitize_hwaddress);
KEYWORD(sanitize_thread); KEYWORD(sanitize_thread);
KEYWORD(sanitize_memory); KEYWORD(sanitize_memory);
KEYWORD(swifterror); KEYWORD(swifterror);
KEYWORD(swiftself); KEYWORD(swiftself);
KEYWORD(uwtable); KEYWORD(uwtable);
KEYWORD(writeonly); KEYWORD(writeonly);
KEYWORD(zeroext); KEYWORD(zeroext);
▲ Show 20 Lines • Show All 353 Lines • Show Last 20 Lines

llvm/trunk/lib/AsmParser/LLParser.cpp

Show First 20 Lines • Show All 1,138 Lines • ▼ Show 20 Lines while (true) {
case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break; case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break;
case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break; case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break;
case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break; case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break;
case lltok::kw_sspstrong: case lltok::kw_sspstrong:
B.addAttribute(Attribute::StackProtectStrong); break; B.addAttribute(Attribute::StackProtectStrong); break;
case lltok::kw_safestack: B.addAttribute(Attribute::SafeStack); break; case lltok::kw_safestack: B.addAttribute(Attribute::SafeStack); break;
case lltok::kw_sanitize_address: case lltok::kw_sanitize_address:
B.addAttribute(Attribute::SanitizeAddress); break; B.addAttribute(Attribute::SanitizeAddress); break;
case lltok::kw_sanitize_hwaddress:
B.addAttribute(Attribute::SanitizeHWAddress); break;
case lltok::kw_sanitize_thread: case lltok::kw_sanitize_thread:
B.addAttribute(Attribute::SanitizeThread); break; B.addAttribute(Attribute::SanitizeThread); break;
case lltok::kw_sanitize_memory: case lltok::kw_sanitize_memory:
B.addAttribute(Attribute::SanitizeMemory); break; B.addAttribute(Attribute::SanitizeMemory); break;
case lltok::kw_strictfp: B.addAttribute(Attribute::StrictFP); break; case lltok::kw_strictfp: B.addAttribute(Attribute::StrictFP); break;
case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break; case lltok::kw_uwtable: B.addAttribute(Attribute::UWTable); break;
case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break; case lltok::kw_writeonly: B.addAttribute(Attribute::WriteOnly); break;
▲ Show 20 Lines • Show All 308 Lines • ▼ Show 20 Lines while (true) {
case lltok::kw_nonlazybind: case lltok::kw_nonlazybind:
case lltok::kw_noredzone: case lltok::kw_noredzone:
case lltok::kw_noreturn: case lltok::kw_noreturn:
case lltok::kw_nounwind: case lltok::kw_nounwind:
case lltok::kw_optnone: case lltok::kw_optnone:
case lltok::kw_optsize: case lltok::kw_optsize:
case lltok::kw_returns_twice: case lltok::kw_returns_twice:
case lltok::kw_sanitize_address: case lltok::kw_sanitize_address:
case lltok::kw_sanitize_hwaddress:
case lltok::kw_sanitize_memory: case lltok::kw_sanitize_memory:
case lltok::kw_sanitize_thread: case lltok::kw_sanitize_thread:
case lltok::kw_ssp: case lltok::kw_ssp:
case lltok::kw_sspreq: case lltok::kw_sspreq:
case lltok::kw_sspstrong: case lltok::kw_sspstrong:
case lltok::kw_safestack: case lltok::kw_safestack:
case lltok::kw_strictfp: case lltok::kw_strictfp:
case lltok::kw_uwtable: case lltok::kw_uwtable:
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines while (true) {
case lltok::kw_nonlazybind: case lltok::kw_nonlazybind:
case lltok::kw_noredzone: case lltok::kw_noredzone:
case lltok::kw_noreturn: case lltok::kw_noreturn:
case lltok::kw_nounwind: case lltok::kw_nounwind:
case lltok::kw_optnone: case lltok::kw_optnone:
case lltok::kw_optsize: case lltok::kw_optsize:
case lltok::kw_returns_twice: case lltok::kw_returns_twice:
case lltok::kw_sanitize_address: case lltok::kw_sanitize_address:
case lltok::kw_sanitize_hwaddress:
case lltok::kw_sanitize_memory: case lltok::kw_sanitize_memory:
case lltok::kw_sanitize_thread: case lltok::kw_sanitize_thread:
case lltok::kw_ssp: case lltok::kw_ssp:
case lltok::kw_sspreq: case lltok::kw_sspreq:
case lltok::kw_sspstrong: case lltok::kw_sspstrong:
case lltok::kw_safestack: case lltok::kw_safestack:
case lltok::kw_strictfp: case lltok::kw_strictfp:
case lltok::kw_uwtable: case lltok::kw_uwtable:
▲ Show 20 Lines • Show All 5,108 Lines • Show Last 20 Lines

llvm/trunk/lib/AsmParser/LLToken.h

Show First 20 Lines • Show All 166 Lines • ▼ Show 20 Linesenum Kind {
kw_amdgpu_kernel, kw_amdgpu_kernel,
// Attributes: // Attributes:
kw_attributes, kw_attributes,
kw_allocsize, kw_allocsize,
kw_alwaysinline, kw_alwaysinline,
kw_argmemonly, kw_argmemonly,
kw_sanitize_address, kw_sanitize_address,
kw_sanitize_hwaddress,
kw_builtin, kw_builtin,
kw_byval, kw_byval,
kw_inalloca, kw_inalloca,
kw_cold, kw_cold,
kw_convergent, kw_convergent,
kw_dereferenceable, kw_dereferenceable,
kw_dereferenceable_or_null, kw_dereferenceable_or_null,
kw_inaccessiblememonly, kw_inaccessiblememonly,
▲ Show 20 Lines • Show All 196 Lines • Show Last 20 Lines

llvm/trunk/lib/Bitcode/Reader/BitcodeReader.cpp

Show First 20 Lines • Show All 1,150 Lines • ▼ Show 20 Linesstatic uint64_t getRawAttributeMask(Attribute::AttrKind Val) {
case Attribute::NoRecurse: return 1ULL << 48; case Attribute::NoRecurse: return 1ULL << 48;
case Attribute::InaccessibleMemOnly: return 1ULL << 49; case Attribute::InaccessibleMemOnly: return 1ULL << 49;
case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50; case Attribute::InaccessibleMemOrArgMemOnly: return 1ULL << 50;
case Attribute::SwiftSelf: return 1ULL << 51; case Attribute::SwiftSelf: return 1ULL << 51;
case Attribute::SwiftError: return 1ULL << 52; case Attribute::SwiftError: return 1ULL << 52;
case Attribute::WriteOnly: return 1ULL << 53; case Attribute::WriteOnly: return 1ULL << 53;
case Attribute::Speculatable: return 1ULL << 54; case Attribute::Speculatable: return 1ULL << 54;
case Attribute::StrictFP: return 1ULL << 55; case Attribute::StrictFP: return 1ULL << 55;
case Attribute::SanitizeHWAddress: return 1ULL << 56;
case Attribute::Dereferenceable: case Attribute::Dereferenceable:
llvm_unreachable("dereferenceable attribute not supported in raw format"); llvm_unreachable("dereferenceable attribute not supported in raw format");
break; break;
case Attribute::DereferenceableOrNull: case Attribute::DereferenceableOrNull:
llvm_unreachable("dereferenceable_or_null attribute not supported in raw " llvm_unreachable("dereferenceable_or_null attribute not supported in raw "
"format"); "format");
break; break;
case Attribute::ArgMemOnly: case Attribute::ArgMemOnly:
▲ Show 20 Lines • Show All 196 Lines • ▼ Show 20 Linesstatic Attribute::AttrKind getAttrFromCode(uint64_t Code) {
case bitc::ATTR_KIND_SAFESTACK: case bitc::ATTR_KIND_SAFESTACK:
return Attribute::SafeStack; return Attribute::SafeStack;
case bitc::ATTR_KIND_STRICT_FP: case bitc::ATTR_KIND_STRICT_FP:
return Attribute::StrictFP; return Attribute::StrictFP;
case bitc::ATTR_KIND_STRUCT_RET: case bitc::ATTR_KIND_STRUCT_RET:
return Attribute::StructRet; return Attribute::StructRet;
case bitc::ATTR_KIND_SANITIZE_ADDRESS: case bitc::ATTR_KIND_SANITIZE_ADDRESS:
return Attribute::SanitizeAddress; return Attribute::SanitizeAddress;
case bitc::ATTR_KIND_SANITIZE_HWADDRESS:
return Attribute::SanitizeHWAddress;
case bitc::ATTR_KIND_SANITIZE_THREAD: case bitc::ATTR_KIND_SANITIZE_THREAD:
return Attribute::SanitizeThread; return Attribute::SanitizeThread;
case bitc::ATTR_KIND_SANITIZE_MEMORY: case bitc::ATTR_KIND_SANITIZE_MEMORY:
return Attribute::SanitizeMemory; return Attribute::SanitizeMemory;
case bitc::ATTR_KIND_SWIFT_ERROR: case bitc::ATTR_KIND_SWIFT_ERROR:
return Attribute::SwiftError; return Attribute::SwiftError;
case bitc::ATTR_KIND_SWIFT_SELF: case bitc::ATTR_KIND_SWIFT_SELF:
return Attribute::SwiftSelf; return Attribute::SwiftSelf;
▲ Show 20 Lines • Show All 4,452 Lines • Show Last 20 Lines

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

Show First 20 Lines • Show All 657 Lines • ▼ Show 20 Linesstatic uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
case Attribute::SafeStack: case Attribute::SafeStack:
return bitc::ATTR_KIND_SAFESTACK; return bitc::ATTR_KIND_SAFESTACK;
case Attribute::StrictFP: case Attribute::StrictFP:
return bitc::ATTR_KIND_STRICT_FP; return bitc::ATTR_KIND_STRICT_FP;
case Attribute::StructRet: case Attribute::StructRet:
return bitc::ATTR_KIND_STRUCT_RET; return bitc::ATTR_KIND_STRUCT_RET;
case Attribute::SanitizeAddress: case Attribute::SanitizeAddress:
return bitc::ATTR_KIND_SANITIZE_ADDRESS; return bitc::ATTR_KIND_SANITIZE_ADDRESS;
case Attribute::SanitizeHWAddress:
return bitc::ATTR_KIND_SANITIZE_HWADDRESS;
case Attribute::SanitizeThread: case Attribute::SanitizeThread:
return bitc::ATTR_KIND_SANITIZE_THREAD; return bitc::ATTR_KIND_SANITIZE_THREAD;
case Attribute::SanitizeMemory: case Attribute::SanitizeMemory:
return bitc::ATTR_KIND_SANITIZE_MEMORY; return bitc::ATTR_KIND_SANITIZE_MEMORY;
case Attribute::SwiftError: case Attribute::SwiftError:
return bitc::ATTR_KIND_SWIFT_ERROR; return bitc::ATTR_KIND_SWIFT_ERROR;
case Attribute::SwiftSelf: case Attribute::SwiftSelf:
return bitc::ATTR_KIND_SWIFT_SELF; return bitc::ATTR_KIND_SWIFT_SELF;
▲ Show 20 Lines • Show All 3,573 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/ShrinkWrap.cpp

Show First 20 Lines • Show All 552 Lines • ▼ Show 20 Lines
} }
bool ShrinkWrap::isShrinkWrapEnabled(const MachineFunction &MF) { bool ShrinkWrap::isShrinkWrapEnabled(const MachineFunction &MF) {
const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering(); const TargetFrameLowering *TFI = MF.getSubtarget().getFrameLowering();
switch (EnableShrinkWrapOpt) { switch (EnableShrinkWrapOpt) {
case cl::BOU_UNSET: case cl::BOU_UNSET:
return TFI->enableShrinkWrapping(MF) && return TFI->enableShrinkWrapping(MF) &&
// Windows with CFI has some limitations that make it impossible // Windows with CFI has some limitations that make it impossible
// to use shrink-wrapping. // to use shrink-wrapping.
!MF.getTarget().getMCAsmInfo()->usesWindowsCFI() && !MF.getTarget().getMCAsmInfo()->usesWindowsCFI() &&
// Sanitizers look at the value of the stack at the location // Sanitizers look at the value of the stack at the location
// of the crash. Since a crash can happen anywhere, the // of the crash. Since a crash can happen anywhere, the
// frame must be lowered before anything else happen for the // frame must be lowered before anything else happen for the
// sanitizers to be able to get a correct stack frame. // sanitizers to be able to get a correct stack frame.
!(MF.getFunction()->hasFnAttribute(Attribute::SanitizeAddress) || !(MF.getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
MF.getFunction()->hasFnAttribute(Attribute::SanitizeThread) || MF.getFunction()->hasFnAttribute(Attribute::SanitizeThread) ||
MF.getFunction()->hasFnAttribute(Attribute::SanitizeMemory)); MF.getFunction()->hasFnAttribute(Attribute::SanitizeMemory) ||
MF.getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress));
// If EnableShrinkWrap is set, it takes precedence on whatever the // If EnableShrinkWrap is set, it takes precedence on whatever the
// target sets. The rational is that we assume we want to test // target sets. The rational is that we assume we want to test
// something related to shrink-wrapping. // something related to shrink-wrapping.
case cl::BOU_TRUE: case cl::BOU_TRUE:
return true; return true;
case cl::BOU_FALSE: case cl::BOU_FALSE:
return false; return false;
} }
llvm_unreachable("Invalid shrink-wrapping state"); llvm_unreachable("Invalid shrink-wrapping state");
} }

llvm/trunk/lib/IR/Attributes.cpp

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Linesstd::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
return unpackAllocSizeArgs(pImpl->getValueAsInt()); return unpackAllocSizeArgs(pImpl->getValueAsInt());
} }
std::string Attribute::getAsString(bool InAttrGrp) const { std::string Attribute::getAsString(bool InAttrGrp) const {
if (!pImpl) return ""; if (!pImpl) return "";
if (hasAttribute(Attribute::SanitizeAddress)) if (hasAttribute(Attribute::SanitizeAddress))
return "sanitize_address"; return "sanitize_address";
if (hasAttribute(Attribute::SanitizeHWAddress))
return "sanitize_hwaddress";
if (hasAttribute(Attribute::AlwaysInline)) if (hasAttribute(Attribute::AlwaysInline))
return "alwaysinline"; return "alwaysinline";
if (hasAttribute(Attribute::ArgMemOnly)) if (hasAttribute(Attribute::ArgMemOnly))
return "argmemonly"; return "argmemonly";
if (hasAttribute(Attribute::Builtin)) if (hasAttribute(Attribute::Builtin))
return "builtin"; return "builtin";
if (hasAttribute(Attribute::ByVal)) if (hasAttribute(Attribute::ByVal))
return "byval"; return "byval";
▲ Show 20 Lines • Show All 1,430 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/Verifier.cpp

Show First 20 Lines • Show All 1,369 Lines • ▼ Show 20 Linesstatic bool isFuncOnlyAttr(Attribute::AttrKind Kind) {
case Attribute::NoImplicitFloat: case Attribute::NoImplicitFloat:
case Attribute::Naked: case Attribute::Naked:
case Attribute::InlineHint: case Attribute::InlineHint:
case Attribute::StackAlignment: case Attribute::StackAlignment:
case Attribute::UWTable: case Attribute::UWTable:
case Attribute::NonLazyBind: case Attribute::NonLazyBind:
case Attribute::ReturnsTwice: case Attribute::ReturnsTwice:
case Attribute::SanitizeAddress: case Attribute::SanitizeAddress:
case Attribute::SanitizeHWAddress:
case Attribute::SanitizeThread: case Attribute::SanitizeThread:
case Attribute::SanitizeMemory: case Attribute::SanitizeMemory:
case Attribute::MinSize: case Attribute::MinSize:
case Attribute::NoDuplicate: case Attribute::NoDuplicate:
case Attribute::Builtin: case Attribute::Builtin:
case Attribute::NoBuiltin: case Attribute::NoBuiltin:
case Attribute::Cold: case Attribute::Cold:
case Attribute::OptimizeNone: case Attribute::OptimizeNone:
▲ Show 20 Lines • Show All 3,600 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/IPO/ForceFunctionAttrs.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines return StringSwitch<Attribute::AttrKind>(Kind)
.Case("optnone", Attribute::OptimizeNone) .Case("optnone", Attribute::OptimizeNone)
.Case("optsize", Attribute::OptimizeForSize) .Case("optsize", Attribute::OptimizeForSize)
.Case("readnone", Attribute::ReadNone) .Case("readnone", Attribute::ReadNone)
.Case("readonly", Attribute::ReadOnly) .Case("readonly", Attribute::ReadOnly)
.Case("argmemonly", Attribute::ArgMemOnly) .Case("argmemonly", Attribute::ArgMemOnly)
.Case("returns_twice", Attribute::ReturnsTwice) .Case("returns_twice", Attribute::ReturnsTwice)
.Case("safestack", Attribute::SafeStack) .Case("safestack", Attribute::SafeStack)
.Case("sanitize_address", Attribute::SanitizeAddress) .Case("sanitize_address", Attribute::SanitizeAddress)
.Case("sanitize_hwaddress", Attribute::SanitizeHWAddress)
.Case("sanitize_memory", Attribute::SanitizeMemory) .Case("sanitize_memory", Attribute::SanitizeMemory)
.Case("sanitize_thread", Attribute::SanitizeThread) .Case("sanitize_thread", Attribute::SanitizeThread)
.Case("ssp", Attribute::StackProtect) .Case("ssp", Attribute::StackProtect)
.Case("sspreq", Attribute::StackProtectReq) .Case("sspreq", Attribute::StackProtectReq)
.Case("sspstrong", Attribute::StackProtectStrong) .Case("sspstrong", Attribute::StackProtectStrong)
.Case("strictfp", Attribute::StrictFP) .Case("strictfp", Attribute::StrictFP)
.Case("uwtable", Attribute::UWTable) .Case("uwtable", Attribute::UWTable)
.Default(Attribute::None); .Default(Attribute::None);
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 3,601 Lines • ▼ Show 20 Lines case Intrinsic::stackrestore: {
// restore. // restore.
if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI))) if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
return eraseInstFromFunction(CI); return eraseInstFromFunction(CI);
break; break;
} }
case Intrinsic::lifetime_start: case Intrinsic::lifetime_start:
// Asan needs to poison memory to detect invalid access which is possible // Asan needs to poison memory to detect invalid access which is possible
// even for empty lifetime range. // even for empty lifetime range.
if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress)) if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
II->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
break; break;
if (removeTriviallyEmptyRange(*II, Intrinsic::lifetime_start, if (removeTriviallyEmptyRange(*II, Intrinsic::lifetime_start,
Intrinsic::lifetime_end, *this)) Intrinsic::lifetime_end, *this))
return nullptr; return nullptr;
break; break;
case Intrinsic::assume: { case Intrinsic::assume: {
Value *IIOperand = II->getArgOperand(0); Value *IIOperand = II->getArgOperand(0);
▲ Show 20 Lines • Show All 791 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt

add_llvm_library(LLVMInstrumentation add_llvm_library(LLVMInstrumentation
AddressSanitizer.cpp AddressSanitizer.cpp
BoundsChecking.cpp BoundsChecking.cpp
DataFlowSanitizer.cpp DataFlowSanitizer.cpp
GCOVProfiling.cpp GCOVProfiling.cpp
MemorySanitizer.cpp MemorySanitizer.cpp
IndirectCallPromotion.cpp IndirectCallPromotion.cpp
Instrumentation.cpp Instrumentation.cpp
InstrProfiling.cpp InstrProfiling.cpp
PGOInstrumentation.cpp PGOInstrumentation.cpp
PGOMemOPSizeOpt.cpp PGOMemOPSizeOpt.cpp
SanitizerCoverage.cpp SanitizerCoverage.cpp
ThreadSanitizer.cpp ThreadSanitizer.cpp
EfficiencySanitizer.cpp EfficiencySanitizer.cpp
HWAddressSanitizer.cpp
ADDITIONAL_HEADER_DIRS ADDITIONAL_HEADER_DIRS
${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms
DEPENDS DEPENDS
intrinsics_gen intrinsics_gen
) )

llvm/trunk/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

//===- HWAddressSanitizer.cpp - detector of uninitialized reads -------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
/// \file
/// This file is a part of HWAddressSanitizer, an address sanity checker
/// based on tagged addressing.
//===----------------------------------------------------------------------===//
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/IR/Attributes.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/InlineAsm.h"
#include "llvm/IR/InstVisitor.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Value.h"
#include "llvm/Pass.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"
using namespace llvm;
#define DEBUG_TYPE "hwasan"
static const char *const kHwasanModuleCtorName = "hwasan.module_ctor";
static const char *const kHwasanInitName = "__hwasan_init";
// Accesses sizes are powers of two: 1, 2, 4, 8, 16.
static const size_t kNumberOfAccessSizes = 5;
static cl::opt<std::string> ClMemoryAccessCallbackPrefix(
"hwasan-memory-access-callback-prefix",
cl::desc("Prefix for memory access callbacks"), cl::Hidden,
cl::init("__hwasan_"));
static cl::opt<bool> ClInstrumentReads("hwasan-instrument-reads",
cl::desc("instrument read instructions"),
cl::Hidden, cl::init(true));
static cl::opt<bool> ClInstrumentWrites(
"hwasan-instrument-writes", cl::desc("instrument write instructions"),
cl::Hidden, cl::init(true));
static cl::opt<bool> ClInstrumentAtomics(
"hwasan-instrument-atomics",
cl::desc("instrument atomic instructions (rmw, cmpxchg)"), cl::Hidden,
cl::init(true));
namespace {
/// \brief An instrumentation pass implementing detection of addressability bugs
/// using tagged pointers.
class HWAddressSanitizer : public FunctionPass {
public:
// Pass identification, replacement for typeid.
static char ID;
HWAddressSanitizer() : FunctionPass(ID) {}
StringRef getPassName() const override { return "HWAddressSanitizer"; }
bool runOnFunction(Function &F) override;
bool doInitialization(Module &M) override;
void initializeCallbacks(Module &M);
bool instrumentMemAccess(Instruction *I);
Value *isInterestingMemoryAccess(Instruction *I, bool *IsWrite,
uint64_t *TypeSize, unsigned *Alignment,
Value **MaybeMask);
private:
LLVMContext *C;
Type *IntptrTy;
Function *HwasanCtorFunction;
Function *HwasanMemoryAccessCallback[2][kNumberOfAccessSizes];
Function *HwasanMemoryAccessCallbackSized[2];
};
} // end anonymous namespace
char HWAddressSanitizer::ID = 0;
INITIALIZE_PASS_BEGIN(
HWAddressSanitizer, "hwasan",
"HWAddressSanitizer: detect memory bugs using tagged addressing.", false, false)
INITIALIZE_PASS_END(
HWAddressSanitizer, "hwasan",
"HWAddressSanitizer: detect memory bugs using tagged addressing.", false, false)
FunctionPass *llvm::createHWAddressSanitizerPass() {
return new HWAddressSanitizer();
}
/// \brief Module-level initialization.
///
/// inserts a call to __hwasan_init to the module's constructor list.
bool HWAddressSanitizer::doInitialization(Module &M) {
DEBUG(dbgs() << "Init " << M.getName() << "\n");
auto &DL = M.getDataLayout();
Triple TargetTriple(M.getTargetTriple());
C = &(M.getContext());
IRBuilder<> IRB(*C);
IntptrTy = IRB.getIntPtrTy(DL);
std::tie(HwasanCtorFunction, std::ignore) =
createSanitizerCtorAndInitFunctions(M, kHwasanModuleCtorName,
kHwasanInitName,
/*InitArgTypes=*/{},
/*InitArgs=*/{});
appendToGlobalCtors(M, HwasanCtorFunction, 0);
return true;
}
void HWAddressSanitizer::initializeCallbacks(Module &M) {
IRBuilder<> IRB(*C);
for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
const std::string TypeStr = AccessIsWrite ? "store" : "load";
HwasanMemoryAccessCallbackSized[AccessIsWrite] =
checkSanitizerInterfaceFunction(M.getOrInsertFunction(
ClMemoryAccessCallbackPrefix + TypeStr,
FunctionType::get(IRB.getVoidTy(), {IntptrTy, IntptrTy}, false)));
for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
AccessSizeIndex++) {
HwasanMemoryAccessCallback[AccessIsWrite][AccessSizeIndex] =
checkSanitizerInterfaceFunction(M.getOrInsertFunction(
ClMemoryAccessCallbackPrefix + TypeStr +
itostr(1ULL << AccessSizeIndex),
FunctionType::get(IRB.getVoidTy(), {IntptrTy}, false)));
}
}
}
Value *HWAddressSanitizer::isInterestingMemoryAccess(Instruction *I,
bool *IsWrite,
uint64_t *TypeSize,
unsigned *Alignment,
Value **MaybeMask) {
// Skip memory accesses inserted by another instrumentation.
if (I->getMetadata("nosanitize")) return nullptr;
Value *PtrOperand = nullptr;
const DataLayout &DL = I->getModule()->getDataLayout();
if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
if (!ClInstrumentReads) return nullptr;
*IsWrite = false;
*TypeSize = DL.getTypeStoreSizeInBits(LI->getType());
*Alignment = LI->getAlignment();
PtrOperand = LI->getPointerOperand();
} else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
if (!ClInstrumentWrites) return nullptr;
*IsWrite = true;
*TypeSize = DL.getTypeStoreSizeInBits(SI->getValueOperand()->getType());
*Alignment = SI->getAlignment();
PtrOperand = SI->getPointerOperand();
} else if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(I)) {
if (!ClInstrumentAtomics) return nullptr;
*IsWrite = true;
*TypeSize = DL.getTypeStoreSizeInBits(RMW->getValOperand()->getType());
*Alignment = 0;
PtrOperand = RMW->getPointerOperand();
} else if (AtomicCmpXchgInst *XCHG = dyn_cast<AtomicCmpXchgInst>(I)) {
if (!ClInstrumentAtomics) return nullptr;
*IsWrite = true;
*TypeSize = DL.getTypeStoreSizeInBits(XCHG->getCompareOperand()->getType());
*Alignment = 0;
PtrOperand = XCHG->getPointerOperand();
}
if (PtrOperand) {
// Do not instrument acesses from different address spaces; we cannot deal
// with them.
Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());
if (PtrTy->getPointerAddressSpace() != 0)
return nullptr;
// Ignore swifterror addresses.
// swifterror memory addresses are mem2reg promoted by instruction
// selection. As such they cannot have regular uses like an instrumentation
// function and it makes no sense to track them as memory.
if (PtrOperand->isSwiftError())
return nullptr;
}
return PtrOperand;
}
static size_t TypeSizeToSizeIndex(uint32_t TypeSize) {
size_t Res = countTrailingZeros(TypeSize / 8);
assert(Res < kNumberOfAccessSizes);
return Res;
}
bool HWAddressSanitizer::instrumentMemAccess(Instruction *I) {
DEBUG(dbgs() << "Instrumenting: " << *I << "\n");
bool IsWrite = false;
unsigned Alignment = 0;
uint64_t TypeSize = 0;
Value *MaybeMask = nullptr;
Value *Addr =
isInterestingMemoryAccess(I, &IsWrite, &TypeSize, &Alignment, &MaybeMask);
if (!Addr)
return false;
if (MaybeMask)
return false; //FIXME
IRBuilder<> IRB(I);
Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy);
if (isPowerOf2_64(TypeSize) &&
(TypeSize / 8 <= (1UL << (kNumberOfAccessSizes - 1)))) {
size_t AccessSizeIndex = TypeSizeToSizeIndex(TypeSize);
IRB.CreateCall(HwasanMemoryAccessCallback[IsWrite][AccessSizeIndex],
AddrLong);
} else {
IRB.CreateCall(HwasanMemoryAccessCallbackSized[IsWrite],
{AddrLong, ConstantInt::get(IntptrTy, TypeSize / 8)});
}
return true;
}
bool HWAddressSanitizer::runOnFunction(Function &F) {
if (&F == HwasanCtorFunction)
return false;
if (!F.hasFnAttribute(Attribute::SanitizeHWAddress))
return false;
DEBUG(dbgs() << "Function: " << F.getName() << "\n");
initializeCallbacks(*F.getParent());
bool Changed = false;
SmallVector<Instruction*, 16> ToInstrument;
for (auto &BB : F) {
for (auto &Inst : BB) {
Value *MaybeMask = nullptr;
bool IsWrite;
unsigned Alignment;
uint64_t TypeSize;
Value *Addr = isInterestingMemoryAccess(&Inst, &IsWrite, &TypeSize,
&Alignment, &MaybeMask);
if (Addr || isa<MemIntrinsic>(Inst))
ToInstrument.push_back(&Inst);
}
}
for (auto Inst : ToInstrument)
Changed |= instrumentMemAccess(Inst);
return Changed;
}

llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linesvoid llvm::initializeInstrumentation(PassRegistry &Registry) {
initializeBoundsCheckingLegacyPassPass(Registry); initializeBoundsCheckingLegacyPassPass(Registry);
initializeGCOVProfilerLegacyPassPass(Registry); initializeGCOVProfilerLegacyPassPass(Registry);
initializePGOInstrumentationGenLegacyPassPass(Registry); initializePGOInstrumentationGenLegacyPassPass(Registry);
initializePGOInstrumentationUseLegacyPassPass(Registry); initializePGOInstrumentationUseLegacyPassPass(Registry);
initializePGOIndirectCallPromotionLegacyPassPass(Registry); initializePGOIndirectCallPromotionLegacyPassPass(Registry);
initializePGOMemOPSizeOptLegacyPassPass(Registry); initializePGOMemOPSizeOptLegacyPassPass(Registry);
initializeInstrProfilingLegacyPassPass(Registry); initializeInstrProfilingLegacyPassPass(Registry);
initializeMemorySanitizerPass(Registry); initializeMemorySanitizerPass(Registry);
initializeHWAddressSanitizerPass(Registry);
initializeThreadSanitizerPass(Registry); initializeThreadSanitizerPass(Registry);
initializeSanitizerCoverageModulePass(Registry); initializeSanitizerCoverageModulePass(Registry);
initializeDataFlowSanitizerPass(Registry); initializeDataFlowSanitizerPass(Registry);
initializeEfficiencySanitizerPass(Registry); initializeEfficiencySanitizerPass(Registry);
} }
/// LLVMInitializeInstrumentation - C binding for /// LLVMInitializeInstrumentation - C binding for
/// initializeInstrumentation. /// initializeInstrumentation.
void LLVMInitializeInstrumentation(LLVMPassRegistryRef R) { void LLVMInitializeInstrumentation(LLVMPassRegistryRef R) {
initializeInstrumentation(*unwrap(R)); initializeInstrumentation(*unwrap(R));
} }

llvm/trunk/lib/Transforms/Scalar/GVN.cpp

Show First 20 Lines • Show All 1,293 Lines • ▼ Show 20 Lines return OptimizationRemark(DEBUG_TYPE, "LoadElim", LI)
<< NV("InfavorOfValue", AvailableValue); << NV("InfavorOfValue", AvailableValue);
}); });
} }
/// Attempt to eliminate a load whose dependencies are /// Attempt to eliminate a load whose dependencies are
/// non-local by performing PHI construction. /// non-local by performing PHI construction.
bool GVN::processNonLocalLoad(LoadInst *LI) { bool GVN::processNonLocalLoad(LoadInst *LI) {
// non-local speculations are not allowed under asan. // non-local speculations are not allowed under asan.
if (LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeAddress)) if (LI->getParent()->getParent()->hasFnAttribute(
Attribute::SanitizeAddress) ||
LI->getParent()->getParent()->hasFnAttribute(
Attribute::SanitizeHWAddress))
return false; return false;
// Step 1: Find the non-local dependencies of the load. // Step 1: Find the non-local dependencies of the load.
LoadDepVect Deps; LoadDepVect Deps;
MD->getNonLocalPointerDependency(LI, Deps); MD->getNonLocalPointerDependency(LI, Deps);
// If we had to process more than one hundred blocks to find the // If we had to process more than one hundred blocks to find the
// dependencies, this load isn't worth worrying about. Optimizing // dependencies, this load isn't worth worrying about. Optimizing
▲ Show 20 Lines • Show All 1,354 Lines • Show Last 20 Lines

llvm/trunk/test/Bitcode/attributes.ll

Show First 20 Lines • Show All 198 Lines • ▼ Show 20 Lines
} }
declare void @nobuiltin() declare void @nobuiltin()
define void @f34() define void @f34()
; CHECK: define void @f34() ; CHECK: define void @f34()
{ {
call void @nobuiltin() nobuiltin call void @nobuiltin() nobuiltin
; CHECK: call void @nobuiltin() #34 ; CHECK: call void @nobuiltin() #35
ret void; ret void;
} }
define void @f35() optnone noinline define void @f35() optnone noinline
; CHECK: define void @f35() #23 ; CHECK: define void @f35() #23
{ {
ret void; ret void;
} }
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Linesdefine void @f56() writeonly
ret void ret void
} }
; CHECK: define void @f57() #33 ; CHECK: define void @f57() #33
define void @f57() speculatable { define void @f57() speculatable {
ret void ret void
} }
; CHECK: define void @f58() #34
define void @f58() sanitize_hwaddress
{
ret void;
}
; CHECK: attributes #0 = { noreturn } ; CHECK: attributes #0 = { noreturn }
; CHECK: attributes #1 = { nounwind } ; CHECK: attributes #1 = { nounwind }
; CHECK: attributes #2 = { readnone } ; CHECK: attributes #2 = { readnone }
; CHECK: attributes #3 = { readonly } ; CHECK: attributes #3 = { readonly }
; CHECK: attributes #4 = { noinline } ; CHECK: attributes #4 = { noinline }
; CHECK: attributes #5 = { alwaysinline } ; CHECK: attributes #5 = { alwaysinline }
; CHECK: attributes #6 = { optsize } ; CHECK: attributes #6 = { optsize }
; CHECK: attributes #7 = { ssp } ; CHECK: attributes #7 = { ssp }
Show All 18 Lines
; CHECK: attributes #26 = { argmemonly } ; CHECK: attributes #26 = { argmemonly }
; CHECK: attributes #27 = { norecurse } ; CHECK: attributes #27 = { norecurse }
; CHECK: attributes #28 = { inaccessiblememonly } ; CHECK: attributes #28 = { inaccessiblememonly }
; CHECK: attributes #29 = { inaccessiblemem_or_argmemonly } ; CHECK: attributes #29 = { inaccessiblemem_or_argmemonly }
; CHECK: attributes #30 = { allocsize(0) } ; CHECK: attributes #30 = { allocsize(0) }
; CHECK: attributes #31 = { allocsize(0,1) } ; CHECK: attributes #31 = { allocsize(0,1) }
; CHECK: attributes #32 = { writeonly } ; CHECK: attributes #32 = { writeonly }
; CHECK: attributes #33 = { speculatable } ; CHECK: attributes #33 = { speculatable }
; CHECK: attributes #34 = { nobuiltin } ; CHECK: attributes #34 = { sanitize_hwaddress }
; CHECK: attributes #35 = { nobuiltin }

llvm/trunk/test/Instrumentation/HWAddressSanitizer/atomic.ll

; Test basic address sanitizer instrumentation.
;
; RUN: opt < %s -hwasan -S | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-android"
define void @atomicrmw(i64* %ptr) sanitize_hwaddress {
; CHECK-LABEL: @atomicrmw(
; CHECK: %[[A:[^ ]*]] = ptrtoint i64* %ptr to i64
; CHECK: call void @__hwasan_store8(i64 %[[A]])
entry:
%0 = atomicrmw add i64* %ptr, i64 1 seq_cst
ret void
}
define void @cmpxchg(i64* %ptr, i64 %compare_to, i64 %new_value) sanitize_hwaddress {
; CHECK-LABEL: @cmpxchg(
; CHECK: %[[A:[^ ]*]] = ptrtoint i64* %ptr to i64
; CHECK: call void @__hwasan_store8(i64 %[[A]])
entry:
%0 = cmpxchg i64* %ptr, i64 %compare_to, i64 %new_value seq_cst seq_cst
ret void
}

llvm/trunk/test/Instrumentation/HWAddressSanitizer/basic.ll

; Test basic address sanitizer instrumentation.
;
; RUN: opt < %s -hwasan -S | FileCheck %s
target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
target triple = "aarch64--linux-android"
define i8 @test_load8(i8* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load8(
; CHECK: %[[A:[^ ]*]] = ptrtoint i8* %a to i64
; CHECK: call void @__hwasan_load1(i64 %[[A]])
; CHECK: %[[B:[^ ]*]] = load i8, i8* %a
; CHECK: ret i8 %[[B]]
entry:
%b = load i8, i8* %a, align 4
ret i8 %b
}
define i16 @test_load16(i16* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load16(
; CHECK: %[[A:[^ ]*]] = ptrtoint i16* %a to i64
; CHECK: call void @__hwasan_load2(i64 %[[A]])
; CHECK: %[[B:[^ ]*]] = load i16, i16* %a
; CHECK: ret i16 %[[B]]
entry:
%b = load i16, i16* %a, align 4
ret i16 %b
}
define i32 @test_load32(i32* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load32(
; CHECK: %[[A:[^ ]*]] = ptrtoint i32* %a to i64
; CHECK: call void @__hwasan_load4(i64 %[[A]])
; CHECK: %[[B:[^ ]*]] = load i32, i32* %a
; CHECK: ret i32 %[[B]]
entry:
%b = load i32, i32* %a, align 4
ret i32 %b
}
define i64 @test_load64(i64* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load64(
; CHECK: %[[A:[^ ]*]] = ptrtoint i64* %a to i64
; CHECK: call void @__hwasan_load8(i64 %[[A]])
; CHECK: %[[B:[^ ]*]] = load i64, i64* %a
; CHECK: ret i64 %[[B]]
entry:
%b = load i64, i64* %a, align 8
ret i64 %b
}
define i128 @test_load128(i128* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load128(
; CHECK: %[[A:[^ ]*]] = ptrtoint i128* %a to i64
; CHECK: call void @__hwasan_load16(i64 %[[A]])
; CHECK: %[[B:[^ ]*]] = load i128, i128* %a
; CHECK: ret i128 %[[B]]
entry:
%b = load i128, i128* %a, align 16
ret i128 %b
}
define i40 @test_load40(i40* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load40(
; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
; CHECK: call void @__hwasan_load(i64 %[[A]], i64 5)
; CHECK: %[[B:[^ ]*]] = load i40, i40* %a
; CHECK: ret i40 %[[B]]
entry:
%b = load i40, i40* %a, align 4
ret i40 %b
}
define void @test_store8(i8* %a, i8 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store8(
; CHECK: %[[A:[^ ]*]] = ptrtoint i8* %a to i64
; CHECK: call void @__hwasan_store1(i64 %[[A]])
; CHECK: store i8 %b, i8* %a
; CHECK: ret void
entry:
store i8 %b, i8* %a, align 4
ret void
}
define void @test_store16(i16* %a, i16 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store16(
; CHECK: %[[A:[^ ]*]] = ptrtoint i16* %a to i64
; CHECK: call void @__hwasan_store2(i64 %[[A]])
; CHECK: store i16 %b, i16* %a
; CHECK: ret void
entry:
store i16 %b, i16* %a, align 4
ret void
}
define void @test_store32(i32* %a, i32 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store32(
; CHECK: %[[A:[^ ]*]] = ptrtoint i32* %a to i64
; CHECK: call void @__hwasan_store4(i64 %[[A]])
; CHECK: store i32 %b, i32* %a
; CHECK: ret void
entry:
store i32 %b, i32* %a, align 4
ret void
}
define void @test_store64(i64* %a, i64 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store64(
; CHECK: %[[A:[^ ]*]] = ptrtoint i64* %a to i64
; CHECK: call void @__hwasan_store8(i64 %[[A]])
; CHECK: store i64 %b, i64* %a
; CHECK: ret void
entry:
store i64 %b, i64* %a, align 4
ret void
}
define void @test_store128(i128* %a, i128 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store128(
; CHECK: %[[A:[^ ]*]] = ptrtoint i128* %a to i64
; CHECK: call void @__hwasan_store16(i64 %[[A]])
; CHECK: store i128 %b, i128* %a
; CHECK: ret void
entry:
store i128 %b, i128* %a, align 4
ret void
}
define void @test_store40(i40* %a, i40 %b) sanitize_hwaddress {
; CHECK-LABEL: @test_store40(
; CHECK: %[[A:[^ ]*]] = ptrtoint i40* %a to i64
; CHECK: call void @__hwasan_store(i64 %[[A]], i64 5)
; CHECK: store i40 %b, i40* %a
; CHECK: ret void
entry:
store i40 %b, i40* %a, align 4
ret void
}
define i8 @test_load_noattr(i8* %a) {
; CHECK-LABEL: @test_load_noattr(
; CHECK-NEXT: entry:
; CHECK-NEXT: %[[B:[^ ]*]] = load i8, i8* %a
; CHECK-NEXT: ret i8 %[[B]]
entry:
%b = load i8, i8* %a, align 4
ret i8 %b
}
define i8 @test_load_notmyattr(i8* %a) sanitize_address {
; CHECK-LABEL: @test_load_notmyattr(
; CHECK-NEXT: entry:
; CHECK-NEXT: %[[B:[^ ]*]] = load i8, i8* %a
; CHECK-NEXT: ret i8 %[[B]]
entry:
%b = load i8, i8* %a, align 4
ret i8 %b
}
define i8 @test_load_addrspace(i8 addrspace(256)* %a) sanitize_hwaddress {
; CHECK-LABEL: @test_load_addrspace(
; CHECK-NEXT: entry:
; CHECK-NEXT: %[[B:[^ ]*]] = load i8, i8 addrspace(256)* %a
; CHECK-NEXT: ret i8 %[[B]]
entry:
%b = load i8, i8 addrspace(256)* %a, align 4
ret i8 %b
}
; CHECK: declare void @__hwasan_init()
; CHECK: define internal void @hwasan.module_ctor() {
; CHECK-NEXT: call void @__hwasan_init()
; CHECK-NEXT: ret void
; CHECK-NEXT: }

llvm/trunk/test/Transforms/GVN/no_speculative_loads_with_asan.ll

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines; <label>:11 ; preds = %0, %6
%12 = phi i32 [ %10, %6 ], [ 0, %0 ] %12 = phi i32 [ %10, %6 ], [ 0, %0 ]
ret i32 %12 ret i32 %12
} }
; CHECK-LABEL: @TestAsan ; CHECK-LABEL: @TestAsan
; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32 ; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32
; CHECK: {{.*}} = phi ; CHECK: {{.*}} = phi
define i32 @TestHWAsan() sanitize_hwaddress {
%1 = tail call noalias i8* @_Znam(i64 2)
%2 = getelementptr inbounds i8, i8* %1, i64 1
store i8 0, i8* %2, align 1
store i8 0, i8* %1, align 1
%3 = bitcast i8* %1 to i16*
%4 = load i16, i16* %3, align 4
%5 = icmp eq i16 %4, 0
br i1 %5, label %11, label %6
; <label>:6 ; preds = %0
%7 = getelementptr inbounds i8, i8* %1, i64 2
%8 = bitcast i8* %7 to i16*
%9 = load i16, i16* %8, align 2
%10 = sext i16 %9 to i32
br label %11
; <label>:11 ; preds = %0, %6
%12 = phi i32 [ %10, %6 ], [ 0, %0 ]
ret i32 %12
}
; CHECK-LABEL: @TestHWAsan
; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32
; CHECK: {{.*}} = phi

llvm/trunk/test/Transforms/Inline/attributes.ll

; RUN: opt < %s -inline -S | FileCheck %s ; RUN: opt < %s -inline -S | FileCheck %s
; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s ; RUN: opt < %s -passes='cgscc(inline)' -S | FileCheck %s
target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
define i32 @noattr_callee(i32 %i) { define i32 @noattr_callee(i32 %i) {
ret i32 %i ret i32 %i
} }
define i32 @sanitize_address_callee(i32 %i) sanitize_address { define i32 @sanitize_address_callee(i32 %i) sanitize_address {
ret i32 %i ret i32 %i
} }
define i32 @sanitize_hwaddress_callee(i32 %i) sanitize_hwaddress {
ret i32 %i
}
define i32 @sanitize_thread_callee(i32 %i) sanitize_thread { define i32 @sanitize_thread_callee(i32 %i) sanitize_thread {
ret i32 %i ret i32 %i
} }
define i32 @sanitize_memory_callee(i32 %i) sanitize_memory { define i32 @sanitize_memory_callee(i32 %i) sanitize_memory {
ret i32 %i ret i32 %i
} }
define i32 @safestack_callee(i32 %i) safestack { define i32 @safestack_callee(i32 %i) safestack {
ret i32 %i ret i32 %i
} }
define i32 @alwaysinline_callee(i32 %i) alwaysinline { define i32 @alwaysinline_callee(i32 %i) alwaysinline {
ret i32 %i ret i32 %i
} }
define i32 @alwaysinline_sanitize_address_callee(i32 %i) alwaysinline sanitize_address { define i32 @alwaysinline_sanitize_address_callee(i32 %i) alwaysinline sanitize_address {
ret i32 %i ret i32 %i
} }
define i32 @alwaysinline_sanitize_hwaddress_callee(i32 %i) alwaysinline sanitize_hwaddress {
ret i32 %i
}
define i32 @alwaysinline_sanitize_thread_callee(i32 %i) alwaysinline sanitize_thread { define i32 @alwaysinline_sanitize_thread_callee(i32 %i) alwaysinline sanitize_thread {
ret i32 %i ret i32 %i
} }
define i32 @alwaysinline_sanitize_memory_callee(i32 %i) alwaysinline sanitize_memory { define i32 @alwaysinline_sanitize_memory_callee(i32 %i) alwaysinline sanitize_memory {
ret i32 %i ret i32 %i
} }
Show All 13 Linesdefine i32 @test_no_sanitize_address(i32 %arg) {
%x3 = call i32 @alwaysinline_callee(i32 %x2) %x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3) %x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3)
ret i32 %x4 ret i32 %x4
; CHECK-LABEL: @test_no_sanitize_address( ; CHECK-LABEL: @test_no_sanitize_address(
; CHECK-NEXT: @sanitize_address_callee ; CHECK-NEXT: @sanitize_address_callee
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
define i32 @test_no_sanitize_hwaddress(i32 %arg) {
%x1 = call i32 @noattr_callee(i32 %arg)
%x2 = call i32 @sanitize_hwaddress_callee(i32 %x1)
%x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_hwaddress_callee(i32 %x3)
ret i32 %x4
; CHECK-LABEL: @test_no_sanitize_hwaddress(
; CHECK-NEXT: @sanitize_hwaddress_callee
; CHECK-NEXT: ret i32
}
define i32 @test_no_sanitize_memory(i32 %arg) { define i32 @test_no_sanitize_memory(i32 %arg) {
%x1 = call i32 @noattr_callee(i32 %arg) %x1 = call i32 @noattr_callee(i32 %arg)
%x2 = call i32 @sanitize_memory_callee(i32 %x1) %x2 = call i32 @sanitize_memory_callee(i32 %x1)
%x3 = call i32 @alwaysinline_callee(i32 %x2) %x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3) %x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3)
ret i32 %x4 ret i32 %x4
; CHECK-LABEL: @test_no_sanitize_memory( ; CHECK-LABEL: @test_no_sanitize_memory(
; CHECK-NEXT: @sanitize_memory_callee ; CHECK-NEXT: @sanitize_memory_callee
Show All 23 Linesdefine i32 @test_sanitize_address(i32 %arg) sanitize_address {
%x3 = call i32 @alwaysinline_callee(i32 %x2) %x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3) %x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3)
ret i32 %x4 ret i32 %x4
; CHECK-LABEL: @test_sanitize_address( ; CHECK-LABEL: @test_sanitize_address(
; CHECK-NEXT: @noattr_callee ; CHECK-NEXT: @noattr_callee
; CHECK-NEXT: ret i32 ; CHECK-NEXT: ret i32
} }
define i32 @test_sanitize_hwaddress(i32 %arg) sanitize_hwaddress {
%x1 = call i32 @noattr_callee(i32 %arg)
%x2 = call i32 @sanitize_hwaddress_callee(i32 %x1)
%x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_hwaddress_callee(i32 %x3)
ret i32 %x4
; CHECK-LABEL: @test_sanitize_hwaddress(
; CHECK-NEXT: @noattr_callee
; CHECK-NEXT: ret i32
}
define i32 @test_sanitize_memory(i32 %arg) sanitize_memory { define i32 @test_sanitize_memory(i32 %arg) sanitize_memory {
%x1 = call i32 @noattr_callee(i32 %arg) %x1 = call i32 @noattr_callee(i32 %arg)
%x2 = call i32 @sanitize_memory_callee(i32 %x1) %x2 = call i32 @sanitize_memory_callee(i32 %x1)
%x3 = call i32 @alwaysinline_callee(i32 %x2) %x3 = call i32 @alwaysinline_callee(i32 %x2)
%x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3) %x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3)
ret i32 %x4 ret i32 %x4
; CHECK-LABEL: @test_sanitize_memory( ; CHECK-LABEL: @test_sanitize_memory(
; CHECK-NEXT: @noattr_callee ; CHECK-NEXT: @noattr_callee
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

llvm/trunk/test/Transforms/InstCombine/lifetime-asan.ll

Show All 13 Linesentry:
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; CHECK-NEXT: call void @llvm.lifetime.end ; CHECK-NEXT: call void @llvm.lifetime.end
call void @foo(i8* %text) ; Keep alloca alive call void @foo(i8* %text) ; Keep alloca alive
ret void ret void
} }
define void @hwasan() sanitize_hwaddress {
entry:
; CHECK-LABEL: @hwasan(
%text = alloca i8, align 1
call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
; CHECK: call void @llvm.lifetime.start
; CHECK-NEXT: call void @llvm.lifetime.end
call void @foo(i8* %text) ; Keep alloca alive
ret void
}
define void @no_asan() { define void @no_asan() {
entry: entry:
; CHECK-LABEL: @no_asan( ; CHECK-LABEL: @no_asan(
%text = alloca i8, align 1 %text = alloca i8, align 1
call void @llvm.lifetime.start.p0i8(i64 1, i8* %text) call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
call void @llvm.lifetime.end.p0i8(i64 1, i8* %text) call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
; CHECK-NO: call void @llvm.lifetime ; CHECK-NO: call void @llvm.lifetime
call void @foo(i8* %text) ; Keep alloca alive call void @foo(i8* %text) ; Keep alloca alive
ret void ret void
} }

llvm/trunk/test/Transforms/NewGVN/no_speculative_loads_with_asan.ll

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines; <label>:11 ; preds = %0, %6
%12 = phi i32 [ %10, %6 ], [ 0, %0 ] %12 = phi i32 [ %10, %6 ], [ 0, %0 ]
ret i32 %12 ret i32 %12
} }
; CHECK-LABEL: @TestAsan ; CHECK-LABEL: @TestAsan
; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32 ; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32
; CHECK: {{.*}} = phi ; CHECK: {{.*}} = phi
define i32 @TestHWAsan() sanitize_hwaddress {
%1 = tail call noalias i8* @_Znam(i64 2)
%2 = getelementptr inbounds i8, i8* %1, i64 1
store i8 0, i8* %2, align 1
store i8 0, i8* %1, align 1
%3 = bitcast i8* %1 to i16*
%4 = load i16, i16* %3, align 4
%5 = icmp eq i16 %4, 0
br i1 %5, label %11, label %6
; <label>:6 ; preds = %0
%7 = getelementptr inbounds i8, i8* %1, i64 2
%8 = bitcast i8* %7 to i16*
%9 = load i16, i16* %8, align 2
%10 = sext i16 %9 to i32
br label %11
; <label>:11 ; preds = %0, %6
%12 = phi i32 [ %10, %6 ], [ 0, %0 ]
ret i32 %12
}
; CHECK-LABEL: @TestHWAsan
; CHECK-NOT: %[[LOAD:[^ ]+]] = load i32
; CHECK: {{.*}} = phi

llvm/trunk/test/Transforms/SimplifyCFG/no_speculative_loads_with_asan.ll

Show All 32 Linesreturn: ; preds = %entry, %if.then
%retval = phi i32 [ %0, %if.then ], [ 0, %entry ] %retval = phi i32 [ %0, %if.then ], [ 0, %entry ]
ret i32 %retval ret i32 %retval
; CHECK-LABEL: @TestAsan ; CHECK-LABEL: @TestAsan
; CHECK: br i1 ; CHECK: br i1
; CHECK: load i32, i32* @g ; CHECK: load i32, i32* @g
; CHECK: br label ; CHECK: br label
; CHECK: ret i32 ; CHECK: ret i32
} }
define i32 @TestHWAsan(i32 %cond) nounwind readonly uwtable sanitize_hwaddress {
entry:
%tobool = icmp eq i32 %cond, 0
br i1 %tobool, label %return, label %if.then
if.then: ; preds = %entry
%0 = load i32, i32* @g, align 4
br label %return
return: ; preds = %entry, %if.then
%retval = phi i32 [ %0, %if.then ], [ 0, %entry ]
ret i32 %retval
; CHECK-LABEL: @TestHWAsan
; CHECK: br i1
; CHECK: load i32, i32* @g
; CHECK: br label
; CHECK: ret i32
}