Exemple #1
0
/**
 * Runs the instruction at the program counters position in memory.
 */
void vm_exec()
{
	cycles++;
	Instruction* op = mem_load_instr(pcounter);
	print_instr(op);

	switch(op->op)
	{
		case OP_NAP: break;

		case OP_ADD: 	op_add(op); 	break;
		case OP_SUB: 	op_sub(op); 	break;

		case OP_EXP:	op_exp(op);		break;
		case OP_SIN:	op_sin(op);		break;
		case OP_COS:	op_cos(op);		break;
		case OP_TAN:	op_tan(op);		break;

		case OP_LW: 	op_lw(op);		break;

		case OP_SW:		op_sw(op);		break;
		case OP_SB:		op_sb(op);		break;

		case OP_J:		op_j(op); 		return; // Jump
		case OP_JR:		op_jr(op);		return;
		case OP_JAL:	op_jal(op);		return;
		case OP_JZ:		op_jz(op);		return;
		case OP_JNZ:	op_jnz(op);		return;
		case OP_JEQ:	op_jeq(op);		return;
		case OP_JNQ:	op_jnq(op);		return;

		case OP_PUSH:	op_push(op);	break;
		case OP_POP:	op_pop(op);		break;

		case OP_PRTI:	op_prti(op);	break;

		case OP_EXIT: 	
			vm_exit(op->k); 
			return;

		/* Unsupported operation */
		default:
			printf("Error: Invalid operation at %d\n", pcounter);
			print_instr(op);
			vm_exit(-1);
			return;
	}

	pcounter = pcounter + 8;
}
void InstructionPrinter::print_line(Instruction* instr) {
  // print instruction data on one line
  if (instr->is_pinned()) tty->put('.');
  fill_to(bci_pos  ); tty->print("%d", instr->bci());
  fill_to(use_pos  ); tty->print("%d", instr->use_count());
  fill_to(temp_pos ); print_temp(instr);
  fill_to(instr_pos); print_instr(instr);
  tty->cr();
  // add a line for StateSplit instructions w/ non-empty stacks
  // (make it robust so we can print incomplete instructions)
  StateSplit* split = instr->as_StateSplit();
  if (split != NULL && split->state() != NULL && !split->state()->stack_is_empty()) {
    fill_to(instr_pos); print_stack(split->state());
    tty->cr();
  }
}
void jellyfish::pretty_dump() const
{
    // get pc
    s32 pc=peekix(REG_PCO)%m_heap_size;
    s32 stop=peekix(REG_STP);

    printf("-- prog -- pc:%d\n",pc);

	for (s32 n=pc-7; n<pc+7; n++)
	{
        if (n>=0 || n<m_heap_size)
        {
            if (n==pc)
            {
                printf("%03d > ",n);
            }
            else
            {
                printf("%03d   ",n);
            }
            
            print_instr(n);
            printf("\n");
        }
	}

    printf("-- stk -- stk:%d\n",stop);
	for (u32 n=REG_STK+stop-2; n<REG_STK+stop+2; n++)
	{
        char txt[2048];
        if (n==stop+REG_STK)
        {
            sprintf(txt,"%s","> %f %f %f : %d\n");
        }
        else
        {
            sprintf(txt,"%s","  %f %f %f : %d\n");
        }

		printf(txt,
               (float)m_heap[n].x,
               (float)m_heap[n].y,
               (float)m_heap[n].z,
               n);
	}

}
void jellyfish::simple_dump() const
{
    s32 pc=peekix(REG_PCO)%m_heap_size;
	for (u32 n=0; n<m_heap_size; n++)
	{
        if (n==pc)
        {
            printf("> ");
        }
        else
        {
            printf("  ");
        }

        print_instr(n);
        printf(" : %d\n",n);
	}
}
Exemple #5
0
void Shade::disassemble_code(void *code, void *target, size_t size)
{
    instr_t instr;

    byte *pos = (byte *)code;
    byte *stop = (byte *)code + size;

    while(pos < stop)
    {
        instr_init(0, &instr);

        byte *next = decode_from_copy(0, pos, (byte *)target + (pos - (byte *)code), &instr);

        print_instr(pos - (byte *)code + (byte *)target, &instr);

        pos = next;

        instr_free(0, &instr);
    }

}
Exemple #6
0
void print_text_segment() {
    int i;
    instr_t *instr;

    printf("\n");
    printf(".text\n");
    printf(".global main\n");

    for(i=0;i<MAX_NUM_OF_MODULES;i++) {
        instr = final_tree[i];
        if (!instr) {
            return;
        }

        free_all_registers();
        while (instr) {
            register_allocate(instr);
            print_instr(instr);
            register_free(instr);
            instr = instr->next;
        }
        printf("\n");
    }
}
Exemple #7
0
void print_func_body(Output& out, const FuncInfo& finfo) {
  auto const func = finfo.func;

  auto       lblIter = begin(finfo.labels);
  auto const lblStop = end(finfo.labels);
  auto       ehIter  = begin(finfo.ehStarts);
  auto const ehStop  = end(finfo.ehStarts);
  auto       bcIter  = func->unit()->at(func->base());
  auto const bcStop  = func->unit()->at(func->past());

  min_priority_queue<Offset> ehEnds;

  while (bcIter != bcStop) {
    auto const pop = reinterpret_cast<const Op*>(bcIter);
    auto const off = func->unit()->offsetOf(pop);

    // First, close any protected EH regions that are past-the-end at
    // this offset.
    while (!ehEnds.empty() && ehEnds.top() == off) {
      ehEnds.pop();
      out.dec_indent();
      out.fmtln("}}");
    }

    // Next, open any new protected regions that start at this offset.
    for (; ehIter != ehStop && ehIter->first == off; ++ehIter) {
      auto const info = finfo.ehInfo.find(ehIter->second);
      always_assert(info != end(finfo.ehInfo));
      match<void>(
        info->second,
        [&] (const EHCatch& catches) {
          out.indent();
          out.fmt(".try_catch");
          for (auto& kv : catches.blocks) {
            out.fmt(" ({} {})", kv.first, kv.second);
          }
          out.fmt(" {{");
          out.nl();
        },
        [&] (const EHFault& fault) {
          out.fmtln(".try_fault {} {{", fault.label);
        }
      );
      out.inc_indent();
      ehEnds.push(ehIter->second->m_past);
    }

    // Then, print labels if we have any.  This order keeps the labels
    // from dangling on weird sides of .try_fault or .try_catch
    // braces.
    while (lblIter != lblStop && lblIter->first < off) ++lblIter;
    if (lblIter != lblStop && lblIter->first == off) {
      out.dec_indent();
      out.fmtln("{}:", lblIter->second);
      out.inc_indent();
    }

    print_instr(out, finfo, bcIter);

    bcIter += instrLen(reinterpret_cast<const Op*>(bcIter));
  }
}
Exemple #8
0
int main(int argc, char *argv[])
{
  FILE *fp;
  int i, pc_init;
  Program pm[50000];
  float x = 0.0;

  fpin = stdin;
  fpout = stdout;

  for(i = 0; i < 32; i++) {
    reg[i].i = 0;
    freg[i].i = 0;
  }

  reg[29].i = 1048575;
  reg[30].i = 65536;
  
  for(i = 0; i < 1048576; i++)
    memory[i].i = 0;

  if((fp = fopen(argv[argc-1],"r")) == NULL) {
    perror("open error");
    return 0;
  }

  load(fp, pm);

  fclose(fp);

  getoption(argc, argv); 

  pc_init = pc;
  while(x < 2*M_PI) {
    freg[12].f = x;
  
    do{
      if(printflag == 1)
        print_instr(pm[pc]);
      
      while((breakflag == 1 && pc == breakpoint) || (stepflag == 1 && stepcount == 0))
        bpoint(pm[pc]);
      
      if(stepcount > 0)
        stepcount--;
      
    } while(exec(pm[pc]) == 0);
    
    fprintf(fpout, "%f %f\n", x, freg[0].f);
    x += 0.01;
    pc = pc_init;
    for(i = 0; i < 32; i++)
      freg[i].i = 0;
  }

  fprintf(stderr, "complete instructions\n");
  print_status();

  fclose(fpin);
  fclose(fpout);

  return 0;
}
Exemple #9
0
t_stat fprint_sym (FILE *ofile, t_addr simh_addr, t_value *val, UNIT *uptr, int32 sw)
{
    //log_msg(INFO_MSG, "SYS:fprint_sym", "addr is %012llo; val-ptr is %p, uptr is %p, sw is %#o\n", simh_addr, val, uptr, sw);

    if (uptr == &cpu_unit) {
        // memory request -- print memory specified by SIMH 
        addr_modes_t mode;
        unsigned segno;
        unsigned offset;
        if (addr_simh_to_emul(simh_addr, &mode, &segno, &offset) != 0)
            return SCPE_ARG;
        unsigned abs_addr;
        if (addr_any_to_abs(&abs_addr, mode, segno, offset) != 0)
            return SCPE_ARG;
        // note that parse_addr() was called by SIMH to determine the absolute addr.
        static int need_init = 1;
        if (need_init) {
            need_init = 0;
            prior_lineno = 0;
            prior_line = NULL;
        }
        /* First print matching source line if we're dumping instructions */
        if (sw & SWMASK('M')) {
            // M -> instr -- print matching source line if we have one
            const char* line;
            int lineno;
            seginfo_find_line(segno, offset, &line, &lineno);
            if (line != NULL && prior_lineno != lineno && prior_line != line) {
                fprintf(ofile, "\r\n");
                fprint_addr(ofile, NULL, simh_addr);    // UNIT doesn't include a reference to a DEVICE
                fprintf(ofile, ":\t");
                fprintf(ofile, "Line %d: %s\n", lineno, line);
                // fprintf(ofile, "%06o:\t", abs_addr); // BUG: print seg|offset too
                fprint_addr(ofile, NULL, simh_addr);    // UNIT doesn't include a reference to a DEVICE
                fprintf(ofile, ":\t");
                prior_lineno = lineno;
                prior_line = line;
            }
        }
        /* Next, we always output the numeric value */
        t_addr alow = abs_addr;
        t_addr ahi = abs_addr;
        t_uint64 word;
        word = Mem[abs_addr];
        if (word == ~ (t_uint64) 0)
            word = 0;
        fprintf(ofile, "%012llo", word);
        if (sw & SWMASK('S') || (sw & SWMASK('X'))) {
            // SDWs are two words
            ++ ahi;
            t_uint64 hiword = Mem[ahi];
            if (hiword == ~ (t_uint64) 0)
                hiword = 0;
            fprintf(ofile, " %012llo", hiword);
        }
        /* User may request (A)scii in addition to another format */
        if (sw & SWMASK('A')) {
            for (t_addr a = alow; a <= ahi; ++ a) {
                t_uint64 word = Mem[a];
                if (word == ~ (t_uint64) 0)
                    word = 0;
                fprintf(ofile, " ");
                for (int i = 0; i < 4; ++i) {
                    uint c = word >> 27;
                    word = (word << 9) & MASKBITS(36);
                    if (c <= 0177 && isprint(c)) {
                        fprintf(ofile, "  '%c'", c);
                    } else {
                        fprintf(ofile, " \\%03o", c);
                    }
                }
            }
        }
        /* See if any other format was requested (but don't bother honoring
           multiple formats */
        if (sw & SWMASK('A')) {
            // already done
        }
        if (sw & SWMASK('L')) {
            // L -> LPW
            fprintf(ofile, " %s", print_lpw(abs_addr));
        } else if (sw & SWMASK('M')) {
            // M -> instr
            char *instr = print_instr(word);
            fprintf(ofile, " %s", instr);
        } else if (sw & SWMASK('P') || (sw & SWMASK('Y'))) {
            // P/Y -> PTW
            char *s = print_ptw(word);
            fprintf(ofile, " %s", s);
        } else if (sw & SWMASK('S') || (sw & SWMASK('X'))) {
            // S/X -> SDW
            t_uint64 hiword = Mem[ahi];
            if (hiword == ~ (t_uint64) 0)
                hiword = 0;
            char *s = print_sdw(word, hiword);
            fprintf(ofile, " %s", s);
        } else if (sw & SWMASK('W')) {
            // W -> DCW
            char *s = print_dcw(abs_addr);
            fprintf(ofile, " %s", s);
        } else if (sw) {
            return SCPE_ARG;
        } else {
            // we already printed the numeric value, so nothing else to do
        }
        fflush(ofile);
        return SCPE_OK;
    } else if (sw & SIM_SW_REG) {
Exemple #10
0
int main(int argc, char *argv[]) {
	if (argc < 2) {
		usage(argv[0]);
	}

	if ((fin = fopen(argv[1], "rb")) == 0) {
		fprintf(stderr, "Error: could not open file\n");
		exit(1);
	}

	BYTE *fbuf = (BYTE *) malloc(16 * sizeof(BYTE));
	pe = (PESTRUCT *) malloc(sizeof(PESTRUCT));

	parse_pe_header();

	printf("EP RVA: %.8X\n", pe->rvaep);
	printf("Code section RVA: %.8X\n", pe->rvacode);
	printf("Data section RVA: %.8X\n", pe->rvadata);
	printf("Image base: %.8X\n", pe->imagebase);
	printf("Size of code section: %.8X\n", pe->codesize);

	/* Get size of headers to know where code section starts */
	fseek(fin, pe->offset + 84, SEEK_SET);
	fgets(fbuf, 4, fin);
	pe->codeoffset = lendian(fbuf, 4);
	printf("Code section offset: %.8X\n", pe->codeoffset);

	/* Get OEP address */
	pe->oep = pe->imagebase + pe->rvacode;
	printf("OEP address: %.8X\n", pe->oep);

	printf("\n");	// Formatting

	/* Get max offset from total file size */
	fseek(fin, 0L, SEEK_END);
	pe->maxoffset = ftell(fin);

	fseek(fin, pe->codeoffset, SEEK_SET);	// Go to start of code section

	DWORD len;
	DWORD cur_addr = pe->oep;	// First instruction at OEP
	DWORD addr;
	int i;
	int quit = 0;

	/* Start parsing and outputting 50 instructions at a time, waiting for user input after each block */
	while (!feof(fin) && !quit) {
		printf(":");

		/* Wait for user input */
		int ch = _getch();
		printf("\b");	// Erase character
		switch (ch) {
		case KEY_ESC:	// Quit
		case 'q':
			quit = 1;
			break;
		case 'n':	// Next instruction
			print_instr(&cur_addr);
			break;
		case ' ':	// Next 32 instructions
			print_ninstr(&cur_addr, 50);
			break;
		case 'o':	// Go back to OEP
			printf("\r \n");	// Clear line
			printf("EP RVA: %.8X\n", pe->rvaep);
			printf("Code section RVA: %.8X\n", pe->rvacode);
			printf("Data section RVA: %.8X\n", pe->rvadata);
			printf("Image base: %.8X\n", pe->imagebase);
			printf("Size of code section: %.8X\n", pe->codesize);
			printf("Code section offset: %.8X\n", pe->codeoffset);
			printf("OEP address: %.8X\n", pe->oep);
			printf("\n");
			fseek(fin, pe->codeoffset, SEEK_SET);
			cur_addr = pe->oep;
			break;
		case 'g': {	// Go to specific address
			printf("\r \n");	// Clear line
			printf("Go to address: ");
			char getaddr[32];
			fgets(getaddr, sizeof(getaddr), stdin);	// Get input
			if (getaddr[0] == '\n' || getaddr[0] == '\r') { printf("\n"); break; }	// Blank input (cancel instruction)
			addr = strtol(getaddr, NULL, 16);	// Parse input address
			if (!print_instr(&addr)) break;	// Print the first instruction
			cur_addr = addr;
			break;
		}
		case 'f': {	// Follow instruction at specific address
			printf("\r \n");	// Clear line
			printf("Address of instruction to follow: ");
			char addrstr[32];
			fgets(addrstr, sizeof(addrstr), stdin);	// Get input
			if (addrstr[0] == '\n' || addrstr[0] == '\r') { printf("\n"); break; }	// Blank input (cancel instruction)
			addr = strtol(addrstr, NULL, 16);
			char *instr = get_instr(addr);
			if (!instr) break;	// Error
			printf("%.8X\t%s\n", addr, instr);	// Print instruction to follow
			printf("\t\tv\n");
			addr = parse_addr(instr);
			if (!print_instr(&addr)) break;
			cur_addr = addr;
			free(instr);
			break;
		}
		case 'd': {	// Dump data at specific address
			printf("\r \n");	// Clear line
			printf("Address to dump: ");
			char addrstr[32];
			fgets(addrstr, sizeof(addrstr), stdin);	// Get input
			if (addrstr[0] == '\n' || addrstr[0] == '\r') { printf("\n"); break; }	// Blank input (cancel instruction)
			addr = strtol(addrstr, NULL, 16);
			if (!valid_addr(addr)) {
				printf("Address out of bounds\n");
				break;
			}
			printf("Number of bytes to dump (default 16): ");
			char bytesstr[3];
			fgets(bytesstr, sizeof(bytesstr), stdin);
			int bytes = strtol(bytesstr, NULL, 10);
			if (bytes == 0) bytes = 16;
			if (bytes > DUMP_MAX) {
				printf("Too high\n");
				break;
			}
			print_dump(addr, bytes);
			printf("\n");	// Formatting
			break;
		}
		case 's': {	// Search for a string in .data, .rdata, and .rsrc sections (no unicode support)
			printf("\r \n");	// Clear line
			printf("Search for string: ");
			char searchstr[STRLEN_MAX];
			fgets(searchstr, sizeof(searchstr), stdin);	// Get input
			if (searchstr[0] == '\n' || searchstr[0] == '\r') { printf("\n"); break; }	// Blank input (cancel instruction)
			addr = find_string_addr(searchstr);	// Find address of string
			if (addr == 0) {
				printf("String not found\n");
			} else {
				print_dump_str(addr);	// Print dump of matched string
			}
			printf("\n");	// Formatting
			break;
		}
		case 'e': {	// Edit binary
			printf("\r \n");	// Clear line
			printf("Starting address for editing: ");
			char addrstr[32];
			fgets(addrstr, sizeof(addrstr), stdin);	// Get input
			if (addrstr[0] == '\n' || addrstr[0] == '\r') { printf("\n"); break; }	// Blank input (cancel instruction)
			addr = strtol(addrstr, NULL, 16);
			if (!valid_addr(addr)) {
				printf("Address out of bounds\n");
				break;
			}
			printf("Input hex bytes: ");
			char bytestr[STRLEN_MAX];
			fgets(bytestr, sizeof(bytestr), stdin);	// Get input
			char *edit_file = (char *) calloc(strlen(argv[1]) + 6, sizeof(char));
			strncpy(edit_file, argv[1], strlen(argv[1]) - 4);
			strcat(edit_file, "_edit.exe");	// Edited file name: inputfilename_edit.exe
			save_edits_to_file(fin, edit_file, addr, bytestr);
			printf("Edited file %s saved\n\n", edit_file);
			free(edit_file);
			break;
		}
		case 'h':	// Show help
		case '?':
			print_help();
			break;

		// Special keys
		case SPECIAL_KEY:
			ch = _getch();
			switch (ch) {
			case KEY_DOWN:	// Next instruction
				print_instr(&cur_addr);
				break;
			case KEY_PGDN:	// Next 32 instructions
				print_ninstr(&cur_addr, 50);
				break;
			case KEY_HOME:	// Go back to OEP
				printf("\r \n");	// Clear line
				printf("EP RVA: %.8X\n", pe->rvaep);
				printf("Code section RVA: %.8X\n", pe->rvacode);
				printf("Data section RVA: %.8X\n", pe->rvadata);
				printf("Image base: %.8X\n", pe->imagebase);
				printf("Size of code section: %.8X\n", pe->codesize);
				printf("Code section offset: %.8X\n", pe->codeoffset);
				printf("OEP address: %.8X\n", pe->oep);
				printf("\n");
				fseek(fin, pe->codeoffset, SEEK_SET);
				cur_addr = pe->oep;
				break;
			default:
				//printf("0x%X\n", ch);	// DEBUGGING
				break;
			}
			break;

		default:
			//printf("0x%X\n", ch);	// DEBUGGING
			break;
		}

		fflush(stdin);
	}

	free(fbuf);
	free(pe);

	fclose(fin);

	return 0;
}