1041 lines
41 KiB
C
1041 lines
41 KiB
C
// SPDX-FileCopyrightText: 2020 Florian Märkl <info@florianmaerkl.de>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
|
|
#include "analysis_private.h"
|
|
#include <rz_core.h>
|
|
#include <rz_windows.h>
|
|
#include "minunit.h"
|
|
|
|
#include "mock_io.inl"
|
|
|
|
#include "test_analysis_block_invars.inl"
|
|
#define check_invariants block_check_invariants
|
|
#define check_leaks block_check_leaks
|
|
|
|
static size_t blocks_count(RzAnalysis *analysis) {
|
|
size_t count = 0;
|
|
RBIter iter;
|
|
RzAnalysisBlock *block;
|
|
RBTree *bb_tree = rz_analysis_get_bb_tree(analysis);
|
|
rz_rbtree_foreach ((*bb_tree), iter, block, RzAnalysisBlock, _rb) {
|
|
count++;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
bool test_rz_analysis_block_create() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
mu_assert_eq(blocks_count(analysis), 0, "initial count");
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
mu_assert("created block", block);
|
|
mu_assert_eq(block->addr, 0x1337, "created addr");
|
|
mu_assert_eq(block->size, 42, "created size");
|
|
mu_assert_eq(block->ref, 1, "created initial ref");
|
|
mu_assert_eq(block->sp_entry, RZ_STACK_ADDR_INVALID, "created sp_entry");
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after create");
|
|
|
|
RzAnalysisBlock *block2 = rz_analysis_create_block(analysis, 0x133f, 100);
|
|
assert_block_invariants(analysis);
|
|
mu_assert("created block (overlap)", block2);
|
|
mu_assert_eq(block2->addr, 0x133f, "created addr");
|
|
mu_assert_eq(block2->size, 100, "created size");
|
|
mu_assert_eq(block2->ref, 1, "created initial ref");
|
|
mu_assert_eq(block2->sp_entry, RZ_STACK_ADDR_INVALID, "created sp_entry");
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after create");
|
|
|
|
RzAnalysisBlock *block3 = rz_analysis_create_block(analysis, 0x1337, 5);
|
|
assert_block_invariants(analysis);
|
|
mu_assert("no double create on same start", !block3);
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after failed create");
|
|
|
|
rz_analysis_block_unref(block);
|
|
rz_analysis_block_unref(block2);
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_contains() {
|
|
RzAnalysisBlock dummy = { 0 };
|
|
dummy.addr = 0x1337;
|
|
dummy.size = 42;
|
|
mu_assert("contains before", !rz_analysis_block_contains(&dummy, 100));
|
|
mu_assert("contains start", rz_analysis_block_contains(&dummy, 0x1337));
|
|
mu_assert("contains inside", rz_analysis_block_contains(&dummy, 0x1339));
|
|
mu_assert("contains last", rz_analysis_block_contains(&dummy, 0x1337 + 42 - 1));
|
|
mu_assert("contains after", !rz_analysis_block_contains(&dummy, 0x1337 + 42));
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_sp() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
ut64 base = 0xfa1afe1;
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, base, 42);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after create");
|
|
|
|
// while ninstr == 0, nothing is known except delta at 0 (always 0)
|
|
st16 delta = rz_analysis_block_get_op_sp_delta(block, 0);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 4);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 5);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base);
|
|
mu_assert_eq(delta, 0, "sp delta at 0");
|
|
delta = rz_analysis_block_get_sp_delta_at_end(block);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
|
|
block->ninstr = 5;
|
|
|
|
// with ninstr > 0, but nothing set yet, still nothing new is known
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 0);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 4);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 5);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base);
|
|
mu_assert_eq(delta, 0, "sp delta at 0");
|
|
delta = rz_analysis_block_get_sp_delta_at_end(block);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
|
|
// after setting one sp delta, this one is known, but nothing else around
|
|
bool succ = rz_analysis_block_set_op_sp_delta(block, 2, -8);
|
|
mu_assert_true(succ, "sp delta set");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 1);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 2);
|
|
mu_assert_eq(delta, -8, "sp delta known after set");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 3);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
delta = rz_analysis_block_get_sp_delta_at_end(block);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta unknown");
|
|
|
|
// fill up the sp deltas for the remaining ops
|
|
succ = rz_analysis_block_set_op_sp_delta(block, 4, -24);
|
|
mu_assert_true(succ, "sp delta set");
|
|
succ = rz_analysis_block_set_op_sp_delta(block, 0, -4);
|
|
mu_assert_true(succ, "sp delta set");
|
|
succ = rz_analysis_block_set_op_sp_delta(block, 1, -5);
|
|
mu_assert_true(succ, "sp delta set");
|
|
succ = rz_analysis_block_set_op_sp_delta(block, 3, -16);
|
|
mu_assert_true(succ, "sp delta set");
|
|
succ = rz_analysis_block_set_op_sp_delta(block, 5, -42);
|
|
mu_assert_false(succ, "set at i >= ninstr");
|
|
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 0);
|
|
mu_assert_eq(delta, -4, "sp delta known after set");
|
|
delta = rz_analysis_block_get_op_sp_delta(block, 5);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta oob");
|
|
|
|
// without knowing the op offsets yet, delta by address is at least known
|
|
// at the beginning and after the end of the block
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base);
|
|
mu_assert_eq(delta, 0, "sp delta at 0");
|
|
delta = rz_analysis_block_get_sp_delta_at_end(block);
|
|
mu_assert_eq(delta, -24, "sp delta at end");
|
|
|
|
// absolute sps are not known until sp_delta is set
|
|
RzStackAddr sp = rz_analysis_block_get_sp_at(block, base);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp unknown");
|
|
sp = rz_analysis_block_get_sp_at_end(block);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp unknown");
|
|
|
|
rz_analysis_block_set_op_offset(block, 1, 1);
|
|
rz_analysis_block_set_op_offset(block, 2, 2);
|
|
rz_analysis_block_set_op_offset(block, 3, 4);
|
|
rz_analysis_block_set_op_offset(block, 4, 30);
|
|
|
|
// with the op offsets, all deltas by address are known
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base);
|
|
mu_assert_eq(delta, 0, "sp delta at 0");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 1);
|
|
mu_assert_eq(delta, -4, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 2);
|
|
mu_assert_eq(delta, -5, "sp delta known through op offset");
|
|
// When inside an instruction, we want to get the sp delta at the instruction's beginning
|
|
// as the best known value here.
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 3);
|
|
mu_assert_eq(delta, -5, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 4);
|
|
mu_assert_eq(delta, -8, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 10);
|
|
mu_assert_eq(delta, -8, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 30);
|
|
mu_assert_eq(delta, -16, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 41);
|
|
mu_assert_eq(delta, -16, "sp delta known through op offset");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base + 42);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta oob");
|
|
delta = rz_analysis_block_get_sp_delta_at(block, base - 1);
|
|
mu_assert_eq(delta, ST16_MAX, "sp delta oob");
|
|
delta = rz_analysis_block_get_sp_delta_at_end(block);
|
|
mu_assert_eq(delta, -24, "sp delta at end");
|
|
|
|
// absolute sps still not known until sp_delta is set
|
|
sp = rz_analysis_block_get_sp_at(block, base);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp unknown");
|
|
sp = rz_analysis_block_get_sp_at_end(block);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp unknown");
|
|
|
|
// complete all info by setting sp_entry
|
|
block->sp_entry = -1000;
|
|
|
|
// now all actual sps are known for the block
|
|
sp = rz_analysis_block_get_sp_at(block, base);
|
|
mu_assert_eq(sp, -1000, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 1);
|
|
mu_assert_eq(sp, -1004, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 2);
|
|
mu_assert_eq(sp, -1005, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 3);
|
|
mu_assert_eq(sp, -1005, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 4);
|
|
mu_assert_eq(sp, -1008, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 10);
|
|
mu_assert_eq(sp, -1008, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 30);
|
|
mu_assert_eq(sp, -1016, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 41);
|
|
mu_assert_eq(sp, -1016, "sp known");
|
|
sp = rz_analysis_block_get_sp_at(block, base + 42);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp oob");
|
|
sp = rz_analysis_block_get_sp_at(block, base - 1);
|
|
mu_assert_eq(sp, RZ_STACK_ADDR_INVALID, "sp oob");
|
|
sp = rz_analysis_block_get_sp_at_end(block);
|
|
mu_assert_eq(sp, -1024, "sp at end");
|
|
|
|
rz_analysis_block_unref(block);
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_split() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after create");
|
|
block->jump = 0xdeadbeef;
|
|
block->fail = 0xc0ffee;
|
|
block->ninstr = 5;
|
|
rz_analysis_block_set_op_offset(block, 0, 0);
|
|
rz_analysis_block_set_op_offset(block, 1, 1);
|
|
rz_analysis_block_set_op_offset(block, 2, 2);
|
|
rz_analysis_block_set_op_offset(block, 3, 4);
|
|
rz_analysis_block_set_op_offset(block, 4, 30);
|
|
block->sp_entry = -1000;
|
|
rz_analysis_block_set_op_sp_delta(block, 0, -4);
|
|
rz_analysis_block_set_op_sp_delta(block, 1, -8);
|
|
rz_analysis_block_set_op_sp_delta(block, 2, -13);
|
|
rz_analysis_block_set_op_sp_delta(block, 3, -18);
|
|
rz_analysis_block_set_op_sp_delta(block, 4, -23);
|
|
|
|
RzAnalysisBlock *second = rz_analysis_block_split(block, 0x1337);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_ptreq(second, block, "nop split on first addr");
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after nop split");
|
|
mu_assert_eq(block->ref, 2, "ref after nop split");
|
|
rz_analysis_block_unref(block);
|
|
|
|
second = rz_analysis_block_split(block, 0x1339);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_ptrneq(second, block, "non-nop split");
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after non-nop split");
|
|
|
|
mu_assert_eq(block->addr, 0x1337, "first addr after split");
|
|
mu_assert_eq(block->size, 2, "first size after split");
|
|
mu_assert_eq(second->addr, 0x1339, "first addr after split");
|
|
mu_assert_eq(second->size, 40, "first size after split");
|
|
|
|
mu_assert_eq(block->jump, second->addr, "first jump");
|
|
mu_assert_eq(block->fail, UT64_MAX, "first fail");
|
|
mu_assert_eq(second->jump, 0xdeadbeef, "second jump");
|
|
mu_assert_eq(second->fail, 0xc0ffee, "second fail");
|
|
|
|
mu_assert_eq(block->ninstr, 2, "first ninstr after split");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "first op_pos[0]");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 1, "first op_pos[1]");
|
|
mu_assert_eq(block->sp_entry, -1000, "first sp_entry after split");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 0), -4, "first sp_delta[0]");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 1), -8, "first sp_delta[1]");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 2), ST16_MAX, "first sp_delta[3]");
|
|
mu_assert_eq(rz_analysis_block_get_sp_delta_at_end(block), -8, "first sp_delta at end");
|
|
mu_assert_eq(rz_analysis_block_get_sp_at_end(block), -1008, "first sp at end");
|
|
|
|
mu_assert_eq(second->ninstr, 3, "second ninstr after split");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(second, 0), 0, "second op_pos[0]");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(second, 1), 2, "second op_pos[1]");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(second, 2), 28, "second op_pos[2]");
|
|
mu_assert_eq(second->sp_entry, -1008, "second sp_entry after split");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(second, 0), -5, "second sp_delta[0]");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(second, 1), -10, "second sp_delta[1]");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(second, 2), -15, "second sp_delta[2]");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(second, 3), ST16_MAX, "second sp_delta[3]");
|
|
mu_assert_eq(rz_analysis_block_get_sp_delta_at_end(second), -15, "second sp_delta at end");
|
|
mu_assert_eq(rz_analysis_block_get_sp_at_end(second), -1023, "second sp at end");
|
|
|
|
rz_analysis_block_unref(block);
|
|
rz_analysis_block_unref(second);
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_split_in_function() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisFunction *fcn = rz_analysis_create_function(analysis, "bbowner", 0x1337, RZ_ANALYSIS_FCN_TYPE_NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after create");
|
|
rz_analysis_function_add_block(fcn, block);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->ref, 2, "block refs after adding to function");
|
|
|
|
RzAnalysisBlock *second = rz_analysis_block_split(block, 0x1339);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_ptrneq(second, block, "non-nop split");
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after non-nop split");
|
|
mu_assert_eq(block->ref, 2, "first block refs after adding to function");
|
|
mu_assert_eq(second->ref, 2, "second block refs after adding to function");
|
|
|
|
mu_assert("function has first block after split", rz_pvector_contains(fcn->bbs, block));
|
|
mu_assert("function has second block after split", rz_pvector_contains(fcn->bbs, second));
|
|
mu_assert("second block is in function after split", rz_list_contains(block->fcns, fcn));
|
|
mu_assert("second block is in function after split", rz_list_contains(second->fcns, fcn));
|
|
|
|
rz_analysis_block_unref(block);
|
|
rz_analysis_block_unref(second);
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_merge() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *first = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
RzAnalysisBlock *second = rz_analysis_create_block(analysis, 0x1337 + 42, 624);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after create");
|
|
second->jump = 0xdeadbeef;
|
|
second->fail = 0xc0ffee;
|
|
|
|
first->ninstr = 3;
|
|
rz_analysis_block_set_op_offset(first, 0, 0);
|
|
rz_analysis_block_set_op_offset(first, 1, 13);
|
|
rz_analysis_block_set_op_offset(first, 2, 16);
|
|
|
|
second->ninstr = 4;
|
|
rz_analysis_block_set_op_offset(second, 0, 0);
|
|
rz_analysis_block_set_op_offset(second, 1, 4);
|
|
rz_analysis_block_set_op_offset(second, 2, 9);
|
|
rz_analysis_block_set_op_offset(second, 3, 30);
|
|
|
|
bool success = rz_analysis_block_merge(first, second);
|
|
assert_block_invariants(analysis);
|
|
mu_assert("merge success", success);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after merge");
|
|
mu_assert_eq(first->addr, 0x1337, "addr after merge");
|
|
mu_assert_eq(first->size, 666, "size after merge");
|
|
mu_assert_eq(first->jump, 0xdeadbeef, "jump after merge");
|
|
mu_assert_eq(first->fail, 0xc0ffee, "fail after merge");
|
|
|
|
mu_assert_eq(first->ninstr, 3 + 4, "ninstr after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 0), 0, "offset 0 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 1), 13, "offset 1 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 2), 16, "offset 2 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 3), 42 + 0, "offset 3 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 4), 42 + 4, "offset 4 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 5), 42 + 9, "offset 5 after merge");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(first, 6), 42 + 30, "offset 6 after merge");
|
|
|
|
rz_analysis_block_unref(first);
|
|
// second must be already freed by the merge!
|
|
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_merge_in_function() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisFunction *fcn = rz_analysis_create_function(analysis, "bbowner", 0x1337, RZ_ANALYSIS_FCN_TYPE_NULL);
|
|
|
|
RzAnalysisBlock *first = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
RzAnalysisBlock *second = rz_analysis_create_block(analysis, 0x1337 + 42, 624);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 2, "count after create");
|
|
|
|
rz_analysis_function_add_block(fcn, first);
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_function_add_block(fcn, second);
|
|
assert_block_invariants(analysis);
|
|
|
|
bool success = rz_analysis_block_merge(first, second);
|
|
assert_block_invariants(analysis);
|
|
mu_assert("merge success", success);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after merge");
|
|
mu_assert_eq(rz_pvector_len(fcn->bbs), 1, "fcn bbs after merge");
|
|
mu_assert_eq(rz_list_length(first->fcns), 1, "bb functions after merge");
|
|
mu_assert("function has merged block", rz_pvector_contains(fcn->bbs, first));
|
|
mu_assert("merged block is in function", rz_list_contains(first->fcns, fcn));
|
|
|
|
rz_analysis_block_unref(first);
|
|
// second must be already freed by the merge!
|
|
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_delete() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisFunction *fcn = rz_analysis_create_function(analysis, "bbowner", 0x1337, RZ_ANALYSIS_FCN_TYPE_NULL);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(blocks_count(analysis), 1, "count after create");
|
|
|
|
rz_analysis_function_add_block(fcn, block);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->ref, 2, "refs after adding");
|
|
mu_assert_eq(rz_pvector_len(fcn->bbs), 1, "fcn bbs after add");
|
|
mu_assert_eq(rz_list_length(block->fcns), 1, "bb fcns after add");
|
|
|
|
rz_analysis_delete_block(block);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->ref, 1, "refs after delete");
|
|
mu_assert_eq(rz_pvector_len(fcn->bbs), 0, "fcn bbs after delete");
|
|
mu_assert_eq(rz_list_length(block->fcns), 0, "bb fcns after delete");
|
|
|
|
rz_analysis_block_unref(block);
|
|
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_set_size() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisFunction *fcn = rz_analysis_create_function(analysis, "bbowner", 0x1337, RZ_ANALYSIS_FCN_TYPE_NULL);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_function_add_block(fcn, block);
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_block_set_size(block, 300);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->size, 300, "size after set_size");
|
|
|
|
RzAnalysisBlock *second = rz_analysis_create_block(analysis, 0x1337 + 300, 100);
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_function_add_block(fcn, block);
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_function_linear_size(fcn); // trigger lazy calculation of min/max cache
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_block_set_size(second, 500);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(second->size, 500, "size after set_size");
|
|
|
|
rz_analysis_block_set_size(block, 80);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->size, 80, "size after set_size");
|
|
|
|
rz_analysis_block_unref(block);
|
|
rz_analysis_block_unref(second);
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_relocate() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisFunction *fcn = rz_analysis_create_function(analysis, "bbowner", 0x1337, RZ_ANALYSIS_FCN_TYPE_NULL);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(analysis, 0x1337, 42);
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_function_add_block(fcn, block);
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_function_linear_size(fcn); // trigger lazy calculation of min/max cache
|
|
assert_block_invariants(analysis);
|
|
|
|
bool success = rz_analysis_block_relocate(block, 0x200, 0x100);
|
|
mu_assert("relocate success", success);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->addr, 0x200, "addr after relocate");
|
|
mu_assert_eq(block->size, 0x100, "size after relocate");
|
|
|
|
RzAnalysisBlock *second = rz_analysis_create_block(analysis, 0x1337 + 300, 100);
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_function_add_block(fcn, second);
|
|
assert_block_invariants(analysis);
|
|
|
|
success = rz_analysis_block_relocate(second, 0x400, 0x123);
|
|
mu_assert("relocate success", success);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(second->addr, 0x400, "addr after relocate");
|
|
mu_assert_eq(second->size, 0x123, "size after relocate");
|
|
rz_analysis_function_linear_size(fcn); // trigger lazy calculation of min/max cache
|
|
assert_block_invariants(analysis);
|
|
|
|
success = rz_analysis_block_relocate(block, 0x400, 0x333);
|
|
mu_assert("relocate fail on same addr", !success);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->addr, 0x200, "addr after failed relocate");
|
|
mu_assert_eq(block->size, 0x100, "size after failed relocate");
|
|
rz_analysis_function_linear_size(fcn); // trigger lazy calculation of min/max cache
|
|
assert_block_invariants(analysis);
|
|
|
|
// jump after the other block
|
|
success = rz_analysis_block_relocate(block, 0x500, 0x333);
|
|
mu_assert("relocate success", success);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->addr, 0x500, "addr after failed relocate");
|
|
mu_assert_eq(block->size, 0x333, "size after failed relocate");
|
|
rz_analysis_function_linear_size(fcn); // trigger lazy calculation of min/max cache
|
|
assert_block_invariants(analysis);
|
|
|
|
// jump before the other block
|
|
success = rz_analysis_block_relocate(block, 0x10, 0x333);
|
|
mu_assert("relocate success", success);
|
|
assert_block_invariants(analysis);
|
|
mu_assert_eq(block->addr, 0x10, "addr after failed relocate");
|
|
mu_assert_eq(block->size, 0x333, "size after failed relocate");
|
|
|
|
rz_analysis_block_unref(block);
|
|
rz_analysis_block_unref(second);
|
|
assert_block_invariants(analysis);
|
|
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_query() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
#define N 200
|
|
#define MAXSIZE 0x300
|
|
#define SPACE 0x10000
|
|
#define SAMPLES 300
|
|
|
|
RzAnalysisBlock *blocks[N];
|
|
size_t i;
|
|
for (i = 0; i < N; i++) {
|
|
blocks[i] = rz_analysis_create_block(analysis, rand() % SPACE, rand() % MAXSIZE); // may return null on duplicates
|
|
assert_block_invariants(analysis);
|
|
}
|
|
|
|
// --
|
|
// test rz_analysis_get_block_at()
|
|
|
|
for (i = 0; i < N; i++) {
|
|
if (!blocks[i]) {
|
|
continue;
|
|
}
|
|
mu_assert_ptreq(rz_analysis_get_block_at(analysis, blocks[i]->addr), blocks[i], "rz_analysis_get_block_at");
|
|
}
|
|
|
|
for (i = 0; i < SAMPLES; i++) {
|
|
ut64 addr = rand() % SPACE;
|
|
size_t j;
|
|
|
|
// goal is to check cases where rz_analysis_get_block_at() returns null,
|
|
// but since the addr is random, there may be a block sometimes too.
|
|
RzAnalysisBlock *block = NULL;
|
|
for (j = 0; j < N; j++) {
|
|
if (!blocks[j]) {
|
|
continue;
|
|
}
|
|
if (blocks[j]->addr == addr) {
|
|
block = blocks[j];
|
|
break;
|
|
}
|
|
}
|
|
|
|
mu_assert_ptreq(rz_analysis_get_block_at(analysis, addr), block, "rz_analysis_get_block_at");
|
|
}
|
|
|
|
// --
|
|
// test rz_analysis_get_blocks_in()
|
|
|
|
for (i = 0; i < SAMPLES; i++) {
|
|
ut64 addr = rand() % SPACE;
|
|
RzList *in = rz_analysis_get_blocks_in(analysis, addr);
|
|
|
|
RzAnalysisBlock *block;
|
|
RzListIter *it;
|
|
rz_list_foreach (in, it, block) {
|
|
mu_assert_eq(block->ref, 2, "block refd in returned list");
|
|
}
|
|
|
|
size_t linear_found = 0;
|
|
size_t j;
|
|
for (j = 0; j < N; j++) {
|
|
if (!blocks[j]) {
|
|
continue;
|
|
}
|
|
if (rz_analysis_block_contains(blocks[j], addr)) {
|
|
linear_found++;
|
|
mu_assert("intersect linear found in list", rz_list_contains(in, blocks[j]));
|
|
}
|
|
}
|
|
mu_assert_eq((size_t)rz_list_length(in), linear_found, "rz_analysis_get_blocks_in count");
|
|
rz_list_free(in);
|
|
}
|
|
|
|
// --
|
|
// test rz_analysis_get_blocks_intersect()
|
|
|
|
for (i = 0; i < SAMPLES; i++) {
|
|
ut64 addr = rand() % SPACE;
|
|
ut64 size = rand() % MAXSIZE;
|
|
RzList *in = rz_analysis_get_blocks_intersect(analysis, addr, size);
|
|
|
|
RzAnalysisBlock *block;
|
|
RzListIter *it;
|
|
rz_list_foreach (in, it, block) {
|
|
mu_assert_eq(block->ref, 2, "block refd in returned list");
|
|
}
|
|
|
|
size_t linear_found = 0;
|
|
size_t j;
|
|
for (j = 0; j < N; j++) {
|
|
RzAnalysisBlock *block = blocks[j];
|
|
if (!block || addr + size <= block->addr || addr >= block->addr + block->size) {
|
|
continue;
|
|
}
|
|
linear_found++;
|
|
mu_assert("in linear found in list", rz_list_contains(in, blocks[j]));
|
|
}
|
|
mu_assert_eq((size_t)rz_list_length(in), linear_found, "rz_analysis_get_blocks_intersect count");
|
|
rz_list_free(in);
|
|
}
|
|
|
|
for (i = 0; i < N; i++) {
|
|
rz_analysis_block_unref(blocks[i]);
|
|
}
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool addr_list_cb(ut64 addr, void *user) {
|
|
RzList *list = user;
|
|
rz_list_push(list, (void *)(size_t)addr);
|
|
return true;
|
|
}
|
|
|
|
bool test_rz_analysis_block_successors() {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *blocks[10];
|
|
blocks[0] = rz_analysis_create_block(analysis, 0x10, 0x10);
|
|
blocks[1] = rz_analysis_create_block(analysis, 0x30, 0x10);
|
|
blocks[2] = rz_analysis_create_block(analysis, 0x50, 0x10);
|
|
blocks[3] = rz_analysis_create_block(analysis, 0x100, 0x10);
|
|
blocks[4] = rz_analysis_create_block(analysis, 0x110, 0x10);
|
|
blocks[5] = rz_analysis_create_block(analysis, 0x120, 0x10);
|
|
blocks[6] = rz_analysis_create_block(analysis, 0x130, 0x10);
|
|
blocks[7] = rz_analysis_create_block(analysis, 0x140, 0x10);
|
|
blocks[8] = rz_analysis_create_block(analysis, 0xa0, 0x10);
|
|
blocks[9] = rz_analysis_create_block(analysis, 0xc0, 0x10);
|
|
assert_block_invariants(analysis);
|
|
|
|
blocks[0]->jump = 0x30;
|
|
blocks[0]->fail = 0x50;
|
|
blocks[1]->jump = 0x10;
|
|
blocks[1]->fail = 0x50;
|
|
blocks[2]->jump = 0x10;
|
|
|
|
RzAnalysisSwitchOp *sop = rz_analysis_switch_op_new(0x55, 0x13, 0x15, 0x42);
|
|
mu_assert_eq(sop->addr, 0x55, "addr");
|
|
mu_assert_eq(sop->min_val, 0x13, "addr");
|
|
mu_assert_eq(sop->max_val, 0x15, "addr");
|
|
mu_assert_eq(sop->def_val, 0x42, "addr");
|
|
rz_analysis_switch_op_add_case(sop, 0x55, 1, 0x100);
|
|
rz_analysis_switch_op_add_case(sop, 0x55, 2, 0x110);
|
|
rz_analysis_switch_op_add_case(sop, 0x55, 3, 0x120);
|
|
rz_analysis_switch_op_add_case(sop, 0x55, 4, 0x130);
|
|
rz_analysis_switch_op_add_case(sop, 0x55, 5, 0x140);
|
|
blocks[2]->switch_op = sop;
|
|
|
|
RzList *result = rz_list_new();
|
|
rz_analysis_block_successor_addrs_foreach(blocks[0], addr_list_cb, result);
|
|
mu_assert_eq(rz_list_length(result), 2, "jump/fail successors count");
|
|
mu_assert("jmp successor", rz_list_contains(result, (void *)0x30));
|
|
mu_assert("fail successor", rz_list_contains(result, (void *)0x50));
|
|
rz_list_purge(result);
|
|
|
|
rz_analysis_block_successor_addrs_foreach(blocks[2], addr_list_cb, result);
|
|
mu_assert_eq(rz_list_length(result), 6, "switch successors count");
|
|
mu_assert("jmp successor", rz_list_contains(result, (void *)0x10));
|
|
mu_assert("case successor", rz_list_contains(result, (void *)0x100));
|
|
mu_assert("case successor", rz_list_contains(result, (void *)0x110));
|
|
mu_assert("case successor", rz_list_contains(result, (void *)0x120));
|
|
mu_assert("case successor", rz_list_contains(result, (void *)0x130));
|
|
mu_assert("case successor", rz_list_contains(result, (void *)0x140));
|
|
rz_list_free(result);
|
|
|
|
result = rz_analysis_block_recurse_list(blocks[0]);
|
|
RzAnalysisBlock *block;
|
|
RzListIter *it;
|
|
rz_list_foreach (result, it, block) {
|
|
mu_assert_eq(block->ref, 2, "block refd in returned list");
|
|
}
|
|
|
|
mu_assert_eq(rz_list_length(result), 8, "recursive successors count");
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[0]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[1]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[2]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[3]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[4]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[5]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[6]));
|
|
mu_assert("recursive successor", rz_list_contains(result, blocks[7]));
|
|
|
|
rz_list_free(result);
|
|
|
|
size_t i;
|
|
for (i = 0; i < sizeof(blocks) / sizeof(RzAnalysisBlock *); i++) {
|
|
rz_analysis_block_unref(blocks[i]);
|
|
}
|
|
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_automerge() {
|
|
size_t i;
|
|
for (i = 0; i < SAMPLES; i++) {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *a = rz_analysis_create_block(analysis, 0x100, 0x10);
|
|
|
|
RzAnalysisBlock *b = rz_analysis_create_block(analysis, 0x110, 0x10);
|
|
a->jump = b->addr;
|
|
|
|
RzAnalysisBlock *c = rz_analysis_create_block(analysis, 0x120, 0x10);
|
|
b->jump = c->addr;
|
|
c->fail = b->addr;
|
|
|
|
RzAnalysisBlock *d = rz_analysis_create_block(analysis, 0x130, 0x10);
|
|
c->jump = d->addr;
|
|
|
|
RzAnalysisBlock *e = rz_analysis_create_block(analysis, 0x140, 0x10);
|
|
d->jump = e->addr;
|
|
|
|
RzAnalysisBlock *f = rz_analysis_create_block(analysis, 0x150, 0x10);
|
|
e->jump = f->addr;
|
|
|
|
RzAnalysisFunction *fa = rz_analysis_create_function(analysis, "fcn", 0x100, RZ_ANALYSIS_FCN_TYPE_FCN);
|
|
rz_analysis_function_add_block(fa, a);
|
|
rz_analysis_function_add_block(fa, c);
|
|
rz_analysis_function_add_block(fa, d);
|
|
rz_analysis_function_add_block(fa, e);
|
|
rz_analysis_function_add_block(fa, f);
|
|
|
|
RzAnalysisFunction *fb = rz_analysis_create_function(analysis, "fcn2", 0x110, RZ_ANALYSIS_FCN_TYPE_FCN);
|
|
rz_analysis_function_add_block(fb, b);
|
|
rz_analysis_function_add_block(fb, c);
|
|
rz_analysis_function_add_block(fb, d);
|
|
rz_analysis_function_add_block(fb, e);
|
|
rz_analysis_function_add_block(fb, f);
|
|
|
|
RzList *all_blocks = rz_list_new();
|
|
rz_list_push(all_blocks, a);
|
|
rz_list_push(all_blocks, b);
|
|
rz_list_push(all_blocks, c);
|
|
rz_list_push(all_blocks, d);
|
|
rz_list_push(all_blocks, e);
|
|
rz_list_push(all_blocks, f);
|
|
|
|
// Randomize the order in which we give the automerge the block.
|
|
// The outcome should always be the same but it can have some delicate implications on the algorithm inside.
|
|
RzPVector *shuffled_blocks = rz_pvector_new((RzPVectorFree)rz_analysis_block_unref);
|
|
while (!rz_list_empty(all_blocks)) {
|
|
int n = rand() % rz_list_length(all_blocks);
|
|
rz_pvector_push(shuffled_blocks, rz_list_get_n(all_blocks, n));
|
|
rz_list_del_n(all_blocks, n);
|
|
}
|
|
rz_list_free(all_blocks);
|
|
|
|
rz_analysis_block_automerge(shuffled_blocks);
|
|
assert_block_invariants(analysis);
|
|
// mu_assert_eq (rz_list_length (shuffled_blocks), 4, "length after automerge");
|
|
mu_assert("remaining blocks a", rz_pvector_contains(shuffled_blocks, a));
|
|
mu_assert("remaining blocks b", rz_pvector_contains(shuffled_blocks, b));
|
|
mu_assert("remaining blocks c", rz_pvector_contains(shuffled_blocks, c));
|
|
mu_assert("remaining blocks d", rz_pvector_contains(shuffled_blocks, d));
|
|
mu_assert_eq(blocks_count(analysis), rz_pvector_len(shuffled_blocks), "blocks in analysis count");
|
|
void **it;
|
|
RzAnalysisBlock *block;
|
|
rz_pvector_foreach (shuffled_blocks, it) {
|
|
block = (RzAnalysisBlock *)*it;
|
|
mu_assert_ptreq(rz_analysis_get_block_at(analysis, block->addr), block, "remaining blocks in analysis");
|
|
}
|
|
rz_pvector_free(shuffled_blocks);
|
|
|
|
assert_block_invariants(analysis);
|
|
assert_block_leaks(analysis);
|
|
rz_analysis_free(analysis);
|
|
}
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_chop_noreturn(void) {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
RzAnalysisBlock *a = rz_analysis_create_block(analysis, 0x100, 0x10);
|
|
RzAnalysisBlock *b = rz_analysis_create_block(analysis, 0x110, 0x10);
|
|
RzAnalysisBlock *c = rz_analysis_create_block(analysis, 0x120, 0x10);
|
|
a->jump = c->addr;
|
|
b->jump = c->addr;
|
|
|
|
RzAnalysisFunction *fa = rz_analysis_create_function(analysis, "fcn", 0x100, RZ_ANALYSIS_FCN_TYPE_FCN);
|
|
rz_analysis_function_add_block(fa, a);
|
|
rz_analysis_function_add_block(fa, b);
|
|
rz_analysis_function_add_block(fa, c);
|
|
|
|
RzAnalysisFunction *fb = rz_analysis_create_function(analysis, "fcn2", 0x130, RZ_ANALYSIS_FCN_TYPE_FCN);
|
|
fb->is_noreturn = true;
|
|
|
|
rz_analysis_block_chop_noreturn(b, 0x111);
|
|
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_free(analysis);
|
|
|
|
mu_end;
|
|
}
|
|
|
|
bool test_rz_analysis_block_chop_noreturn_last_instr(void) {
|
|
RzAnalysis *analysis = rz_analysis_new(NULL);
|
|
assert_block_invariants(analysis);
|
|
|
|
// Block a ends with a call to a noreturn function as its *last* instruction,
|
|
// so the fall-through address (where execution would continue if the callee
|
|
// returned) lands exactly at the end of the block, a->addr + a->size, which
|
|
// here is also the start of the following block b. chop_noreturn must still
|
|
// drop a's bogus fall-through edge even though the block itself does not need
|
|
// to be resized in this case. See issue #2725.
|
|
RzAnalysisBlock *a = rz_analysis_create_block(analysis, 0x100, 0x10);
|
|
RzAnalysisBlock *b = rz_analysis_create_block(analysis, 0x110, 0x10);
|
|
a->jump = b->addr;
|
|
|
|
RzAnalysisFunction *fa = rz_analysis_create_function(analysis, "fcn", 0x100, RZ_ANALYSIS_FCN_TYPE_FCN);
|
|
rz_analysis_function_add_block(fa, a);
|
|
rz_analysis_function_add_block(fa, b);
|
|
|
|
// Chop exactly at the end of block a (addr == a->addr + a->size). Use the
|
|
// returned block, since the automerge step may free the original pointer.
|
|
RzAnalysisBlock *chopped = rz_analysis_block_chop_noreturn(a, a->addr + a->size);
|
|
mu_assert_notnull(chopped, "block still exists after the chop");
|
|
mu_assert_eq(chopped->size, 0x10, "block size is unchanged when chopping at the block end");
|
|
mu_assert_eq(chopped->jump, UT64_MAX, "bogus fall-through jump is removed");
|
|
mu_assert_eq(chopped->fail, UT64_MAX, "no fail edge remains");
|
|
|
|
assert_block_invariants(analysis);
|
|
rz_analysis_free(analysis);
|
|
|
|
mu_end;
|
|
}
|
|
|
|
static const uint8_t example_code[0x18] = {
|
|
0x48, 0xc7, 0xc0, 0x2a, 0x00, 0x00, 0x00, // mov rax, 0x2a
|
|
0x48, 0x89, 0xc2, // mov rdx, rax
|
|
0x48, 0x81, 0xc2, 0x0f, 0x05, 0x00, 0x00, // add rdx, 0x50f
|
|
0x48, 0xc7, 0xc0, 0x37, 0x13, 0x00, 0x00 // mov rax, 0x1337
|
|
};
|
|
|
|
bool test_rz_analysis_block_analyze_ops(void) {
|
|
RzAnalysis *a = rz_analysis_new(NULL);
|
|
rz_analysis_use(a, "x86");
|
|
rz_analysis_set_bits(a, 64);
|
|
IOMock io;
|
|
RzIOBind *iob = rz_analysis_get_io_bind(a);
|
|
io_mock_init(&io, 0x1000, example_code, sizeof(example_code));
|
|
io_mock_bind(&io, iob);
|
|
|
|
// clean block with valid code
|
|
RzAnalysisBlock *block = rz_analysis_create_block(a, 0x1000, 0x18);
|
|
mu_assert_eq(block->ninstr, 0, "clean block");
|
|
rz_analysis_block_analyze_ops(block);
|
|
mu_assert_eq(block->ninstr, 4, "ninstr");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 0x7, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 2), 0xa, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 3), 0x11, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr(block, 0), 0x1000, "op addr");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr(block, 1), 0x1007, "op addr");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr(block, 2), 0x100a, "op addr");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr(block, 3), 0x1011, "op addr");
|
|
mu_assert_eq(rz_analysis_block_get_op_size(block, 0), 0x7, "op size");
|
|
mu_assert_eq(rz_analysis_block_get_op_size(block, 1), 0x3, "op size");
|
|
mu_assert_eq(rz_analysis_block_get_op_size(block, 2), 0x7, "op size");
|
|
mu_assert_eq(rz_analysis_block_get_op_size(block, 3), 0x7, "op size");
|
|
mu_assert_eq(rz_analysis_block_get_op_index_in(block, 0x1000), 0, "op index in");
|
|
mu_assert_eq(rz_analysis_block_get_op_index_in(block, 0x1001), 0, "op index in");
|
|
mu_assert_eq(rz_analysis_block_get_op_index_in(block, 0x1006), 0, "op index in");
|
|
mu_assert_eq(rz_analysis_block_get_op_index_in(block, 0x1007), 1, "op index in");
|
|
mu_assert_eq(rz_analysis_block_get_op_index_in(block, 0x1008), 1, "op index in");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr_in(block, 0x1000), 0x1000, "op addr in");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr_in(block, 0x1001), 0x1000, "op addr in");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr_in(block, 0x1006), 0x1000, "op addr in");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr_in(block, 0x1007), 0x1007, "op addr in");
|
|
mu_assert_eq(rz_analysis_block_get_op_addr_in(block, 0x1008), 0x1007, "op addr in");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 0), 0, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 1), 0, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 2), 0, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 3), 0, "sp delta");
|
|
|
|
// dirty block with valid code
|
|
rz_analysis_block_relocate(block, 0x1000, 0x11);
|
|
rz_analysis_block_analyze_ops(block);
|
|
mu_assert_eq(block->ninstr, 3, "ninstr");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 0x7, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 2), 0xa, "op offset");
|
|
|
|
rz_analysis_block_unref(block);
|
|
|
|
// clean block with invalid code a the end
|
|
// when encountering invalid code, analysis should stop.
|
|
block = rz_analysis_create_block(a, 0x1000, 0x17);
|
|
mu_assert_eq(block->ninstr, 0, "clean block");
|
|
rz_analysis_block_analyze_ops(block);
|
|
mu_assert_eq(block->ninstr, 3, "ninstr");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 0x7, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 2), 0xa, "op offset");
|
|
|
|
rz_analysis_block_unref(block);
|
|
|
|
assert_block_invariants(a);
|
|
assert_block_leaks(a);
|
|
rz_analysis_free(a);
|
|
io_mock_fini(&io);
|
|
mu_end;
|
|
}
|
|
|
|
static const uint8_t example_code_sp[0xa] = {
|
|
0x55, // push rbp
|
|
0x48, 0x89, 0xe5, // mov rbp, rsp
|
|
0x48, 0x83, 0xec, 0x20, // sub rsp, 0x20
|
|
0xc9, // leave
|
|
0x55, // push rbp
|
|
};
|
|
|
|
bool test_rz_analysis_block_analyze_ops_sp(void) {
|
|
RzAnalysis *a = rz_analysis_new(NULL);
|
|
rz_analysis_use(a, "x86");
|
|
rz_analysis_set_bits(a, 64);
|
|
IOMock io;
|
|
RzIOBind *iob = rz_analysis_get_io_bind(a);
|
|
io_mock_init(&io, 0x1000, example_code_sp, sizeof(example_code_sp));
|
|
io_mock_bind(&io, iob);
|
|
|
|
RzAnalysisBlock *block = rz_analysis_create_block(a, 0x1000, 0xa);
|
|
mu_assert_eq(block->ninstr, 0, "clean block");
|
|
rz_analysis_block_analyze_ops(block);
|
|
mu_assert_eq(block->ninstr, 5, "ninstr");
|
|
mu_assert_eq(block->sp_entry, RZ_STACK_ADDR_INVALID, "sp_entry untouched");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 0x1, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 2), 0x4, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 3), 0x8, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 4), 0x9, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 0), -8, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 1), -8, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 2), -0x28, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 3), 0, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 4), -8, "sp delta");
|
|
|
|
block->sp_entry = -0x10;
|
|
rz_analysis_block_analyze_ops(block);
|
|
mu_assert_eq(block->ninstr, 5, "ninstr");
|
|
mu_assert_eq(block->sp_entry, -0x10, "sp_entry untouched");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 0), 0, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 1), 0x1, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 2), 0x4, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 3), 0x8, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_offset(block, 4), 0x9, "op offset");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 0), -8, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 1), -8, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 2), -0x28, "sp delta");
|
|
// stack reset depends on the sp_entry, which makes the following difference to above:
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 3), 0x10, "sp delta");
|
|
mu_assert_eq(rz_analysis_block_get_op_sp_delta(block, 4), 8, "sp delta");
|
|
|
|
rz_analysis_block_unref(block);
|
|
|
|
assert_block_invariants(a);
|
|
assert_block_leaks(a);
|
|
rz_analysis_free(a);
|
|
io_mock_fini(&io);
|
|
mu_end;
|
|
}
|
|
|
|
int all_tests() {
|
|
mu_run_test(test_rz_analysis_block_chop_noreturn);
|
|
mu_run_test(test_rz_analysis_block_chop_noreturn_last_instr);
|
|
mu_run_test(test_rz_analysis_block_create);
|
|
mu_run_test(test_rz_analysis_block_contains);
|
|
mu_run_test(test_rz_analysis_block_sp);
|
|
mu_run_test(test_rz_analysis_block_split);
|
|
mu_run_test(test_rz_analysis_block_split_in_function);
|
|
mu_run_test(test_rz_analysis_block_merge);
|
|
mu_run_test(test_rz_analysis_block_merge_in_function);
|
|
mu_run_test(test_rz_analysis_block_delete);
|
|
mu_run_test(test_rz_analysis_block_set_size);
|
|
mu_run_test(test_rz_analysis_block_relocate);
|
|
mu_run_test(test_rz_analysis_block_query);
|
|
mu_run_test(test_rz_analysis_block_successors);
|
|
mu_run_test(test_rz_analysis_block_automerge);
|
|
mu_run_test(test_rz_analysis_block_analyze_ops);
|
|
mu_run_test(test_rz_analysis_block_analyze_ops_sp);
|
|
return tests_passed != tests_run;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
struct timeval tv;
|
|
rz_time_gettimeofday(&tv);
|
|
unsigned int seed = argc > 1 ? strtoul(argv[1], NULL, 0) : tv.tv_sec + tv.tv_usec;
|
|
printf("seed for test_analysis_block: %u\n", seed);
|
|
return all_tests();
|
|
}
|