"I am a person who works hard and plays hard."

---

Yuan Wei
Second Year Graduate Student Department of Computer Science
University of Virginia Charlottesville, VA 22903
Email: yw3f@cs.virginia.edu

---

Source Code Analysis
         

---

eio.h File Reference

#include <stdio.h>

Include dependency graph for eio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

• #define EIO_PISA_FORMAT   1
• #define EIO_ALPHA_FORMAT   2
• #define EIO_FILE_VERSION   3

Functions

• FILE * eio_create (char *fname)
• FILE * eio_open (char *fname)
• int eio_valid (char *fname)
• void eio_close (FILE *fd)
• counter_t eio_write_chkpt (struct regs_t *regs, struct mem_t *mem, FILE *fd)
• counter_t eio_read_chkpt (struct regs_t *regs, struct mem_t *mem, FILE *fd)
• void eio_write_trace (FILE *eio_fd, counter_t icnt, struct regs_t *regs, mem_access_fn mem_fn, struct mem_t *mem, md_inst_t inst)
• void eio_read_trace (FILE *eio_fd, counter_t icnt, struct regs_t *regs, mem_access_fn mem_fn, struct mem_t *mem, md_inst_t inst)
• void eio_fast_forward (FILE *eio_fd, counter_t icnt)

---

Define Documentation

#define EIO_ALPHA_FORMAT   2

Definition at line 73 of file eio.h.

#define EIO_FILE_VERSION   3

Definition at line 76 of file eio.h. Referenced by eio_create(), and eio_open().

#define EIO_PISA_FORMAT   1

Definition at line 72 of file eio.h.

---

Function Documentation

void eio_close (  FILE *    fd )

Definition at line 226 of file eio.c. References gzclose(). Referenced by sim_main(), and sim_uninit(). { gzclose(fd); }

FILE* eio_create (  char *    fname )

Definition at line 122 of file eio.c. References ec_integer, ec_list, EIO_FILE_HEADER, EIO_FILE_VERSION, endian_big, endian_host_byte_order(), exo_delete(), exo_new(), exo_print(), fatal(), and gzopen(). Referenced by sim_load_prog(), and sim_main(). { FILE *fd; struct exo_term_t *exo; int target_big_endian; target_big_endian = (endian_host_byte_order() == endian_big); fd = gzopen(fname, "w"); if (!fd) fatal("unable to create EIO file `%s'", fname); /* emit EIO file header */ fprintf(fd, "%s\n", EIO_FILE_HEADER); fprintf(fd, "/* file_format: %d, file_version: %d, big_endian: %d */\n", MD_EIO_FILE_FORMAT, EIO_FILE_VERSION, ld_target_big_endian); exo = exo_new(ec_list, exo_new(ec_integer, (exo_integer_t)MD_EIO_FILE_FORMAT), exo_new(ec_integer, (exo_integer_t)EIO_FILE_VERSION), exo_new(ec_integer, (exo_integer_t)target_big_endian), NULL); exo_print(exo, fd); exo_delete(exo); fprintf(fd, "\n\n"); return fd; }

void eio_fast_forward (  FILE *    eio_fd, counter_t    icnt )

Definition at line 840 of file eio.c. References exo_term_t::as_integer, exo_term_t::as_list, counter_t, exo_term_t::ec, ec_integer, ec_list, eio_trans_icnt, exo_read(), and fatal(). Referenced by ld_load_prog(). { struct exo_term_t *exo, *exo_icnt; do { /* read the next external I/O (EIO) transaction */ exo = exo_read(eio_fd); if (!exo) fatal("could not fast forward to EIO checkpoint"); /* one more transaction processed */ eio_trans_icnt = icnt; /* pull apart the EIO transaction (EXO format) */ if (!exo || exo->ec != ec_list || !(exo_icnt = exo->as_list.head) || exo_icnt->ec != ec_integer) fatal("cannot read EIO transaction (during fast forward)"); } while ((counter_t)exo_icnt->as_integer.val != icnt); /* found it! */ }

FILE* eio_open (  char *    fname )

