FILE *
eio_create(char *fname)
{
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;
}
FILE *
eio_open(char *fname)
{
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;
}
/* read one EXO term from STREAM */
struct exo_term_t *
exo_read(FILE *stream)
{
int tok;
char tok_buf[1024], *endp;
struct exo_term_t *ent = NULL;
extern int errno;
extern void yy_setstream(FILE *);
/* make sure we have a valid stream */
if (!stream)
stream = stdin;
yy_setstream(stream);
/* make local copies of everything, allows arbitrary recursion */
tok = yylex();
strcpy(tok_buf, yytext);
switch (tok)
{
case lex_integer:
{
exo_integer_t int_val;
/* attempt integer conversion */
errno = 0;
#ifdef HOST_HAS_QUAD
int_val = myatoq(tok_buf, &endp, /* parse base */10);
#else /* !HOST_HAS_QUAD */
int_val = strtoul(tok_buf, &endp, /* parse base */10);
#endif /* HOST_HAS_QUAD */
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_integer, int_val);
}
else
exo_err("cannot parse integer literal");
}
break;
case lex_address:
{
exo_address_t addr_val;
/* attempt address conversion */
errno = 0;
#ifdef HOST_HAS_QUAD
addr_val = myatoq(tok_buf, &endp, /* parse base */16);
#else /* !HOST_HAS_QUAD */
addr_val = strtoul(tok_buf, &endp, /* parse base */16);
#endif /* HOST_HAS_QUAD */
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_address, addr_val);
}
else
exo_err("cannot parse address literal");
}
break;
case lex_float:
{
exo_float_t float_val;
/* attempt double conversion */
errno = 0;
float_val = strtod(tok_buf, &endp);
if (!errno && !*endp)
{
/* good conversion */
ent = exo_new(ec_float, float_val);
}
else
exo_err("cannot parse floating point literal");
}
break;
case lex_char:
{
int c;
c = intern_char(tok_buf, &endp);
if (!endp)
exo_err("cannot convert character literal");
ent = exo_new(ec_char, c);
}
break;
case lex_string:
{
char *s;
s = intern_string(tok_buf);
ent = exo_new(ec_string, s);
free(s);
}
break;
case lex_token:
ent = exo_new(ec_token, tok_buf);
break;
case lex_byte:
exo_err("unexpected blob byte encountered");
break;
case '(':
{
struct exo_term_t *elt;
ent = exo_new(ec_list, NULL);
if (yy_nextchar() != ')')
{
/* not an empty list */
do {
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
ent->as_list.head =
exo_chain(ent->as_list.head, elt);
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ')');
}
/* read tail delimiter */
tok = yylex();
if (tok != ')')
exo_err("expected ')'");
}
break;
case ')':
exo_err("unexpected ')' encountered");
break;
case '<':
exo_err("unexpected '<' encountered");
break;
case '>':
exo_err("unexpected '>' encountered");
break;
case '{':
{
int cnt, size;
struct exo_term_t *elt;
/* get the size */
elt = exo_read(stream);
if (!elt || elt->ec != ec_integer)
exo_err("badly formed array size");
/* record the size of the array/blob */
size = (int)elt->as_integer.val;
/* done with the EXO integer */
exo_delete(elt);
/* read the array delimiters */
tok = yylex();
if (tok != '}')
exo_err("expected '}'");
tok = yylex();
switch (tok)
{
case '[': /* array definition */
/* allocate an array definition */
ent = exo_new(ec_array, size, NULL);
/* read until array is full or tail delimiter encountered */
if (yy_nextchar() != ']')
{
/* not an empty array */
cnt = 0;
do {
if (cnt == ent->as_array.size)
exo_err("too many initializers for array");
/* NULL element? */
if (yy_nextchar() == ',')
{
elt = NULL;
}
else
{
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
}
SET_EXO_ARR(ent, cnt, elt);
cnt++;
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ']');
}
/* read tail delimiter */
tok = yylex();
if (tok != ']')
exo_err("expected ']'");
break;
case '<': /* blob definition */
/* allocate an array definition */
ent = exo_new(ec_blob, size, /* zero contents */NULL);
/* read until blob is full */
if (yy_nextchar() != '>')
{
unsigned int byte_val;
/* not an empty array */
cnt = 0;
for (;;) {
/* read next blob byte */
tok = yylex();
if (tok == lex_byte)
{
if (cnt == ent->as_blob.size)
exo_err("too many initializers for blob");
/* attempt hex conversion */
errno = 0;
byte_val = strtoul(yytext, &endp, /* parse base */16);
if (errno != 0 || *endp != '\0')
exo_err("cannot parse blob byte literal");
if (byte_val > 255)
panic("bogus byte value");
ent->as_blob.data[cnt] = byte_val;
cnt++;
}
else if (tok == '>')
break;
else
exo_err("unexpected character in blob");
}
}
#if 0 /* zero tail is OK... */
if (cnt != ent->as_blob.size)
exo_err("not enough initializers for blob");
#endif
break;
default:
exo_err("expected '[' or '<'");
}
}
break;
case '}':
exo_err("unexpected '}' encountered");
break;
case ',':
exo_err("unexpected ',' encountered");
break;
case '[':
{
int i, cnt;
struct exo_term_t *list, *elt, *next_elt;
/* compute the array size */
list = NULL;
if (yy_nextchar() == ']')
exo_err("unsized array has no initializers");
cnt = 0;
do {
/* NULL element? */
if (yy_nextchar() == ',')
{
elt = exo_new(ec_null);
}
else
{
elt = exo_read(stream);
if (!elt)
exo_err("unexpected end-of-file");
}
cnt++;
list = exo_chain(list, elt);
/* consume optional commas */
if (yy_nextchar() == ',')
yylex();
} while (yy_nextchar() != ']');
/* read tail delimiter */
tok = yylex();
if (tok != ']')
exo_err("expected ']'");
/* create the array */
assert(cnt > 0);
ent = exo_new(ec_array, cnt, NULL);
/* fill up the array */
for (i=0,elt=list; i<cnt; i++,elt=next_elt)
{
assert(elt != NULL);
next_elt = elt->next;
if (elt->ec == ec_null)
{
SET_EXO_ARR(ent, cnt, NULL);
exo_delete(ent);
}
else
{
SET_EXO_ARR(ent, cnt, elt);
elt->next = NULL;
}
}
}
break;
case ']':
exo_err("unexpected ']' encountered");
break;
case lex_eof:
/* nothing to read */
ent = NULL;
break;
default:
panic("bogus token");
}
return ent;
}
/* release an EXO term */
void
exo_delete(struct exo_term_t *exo)
{
exo->next = NULL;
switch (exo->ec)
{
case ec_integer:
/* no extra storage */
exo->as_integer.val = 0;
break;
case ec_address:
/* no extra storage */
exo->as_address.val = 0;
break;
case ec_float:
/* no extra storage */
exo->as_float.val = 0.0;
break;
case ec_char:
/* no extra storage */
exo->as_char.val = '\0';
break;
case ec_string:
free(exo->as_string.str);
exo->as_string.str = NULL;
break;
case ec_list:
{
struct exo_term_t *ent, *next_ent;
for (ent=exo->as_list.head; ent != NULL; ent = next_ent)
{
next_ent = ent->next;
exo_delete(ent);
}
exo->as_list.head = NULL;
}
break;
case ec_array:
{
int i;
for (i=0; i < exo->as_array.size; i++)
{
if (exo->as_array.array[i] != NULL)
exo_delete(exo->as_array.array[i]);
}
free(exo->as_array.array);
exo->as_array.array = NULL;
exo->as_array.size = 0;
}
break;
case ec_token:
/* no extra storage */
exo->as_token.ent = NULL;
break;
case ec_blob:
/* free the blob data */
free(exo->as_blob.data);
exo->as_blob.data = NULL;
break;
case ec_null:
/* no extra storage */
break;
default:
panic("bogus EXO class");
}
exo->ec = (enum exo_class_t)0;
/* release the node */
free(exo);
}
/* check point current architected state to stream FD, returns
EIO transaction count (an EIO file pointer) */
counter_t
eio_write_chkpt(struct regs_t *regs, /* regs to dump */
struct mem_t *mem, /* memory to dump */
FILE *fd) /* stream to write to */
{
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);
}