static void
event_exit(void)
{
dr_mutex_destroy(syslock);
dr_mutex_destroy(threadlock);
CHECK(checked_tls_from_cache, "failed to hit clean call");
CHECK(checked_cls_from_cache, "failed to hit clean call");
CHECK(checked_tls_write_from_cache, "failed to hit clean call");
CHECK(checked_cls_write_from_cache, "failed to hit clean call");
CHECK(one_time_exec == 1, "failed to execute one-time event");
if (!drmgr_unregister_bb_instrumentation_event(event_bb_analysis))
CHECK(false, "drmgr unregistration failed");
if (!drmgr_unregister_bb_instrumentation_ex_event(event_bb4_app2app,
event_bb4_analysis,
event_bb4_insert,
event_bb4_instru2instru))
CHECK(false, "drmgr unregistration failed");
if (!drmgr_unregister_cls_field(event_thread_context_init,
event_thread_context_exit, cls_idx))
CHECK(false, "drmgr unregistration failed");
drmgr_exit();
dr_fprintf(STDERR, "all done\n");
}
DR_EXPORT
void
drmgr_exit(void)
{
static bool exited;
/* try to handle multiple calls to exit. still possible to crash
* trying to lock a destroyed lock.
*/
if (exited || !dr_mutex_trylock(exit_lock) || exited)
return;
exited = true;
drmgr_bb_exit();
drmgr_event_exit();
dr_rwlock_destroy(presys_event_lock);
dr_rwlock_destroy(cls_event_lock);
dr_mutex_destroy(tls_lock);
dr_rwlock_destroy(thread_event_lock);
dr_rwlock_destroy(bb_cb_lock);
dr_mutex_destroy(note_lock);
dr_mutex_unlock(exit_lock);
dr_mutex_destroy(exit_lock);
}
void
hashtable_delete(hashtable_t *table)
{
uint i;
if (table->synch)
dr_mutex_lock(table->lock);
for (i = 0; i < HASHTABLE_SIZE(table->table_bits); i++) {
hash_entry_t *e = table->table[i];
while (e != NULL) {
hash_entry_t *nexte = e->next;
if (table->str_dup)
hash_free(e->key, strlen((const char *)e->key) + 1);
if (table->free_payload_func != NULL)
(table->free_payload_func)(e->payload);
hash_free(e, sizeof(*e));
e = nexte;
}
}
hash_free(table->table, (size_t)HASHTABLE_SIZE(table->table_bits) *
sizeof(hash_entry_t*));
table->table = NULL;
table->entries = 0;
if (table->synch)
dr_mutex_unlock(table->lock);
dr_mutex_destroy(table->lock);
}
void
terminate_IPC(int idx)
{
ipc_channel_t *channel = &IPC[idx];
if (channel->standalone)
{
dr_raw_mem_free(channel->shared_mem, sizeof(Sigil2DBISharedData));
}
else
{
/* send terminate sequence */
uint finished = SIGIL2_IPC_FINISHED;
uint last_buffer = channel->shmem_buf_idx;
if(dr_write_file(channel->full_fifo, &last_buffer, sizeof(last_buffer)) != sizeof(last_buffer) ||
dr_write_file(channel->full_fifo, &finished, sizeof(finished)) != sizeof(finished))
DR_ABORT_MSG("error writing finish sequence sigil2 fifos");
/* wait for sigil2 to disconnect */
while(dr_read_file(channel->empty_fifo, &finished, sizeof(finished)) > 0);
dr_close_file(channel->empty_fifo);
dr_close_file(channel->full_fifo);
dr_unmap_file(channel->shared_mem, sizeof(Sigil2DBISharedData));
}
dr_global_free((void*)channel->ticket_queue.head, sizeof(ticket_queue_t));
dr_mutex_destroy(channel->queue_lock);
}
static void
event_exit()
{
#ifdef SHOW_RESULTS
char msg[512];
int len;
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
" saw %llu memory references\n",
num_refs);
DR_ASSERT(len > 0);
NULL_TERMINATE_BUFFER(msg);
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
code_cache_exit();
if (!drmgr_unregister_tls_field(tls_index) ||
!drmgr_unregister_thread_init_event(event_thread_init) ||
!drmgr_unregister_thread_exit_event(event_thread_exit) ||
!drmgr_unregister_bb_insertion_event(event_bb_insert) ||
drreg_exit() != DRREG_SUCCESS)
DR_ASSERT(false);
dr_mutex_destroy(mutex);
drmgr_exit();
}
bool
drvector_delete(drvector_t *vec)
{
uint i;
if (vec == NULL)
return false;
if (vec->synch)
dr_mutex_lock(vec->lock);
/* Since we lazily initialize the array, vec->array could be NULL if we
* called drvector_init with capacity 0 and never inserted an element into
* the vec. We check vec->array here and below before access.
* */
if (vec->free_data_func != NULL && vec->array != NULL) {
for (i = 0; i < vec->entries; i++) {
(vec->free_data_func)(vec->array[i]);
}
}
if (vec->array != NULL) {
dr_global_free(vec->array, vec->capacity * sizeof(void *));
vec->array = NULL;
vec->entries = 0;
}
if (vec->synch)
dr_mutex_unlock(vec->lock);
dr_mutex_destroy(vec->lock);
return true;
}
static void
exit_event(void)
{
#ifdef SHOW_RESULTS
char msg[512];
int len;
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
"Processed %d instructions\n"
,fp_count);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
dr_mutex_destroy(count_mutex);
#ifdef SHOW_SYMBOLS
if (drsym_exit() != DRSYM_SUCCESS) {
dr_log(NULL, LOG_ALL, 1, "WARNING: error cleaning up symbol library\n");
}
#endif
printht();
__wrap_free(testarr);
}
void instrace_exit_event()
{
int i;
DEBUG_PRINT("%s - total amount of instructions - %d\n",ins_pass_name, num_refs);
if (client_arg->instrace_mode == OPCODE_TRACE){
dr_printf("opcodes that were covered in this part of the code - \n");
for (i = OP_FIRST; i <= OP_LAST; i++){
if (opcodes_visited[i]){
dr_printf(logfile,"%s - ", decode_opcode_name(i));
}
}
dr_printf("\n");
}
md_delete_list(head, false);
md_delete_list(instrace_head, false);
dr_global_free(client_arg,sizeof(client_arg_t));
code_cache_exit();
drmgr_unregister_tls_field(tls_index);
dr_mutex_destroy(mutex);
if (log_mode){
dr_close_file(logfile);
}
drutil_exit();
drmgr_exit();
}
static void
event_exit(void)
{
VDISPLAY_FUNC(NAME" exiting.");
/* free structures */
free_table();
dr_mutex_destroy(table_lock);
}
int
main(int argc, char *argv[])
{
#ifdef STANDALONE_DECODER
void *dcontext = GLOBAL_DCONTEXT;
#else
void *dcontext = dr_standalone_init();
/* simple test of deadlock_avoidance, etc. being disabled in standalone */
void *x = dr_mutex_create();
dr_mutex_lock(x);
dr_mutex_unlock(x);
dr_mutex_destroy(x);
#endif
test_all_opcodes_0(dcontext);
#ifndef STANDALONE_DECODER /* speed up compilation */
test_all_opcodes_1(dcontext);
test_all_opcodes_2(dcontext);
test_all_opcodes_2_mm(dcontext);
test_all_opcodes_3(dcontext);
test_all_opcodes_3_avx(dcontext);
test_all_opcodes_4(dcontext);
#endif
test_disp_control(dcontext);
test_indirect_cti(dcontext);
test_cti_prefixes(dcontext);
#ifndef X64
test_modrm16(dcontext);
#endif
test_size_changes(dcontext);
test_nop_xchg(dcontext);
#ifdef X64
test_x86_mode(dcontext);
test_x64_abs_addr(dcontext);
test_x64_inc(dcontext);
#endif
test_regs(dcontext);
test_instr_opnds(dcontext);
test_strict_invalid(dcontext);
print("all done\n");
return 0;
}
static void
event_exit(void)
{
/* On WOW64xpsp2 I see 440+, but only 230+ on 2k3 */
if (num_complete_inlines > 100)
dr_fprintf(STDERR, "Inlined callees in >100 traces\n");
else
dr_fprintf(STDERR, "Inlined callees in %d traces: < 100!!!\n", num_complete_inlines);
htable_free(NULL/*global*/, htable);
dr_mutex_destroy(htable_mutex);
}
static
void exit_event1(void)
{
dr_fprintf(STDERR, "exit event 1\n");
dr_flush_file(STDOUT);
if (!dr_unregister_exit_event(exit_event1))
dr_fprintf(STDERR, "unregister failed!\n");
check_result();
dr_mutex_destroy(mutex);
}
void dr_exit() {
dr_fprintf(STDERR, "info: stopping dtrace..\n");
tb_delete(trace_buffer);
dr_mutex_destroy(trace_buffer_lock);
dr_close_file(trace_file);
dr_mutex_destroy(trace_file_lock);
hashtable_delete(&tags);
dr_mutex_destroy(tags_lock);
dr_unregister_exit_event(&dr_exit);
dr_unregister_thread_init_event(&handle_thread_init);
dr_unregister_thread_exit_event(&handle_thread_exit);
dr_unregister_bb_event(&handle_bb);
dr_unregister_trace_event(&handle_trace);
dr_unregister_delete_event(&handle_delete);
dr_unregister_signal_event(&handle_signal);
dr_unregister_restore_state_event(&handle_restore_state);
}
/* Report the history of "analysis mode" changes and clean up local allocations */
static void
event_exit(void)
{
uint i;
context_t *context, *next;
for (context = context_list->head; context != NULL; context = next) {
next = context->next;
for (i = 1; i < context->mode_history_index; i++) {
PRINTF("In context %d at event %d, the mode changed from %d to %d",
context->id, i, context->mode_history[i-1], context->mode_history[i]);
}
PRINTF("Context '%s' terminates in mode %d",
context->label, context->mode);
}
#if !(defined (WINDOWS) && defined (X64))
ASSERT(mem_defines->v1 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v2 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v3 > MIN_MEM_DEFINES);
ASSERT(mem_defines->v4 > MIN_MEM_DEFINES);
#endif
dr_mutex_destroy(context_lock);
dr_mutex_destroy(write_lock);
for (context = context_list->head; context != NULL; context = next) {
next = context->next;
dr_global_free(context->label, (sizeof(char) * strlen(context->label)) + 1);
dr_global_free(context->mode_history, MAX_MODE_HISTORY * sizeof(uint));
dr_global_free(context, sizeof(context_t));
}
dr_global_free(context_list, sizeof(context_list_t));
#if !(defined (WINDOWS) && defined (X64))
dr_global_free(mem_defines, sizeof(mem_defines_t));
#endif
}
static void onExit() {
dr_printf( "In onExit()\n" );
// Clean up hashtable.
hashtable_delete( &wraps );
// Clean up output.
dr_mutex_destroy( outMutex );
dr_close_file( outFile );
// Clean up extensions.
drwrap_exit();
drsym_exit();
}
static void event_exit()
{
char msg[512];
int len;
len = snprintf(msg, sizeof(msg) / sizeof(msg[0]), "Number of basi blocks built : %"UINT64_FORMAT_CODE"\n"
" Average size : %5.2lf instructions\n",
counts_as_built.blocks, counts_as_built.total_size / (double)counts_as_built.blocks);
DR_ASSERT(len > 0);
msg[sizeof(msg)/sizeof(msg[0])-1] = '\0'; /*NULL Terminate */
DISPLAY_STRING(msg);
/* Free mutex */
dr_mutex_destroy(as_built_lock);
}
void memtrace_exit_event()
{
md_delete_list(head,false);
code_cache_exit();
drmgr_unregister_tls_field(tls_index);
if (log_mode){
dr_close_file(logfile);
}
dr_mutex_destroy(mutex);
dr_global_free(client_arg, sizeof(client_arg_t));
drutil_exit();
drmgr_exit();
}
void
hashtable_delete(hashtable_t *table)
{
if (table->synch)
dr_mutex_lock(table->lock);
hashtable_clear_internal(table);
hash_free(table->table, (size_t)HASHTABLE_SIZE(table->table_bits) *
sizeof(hash_entry_t*));
table->table = NULL;
table->entries = 0;
if (table->synch)
dr_mutex_unlock(table->lock);
dr_mutex_destroy(table->lock);
}
static void
event_exit(void)
{
#ifdef SHOW_RESULTS
char msg[256];
int len;
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"<Largest malloc request: %d>\n<OOM simulations: %d>\n",
max_malloc, malloc_oom);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
dr_mutex_destroy(max_lock);
drwrap_exit();
}
void
symcache_exit(void)
{
uint i;
ASSERT(initialized, "symcache was not initialized");
dr_mutex_lock(symcache_lock);
for (i = 0; i < HASHTABLE_SIZE(symcache_table.table_bits); i++) {
hash_entry_t *he;
for (he = symcache_table.table[i]; he != NULL; he = he->next) {
mod_cache_t *modcache = (mod_cache_t *) he->payload;
symcache_write_symfile(modcache->modname, modcache);
}
}
hashtable_delete(&symcache_table);
dr_mutex_unlock(symcache_lock);
dr_mutex_destroy(symcache_lock);
}
static void
exit_event(void)
{
#ifdef SHOW_RESULTS
char msg[512];
int len;
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
" saw %d div instructions\n"
" of which %d were powers of 2\n",
div_count, div_p2_count);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
dr_mutex_destroy(count_mutex);
}
static void
event_exit(void)
{
dr_log(NULL, DR_LOG_ALL, 1, "Client 'memtrace' num refs seen: " SZFMT "\n", num_refs);
if (!dr_raw_tls_cfree(tls_offs, MEMTRACE_TLS_COUNT))
DR_ASSERT(false);
if (!drmgr_unregister_tls_field(tls_idx) ||
!drmgr_unregister_thread_init_event(event_thread_init) ||
!drmgr_unregister_thread_exit_event(event_thread_exit) ||
!drmgr_unregister_bb_app2app_event(event_bb_app2app) ||
!drmgr_unregister_bb_insertion_event(event_app_instruction) ||
drreg_exit() != DRREG_SUCCESS)
DR_ASSERT(false);
dr_mutex_destroy(mutex);
drutil_exit();
drmgr_exit();
}
bool
drvector_delete(drvector_t *vec)
{
uint i;
if (vec == NULL)
return false;
if (vec->synch)
dr_mutex_lock(vec->lock);
for (i = 0; i < vec->entries; i++) {
if (vec->free_data_func != NULL)
(vec->free_data_func)(vec->array[i]);
}
dr_global_free(vec->array, vec->capacity * sizeof(void*));
vec->array = NULL;
vec->entries = 0;
if (vec->synch)
dr_mutex_unlock(vec->lock);
dr_mutex_destroy(vec->lock);
return true;
}
static void
event_exit(void)
{
#ifdef SHOW_RESULTS
char msg[512];
int len;
/* Note that using %f with dr_printf or dr_fprintf on Windows will print
* garbage as they use ntdll._vsnprintf, so we must use dr_snprintf.
*/
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Number of basic blocks seen: %d\n"
" Maximum size: %d instructions\n"
" Average size: %5.1f instructions\n",
num_bb, max_size, ave_size);
DR_ASSERT(len > 0);
msg[sizeof(msg)/sizeof(msg[0])-1] = '\0';
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
dr_mutex_destroy(stats_mutex);
}
void memdump_exit_event(void)
{
int i = 0;
md_delete_list(filter_head, false);
md_delete_list(done_head, false);
md_delete_list(app_pc_head, false);
dr_global_free(client_arg, sizeof(client_arg_t));
drmgr_unregister_tls_field(tls_index);
if (log_mode){
dr_close_file(logfile);
}
for (i = 0; i < instr_clone_amount; i++){
instr_destroy(dr_get_current_drcontext(), instr_clones[i]);
}
dr_mutex_destroy(mutex);
drutil_exit();
drmgr_exit();
drwrap_exit();
}
static void
umbra_client_exit()
{
dr_mutex_destroy(client_proc_data.lock);
}
static void
event_exit(void)
{
int i;
char msg[512];
int len;
int j;
uint64 xmod_xfer = 0;
uint64 self_xfer = 0;
for (i = 0; i < num_mods; i++) {
dr_fprintf(logfile, "module %3d: %s\n", i,
dr_module_preferred_name(mod_array[i].info) == NULL ?
"<unknown>" : dr_module_preferred_name(mod_array[i].info));
dr_fprintf(logfile, "%20llu instruction executed\n", mod_cnt[i]);
}
if (mod_cnt[UNKNOW_MODULE_IDX] != 0) {
dr_fprintf(logfile, "unknown modules:\n%20llu instruction executed\n",
mod_cnt[UNKNOW_MODULE_IDX]);
}
for (i = 0; i < MAX_NUM_MODULES; i++) {
for (j = 0; j < num_mods; j++) {
if (xfer_cnt[i][j] != 0) {
dr_fprintf(logfile, "mod %3d => mod %3d: %8u\n",
i, j, xfer_cnt[i][j]);
if (i == j)
self_xfer += xfer_cnt[i][j];
else
xmod_xfer += xfer_cnt[i][j];
}
}
}
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
"\t%10llu instructions executed\n"
"\t%10llu (%2.3f%%) cross module indirect branches\n"
"\t%10llu (%2.3f%%) intra-module indirect branches\n",
ins_count,
xmod_xfer, 100*(float)xmod_xfer/ins_count,
self_xfer, 100*(float)self_xfer/ins_count);
DR_ASSERT(len > 0);
NULL_TERMINATE_BUFFER(msg);
#ifdef SHOW_RESULTS
DISPLAY_STRING(msg);
#endif /* SHOW_RESULTS */
dr_fprintf(logfile, "%s\n", msg);
dr_mutex_lock(mod_lock);
for (i = 0; i < num_mods; i++) {
DR_ASSERT(mod_array[i].info != NULL);
dr_free_module_data(mod_array[i].info);
}
dr_mutex_unlock(mod_lock);
dr_mutex_destroy(mod_lock);
log_file_close(logfile);
drx_exit();
if (!drmgr_unregister_bb_instrumentation_event(event_analyze_bb) ||
!drmgr_unregister_module_load_event(event_module_load) ||
!drmgr_unregister_module_unload_event(event_module_unload) ||
drreg_exit() != DRREG_SUCCESS)
DR_ASSERT(false);
drmgr_exit();
}
static void
event_exit(void)
{
int i,j;
unsigned long long flop_count = 0;
double ilp;
int total_bbexecs = 0;
double total_ilp = 0;
float max_ilp = FLT_MIN;
float min_ilp = FLT_MAX;
unsigned long long tot_instr_count[tracked_instrs_len];
for( i = 0; i < tracked_instrs_len; i++ ) tot_instr_count[i] = 0;
for(i = 0; i < MY_MAX_BB && i < my_bbcount; i++){
flop_count += my_bbexecs[i] * bb_flop_count[i];
for( j = 0; j < tracked_instrs_len; j++ )
tot_instr_count[j] += my_bbexecs[i] * bb_instr_count[i*tracked_instrs_len+j];
total_bbexecs += my_bbexecs[i];
total_ilp += ((double)my_bbexecs[i])*((double)my_bbilp[i]);
min_ilp = MIN(min_ilp, my_bbilp[i]);
max_ilp = MAX(max_ilp, my_bbilp[i]);
}
ilp = total_ilp / ((double)(total_bbexecs != 0 ? total_bbexecs : 1));
#ifdef SHOW_RESULTS
char msg[2048];
int len;
#ifdef VERBOSE
for(i = 0; i < MY_MAX_BB && i < my_bbcount; i++){
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Basic block # %5d, size: %5d, execs: %8d, ILP: %3f",
i, my_bbsizes[i], my_bbexecs[i], my_bbilp[i]);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
dr_printf("%s\n", msg);
}
#endif
for( i = 0; i < tracked_instrs_len; i++ ) {
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"%10d %s\n", tot_instr_count[i], tracked_instrs[i]);
dr_printf("%s", msg);
}
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"Instrumentation results:\n"
"%10d basic block execs\n"
"%10d basic blocks\n"
"%10d flop(s)\n"
"%10.3f avg ILP\n"
"%10.3f max ILP\n"
"%10.3f min ILP\n",
total_bbexecs, my_bbcount, flop_count, ilp, max_ilp, min_ilp);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
dr_printf("%s\n", msg);
if (my_bbcount > MY_MAX_BB){
len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),
"\n"
"Overflow warning! Only the latest %d basic blocks were used for ILP calcution.\n",
MY_MAX_BB);
DR_ASSERT(len > 0);
NULL_TERMINATE(msg);
dr_printf("%s\n", msg);
}
#endif /* SHOW_RESULTS */
dr_mutex_destroy(stats_mutex);
}