Definition at line 151 of file eio.c. References exo_term_t::as_list, exo_term_t::ec, ec_integer, ec_list, EIO_FILE_VERSION, endian_big, endian_host_byte_order(), exo_delete(), exo_read(), fatal(), gzopen(), and warn(). Referenced by ld_load_prog(). { FILE *fd; struct exo_term_t *exo; int file_format, file_version, big_endian, target_big_endian; target_big_endian = (endian_host_byte_order() == endian_big); fd = gzopen(fname, "r"); if (!fd) fatal("unable to open EIO file `%s'", fname); /* read and check EIO file header */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_integer || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_integer || !exo->as_list.head->next->next || exo->as_list.head->next->next->ec != ec_integer || exo->as_list.head->next->next->next != NULL) fatal("could not read EIO file header"); file_format = exo->as_list.head->as_integer.val; file_version = exo->as_list.head->next->as_integer.val; big_endian = exo->as_list.head->next->next->as_integer.val; exo_delete(exo); if (file_format != MD_EIO_FILE_FORMAT) fatal("EIO file `%s' has incompatible format", fname); if (file_version != EIO_FILE_VERSION) fatal("EIO file `%s' has incompatible version", fname); if (!!big_endian != !!target_big_endian) { warn("endian of `%s' does not match host", fname); warn("running with experimental cross-endian execution support"); warn("****************************************"); warn("**>> please check results carefully <<**"); warn("****************************************"); } return fd; }

counter_t eio_read_chkpt (  struct regs_t *    regs, struct mem_t *    mem, FILE *    fd )

Definition at line 333 of file eio.c. References exo_term_t::as_blob, exo_term_t::as_integer, exo_term_t::as_list, byte_t, counter_t, exo_term_t::ec, ec_address, ec_blob, ec_integer, ec_list, exo_delete(), exo_read(), fatal(), MD_EXO_TO_FREG, MD_EXO_TO_IREG, MD_EXO_TO_MISC_REGS, MEM_WRITE_BYTE, and exo_term_t::next. Referenced by ld_load_prog(). { int i, page_count; counter_t trans_icnt; struct exo_term_t *exo, *elt; /* read the EIO file pointer */ exo = exo_read(fd); if (!exo || exo->ec != ec_integer) fatal("could not read EIO file pointer"); trans_icnt = exo->as_integer.val; exo_delete(exo); /* read misc regs: icnt, PC, NPC, HI, LO, FCC */ exo = exo_read(fd); MD_EXO_TO_MISC_REGS(exo, sim_num_insn, regs); exo_delete(exo); /* read integer registers */ exo = exo_read(fd); if (!exo || exo->ec != ec_list) fatal("could not read EIO integer regs"); elt = exo->as_list.head; for (i=0; i < MD_NUM_IREGS; i++) { if (!elt) fatal("could not read EIO integer regs (too few)"); if (elt->ec != ec_address) fatal("could not read EIO integer regs (bad value)"); MD_EXO_TO_IREG(elt, regs, i); elt = elt->next; } if (elt != NULL) fatal("could not read EIO integer regs (too many)"); exo_delete(exo); /* read FP registers */ exo = exo_read(fd); if (!exo || exo->ec != ec_list) fatal("could not read EIO FP regs"); elt = exo->as_list.head; for (i=0; i < MD_NUM_FREGS; i++) { if (!elt) fatal("could not read EIO FP regs (too few)"); if (elt->ec != ec_address) fatal("could not read EIO FP regs (bad value)"); MD_EXO_TO_FREG(elt, regs, i); elt = elt->next; } if (elt != NULL) fatal("could not read EIO FP regs (too many)"); exo_delete(exo); /* read the number of page defs, and memory config */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_integer || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_address || !exo->as_list.head->next->next || exo->as_list.head->next->next->ec != ec_address || exo->as_list.head->next->next->next != NULL) fatal("could not read EIO memory page count"); page_count = exo->as_list.head->as_integer.val; ld_brk_point = (md_addr_t)exo->as_list.head->next->as_address.val; ld_stack_min = (md_addr_t)exo->as_list.head->next->next->as_address.val; exo_delete(exo); /* read text segment specifiers */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_address || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_integer || exo->as_list.head->next->next != NULL) fatal("count not read EIO text segment specifiers"); ld_text_base = (md_addr_t)exo->as_list.head->as_address.val; ld_text_size = (unsigned int)exo->as_list.head->next->as_integer.val; exo_delete(exo); /* read data segment specifiers */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_address || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_integer || exo->as_list.head->next->next != NULL) fatal("count not read EIO data segment specifiers"); ld_data_base = (md_addr_t)exo->as_list.head->as_address.val; ld_data_size = (unsigned int)exo->as_list.head->next->as_integer.val; exo_delete(exo); /* read stack segment specifiers */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_address || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_integer || exo->as_list.head->next->next != NULL) fatal("count not read EIO stack segment specifiers"); ld_stack_base = (md_addr_t)exo->as_list.head->as_address.val; ld_stack_size = (unsigned int)exo->as_list.head->next->as_integer.val; exo_delete(exo); for (i=0; i < page_count; i++) { int j; md_addr_t page_addr; struct exo_term_t *blob; /* read the page */ exo = exo_read(fd); if (!exo || exo->ec != ec_list || !exo->as_list.head || exo->as_list.head->ec != ec_address || !exo->as_list.head->next || exo->as_list.head->next->ec != ec_blob || exo->as_list.head->next->next != NULL) fatal("could not read EIO memory page"); page_addr = (md_addr_t)exo->as_list.head->as_address.val; blob = exo->as_list.head->next; /* write data to simulator memory */ for (j=0; j < blob->as_blob.size; j++) { byte_t val; val = blob->as_blob.data[j]; /* unchecked access... */ MEM_WRITE_BYTE(mem, page_addr, val); page_addr++; } exo_delete(exo); } return trans_icnt; }

