vine_blocks_t * asmir_asmprogram_to_vine(asm_program_t *prog) {
vector<vine_block_t *> *res = new vector<vine_block_t *>();
// eww, references
*res = generate_vex_ir(prog);
generate_vine_ir(prog, *res);
return res;
}
vine_blocks_t *instmap_translate_address_range(instmap_t *insts,
address_t start,
address_t end)
{
translate_init();
vx_FreeAll();
vector<Instruction *> foo;
vine_blocks_t *ret = new vine_blocks_t;
for(address_t i = start; i <= end; i++){
if(insts->imap.find(i) == insts->imap.end()) continue;
foo.push_back(insts->imap.find(i)->second);
}
vector<vine_block_t *> blocks = generate_vex_ir(insts->prog, foo);
blocks = generate_vine_ir(insts->prog, blocks);
for(unsigned i = 0; i < blocks.size(); i++){
vine_block_t *block = blocks.at(i);
assert(block);
if(block->inst == NULL)
continue;
/* This is broken as it removes the jumps from the end of
repz instructions. Just because control flow eventually goes on
to the following instruction doesn't mean that jump is at the end.
It should simply be checking that the jump is to the following
instruction since we know where that is.
// If the statement isn't control flow, and not the last
// remove the dummy jumps to the next block that vex inserts
bfd_vma target;
int ctype = get_control_transfer_type(block->inst, &target);
Stmt *s;
switch(ctype){
case INST_CONT:
s = block->vine_ir->back();
if(s->stmt_type == JMP){
block->vine_ir->pop_back();
}
break;
default:
break;
}
*/
}
ret->insert(ret->end(), blocks.begin(), blocks.end());
for(vector<vine_block_t *>::iterator it = ret->begin();
it != ret->end(); it++){
vine_block_t *block = *it;
block->vex_ir = NULL; // this isn't available.
}
return ret;
}
// moved from ir_program.cpp
vine_block_t* asm_addr_to_ir(asm_program_t *p, address_t addr)
{
translate_init();
asm_function_t *f = get_nearest_function(p, addr);
assert(f);
assert(f->instmap.find(addr) != f->instmap.end());
Instruction *inst = f->instmap.find(addr)->second;
vector<Instruction *> instrs;
instrs.push_back(inst);
vector<vine_block_t *> vine_blocks = generate_vex_ir(p, instrs);
vine_blocks = generate_vine_ir(p, vine_blocks);
vx_FreeAll();
assert(vine_blocks.size() == 1);
return vine_blocks[0];
}
vine_block_t *instmap_translate_address(instmap_t *insts,
address_t addr)
{
translate_init();
vx_FreeAll();
vector<Instruction *> foo;
assert(insts->imap.find(addr) != insts->imap.end());
foo.push_back(insts->imap.find(addr)->second);
vector<vine_block_t *> blocks = generate_vex_ir(insts->prog, foo);
blocks = generate_vine_ir(insts->prog, blocks);
assert(blocks.size() == 1);
vine_block_t *block = *(blocks.begin());
block->vex_ir = NULL;
vx_FreeAll();
return block;
}
