#undef RELEASE_DATE
#undef VERSION
#define VERSION_MAJOR "0"
-#define VERSION_MINOR "63"
-#define RELEASE_DATE "28 May 2004"
+#define VERSION_MINOR "64"
+#define RELEASE_DATE "28 June 2004"
#define VERSION VERSION_MAJOR "." VERSION_MINOR
#include <stdarg.h>
(blob->op == OP_BLOBCONST)) {
unsigned char buffer[SIZEOF_WORD];
size_t reg_size, mem_size;
- const char *src;
+ const char *src, *end;
ulong_t val;
reg_size = reg_size_of(state, ins->type);
if (reg_size > REG_SIZEOF_REG) {
internal_error(state, ins, "load size greater than register");
}
mem_size = size_of(state, ins->type);
+ end = blob->u.blob;
+ end += bits_to_bytes(size_of(state, sdecl->type));
src = blob->u.blob;
src += addr->u.cval;
+ if (src > end) {
+ error(state, ins, "Load address out of bounds");
+ }
+
memset(buffer, 0, sizeof(buffer));
memcpy(buffer, src, bits_to_bytes(mem_size));
jmp = flatten(state, ret_loc,
call(state, retvar, ret_addr, func_first, func_last));
+ /* Find the result */
+ if ((rtype->type & TYPE_MASK) != TYPE_VOID) {
+ struct triple * result;
+ result = flatten(state, first,
+ read_expr(state,
+ deref_index(state, fresult(state, func), 1)));
+
+ propogate_use(state, fcall, result);
+ }
+
+ /* Release the original fcall instruction */
+ release_triple(state, fcall);
+
/* Restore the active variables from the result variable */
for(i = 0, set = enclose; set ; set = set->next, i++) {
struct triple_set *use, *next;
struct triple *new;
+ struct basic_blocks bb;
if (!set->member || (set->member == fcall)) {
continue;
}
write_expr(state, set->member, new));
continue;
}
- /* If the original is a value update the dominated uses */
+ /*
+ * If the original is a value update the dominated uses.
+ */
+
+ /* Analyze the basic blocks so I can see who dominates whom */
+ bb.func = me;
+ bb.first = RHS(me, 0);
+ if (!triple_is_ret(state, bb.first->prev)) {
+ bb.func = 0;
+ }
+ analyze_basic_blocks(state, &bb);
+
#if DEBUG_EXPLICIT_CLOSURES
fprintf(state->errout, "Updating domindated uses: %p -> %p\n",
}
replace_use(state, set->member, new, use->member);
}
- }
- /* Find the result */
- if ((rtype->type & TYPE_MASK) != TYPE_VOID) {
- struct triple * result;
- result = flatten(state, first,
- read_expr(state,
- deref_index(state, fresult(state, func), 1)));
-
- propogate_use(state, fcall, result);
+ /* Release the basic blocks, the instructions will be
+ * different next time, and flatten/insert_triple does
+ * not update the block values so I can't cache the analysis.
+ */
+ free_basic_blocks(state, &bb);
}
- /* Release the original fcall instruction */
- release_triple(state, fcall);
-
/* Release the closure variable list */
free_closure_variables(state, &enclose);
}
static void print_control_flow(struct compile_state *state,
- struct basic_blocks *bb)
+ FILE *fp, struct basic_blocks *bb)
{
struct cf_block *cf;
int i;
- printf("\ncontrol flow\n");
+ fprintf(fp, "\ncontrol flow\n");
cf = xcmalloc(sizeof(*cf) * (bb->last_vertex + 1), "cf_block");
find_cf_blocks(cf, bb->first_block);
block = cf[i].block;
if (!block)
continue;
- printf("(%p) %d:", block, block->vertex);
+ fprintf(fp, "(%p) %d:", block, block->vertex);
for(edge = block->edges; edge; edge = edge->next) {
- printf(" %d", edge->member->vertex);
+ fprintf(fp, " %d", edge->member->vertex);
}
- printf("\n");
+ fprintf(fp, "\n");
}
xfree(cf);
}
static void print_blocks(struct compile_state *state, const char *func, FILE *fp)
{
+ static void print_dominators(struct compile_state *state, FILE *fp, struct basic_blocks *bb);
+ static void print_dominance_frontiers(struct compile_state *state, FILE *fp, struct basic_blocks *bb);
if (state->compiler->debug & DEBUG_BASIC_BLOCKS) {
fprintf(fp, "After %s\n", func);
romcc_print_blocks(state, fp);
- print_control_flow(state, &state->bb);
+ if (state->compiler->debug & DEBUG_FDOMINATORS) {
+ print_dominators(state, fp, &state->bb);
+ print_dominance_frontiers(state, fp, &state->bb);
+ }
+ print_control_flow(state, fp, &state->bb);
}
}
static int print_frontiers(
- struct compile_state *state, struct block *block, int vertex)
+ struct compile_state *state, FILE *fp, struct block *block, int vertex)
{
struct block_set *user, *edge;
}
vertex += 1;
- printf("%d:", block->vertex);
+ fprintf(fp, "%d:", block->vertex);
for(user = block->domfrontier; user; user = user->next) {
- printf(" %d", user->member->vertex);
+ fprintf(fp, " %d", user->member->vertex);
}
- printf("\n");
+ fprintf(fp, "\n");
for(edge = block->edges; edge; edge = edge->next) {
- vertex = print_frontiers(state, edge->member, vertex);
+ vertex = print_frontiers(state, fp, edge->member, vertex);
}
return vertex;
}
static void print_dominance_frontiers(struct compile_state *state,
- struct basic_blocks *bb)
+ FILE *fp, struct basic_blocks *bb)
{
- printf("\ndominance frontiers\n");
- print_frontiers(state, bb->first_block, 0);
+ fprintf(fp, "\ndominance frontiers\n");
+ print_frontiers(state, fp, bb->first_block, 0);
}
/* If debuging print the print what I have just found */
if (state->compiler->debug & DEBUG_FDOMINATORS) {
print_dominators(state, state->dbgout, bb);
- print_dominance_frontiers(state, bb);
- print_control_flow(state, bb);
+ print_dominance_frontiers(state, state->dbgout, bb);
+ print_control_flow(state, state->dbgout, bb);
}
}
}
static int print_pfrontiers(
- struct compile_state *state, struct block *block, int vertex)
+ struct compile_state *state, FILE *fp, struct block *block, int vertex)
{
struct block_set *user;
}
vertex += 1;
- printf("%d:", block->vertex);
+ fprintf(fp, "%d:", block->vertex);
for(user = block->ipdomfrontier; user; user = user->next) {
- printf(" %d", user->member->vertex);
+ fprintf(fp, " %d", user->member->vertex);
}
- printf("\n");
+ fprintf(fp, "\n");
for(user = block->use; user; user = user->next) {
- vertex = print_pfrontiers(state, user->member, vertex);
+ vertex = print_pfrontiers(state, fp, user->member, vertex);
}
return vertex;
}
static void print_ipdominance_frontiers(struct compile_state *state,
- struct basic_blocks *bb)
+ FILE *fp, struct basic_blocks *bb)
{
- printf("\nipdominance frontiers\n");
- print_pfrontiers(state, bb->last_block, 0);
+ fprintf(fp, "\nipdominance frontiers\n");
+ print_pfrontiers(state, fp, bb->last_block, 0);
}
/* If debuging print the print what I have just found */
if (state->compiler->debug & DEBUG_RDOMINATORS) {
print_ipdominators(state, state->dbgout, bb);
- print_ipdominance_frontiers(state, bb);
- print_control_flow(state, bb);
+ print_ipdominance_frontiers(state, state->dbgout, bb);
+ print_control_flow(state, state->dbgout, bb);
}
}
}
else {
struct triple *ins;
+ if (!bdom || !bsub) {
+ internal_error(state, dom, "huh?");
+ }
ins = sub;
while((ins != bsub->first) && (ins != dom)) {
ins = ins->prev;
struct reg_state *rstate = arg;
struct live_range *lr;
unsigned id;
+ FILE *fp = state->dbgout;
lr = rstate->lrd[ins->id].lr;
id = ins->id;
if (lr->defs) {
struct live_range_def *lrd;
- printf(" range:");
+ fprintf(fp, " range:");
lrd = lr->defs;
do {
- printf(" %-10p", lrd->def);
+ fprintf(fp, " %-10p", lrd->def);
lrd = lrd->next;
} while(lrd != lr->defs);
- printf("\n");
+ fprintf(fp, "\n");
}
if (live) {
struct triple_reg_set *entry;
- printf(" live:");
+ fprintf(fp, " live:");
for(entry = live; entry; entry = entry->next) {
- printf(" %-10p", entry->member);
+ fprintf(fp, " %-10p", entry->member);
}
- printf("\n");
+ fprintf(fp, "\n");
}
if (lr->edges) {
struct live_range_edge *entry;
- printf(" edges:");
+ fprintf(fp, " edges:");
for(entry = lr->edges; entry; entry = entry->next) {
struct live_range_def *lrd;
lrd = entry->node->defs;
do {
- printf(" %-10p", lrd->def);
+ fprintf(fp, " %-10p", lrd->def);
lrd = lrd->next;
} while(lrd != entry->node->defs);
- printf("|");
+ fprintf(fp, "|");
}
- printf("\n");
+ fprintf(fp, "\n");
}
if (triple_is_branch(state, ins)) {
- printf("\n");
+ fprintf(fp, "\n");
}
return;
}
if (state->compiler->debug & DEBUG_INTERFERENCE) {
FILE *fp = state->dbgout;
print_interference_blocks(state, rstate, fp, 0);
- print_control_flow(state, &state->bb);
+ print_control_flow(state, fp, &state->bb);
fflush(fp);
}
first = state->first;
/* Display the interference graph if desired */
if (state->compiler->debug & DEBUG_INTERFERENCE) {
print_interference_blocks(state, &rstate, state->dbgout, 1);
- printf("\nlive variables by instruction\n");
+ fprintf(state->dbgout, "\nlive variables by instruction\n");
walk_variable_lifetimes(
state, &state->bb, rstate.blocks,
print_interference_ins, &rstate);
!tdominates(state, ins, use_point)) {
if (is_const(ins)) {
internal_warning(state, ins,
- "non dominated rhs use point?");
+ "non dominated rhs use point %p?", use_point);
}
else {
internal_error(state, ins,
- "non dominated rhs use point?");
+ "non dominated rhs use point %p?", use_point);
}
}
}
projects / coreboot.git / commitdiff