自学教程：C++ DR_ASSERT函数代码示例

/* We transform string loops into regular loops so we can more easily * monitor every memory reference they make. */static dr_emit_flags_tevent_bb_app2app(void *drcontext, void *tag, instrlist_t *bb, bool for_trace,                 bool translating){    if (!drutil_expand_rep_string(drcontext, bb)) {        DR_ASSERT(false);        /* in release build, carry on: we'll just miss per-iter refs */    }    drx_tail_pad_block(drcontext, bb);    return DR_EMIT_DEFAULT;}

static voidevent_exit(void){#ifdef SHOW_RESULTS    /* Display the results! */    char msg[512];    int len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),                          "Inlining results:/n"                          "  Number of traces: %d/n"                          "  Number of complete inlines: %d/n",                          num_traces, num_complete_inlines);    DR_ASSERT(len > 0);    msg[sizeof(msg)/sizeof(msg[0])-1] = '/0';    DISPLAY_STRING(msg);#endif    hashtable_delete(&head_table);    if (!drmgr_unregister_bb_instrumentation_event(event_analyze_bb))        DR_ASSERT(false);    drmgr_exit();}

app_pctable_alloc_bytes(umbra_info_t *info, int size){    app_pc ptr;    DR_ASSERT(size >= 0 &&               (info->table.bytes_ptr + size) <               (info->table.bytes_table + MAX_BYTES_TABLE_SIZE));    ptr = info->table.bytes_ptr;    info->table.bytes_ptr += size;    return ptr;}

static voidevent_exit(void){    if (!drmgr_unregister_thread_init_event(event_thread_init) ||        !drmgr_unregister_bb_insertion_event(event_app_instruction) ||        drreg_exit() != DRREG_SUCCESS)        DR_ASSERT(false);    drx_buf_free(buf);    drmgr_exit();    drx_exit();}

static voidevent_exit(void){    show_results();    if (!drmgr_unregister_cls_field(event_thread_context_init,                                    event_thread_context_exit,                                    tcls_idx) ||        !drmgr_unregister_pre_syscall_event(event_pre_syscall) ||        !drmgr_unregister_post_syscall_event(event_post_syscall))        DR_ASSERT(false && "failed to unregister");    drmgr_exit();}

static void event_exit(void){    char msg[512];    int len;    len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),                      "Instrumentation results: %llu instructions executed/n",                      global_count);    DR_ASSERT(len > 0);    NULL_TERMINATE(msg);    DISPLAY_STRING(msg);}

static voidwrap_post(void *wrapcxt, void *user_data){    size_t sz = (size_t) user_data;    /* test out-of-memory by having a random moderately-large alloc fail */    if (sz > 1024 && dr_get_random_value(1000) < 10) {        bool ok = drwrap_set_retval(wrapcxt, NULL);        DR_ASSERT(ok);        dr_mutex_lock(max_lock);        malloc_oom++;        dr_mutex_unlock(max_lock);    }}

