71#define DEBUG_TYPE "hwasan"
79 "__hwasan_shadow_memory_dynamic_address";
86 std::numeric_limits<uint64_t>::max();
92 cl::desc(
"Prefix for memory access callbacks"),
96 "hwasan-kernel-mem-intrinsic-prefix",
101 "hwasan-instrument-with-calls",
106 cl::desc(
"instrument read instructions"),
115 "hwasan-instrument-atomics",
120 cl::desc(
"instrument byval arguments"),
125 cl::desc(
"Enable recovery mode (continue-after-error)."),
129 cl::desc(
"instrument stack (allocas)"),
140 cl::desc(
"How many lifetime ends to handle for a single alloca."),
145 cl::desc(
"detect use after scope within function"),
149 "hwasan-generate-tags-with-calls",
157 "hwasan-match-all-tag",
158 cl::desc(
"don't report bad accesses via pointers with this tag"),
163 cl::desc(
"Enable KernelHWAddressSanitizer instrumentation"),
172 cl::desc(
"HWASan shadow mapping offset [EXPERIMENTAL]"),
177 cl::desc(
"Access dynamic shadow through an ifunc global on "
178 "platforms that support this"),
183 cl::desc(
"Access dynamic shadow through an thread-local pointer on "
184 "platforms that support this"),
188 cl::desc(
"Hot percentile cuttoff."));
192 cl::desc(
"Probability value in the range [0.0, 1.0] "
193 "to keep instrumentation of a function."));
196STATISTIC(NumInstrumentedFuncs,
"Number of instrumented funcs");
197STATISTIC(NumNoProfileSummaryFuncs,
"Number of funcs without PS");
214 "hwasan-record-stack-history",
215 cl::desc(
"Record stack frames with tagged allocations in a thread-local "
219 "storing into the stack ring buffer directly"),
221 "storing into the stack ring buffer")),
226 cl::desc(
"instrument memory intrinsics"),
235 "hwasan-use-short-granules",
240 "hwasan-instrument-personality-functions",
253 cl::desc(
"Use page aliasing in HWASan"),
262bool shouldUsePageAliases(
const Triple &TargetTriple) {
266bool shouldInstrumentStack(
const Triple &TargetTriple) {
270bool shouldInstrumentWithCalls(
const Triple &TargetTriple) {
274bool mightUseStackSafetyAnalysis(
bool DisableOptimization) {
278bool shouldUseStackSafetyAnalysis(
const Triple &TargetTriple,
279 bool DisableOptimization) {
280 return shouldInstrumentStack(TargetTriple) &&
281 mightUseStackSafetyAnalysis(DisableOptimization);
284bool shouldDetectUseAfterScope(
const Triple &TargetTriple) {
290class HWAddressSanitizer {
292 HWAddressSanitizer(
Module &M,
bool CompileKernel,
bool Recover,
295 this->Recover = optOr(
ClRecover, Recover);
306 struct ShadowTagCheckInfo {
308 Value *PtrLong =
nullptr;
309 Value *AddrLong =
nullptr;
310 Value *PtrTag =
nullptr;
311 Value *MemTag =
nullptr;
314 bool selectiveInstrumentationShouldSkip(
Function &
F,
316 void initializeModule();
317 void createHwasanCtorComdat();
319 void initializeCallbacks(
Module &M);
329 int64_t getAccessInfo(
bool IsWrite,
unsigned AccessSizeIndex);
332 void instrumentMemAccessOutline(
Value *
Ptr,
bool IsWrite,
333 unsigned AccessSizeIndex,
336 void instrumentMemAccessInline(
Value *
Ptr,
bool IsWrite,
337 unsigned AccessSizeIndex,
345 void getInterestingMemoryOperands(
363 unsigned retagMask(
unsigned AllocaNo);
365 void emitPrologue(
IRBuilder<> &IRB,
bool WithFrameRecord);
368 void instrumentGlobals();
373 void instrumentPersonalityFunctions();
379 std::unique_ptr<RandomNumberGenerator> Rng;
392 struct ShadowMapping {
397 bool WithFrameRecord;
399 void init(
Triple &TargetTriple,
bool InstrumentWithCalls);
400 Align getObjectAlignment()
const {
return Align(1ULL << Scale); }
403 ShadowMapping Mapping;
406 Type *IntptrTy =
M.getDataLayout().getIntPtrType(
M.getContext());
407 PointerType *PtrTy = PointerType::getUnqual(
M.getContext());
416 bool UseShortGranules;
417 bool InstrumentLandingPads;
418 bool InstrumentWithCalls;
419 bool InstrumentStack;
420 bool InstrumentGlobals;
421 bool DetectUseAfterScope;
423 bool UseMatchAllCallback;
425 std::optional<uint8_t> MatchAllTag;
427 unsigned PointerTagShift;
444 Value *ShadowBase =
nullptr;
445 Value *StackBaseTag =
nullptr;
446 Value *CachedFP =
nullptr;
462 HWASan.sanitizeFunction(
F,
FAM);
480 OS, MapClassName2PassName);
489void HWAddressSanitizer::createHwasanCtorComdat() {
490 std::tie(HwasanCtorFunction, std::ignore) =
539 nullptr,
"__start_hwasan_globals");
543 nullptr,
"__stop_hwasan_globals");
555 Note->setSection(
".note.hwasan.globals");
556 Note->setComdat(NoteComdat);
571 Name, CreateRelPtr(Start), CreateRelPtr(Stop)}));
579 Dummy->setSection(
"hwasan_globals");
580 Dummy->setComdat(NoteComdat);
581 Dummy->setMetadata(LLVMContext::MD_associated,
589void HWAddressSanitizer::initializeModule() {
591 TargetTriple =
Triple(
M.getTargetTriple());
597 UsePageAliases = shouldUsePageAliases(TargetTriple);
598 InstrumentWithCalls = shouldInstrumentWithCalls(TargetTriple);
599 InstrumentStack = shouldInstrumentStack(TargetTriple);
600 DetectUseAfterScope = shouldDetectUseAfterScope(TargetTriple);
601 PointerTagShift = IsX86_64 ? 57 : 56;
602 TagMaskByte = IsX86_64 ? 0x3F : 0xFF;
604 Mapping.init(TargetTriple, InstrumentWithCalls);
606 C = &(
M.getContext());
609 HwasanCtorFunction =
nullptr;
630 }
else if (CompileKernel) {
633 UseMatchAllCallback = !CompileKernel && MatchAllTag.has_value();
639 !CompileKernel && !UsePageAliases && optOr(
ClGlobals, NewRuntime);
641 if (!CompileKernel) {
642 createHwasanCtorComdat();
644 if (InstrumentGlobals)
647 bool InstrumentPersonalityFunctions =
649 if (InstrumentPersonalityFunctions)
650 instrumentPersonalityFunctions();
654 Constant *
C =
M.getOrInsertGlobal(
"__hwasan_tls", IntptrTy, [&] {
657 "__hwasan_tls",
nullptr,
662 ThreadPtrGlobal = cast<GlobalVariable>(
C);
666void HWAddressSanitizer::initializeCallbacks(
Module &M) {
668 const std::string MatchAllStr = UseMatchAllCallback ?
"_match_all" :
"";
670 *HwasanMemoryAccessCallbackFnTy, *HwasanMemTransferFnTy,
672 if (UseMatchAllCallback) {
673 HwasanMemoryAccessCallbackSizedFnTy =
675 HwasanMemoryAccessCallbackFnTy =
677 HwasanMemTransferFnTy =
682 HwasanMemoryAccessCallbackSizedFnTy =
684 HwasanMemoryAccessCallbackFnTy =
686 HwasanMemTransferFnTy =
692 for (
size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
693 const std::string TypeStr = AccessIsWrite ?
"store" :
"load";
694 const std::string EndingStr = Recover ?
"_noabort" :
"";
696 HwasanMemoryAccessCallbackSized[AccessIsWrite] =
M.getOrInsertFunction(
698 HwasanMemoryAccessCallbackSizedFnTy);
702 HwasanMemoryAccessCallback[AccessIsWrite][AccessSizeIndex] =
704 itostr(1ULL << AccessSizeIndex) +
705 MatchAllStr + EndingStr,
706 HwasanMemoryAccessCallbackFnTy);
710 const std::string MemIntrinCallbackPrefix =
715 HwasanMemmove =
M.getOrInsertFunction(
716 MemIntrinCallbackPrefix +
"memmove" + MatchAllStr, HwasanMemTransferFnTy);
717 HwasanMemcpy =
M.getOrInsertFunction(
718 MemIntrinCallbackPrefix +
"memcpy" + MatchAllStr, HwasanMemTransferFnTy);
719 HwasanMemset =
M.getOrInsertFunction(
720 MemIntrinCallbackPrefix +
"memset" + MatchAllStr, HwasanMemsetFnTy);
722 HwasanTagMemoryFunc =
M.getOrInsertFunction(
"__hwasan_tag_memory", VoidTy,
723 PtrTy, Int8Ty, IntptrTy);
724 HwasanGenerateTagFunc =
725 M.getOrInsertFunction(
"__hwasan_generate_tag", Int8Ty);
727 HwasanRecordFrameRecordFunc =
728 M.getOrInsertFunction(
"__hwasan_add_frame_record", VoidTy, Int64Ty);
734 M.getOrInsertFunction(
"__hwasan_handle_vfork", VoidTy, IntptrTy);
746 return IRB.
CreateCall(Asm, {Val},
".hwasan.shadow");
750 return getOpaqueNoopCast(IRB, ShadowGlobal);
755 return getOpaqueNoopCast(
757 ConstantInt::get(IntptrTy, Mapping.Offset), PtrTy));
759 if (Mapping.InGlobal)
760 return getDynamicShadowIfunc(IRB);
762 Value *GlobalDynamicAddress =
765 return IRB.
CreateLoad(PtrTy, GlobalDynamicAddress);
771 Type *PtrTy = cast<PointerType>(
Ptr->getType()->getScalarType());
779 if (
Ptr->isSwiftError())
783 if (!InstrumentStack)
790 if (!InstrumentGlobals)
798void HWAddressSanitizer::getInterestingMemoryOperands(
802 if (
I->hasMetadata(LLVMContext::MD_nosanitize))
809 if (
LoadInst *LI = dyn_cast<LoadInst>(
I)) {
812 Interesting.
emplace_back(
I, LI->getPointerOperandIndex(),
false,
813 LI->getType(), LI->getAlign());
814 }
else if (
StoreInst *SI = dyn_cast<StoreInst>(
I)) {
818 SI->getValueOperand()->getType(),
SI->getAlign());
822 Interesting.
emplace_back(
I, RMW->getPointerOperandIndex(),
true,
823 RMW->getValOperand()->getType(), std::nullopt);
827 Interesting.
emplace_back(
I, XCHG->getPointerOperandIndex(),
true,
828 XCHG->getCompareOperand()->getType(),
830 }
else if (
auto *CI = dyn_cast<CallInst>(
I)) {
831 for (
unsigned ArgNo = 0; ArgNo < CI->arg_size(); ArgNo++) {
833 ignoreAccess(
I, CI->getArgOperand(ArgNo)))
835 Type *Ty = CI->getParamByValType(ArgNo);
843 if (
LoadInst *LI = dyn_cast<LoadInst>(
I))
844 return LI->getPointerOperandIndex();
846 return SI->getPointerOperandIndex();
848 return RMW->getPointerOperandIndex();
850 return XCHG->getPointerOperandIndex();
876 if (Mapping.Offset == 0)
882int64_t HWAddressSanitizer::getAccessInfo(
bool IsWrite,
883 unsigned AccessSizeIndex) {
892HWAddressSanitizer::ShadowTagCheckInfo
895 ShadowTagCheckInfo
R;
902 R.AddrLong = untagPointer(IRB,
R.PtrLong);
903 Value *Shadow = memToShadow(
R.AddrLong, IRB);
907 if (MatchAllTag.has_value()) {
909 R.PtrTag, ConstantInt::get(
R.PtrTag->getType(), *MatchAllTag));
910 TagMismatch = IRB.
CreateAnd(TagMismatch, TagNotIgnored);
914 TagMismatch, InsertBefore,
false,
920void HWAddressSanitizer::instrumentMemAccessOutline(
Value *
Ptr,
bool IsWrite,
921 unsigned AccessSizeIndex,
926 const int64_t AccessInfo = getAccessInfo(IsWrite, AccessSizeIndex);
930 insertShadowTagCheck(
Ptr, InsertBefore, DTU, LI).TagMismatchTerm;
934 bool useFixedShadowIntrinsic =
false;
943 uint16_t offset_shifted = Mapping.Offset >> 32;
944 useFixedShadowIntrinsic = (
uint64_t)offset_shifted << 32 == Mapping.Offset;
947 if (useFixedShadowIntrinsic)
951 ? Intrinsic::hwasan_check_memaccess_shortgranules_fixedshadow
952 : Intrinsic::hwasan_check_memaccess_fixedshadow),
954 ConstantInt::get(Int64Ty, Mapping.Offset)});
958 ? Intrinsic::hwasan_check_memaccess_shortgranules
959 : Intrinsic::hwasan_check_memaccess),
960 {ShadowBase,
Ptr, ConstantInt::get(
Int32Ty, AccessInfo)});
963void HWAddressSanitizer::instrumentMemAccessInline(
Value *
Ptr,
bool IsWrite,
964 unsigned AccessSizeIndex,
969 const int64_t AccessInfo = getAccessInfo(IsWrite, AccessSizeIndex);
971 ShadowTagCheckInfo TCI = insertShadowTagCheck(
Ptr, InsertBefore, DTU, LI);
974 Value *OutOfShortGranuleTagRange =
977 OutOfShortGranuleTagRange, TCI.TagMismatchTerm, !Recover,
983 PtrLowBits, ConstantInt::get(Int8Ty, (1 << AccessSizeIndex) - 1));
1000 switch (TargetTriple.
getArch()) {
1024 "ebreak\naddiw x0, x11, " +
1034 cast<BranchInst>(CheckFailTerm)
1043 if (isa<MemSetInst>(
MI))
1048void HWAddressSanitizer::instrumentMemIntrinsic(
MemIntrinsic *
MI) {
1050 if (isa<MemTransferInst>(
MI)) {
1052 MI->getOperand(0),
MI->getOperand(1),
1055 if (UseMatchAllCallback)
1056 Args.emplace_back(ConstantInt::get(Int8Ty, *MatchAllTag));
1057 IRB.
CreateCall(isa<MemMoveInst>(
MI) ? HwasanMemmove : HwasanMemcpy, Args);
1058 }
else if (isa<MemSetInst>(
MI)) {
1063 if (UseMatchAllCallback)
1064 Args.emplace_back(ConstantInt::get(Int8Ty, *MatchAllTag));
1067 MI->eraseFromParent();
1081 if (!
O.TypeStoreSize.isScalable() &&
isPowerOf2_64(
O.TypeStoreSize) &&
1083 (!
O.Alignment || *
O.Alignment >= Mapping.getObjectAlignment() ||
1084 *
O.Alignment >=
O.TypeStoreSize / 8)) {
1086 if (InstrumentWithCalls) {
1088 if (UseMatchAllCallback)
1089 Args.emplace_back(ConstantInt::get(Int8Ty, *MatchAllTag));
1090 IRB.
CreateCall(HwasanMemoryAccessCallback[
O.IsWrite][AccessSizeIndex],
1092 }
else if (OutlinedChecks) {
1093 instrumentMemAccessOutline(
Addr,
O.IsWrite, AccessSizeIndex,
O.getInsn(),
1096 instrumentMemAccessInline(
Addr,
O.IsWrite, AccessSizeIndex,
O.getInsn(),
1103 ConstantInt::get(IntptrTy, 8))};
1104 if (UseMatchAllCallback)
1105 Args.emplace_back(ConstantInt::get(Int8Ty, *MatchAllTag));
1106 IRB.
CreateCall(HwasanMemoryAccessCallbackSized[
O.IsWrite], Args);
1108 untagPointerOperand(
O.getInsn(),
Addr);
1115 size_t AlignedSize =
alignTo(
Size, Mapping.getObjectAlignment());
1116 if (!UseShortGranules)
1120 if (InstrumentWithCalls) {
1123 ConstantInt::get(IntptrTy, AlignedSize)});
1125 size_t ShadowSize =
Size >> Mapping.Scale;
1127 Value *ShadowPtr = memToShadow(AddrLong, IRB);
1136 if (
Size != AlignedSize) {
1137 const uint8_t SizeRemainder =
Size % Mapping.getObjectAlignment().value();
1138 IRB.
CreateStore(ConstantInt::get(Int8Ty, SizeRemainder),
1147unsigned HWAddressSanitizer::retagMask(
unsigned AllocaNo) {
1149 return AllocaNo & TagMaskByte;
1161 static const unsigned FastMasks[] = {
1162 0, 128, 64, 192, 32, 96, 224, 112, 240, 48, 16, 120,
1163 248, 56, 24, 8, 124, 252, 60, 28, 12, 4, 126, 254,
1164 62, 30, 14, 6, 2, 127, 63, 31, 15, 7, 3, 1};
1165 return FastMasks[AllocaNo % std::size(FastMasks)];
1169 if (TagMaskByte == 0xFF)
1172 ConstantInt::get(OldTag->
getType(), TagMaskByte));
1183 return StackBaseTag;
1187 Value *FramePointerLong = getCachedFP(IRB);
1189 applyTagMask(IRB, IRB.
CreateXor(FramePointerLong,
1191 StackTag->
setName(
"hwasan.stack.base.tag");
1196 unsigned AllocaNo) {
1198 return getNextTagWithCall(IRB);
1200 StackTag, ConstantInt::get(StackTag->
getType(), retagMask(AllocaNo)));
1204 Value *FramePointerLong = getCachedFP(IRB);
1206 applyTagMask(IRB, IRB.
CreateLShr(FramePointerLong, PointerTagShift));
1208 UARTag->
setName(
"hwasan.uar.tag");
1216 Value *TaggedPtrLong;
1217 if (CompileKernel) {
1221 ConstantInt::get(IntptrTy, (1ULL << PointerTagShift) - 1));
1222 TaggedPtrLong = IRB.
CreateAnd(PtrLong, ShiftedTag);
1226 TaggedPtrLong = IRB.
CreateOr(PtrLong, ShiftedTag);
1234 Value *UntaggedPtrLong;
1235 if (CompileKernel) {
1239 TagMaskByte << PointerTagShift));
1243 PtrLong, ConstantInt::get(PtrLong->
getType(),
1244 ~(TagMaskByte << PointerTagShift)));
1246 return UntaggedPtrLong;
1252 constexpr int SanitizerSlot = 6;
1255 return ThreadPtrGlobal;
1282void HWAddressSanitizer::emitPrologue(
IRBuilder<> &IRB,
bool WithFrameRecord) {
1284 ShadowBase = getShadowNonTls(IRB);
1285 else if (!WithFrameRecord && TargetTriple.
isAndroid())
1286 ShadowBase = getDynamicShadowIfunc(IRB);
1288 if (!WithFrameRecord && ShadowBase)
1291 Value *SlotPtr =
nullptr;
1292 Value *ThreadLong =
nullptr;
1293 Value *ThreadLongMaybeUntagged =
nullptr;
1295 auto getThreadLongMaybeUntagged = [&]() {
1297 SlotPtr = getHwasanThreadSlotPtr(IRB);
1299 ThreadLong = IRB.
CreateLoad(IntptrTy, SlotPtr);
1302 return TargetTriple.
isAArch64() ? ThreadLong
1303 : untagPointer(IRB, ThreadLong);
1306 if (WithFrameRecord) {
1311 Value *FrameRecordInfo = getFrameRecordInfo(IRB);
1312 IRB.
CreateCall(HwasanRecordFrameRecordFunc, {FrameRecordInfo});
1316 ThreadLongMaybeUntagged = getThreadLongMaybeUntagged();
1318 StackBaseTag = IRB.
CreateAShr(ThreadLong, 3);
1321 Value *FrameRecordInfo = getFrameRecordInfo(IRB);
1351 ConstantInt::get(IntptrTy, (
uint64_t)-1));
1353 IRB.
CreateAdd(ThreadLong, ConstantInt::get(IntptrTy, 8)), WrapMask);
1359 "A stack history recording mode should've been selected.");
1365 if (!ThreadLongMaybeUntagged)
1366 ThreadLongMaybeUntagged = getThreadLongMaybeUntagged();
1373 ThreadLongMaybeUntagged,
1375 ConstantInt::get(IntptrTy, 1),
"hwasan.shadow");
1380bool HWAddressSanitizer::instrumentLandingPads(
1382 for (
auto *LP : LandingPadVec) {
1383 IRBuilder<> IRB(LP->getNextNonDebugInstruction());
1406 auto *AI = KV.first;
1411 Value *
Tag = getAllocaTag(IRB, StackTag,
N);
1413 Value *AINoTagLong = untagPointer(IRB, AILong);
1414 Value *Replacement = tagPointer(IRB, AI->
getType(), AINoTagLong,
Tag);
1420 size_t AlignedSize =
alignTo(
Size, Mapping.getObjectAlignment());
1435 II->setArgOperand(0, ConstantInt::get(Int64Ty, AlignedSize));
1436 II->setArgOperand(1, AICast);
1442 auto *
User =
U.getUser();
1443 return User != AILong &&
User != AICast &&
1455 tagAlloca(IRB, AI, UARTag, AlignedSize);
1461 bool StandardLifetime =
1466 if (DetectUseAfterScope && StandardLifetime) {
1469 tagAlloca(IRB, AI,
Tag,
Size);
1472 for (
auto *
End :
Info.LifetimeEnd)
1473 End->eraseFromParent();
1476 tagAlloca(IRB, AI,
Tag,
Size);
1477 for (
auto *RI : SInfo.
RetVec)
1481 for (
auto &II :
Info.LifetimeStart)
1482 II->eraseFromParent();
1483 for (
auto &II :
Info.LifetimeEnd)
1484 II->eraseFromParent();
1489 I->eraseFromParent();
1498 <<
"Skipped: F=" <<
ore::NV(
"Function", &
F);
1503 <<
"Sanitized: F=" <<
ore::NV(
"Function", &
F);
1508bool HWAddressSanitizer::selectiveInstrumentationShouldSkip(
1520 if (!PSI || !PSI->hasProfileSummary()) {
1521 ++NumNoProfileSummaryFuncs;
1524 return PSI->isFunctionHotInCallGraphNthPercentile(
1531void HWAddressSanitizer::sanitizeFunction(
Function &
F,
1533 if (&
F == HwasanCtorFunction)
1536 if (!
F.hasFnAttribute(Attribute::SanitizeHWAddress))
1544 if (selectiveInstrumentationShouldSkip(
F,
FAM))
1547 NumInstrumentedFuncs++;
1558 if (InstrumentStack) {
1562 if (InstrumentLandingPads && isa<LandingPadInst>(Inst))
1565 getInterestingMemoryOperands(&Inst, TLI, OperandsToInstrument);
1568 if (!ignoreMemIntrinsic(
MI))
1574 initializeCallbacks(*
F.getParent());
1576 if (!LandingPadVec.
empty())
1577 instrumentLandingPads(LandingPadVec);
1583 F.setPersonalityFn(
nullptr);
1587 IntrinToInstrument.
empty())
1594 emitPrologue(EntryIRB,
1596 Mapping.WithFrameRecord &&
1603 Value *StackTag = getStackBaseTag(EntryIRB);
1604 Value *UARTag = getUARTag(EntryIRB);
1605 instrumentStack(SInfo, StackTag, UARTag, DT, PDT, LI);
1611 if (EntryIRB.GetInsertBlock() != &
F.getEntryBlock()) {
1612 InsertPt =
F.getEntryBlock().begin();
1615 if (
auto *AI = dyn_cast<AllocaInst>(&
I))
1617 I.moveBefore(
F.getEntryBlock(), InsertPt);
1625 for (
auto &Operand : OperandsToInstrument)
1626 instrumentMemAccess(Operand, DTU, LI);
1630 for (
auto *Inst : IntrinToInstrument)
1631 instrumentMemIntrinsic(Inst);
1634 ShadowBase =
nullptr;
1635 StackBaseTag =
nullptr;
1643 M.getDataLayout().getTypeAllocSize(Initializer->
getType());
1644 uint64_t NewSize =
alignTo(SizeInBytes, Mapping.getObjectAlignment());
1645 if (SizeInBytes != NewSize) {
1648 std::vector<uint8_t>
Init(NewSize - SizeInBytes, 0);
1657 NewGV->copyAttributesFrom(GV);
1659 NewGV->copyMetadata(GV, 0);
1660 NewGV->setAlignment(
1680 const uint64_t MaxDescriptorSize = 0xfffff0;
1681 for (
uint64_t DescriptorPos = 0; DescriptorPos < SizeInBytes;
1682 DescriptorPos += MaxDescriptorSize) {
1685 nullptr, GV->
getName() +
".hwasan.descriptor");
1691 ConstantInt::get(Int64Ty, DescriptorPos)),
1693 uint32_t Size = std::min(SizeInBytes - DescriptorPos, MaxDescriptorSize);
1695 Descriptor->setComdat(NewGV->getComdat());
1697 Descriptor->setSection(
"hwasan_globals");
1698 Descriptor->setMetadata(LLVMContext::MD_associated,
1706 ConstantInt::get(Int64Ty,
uint64_t(
Tag) << PointerTagShift)),
1711 Alias->takeName(GV);
1716void HWAddressSanitizer::instrumentGlobals() {
1717 std::vector<GlobalVariable *> Globals;
1736 Globals.push_back(&GV);
1740 Hasher.
update(
M.getSourceFileName());
1743 uint8_t
Tag = Hash[0];
1745 assert(TagMaskByte >= 16);
1751 if (Tag < 16 || Tag > TagMaskByte)
1753 instrumentGlobal(GV,
Tag++);
1757void HWAddressSanitizer::instrumentPersonalityFunctions() {
1766 if (
F.isDeclaration() || !
F.hasFnAttribute(Attribute::SanitizeHWAddress))
1769 if (
F.hasPersonalityFn()) {
1770 PersonalityFns[
F.getPersonalityFn()->stripPointerCasts()].push_back(&
F);
1771 }
else if (!
F.hasFnAttribute(Attribute::NoUnwind)) {
1772 PersonalityFns[
nullptr].push_back(&
F);
1776 if (PersonalityFns.
empty())
1781 PtrTy, PtrTy, PtrTy, PtrTy);
1782 FunctionCallee UnwindGetGR =
M.getOrInsertFunction(
"_Unwind_GetGR", VoidTy);
1783 FunctionCallee UnwindGetCFA =
M.getOrInsertFunction(
"_Unwind_GetCFA", VoidTy);
1785 for (
auto &
P : PersonalityFns) {
1788 ThunkName += (
"." +
P.first->getName()).str();
1791 bool IsLocal =
P.first && (!isa<GlobalValue>(
P.first) ||
1792 cast<GlobalValue>(
P.first)->hasLocalLinkage());
1799 ThunkFn->setComdat(
M.getOrInsertComdat(ThunkName));
1805 HwasanPersonalityWrapper,
1806 {ThunkFn->getArg(0), ThunkFn->getArg(1), ThunkFn->getArg(2),
1807 ThunkFn->getArg(3), ThunkFn->getArg(4),
1814 F->setPersonalityFn(ThunkFn);
1818void HWAddressSanitizer::ShadowMapping::init(
Triple &TargetTriple,
1819 bool InstrumentWithCalls) {
1827 WithFrameRecord =
true;
1832 WithFrameRecord =
false;
1837 WithFrameRecord =
false;
1842 WithFrameRecord =
false;
1847 WithFrameRecord =
true;
1852 WithFrameRecord =
false;
static cl::opt< size_t > ClMaxLifetimes("stack-tagging-max-lifetimes-for-alloca", cl::Hidden, cl::init(3), cl::ReallyHidden, cl::desc("How many lifetime ends to handle for a single alloca."), cl::Optional)
static const uint64_t kDefaultShadowScale
static cl::opt< std::string > ClMemoryAccessCallbackPrefix("asan-memory-access-callback-prefix", cl::desc("Prefix for memory access callbacks"), cl::Hidden, cl::init("__asan_"))
static cl::opt< bool > ClInstrumentWrites("asan-instrument-writes", cl::desc("instrument write instructions"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInstrumentByval("asan-instrument-byval", cl::desc("instrument byval call arguments"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClGlobals("asan-globals", cl::desc("Handle global objects"), cl::Hidden, cl::init(true))
static const uint64_t kDynamicShadowSentinel
static cl::opt< bool > ClInstrumentAtomics("asan-instrument-atomics", cl::desc("instrument atomic instructions (rmw, cmpxchg)"), cl::Hidden, cl::init(true))
static const size_t kNumberOfAccessSizes
static cl::opt< bool > ClInstrumentReads("asan-instrument-reads", cl::desc("instrument read instructions"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClWithIfunc("asan-with-ifunc", cl::desc("Access dynamic shadow through an ifunc global on " "platforms that support this"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClKasanMemIntrinCallbackPrefix("asan-kernel-mem-intrinsic-prefix", cl::desc("Use prefix for memory intrinsics in KASAN mode"), cl::Hidden, cl::init(false))
static cl::opt< uint64_t > ClMappingOffset("asan-mapping-offset", cl::desc("offset of asan shadow mapping [EXPERIMENTAL]"), cl::Hidden, cl::init(0))
Expand Atomic instructions
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
Analysis containing CSE Info
#define clEnumVal(ENUMVAL, DESC)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file contains constants used for implementing Dwarf debug support.
std::optional< std::vector< StOtherPiece > > Other
This is the interface for a simple mod/ref and alias analysis over globals.
static cl::opt< float > ClRandomSkipRate("hwasan-random-rate", cl::desc("Probability value in the range [0.0, 1.0] " "to keep instrumentation of a function."))
static size_t TypeSizeToSizeIndex(uint32_t TypeSize)
static cl::opt< bool > ClInstrumentWrites("hwasan-instrument-writes", cl::desc("instrument write instructions"), cl::Hidden, cl::init(true))
static const size_t kDefaultShadowScale
static cl::opt< RecordStackHistoryMode > ClRecordStackHistory("hwasan-record-stack-history", cl::desc("Record stack frames with tagged allocations in a thread-local " "ring buffer"), cl::values(clEnumVal(none, "Do not record stack ring history"), clEnumVal(instr, "Insert instructions into the prologue for " "storing into the stack ring buffer directly"), clEnumVal(libcall, "Add a call to __hwasan_add_frame_record for " "storing into the stack ring buffer")), cl::Hidden, cl::init(instr))
const char kHwasanModuleCtorName[]
static cl::opt< int > ClMatchAllTag("hwasan-match-all-tag", cl::desc("don't report bad accesses via pointers with this tag"), cl::Hidden, cl::init(-1))
static cl::opt< bool > ClUseAfterScope("hwasan-use-after-scope", cl::desc("detect use after scope within function"), cl::Hidden, cl::init(true))
const char kHwasanNoteName[]
static cl::opt< int > ClHotPercentileCutoff("hwasan-percentile-cutoff-hot", cl::desc("Hot percentile cuttoff."))
static const unsigned kShadowBaseAlignment
static cl::opt< bool > ClGenerateTagsWithCalls("hwasan-generate-tags-with-calls", cl::desc("generate new tags with runtime library calls"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInstrumentReads("hwasan-instrument-reads", cl::desc("instrument read instructions"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInstrumentWithCalls("hwasan-instrument-with-calls", cl::desc("instrument reads and writes with callbacks"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClUseStackSafety("hwasan-use-stack-safety", cl::Hidden, cl::init(true), cl::Hidden, cl::desc("Use Stack Safety analysis results"), cl::Optional)
static cl::opt< bool > ClInstrumentAtomics("hwasan-instrument-atomics", cl::desc("instrument atomic instructions (rmw, cmpxchg)"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClInstrumentStack("hwasan-instrument-stack", cl::desc("instrument stack (allocas)"), cl::Hidden, cl::init(true))
static cl::opt< uint64_t > ClMappingOffset("hwasan-mapping-offset", cl::desc("HWASan shadow mapping offset [EXPERIMENTAL]"), cl::Hidden, cl::init(0))
static cl::opt< bool > ClRecover("hwasan-recover", cl::desc("Enable recovery mode (continue-after-error)."), cl::Hidden, cl::init(false))
static cl::opt< bool > ClEnableKhwasan("hwasan-kernel", cl::desc("Enable KernelHWAddressSanitizer instrumentation"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInlineAllChecks("hwasan-inline-all-checks", cl::desc("inline all checks"), cl::Hidden, cl::init(false))
static const uint64_t kDynamicShadowSentinel
static cl::opt< bool > ClUsePageAliases("hwasan-experimental-use-page-aliases", cl::desc("Use page aliasing in HWASan"), cl::Hidden, cl::init(false))
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 > ClInstrumentMemIntrinsics("hwasan-instrument-mem-intrinsics", cl::desc("instrument memory intrinsics"), cl::Hidden, cl::init(true))
static const size_t kNumberOfAccessSizes
static cl::opt< bool > ClWithTls("hwasan-with-tls", cl::desc("Access dynamic shadow through an thread-local pointer on " "platforms that support this"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClGlobals("hwasan-globals", cl::desc("Instrument globals"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClKasanMemIntrinCallbackPrefix("hwasan-kernel-mem-intrinsic-prefix", cl::desc("Use prefix for memory intrinsics in KASAN mode"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInstrumentByval("hwasan-instrument-byval", cl::desc("instrument byval arguments"), cl::Hidden, cl::init(true))
static cl::opt< bool > ClUseShortGranules("hwasan-use-short-granules", cl::desc("use short granules in allocas and outlined checks"), cl::Hidden, cl::init(false))
const char kHwasanShadowMemoryDynamicAddress[]
static unsigned getPointerOperandIndex(Instruction *I)
static cl::opt< bool > ClInlineFastPathChecks("hwasan-inline-fast-path-checks", cl::desc("inline all checks"), cl::Hidden, cl::init(false))
static cl::opt< bool > ClInstrumentPersonalityFunctions("hwasan-instrument-personality-functions", cl::desc("instrument personality functions"), cl::Hidden)
const char kHwasanInitName[]
static cl::opt< bool > ClInstrumentLandingPads("hwasan-instrument-landing-pads", cl::desc("instrument landing pads"), cl::Hidden, cl::init(false))
static cl::opt< size_t > ClMaxLifetimes("hwasan-max-lifetimes-for-alloca", cl::Hidden, cl::init(3), cl::ReallyHidden, cl::desc("How many lifetime ends to handle for a single alloca."), cl::Optional)
const char kHwasanPersonalityThunkName[]
static cl::opt< bool > ClWithIfunc("hwasan-with-ifunc", cl::desc("Access dynamic shadow through an ifunc global on " "platforms that support this"), cl::Hidden, cl::init(false))
static void emitRemark(const Function &F, OptimizationRemarkEmitter &ORE, bool Skip)
This file implements a map that provides insertion order iteration.
Module.h This file contains the declarations for the Module class.
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
an instruction to allocate memory on the stack
PointerType * getType() const
Overload to return most specific pointer type.
const Value * getArraySize() const
Get the number of elements allocated.
A container for analyses that lazily runs them and caches their results.
PassT::Result * getCachedResult(IRUnitT &IR) const
Get the cached result of an analysis pass for a given IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
static ArrayType * get(Type *ElementType, uint64_t NumElements)
This static method is the primary way to construct an ArrayType.
An instruction that atomically checks whether a specified value is in a memory location,...
an instruction that atomically reads a memory location, combines it with another value,...
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
const Function * getParent() const
Return the enclosing method, or null if none.
InstListType::iterator iterator
Instruction iterators...
Analysis pass which computes BlockFrequencyInfo.
This class represents a function call, abstracting a target machine's calling convention.
void setTailCall(bool IsTc=true)
static Constant * get(LLVMContext &Context, ArrayRef< ElementTy > Elts)
get() constructor - Return a constant with array type with an element count and element type matching...
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getPtrToInt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
static Constant * getAnon(ArrayRef< Constant * > V, bool Packed=false)
Return an anonymous struct that has the specified elements.
This is an important base class in LLVM.
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
void flush()
Apply all pending updates to available trees and flush all BasicBlocks awaiting deletion.
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
static GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
MaybeAlign getAlign() const
Returns the alignment of the given variable or function.
void setComdat(Comdat *C)
bool hasSection() const
Check if this global has a custom object file section.
const SanitizerMetadata & getSanitizerMetadata() const
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
VisibilityTypes getVisibility() const
LinkageTypes getLinkage() const
bool isDeclarationForLinker() const
bool hasSanitizerMetadata() const
unsigned getAddressSpace() const
Module * getParent()
Get the module that this global value is contained inside of...
PointerType * getType() const
Global values are always pointers.
@ HiddenVisibility
The GV is hidden.
bool hasCommonLinkage() const
@ PrivateLinkage
Like Internal, but omit from symbol table.
@ InternalLinkage
Rename collisions when linking (static functions).
@ ExternalLinkage
Externally visible function.
@ LinkOnceODRLinkage
Same, but only replaced by something equivalent.
Type * getValueType() const
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Analysis pass providing a never-invalidated alias analysis result.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM)
void printPipeline(raw_ostream &OS, function_ref< StringRef(StringRef)> MapClassName2PassName)
Value * CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0, const Twine &Name="")
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", bool IsInBounds=false)
Value * CreatePointerCast(Value *V, Type *DestTy, const Twine &Name="")
CallInst * CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, MaybeAlign Align, bool isVolatile=false, MDNode *TBAATag=nullptr, MDNode *ScopeTag=nullptr, MDNode *NoAliasTag=nullptr)
Create and insert a memset to the specified pointer and the specified value.
Value * CreateIntToPtr(Value *V, Type *DestTy, const Twine &Name="")
Value * CreateTypeSize(Type *DstType, TypeSize Size)
Create an expression which evaluates to the number of units in Size at runtime.
Value * CreateLShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
IntegerType * getInt32Ty()
Fetch the type representing a 32-bit integer.
ReturnInst * CreateRet(Value *V)
Create a 'ret <val>' instruction.
BasicBlock * GetInsertBlock() const
Value * CreateUDiv(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name="")
LoadInst * CreateLoad(Type *Ty, Value *Ptr, const char *Name)
Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of converting the string to 'bool...
Value * CreateShl(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateZExt(Value *V, Type *DestTy, const Twine &Name="", bool IsNonNeg=false)
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
StoreInst * CreateStore(Value *Val, Value *Ptr, bool isVolatile=false)
Value * CreateAdd(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Value * CreateTrunc(Value *V, Type *DestTy, const Twine &Name="", bool IsNUW=false, bool IsNSW=false)
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
PointerType * getPtrTy(unsigned AddrSpace=0)
Fetch the type representing a pointer.
Value * CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name="")
Value * CreateIntCast(Value *V, Type *DestTy, bool isSigned, const Twine &Name="")
void SetInsertPoint(BasicBlock *TheBB)
This specifies that created instructions should be appended to the end of the specified block.
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=std::nullopt, const Twine &Name="", MDNode *FPMathTag=nullptr)
Value * CreateAShr(Value *LHS, Value *RHS, const Twine &Name="", bool isExact=false)
Value * CreateXor(Value *LHS, Value *RHS, const Twine &Name="")
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
static InlineAsm * get(FunctionType *Ty, StringRef AsmString, StringRef Constraints, bool hasSideEffects, bool isAlignStack=false, AsmDialect asmDialect=AD_ATT, bool canThrow=false)
InlineAsm::get - Return the specified uniqued inline asm string.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
const BasicBlock * getParent() const
const Instruction * getNextNonDebugInstruction(bool SkipPseudoOp=false) const
Return a pointer to the next non-debug instruction in the same basic block as 'this',...
void setSuccessor(unsigned Idx, BasicBlock *BB)
Update the specified successor to point at the provided block.
A wrapper class for inspecting calls to intrinsic functions.
This is an important class for using LLVM in a threaded context.
An instruction for reading from memory.
Analysis pass that exposes the LoopInfo for a function.
void update(ArrayRef< uint8_t > Data)
Updates the hash for the byte stream provided.
void final(MD5Result &Result)
Finishes off the hash and puts the result in result.
MDNode * createUnlikelyBranchWeights()
Return metadata containing two branch weights, with significant bias towards false destination.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
This class implements a map that also provides access to all stored values in a deterministic order.
This is the common base class for memset/memcpy/memmove.
This class wraps the llvm.memcpy/memmove intrinsics.
A Module instance is used to store all the information related to an LLVM module.
Constant * getOrInsertGlobal(StringRef Name, Type *Ty, function_ref< GlobalVariable *()> CreateGlobalCallback)
Look up the specified global in the module symbol table.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
Analysis pass which computes a PostDominatorTree.
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
void abandon()
Mark an analysis as abandoned.
void preserve()
Mark an analysis as preserved.
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
Analysis providing profile information.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This pass performs the global (interprocedural) stack safety analysis (new pass manager).
bool stackAccessIsSafe(const Instruction &I) const
An instruction for storing to memory.
StringRef - Represent a constant reference to a string, i.e.
std::string str() const
str - Get the contents as an std::string.
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
static StructType * get(LLVMContext &Context, ArrayRef< Type * > Elements, bool isPacked=false)
This static method is the primary way to create a literal StructType.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
Triple - Helper class for working with autoconf configuration names.
bool isAndroidVersionLT(unsigned Major) const
bool isAndroid() const
Tests whether the target is Android.
ArchType getArch() const
Get the parsed architecture type of this triple.
bool isRISCV64() const
Tests whether the target is 64-bit RISC-V.
bool isAArch64() const
Tests whether the target is AArch64 (little and big endian).
bool isOSBinFormatELF() const
Tests whether the OS uses the ELF binary format.
The instances of the Type class are immutable: once they are created, they are never changed.
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
static Type * getVoidTy(LLVMContext &C)
static IntegerType * getInt8Ty(LLVMContext &C)
static IntegerType * getInt32Ty(LLVMContext &C)
static IntegerType * getInt64Ty(LLVMContext &C)
A Use represents the edge between a Value definition and its users.
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
void setName(const Twine &Name)
Change the name of the value.
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
void replaceUsesWithIf(Value *New, llvm::function_ref< bool(Use &U)> ShouldReplace)
Go through the uses list for this definition and make each use point to "V" if the callback ShouldRep...
StringRef getName() const
Return a constant reference to the value's name.
int getNumOccurrences() const
An efficient, type-erasing, non-owning reference to a callable.
This class implements an extremely fast bulk output stream that can only output to a stream.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
@ C
The default llvm calling convention, compatible with C.
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=std::nullopt)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
initializer< Ty > init(const Ty &Val)
Value * getFP(IRBuilder<> &IRB)
bool isStandardLifetime(const SmallVectorImpl< IntrinsicInst * > &LifetimeStart, const SmallVectorImpl< IntrinsicInst * > &LifetimeEnd, const DominatorTree *DT, const LoopInfo *LI, size_t MaxLifetimes)
bool forAllReachableExits(const DominatorTree &DT, const PostDominatorTree &PDT, const LoopInfo &LI, const Instruction *Start, const SmallVectorImpl< IntrinsicInst * > &Ends, const SmallVectorImpl< Instruction * > &RetVec, llvm::function_ref< void(Instruction *)> Callback)
uint64_t getAllocaSizeInBytes(const AllocaInst &AI)
Value * getAndroidSlotPtr(IRBuilder<> &IRB, int Slot)
Value * readRegister(IRBuilder<> &IRB, StringRef Name)
void annotateDebugRecords(AllocaInfo &Info, unsigned int Tag)
void alignAndPadAlloca(memtag::AllocaInfo &Info, llvm::Align Align)
Value * getPC(const Triple &TargetTriple, IRBuilder<> &IRB)
bool isLifetimeIntrinsic(Value *V)
DiagnosticInfoOptimizationBase::Argument NV
This is an optimization pass for GlobalISel generic memory operations.
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
AllocaInst * findAllocaForValue(Value *V, bool OffsetZero=false)
Returns unique alloca where the value comes from, or nullptr.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
constexpr bool isPowerOf2_64(uint64_t Value)
Return true if the argument is a power of two > 0 (64 bit edition.)
int countr_zero(T Val)
Count number of 0's from the least significant bit to the most stopping at the first 1.
std::pair< Function *, FunctionCallee > getOrCreateSanitizerCtorAndInitFunctions(Module &M, StringRef CtorName, StringRef InitName, ArrayRef< Type * > InitArgTypes, ArrayRef< Value * > InitArgs, function_ref< void(Function *, FunctionCallee)> FunctionsCreatedCallback, StringRef VersionCheckName=StringRef(), bool Weak=false)
Creates sanitizer constructor function lazily.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
void appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data=nullptr)
Append F to the list of global ctors of module M with the given Priority.
Instruction * SplitBlockAndInsertIfThen(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)
Split the containing block at the specified instruction - everything before SplitBefore stays in the ...
void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, const TargetLibraryInfo *TLI)
Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if...
This struct is a compact representation of a valid (non-zero power of two) alignment.
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
A CRTP mix-in to automatically provide informational APIs needed for passes.
MapVector< AllocaInst *, AllocaInfo > AllocasToInstrument
SmallVector< Instruction *, 4 > UnrecognizedLifetimes
SmallVector< Instruction *, 8 > RetVec