int RSIM_Simulator::main_loop() { RSIM_Process *process = get_process(); RSIM_Thread *thread = process->get_main_thread(); /* The simulator's main thread is executed by the calling thread because the simulator's main thread must be a thread group * leader. */ bool cb_process_status = process->get_callbacks().call_process_callbacks(RSIM_Callbacks::BEFORE, process, RSIM_Callbacks::ProcessCallback::START, true); // The process' main thread has already been created and initialized but has not started running yet. thread->start(); thread->waitForState(RSIM_Thread::TERMINATED); process->get_callbacks().call_process_callbacks(RSIM_Callbacks::AFTER, process, RSIM_Callbacks::ProcessCallback::FINISH, cb_process_status); return process->get_termination_status(); }
int main(int argc, char *argv[], char *envp[]) { rose_addr_t trigger_va = 0; // address at which disassembly is triggered std::string trigger_func = "oep"; // name of function at which disassembly is triggered (oep=original entry point) AsmUnparser::Organization org = AsmUnparser::ORGANIZED_BY_AST; // Parse arguments that we need for ourself. for (int i=1; i<argc; i++) { if (!strncmp(argv[i], "--trigger=", 10)) { // Address (or name of function) that will trigger the disassembly. When the EIP register contains this value then // disassembly will run and the specimen will be terminated. char *rest; trigger_func = ""; trigger_va = strtoull(argv[i]+10, &rest, 0); if (*rest) { trigger_va = 0; trigger_func = argv[i]+10; } memmove(argv+i, argv+i+1, (argc-- - i)*sizeof(*argv)); --i; } else if (!strcmp(argv[i], "--linear")) { org = AsmUnparser::ORGANIZED_BY_ADDRESS; memmove(argv+i, argv+i+1, (argc-- - i)*sizeof(*argv)); --i; } } // Initialize the simulator RSIM_Linux32 sim; int n = sim.configure(argc, argv, envp); sim.install_callback(new RSIM_Tools::UnhandledInstruction); sim.exec(argc-n, argv+n); RSIM_Process *process = sim.get_process(); RSIM_Thread *main_thread = process->get_main_thread(); // Find the trigger address if (0==trigger_va) { if (trigger_func.empty() || !trigger_func.compare("oep")) { trigger_va = process->get_ep_orig_va(); } else if (0==(trigger_va = RSIM_Tools::FunctionFinder().address(process->headers(), trigger_func))) { std::cerr <<argv[0] <<": unable to locate address of function: " <<trigger_func <<"\n"; exit(1); } } // Install our disassembler callback to the main thread. We don't use RSIM_Tools::MemoryDisassembler because we want to // cancel the specimen once we disassemble. main_thread->install_callback(new MyDisassembler(trigger_va, org)); // Allow the specimen to run until the disassembly is triggered bool disassembled = false; sim.activate(); try { sim.main_loop(); } catch (MyDisassembler*) { disassembled = true; } if (!disassembled) { std::cerr <<argv[0] <<": specimen ran to completion without triggering a disassembly.\n"; exit(1); } return 0; }