DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
# ifdef WINDOWS
dr_enable_console_printing();
# endif
client_id = id;
/* XXX: should use droption */
if (argc > 1 && strcmp(argv[1], "full-decode") == 0) {
PRINT("Init annotation test client with full decoding");
dr_register_bb_event(empty_bb_event);
} else if (argc > 1 && strlen(argv[1]) >= 8 && strncmp(argv[1], "truncate", 8) == 0) {
bb_truncation_length = (argv[1][9] - '0'); /* format is "truncate@n" (0<n<10) */
ASSERT(bb_truncation_length < 10 && bb_truncation_length > 0);
PRINT("Init annotation test client with bb truncation");
dr_register_bb_event(bb_event_truncate);
} else {
PRINT("Init annotation test client with fast decoding");
}
register_call("test_annotation_two_args", (void *) test_two_args, 2);
register_call("test_annotation_three_args", (void *) test_three_args, 3);
register_call("test_annotation_eight_args", (void *) test_eight_args, 8);
register_call("test_annotation_nine_args", (void *) test_nine_args, 9);
register_call("test_annotation_ten_args", (void *) test_ten_args, 10);
}
/* Parse CL options and register DR event handlers and annotation handlers */
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
context_lock = dr_mutex_create();
write_lock = dr_mutex_create();
# ifdef WINDOWS
dr_enable_console_printing();
# endif
client_id = id;
/* XXX: should use droption */
if (argc > 1 && strcmp(argv[1], "full-decode") == 0) {
PRINTF("Init annotation test client with full decoding");
dr_register_bb_event(empty_bb_event);
} else if (argc > 1 && strlen(argv[1]) >= 8 && strncmp(argv[1], "truncate", 8) == 0) {
bb_truncation_length = (argv[1][9] - '0'); /* format is "truncate@n" (0<n<10) */
ASSERT(bb_truncation_length < 10 && bb_truncation_length > 0);
PRINTF("Init annotation test client with bb truncation");
dr_register_bb_event(bb_event_truncate);
} else {
PRINTF("Init annotation test client with fast decoding");
}
context_list = dr_global_alloc(sizeof(context_list_t));
memset(context_list, 0, sizeof(context_list_t));
#if !(defined (WINDOWS) && defined (X64))
mem_defines = dr_global_alloc(sizeof(mem_defines_t));
memset(mem_defines, 0, sizeof(mem_defines_t));
#endif
dr_register_exit_event(event_exit);
register_call("test_annotation_init_mode", (void *) init_mode, 1);
register_call("test_annotation_init_context", (void *) init_context, 3);
register_call("test_annotation_get_mode", (void *) get_mode, 1);
register_call("test_annotation_set_mode", (void *) set_mode, 2);
#if !(defined (WINDOWS) && defined (X64))
register_call("test_annotation_rotate_valgrind_handler",
(void *) rotate_valgrind_handler, 1);
#endif
register_call("test_annotation_eight_args", (void *) test_eight_args_v1, 8);
register_call("test_annotation_eight_args", (void *) test_eight_args_v2, 8);
/* Test removing the last handler */
dr_annotation_unregister_call("test_annotation_eight_args", test_eight_args_v1);
register_call("test_annotation_nine_args", (void *) test_nine_args_v1, 9);
register_call("test_annotation_nine_args", (void *) test_nine_args_v2, 9);
/* Test removing the first handler */
dr_annotation_unregister_call("test_annotation_nine_args", test_nine_args_v2);
/* Test multiple handlers */
register_call("test_annotation_ten_args", (void *) test_ten_args_v1, 10);
register_call("test_annotation_ten_args", (void *) test_ten_args_v2, 10);
dr_annotation_register_return("test_annotation_get_client_version", (void *) "2.2.8");
}
DR_EXPORT void
dr_init(client_id_t id)
{
dr_register_exit_event(exit_event);
dr_register_bb_event(bb_event);
count_mutex = dr_mutex_create();
}
DR_EXPORT
void dr_init(client_id_t id)
{
table = new_table();
dr_register_bb_event(bb_event);
dr_register_exit_event(dr_exit);
}
DR_EXPORT void dr_init(client_id_t id) {
dr_fprintf(STDERR, "info: starting dtrace, &dr_init=%p..\n", &dr_init);
trace_file = dr_open_file(TRACE_FILE_NAME,
DR_FILE_ALLOW_LARGE | DR_FILE_WRITE_OVERWRITE);
if(trace_file == INVALID_FILE) {
dr_fprintf(STDERR, "fatal: dr_open_file() failed\n");
dr_exit_process(1);
}
trace_file_lock = dr_mutex_create();
trace_buffer = tb_create(-1);
trace_buffer_lock = dr_mutex_create();
hashtable_init_ex(&tags,
16,
HASH_INTPTR,
false,
false,
&tag_info_free_raw,
NULL,
NULL);
tags_lock = dr_mutex_create();
dr_register_exit_event(&dr_exit);
dr_register_thread_init_event(&handle_thread_init);
dr_register_thread_exit_event(&handle_thread_exit);
dr_register_bb_event(&handle_bb);
dr_register_trace_event(&handle_trace);
dr_register_delete_event(&handle_delete);
dr_register_signal_event(&handle_signal);
dr_register_restore_state_event(&handle_restore_state);
}
DR_EXPORT void
dr_init(client_id_t id)
{
dr_set_client_name("DynamoRIO Sample Client 'instrcalls'",
"http://dynamorio.org/issues");
my_id = id;
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'instrcalls' initializing\n");
/* also give notification to stderr */
#ifdef SHOW_RESULTS
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client instrcalls is running\n");
}
#endif
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
#ifdef SHOW_SYMBOLS
if (drsym_init(0) != DRSYM_SUCCESS) {
dr_log(NULL, LOG_ALL, 1, "WARNING: unable to initialize symbol translation\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
module_data_t *appmod = dr_get_main_module();
DR_ASSERT(appmod != NULL);
app_base = appmod->start;
app_end = appmod->end;
dr_free_module_data(appmod);
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'modxfer_app2lib' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client modxfer_app2lib is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* Look up start_monitor() and stop_monitor() in the target app.
* These functions are dummy markers that tell us when to start
* and stop printing syscalls.
*/
/* NOTE - we could use dr_module_lookup_by_name, but we use the iterator instead
* to test it out. */
dr_module_iterator_t *iter = dr_module_iterator_start();
while (dr_module_iterator_hasnext(iter)) {
module_data_t *data = dr_module_iterator_next(iter);
if (strcmp(dr_module_preferred_name(data), TEST_NAME) == 0) {
module_handle_t lib = data->handle;
start_pc = (app_pc)dr_get_proc_address(lib, "start_monitor");
stop_pc = (app_pc)dr_get_proc_address(lib, "stop_monitor");
}
dr_free_module_data(data);
}
dr_module_iterator_stop(iter);
if (start_pc == NULL || stop_pc == NULL) {
dr_fprintf(STDERR, "ERROR: did not find start/stop markers\n");
}
/* Register the BB hook */
dr_register_bb_event(bb_event);
#ifdef LINUX /* With early injection, libc won't be loaded until later. */
dr_register_module_load_event(event_module_load);
#endif
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
print("in dr_client_main\n");
dr_register_bb_event(event_bb);
dr_register_signal_event(event_signal);
dr_register_exit_event(event_exit);
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
}
DR_EXPORT void dr_init(client_id_t id)
{
/* Register Events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* Initalize lock */
as_built_lock = dr_mutex_create();
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'memtrace' initializing\n");
if (dr_is_notify_on()) {
dr_fprintf(STDERR, "Client is running\n");
}
}
DR_EXPORT void dr_init(client_id_t id)
{
insn_count = 0;
read_count = 0;
writ_count = 0;
read_size = 0;
writ_size = 0;
dr_register_post_syscall_event(event_post_syscall);
dr_register_bb_event(event_bb);
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
dr_register_exit_event(event_exit);
}
DR_EXPORT void
dr_init(client_id_t id)
{
num_bb = 0;
ave_size = 0.;
max_size = 0;
stats_mutex = dr_mutex_create();
dr_register_bb_event(event_basic_block);
dr_register_exit_event(event_exit);
#ifdef SHOW_RESULTS
if (dr_is_notify_on())
dr_fprintf(STDERR, "Client bbsize is running\n");
#endif
}
DR_EXPORT
void dr_init(client_id_t id)
{
const char *options = dr_get_options(id);
if (strlen(options) == 0) {
bb_truncation_length = DEFAULT_BB_TRUNCATION_LENGTH;
} else {
ASSERT(strlen(options) == 1); /* supports bb truncation at 1-9 instrs */
bb_truncation_length = (options[0] - '0');
ASSERT(bb_truncation_length < 10 && bb_truncation_length > 0);
}
dr_fprintf(STDERR, "thank you for testing the client interface\n");
dr_register_bb_event(bb_event);
}
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);
}
DR_EXPORT
void dr_init(client_id_t id)
{
module_data_t *data;
dr_fprintf(STDERR, "thank you for testing the client interface\n");
dr_register_bb_event(bb_event);
data = dr_lookup_module_by_name("kernel32.dll");
if (data != NULL) {
exit_proc_addr = (void *)dr_get_proc_address(data->handle, "ExitProcess");
if (exit_proc_addr == NULL)
dr_fprintf(STDERR, "ERROR: unable to find kernel32!ExitProcess\n");
dr_free_module_data(data);
} else {
dr_fprintf(STDERR, "ERROR: unable to find ntdll.dll\n");
}
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* Generate the "slowpath" which just returns to eax. */
void *dc = dr_get_current_drcontext();
instrlist_t *ilist = instrlist_create(dc);
PRE(ilist, NULL, INSTR_CREATE_jmp_ind(dc, opnd_create_reg(DR_REG_XAX)));
slowpath = dr_nonheap_alloc(SLOWPATH_SIZE, (DR_MEMPROT_READ|
DR_MEMPROT_WRITE|
DR_MEMPROT_EXEC));
instrlist_encode(dc, ilist, slowpath, false /*no relative jumps*/);
instrlist_clear_and_destroy(dc, ilist);
dr_register_bb_event(event_bb);
dr_register_exit_event(event_exit);
}
DR_EXPORT void
dr_init(client_id_t id)
{
htable_mutex = dr_mutex_create();
/* global HASH_BITS-bit addressed hash table */
htable = htable_create(NULL/*global*/);
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
dr_register_delete_event(event_fragment_deleted);
dr_register_end_trace_event(query_end_trace);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'inline' initializing\n");
num_complete_inlines = 0;
}
DR_EXPORT
void dr_init(client_id_t id)
{
const char *options = dr_get_options(id);
dr_fprintf(STDERR, "options = %s\n", options);
if (options != NULL && strstr(options, "use_unlink") != NULL) {
use_unlink = true;
}
#ifdef WINDOWS
dr_register_module_load_event(module_load_event);
#endif
dr_register_exit_event(exit_event);
dr_register_trace_event(trace_event);
dr_register_delete_event(deleted_event);
dr_register_bb_event(bb_event);
dr_register_kernel_xfer_event(kernel_xfer_event);
}
DR_EXPORT void
dr_init(client_id_t id)
{
dr_printf("dr_init()\n");
my_bbcount = 0;
stats_mutex = dr_mutex_create();
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
#ifdef SHOW_RESULTS
dr_log(NULL, LOG_ALL, 1, "Client 'inspar' initializing\n");
if (dr_is_notify_on()) {
# ifdef WINDOWS
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client inspar is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
num_bb = 0;
ave_size = 0.;
max_size = 0;
stats_mutex = dr_mutex_create();
dr_register_bb_event(event_basic_block);
dr_register_exit_event(event_exit);
#ifdef SHOW_RESULTS
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client bbsize is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
/* register events */
dr_register_exit_event(event_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'inscount' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called in dr_init(). */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client inscount is running\n");
}
#endif
}
DR_EXPORT void
dr_init(client_id_t id)
{
printf("Started dr_init\n");
dr_register_exit_event(exit_event);
dr_register_bb_event(bb_event);
dr_register_thread_init_event(writeLog);
count_mutex = dr_mutex_create();
client_id = id;
#ifdef SHOW_SYMBOLS
if (drsym_init(0) != DRSYM_SUCCESS) {
dr_log(NULL, LOG_ALL, 1, "WARNING: unable to initialize symbol translation\n");
}
#endif
htinit();
}
DR_EXPORT
void dr_init(client_id_t id)
{
/* Look up start_instrument() and stop_instrument() in the app.
* These functions are markers that tell us when to start and stop
* instrumenting.
*/
module_data_t *prog = dr_lookup_module_by_name("client.cbr4.exe");
ASSERT(prog != NULL);
start_pc = (app_pc)dr_get_proc_address(prog->handle, "start_instrument");
stop_pc = (app_pc)dr_get_proc_address(prog->handle, "stop_instrument");
ASSERT(start_pc != NULL && stop_pc != NULL);
dr_free_module_data(prog);
table = new_table();
dr_register_bb_event(bb_event);
dr_register_exit_event(dr_exit);
}
DR_EXPORT
void dr_init(client_id_t id)
{
module_iterator_t *iter;
dr_register_bb_event(bb_event);
dr_register_exit_event(exit_event);
mutex = dr_mutex_init();
iter = module_iterator_start();
while (module_iterator_hasnext(iter)) {
module_data_t *data = module_iterator_next(iter);
if (my_strcmp(module_name(data), "fragdel.exe")) {
start = data->start;
end = data->end;
break;
}
}
module_iterator_stop(iter);
}
DR_EXPORT
void dr_client_main(client_id_t id, int argc, const char *argv[])
{
dr_set_client_name("DynamoRIO Sample Client 'cbrtrace'",
"http://dynamorio.org/issues");
dr_log(NULL, LOG_ALL, 1, "Client 'cbrtrace' initializing");
client_id = id;
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
dr_register_bb_event(event_basic_block);
dr_register_exit_event(event_exit);
#ifdef SHOW_RESULTS
if (dr_is_notify_on()) {
# ifdef WINDOWS
dr_enable_console_printing();
# endif /* WINDOWS */
dr_fprintf(STDERR, "Client 'cbrtrace' is running\n");
}
#endif /* SHOW_RESULTS */
}
DR_EXPORT void
dr_client_main(client_id_t id, int argc, const char *argv[])
{
dr_set_client_name("DynamoRIO Sample Client 'countcalls'",
"http://dynamorio.org/issues");
/* register events */
dr_register_exit_event(event_exit);
dr_register_thread_init_event(event_thread_init);
dr_register_thread_exit_event(event_thread_exit);
dr_register_bb_event(event_basic_block);
/* make it easy to tell, by looking at log file, which client executed */
dr_log(NULL, LOG_ALL, 1, "Client 'countcalls' initializing\n");
#ifdef SHOW_RESULTS
/* also give notification to stderr */
if (dr_is_notify_on()) {
# ifdef WINDOWS
/* ask for best-effort printing to cmd window. must be called at init. */
dr_enable_console_printing();
# endif
dr_fprintf(STDERR, "Client countcalls is running\n");
}
#endif
}
int main(void)
{
double res = 0.;
int i,j;
void *stack = NULL;
uint tid;
#ifdef LINUX
pthread_t pt[10]; /* On Linux, the tid. */
#else
uintptr_t thread[10]; /* _beginthreadex doesn't return HANDLE? */
#endif
/* Create spinning sideline threads. */
#ifdef LINUX
pthread_create(&pt[0], NULL, sideline_spinner, (void*)func_0);
pthread_create(&pt[1], NULL, sideline_spinner, (void*)func_1);
pthread_create(&pt[2], NULL, sideline_spinner, (void*)func_2);
pthread_create(&pt[3], NULL, sideline_spinner, (void*)func_3);
pthread_create(&pt[4], NULL, sideline_spinner, (void*)func_4);
pthread_create(&pt[5], NULL, sideline_spinner, (void*)func_5);
pthread_create(&pt[6], NULL, sideline_spinner, (void*)func_6);
pthread_create(&pt[7], NULL, sideline_spinner, (void*)func_7);
pthread_create(&pt[8], NULL, sideline_spinner, (void*)func_8);
pthread_create(&pt[9], NULL, sideline_spinner, (void*)func_9);
#else
thread[0] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_0, 0, &tid);
thread[1] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_1, 0, &tid);
thread[2] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_2, 0, &tid);
thread[3] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_3, 0, &tid);
thread[4] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_4, 0, &tid);
thread[5] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_5, 0, &tid);
thread[6] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_6, 0, &tid);
thread[7] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_7, 0, &tid);
thread[8] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_8, 0, &tid);
thread[9] = _beginthreadex(NULL, 0, sideline_spinner, (void*)func_9, 0, &tid);
#endif
#ifdef USE_DYNAMO
dr_app_setup();
/* XXX: Calling the client interface from the app is not supported. We're
* just using it for testing.
*/
dr_register_bb_event(event_bb);
#endif
for (j=0; j<10; j++) {
#ifdef USE_DYNAMO
dr_app_start();
#endif
for (i=0; i<ITERS; i++) {
if (i % 2 == 0) {
res += cos(1./(double)(i+1));
} else {
res += sin(1./(double)(i+1));
}
}
foo();
#ifdef USE_DYNAMO
/* FIXME i#95: On Linux dr_app_stop only makes the current thread run
* native. We should revisit this while implementing full detach for
* Linux.
*/
dr_app_stop();
#endif
}
/* PR : we get different floating point results on different platforms,
* so we no longer print out res */
print("all done: %d iters\n", i);
#ifdef USE_DYNAMO
/* On x64 Linux it's OK if we call pthread_join natively, but x86-32 has
* problems. We start and stop to bracket it.
*/
dr_app_start();
#endif
should_spin = false; /* Break the loops. */
for (i = 0; i < 10; i++) {
#ifdef LINUX
pthread_join(pt[i], NULL);
/* FIXME i#725: Windows needs attach in order to take over these
* threads.
*/
if (!took_over_thread[i])
print("failed to take over thread %d!\n", i);
#else
WaitForSingleObject((HANDLE)thread[i], INFINITE);
#endif
}
#ifdef USE_DYNAMO
dr_app_stop();
#endif
#ifdef USE_DYNAMO
dr_app_cleanup();
#endif
return 0;
}
DR_EXPORT
void dr_init(client_id_t id)
{
dr_register_bb_event(bb_event);
}
