Skip to content

S
swiftshader
Commit 1fd80c72 by Thomas Lively
Options

Instrumented local variables and implemented runtime.

BUG=https://bugs.chromium.org/p/nativeclient/issues/detail?id=4374 R=kschimpf@google.com Review URL: https://codereview.chromium.org/2095763002 .
parent 9dd397d3
Showing with 331 additions and 113 deletions
runtime/szrt_asan.c
...@@ -16,48 +16,133 @@ ...@@ -16,48 +16,133 @@
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include <assert.h> #include <assert.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <sys/mman.h>
static __thread int behind_malloc = 0; #define RZ_SIZE (32)
#define SHADOW_SCALE_LOG2 (3)
#define SHADOW_SCALE ((size_t)1 << SHADOW_SCALE_LOG2)
// Assuming 48 bit address space on 64 bit systems
#define SHADOW_LENGTH_64 (1u << (48 - SHADOW_SCALE_LOG2))
#define SHADOW_LENGTH_32 (1u << (32 - SHADOW_SCALE_LOG2))
#define IS_32_BIT (sizeof(void *) == 4)
#define SHADOW_OFFSET(p) ((uintptr_t)(p) % SHADOW_SCALE)
#define IS_SHADOW_ALIGNED(p) (SHADOW_OFFSET(p) == 0)
#define MEM2SHADOW(p) (((uintptr_t)(p) >> SHADOW_SCALE_LOG2) + shadow_offset)
#define SHADOW2MEM(p) \
((uintptr_t)((char *)(p)-shadow_offset) << SHADOW_SCALE_LOG2)
#define POISON_VAL (-1)
static char *shadow_offset = NULL;
void __asan_init(void);
void __asan_check(char *, int);
void *__asan_malloc(size_t);
void __asan_free(char *);
void __asan_poison(char *, int);
void __asan_unpoison(char *, int);
// TODO(tlively): Define and implement this library
void __asan_init(void) { void __asan_init(void) {
if (behind_malloc == 0) // ensure the redzones are large enough to hold metadata
printf("set up shadow memory here\n"); assert(RZ_SIZE >= sizeof(void *) && RZ_SIZE >= sizeof(size_t));
assert(shadow_offset == NULL);
size_t length = (IS_32_BIT) ? SHADOW_LENGTH_32 : SHADOW_LENGTH_64;
int prot = PROT_READ | PROT_WRITE;
int flags = MAP_PRIVATE | MAP_ANONYMOUS;
int fd = -1;
off_t offset = 0;
shadow_offset = mmap((void *)length, length, prot, flags, fd, offset);
if (shadow_offset == NULL)
fprintf(stderr, "unable to allocate shadow memory\n");
else
printf("set up shadow memory at %p\n", shadow_offset);
if (mprotect(MEM2SHADOW(shadow_offset), length >> SHADOW_SCALE_LOG2,
PROT_NONE))
fprintf(stderr, "could not protect bad region\n");
else
printf("protected bad region\n");
} }
void __asan_check(void *addr, int size) { void __asan_check(char *ptr, int size) {
if (behind_malloc == 0) printf("check %d bytes at %p\n", size, ptr);
printf("check %d bytes at %p\n", size, addr); char *end = ptr + size;
for (; ptr < end; ++ptr) {
char shadow = *(char *)MEM2SHADOW(ptr);
printf("checking %p with shadow %d\n", ptr, shadow);
assert(shadow == 0 || (shadow > 0 && SHADOW_OFFSET(ptr) <= shadow));
}
} }
void *__asan_malloc(size_t size) { void *__asan_malloc(size_t size) {
if (behind_malloc == 0) printf("malloc() called with size %d\n", size);
printf("malloc() called with size %d\n", size); size_t padding =
++behind_malloc; (IS_SHADOW_ALIGNED(size)) ? 0 : SHADOW_SCALE - SHADOW_OFFSET(size);
void *ret = malloc(size); size_t rz_left_size = RZ_SIZE;
--behind_malloc; size_t rz_right_size = RZ_SIZE + padding;
assert(behind_malloc >= 0); void *rz_left;
int err = posix_memalign(&rz_left, SHADOW_SCALE,
rz_left_size + size + rz_right_size);
if (err != 0) {
assert(err == ENOMEM);
return NULL;
}
void *ret = rz_left + rz_left_size;
void *rz_right = ret + size;
__asan_poison(rz_left, rz_left_size);
__asan_poison(rz_right, rz_right_size);
// record size and location data so we can find it again
*(void **)rz_left = rz_right;
*(size_t *)rz_right = rz_right_size;
assert((uintptr_t)ret % 8 == 0);
return ret; return ret;
} }
void __asan_free(void *ptr) { void __asan_free(char *ptr) {
if (behind_malloc == 0) printf("free() called on %p\n", ptr);
printf("free() called on %p\n", ptr); void *rz_left = ptr - RZ_SIZE;
++behind_malloc; void *rz_right = *(void **)rz_left;
free(ptr); size_t rz_right_size = *(size_t *)rz_right;
--behind_malloc; __asan_unpoison(rz_left, RZ_SIZE);
assert(behind_malloc >= 0); __asan_unpoison(rz_right, rz_right_size);
free(rz_left);
} }
void __asan_alloca(void *ptr, int size) { void __asan_poison(char *ptr, int size) {
if (behind_malloc == 0) char *end = ptr + size;
printf("alloca of %d bytes at %p\n", size, ptr); assert(IS_SHADOW_ALIGNED(end));
// redzones should be no greater than RZ_SIZE + RZ_SIZE-1 for alignment
assert(size < 2 * RZ_SIZE);
printf("poison %d bytes at %p: %p - %p\n", size, ptr, MEM2SHADOW(ptr),
MEM2SHADOW(end));
size_t offset = SHADOW_OFFSET(ptr);
*(char *)MEM2SHADOW(ptr) = (offset == 0) ? POISON_VAL : offset;
ptr += SHADOW_OFFSET(size);
assert(IS_SHADOW_ALIGNED(ptr));
for (; ptr != end; ptr += SHADOW_SCALE) {
*(char *)MEM2SHADOW(ptr) = POISON_VAL;
}
} }
void __asan_unalloca(void *ptr, int size) { void __asan_unpoison(char *ptr, int size) {
if (behind_malloc == 0) char *end = ptr + size;
printf("unalloca of %d bytes as %p\n", size, ptr); assert(IS_SHADOW_ALIGNED(end));
assert(size < 2 * RZ_SIZE);
printf("unpoison %d bytes at %p: %p - %p\n", size, ptr, MEM2SHADOW(ptr),
MEM2SHADOW(end));
*(char *)MEM2SHADOW(ptr) = 0;
ptr += SHADOW_OFFSET(size);
assert(IS_SHADOW_ALIGNED(ptr));
for (; ptr != end; ptr += SHADOW_SCALE) {
*(char *)MEM2SHADOW(ptr) = 0;
}
} }
src/IceASanInstrumentation.cpp
...@@ -24,10 +24,12 @@ ...@@ -24,10 +24,12 @@
#include <sstream> #include <sstream>
#include <unordered_map> #include <unordered_map>
#include <vector>
namespace Ice { namespace Ice {
namespace { namespace {
constexpr SizeT RzSize = 32; constexpr SizeT RzSize = 32;
const std::string RzPrefix = "__$rz"; const std::string RzPrefix = "__$rz";
const llvm::NaClBitcodeRecord::RecordVector RzContents = const llvm::NaClBitcodeRecord::RecordVector RzContents =
...@@ -42,6 +44,9 @@ const string_map FuncSubstitutions = {{"malloc", "__asan_malloc"}, ...@@ -42,6 +44,9 @@ const string_map FuncSubstitutions = {{"malloc", "__asan_malloc"},
} // end of anonymous namespace } // end of anonymous namespace
ICE_TLS_DEFINE_FIELD(std::vector<InstCall *> *, ASanInstrumentation,
LocalDtors);
// Create redzones around all global variables, ensuring that the initializer // Create redzones around all global variables, ensuring that the initializer
// types of the redzones and their associated globals match so that they are // types of the redzones and their associated globals match so that they are
// laid out together in memory. // laid out together in memory.
...@@ -126,38 +131,95 @@ ASanInstrumentation::createRz(VariableDeclarationList *List, ...@@ -126,38 +131,95 @@ ASanInstrumentation::createRz(VariableDeclarationList *List,
// Check for an alloca signaling the presence of local variables and add a // Check for an alloca signaling the presence of local variables and add a
// redzone if it is found // redzone if it is found
void ASanInstrumentation::instrumentFuncStart(LoweringContext &Context) { void ASanInstrumentation::instrumentFuncStart(LoweringContext &Context) {
auto *FirstAlloca = llvm::dyn_cast<InstAlloca>(Context.getCur()); if (ICE_TLS_GET_FIELD(LocalDtors) == nullptr)
if (FirstAlloca == nullptr) ICE_TLS_SET_FIELD(LocalDtors, new std::vector<InstCall *>());
return;
constexpr SizeT Alignment = 4; Cfg *Func = Context.getNode()->getCfg();
InstAlloca *RzAlloca = createLocalRz(Context, RzSize, Alignment); bool HasLocals = false;
LoweringContext C;
C.init(Context.getNode());
std::vector<Inst *> Initializations;
Constant *InitFunc =
Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_poison"));
Constant *DestroyFunc =
Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_unpoison"));
// insert before the current instruction InstAlloca *Cur;
InstList::iterator Next = Context.getNext(); ConstantInteger32 *VarSizeOp;
Context.setInsertPoint(Context.getCur()); while (
Context.insert(RzAlloca); (Cur = llvm::dyn_cast<InstAlloca>(iteratorToInst(C.getCur()))) &&
Context.setNext(Next); (VarSizeOp = llvm::dyn_cast<ConstantInteger32>(Cur->getSizeInBytes()))) {
} HasLocals = true;
void ASanInstrumentation::instrumentAlloca(LoweringContext &Context, // create the new alloca that includes a redzone
InstAlloca *Instr) { SizeT VarSize = VarSizeOp->getValue();
auto *VarSizeOp = llvm::dyn_cast<ConstantInteger32>(Instr->getSizeInBytes()); Variable *Dest = Cur->getDest();
SizeT VarSize = (VarSizeOp == nullptr) ? RzSize : VarSizeOp->getValue(); SizeT RzPadding = RzSize + Utils::OffsetToAlignment(VarSize, RzSize);
SizeT Padding = Utils::OffsetToAlignment(VarSize, RzSize); auto *ByteCount =
constexpr SizeT Alignment = 1; ConstantInteger32::create(Ctx, IceType_i32, VarSize + RzPadding);
InstAlloca *Rz = createLocalRz(Context, RzSize + Padding, Alignment); constexpr SizeT Alignment = 8;
Context.insert(Rz); auto *NewVar = InstAlloca::create(Func, Dest, ByteCount, Alignment);
}
InstAlloca *ASanInstrumentation::createLocalRz(LoweringContext &Context, // calculate the redzone offset
SizeT Size, SizeT Alignment) { Variable *RzLocVar = Func->makeVariable(IceType_i32);
Cfg *Func = Context.getNode()->getCfg(); RzLocVar->setName(Func, nextRzName());
Variable *Rz = Func->makeVariable(IceType_i32); auto *Offset = ConstantInteger32::create(Ctx, IceType_i32, VarSize);
Rz->setName(Func, nextRzName()); auto *RzLoc = InstArithmetic::create(Func, InstArithmetic::Add, RzLocVar,
auto *ByteCount = ConstantInteger32::create(Ctx, IceType_i32, Size); Dest, Offset);
auto *RzAlloca = InstAlloca::create(Func, Rz, ByteCount, Alignment);
return RzAlloca; // instructions to poison and unpoison the redzone
constexpr SizeT NumArgs = 2;
constexpr Variable *Void = nullptr;
constexpr bool NoTailcall = false;
auto *Init = InstCall::create(Func, NumArgs, Void, InitFunc, NoTailcall);
auto *Destroy =
InstCall::create(Func, NumArgs, Void, DestroyFunc, NoTailcall);
Init->addArg(RzLocVar);
Destroy->addArg(RzLocVar);
auto *RzSizeConst = ConstantInteger32::create(Ctx, IceType_i32, RzPadding);
Init->addArg(RzSizeConst);
Destroy->addArg(RzSizeConst);
Cur->setDeleted();
C.insert(NewVar);
ICE_TLS_GET_FIELD(LocalDtors)->emplace_back(Destroy);
Initializations.emplace_back(RzLoc);
Initializations.emplace_back(Init);
C.advanceCur();
C.advanceNext();
}
C.setInsertPoint(C.getCur());
// add the leftmost redzone
if (HasLocals) {
Variable *LastRz = Func->makeVariable(IceType_i32);
LastRz->setName(Func, nextRzName());
auto *ByteCount = ConstantInteger32::create(Ctx, IceType_i32, RzSize);
constexpr SizeT Alignment = 8;
auto *RzAlloca = InstAlloca::create(Func, LastRz, ByteCount, Alignment);
constexpr SizeT NumArgs = 2;
constexpr Variable *Void = nullptr;
constexpr bool NoTailcall = false;
auto *Init = InstCall::create(Func, NumArgs, Void, InitFunc, NoTailcall);
auto *Destroy =
InstCall::create(Func, NumArgs, Void, DestroyFunc, NoTailcall);
Init->addArg(LastRz);
Destroy->addArg(LastRz);
Init->addArg(RzAlloca->getSizeInBytes());
Destroy->addArg(RzAlloca->getSizeInBytes());
ICE_TLS_GET_FIELD(LocalDtors)->emplace_back(Destroy);
C.insert(RzAlloca);
C.insert(Init);
}
// insert initializers for the redzones
for (Inst *Init : Initializations) {
C.insert(Init);
}
} }
void ASanInstrumentation::instrumentCall(LoweringContext &Context, void ASanInstrumentation::instrumentCall(LoweringContext &Context,
...@@ -214,6 +276,15 @@ void ASanInstrumentation::instrumentAccess(LoweringContext &Context, ...@@ -214,6 +276,15 @@ void ASanInstrumentation::instrumentAccess(LoweringContext &Context,
Context.setNext(Next); Context.setNext(Next);
} }
void ASanInstrumentation::instrumentRet(LoweringContext &Context, InstRet *) {
InstList::iterator Next = Context.getNext();
Context.setInsertPoint(Context.getCur());
for (InstCall *RzUnpoison : *ICE_TLS_GET_FIELD(LocalDtors)) {
Context.insert(RzUnpoison);
}
Context.setNext(Next);
}
void ASanInstrumentation::instrumentStart(Cfg *Func) { void ASanInstrumentation::instrumentStart(Cfg *Func) {
Constant *ShadowMemInit = Constant *ShadowMemInit =
Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_init")); Ctx->getConstantExternSym(Ctx->getGlobalString("__asan_init"));
...@@ -224,4 +295,10 @@ void ASanInstrumentation::instrumentStart(Cfg *Func) { ...@@ -224,4 +295,10 @@ void ASanInstrumentation::instrumentStart(Cfg *Func) {
Func->getEntryNode()->getInsts().push_front(Call); Func->getEntryNode()->getInsts().push_front(Call);
} }
// TODO(tlively): make this more efficient with swap idiom
void ASanInstrumentation::finishFunc(Cfg *Func) {
(void)Func;
ICE_TLS_GET_FIELD(LocalDtors)->clear();
}
} // end of namespace Ice } // end of namespace Ice
src/IceASanInstrumentation.h
...@@ -31,7 +31,9 @@ class ASanInstrumentation : public Instrumentation { ...@@ -31,7 +31,9 @@ class ASanInstrumentation : public Instrumentation {
ASanInstrumentation &operator=(const ASanInstrumentation &) = delete; ASanInstrumentation &operator=(const ASanInstrumentation &) = delete;
public: public:
ASanInstrumentation(GlobalContext *Ctx) : Instrumentation(Ctx), RzNum(0) {} ASanInstrumentation(GlobalContext *Ctx) : Instrumentation(Ctx), RzNum(0) {
ICE_TLS_INIT_FIELD(LocalDtors);
}
void instrumentGlobals(VariableDeclarationList &Globals) override; void instrumentGlobals(VariableDeclarationList &Globals) override;
private: private:
...@@ -40,15 +42,15 @@ private: ...@@ -40,15 +42,15 @@ private:
VariableDeclaration *RzArray, VariableDeclaration *RzArray,
SizeT &RzArraySize, SizeT &RzArraySize,
VariableDeclaration *Global); VariableDeclaration *Global);
InstAlloca *createLocalRz(LoweringContext &Context, SizeT Size,
SizeT Alignment);
void instrumentFuncStart(LoweringContext &Context) override; void instrumentFuncStart(LoweringContext &Context) override;
void instrumentAlloca(LoweringContext &Context, InstAlloca *Instr) override;
void instrumentCall(LoweringContext &Context, InstCall *Instr) override; void instrumentCall(LoweringContext &Context, InstCall *Instr) override;
void instrumentRet(LoweringContext &Context, InstRet *Instr) override;
void instrumentLoad(LoweringContext &Context, InstLoad *Instr) override; void instrumentLoad(LoweringContext &Context, InstLoad *Instr) override;
void instrumentStore(LoweringContext &Context, InstStore *Instr) override; void instrumentStore(LoweringContext &Context, InstStore *Instr) override;
void instrumentAccess(LoweringContext &Context, Operand *Op, SizeT Size); void instrumentAccess(LoweringContext &Context, Operand *Op, SizeT Size);
void instrumentStart(Cfg *Func) override; void instrumentStart(Cfg *Func) override;
void finishFunc(Cfg *Func) override;
ICE_TLS_DECLARE_FIELD(std::vector<InstCall *> *, LocalDtors);
bool DidInsertRedZones = false; bool DidInsertRedZones = false;
std::atomic<uint32_t> RzNum; std::atomic<uint32_t> RzNum;
}; };
......
src/IceCfg.cpp
...@@ -645,16 +645,19 @@ void Cfg::doArgLowering() { ...@@ -645,16 +645,19 @@ void Cfg::doArgLowering() {
getTarget()->lowerArguments(); getTarget()->lowerArguments();
} }
void Cfg::sortAndCombineAllocas(CfgVector<Inst *> &Allocas, void Cfg::sortAndCombineAllocas(CfgVector<InstAlloca *> &Allocas,
uint32_t CombinedAlignment, InstList &Insts, uint32_t CombinedAlignment, InstList &Insts,
AllocaBaseVariableType BaseVariableType) { AllocaBaseVariableType BaseVariableType) {
if (Allocas.empty()) if (Allocas.empty())
return; return;
// Sort by decreasing alignment. // Sort by decreasing alignment.
std::sort(Allocas.begin(), Allocas.end(), [](Inst *I1, Inst *I2) { std::sort(Allocas.begin(), Allocas.end(), [](InstAlloca *A1, InstAlloca *A2) {
auto *A1 = llvm::dyn_cast<InstAlloca>(I1); uint32_t Align1 = A1->getAlignInBytes();
auto *A2 = llvm::dyn_cast<InstAlloca>(I2); uint32_t Align2 = A2->getAlignInBytes();
return A1->getAlignInBytes() > A2->getAlignInBytes(); if (Align1 == Align2)
return A1->getNumber() > A2->getNumber();
else
return Align1 > Align2;
}); });
// Process the allocas in order of decreasing stack alignment. This allows // Process the allocas in order of decreasing stack alignment. This allows
// us to pack less-aligned pieces after more-aligned ones, resulting in less // us to pack less-aligned pieces after more-aligned ones, resulting in less
...@@ -746,6 +749,8 @@ void Cfg::processAllocas(bool SortAndCombine) { ...@@ -746,6 +749,8 @@ void Cfg::processAllocas(bool SortAndCombine) {
bool HasLargeAlignment = false; bool HasLargeAlignment = false;
bool HasDynamicAllocation = false; bool HasDynamicAllocation = false;
for (Inst &Instr : EntryNode->getInsts()) { for (Inst &Instr : EntryNode->getInsts()) {
if (Instr.isDeleted())
continue;
if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) { if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) {
uint32_t AlignmentParam = Alloca->getAlignInBytes(); uint32_t AlignmentParam = Alloca->getAlignInBytes();
if (AlignmentParam > StackAlignment) if (AlignmentParam > StackAlignment)
...@@ -769,6 +774,8 @@ void Cfg::processAllocas(bool SortAndCombine) { ...@@ -769,6 +774,8 @@ void Cfg::processAllocas(bool SortAndCombine) {
if (Node == EntryNode) if (Node == EntryNode)
continue; continue;
for (Inst &Instr : Node->getInsts()) { for (Inst &Instr : Node->getInsts()) {
if (Instr.isDeleted())
continue;
if (llvm::isa<InstAlloca>(&Instr)) { if (llvm::isa<InstAlloca>(&Instr)) {
// Allocations outside the entry block require a frame pointer. // Allocations outside the entry block require a frame pointer.
HasDynamicAllocation = true; HasDynamicAllocation = true;
...@@ -784,13 +791,15 @@ void Cfg::processAllocas(bool SortAndCombine) { ...@@ -784,13 +791,15 @@ void Cfg::processAllocas(bool SortAndCombine) {
// Collect the Allocas into the two vectors. // Collect the Allocas into the two vectors.
// Allocas in the entry block that have constant size and alignment less // Allocas in the entry block that have constant size and alignment less
// than or equal to the function's stack alignment. // than or equal to the function's stack alignment.
CfgVector<Inst *> FixedAllocas; CfgVector<InstAlloca *> FixedAllocas;
// Allocas in the entry block that have constant size and alignment greater // Allocas in the entry block that have constant size and alignment greater
// than the function's stack alignment. // than the function's stack alignment.
CfgVector<Inst *> AlignedAllocas; CfgVector<InstAlloca *> AlignedAllocas;
// Maximum alignment used by any alloca. // Maximum alignment used by any alloca.
uint32_t MaxAlignment = StackAlignment; uint32_t MaxAlignment = StackAlignment;
for (Inst &Instr : EntryNode->getInsts()) { for (Inst &Instr : EntryNode->getInsts()) {
if (Instr.isDeleted())
continue;
if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) { if (auto *Alloca = llvm::dyn_cast<InstAlloca>(&Instr)) {
if (!llvm::isa<Constant>(Alloca->getSizeInBytes())) if (!llvm::isa<Constant>(Alloca->getSizeInBytes()))
continue; continue;
......
src/IceCfg.h
...@@ -295,7 +295,7 @@ private: ...@@ -295,7 +295,7 @@ private:
BVT_FramePointer, BVT_FramePointer,
BVT_UserPointer BVT_UserPointer
}; };
void sortAndCombineAllocas(CfgVector<Inst *> &Allocas, void sortAndCombineAllocas(CfgVector<InstAlloca *> &Allocas,
uint32_t CombinedAlignment, InstList &Insts, uint32_t CombinedAlignment, InstList &Insts,
AllocaBaseVariableType BaseVariableType); AllocaBaseVariableType BaseVariableType);
void findRematerializable(); void findRematerializable();
......
src/IceInstrumentation.cpp
...@@ -51,6 +51,8 @@ void Instrumentation::instrumentFunc(Cfg *Func) { ...@@ -51,6 +51,8 @@ void Instrumentation::instrumentFunc(Cfg *Func) {
std::string FuncName = Func->getFunctionName().toStringOrEmpty(); std::string FuncName = Func->getFunctionName().toStringOrEmpty();
if (FuncName == "_start") if (FuncName == "_start")
instrumentStart(Func); instrumentStart(Func);
finishFunc(Func);
} }
void Instrumentation::instrumentInst(LoweringContext &Context) { void Instrumentation::instrumentInst(LoweringContext &Context) {
......
src/IceInstrumentation.h
...@@ -44,8 +44,10 @@ public: ...@@ -44,8 +44,10 @@ public:
virtual void instrumentGlobals(VariableDeclarationList &) {} virtual void instrumentGlobals(VariableDeclarationList &) {}
void instrumentFunc(Cfg *Func); void instrumentFunc(Cfg *Func);
protected:
virtual void instrumentInst(LoweringContext &Context);
private: private:
void instrumentInst(LoweringContext &Context);
virtual void instrumentFuncStart(LoweringContext &) {} virtual void instrumentFuncStart(LoweringContext &) {}
virtual void instrumentAlloca(LoweringContext &, class InstAlloca *) {} virtual void instrumentAlloca(LoweringContext &, class InstAlloca *) {}
virtual void instrumentArithmetic(LoweringContext &, class InstArithmetic *) { virtual void instrumentArithmetic(LoweringContext &, class InstArithmetic *) {
...@@ -71,6 +73,7 @@ private: ...@@ -71,6 +73,7 @@ private:
class InstUnreachable *) {} class InstUnreachable *) {}
virtual void instrumentStart(Cfg *) {} virtual void instrumentStart(Cfg *) {}
virtual void instrumentLocalVars(Cfg *) {} virtual void instrumentLocalVars(Cfg *) {}
virtual void finishFunc(Cfg *) {}
protected: protected:
GlobalContext *Ctx; GlobalContext *Ctx;
......
tests_lit/asan_tests/alignment.ll 0 → 100644
; Translate with -fsanitize-address and -O2 to test alignment and ordering of
; redzones when allocas are coalesced.
; REQUIRES: no_minimal_build
; RUN: %p2i --filetype=obj --disassemble --target x8632 -i %s --args -O2 \
; RUN: -allow-externally-defined-symbols -fsanitize-address | FileCheck %s
define internal i32 @func(i32 %arg1, i32 %arg2) {
%l1 = alloca i8, i32 4, align 4
%l2 = alloca i8, i32 5, align 1
ret i32 42
}
; CHECK: func
; CHECK-NEXT: sub esp,0xbc
; CHECK-NEXT: lea eax,[esp+0x10]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x20
; CHECK-NEXT: __asan_poison
; CHECK-NEXT: lea eax,[esp+0x74]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x3c
; CHECK-NEXT: __asan_poison
; CHECK-NEXT: lea eax,[esp+0x35]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x3b
; CHECK-NEXT: __asan_poison
; CHECK-NEXT: lea eax,[esp+0x74]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x3c
; CHECK-NEXT: __asan_unpoison
; CHECK-NEXT: lea eax,[esp+0x35]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x3b
; CHECK-NEXT: __asan_unpoison
; CHECK-NEXT: lea eax,[esp+0x10]
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x4],0x20
; CHECK-NEXT: __asan_unpoison
; CHECK-NEXT: mov eax,0x2a
; CHECK-NEXT: add esp,0xbc
; CHECK-NEXT: ret
tests_lit/asan_tests/instrumentload.ll
...@@ -69,7 +69,7 @@ define internal void @doLoads() { ...@@ -69,7 +69,7 @@ define internal void @doLoads() {
; DUMP-LABEL: ================ Instrumented CFG ================ ; DUMP-LABEL: ================ Instrumented CFG ================
; DUMP-NEXT: define internal void @doLoads() { ; DUMP-NEXT: define internal void @doLoads() {
; DUMP-NEXT: __0: ; DUMP-NEXT: __0:
; DUMP: call void @__asan_check(i32 @srcConst8, i32 1) ; DUMP: call void @__asan_check(i32 @srcConst8, i32 1)
; DUMP-NEXT: %dest1 = load i8, i8* @srcConst8, align 1 ; DUMP-NEXT: %dest1 = load i8, i8* @srcConst8, align 1
; DUMP-NEXT: call void @__asan_check(i32 @srcConst16, i32 2) ; DUMP-NEXT: call void @__asan_check(i32 @srcConst16, i32 2)
; DUMP-NEXT: %dest2 = load i16, i16* @srcConst16, align 1 ; DUMP-NEXT: %dest2 = load i16, i16* @srcConst16, align 1
...@@ -99,5 +99,5 @@ define internal void @doLoads() { ...@@ -99,5 +99,5 @@ define internal void @doLoads() {
; DUMP-NEXT: %dest14 = load i64, i64* %srcLocal64, align 1 ; DUMP-NEXT: %dest14 = load i64, i64* %srcLocal64, align 1
; DUMP-NEXT: call void @__asan_check(i32 %srcLocal128, i32 16) ; DUMP-NEXT: call void @__asan_check(i32 %srcLocal128, i32 16)
; DUMP-NEXT: %dest15 = load <4 x i32>, <4 x i32>* %srcLocal128, align 4 ; DUMP-NEXT: %dest15 = load <4 x i32>, <4 x i32>* %srcLocal128, align 4
; DUMP-NEXT: ret void ; DUMP: ret void
; DUMP-NEXT } ; DUMP-NEXT: }
tests_lit/asan_tests/instrumentlocals.ll
; Test for insertion of redzones around global variables ; Test for insertion of redzones around local variables
; REQUIRES: allow_dump ; REQUIRES: allow_dump
...@@ -7,42 +7,39 @@ ...@@ -7,42 +7,39 @@
; Function with local variables to be instrumented ; Function with local variables to be instrumented
define internal void @func() { define internal void @func() {
%local0 = alloca i8, i32 4, align 4 %local1 = alloca i8, i32 4, align 4
%local1 = alloca i8, i32 32, align 4 %local2 = alloca i8, i32 32, align 1
%local2 = alloca i8, i32 13, align 4 %local3 = alloca i8, i32 13, align 2
%local3 = alloca i8, i32 75, align 4 %local4 = alloca i8, i32 75, align 4
%local4 = alloca i8, i32 64, align 4 %local5 = alloca i8, i32 64, align 8
%local5 = alloca i8, i32 4, align 1
%local6 = alloca i8, i32 32, align 1
%local7 = alloca i8, i32 13, align 1
%local8 = alloca i8, i32 75, align 1
%local9 = alloca i8, i32 64, align 1
ret void ret void
} }
; DUMP-LABEL: ================ Instrumented CFG ================ ; DUMP-LABEL: ================ Instrumented CFG ================
; DUMP-NEXT: define internal void @func() { ; DUMP-NEXT: define internal void @func() {
; DUMP-NEXT: __0: ; DUMP-NEXT: __0:
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 32, align 4 ; DUMP-NEXT: %local1 = alloca i8, i32 64, align 8
; DUMP-NEXT: %local0 = alloca i8, i32 4, align 4 ; DUMP-NEXT: %local2 = alloca i8, i32 64, align 8
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 60, align 1 ; DUMP-NEXT: %local3 = alloca i8, i32 64, align 8
; DUMP-NEXT: %local1 = alloca i8, i32 32, align 4 ; DUMP-NEXT: %local4 = alloca i8, i32 128, align 8
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 32, align 1 ; DUMP-NEXT: %local5 = alloca i8, i32 96, align 8
; DUMP-NEXT: %local2 = alloca i8, i32 13, align 4 ; DUMP-NEXT: %__$rz[[RZ0:[0-9]+]] = alloca i8, i32 32, align 8
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 51, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ0]], i32 32)
; DUMP-NEXT: %local3 = alloca i8, i32 75, align 4 ; DUMP-NEXT: %__$rz[[RZ1:[0-9]+]] = add i32 %local1, 4
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 53, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ1]], i32 60)
; DUMP-NEXT: %local4 = alloca i8, i32 64, align 4 ; DUMP-NEXT: %__$rz[[RZ2:[0-9]+]] = add i32 %local2, 32
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 32, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ2]], i32 32)
; DUMP-NEXT: %local5 = alloca i8, i32 4, align 1 ; DUMP-NEXT: %__$rz[[RZ3:[0-9]+]] = add i32 %local3, 13
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 60, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ3]], i32 51)
; DUMP-NEXT: %local6 = alloca i8, i32 32, align 1 ; DUMP-NEXT: %__$rz[[RZ4:[0-9]+]] = add i32 %local4, 75
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 32, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ4]], i32 53)
; DUMP-NEXT: %local7 = alloca i8, i32 13, align 1 ; DUMP-NEXT: %__$rz[[RZ5:[0-9]+]] = add i32 %local5, 64
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 51, align 1 ; DUMP-NEXT: call void @__asan_poison(i32 %__$rz[[RZ5]], i32 32)
; DUMP-NEXT: %local8 = alloca i8, i32 75, align 1 ; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ1]], i32 60)
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 53, align 1 ; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ2]], i32 32)
; DUMP-NEXT: %local9 = alloca i8, i32 64, align ; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ3]], i32 51)
; DUMP-NEXT: %__$rz{{[0-9]+}} = alloca i8, i32 32, align 1 ; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ4]], i32 53)
; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ5]], i32 32)
; DUMP-NEXT: call void @__asan_unpoison(i32 %__$rz[[RZ0]], i32 32)
; DUMP-NEXT: ret void ; DUMP-NEXT: ret void
; DUMP-NEXT: } ; DUMP-NEXT: }
tests_lit/asan_tests/instrumentstore.ll
...@@ -70,5 +70,5 @@ define internal void @doStores(<4 x i32> %vecSrc) { ...@@ -70,5 +70,5 @@ define internal void @doStores(<4 x i32> %vecSrc) {
; DUMP-NEXT: store i64 42, i64* %destLocal64, align 1 ; DUMP-NEXT: store i64 42, i64* %destLocal64, align 1
; DUMP-NEXT: call void @__asan_check(i32 %destLocal128, i32 16) ; DUMP-NEXT: call void @__asan_check(i32 %destLocal128, i32 16)
; DUMP-NEXT: store <4 x i32> %vecSrc, <4 x i32>* %destLocal128, align 4 ; DUMP-NEXT: store <4 x i32> %vecSrc, <4 x i32>* %destLocal128, align 4
; DUMP-NEXT: ret void ; DUMP: ret void
; DUMP-NEXT: } ; DUMP-NEXT: }
tests_lit/llvm2ice_tests/fused-alloca-arg.ll
...@@ -49,16 +49,16 @@ entry: ...@@ -49,16 +49,16 @@ entry:
; CHECK-LABEL: caller2 ; CHECK-LABEL: caller2
; CHECK-NEXT: sub esp,0x6c ; CHECK-NEXT: sub esp,0x6c
; CHECK-NEXT: mov eax,DWORD PTR [esp+0x70] ; CHECK-NEXT: mov eax,DWORD PTR [esp+0x70]
; CHECK-NEXT: mov DWORD PTR [esp+0x20],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x40],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x40],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x20],eax
; CHECK-NEXT: mov DWORD PTR [esp],eax ; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: lea eax,[esp+0x20]
; CHECK-NEXT: mov DWORD PTR [esp+0x4],eax
; CHECK-NEXT: lea eax,[esp+0x40] ; CHECK-NEXT: lea eax,[esp+0x40]
; CHECK-NEXT: mov DWORD PTR [esp+0x8],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x4],eax
; CHECK-NEXT: lea eax,[esp+0x20] ; CHECK-NEXT: lea eax,[esp+0x20]
; CHECK-NEXT: mov DWORD PTR [esp+0xc],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x8],eax
; CHECK-NEXT: lea eax,[esp+0x40] ; CHECK-NEXT: lea eax,[esp+0x40]
; CHECK-NEXT: mov DWORD PTR [esp+0xc],eax
; CHECK-NEXT: lea eax,[esp+0x20]
; CHECK-NEXT: mov DWORD PTR [esp+0x10],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x10],eax
; CHECK-NEXT: call ; CHECK-NEXT: call
; CHECK-NEXT: add esp,0x6c ; CHECK-NEXT: add esp,0x6c
......
tests_lit/llvm2ice_tests/fused-alloca.ll
...@@ -21,8 +21,8 @@ entry: ...@@ -21,8 +21,8 @@ entry:
; CHECK-LABEL: fused_small_align ; CHECK-LABEL: fused_small_align
; CHECK-NEXT: sub esp,0x30 ; CHECK-NEXT: sub esp,0x30
; CHECK-NEXT: mov eax,DWORD PTR [esp+0x34] ; CHECK-NEXT: mov eax,DWORD PTR [esp+0x34]
; CHECK-NEXT: mov DWORD PTR [esp+0x1c],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x10],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x10],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x18],eax
; CHECK-NEXT: mov DWORD PTR [esp],eax ; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: add esp,0x30 ; CHECK-NEXT: add esp,0x30
...@@ -46,9 +46,9 @@ entry: ...@@ -46,9 +46,9 @@ entry:
; CHECK-NEXT: sub esp,0x80 ; CHECK-NEXT: sub esp,0x80
; CHECK-NEXT: and esp,0xffffffc0 ; CHECK-NEXT: and esp,0xffffffc0
; CHECK-NEXT: mov eax,DWORD PTR [ebp+0x8] ; CHECK-NEXT: mov eax,DWORD PTR [ebp+0x8]
; CHECK-NEXT: mov DWORD PTR [esp+0x40],eax
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x60],eax ; CHECK-NEXT: mov DWORD PTR [esp+0x60],eax
; CHECK-NEXT: mov DWORD PTR [esp],eax
; CHECK-NEXT: mov DWORD PTR [esp+0x40],eax
; CHECK-NEXT: mov esp,ebp ; CHECK-NEXT: mov esp,ebp
; CHECK-NEXT: pop ebp ; CHECK-NEXT: pop ebp
...@@ -154,10 +154,10 @@ next: ...@@ -154,10 +154,10 @@ next:
; CHECK-NEXT: add ecx,0x0 ; CHECK-NEXT: add ecx,0x0
; CHECK-NEXT: sub esp,0x10 ; CHECK-NEXT: sub esp,0x10
; CHECK-NEXT: mov ebx,esp ; CHECK-NEXT: mov ebx,esp
; CHECK-NEXT: mov DWORD PTR [ecx],eax
; CHECK-NEXT: mov DWORD PTR [edx],eax ; CHECK-NEXT: mov DWORD PTR [edx],eax
; CHECK-NEXT: mov DWORD PTR [ebp-0x14],eax ; CHECK-NEXT: mov DWORD PTR [ecx],eax
; CHECK-NEXT: mov DWORD PTR [ebp-0x24],eax ; CHECK-NEXT: mov DWORD PTR [ebp-0x24],eax
; CHECK-NEXT: mov DWORD PTR [ebp-0x14],eax
; CHECK-NEXT: mov DWORD PTR [ebx],eax ; CHECK-NEXT: mov DWORD PTR [ebx],eax
; CHECK-NEXT: mov esp,ebp ; CHECK-NEXT: mov esp,ebp
; CHECK-NEXT: pop ebp ; CHECK-NEXT: pop ebp
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment