Import ASR pass from llvm-apps
Change-Id: I106c5faf8d8f1af5d3f5542fe666532895413909
This commit is contained in:
David van Moolenbroek
parent
78ff1e69b6
commit
0b98e8aad8
4 changed files with 776 additions and 0 deletions
|
|
@ -71,3 +71,6 @@ make install
|
|||
|
||||
cd ${NETBSDSRCDIR}/minix/llvm/passes/magic
|
||||
make install
|
||||
|
||||
cd ${NETBSDSRCDIR}/minix/llvm/passes/asr
|
||||
make install
|
||||
|
|
|
|||
712
minix/llvm/passes/asr/ASRPass.cpp
Normal file
712
minix/llvm/passes/asr/ASRPass.cpp
Normal file
|
|
@ -0,0 +1,712 @@
|
|||
#include <asr/ASRPass.h>
|
||||
#include <magic_common.h>
|
||||
#include <magic/support/MagicUtil.h>
|
||||
#include <llvm/Transforms/Utils/BasicBlockUtils.h>
|
||||
|
||||
#define MAGIC_IS_MAGIC_FUNC(M, F) (!(F)->getSection().compare(MAGIC_STATIC_FUNCTIONS_SECTION))
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
|
||||
// command-line arguments
|
||||
|
||||
static cl::opt<int>
|
||||
seed("asr-seed",
|
||||
cl::desc("Random seed integer value for ASRPass. '0' will use current time as seed"),
|
||||
cl::init(DEFAULT_SEED), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
gv_max_offset("asr-gv-max-offset",
|
||||
cl::desc(""),
|
||||
cl::init(GV_DEFAULT_MAX_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
gv_max_padding("asr-gv-max-padding",
|
||||
cl::desc(""),
|
||||
cl::init(GV_DEFAULT_MAX_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
gv_do_permutate("asr-gv-do-permutate",
|
||||
cl::desc(""),
|
||||
cl::init(GV_DEFAULT_DO_PERMUTATE), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
func_max_offset("asr-func-max-offset",
|
||||
cl::desc(""),
|
||||
cl::init(FUNC_DEFAULT_MAX_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
func_max_padding("asr-func-max-padding",
|
||||
cl::desc(""),
|
||||
cl::init(FUNC_DEFAULT_MAX_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
func_max_bb_shift("asr-func-max-bb-shift",
|
||||
cl::desc(""),
|
||||
cl::init(FUNC_DEFAULT_MAX_BB_SHIFT), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
func_do_permutate("asr-func-do-permutate",
|
||||
cl::desc(""),
|
||||
cl::init(FUNC_DEFAULT_DO_PERMUTATE), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
stack_do_offset("asr-stack-do-offset",
|
||||
cl::desc(""),
|
||||
cl::init(STACK_DEFAULT_DO_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stack_max_offset("asr-stack-max-offset",
|
||||
cl::desc(""),
|
||||
cl::init(STACK_DEFAULT_MAX_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_do_offset("asr-stackframe-do-offset",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_DO_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_max_offset("asr-stackframe-max-offset",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_MAX_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_max_padding("asr-stackframe-max-padding",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_MAX_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_do_permutate("asr-stackframe-do-permutate",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_DO_PERMUTATE), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_static_padding("asr-stackframe-static-padding",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_STATIC_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
stackframe_caller_padding("asr-stackframe-caller-padding",
|
||||
cl::desc(""),
|
||||
cl::init(STACKFRAME_DEFAULT_CALLER_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
heap_map_do_permutate("asr-heap-map-do-permutate",
|
||||
cl::desc(""),
|
||||
cl::init(HEAP_MAP_DEFAULT_DO_PERMUTATE), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
heap_max_offset("asr-heap-max-offset",
|
||||
cl::desc(""),
|
||||
cl::init(HEAP_DEFAULT_MAX_OFFSET), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
heap_max_padding("asr-heap-max-padding",
|
||||
cl::desc(""),
|
||||
cl::init(HEAP_DEFAULT_MAX_PADDING), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
static cl::opt<int>
|
||||
map_max_offset_pages("asr-map-max-offset-pages",
|
||||
cl::desc(""),
|
||||
cl::init(MAP_DEFAULT_MAX_OFFSET_PAGES), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
static cl::opt<int>
|
||||
map_max_padding_pages("asr-map-max-padding-pages",
|
||||
cl::desc(""),
|
||||
cl::init(MAP_DEFAULT_MAX_PADDING_PAGES), cl::NotHidden, cl::ValueRequired);
|
||||
|
||||
|
||||
#define __X(P) #P
|
||||
std::string magicMemFuncNames[] = { MAGIC_MEM_FUNC_NAMES };
|
||||
#undef __X
|
||||
|
||||
namespace llvm {
|
||||
|
||||
PASS_COMMON_INIT_ONCE();
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Constructors, destructor, and operators
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
ASRPass::ASRPass() : ModulePass(ID) {}
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Public methods
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
void fillPermutationGenerator(std::vector<unsigned> &permutationGenerator){
|
||||
// This function returns a list of indices. In order to create a permutation of a list of elements, for each index, remove that element and place it at the end of the list.
|
||||
unsigned size = permutationGenerator.size();
|
||||
for (unsigned i = 0; i < size; ++i) {
|
||||
unsigned j = rand() % (size - i);
|
||||
permutationGenerator[i] = j;
|
||||
}
|
||||
}
|
||||
|
||||
Function* getCalledFunctionFromCS(const CallSite &CS) {
|
||||
assert(CS.getInstruction());
|
||||
Function *function = CS.getCalledFunction();
|
||||
if(function) {
|
||||
return function;
|
||||
}
|
||||
|
||||
//handle the weird case of bitcasted function call
|
||||
ConstantExpr *CE = dyn_cast<ConstantExpr>(CS.getCalledValue());
|
||||
if(!CE) {
|
||||
return NULL;
|
||||
}
|
||||
assert(CE && CE->getOpcode() == Instruction::BitCast && "Bitcast expected, something else found!");
|
||||
function = dyn_cast<Function>(CE->getOperand(0));
|
||||
assert(function);
|
||||
|
||||
return function;
|
||||
}
|
||||
|
||||
#define ADVANCE_ITERATOR(IT, N_POS) for(unsigned __adv_it_count=0; __adv_it_count< N_POS; __adv_it_count++){ IT++;}
|
||||
|
||||
GlobalVariable *create_padding_gv(Module &M, GlobalVariable *InsertBefore, int n_bytes){
|
||||
|
||||
ArrayType* ArrayTy = ArrayType::get(IntegerType::get(M.getContext(), 8), n_bytes);
|
||||
|
||||
GlobalVariable* padding_char_arr = new GlobalVariable(/*Module=*/M,
|
||||
/*Type=*/ArrayTy,
|
||||
/*isConstant=*/false,
|
||||
/*Linkage=*/GlobalValue::InternalLinkage,
|
||||
/*Initializer=*/ConstantAggregateZero::get(ArrayTy),
|
||||
/*Name=*/"magic_asr_padding_gv",
|
||||
/*InsertBefore=*/InsertBefore);
|
||||
padding_char_arr->setAlignment(1);
|
||||
padding_char_arr->setSection(InsertBefore->getSection());
|
||||
return padding_char_arr;
|
||||
|
||||
}
|
||||
|
||||
AllocaInst *create_padding_lv(Module &M, Instruction *InsertBefore, int n_bytes){
|
||||
|
||||
ArrayType* ArrayTy = ArrayType::get(IntegerType::get(M.getContext(), 8), n_bytes);
|
||||
AllocaInst* ptr_x = new AllocaInst(ArrayTy, "magic_asr_padding_lv", InsertBefore);
|
||||
ptr_x->setAlignment(16);
|
||||
|
||||
/* Seems not to be necessary
|
||||
|
||||
ConstantInt* const_int64_0 = ConstantInt::get(M.getContext(), APInt(64, StringRef("0"), 10));
|
||||
ConstantInt* const_int8_0 = ConstantInt::get(M.getContext(), APInt(8, StringRef("97"), 10));
|
||||
|
||||
std::vector<Value*> ptr_indices;
|
||||
ptr_indices.push_back(const_int64_0);
|
||||
ptr_indices.push_back(const_int64_0);
|
||||
|
||||
Instruction* ptr_8 = GetElementPtrInst::Create(ptr_x, ptr_indices.begin(), ptr_indices.end(), "", ptr_x->getParent());
|
||||
ptr_8->removeFromParent();
|
||||
ptr_8->insertAfter(ptr_x);
|
||||
|
||||
StoreInst* void_9 = new StoreInst(const_int8_0, ptr_8, true, ptr_x->getParent());
|
||||
void_9->setAlignment(16);
|
||||
void_9->removeFromParent();
|
||||
void_9->insertAfter(ptr_8);
|
||||
|
||||
*/
|
||||
|
||||
return ptr_x;
|
||||
|
||||
}
|
||||
|
||||
Function *create_padding_func(Module &M, int n_ops){
|
||||
/* Places a padding function at the end of the function list */
|
||||
|
||||
std::vector<TYPECONST Type*>FuncTy_0_args;
|
||||
TYPECONST FunctionType* FuncTy_0 = FunctionType::get(Type::getVoidTy(M.getContext()), FuncTy_0_args, false);
|
||||
|
||||
Function* func_padding_func = Function::Create(FuncTy_0, GlobalValue::ExternalLinkage, "magic_asr_padding_func", &M);
|
||||
func_padding_func->setCallingConv(CallingConv::C);
|
||||
BasicBlock* bb = BasicBlock::Create(M.getContext(), "",func_padding_func,0);
|
||||
|
||||
ConstantInt* const_int32_0 = ConstantInt::get(M.getContext(), APInt(32, StringRef("0"), 10));
|
||||
ConstantInt* const_int32_1 = ConstantInt::get(M.getContext(), APInt(32, StringRef("1"), 10));
|
||||
|
||||
AllocaInst* ptr_x = new AllocaInst(IntegerType::get(M.getContext(), 32), "x", bb);
|
||||
ptr_x->setAlignment(4);
|
||||
|
||||
StoreInst* void_1 = new StoreInst(const_int32_0, ptr_x, true, bb);
|
||||
void_1->setAlignment(4);
|
||||
|
||||
for(int i=0; i< n_ops; i++){
|
||||
LoadInst* load_x = new LoadInst(ptr_x, "", true, bb);
|
||||
load_x->setAlignment(4);
|
||||
|
||||
BinaryOperator* add_x = BinaryOperator::Create(Instruction::Add, load_x, const_int32_1, "", bb);
|
||||
|
||||
StoreInst* void_2 = new StoreInst(add_x, ptr_x, true, bb);
|
||||
void_2->setAlignment(4);
|
||||
}
|
||||
|
||||
ReturnInst::Create(M.getContext(), bb);
|
||||
|
||||
return func_padding_func;
|
||||
}
|
||||
|
||||
StringRef getStringRefFromInt(int i){
|
||||
std::stringstream stm;
|
||||
stm << i;
|
||||
return StringRef(*new std::string(stm.str()));
|
||||
}
|
||||
|
||||
bool ASRPass::runOnModule(Module &M) {
|
||||
|
||||
Module::GlobalListType &globalList = M.getGlobalList();
|
||||
Module::FunctionListType &functionList = M.getFunctionList();
|
||||
int runtime_seed = seed;
|
||||
|
||||
Function *magicEntryPointFunc = M.getFunction(MAGIC_ENTRY_POINT);
|
||||
if( !magicEntryPointFunc ){
|
||||
//if no valid entry point, we are not compiling a valid program, skip pass
|
||||
return false;
|
||||
}
|
||||
|
||||
Function *magicInitFunc = M.getFunction(MAGIC_INIT_FUNC_NAME);
|
||||
if( !magicInitFunc ){
|
||||
outs() << "Error: no " << MAGIC_INIT_FUNC_NAME << "() found";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
{
|
||||
// get random seed number, or use the current time if the seed number is set to 0.
|
||||
if(!seed){
|
||||
seed = time(NULL);
|
||||
}
|
||||
srand(seed);
|
||||
|
||||
}{
|
||||
|
||||
/* Randomly offset and permutate list of global variables, and insert random padding between neighbouring global variables */
|
||||
|
||||
std::vector<unsigned> pg(globalList.size());
|
||||
fillPermutationGenerator(pg);
|
||||
|
||||
for(unsigned i=0; i < pg.size(); i++){
|
||||
Module::global_iterator it = globalList.begin();
|
||||
// get the next random global variable
|
||||
ADVANCE_ITERATOR(it, pg[i]);
|
||||
// skip certain variables
|
||||
if(it->getName().startswith("llvm.")
|
||||
|| it->getLinkage() == GlobalValue::ExternalWeakLinkage){
|
||||
continue;
|
||||
}
|
||||
if(it->getLinkage() != GlobalValue::ExternalLinkage && it->getName().compare("environ")){
|
||||
// This prevents most public global variables (common linkage, but not external linkage) to be kept in the same order
|
||||
it->setLinkage(GlobalValue::InternalLinkage);
|
||||
}
|
||||
if(gv_do_permutate){
|
||||
// randomize the order of variables, by removing the global variable, and putting it at the end of globalList
|
||||
GlobalVariable *gv = globalList.remove(it);
|
||||
globalList.push_back(gv);
|
||||
it = --globalList.end();
|
||||
}
|
||||
// put a padding variable between each two adjacent global variables, and place a big offset before the first global variable
|
||||
int max_padding = i == 0 ? gv_max_offset : gv_max_padding;
|
||||
if(max_padding > 0){
|
||||
create_padding_gv(M, it, (rand () % max_padding) + 1);
|
||||
}
|
||||
}
|
||||
|
||||
}{
|
||||
|
||||
/* Randomly offset and permutate function list, and insert random padding between neighbouring functions. */
|
||||
|
||||
std::vector<unsigned> pg(functionList.size());
|
||||
fillPermutationGenerator(pg);
|
||||
|
||||
for(unsigned i=0; i < pg.size(); i++){
|
||||
Module::iterator it = functionList.begin();
|
||||
if(func_do_permutate){
|
||||
/* randomize the order of functions, just like we did with the global variables if permutions is disabled, we end up with the same order of functions */
|
||||
ADVANCE_ITERATOR(it, pg[i]);
|
||||
}
|
||||
Function *F = functionList.remove(it);
|
||||
functionList.push_back(F);
|
||||
/* place a padding function at the end of the function list, behind the current function */
|
||||
int max_padding = i == 0 ? func_max_offset : func_max_padding;
|
||||
if(max_padding > 0){
|
||||
create_padding_func(M, (rand () % (max_padding/2)) + (max_padding/2));
|
||||
}
|
||||
}
|
||||
|
||||
}{
|
||||
|
||||
|
||||
/* permutate and pad local function variables, and create dynamically randomized stack and stack frame offsets */
|
||||
|
||||
for (Module::iterator it = functionList.begin(); it != functionList.end(); ++it) {
|
||||
Function *F = it;
|
||||
|
||||
/* skip certain functions */
|
||||
if(F->getBasicBlockList().size() == 0){
|
||||
continue;
|
||||
}
|
||||
if(MAGIC_IS_MAGIC_FUNC(M, F)){
|
||||
continue;
|
||||
}
|
||||
if(!F->getName().compare("rand")){
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
/* find all allocation instructions in order to pad them. */
|
||||
|
||||
/* Helper vectors to store all alloca instructions temporarily.
|
||||
* Make two collections, depending on whether the address of the variable is taken and used as a pointer.
|
||||
* (Because pointer dereferencing, buffer overflow, etc. add extra risks to those variables that have their addresses taken)
|
||||
* We order the allocation instructions as follows:
|
||||
* - First, we allocate the ones that don't have their address taken, only permutated.
|
||||
* - Then, we allocate an stack frame offset (dynamically randomly sized).
|
||||
* - After the stack frame offset, we allocate those that have their address taken, with permutation and padding.
|
||||
* Because the majority doesn't have its address taken, most variables are allocated in the first basic block, before the stack frame offset allocation.
|
||||
* This gives the extra advantages that those allocations are folded into the prolog/epilog code by the code generator, for extra performance.
|
||||
* (See AllocaInst::isStaticAlloca() in llvm/Instructions.h)
|
||||
* */
|
||||
std::vector<Instruction *> allocaAddressTaken, allocaNoAddressTaken;
|
||||
|
||||
/* Only the first basic block contains alloca instructions */
|
||||
BasicBlock *BB = F->getBasicBlockList().begin();
|
||||
|
||||
/* with each iteration, one of these integers will be incremented/decremented */
|
||||
unsigned bb_size = BB->getInstList().size();
|
||||
unsigned pos = 0;
|
||||
while(pos < bb_size){
|
||||
|
||||
/* check if instruction at position <pos> is an allocation instruction.
|
||||
* If, so remove and put in one of the helper vectors
|
||||
* */
|
||||
|
||||
BasicBlock::iterator it = BB->getInstList().begin();
|
||||
/* move to current position in instruction list */
|
||||
ADVANCE_ITERATOR(it, pos);
|
||||
Instruction *inst = &(*it);
|
||||
if (AllocaInst *allocaInst = dyn_cast<AllocaInst>(inst)){
|
||||
/* this is an allocation instruction. insert it at the front of of the right helper vector
|
||||
* (last found allocation instruction will be at the front), and remove it from the basic block.
|
||||
* */
|
||||
int hasAddressTaken = 0;
|
||||
for (Value::use_iterator UI = allocaInst->use_begin(), E = allocaInst->use_end(); UI != E; ++UI) {
|
||||
|
||||
/* Loop through all the Uses of this allocation function. */
|
||||
|
||||
User *U = *UI;
|
||||
if(dyn_cast<LoadInst>(U) || dyn_cast<StoreInst>(U)){
|
||||
/* This is a load or store instruction, which does not
|
||||
* indicate that a pointer of this variable is generated
|
||||
* */
|
||||
continue;
|
||||
}else if(CallInst *cInst = dyn_cast<CallInst>(U)){
|
||||
if(cInst->getCalledFunction() && MAGIC_IS_MAGIC_FUNC(M, cInst->getCalledFunction())){
|
||||
/* This is a function call instruction, but this
|
||||
* concerns a magic library function, so it does not count as a generated pointer.
|
||||
* Any other functions calls would have set hasAddressTaken to 1 */
|
||||
continue;
|
||||
}
|
||||
}
|
||||
/* This instruction will (likely) create a pointer, because it is not a load, store or magic-function-call instruction */
|
||||
hasAddressTaken = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Put the alloca instruction in the right helper vector, and remove from the basic block. */
|
||||
if(hasAddressTaken){
|
||||
allocaAddressTaken.insert(allocaAddressTaken.begin(), it);
|
||||
}else{
|
||||
allocaNoAddressTaken.insert(allocaNoAddressTaken.begin(), it);
|
||||
}
|
||||
it->removeFromParent();
|
||||
bb_size--;
|
||||
}else{
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Permutate and pad the alloca instructions whose addresses are taken. */
|
||||
|
||||
std::vector<unsigned> pg(allocaAddressTaken.size());
|
||||
fillPermutationGenerator(pg);
|
||||
for(unsigned i=0; i<pg.size(); i++){
|
||||
/* get the iterator for the first element of the helper vector */
|
||||
std::vector<Instruction *>::iterator it = allocaAddressTaken.begin();
|
||||
if(stackframe_do_permutate){
|
||||
/* get the iterator for the next random element. When permutation is disabled, it keeps pointing to the first element */
|
||||
ADVANCE_ITERATOR(it, pg[i]);
|
||||
}
|
||||
/* put the variable at the front of the basic block, and remove it from the helper vector.
|
||||
* This way, the variable that is added last will be at the front
|
||||
* */
|
||||
BB->getInstList().push_front(*it);
|
||||
allocaAddressTaken.erase(it);
|
||||
|
||||
/* put a padding variable between each two adjacent local variables
|
||||
* this is done by inserting a padding var at the front each time a
|
||||
* var has been put at the front with push_front().
|
||||
* */
|
||||
int max_padding = (i==pg.size()-1 ? 0 : stackframe_max_padding);
|
||||
if(max_padding > 0){
|
||||
create_padding_lv(M, BB->getInstList().begin(), (rand () % max_padding) + 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Create a global stack offset, and an offset for each stack frame. Both have a dynamic random size */
|
||||
|
||||
/* Determine if we must pad or offset, and how much */
|
||||
int max_offset, do_offset=1;
|
||||
if(F->getName().equals(MAGIC_ENTRY_POINT)){
|
||||
if(!stack_do_offset){
|
||||
do_offset=0;
|
||||
}
|
||||
/* give the entry function (first function) a large offset instead of an padding */
|
||||
max_offset = stack_max_offset;
|
||||
}else{
|
||||
if(!stackframe_do_offset){
|
||||
do_offset=0;
|
||||
}
|
||||
max_offset = stackframe_max_offset;
|
||||
}
|
||||
|
||||
/* Create a new block before the first block. Now, all the variable allocations whose addresses are taken are no longer
|
||||
* in the first block, so CallInst::isStaticAlloca() does no longer apply to them.
|
||||
* When isStaticAlloca() == true, the code generator will fold it into the prolog/epilog code, so it is basically free.
|
||||
* This means that we now get less efficient code.
|
||||
* This is necessary to prevent the variables whose address is taken from being allocated before the stack frame offset is allocated.
|
||||
* Alternatively, we could allocate before the function call, instead of after. */
|
||||
|
||||
BasicBlock *OldFirstBB = F->getBasicBlockList().begin();
|
||||
BasicBlock *NewFirstBB = BasicBlock::Create(M.getContext(), "newBB", F, OldFirstBB);
|
||||
|
||||
|
||||
/* Permutate and insert the allocation instructions whose addresses are NOT taken into the new first block (dont apply padding).
|
||||
* These must be allocated before the stack frame offset is allocated. */
|
||||
|
||||
pg = std::vector<unsigned>(allocaNoAddressTaken.size());
|
||||
fillPermutationGenerator(pg);
|
||||
for(unsigned i=0; i<pg.size(); i++){
|
||||
/* get the iterator for the first element of the helper vector */
|
||||
std::vector<Instruction *>::iterator it = allocaNoAddressTaken.begin();
|
||||
if(stackframe_do_permutate){
|
||||
/* get the iterator for the next random element. When permutation is disabled, it keeps pointing to the first element */
|
||||
ADVANCE_ITERATOR(it, pg[i]);
|
||||
}
|
||||
/* put the variable at the front of the basic block, and remove it from the helper vector.
|
||||
* This way, the variable that is added last will be at the front
|
||||
* */
|
||||
NewFirstBB->getInstList().push_front(*it);
|
||||
allocaNoAddressTaken.erase(it);
|
||||
}
|
||||
|
||||
if(do_offset){
|
||||
if(stackframe_static_padding) {
|
||||
if(max_offset > 0) {
|
||||
new AllocaInst(IntegerType::get(M.getContext(), 8), ConstantInt::get(M.getContext(), APInt(64, (rand() % max_offset) + 1, 10)), "", NewFirstBB);
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* Now insert a dynamically randomized stackframe offset */
|
||||
Function *RandFunc = M.getFunction("rand");
|
||||
assert(RandFunc != NULL);
|
||||
|
||||
/* Call rand() */
|
||||
std::vector<Value*> args;
|
||||
CallInst* RandFuncCall = PassUtil::createCallInstruction(RandFunc, args, "", NewFirstBB);
|
||||
Instruction *nextInst = RandFuncCall;
|
||||
|
||||
if(max_offset > 0){
|
||||
/* limit the rand value: rand() % max_offet */
|
||||
ConstantInt* max_offset_const = ConstantInt::get(M.getContext(), APInt(32, max_offset, 10));
|
||||
BinaryOperator *Remainder = BinaryOperator::Create(Instruction::SRem, RandFuncCall, max_offset_const, "", NewFirstBB);
|
||||
Remainder->removeFromParent();
|
||||
Remainder->insertAfter(RandFuncCall);
|
||||
nextInst = Remainder;
|
||||
}
|
||||
|
||||
/* Minimum rand value must be 1, so increment it. */
|
||||
ConstantInt* One = ConstantInt::get(M.getContext(), APInt(32, StringRef("1"), 10));
|
||||
BinaryOperator* AddOne = BinaryOperator::Create(Instruction::Add, nextInst, One, "", NewFirstBB);
|
||||
AddOne->removeFromParent();
|
||||
AddOne->insertAfter(nextInst);
|
||||
|
||||
/* Allocate the offset/padding */
|
||||
AllocaInst* allocaInstruction = new AllocaInst(IntegerType::get(M.getContext(), 8), AddOne, "", NewFirstBB);
|
||||
allocaInstruction->removeFromParent();
|
||||
allocaInstruction->insertAfter(AddOne);
|
||||
|
||||
/* Inline the rand() call. */
|
||||
InlineFunctionInfo IFI;
|
||||
InlineFunction(RandFuncCall, IFI);
|
||||
}
|
||||
}
|
||||
|
||||
/* Go to the old first block */
|
||||
BranchInst *br = BranchInst::Create (OldFirstBB, NewFirstBB);
|
||||
br->setSuccessor(0, OldFirstBB);
|
||||
|
||||
/* Static stack frame padding does not really need 2 basic blocks, but it may need call site instrumentation. */
|
||||
if(stackframe_static_padding) {
|
||||
bool ret = MergeBlockIntoPredecessor(OldFirstBB, this);
|
||||
assert(ret);
|
||||
|
||||
if(stackframe_caller_padding && max_offset > 0) {
|
||||
std::vector<User*> Users(F->use_begin(), F->use_end());
|
||||
while (!Users.empty()) {
|
||||
User *U = Users.back();
|
||||
Users.pop_back();
|
||||
if (Instruction *I = dyn_cast<Instruction>(U)) {
|
||||
Function *parent = I->getParent()->getParent();
|
||||
/* XXX Skipping MAGIC_ENTRY_POINT shouldn't be necessary. Check why. */
|
||||
if(MAGIC_IS_MAGIC_FUNC(M, parent) || parent->getName().equals(MAGIC_ENTRY_POINT)) {
|
||||
continue;
|
||||
}
|
||||
CallSite CS = PassUtil::getCallSiteFromInstruction(I);
|
||||
if(!CS.getInstruction()) {
|
||||
continue;
|
||||
}
|
||||
Function *calledFunction = getCalledFunctionFromCS(CS);
|
||||
if (CS.getInstruction() && !CS.arg_empty() && (calledFunction == F || calledFunction == NULL)) {
|
||||
new AllocaInst(IntegerType::get(M.getContext(), 8), ConstantInt::get(M.getContext(), APInt(64, (rand() % max_offset) + 1, 10)), "", I);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Basic block shifting. */
|
||||
if(func_max_bb_shift > 0) {
|
||||
Instruction *I;
|
||||
PassUtil::getAllocaInfo(F, NULL, &I);
|
||||
BasicBlock *firstBB = F->getBasicBlockList().begin();
|
||||
BasicBlock *splitBB = firstBB->splitBasicBlock(I, "split");
|
||||
BasicBlock *dummyBB = BasicBlock::Create(M.getContext(), "dummy", F, splitBB);
|
||||
if(!stackframe_caller_padding) {
|
||||
firstBB = NewFirstBB;
|
||||
}
|
||||
|
||||
/* Fill the dummy basic block with dummy instructions (using the prefetch intrinsic to emulate nop instructions), to shift the next basic block. */
|
||||
Function *prefetchIntrinsic = PassUtil::getIntrinsicFunction(M, Intrinsic::prefetch);
|
||||
std::vector<Value*> args;
|
||||
args.push_back(ConstantPointerNull::get(PointerType::get(IntegerType::get(M.getContext(), 8), 0)));
|
||||
args.push_back(ConstantInt::get(M.getContext(), APInt(32, 0)));
|
||||
args.push_back(ConstantInt::get(M.getContext(), APInt(32, 0)));
|
||||
#if LLVM_VERSION >= 30
|
||||
args.push_back(ConstantInt::get(M.getContext(), APInt(32, 0)));
|
||||
#endif
|
||||
unsigned shift = (rand() % func_max_bb_shift) + 1;
|
||||
do {
|
||||
PassUtil::createCallInstruction(prefetchIntrinsic, args, "", dummyBB);
|
||||
shift--;
|
||||
} while(shift > 0);
|
||||
BranchInst *br = BranchInst::Create (splitBB, dummyBB);
|
||||
br->setSuccessor(0, splitBB);
|
||||
|
||||
/* Place an opaque conditional branch (always unconditionally skips the dummy basic block). */
|
||||
Function *frameAddrIntrinsic = PassUtil::getIntrinsicFunction(M, Intrinsic::frameaddress);
|
||||
std::vector<Value*> frameAddrArgs;
|
||||
frameAddrArgs.push_back(ConstantInt::get(M.getContext(), APInt(32, 0)));
|
||||
Value *frameAddr = PassUtil::createCallInstruction(frameAddrIntrinsic, frameAddrArgs, "", firstBB->getTerminator());
|
||||
TerminatorInst *OldTI = firstBB->getTerminator();
|
||||
IRBuilder<> Builder(firstBB);
|
||||
ICmpInst* ExtraCase = new ICmpInst(OldTI, ICmpInst::ICMP_EQ, frameAddr, ConstantPointerNull::get(PointerType::get(IntegerType::get(M.getContext(), 8), 0)), "");
|
||||
Builder.CreateCondBr(ExtraCase, dummyBB, splitBB);
|
||||
OldTI->eraseFromParent();
|
||||
}
|
||||
}
|
||||
|
||||
}{
|
||||
|
||||
|
||||
#define __X(VAR) __XX(VAR)
|
||||
#define __XX(VAR) #VAR
|
||||
|
||||
/* heap and map padding */
|
||||
|
||||
{
|
||||
|
||||
/* Inject magic init call at the beginning of magic entry point function (before any allocaInsts).
|
||||
* Magic_init will return immediately if called for the second time, so both the magic pass and
|
||||
* this pass can insert call instructions into main
|
||||
* */
|
||||
std::vector<Value*> args;
|
||||
PassUtil::createCallInstruction(magicInitFunc, args, "", magicEntryPointFunc->getBasicBlockList().begin()->begin());
|
||||
|
||||
}{
|
||||
|
||||
/* set the global variables */
|
||||
|
||||
Function *magicDataInitFunc = M.getFunction(MAGIC_DATA_INIT_FUNC_NAME);
|
||||
if(!magicDataInitFunc){
|
||||
outs() <<"Error: no " << MAGIC_DATA_INIT_FUNC_NAME << "() found";
|
||||
exit(1);
|
||||
}
|
||||
Instruction *magicArrayBuildFuncInst = magicDataInitFunc->back().getTerminator();
|
||||
|
||||
GlobalVariable* magicRootVar = M.getNamedGlobal(MAGIC_ROOT_VAR_NAME);
|
||||
if(!magicRootVar) {
|
||||
outs() << "Error: no " << MAGIC_ROOT_VAR_NAME << " variable found";
|
||||
exit(1);
|
||||
}
|
||||
|
||||
Value *seedValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_SEED);
|
||||
if(!seedValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_SEED << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, runtime_seed)), seedValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
Value *heapMapPermutateValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAP_DO_PERMUTATE);
|
||||
if(!heapMapPermutateValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAP_DO_PERMUTATE << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, heap_map_do_permutate)), heapMapPermutateValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
|
||||
Value *heapOffsetValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAX_OFFSET);
|
||||
if(!heapOffsetValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAX_OFFSET << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, heap_max_offset)), heapOffsetValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
Value *heapPaddingValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAX_PADDING);
|
||||
if(!heapPaddingValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_HEAP_MAX_PADDING << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, heap_max_padding)), heapPaddingValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
|
||||
Value *mapOffsetValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_MAP_MAX_OFFSET_PAGES);
|
||||
if(!mapOffsetValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_MAP_MAX_OFFSET_PAGES << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, map_max_offset_pages)), mapOffsetValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
Value *mapPaddingValue = MagicUtil::getMagicRStructFieldPtr(M, magicArrayBuildFuncInst, magicRootVar, MAGIC_RSTRUCT_FIELD_ASR_MAP_MAX_PADDING_PAGES);
|
||||
if(!mapPaddingValue) {
|
||||
outs() << "Error: no " << MAGIC_RSTRUCT_FIELD_ASR_MAP_MAX_PADDING_PAGES << " field found";
|
||||
exit(1);
|
||||
}
|
||||
new StoreInst(ConstantInt::get(M.getContext(), APInt(32, map_max_padding_pages)), mapPaddingValue, false, magicArrayBuildFuncInst);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
} // end namespace
|
||||
|
||||
char ASRPass::ID = 1;
|
||||
static RegisterPass<ASRPass> AP("asr", "Address Space Randomization Pass");
|
||||
8
minix/llvm/passes/asr/Makefile
Normal file
8
minix/llvm/passes/asr/Makefile
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
# Makefile for the ASR pass
|
||||
|
||||
MAGIC_SUPPORT_DIR=../magic/support
|
||||
|
||||
PASSNAME := asr
|
||||
OBJS := $(MAGIC_SUPPORT_DIR)/MagicUtil.o ASRPass.o
|
||||
|
||||
include ../Makefile.inc
|
||||
53
minix/llvm/passes/include/asr/ASRPass.h
Normal file
53
minix/llvm/passes/include/asr/ASRPass.h
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
#ifndef ASR_PASS_H
|
||||
|
||||
#define ASR_PASS_H
|
||||
|
||||
#include <pass.h>
|
||||
|
||||
#define DEFAULT_SEED 0
|
||||
|
||||
#define GV_DEFAULT_MAX_OFFSET 10000
|
||||
#define GV_DEFAULT_MAX_PADDING 50
|
||||
#define GV_DEFAULT_DO_PERMUTATE 1
|
||||
|
||||
#define FUNC_DEFAULT_MAX_OFFSET 10000
|
||||
#define FUNC_DEFAULT_MAX_PADDING 100
|
||||
#define FUNC_DEFAULT_MAX_BB_SHIFT 50
|
||||
#define FUNC_DEFAULT_DO_PERMUTATE 1
|
||||
|
||||
#define STACK_DEFAULT_DO_OFFSET 1
|
||||
#define STACK_DEFAULT_MAX_OFFSET 50
|
||||
|
||||
#define STACKFRAME_DEFAULT_DO_OFFSET 1
|
||||
#define STACKFRAME_DEFAULT_MAX_OFFSET 50
|
||||
#define STACKFRAME_DEFAULT_MAX_PADDING 5000
|
||||
#define STACKFRAME_DEFAULT_DO_PERMUTATE 1
|
||||
#define STACKFRAME_DEFAULT_STATIC_PADDING 1
|
||||
#define STACKFRAME_DEFAULT_CALLER_PADDING 1
|
||||
|
||||
#define HEAP_MAP_DEFAULT_DO_PERMUTATE 1
|
||||
|
||||
#define HEAP_DEFAULT_MAX_OFFSET 10000
|
||||
#define HEAP_DEFAULT_MAX_PADDING 100
|
||||
|
||||
#define MAP_DEFAULT_MAX_OFFSET_PAGES 10
|
||||
#define MAP_DEFAULT_MAX_PADDING_PAGES 3
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class ASRPass : public ModulePass {
|
||||
|
||||
public:
|
||||
static char ID;
|
||||
|
||||
ASRPass();
|
||||
|
||||
virtual bool runOnModule(Module &M);
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue