// If configured to do so, dump memory around *all* registers
// for the crashing thread.
void dump_memory_and_code(log_t* log, Backtrace* backtrace) {
pt_regs r;
if (ptrace(PTRACE_GETREGS, backtrace->Tid(), 0, &r)) {
ALOGE("cannot get registers: %s\n", strerror(errno));
return;
}
static const char reg_names[] = "$0atv0v1a0a1a2a3a4a5a6a7t0t1t2t3s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra";
for (int reg = 0; reg < 32; reg++) {
// skip uninteresting registers
if (reg == 0 // $0
|| reg == 26 // $k0
|| reg == 27 // $k1
|| reg == 31 // $ra (done below)
)
continue;
dump_memory(log, backtrace, R(r.regs[reg]), "memory near %.2s:", ®_names[reg * 2]);
}
uintptr_t pc = R(r.cp0_epc);
uintptr_t ra = R(r.regs[31]);
dump_memory(log, backtrace, pc, "code around pc:");
if (pc != ra) {
dump_memory(log, backtrace, ra, "code around ra:");
}
}
// If configured to do so, dump memory around *all* registers
// for the crashing thread.
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
struct pt_regs regs;
if (ptrace(PTRACE_GETREGS, tid, 0, ®s)) {
return;
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) {
static const char REG_NAMES[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp";
for (int reg = 0; reg < 14; reg++) {
// this may not be a valid way to access, but it'll do for now
uintptr_t addr = regs.uregs[reg];
// Don't bother if it looks like a small int or ~= null, or if
// it's in the kernel area.
if (addr < 4096 || addr >= 0xc0000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", ®_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
}
}
// explicitly allow upload of code dump logging
_LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, static_cast<uintptr_t>(regs.ARM_pc), scope_flags);
if (regs.ARM_pc != regs.ARM_lr) {
_LOG(log, scope_flags, "\ncode around lr:\n");
dump_memory(log, tid, static_cast<uintptr_t>(regs.ARM_lr), scope_flags);
}
}
int launch_vm(t_param *param)
{
t_vm *vm;
int i;
if ((vm = my_malloc(sizeof(t_vm), "Error: fail to malloc vm\n")) == 0)
return (1);
vm->screen = SDL_SetVideoMode(MEM_SIZE / NB_COL * WIDTH + DECAL, NB_COL * WIDTH, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
SDL_WM_SetCaption("Corewar", NULL);
if (vm->screen == NULL)
err_SDL();
vm->police = TTF_OpenFont("arial.ttf", 20);
vm->param = param;
vm->cycle = 0;
vm->cycle_to_die = CYCLE_TO_DIE;
vm->nb_live = 0;
owner_set(vm->mem_owner, -1, 0, MEM_SIZE);
my_memset(vm->register_player, 0, (MAX_PLAYER + 1) * sizeof(char));
i = 0;
while (i < MAX_PROG_NUMBER)
vm->progs_live[i++] = -1;
if (load_all_programs(vm) != 0)
return (1);
my_printf("%d program(s) loaded\n", vm->prog_list->nb_elm);
if (param->debug == 1)
dump_memory(vm->memory);
pause_vm(vm, 1);
vm_run(vm);
pause_vm(vm, 0);
if (param->debug == 1)
dump_memory(vm->memory);
TTF_CloseFont(vm->police);
return (0);
}
void on_break(int32_t s) {
puts("");
static bool s_double = false;
if (s_double)
{
puts("User interrupt.");
#ifdef DEBUG
dump_memory(0);
#endif
_exit(1);
}
s_double = true;
#ifdef WIN32
exlib::OSThread _thread;
_thread.bindCurrent();
#endif
Isolate *p = s_isolates.head();
while (p != 0) {
p->m_isolate->RequestInterrupt(cb_interrupt, NULL);
p->m_interrupt = true;
// p->RequestInterrupt(InterruptCallbackEx);
p = s_isolates.next(p);
}
}
int main(int argc, char *argv[]) {
printf("[*] Android Dalvik Unpacker/Unprotector - <*****@*****.**>\n");
if(argc <= 0) {
printf(" [!] Nothing to unpack, quitting\n");
return 0;
}
if(getuid() != 0) {
printf(" [!] Not root, quitting\n");
return -1;
}
char *package_name = argv[1];
printf(" [+] Hunting for %s\n", package_name);
uint32_t pid = get_process_pid(package_name);
if(pid <= 0) {
printf(" [!] Process could not be found!\n");
return -1;
}
printf(" [+] %d is service pid\n", pid);
uint32_t clone_pid = get_clone_pid(pid);
if(clone_pid <= 0) {
printf(" [!] A suitable clone process could not be found!");
return -1;
}
printf(" [+] %d is clone pid\n", clone_pid);
int mem_file = attach_get_memory(clone_pid);
if(mem_file == -1) {
printf(" [!] An error occured attaching and finding the memory!\n");
return -1;
}
// Determine if we are dealing with APKProtect or Bangcle
char *extra_filter = determine_filter(clone_pid, mem_file);
memory_region memory;
if(find_magic_memory(clone_pid, mem_file, &memory, extra_filter) <= 0) {
printf(" [!] Something unexpected happened, new version of packer/protectors? Or it wasn't packed/protected!\n");
return -1;
}
printf(" [+] Unpacked odex found in memory!\n");
// Build a safe file to dump to and call the memory dumping function
char *dumped_file_name = malloc(strlen(static_safe_location) + strlen(package_name) + strlen(suffix));
sprintf(dumped_file_name, "%s%s%s", static_safe_location, package_name, suffix);
if(dump_memory(mem_file, &memory, dumped_file_name) <= 0) {
printf(" [!] An issue occured trying to dump the memory to a file!\n");
return -1;
}
printf(" [+] Unpacked/protected file dumped to : %s\n", dumped_file_name);
close(mem_file);
ptrace(PTRACE_DETACH, clone_pid, NULL, 0);
return 1;
}
void dispatch_wait2(dispatch_t * self, int timeout)
{
if (unlikely(self == NULL))
throw_unexpected(DISPATCH_NULL);
if (-1 < self->fd) {
struct epoll_event events[DISPATCH_EVENT_SIZE];
int rc = epoll_wait(self->fd, events,
DISPATCH_EVENT_SIZE, timeout);
if (0 < rc) {
dump_memory(stdout, 0, events, sizeof(events));
}
for (int n = 0; n < rc; n++) {
dispatch_callback_t *cb =
(dispatch_callback_t *) events[n].data.ptr;
if (cb != NULL) {
printf
("cb[%p] fd[%d] data[%p] ep->data.u64[%lld]\n",
cb, cb->fd, cb->data, events[n].data.u64);
if (cb->func != NULL) {
// dispatch_event ev = {events[n].data.u64 >> 32, events[n].events};
dispatch_event_t ev =
{ cb->fd, events[n].events };
cb->func(&ev, cb->data);
}
}
}
}
}
void battle_begins(int dump, t_uchar *arena,
t_champ *champ, t_cycle *cycles)
{
t_champ *tmp;
while (cycles->cycle_to_die > 0 && check_round(champ, cycles))
{
tmp = champ->next;
while (tmp != champ)
{
check_cycles(tmp, arena, cycles);
tmp->cycle_to_die++;
tmp = tmp->next;
if (cycles->nbr_live >= NBR_LIVE)
{
cycles->cycle_to_die -= CYCLE_DELTA;
cycles->nbr_live = 0;
}
}
if (cycles->current_cycle == dump)
dump_memory(champ, cycles, arena);
cycles->current_cycle += 1;
}
is_there_a_winner(arena, champ, cycles);
}
int execute_command(char cmd_char, int reg[], int nreg,
int mem[], int memlen)
{
if (cmd_char == '?' || cmd_char == 'h')
help_message();
switch (cmd_char) {
case 'd':
dump_control_unit(pc, ir, running, reg, nreg);
dump_memory(mem, memlen);
return 0;
break;
case 'q':
return 1;
break;
case '\n':
one_instruction_cycle(reg, nreg, mem, memlen);
return 0;
break;
default:
printf("Please enter a valid character");
break;
}
return 0;
}
void main(int argc,char **argv)
{
DWORD iLength;
void * pvStartingAddress;
DWORD PID;
static char * szPid;
static char * szAddress;
static char * szLength;
static char * szFile;
static BEGIN_ARGS
ARG("f:",szFile,"char *","Output file name.")
ARG("p:",szPid,"char *","PID of the destination process(hex)")
ARG("a:",szAddress,"char *","Starting address(hex).")
ARG("l:",szLength,"char *","Length of memory to dump(hex).")
END_ARGS
process_args_1(argc,argv);
if(!szFile || !szPid || !szAddress || !szLength){
print_usage(__CmdLineArgValues);
return;
};
sscanf(szPid,"%x",&PID);
sscanf(szLength,"%x",&iLength);
sscanf(szAddress,"%x",&pvStartingAddress);
dump_memory(PID,pvStartingAddress,iLength,szFile);
}
int main(int argc, const char *argv[]) {
volatile double d;
volatile float f;
volatile unsigned char *p;
/* FLT_MAX: (1 - 2^(-24)) * 2^128. */
printf("- FLT_MAX\n");
d = FLT_MAX;
f = (float) d;
printf("d: %f\n", d);
printf("f: %f\n", f);
dump_memory((volatile unsigned char *) &d, 8);
dump_memory((volatile unsigned char *) &f, 4);
/* FLT_MAX + floating point unit: 2^128. */
printf("- FLT_MAX_PLUS\n");
d = FLT_MAX_PLUS;
f = (float) d;
printf("d: %f\n", d);
printf("f: %f\n", f);
dump_memory((volatile unsigned char *) &d, 8);
dump_memory((volatile unsigned char *) &f, 4);
/* Number between FLT_MAX and FLT_MAX + unit. */
printf("- between FLT_MAX and FLT_MAX_PLUS\n");
d = (FLT_MAX + FLT_MAX_PLUS) / 2.0;
f = (float) d;
printf("d: %f\n", d);
printf("f: %f\n", f);
dump_memory((volatile unsigned char *) &d, 8);
dump_memory((volatile unsigned char *) &f, 4);
/* Same as above, but one double unit less.
* 47effffff0000000 ->
* 47efffffefffffff
*
* This is the largest double that doesn't round to infinity on x64.
*/
printf("- just below above\n");
p = (volatile unsigned char *) &d;
p[7] = 0x47U;
p[6] = 0xefU;
p[5] = 0xffU;
p[4] = 0xffU;
p[3] = 0xefU;
p[2] = 0xffU;
p[1] = 0xffU;
p[0] = 0xffU;
f = (float) d;
printf("d: %f\n", d);
printf("f: %f\n", f);
dump_memory((volatile unsigned char *) &d, 8);
dump_memory((volatile unsigned char *) &f, 4);
return 0;
}
// Read and dump initial values for memory
//
void initialize_memory(int argc, char *argv[], CPU *cpu) {
FILE *datafile = get_datafile(argc, argv);
printf("\nBefore While");
// Buffer to read next line of text into
#define BUFFER_LEN 80
char buffer[BUFFER_LEN];
printf("\nBefore While");
// Will read the next line (words_read = 1 if it started
// with a memory value). Will set memory location loc to
// value_read
//
int value_read, words_read, loc = 0, done = 0;
char *read_success; // NULL if reading in a line fails.
read_success = fgets(buffer, BUFFER_LEN, datafile);
int range = MEMLEN -1;
while (read_success != NULL && !done) {
// If the line of input begins with an integer, treat
// it as the memory value to read in. Ignore junk
// after the number and ignore blank lines and lines
// that don't begin with a number.
//
words_read = sscanf(buffer, "%d", &value_read);
//printf("\nWords Read: %d",words_read);
// *** STUB *** set memory value at current location to
// value_read and increment location. Exceptions: If
// loc is out of range, complain and quit the loop. If
// value_read is outside -9999...9999, then it's a
// sentinel and we should say so and quit the loop.
if(words_read == 1){
if(loc>range){
printf("\nERROR: Location %d is outside range",value_read);
done = 1;
} else if(value_read < -9999 || value_read > 9999) {
printf("\nSentinel %d at location %d",value_read,loc);
done = 1;
} else {
(*cpu).mem[loc] = value_read;
loc++;
}
}
// Get next line and continue the loop
//
// *** STUB ***
words_read = sscanf(buffer,"%d",&value_read);
}//end while
// Initialize rest of memory
//
while (loc < MEMLEN) {
cpu -> mem[loc++] = 0;
}
dump_memory(cpu);
}
int main() {
registers regs; /* Registers */
memory mem; /* Main memory */
int i; /* Instruction count */
/*
* 'Boot up'??
*/
/* Initialize memory/registers to zero */
memset(mem.data, 0, MEMSIZE);
memset(®s, 0, sizeof(registers));
/* 'Load' sample program into memory */
memcpy(mem.data + OS_SIZE, test_program, sizeof(test_program));
/* Initialize some register and memory values
* (hard-coded for the purposes of testing)
*/
const uint32_t sample_value_addr = OS_SIZE + sizeof(test_program);
regs.general[0] = 0xDEADBEEF;
regs.general[1] = sample_value_addr;
regs.general[3] = 0xCAFEBABE;
printf("Initial state:\n");
dump_registers(®s);
dump_memory(&mem);
/* Execute program */
regs.prog_counter = OS_SIZE;
for (i = 0; i < sizeof(test_program)/sizeof(uint32_t); i++) {
printf("Executing instruction %u in test_program\n", i);
/* Execute instruction */
execute(®s, &mem);
/* Dump */
dump_registers(®s);
dump_memory(&mem);
}
return EXIT_SUCCESS;
}
void dump_memory_and_code(log_t* log, Backtrace* backtrace) {
pt_regs regs;
if (ptrace(PTRACE_GETREGS, backtrace->Tid(), 0, ®s)) {
ALOGE("cannot get registers: %s\n", strerror(errno));
return;
}
static const char reg_names[] = "r0r1r2r3r4r5r6r7r8r9slfpipsp";
for (int reg = 0; reg < 14; reg++) {
dump_memory(log, backtrace, regs.uregs[reg], "memory near %.2s:", ®_names[reg * 2]);
}
dump_memory(log, backtrace, static_cast<uintptr_t>(regs.ARM_pc), "code around pc:");
if (regs.ARM_pc != regs.ARM_lr) {
dump_memory(log, backtrace, static_cast<uintptr_t>(regs.ARM_lr), "code around lr:");
}
}
// If configured to do so, dump memory around *all* registers
// for the crashing thread.
void dump_memory_and_code(log_t* log, pid_t tid, int scope_flags) {
pt_regs_mips_t r;
if (ptrace(PTRACE_GETREGS, tid, 0, &r)) {
return;
}
if (IS_AT_FAULT(scope_flags) && DUMP_MEMORY_FOR_ALL_REGISTERS) {
static const char REG_NAMES[] = "$0atv0v1a0a1a2a3t0t1t2t3t4t5t6t7s0s1s2s3s4s5s6s7t8t9k0k1gpsps8ra";
for (int reg = 0; reg < 32; reg++) {
// skip uninteresting registers
if (reg == 0 // $0
|| reg == 26 // $k0
|| reg == 27 // $k1
|| reg == 31 // $ra (done below)
)
continue;
uintptr_t addr = R(r.regs[reg]);
// Don't bother if it looks like a small int or ~= null, or if
// it's in the kernel area.
if (addr < 4096 || addr >= 0x80000000) {
continue;
}
_LOG(log, scope_flags | SCOPE_SENSITIVE, "\nmemory near %.2s:\n", ®_NAMES[reg * 2]);
dump_memory(log, tid, addr, scope_flags | SCOPE_SENSITIVE);
}
}
unsigned int pc = R(r.cp0_epc);
unsigned int ra = R(r.regs[31]);
_LOG(log, scope_flags, "\ncode around pc:\n");
dump_memory(log, tid, (uintptr_t)pc, scope_flags);
if (pc != ra) {
_LOG(log, scope_flags, "\ncode around ra:\n");
dump_memory(log, tid, (uintptr_t)ra, scope_flags);
}
}
static void ecc_1(void) {
int size[] = {7, 8, 16, 1024+16, 4096+32, 8*1024*4+64, 0};
for (int * s = size; *s != 0; s++) {
unsigned char in[*s];
unsigned char out[*s + (*s / 8)];
ssize_t in_sz = sizeof in;
ssize_t out_sz = sizeof out;
memset(in, 0, in_sz);
memset(out, 0, out_sz);
FILE * f = fopen("/dev/urandom", "r");
CU_ASSERT_FATAL(f != NULL);
CU_ASSERT_FATAL(fread(in, in_sz, 1, f) == 1);
fclose(f);
ssize_t rc = sfc_ecc_inject(out, out_sz, in, in_sz);
if ((*s % 8) != 0) {
CU_ASSERT(rc == -1);
} else {
CU_ASSERT(rc == in_sz + (in_sz / 8));
}
unsigned char cmp[*s];
ssize_t cmp_sz = sizeof cmp;
memset(cmp, 0, cmp_sz);
rc = sfc_ecc_remove(cmp, cmp_sz, out, out_sz);
if ((out_sz % 9) != 0) {
CU_ASSERT(rc == -1);
} else {
CU_ASSERT(rc == in_sz)
CU_ASSERT_FATAL(memcmp(in, cmp, in_sz) == 0);
#ifdef DEBUG
dump_memory(stdout, 0, in, in_sz);
dump_memory(stdout, 0, cmp, cmp_sz);
#endif
}
}
}
void process_command ()
{ char action;
char fname[100];
int pid, time, ret;
printf ("command> ");
scanf ("%c", &action);
while (action != 'T')
{ switch (action)
{ case 's': // submit
scanf ("%s", &fname);
if (Debug) printf ("File name: %s is submitted\n", fname);
submit_process (fname);
break;
case 'x': // execute
execute_process ();
break;
case 'r': // dump register
dump_registers ();
break;
case 'q': // dump ready queue and list of processes completed IO
dump_ready_queue ();
dump_doneWait_list ();
break;
case 'p': // dump PCB
printf ("PCB Dump Starts: Checks from 0 to %d\n", currentPid);
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_PCB (pid);
break;
case 'e': // dump events in timer
dump_events ();
break;
case 'm': // dump Memory
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_memory (pid);
break;
case 'w': // dump Swap Space
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_swap_memory (pid);
break;
case 'l': // dump Spool
for (pid=1; pid<currentPid; pid++)
if (PCB[pid] != NULL) dump_spool (pid);
break;
case 'T': // Terminate, do nothing, terminate in while loop
break;
default:
printf ("Incorrect command!!!\n");
}
printf ("\ncommand> ");
scanf ("\n%c", &action);
if (Debug) printf ("Next command is %c\n", action);
}
}
static void out_segment(OutputBuffer* buf,
WasmSegment* segment,
const char* desc) {
size_t offset = buf->size;
ensure_output_buffer_capacity(buf, offset + segment->size);
void* dest = buf->start + offset;
wasm_copy_segment_data(segment->data, dest, segment->size);
if (g_verbose)
dump_memory(buf->start + offset, segment->size, offset, 1, desc);
buf->size += segment->size;
}
static void mem_dumper_task() {
int i;
beep();
for (i=0; i<10; i++) {
LEDBLUE ^= 2;
SleepTask(500);
}
dump_memory();
}
result_t process_base::exit(int32_t code)
{
flushLog(false);
#ifdef DEBUG
global_base::GC();
dump_memory();
#endif
::_exit(code);
return 0;
}
static size_t out_data(OutputBuffer* buf,
size_t offset,
const void* src,
size_t size,
const char* desc) {
assert(offset <= buf->size);
ensure_output_buffer_capacity(buf, offset + size);
memcpy(buf->start + offset, src, size);
if (g_verbose)
dump_memory(buf->start + offset, size, offset, 0, desc);
return offset + size;
}
int main(int argc, char **argv)
{
struct io_space *ios;
struct list_head *pvs, *tmp;
struct dm_pool *mem;
init_log(stderr);
init_debug(_LOG_INFO);
if (!dev_cache_init()) {
fprintf(stderr, "init of dev-cache failed\n");
exit(1);
}
if (!dev_cache_add_dir("/dev/loop")) {
fprintf(stderr, "couldn't add /dev to dir-cache\n");
exit(1);
}
if (!(mem = dm_pool_create(10 * 1024))) {
fprintf(stderr, "couldn't create pool\n");
exit(1);
}
ios = create_lvm1_format("/dev", mem, NULL);
if (!ios) {
fprintf(stderr, "failed to create io_space for format1\n");
exit(1);
}
pvs = ios->get_pvs(ios);
if (!pvs) {
fprintf(stderr, "couldn't read vg %s\n", argv[1]);
exit(1);
}
list_for_each(tmp, pvs) {
struct pv_list *pvl = list_entry(tmp, struct pv_list, list);
dump_pv(&pvl->pv, stdout);
}
ios->destroy(ios);
dm_pool_destroy(mem);
dev_cache_exit();
dump_memory();
fin_log();
return 0;
}
// Main program: Initialize the cpu, and read the initial memory values
//
int main(int argc, char *argv[]) {
printf("SDC Simulator pt 1 Devanshu Bharel: CS 350 Lab 6\n");
CPU cpu_value, *cpu = &cpu_value;
printf("Initalizing CPU:\n");
initialize_CPU(cpu);
printf("Initalizing MEM:\n");
initialize_memory(argc, argv, cpu);
dump_CPU(cpu);
dump_memory(cpu);
dump_registers(cpu);
// That's it for Lab 6
//
return 0;
}
/**
* Shows a mixed hexadecimal+ASCII dump for all allocated chunks within the
* heap.
*/
void hexdump_heap()
{
Chunk *cur = alloc_list;
while (cur) {
printf("SIZE = %zu:\n", cur->size);
dump_memory(cur->addr, cur->size);
if (cur->next) {
printf("\n");
}
cur = cur->next;
}
}
void initialize_memory(int argc, char *argv[], int mem[], int memlen)
{
FILE *datafile = get_datafile(argc, argv);
int value_read, words_read, loc = 0, done = 0;
char *buffer = NULL;
size_t buffer_len = 0, bytes_read = 0;
/* Fetch first instruction */
bytes_read = getline(&buffer, &buffer_len, datafile);
while (bytes_read != -1 && !done) {
words_read = sscanf(buffer, "%d", &value_read);
/* If beginning was not an integer (junk) discard it and go on
* else populate memory location and advance to the next one.
* Always check that you have not hit the memory bound */
if (words_read == 0 || words_read == -1) {
bytes_read = getline(&buffer, &buffer_len, datafile);
continue;
}
if (loc > memlen) {
printf("The memory location is out of range");
done = 1;
} else if (value_read > 9999 || value_read < -9999) {
printf("Hit sentinel, quitting loop");
done = 1;
} else {
mem[loc++] = value_read;
bytes_read = getline(&buffer, &buffer_len, datafile);
}
}
/* buffer is not needed anymore */
free(buffer);
/* zero-out the rest of the memory locations */
while (loc < memlen) {
mem[loc] = 0;
loc++;
}
dump_memory(mem, memlen);
}
void dump_memory_and_code(log_t* log, Backtrace* backtrace) {
struct user_regs_struct r;
if (ptrace(PTRACE_GETREGS, backtrace->Tid(), 0, &r) == -1) {
_LOG(log, logtype::ERROR, "cannot get registers: %s\n", strerror(errno));
return;
}
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rax), "memory near rax:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rbx), "memory near rbx:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rcx), "memory near rcx:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rdx), "memory near rdx:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rsi), "memory near rsi:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rdi), "memory near rdi:");
dump_memory(log, backtrace, static_cast<uintptr_t>(r.rip), "code around rip:");
}
// Execute a nonnumeric command; complain if it's not 'h', '?', 'd', 'q' or '\n'
// Return true for the q command, false otherwise
//
int execute_command(char cmd_char, int reg[], int nreg, int mem[], int memlen) {
if (cmd_char == '?' || cmd_char == 'h') {
help_message();
} else if (cmd_char == 'd') {
printf("Dumping control and memory:\n");
dump_control_unit(pc, ir, running, reg, NREG);
dump_memory(mem, MEMLEN);
} else if (cmd_char == 'q') {
printf("Quitting\n");
exit(0);
} else if (cmd_char == '\n' || cmd_char == ' ') {
one_instruction_cycle(reg,nreg,mem,memlen);
} else {
printf("Unkown command: %c; Ignoring it.\n",cmd_char);
return 1;
}
return 0;
}
int execute_command(char cmd_char, CPU *cpu) {
if (cmd_char == '?' || cmd_char == 'h') {
help_message();
} else if (cmd_char == 'd') {
printf("Dumping CPU and MEM:\n");
dump_CPU(cpu);
dump_memory(cpu);
} else if (cmd_char == 'q') {
printf("Quitting. \n");
exit(0);
} else if (cmd_char == '\n' || cmd_char == ' ') {
one_instruction_cycle(cpu);
} else {
printf("Unkown Command: %c \n",cmd_char);
return 1;
}
return 0;
}
// Main program: Initialize the cpu, read initial memory values,
// and execute the read-in program starting at location 00.
//
int main(int argc, char *argv[]) {
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
printf("=-=-=-=-=-=-= SDC SIM lab06 CS350 Devanshu Bharel =-=-=-=-=-=-=\n");
printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
initialize_control_unit(reg, NREG);
initialize_memory(argc, argv, mem, MEMLEN);
char *prompt = "> ";
printf("\nBeginning execution; type h for help\n%s", prompt);
int done = read_execute_command(reg, NREG, mem, MEMLEN);
while (!done) {
printf("%s", prompt);
done = read_execute_command(reg, NREG, mem, MEMLEN);
}
printf("At termination\n");
dump_control_unit(pc, ir, running, reg, NREG);
dump_memory(mem, MEMLEN);
return 0;
}
static void dumpFibers()
{
std::string msg;
msg.append(COLOR_LIGHTRED "User interrupt.");
if (Isolate::rt::g_trace)
msg.append(traceFiber());
else if (JSFiber::current())
msg.append(traceInfo(300));
msg.append(COLOR_RESET "\n");
std_logger::out(msg.c_str());
#ifdef DEBUG
dump_memory(0);
#endif
_exit(1);
}
// Read and dump initial values for memory
void initialize_memory(int argc, char *argv[], CPU *cpu) {
FILE *datafile = get_datafile(argc, argv);
#define BUFFER_LEN 80
char buffer[BUFFER_LEN];
int value_read, words_read, loc = 0, done = 0;
char *read_success; // NULL if reading in a line fails.
int max=MEMLEN;
read_success = fgets(buffer, BUFFER_LEN, datafile);
while (read_success != NULL && !done) {
words_read = sscanf(buffer, "%d", &value_read);
if (words_read==1){
if(loc>max){
printf("\nERROR: Memory out of Range!.");
done = 1;
}
else if (value_read < -9999 || value_read > 9999){
printf("\nSentinel %d at %d\n",value_read,loc);
done = 1;
}
else{
(*cpu).mem[loc]=value_read;
loc++;
}
}
read_success = fgets(buffer, BUFFER_LEN, datafile);
}
// Initialize rest of memory with zeroes.
while (loc < MEMLEN) {
cpu -> mem[loc++] = 0;
}
dump_memory(cpu);
}