void eio_read_trace (  FILE *    eio_fd, counter_t    icnt, struct regs_t *    regs, mem_access_fn    mem_fn, struct mem_t *    mem, md_inst_t    inst )

Definition at line 661 of file eio.c. References exo_term_t::as_blob, exo_term_t::as_integer, exo_term_t::as_list, counter_t, exo_term_t::ec, ec_address, ec_blob, ec_integer, ec_list, eio_trans_icnt, exo_delete(), exo_read(), FALSE, fatal(), MD_EXIT_SYSCALL, MD_EXO_CMP_IREG, MD_EXO_TO_IREG, MD_OUTPUT_SYSCALL, MD_STREAM_FILENO, mem_access_fn, myfprintf(), exo_term_t::next, panic(), Read, regs_t::regs_PC, sys_syscall(), and Write. Referenced by eio_write_trace(), and sys_syscall(). { int i; struct exo_term_t *exo, *exo_icnt, *exo_pc; struct exo_term_t *exo_inregs, *exo_inmem, *exo_outregs, *exo_outmem; struct exo_term_t *brkrec, *regrec, *memrec; /* exit() system calls get executed for real... */ if (MD_EXIT_SYSCALL(regs)) { sys_syscall(regs, mem_fn, mem, inst, FALSE); panic("returned from exit() system call"); } /* else, read the external I/O (EIO) transaction */ exo = exo_read(eio_fd); /* one more transaction processed */ eio_trans_icnt = icnt; /* pull apart the EIO transaction (EXO format) */ if (!exo || exo->ec != ec_list || !(exo_icnt = exo->as_list.head) || exo_icnt->ec != ec_integer || !(exo_pc = exo_icnt->next) || exo_pc->ec != ec_address || !(exo_inregs = exo_pc->next) || exo_inregs->ec != ec_list || !(exo_inmem = exo_inregs->next) || exo_inmem->ec != ec_list || !(exo_outregs = exo_inmem->next) || exo_outregs->ec != ec_list || !(exo_outmem = exo_outregs->next) || exo_outmem->ec != ec_list || exo_outmem->next != NULL) fatal("cannot read EIO transaction"); /* * check the system call inputs */ /* check ICNT input */ if (icnt != (counter_t)exo_icnt->as_integer.val) fatal("EIO trace inconsistency: ICNT mismatch"); /* check PC input */ if (regs->regs_PC != (md_addr_t)exo_pc->as_integer.val) fatal("EIO trace inconsistency: PC mismatch"); /* check integer register inputs */ for (i=MD_FIRST_IN_REG, regrec=exo_inregs->as_list.head; i <= MD_LAST_IN_REG; i++, regrec=regrec->next) { if (!regrec || regrec->ec != ec_address) fatal("EIO trace inconsistency: missing input reg"); if (MD_EXO_CMP_IREG(regrec, regs, i)) fatal("EIO trace inconsistency: R[%d] input mismatch", i); #ifdef VERBOSE fprintf(stderr, "** R[%d] checks out...\n", i); #endif /* VERBOSE */ } if (regrec != NULL) fatal("EIO trace inconsistency: too many input regs"); /* check memory inputs */ for (memrec=exo_inmem->as_list.head; memrec != NULL; memrec=memrec->next) { md_addr_t loc; struct exo_term_t *addr, *blob; /* check the mem transaction format */ if (!memrec || memrec->ec != ec_list || !(addr = memrec->as_list.head) || addr->ec != ec_address || !(blob = addr->next) || blob->ec != ec_blob || blob->next != NULL) fatal("EIO trace inconsistency: bad memory transaction"); for (loc=addr->as_integer.val, i=0; i < blob->as_blob.size; loc++,i++) { unsigned char val; /* was: val = MEM_READ_BYTE(loc); */ (*mem_fn)(mem, Read, loc, &val, sizeof(unsigned char)); if (val != blob->as_blob.data[i]) fatal("EIO trace inconsistency: addr 0x%08p input mismatch", loc); #ifdef VERBOSE myfprintf(stderr, "** 0x%08p checks out...\n", loc); #endif /* VERBOSE */ } /* simulate view'able I/O */ if (MD_OUTPUT_SYSCALL(regs)) { if (sim_progfd) { /* redirect program output to file */ fwrite(blob->as_blob.data, 1, blob->as_blob.size, sim_progfd); } else { /* write the output to stdout/stderr */ write(MD_STREAM_FILENO(regs), blob->as_blob.data, blob->as_blob.size); } } } /* * write system call outputs */ /* adjust breakpoint */ brkrec = exo_outregs->as_list.head; if (!brkrec || brkrec->ec != ec_address) fatal("EIO trace inconsistency: missing memory breakpoint"); ld_brk_point = (md_addr_t)brkrec->as_integer.val; /* write integer register outputs */ for (i=MD_FIRST_OUT_REG, regrec=exo_outregs->as_list.head->next; i <= MD_LAST_OUT_REG; i++, regrec=regrec->next) { if (!regrec || regrec->ec != ec_address) fatal("EIO trace inconsistency: missing output reg"); MD_EXO_TO_IREG(regrec, regs, i); #ifdef VERBOSE fprintf(stderr, "** R[%d] written...\n", i); #endif /* VERBOSE */ } if (regrec != NULL) fatal("EIO trace inconsistency: too many output regs"); /* write memory outputs */ for (memrec=exo_outmem->as_list.head; memrec != NULL; memrec=memrec->next) { md_addr_t loc; struct exo_term_t *addr, *blob; /* check the mem transaction format */ if (!memrec || memrec->ec != ec_list || !(addr = memrec->as_list.head) || addr->ec != ec_address || !(blob = addr->next) || blob->ec != ec_blob || blob->next != NULL) fatal("EIO trace icnonsistency: bad memory transaction"); for (loc=addr->as_integer.val, i=0; i < blob->as_blob.size; loc++,i++) { /* was: MEM_WRITE_BYTE(loc, blob->as_blob.data[i]); */ (*mem_fn)(mem, Write, loc, &blob->as_blob.data[i], sizeof(unsigned char)); #ifdef VERBOSE fprintf(stderr, "** 0x%08p written...\n", loc); #endif /* VERBOSE */ } } /* release the EIO EXO node */ exo_delete(exo); }

int eio_valid (  char *    fname )

Definition at line 201 of file eio.c. References EIO_FILE_HEADER, FALSE, gzclose(), gzopen(), and TRUE. Referenced by ld_load_prog(). { FILE *fd; char buf[512]; /* open possible EIO file */ fd = gzopen(fname, "r"); if (!fd) return FALSE; /* read and check EIO file header */ fgets(buf, 512, fd); /* check the header */ if (strcmp(buf, EIO_FILE_HEADER)) return FALSE; /* all done, close up file */ gzclose(fd); /* else, has a valid header, go with it... */ return TRUE; }

counter_t eio_write_chkpt (  struct regs_t *    regs, struct mem_t *    mem, FILE *    fd )

Definition at line 234 of file eio.c. References exo_term_t::as_list, ec_address, ec_blob, ec_integer, ec_list, eio_trans_icnt, exo_chain(), exo_delete(), exo_new(), exo_print(), MD_MISC_REGS_TO_EXO, MEM_FORALL, MEM_PTE_ADDR, myfprintf(), mem_pte_t::page, and mem_t::page_count. Referenced by sim_main(). { int i; struct exo_term_t *exo; struct mem_pte_t *pte; myfprintf(fd, "/* ** start checkpoint @ %n... */\n\n", eio_trans_icnt); myfprintf(fd, "/* EIO file pointer: %n... */\n", eio_trans_icnt); exo = exo_new(ec_integer, (exo_integer_t)eio_trans_icnt); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump misc regs: icnt, PC, NPC, etc... */ fprintf(fd, "/* misc regs icnt, PC, NPC, etc... */\n"); exo = MD_MISC_REGS_TO_EXO(regs); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump integer registers */ fprintf(fd, "/* integer regs */\n"); exo = exo_new(ec_list, NULL); for (i=0; i < MD_NUM_IREGS; i++) exo->as_list.head = exo_chain(exo->as_list.head, MD_IREG_TO_EXO(regs, i)); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* dump FP registers */ fprintf(fd, "/* FP regs (integer format) */\n"); exo = exo_new(ec_list, NULL); for (i=0; i < MD_NUM_FREGS; i++) exo->as_list.head = exo_chain(exo->as_list.head, MD_FREG_TO_EXO(regs, i)); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* writing `%d' memory pages... */\n", (int)mem->page_count); exo = exo_new(ec_list, exo_new(ec_integer, (exo_integer_t)mem->page_count), exo_new(ec_address, (exo_integer_t)ld_brk_point), exo_new(ec_address, (exo_integer_t)ld_stack_min), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* text segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_text_base), exo_new(ec_integer, (exo_integer_t)ld_text_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* data segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_data_base), exo_new(ec_integer, (exo_integer_t)ld_data_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); fprintf(fd, "/* stack segment specifiers (base & size) */\n"); exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)ld_stack_base), exo_new(ec_integer, (exo_integer_t)ld_stack_size), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); /* visit all active memory pages, and dump them to the checkpoint file */ MEM_FORALL(mem, i, pte) { /* dump this page... */ exo = exo_new(ec_list, exo_new(ec_address, (exo_integer_t)MEM_PTE_ADDR(pte, i)), exo_new(ec_blob, MD_PAGE_SIZE, pte->page), NULL); exo_print(exo, fd); fprintf(fd, "\n\n"); exo_delete(exo); } myfprintf(fd, "/* ** end checkpoint @ %n... */\n\n", eio_trans_icnt); return eio_trans_icnt; }

void eio_write_trace (  FILE *    eio_fd, counter_t    icnt, struct regs_t *    regs, mem_access_fn    mem_fn, struct mem_t *    mem, md_inst_t    inst )

Definition at line 596 of file eio.c. References exo_term_t::as_list, counter_t, ec_address, ec_integer, ec_list, eio_read_trace(), eio_trans_icnt, mem_rec_t::exo, exo_chain(), exo_delete(), exo_new(), exo_print(), FALSE, local_mem_fn, mem_access_fn, my_mem_fn(), regs_t::regs_PC, seen_write, and sys_syscall(). { int i; struct exo_term_t *exo; /* write syscall register inputs ($r2..$r7) */ input_regs = exo_new(ec_list, NULL); for (i=MD_FIRST_IN_REG; i <= MD_LAST_IN_REG; i++) { input_regs->as_list.head = exo_chain(input_regs->as_list.head, MD_IREG_TO_EXO(regs, i)); } /* initialize memory inputs */ input_mem = exo_new(ec_list, NULL); input_mem_rec.exo = NULL; output_mem = exo_new(ec_list, NULL); output_mem_rec.exo = NULL; /* perform the system call, record inputs and outputs */ seen_write = FALSE; local_mem_fn = mem_fn; if (sim_eio_fd != NULL) eio_read_trace(sim_eio_fd, icnt, regs, my_mem_fn, mem, inst); else { sys_syscall(regs, my_mem_fn, mem, inst, FALSE); } /* write syscall breakpoint and register outputs ($r2..$r7) */ output_regs = exo_new(ec_list, NULL); output_regs->as_list.head = exo_chain(output_regs->as_list.head, exo_new(ec_address, (exo_integer_t)ld_brk_point)); for (i=MD_FIRST_OUT_REG; i <= MD_LAST_OUT_REG; i++) { output_regs->as_list.head = exo_chain(output_regs->as_list.head, MD_IREG_TO_EXO(regs, i)); } /* write the whole enchalada to output stream */ exo = exo_new(ec_list, /* icnt */exo_new(ec_integer, (exo_integer_t)icnt), /* PC */exo_new(ec_address, (exo_integer_t)regs->regs_PC), input_regs, input_mem, output_regs, output_mem, NULL); exo_print(exo, eio_fd); fprintf(eio_fd, "\n\n"); /* release input storage */ exo_delete(exo); /* one more transaction processed */ eio_trans_icnt = icnt; }

	Department of Computer Science School of Engineering, University of Virginia 151 Engineer's Way, P.O. Box 400740 Charlottesville, Virginia 22904-4740 (434) 982-2200  Fax: (434) 982-2214