file_t umbra_open_proc_log(process_id_t pid){#ifdef LINUX_KERNEL    return our_stdout;#else    char   name[128];    int    len;    file_t logfile;    /* XXX: Windows need a absolute path */    name[0] = '/0';    len = dr_snprintf(name, sizeof(name)/sizeof(name[0]),                      "umbra.%s.%d.proc.log",                       dr_get_application_name(), pid);    DR_ASSERT(len > 0);    name[sizeof(name)/sizeof(name[0])-1] = '/0';    logfile = dr_open_file(name, DR_FILE_READ | DR_FILE_WRITE_APPEND);    DR_ASSERT(logfile != INVALID_FILE);    return logfile;#endif}

static void post_func_cb(void * wrapcxt, void ** user_data){	DEBUG_PRINT("funcwrap - post_func_cb/n");	per_thread_t * data = drmgr_get_tls_field(dr_get_current_drcontext(), tls_index);	data->nesting--;	//dr_unlink_flush_region(0, ~((ptr_uint_t)0));	DR_ASSERT(data->nesting >= 0); 	if (data->nesting == 0){		data->filter_func = false;	}	DEBUG_PRINT("funcwrap - post_func_cb done /n");	}

static voidevent_thread_init(void *drcontext){    file_t log;    log = log_file_open(client_id, drcontext, NULL /* using client lib path */,                        "cbrtrace",#ifndef WINDOWS                        DR_FILE_CLOSE_ON_FORK |#endif                        DR_FILE_ALLOW_LARGE);    DR_ASSERT(log != INVALID_FILE);    dr_set_tls_field(drcontext, (void *)(ptr_uint_t)log);}

static voidmodule_load_event(void *drcontext, const module_data_t *mod, bool loaded){    app_pc towrap = (app_pc)dr_get_proc_address(mod->handle, "SSL_write");    if (towrap != NULL) {        bool ok = drwrap_wrap(towrap, wrap_pre_SSL_write, NULL);        if (!ok) {            dr_fprintf(STDERR, "Couldn’t wrap SSL_write/n");            DR_ASSERT(ok);        }    }    towrap = (app_pc)dr_get_proc_address(mod->handle, "SSL_read");    if (towrap != NULL) {        bool ok = drwrap_wrap(towrap, wrap_pre_SSL_read, wrap_post_SSL_read);        if (!ok) {            dr_fprintf(STDERR, "Couldn’t wrap SSL_read/n");            DR_ASSERT(ok);        }    }    towrap = (app_pc)dr_get_proc_address(mod->handle, "gnutls_record_send");    if (towrap != NULL) {        bool ok = drwrap_wrap(towrap, wrap_pre_SSL_write, NULL);        if (!ok) {            dr_fprintf(STDERR, "Couldn’t wrap gnutls_record_send/n");            DR_ASSERT(ok);        }    }    towrap = (app_pc)dr_get_proc_address(mod->handle, "gnutls_record_recv");    if (towrap != NULL) {        bool ok = drwrap_wrap(towrap, wrap_pre_SSL_read, wrap_post_SSL_read);        if (!ok) {            dr_fprintf(STDERR, "Couldn’t wrap gnutls_record_recv/n");            DR_ASSERT(ok);        }    }}

static dr_emit_flags_tevent_app_analysis(void *drcontext, void *tag, instrlist_t *bb, bool for_trace,                   bool translating, void **user_data){    per_thread_t *data = drmgr_get_tls_field(drcontext, tls_idx);    *user_data = (void *)&data->reg_addr;    /* If we have an outstanding write, that means we did not correctly handle a case     * where there was a write but no fall-through NOP or terminating instruction in     * the previous basic block.     */    DR_ASSERT(data->reg_addr == DR_REG_NULL);    return DR_EMIT_DEFAULT;}

static voidinsert_save_addr(void *drcontext, instrlist_t *ilist, instr_t *where, opnd_t ref,                 reg_id_t reg_ptr, reg_id_t reg_addr){    bool ok;    /* we use reg_ptr as scratch to get addr */    ok = drutil_insert_get_mem_addr(drcontext, ilist, where, ref, reg_addr, reg_ptr);    DR_ASSERT(ok);    insert_load_buf_ptr(drcontext, ilist, where, reg_ptr);    MINSERT(ilist, where,            XINST_CREATE_store(drcontext,                               OPND_CREATE_MEMPTR(reg_ptr, offsetof(mem_ref_t, addr)),                               opnd_create_reg(reg_addr)));}

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_init(client_id_t id,const char * name, const char * arguments){	char logfilename[MAX_STRING_LENGTH];	file_t in_file;	drmgr_init();    drutil_init();    client_id = id;    mutex = dr_mutex_create();	DR_ASSERT(parse_commandline_args(arguments) == true);		head = md_initialize();	if(client_arg->filter_mode != FILTER_NONE){		in_file = dr_open_file(client_arg->filter_filename,DR_FILE_READ);		DR_ASSERT(in_file != INVALID_FILE);		md_read_from_file(head,in_file,false);		dr_close_file(in_file);	}        tls_index = drmgr_register_tls_field();    DR_ASSERT(tls_index != -1);    code_cache_init();	if (log_mode){		populate_conv_filename(logfilename, logdir, name, NULL);		logfile = dr_open_file(logfilename, DR_FILE_WRITE_OVERWRITE);	}	strncpy(ins_pass_name, name, MAX_STRING_LENGTH);}

static instr_t * static_info_instrumentation(void * drcontext, instr_t* instr){	/*		for each src and dest add the information accordingly		this should return canonicalized static info about an instruction; breaking down any complex instructions if necessary		1) check whether this instruction needs to be instrumented		2) if yes, then get a location and then proceed to instrument -> return the struct		3) if no, return null	*/	/* main variables */	per_thread_t * data = drmgr_get_tls_field(drcontext,tls_index);	/* helper variables */	int opcode;	instr_t * ret;		/* loop variables */	int i;	/* 1) */	opcode = instr_get_opcode(instr);	if (client_arg->instrace_mode == OPCODE_TRACE){		opcodes_visited[opcode] = true;		return NULL;	}	if ( (client_arg->instrace_mode == OPERAND_TRACE) || (client_arg->instrace_mode == INS_DISASM_TRACE) ){		operand_trace(instr, drcontext);		return NULL;	}	/* check whether this instr needs instrumentation - check for ones to skip and skip if */	/*switch(opcode){	case OP_jecxz:		return NULL;	}*/		/* 2) */	data->static_array[data->static_ptr++] = instr_clone(drcontext,instr);	DR_ASSERT(data->static_ptr < data->static_array_size);	return data->static_array[data->static_ptr - 1];}

DR_EXPORT void dr_init(client_id_t id){    /* register events */    dr_register_thread_init_event(event_thread_init);    dr_register_thread_exit_event(event_thread_exit);    dr_register_exit_event(event_exit);    dr_register_bb_event(event_basic_block);    /* The TLS field provided by DR cannot be directly accessed from code cache.     * For better performance, we allocate raw TLS so that we can directly     * access and update it with a single instruction.     */    if(!dr_raw_tls_calloc(&tls_seg, &tls_offs, 1, 0))        DR_ASSERT(false);}

voidwriteCallgrind(int thread_id){	char logname[MAXIMUM_PATH];	char *dirsep;    	int len;	char * tmp = process_path;	len = dr_snprintf(logname, sizeof(logname)/sizeof(logname[0]),                      "%s", tmp);	DR_ASSERT(len > 0);	for (dirsep = logname + len; *dirsep != '/'; dirsep--)        DR_ASSERT(dirsep > logname);    	len = dr_snprintf(dirsep + 1,                      (sizeof(logname) - (dirsep - logname))/sizeof(logname[0]),                      "callgrind.%d.out", thread_id);    	DR_ASSERT(len > 0);    	NULL_TERMINATE(logname);    	logOut = dr_open_file(logname,                              DR_FILE_WRITE_OVERWRITE | DR_FILE_ALLOW_LARGE);    	DR_ASSERT(logOut != INVALID_FILE);//    	dr_log(drcontext, LOG_ALL, 1,  //          "floating point: log for thread %d is fp.%03d/n",thread_id, thread_id);	#ifdef SHOW_RESULTS    	if (dr_is_notify_on()) {//        	dr_fprintf(STDERR, "<floating point instruction operands for thread %d in %s>/n",//                  dr_get_thread_id(drcontext), logname);    	}	#endif	       	dr_fprintf(logOut, "version: 1/n");       	dr_fprintf(logOut, "creator: callgrind-3.6.1-Debian/n");       	dr_fprintf(logOut, "positions: instr line/n");       	dr_fprintf(logOut, "events: Average Max/n/n/n");}

static voidwrap_post(void *wrapcxt, void *user_data){#ifdef SHOW_RESULTS /* we want determinism in our test suite */    size_t sz = (size_t) user_data;    /* test out-of-memory by having a random moderately-large alloc fail */    if (sz > 1024 && dr_get_random_value(1000) < 10) {        bool ok = drwrap_set_retval(wrapcxt, NULL);        DR_ASSERT(ok);        dr_mutex_lock(max_lock);        malloc_oom++;        dr_mutex_unlock(max_lock);    }#endif}

DR_EXPORT voiddr_init(client_id_t id){    drreg_options_t ops = { sizeof(ops), 2 /*max slots needed*/, false };    drreg_status_t res;    bool ok = drmgr_init();    CHECK(ok, "drmgr_init failed");    ok = drx_init();    CHECK(ok, "drx_init failed");    res = drreg_init(&ops);    CHECK(res == DRREG_SUCCESS, "drreg_init failed");    dr_register_exit_event(event_exit);    if (!drmgr_register_bb_instrumentation_event(NULL, event_app_instruction, NULL))        DR_ASSERT(false);}

static void do_mem_dump(file_t file, uint base_pc,uint size){	uint read;	bool ok;	byte * mem_values = dr_global_alloc(sizeof(byte) * size);	ssize_t written;	ok = dr_safe_read(base_pc, size, mem_values, &read);	DR_ASSERT(ok);	written = dr_write_file(file, mem_values, size);	DEBUG_PRINT("read %d from %x of size %d and written %d/n", read, base_pc, size, written);	dr_global_free(mem_values, sizeof(byte) * size);}

/* * Helper function for bulk use of drwrap. */static void try_wrap_fn(const module_data_t *module, const char *name,                        prewrapper_t pre, postwrapper_t post, bool *done){    if (*done)        return;    size_t offset;    drsym_error_t status = drsym_lookup_symbol(        module->full_path, name, &offset, DRSYM_DEFAULT_FLAGS);    if (status == DRSYM_SUCCESS) {        app_pc notify_fn = module->start + offset;        bool ok = drwrap_wrap(notify_fn, pre, post);        DR_ASSERT(ok);        *done = true;    }}

static voidshow_results(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 system calls seen: %d>", num_syscalls);    DR_ASSERT(len > 0);    msg[sizeof(msg)/sizeof(msg[0])-1] = '/0';    DISPLAY_STRING(msg);#endif /* SHOW_RESULTS */}

trace_type_toffline_instru_t::get_entry_type(byte *buf_ptr) const{    offline_entry_t *entry = (offline_entry_t *) buf_ptr;    switch (entry->addr.type) {    case OFFLINE_TYPE_MEMREF: return TRACE_TYPE_READ;    case OFFLINE_TYPE_MEMREF_HIGH: return TRACE_TYPE_READ;    case OFFLINE_TYPE_PC: return TRACE_TYPE_INSTR;    case OFFLINE_TYPE_THREAD: return TRACE_TYPE_THREAD;    case OFFLINE_TYPE_PID: return TRACE_TYPE_PID;    case OFFLINE_TYPE_TIMESTAMP: return TRACE_TYPE_THREAD; // Closest.    case OFFLINE_TYPE_IFLUSH: return TRACE_TYPE_INSTR_FLUSH;    }    DR_ASSERT(false);    return TRACE_TYPE_THREAD_EXIT; // Unknown: returning rarest entry.}

static voidevent_exit(void){    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))        DR_ASSERT(false);    drx_buf_free(write_buffer);    drx_buf_free(trace_buffer);    drutil_exit();    drreg_exit();    drmgr_exit();    drx_exit();}

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();}

static inline voidordered_lock(ipc_channel_t *channel, uint tid){    dr_mutex_lock(channel->queue_lock);    ticket_queue_t *q = &channel->ticket_queue;    if (q->locked)    {        ticket_node_t *node = dr_global_alloc(sizeof(ticket_node_t));        if (node == NULL)            DR_ABORT_MSG("Failed to allocate ticket node/n");        node->next = NULL;        node->dr_event = dr_event_create();        node->waiting = true;        node->thread_id = tid;        DR_ASSERT(q->tail->next == NULL);        q->tail = q->tail->next = node;        SGL_DEBUG("Sleeping Thread :%d/n", tid);        dr_mutex_unlock(channel->queue_lock);        /* MDL20170425 TODO(soonish)         * how likely is it that we'll miss a wakeup here? */        while (node->waiting)            dr_event_wait(node->dr_event);        dr_mutex_lock(channel->queue_lock);        q->head->next = node->next;        if (q->tail == node)            q->tail = q->head;        dr_event_destroy(node->dr_event);        dr_global_free(node, sizeof(ticket_node_t));        SGL_DEBUG("Awakened Thread :%d/n", tid);    }    else    {        q->locked = true;    }    dr_mutex_unlock(channel->queue_lock);}

/* save reg before where in ilist */voidumbra_save_reg(void         *drcontext,               umbra_info_t *info,               instrlist_t  *ilist,               instr_t      *where,               reg_id_t      reg){    int slot;    instr_t *instr;    DR_ASSERT(reg >= REG_SPILL_START && reg <= REG_SPILL_STOP);    slot  = reg - REG_SPILL_START;    instr = INSTR_CREATE_mov_st(drcontext,                                OPND_CREATE_ABSMEM(&info->spill_regs[slot],                                        OPSZ_PTR),                                opnd_create_reg(reg));    instrlist_meta_preinsert(ilist, where, instr);}

static voiddisplay_results(per_thread_t *data, char *thread_note){#ifdef SHOW_RESULTS    char msg[512];    int len;    len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),                      "%sInstrumentation results:/n"                      "  saw %d direct calls/n"                      "  saw %d indirect calls/n"                      "  saw %d returns/n",                      thread_note, data->num_direct_calls,                      data->num_indirect_calls, data->num_returns);    DR_ASSERT(len > 0);    NULL_TERMINATE(msg);    DISPLAY_STRING(msg);#endif /* SHOW_RESULTS */}

static void event_thread_exit(void *drcontext){    per_thread_t *data = (per_thread_t *) dr_get_tls_field(drcontext);    char msg[512];    int len;    len = dr_snprintf(msg, sizeof(msg)/sizeof(msg[0]),                      "Thread %d exited - ", dr_get_thread_id(drcontext));    DR_ASSERT(len > 0);    NULL_TERMINATE(msg);    /* display thread private counts data */    display_results(data, msg);    /* clean up memory */    dr_thread_free(drcontext, data, sizeof(per_thread_t));}