#define DEBUG_CONSISTENCY 2
#define DEBUG_RANGE_CONFLICTS 0
#define DEBUG_COALESCING 0
+#define DEBUG_SDP_BLOCKS 0
+#define DEBUG_TRIPLE_COLOR 0
#warning "FIXME boundary cases with small types in larger registers"
#warning "FIXME give clear error messages about unused variables"
+#warning "FIXME properly handle multi dimensional arrays"
+#warning "FIXME fix scc_transform"
/* Control flow graph of a loop without goto.
*
/* Operations on general purpose registers.
*/
-#define OP_SMUL 0
-#define OP_UMUL 1
-#define OP_SDIV 2
-#define OP_UDIV 3
-#define OP_SMOD 4
-#define OP_UMOD 5
-#define OP_ADD 6
-#define OP_SUB 7
-#define OP_SL 8
-#define OP_USR 9
-#define OP_SSR 10
-#define OP_AND 11
-#define OP_XOR 12
-#define OP_OR 13
-#define OP_POS 14 /* Dummy positive operator don't use it */
-#define OP_NEG 15
-#define OP_INVERT 16
+#define OP_SDIVT 0
+#define OP_UDIVT 1
+#define OP_SMUL 2
+#define OP_UMUL 3
+#define OP_SDIV 4
+#define OP_UDIV 5
+#define OP_SMOD 6
+#define OP_UMOD 7
+#define OP_ADD 8
+#define OP_SUB 9
+#define OP_SL 10
+#define OP_USR 11
+#define OP_SSR 12
+#define OP_AND 13
+#define OP_XOR 14
+#define OP_OR 15
+#define OP_POS 16 /* Dummy positive operator don't use it */
+#define OP_NEG 17
+#define OP_INVERT 18
#define OP_EQ 20
#define OP_NOTEQ 21
#define OP_LOAD 32
#define OP_STORE 33
+/* For OP_STORE ->type holds the type
+ * RHS(0) holds the destination address
+ * RHS(1) holds the value to store.
+ */
#define OP_NOOP 34
#define OP_WRITE 60
/* OP_WRITE moves one pseudo register to another.
- * LHS(0) holds the destination pseudo register, which must be an OP_DECL.
- * RHS(0) holds the psuedo to move.
+ * RHS(0) holds the destination pseudo register, which must be an OP_DECL.
+ * RHS(1) holds the psuedo to move.
*/
#define OP_READ 61
.targ = (TARG), \
}
static const struct op_info table_ops[] = {
+[OP_SDIVT ] = OP( 2, 2, 0, 0, PURE | BLOCK , "sdivt"),
+[OP_UDIVT ] = OP( 2, 2, 0, 0, PURE | BLOCK , "udivt"),
[OP_SMUL ] = OP( 0, 2, 0, 0, PURE | DEF | BLOCK , "smul"),
[OP_UMUL ] = OP( 0, 2, 0, 0, PURE | DEF | BLOCK , "umul"),
[OP_SDIV ] = OP( 0, 2, 0, 0, PURE | DEF | BLOCK , "sdiv"),
[OP_LTRUE ] = OP( 0, 1, 0, 0, PURE | DEF | BLOCK , "ltrue"),
[OP_LOAD ] = OP( 0, 1, 0, 0, IMPURE | DEF | BLOCK, "load"),
-[OP_STORE ] = OP( 1, 1, 0, 0, IMPURE | BLOCK , "store"),
+[OP_STORE ] = OP( 0, 2, 0, 0, IMPURE | BLOCK , "store"),
[OP_NOOP ] = OP( 0, 0, 0, 0, PURE | BLOCK, "noop"),
[OP_BLOBCONST ] = OP( 0, 0, 0, 0, PURE, "blobconst"),
[OP_ADDRCONST ] = OP( 0, 0, 1, 0, PURE | DEF, "addrconst"),
-[OP_WRITE ] = OP( 1, 1, 0, 0, PURE | BLOCK, "write"),
+[OP_WRITE ] = OP( 0, 2, 0, 0, PURE | BLOCK, "write"),
[OP_READ ] = OP( 0, 1, 0, 0, PURE | DEF | BLOCK, "read"),
[OP_COPY ] = OP( 0, 1, 0, 0, PURE | DEF | BLOCK, "copy"),
[OP_PIECE ] = OP( 0, 0, 1, 0, PURE | DEF, "piece"),
#define MAX_REG_EQUIVS 16
#define REGISTER_BITS 16
#define MAX_VIRT_REGISTERS (1<<REGISTER_BITS)
-#define TEMPLATE_BITS 6
+#define TEMPLATE_BITS 7
#define MAX_TEMPLATES (1<<TEMPLATE_BITS)
-#define MAX_REGC 12
+#define MAX_REGC 14
#define REG_UNSET 0
#define REG_UNNEEDED 1
#define REG_VIRT0 (MAX_REGISTERS + 0)
static void loc(FILE *fp, struct compile_state *state, struct triple *triple)
{
int col;
- if (triple) {
+ if (triple && triple->occurance) {
struct occurance *spot;
spot = triple->occurance;
while(spot->parent) {
}
/* If I have a left hand side skip over it */
zlhs = TRIPLE_LHS(base->sizes);
- if (zlhs && (base->op != OP_WRITE) && (base->op != OP_STORE)) {
+ if (zlhs) {
base = LHS(base, zlhs - 1);
}
ptr->col);
}
fprintf(fp, "\n");
+#if 0
+ {
+ struct triple_set *user;
+ for(user = ptr->use; user; user = user->next) {
+ fprintf(fp, "use: %p\n", user->member);
+ }
+ }
+#endif
fflush(fp);
}
return is_branch;
}
+static int triple_is_cond_branch(struct compile_state *state, struct triple *ins)
+{
+ /* A conditional branch has the condition argument as a single
+ * RHS parameter.
+ */
+ return triple_is_branch(state, ins) &&
+ (TRIPLE_RHS(ins->sizes) == 1);
+}
+
+static int triple_is_uncond_branch(struct compile_state *state, struct triple *ins)
+{
+ /* A unconditional branch has no RHS parameters.
+ */
+ return triple_is_branch(state, ins) &&
+ (TRIPLE_RHS(ins->sizes) == 0);
+}
+
static int triple_is_def(struct compile_state *state, struct triple *ins)
{
/* This function is used to determine which triples need
return 0;
}
type = left->type & TYPE_MASK;
+ /* If the basic types match and it is a void type we are done */
+ if (type == TYPE_VOID) {
+ return 1;
+ }
/* if the basic types match and it is an arithmetic type we are done */
if (TYPE_ARITHMETIC(type)) {
return 1;
return ptr;
}
switch(ptr->op) {
- case OP_WRITE:
- case OP_STORE:
- RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
- LHS(ptr, 0) = flatten(state, first, LHS(ptr, 0));
- use_triple(LHS(ptr, 0), ptr);
- use_triple(RHS(ptr, 0), ptr);
- break;
case OP_COMMA:
RHS(ptr, 0) = flatten(state, first, RHS(ptr, 0));
ptr = RHS(ptr, 1);
return is_const(ins) && (ins->u.cval == 1);
}
+static long_t bit_count(ulong_t value)
+{
+ int count;
+ int i;
+ count = 0;
+ for(i = (sizeof(ulong_t)*8) -1; i >= 0; i--) {
+ ulong_t mask;
+ mask = 1;
+ mask <<= i;
+ if (value & mask) {
+ count++;
+ }
+ }
+ return count;
+
+}
static long_t bsr(ulong_t value)
{
int i;
ulong_t i;
op = ins->op;
- src = RHS(ins, 0);
- dst = LHS(ins, 0);
+ src = RHS(ins, 1);
+ dst = RHS(ins, 0);
get_occurance(ins->occurance);
next = alloc_triple(state, OP_VAL_VEC, ins->type, -1, -1,
ins->occurance);
RHS(ins, 1) = tmp;
}
if (is_const(RHS(ins, 0)) && is_const(RHS(ins, 1))) {
- if (!is_pointer(RHS(ins, 0))) {
+ if (RHS(ins, 0)->op == OP_INTCONST) {
ulong_t left, right;
left = read_const(state, ins, &RHS(ins, 0));
right = read_const(state, ins, &RHS(ins, 1));
mkconst(state, ins, left + right);
}
- else /* op == OP_ADDRCONST */ {
+ else if (RHS(ins, 0)->op == OP_ADDRCONST) {
struct triple *sdecl;
ulong_t left, right;
sdecl = MISC(RHS(ins, 0), 0);
right = RHS(ins, 1)->u.cval;
mkaddr_const(state, ins, sdecl, left + right);
}
+ else {
+ internal_warning(state, ins, "Optimize me!");
+ }
}
else if (is_const(RHS(ins, 0)) && !is_const(RHS(ins, 1))) {
struct triple *tmp;
static void simplify_sub(struct compile_state *state, struct triple *ins)
{
if (is_const(RHS(ins, 0)) && is_const(RHS(ins, 1))) {
- if (!is_pointer(RHS(ins, 0))) {
+ if (RHS(ins, 0)->op == OP_INTCONST) {
ulong_t left, right;
left = read_const(state, ins, &RHS(ins, 0));
right = read_const(state, ins, &RHS(ins, 1));
mkconst(state, ins, left - right);
}
- else /* op == OP_ADDRCONST */ {
+ else if (RHS(ins, 0)->op == OP_ADDRCONST) {
struct triple *sdecl;
ulong_t left, right;
sdecl = MISC(RHS(ins, 0), 0);
right = RHS(ins, 1)->u.cval;
mkaddr_const(state, ins, sdecl, left - right);
}
+ else {
+ internal_warning(state, ins, "Optimize me!");
+ }
}
}
}
}
+int phi_present(struct block *block)
+{
+ struct triple *ptr;
+ if (!block) {
+ return 0;
+ }
+ ptr = block->first;
+ do {
+ if (ptr->op == OP_PHI) {
+ return 1;
+ }
+ ptr = ptr->next;
+ } while(ptr != block->last);
+ return 0;
+}
+
+static void simplify_label(struct compile_state *state, struct triple *ins)
+{
+#warning "FIXME enable simplify_label"
+ struct triple *first, *last;
+ first = RHS(state->main_function, 0);
+ last = first->prev;
+ /* Ignore the first and last instructions */
+ if ((ins == first) || (ins == last)) {
+ return;
+ }
+ if (ins->use == 0) {
+ ins->op = OP_NOOP;
+ }
+ else if (ins->prev->op == OP_LABEL) {
+ struct block *block;
+ block = ins->prev->u.block;
+ /* In general it is not safe to merge one label that
+ * imediately follows another. The problem is that the empty
+ * looking block may have phi functions that depend on it.
+ */
+ if (!block ||
+ (!phi_present(block->left) &&
+ !phi_present(block->right)))
+ {
+ struct triple_set *user, *next;
+ ins->op = OP_NOOP;
+ for(user = ins->use; user; user = next) {
+ struct triple *use;
+ next = user->next;
+ use = user->member;
+ if (TARG(use, 0) == ins) {
+ TARG(use, 0) = ins->prev;
+ unuse_triple(ins, use);
+ use_triple(ins->prev, use);
+ }
+ }
+ if (ins->use) {
+ internal_error(state, ins, "noop use != 0");
+ }
+ }
+ }
+}
+
static void simplify_phi(struct compile_state *state, struct triple *ins)
{
struct triple **expr;
typedef void (*simplify_t)(struct compile_state *state, struct triple *ins);
static const simplify_t table_simplify[] = {
+#if 1
+#define simplify_sdivt simplify_noop
+#define simplify_udivt simplify_noop
+#endif
#if 0
#define simplify_smul simplify_noop
#define simplify_umul simplify_noop
#if 0
#define simplify_branch simplify_noop
#endif
+#if 1
+#define simplify_label simplify_noop
+#endif
#if 0
#define simplify_phi simplify_noop
#define simplify_bsr simplify_noop
#endif
+[OP_SDIVT ] = simplify_sdivt,
+[OP_UDIVT ] = simplify_udivt,
[OP_SMUL ] = simplify_smul,
[OP_UMUL ] = simplify_umul,
[OP_SDIV ] = simplify_sdiv,
[OP_LIST ] = simplify_noop,
[OP_BRANCH ] = simplify_branch,
-[OP_LABEL ] = simplify_noop,
+[OP_LABEL ] = simplify_label,
[OP_ADECL ] = simplify_noop,
[OP_SDECL ] = simplify_noop,
[OP_PHI ] = simplify_phi,
do {
simplify(state, ins);
ins = ins->next;
- } while(ins != first);
+ }while(ins != first);
}
/*
static void register_builtins(struct compile_state *state)
{
+ struct type *div_type, *ldiv_type;
+ struct type *udiv_type, *uldiv_type;
struct type *msr_type;
+ div_type = register_builtin_type(state, "__builtin_div_t",
+ partial_struct(state, "quot", &int_type,
+ partial_struct(state, "rem", &int_type, 0)));
+ ldiv_type = register_builtin_type(state, "__builtin_ldiv_t",
+ partial_struct(state, "quot", &long_type,
+ partial_struct(state, "rem", &long_type, 0)));
+ udiv_type = register_builtin_type(state, "__builtin_udiv_t",
+ partial_struct(state, "quot", &uint_type,
+ partial_struct(state, "rem", &uint_type, 0)));
+ uldiv_type = register_builtin_type(state, "__builtin_uldiv_t",
+ partial_struct(state, "quot", &ulong_type,
+ partial_struct(state, "rem", &ulong_type, 0)));
+
+ register_builtin_function(state, "__builtin_div", OP_SDIVT, div_type,
+ &int_type, &int_type);
+ register_builtin_function(state, "__builtin_ldiv", OP_SDIVT, ldiv_type,
+ &long_type, &long_type);
+ register_builtin_function(state, "__builtin_udiv", OP_UDIVT, udiv_type,
+ &uint_type, &uint_type);
+ register_builtin_function(state, "__builtin_uldiv", OP_UDIVT, uldiv_type,
+ &ulong_type, &ulong_type);
+
register_builtin_function(state, "__builtin_inb", OP_INB, &uchar_type,
&ushort_type);
register_builtin_function(state, "__builtin_inw", OP_INW, &ushort_type,
return type;
}
-#if 0
static struct type *struct_declarator(
struct compile_state *state, struct type *type, struct hash_entry **ident)
{
int tok;
-#warning "struct_declarator is complicated because of bitfields, kill them?"
tok = peek(state);
if (tok != TOK_COLON) {
type = declarator(state, type, ident, 1);
}
if ((tok == TOK_COLON) || (peek(state) == TOK_COLON)) {
+ struct triple *value;
eat(state, TOK_COLON);
- constant_expr(state);
+ value = constant_expr(state);
+#warning "FIXME implement bitfields to reduce register usage"
+ error(state, 0, "bitfields not yet implemented");
}
- FINISHME();
return type;
}
-#endif
static struct type *struct_or_union_specifier(
struct compile_state *state, unsigned int spec)
struct type *type;
struct hash_entry *fident;
done = 1;
- type = declarator(state, base_type, &fident, 1);
+ type = struct_declarator(state, base_type, &fident);
elements++;
if (peek(state) == TOK_COMMA) {
done = 0;
if ((ins->op == OP_BRANCH) && ins->use) {
internal_error(state, ins, "branch used?");
}
-#if 0
- {
- struct triple_set *user;
- for(user = ins->use; user; user = user->next) {
- printf("use: %p\n", user->member);
- }
- }
-#endif
if (triple_is_branch(state, ins)) {
printf("\n");
}
ptr = first;
do {
struct block *block;
- if (ptr->op == OP_LABEL) {
+ if (triple_stores_block(state, ptr)) {
block = ptr->u.block;
if (block && (block != last_block)) {
cb(state, block, arg);
}
last_block = block;
}
+ if (block && (block->last == ptr)) {
+ block = 0;
+ }
ptr = ptr->next;
} while(ptr != first);
}
static void print_block(
struct compile_state *state, struct block *block, void *arg)
{
+ struct block_set *user;
struct triple *ptr;
FILE *fp = arg;
- fprintf(fp, "\nblock: %p (%d), %p<-%p %p<-%p\n",
+ fprintf(fp, "\nblock: %p (%d) %p<-%p %p<-%p\n",
block,
block->vertex,
block->left,
fprintf(fp, "%p:\n", block->first);
}
for(ptr = block->first; ; ptr = ptr->next) {
- struct triple_set *user;
- int op = ptr->op;
-
- if (triple_stores_block(state, ptr)) {
- if (ptr->u.block != block) {
- internal_error(state, ptr,
- "Wrong block pointer: %p\n",
- ptr->u.block);
- }
- }
- if (op == OP_ADECL) {
- for(user = ptr->use; user; user = user->next) {
- if (!user->member->u.block) {
- internal_error(state, user->member,
- "Use %p not in a block?\n",
- user->member);
- }
- }
- }
display_triple(fp, ptr);
-
-#if 0
- for(user = ptr->use; user; user = user->next) {
- fprintf(fp, "use: %p\n", user->member);
- }
-#endif
-
- /* Sanity checks... */
- valid_ins(state, ptr);
- for(user = ptr->use; user; user = user->next) {
- struct triple *use;
- use = user->member;
- valid_ins(state, use);
- if (triple_stores_block(state, user->member) &&
- !user->member->u.block) {
- internal_error(state, user->member,
- "Use %p not in a block?",
- user->member);
- }
- }
-
if (ptr == block->last)
break;
}
- fprintf(fp,"\n");
+ fprintf(fp, "users %d: ", block->users);
+ for(user = block->use; user; user = user->next) {
+ fprintf(fp, "%p (%d) ",
+ user->member,
+ user->member->vertex);
+ }
+ fprintf(fp,"\n\n");
}
if (!block) {
release_triple(state, ins);
}
+ if (block && block->last == ins) {
+ block = 0;
+ }
ins = next;
} while(ins != first);
}
if (!state->last_block) {
internal_error(state, 0, "end not used?");
}
- /* Insert an extra unused edge from start to the end
- * This helps with reverse control flow calculations.
- */
- use_block(state->first_block, state->last_block);
/* If we are debugging print what I have just done */
if (state->debug & DEBUG_BASIC_BLOCKS) {
print_blocks(state, stdout);
return vertex;
}
-static int initialize_sdpblock(struct sdom_block *sd,
+static int initialize_sdpblock(
+ struct compile_state *state, struct sdom_block *sd,
struct block *parent, struct block *block, int vertex)
{
struct block_set *user;
sd[vertex].ancestor = 0;
sd[vertex].vertex = vertex;
for(user = block->use; user; user = user->next) {
- vertex = initialize_sdpblock(sd, block, user->member, vertex);
+ vertex = initialize_sdpblock(state, sd, block, user->member, vertex);
+ }
+ return vertex;
+}
+
+static int setup_sdpblocks(struct compile_state *state, struct sdom_block *sd)
+{
+ struct block *block;
+ int vertex;
+ /* Setup as many sdpblocks as possible without using fake edges */
+ vertex = initialize_sdpblock(state, sd, 0, state->last_block, 0);
+
+ /* Walk through the graph and find unconnected blocks. If
+ * we can, add a fake edge from the unconnected blocks to the
+ * end of the graph.
+ */
+ block = state->first_block->last->next->u.block;
+ for(; block && block != state->first_block; block = block->last->next->u.block) {
+ if (sd[block->vertex].block == block) {
+ continue;
+ }
+ if (block->left != 0) {
+ continue;
+ }
+
+#if DEBUG_SDP_BLOCKS
+ fprintf(stderr, "Adding %d\n", vertex +1);
+#endif
+
+ block->left = state->last_block;
+ use_block(block->left, block);
+ vertex = initialize_sdpblock(state, sd, state->last_block, block, vertex);
}
return vertex;
}
static void find_post_dominators(struct compile_state *state)
{
struct sdom_block *sd;
+ int vertex;
/* Step 1 initialize the basic block information */
sd = xcmalloc(sizeof(*sd) * (state->last_vertex + 1), "sdom_state");
- initialize_sdpblock(sd, 0, state->last_block, 0);
+ vertex = setup_sdpblocks(state, sd);
+ if (vertex != state->last_vertex) {
+ internal_error(state, 0, "missing %d blocks\n",
+ state->last_vertex - vertex);
+ }
/* Step 2 compute the semidominators */
/* Step 3 implicitly define the immediate dominator of each vertex */
/* LHS(A) */
if (ptr->op == OP_WRITE) {
struct triple *var, *val, *tval;
- var = LHS(ptr, 0);
- tval = val = RHS(ptr, 0);
+ var = RHS(ptr, 0);
+ tval = val = RHS(ptr, 1);
if ((val->op == OP_WRITE) || (val->op == OP_READ)) {
internal_error(state, val, "bad value in write");
}
use_triple(val, tval);
}
unuse_triple(val, ptr);
- RHS(ptr, 0) = tval;
+ RHS(ptr, 1) = tval;
use_triple(tval, ptr);
}
propogate_use(state, ptr, tval);
}
if (ptr->op == OP_WRITE) {
struct triple *var;
- var = LHS(ptr, 0);
+ var = RHS(ptr, 0);
/* Pop OP_WRITE ptr->right from the stack of variable uses */
- pop_triple(var, RHS(ptr, 0));
+ pop_triple(var, RHS(ptr, 1));
release_triple(state, ptr);
continue;
}
unuse_triple(phi, use->member);
}
+#warning "CHECK_ME does the OP_ADECL need to be placed somewhere that dominates all of the incoming phi edges?"
/* A variable to replace the phi function */
var = post_triple(state, phi, OP_ADECL, phi->type, 0,0);
/* A read of the single value that is set into the variable */
for(edge = 0, set = block->use; set; set = set->next, edge++) {
struct block *eblock;
struct triple *move;
- struct triple *val;
+ struct triple *val, *base;
eblock = set->member;
val = slot[edge];
slot[edge] = 0;
continue;
}
- move = post_triple(state,
- val, OP_WRITE, phi->type, var, val);
+ /* Make certain the write is placed in the edge block... */
+ base = eblock->first;
+ if (block_of_triple(state, val) == eblock) {
+ base = val;
+ }
+ move = post_triple(state, base, OP_WRITE, phi->type, var, val);
use_triple(val, move);
use_triple(var, move);
}
/* See if there are any writers of var */
used = 0;
for(use = var->use; use; use = use->next) {
- struct triple **expr;
- expr = triple_lhs(state, use->member, 0);
- for(; expr; expr = triple_lhs(state, use->member, expr)) {
- if (*expr == var) {
- used = 1;
- }
+ if ((use->member->op == OP_WRITE) &&
+ (RHS(use->member, 0) == var)) {
+ used = 1;
}
}
/* If var is not used free it */
struct triple_set *set;
struct reg_info info;
struct triple *lhs;
-#if 0
+#if DEBUG_TRIPLE_COLOR
fprintf(stderr, "find_lhs_post_color(%p, %d)\n",
ins, index);
#endif
info.regcm &= rinfo.regcm;
}
}
-#if 0
+#if DEBUG_TRIPLE_COLOR
fprintf(stderr, "find_lhs_post_color(%p, %d) -> ( %d, %x)\n",
ins, index, info.reg, info.regcm);
#endif
{
struct reg_info info, rinfo;
int zlhs, i;
-#if 0
+#if DEBUG_TRIPLE_COLOR
fprintf(stderr, "find_rhs_post_color(%p, %d)\n",
ins, index);
#endif
if (tinfo.reg >= MAX_REGISTERS) {
tinfo.reg = REG_UNSET;
}
- info.regcm &= linfo.reg;
+ info.regcm &= linfo.regcm;
info.regcm &= tinfo.regcm;
if (info.reg != REG_UNSET) {
internal_error(state, ins, "register conflict");
info.reg = tinfo.reg;
}
}
-#if 0
+#if DEBUG_TRIPLE_COLOR
fprintf(stderr, "find_rhs_post_color(%p, %d) -> ( %d, %x)\n",
ins, index, info.reg, info.regcm);
#endif
struct compile_state *state, struct triple *ins, int index)
{
struct reg_info pre, post, info;
-#if 0
+#if DEBUG_TRIPLE_COLOR
fprintf(stderr, "find_lhs_color(%p, %d)\n",
ins, index);
#endif
if (info.reg == REG_UNSET) {
info.reg = post.reg;
}
-#if 0
- fprintf(stderr, "find_lhs_color(%p, %d) -> ( %d, %x)\n",
- ins, index, info.reg, info.regcm);
+#if DEBUG_TRIPLE_COLOR
+ fprintf(stderr, "find_lhs_color(%p, %d) -> ( %d, %x) ... (%d, %x) (%d, %x)\n",
+ ins, index, info.reg, info.regcm,
+ pre.reg, pre.regcm, post.reg, post.regcm);
#endif
return info;
}
if (!triple_is_pure(state, ins) || triple_is_branch(state, ins)) {
awaken(state, dtriple, &ins, &work_list_tail);
}
+#if 1
+ /* Unconditionally keep the very last instruction */
+ else if (ins->next == first) {
+ awaken(state, dtriple, &ins, &work_list_tail);
+ }
+#endif
i++;
ins = ins->next;
} while(ins != first);
fprintf(fp, "%p:\n", block->first);
}
for(done = 0, ptr = block->first; !done; ptr = ptr->next) {
- struct triple_set *user;
struct live_range *lr;
unsigned id;
int op;
done = (ptr == block->last);
lr = rstate->lrd[ptr->id].lr;
- if (triple_stores_block(state, ptr)) {
- if (ptr->u.block != block) {
- internal_error(state, ptr,
- "Wrong block pointer: %p",
- ptr->u.block);
- }
- }
- if (op == OP_ADECL) {
- for(user = ptr->use; user; user = user->next) {
- if (!user->member->u.block) {
- internal_error(state, user->member,
- "Use %p not in a block?",
- user->member);
- }
-
- }
- }
id = ptr->id;
ptr->id = rstate->lrd[id].orig_id;
SET_REG(ptr->id, lr->color);
internal_error(state, ptr, "Invalid triple id: %d",
ptr->id);
}
- for(user = ptr->use; user; user = user->next) {
- struct triple *use;
- struct live_range *ulr;
- use = user->member;
- valid_ins(state, use);
- if ((use->id < 0) || (use->id > rstate->defs)) {
- internal_error(state, use, "Invalid triple id: %d",
- use->id);
- }
- ulr = rstate->lrd[user->member->id].lr;
- if (triple_stores_block(state, user->member) &&
- !user->member->u.block) {
- internal_error(state, user->member,
- "Use %p not in a block?",
- user->member);
- }
- }
}
if (rb->out) {
struct triple_reg_set *out_set;
#if DEBUG_COALESCING > 1
fprintf(stderr, "mandatory coalesce: %p %d %d\n",
ins, zlhs, zrhs);
-
#endif
for(i = 0; i < zlhs; i++) {
struct reg_info linfo;
* least dominated one first.
*/
if (is_constrained) {
+#if DEBUG_RANGE_CONFLICTS
+ fprintf(stderr, "canidate: %p %-8s regcm: %x %x\n",
+ lrd->def, tops(lrd->def->op), regcm, info.regcm);
+#endif
if (!constrained ||
tdominates(state, lrd->def, constrained))
{
constrained = find_constrained_def(state, range, constrained);
}
#if DEBUG_RANGE_CONFLICTS
- fprintf(stderr, "constrained: %s %p\n",
- tops(constrained->op), constrained);
+ fprintf(stderr, "constrained: %p %-8s\n",
+ constrained, tops(constrained->op));
#endif
if (constrained) {
ids_from_rstate(state, rstate);
return split;
}
-
#if DEBUG_COLOR_GRAPH > 1
#define cgdebug_printf(...) fprintf(stdout, __VA_ARGS__)
#define cgdebug_flush() fflush(stdout)
}
#endif
-#warning "FIXME detect conflicts caused by the source and destination being the same register"
-
/* If a color is already assigned see if it will work */
if (range->color != REG_UNSET) {
struct live_range_def *lrd;
entry = lrd->def->use;
for(;(range->color == REG_UNSET) && entry; entry = entry->next) {
struct live_range_def *insd;
+ unsigned regcm;
insd = &rstate->lrd[entry->member->id];
if (insd->lr->defs == 0) {
continue;
!interfere(rstate, range, insd->lr)) {
phi = insd;
}
- if ((insd->lr->color == REG_UNSET) ||
- ((insd->lr->classes & range->classes) == 0) ||
+ if (insd->lr->color == REG_UNSET) {
+ continue;
+ }
+ regcm = insd->lr->classes;
+ if (((regcm & range->classes) == 0) ||
(used[insd->lr->color])) {
continue;
}
expr = triple_rhs(state, phi->def, 0);
for(; expr; expr = triple_rhs(state, phi->def, expr)) {
struct live_range *lr;
+ unsigned regcm;
if (!*expr) {
continue;
}
lr = rstate->lrd[(*expr)->id].lr;
- if ((lr->color == REG_UNSET) ||
- ((lr->classes & range->classes) == 0) ||
+ if (lr->color == REG_UNSET) {
+ continue;
+ }
+ regcm = lr->classes;
+ if (((regcm & range->classes) == 0) ||
(used[lr->color])) {
continue;
}
expr = triple_rhs(state, lrd->def, 0);
for(; expr; expr = triple_rhs(state, lrd->def, expr)) {
struct live_range *lr;
+ unsigned regcm;
if (!*expr) {
continue;
}
lr = rstate->lrd[(*expr)->id].lr;
- if ((lr->color == -1) ||
- ((lr->classes & range->classes) == 0) ||
+ if (lr->color == REG_UNSET) {
+ continue;
+ }
+ regcm = lr->classes;
+ if (((regcm & range->classes) == 0) ||
(used[lr->color])) {
continue;
}
internal_error(state, range->defs->def, "too few registers");
#endif
}
- range->classes = arch_reg_regcm(state, range->color);
- if (range->color == -1) {
+ range->classes &= arch_reg_regcm(state, range->color);
+ if ((range->color == REG_UNSET) || (range->classes == 0)) {
internal_error(state, range->defs->def, "select_free_color did not?");
}
return 1;
first = RHS(state->main_function, 0);
ins = first;
do {
+ valid_ins(state, ins);
if (triple_stores_block(state, ins)) {
if (!ins->u.block) {
internal_error(state, ins,
{
struct triple *ins;
struct block *block;
+ int blocks;
block = state->first_block;
if (!block) {
return;
}
+ blocks = 0;
do {
+ int users;
+ struct block_set *user;
+ blocks++;
for(ins = block->first; ins != block->last->next; ins = ins->next) {
- if (!triple_stores_block(state, ins)) {
+ if (triple_stores_block(state, ins) && (ins->u.block != block)) {
+ internal_error(state, ins, "inconsitent block specified");
+ }
+ valid_ins(state, ins);
+ }
+ users = 0;
+ for(user = block->use; user; user = user->next) {
+ users++;
+ if ((block == state->last_block) &&
+ (user->member == state->first_block)) {
continue;
}
- if (ins->u.block != block) {
- internal_error(state, ins, "inconsitent block specified");
+ if ((user->member->left != block) &&
+ (user->member->right != block)) {
+ internal_error(state, user->member->first,
+ "user does not use block");
+ }
+ }
+ if (triple_is_branch(state, block->last) &&
+ (block->right != block_of_triple(state, TARG(block->last, 0))))
+ {
+ internal_error(state, block->last, "block->right != TARG(0)");
+ }
+ if (!triple_is_uncond_branch(state, block->last) &&
+ (block != state->last_block) &&
+ (block->left != block_of_triple(state, block->last->next)))
+ {
+ internal_error(state, block->last, "block->left != block->last->next");
+ }
+ if (block->left) {
+ for(user = block->left->use; user; user = user->next) {
+ if (user->member == block) {
+ break;
+ }
+ }
+ if (!user || user->member != block) {
+ internal_error(state, block->first,
+ "block does not use left");
+ }
+ }
+ if (block->right) {
+ for(user = block->right->use; user; user = user->next) {
+ if (user->member == block) {
+ break;
+ }
+ }
+ if (!user || user->member != block) {
+ internal_error(state, block->first,
+ "block does not use right");
}
}
+ if (block->users != users) {
+ internal_error(state, block->first,
+ "computed users %d != stored users %d\n",
+ users, block->users);
+ }
if (!triple_stores_block(state, block->last->next)) {
internal_error(state, block->last->next,
"cannot find next block");
"bad next block");
}
} while(block != state->first_block);
+ if (blocks != state->last_vertex) {
+ internal_error(state, 0, "computed blocks != stored blocks %d\n",
+ blocks, state->last_vertex);
+ }
}
static void verify_domination(struct compile_state *state)
struct triple *ptr;
int lhs, i;
lhs = TRIPLE_LHS(ins->sizes);
- if ((ins->op == OP_WRITE) || (ins->op == OP_STORE)) {
- lhs = 0;
- }
for(ptr = ins->next, i = 0; i < lhs; i++, ptr = ptr->next) {
if (ptr != LHS(ins, i)) {
internal_error(state, ins, "malformed lhs on %s",
analyze_idominators(state);
analyze_ipdominators(state);
- /* Transform the code to ssa form */
+ /* Transform the code to ssa form. */
+ /*
+ * The transformation to ssa form puts a phi function
+ * on each of edge of a dominance frontier where that
+ * phi function might be needed. At -O2 if we don't
+ * eleminate the excess phi functions we can get an
+ * exponential code size growth. So I kill the extra
+ * phi functions early and I kill them often.
+ */
transform_to_ssa_form(state);
+ eliminate_inefectual_code(state);
+
verify_consistency(state);
if (state->debug & DEBUG_CODE_ELIMINATION) {
fprintf(stdout, "After transform_to_ssa_form\n");
/* Do strength reduction and simple constant optimizations */
if (state->optimize >= 1) {
simplify_all(state);
+ transform_from_ssa_form(state);
+ free_basic_blocks(state);
+ setup_basic_blocks(state);
+ analyze_idominators(state);
+ analyze_ipdominators(state);
+ transform_to_ssa_form(state);
+ eliminate_inefectual_code(state);
+ }
+ if (state->debug & DEBUG_CODE_ELIMINATION) {
+ fprintf(stdout, "After simplify_all\n");
+ print_blocks(state, stdout);
}
verify_consistency(state);
/* Propogate constants throughout the code */
if (state->optimize >= 2) {
-#warning "FIXME fix scc_transform"
scc_transform(state);
transform_from_ssa_form(state);
free_basic_blocks(state);
analyze_idominators(state);
analyze_ipdominators(state);
transform_to_ssa_form(state);
+ eliminate_inefectual_code(state);
}
verify_consistency(state);
#warning "WISHLIST implement single use constants (least possible register pressure)"
#define CPU_DEFAULT CPU_I386
/* The x86 register classes */
-#define REGC_FLAGS 0
-#define REGC_GPR8 1
-#define REGC_GPR16 2
-#define REGC_GPR32 3
-#define REGC_GPR64 4
-#define REGC_MMX 5
-#define REGC_XMM 6
-#define REGC_GPR32_8 7
-#define REGC_GPR16_8 8
-#define REGC_IMM32 9
-#define REGC_IMM16 10
-#define REGC_IMM8 11
+#define REGC_FLAGS 0
+#define REGC_GPR8 1
+#define REGC_GPR16 2
+#define REGC_GPR32 3
+#define REGC_DIVIDEND64 4
+#define REGC_DIVIDEND32 5
+#define REGC_MMX 6
+#define REGC_XMM 7
+#define REGC_GPR32_8 8
+#define REGC_GPR16_8 9
+#define REGC_GPR8_LO 10
+#define REGC_IMM32 11
+#define REGC_IMM16 12
+#define REGC_IMM8 13
#define LAST_REGC REGC_IMM8
#if LAST_REGC >= MAX_REGC
#error "MAX_REGC is to low"
#endif
/* Register class masks */
-#define REGCM_FLAGS (1 << REGC_FLAGS)
-#define REGCM_GPR8 (1 << REGC_GPR8)
-#define REGCM_GPR16 (1 << REGC_GPR16)
-#define REGCM_GPR32 (1 << REGC_GPR32)
-#define REGCM_GPR64 (1 << REGC_GPR64)
-#define REGCM_MMX (1 << REGC_MMX)
-#define REGCM_XMM (1 << REGC_XMM)
-#define REGCM_GPR32_8 (1 << REGC_GPR32_8)
-#define REGCM_GPR16_8 (1 << REGC_GPR16_8)
-#define REGCM_IMM32 (1 << REGC_IMM32)
-#define REGCM_IMM16 (1 << REGC_IMM16)
-#define REGCM_IMM8 (1 << REGC_IMM8)
-#define REGCM_ALL ((1 << (LAST_REGC + 1)) - 1)
+#define REGCM_FLAGS (1 << REGC_FLAGS)
+#define REGCM_GPR8 (1 << REGC_GPR8)
+#define REGCM_GPR16 (1 << REGC_GPR16)
+#define REGCM_GPR32 (1 << REGC_GPR32)
+#define REGCM_DIVIDEND64 (1 << REGC_DIVIDEND64)
+#define REGCM_DIVIDEND32 (1 << REGC_DIVIDEND32)
+#define REGCM_MMX (1 << REGC_MMX)
+#define REGCM_XMM (1 << REGC_XMM)
+#define REGCM_GPR32_8 (1 << REGC_GPR32_8)
+#define REGCM_GPR16_8 (1 << REGC_GPR16_8)
+#define REGCM_GPR8_LO (1 << REGC_GPR8_LO)
+#define REGCM_IMM32 (1 << REGC_IMM32)
+#define REGCM_IMM16 (1 << REGC_IMM16)
+#define REGCM_IMM8 (1 << REGC_IMM8)
+#define REGCM_ALL ((1 << (LAST_REGC + 1)) - 1)
/* The x86 registers */
#define REG_EFLAGS 2
#define REG_BH 8
#define REG_CH 9
#define REG_DH 10
+#define REGC_GPR8_LO_FIRST REG_AL
+#define REGC_GPR8_LO_LAST REG_DL
#define REGC_GPR8_FIRST REG_AL
-#if X86_4_8BIT_GPRS
-#define REGC_GPR8_LAST REG_DL
-#else
#define REGC_GPR8_LAST REG_DH
-#endif
#define REG_AX 11
#define REG_BX 12
#define REG_CX 13
#define REGC_GPR32_FIRST REG_EAX
#define REGC_GPR32_LAST REG_ESP
#define REG_EDXEAX 27
-#define REGC_GPR64_FIRST REG_EDXEAX
-#define REGC_GPR64_LAST REG_EDXEAX
-#define REG_MMX0 28
-#define REG_MMX1 29
-#define REG_MMX2 30
-#define REG_MMX3 31
-#define REG_MMX4 32
-#define REG_MMX5 33
-#define REG_MMX6 34
-#define REG_MMX7 35
+#define REGC_DIVIDEND64_FIRST REG_EDXEAX
+#define REGC_DIVIDEND64_LAST REG_EDXEAX
+#define REG_DXAX 28
+#define REGC_DIVIDEND32_FIRST REG_DXAX
+#define REGC_DIVIDEND32_LAST REG_DXAX
+#define REG_MMX0 29
+#define REG_MMX1 30
+#define REG_MMX2 31
+#define REG_MMX3 32
+#define REG_MMX4 33
+#define REG_MMX5 34
+#define REG_MMX6 35
+#define REG_MMX7 36
#define REGC_MMX_FIRST REG_MMX0
#define REGC_MMX_LAST REG_MMX7
-#define REG_XMM0 36
-#define REG_XMM1 37
-#define REG_XMM2 38
-#define REG_XMM3 39
-#define REG_XMM4 40
-#define REG_XMM5 41
-#define REG_XMM6 42
-#define REG_XMM7 43
+#define REG_XMM0 37
+#define REG_XMM1 38
+#define REG_XMM2 39
+#define REG_XMM3 40
+#define REG_XMM4 41
+#define REG_XMM5 42
+#define REG_XMM6 43
+#define REG_XMM7 44
#define REGC_XMM_FIRST REG_XMM0
#define REGC_XMM_LAST REG_XMM7
#warning "WISHLIST figure out how to use pinsrw and pextrw to better use extended regs"
static unsigned regc_size[LAST_REGC +1] = {
- [REGC_FLAGS] = REGC_FLAGS_LAST - REGC_FLAGS_FIRST + 1,
- [REGC_GPR8] = REGC_GPR8_LAST - REGC_GPR8_FIRST + 1,
- [REGC_GPR16] = REGC_GPR16_LAST - REGC_GPR16_FIRST + 1,
- [REGC_GPR32] = REGC_GPR32_LAST - REGC_GPR32_FIRST + 1,
- [REGC_GPR64] = REGC_GPR64_LAST - REGC_GPR64_FIRST + 1,
- [REGC_MMX] = REGC_MMX_LAST - REGC_MMX_FIRST + 1,
- [REGC_XMM] = REGC_XMM_LAST - REGC_XMM_FIRST + 1,
- [REGC_GPR32_8] = REGC_GPR32_8_LAST - REGC_GPR32_8_FIRST + 1,
- [REGC_GPR16_8] = REGC_GPR16_8_LAST - REGC_GPR16_8_FIRST + 1,
- [REGC_IMM32] = 0,
- [REGC_IMM16] = 0,
- [REGC_IMM8] = 0,
+ [REGC_FLAGS] = REGC_FLAGS_LAST - REGC_FLAGS_FIRST + 1,
+ [REGC_GPR8] = REGC_GPR8_LAST - REGC_GPR8_FIRST + 1,
+ [REGC_GPR16] = REGC_GPR16_LAST - REGC_GPR16_FIRST + 1,
+ [REGC_GPR32] = REGC_GPR32_LAST - REGC_GPR32_FIRST + 1,
+ [REGC_DIVIDEND64] = REGC_DIVIDEND64_LAST - REGC_DIVIDEND64_FIRST + 1,
+ [REGC_DIVIDEND32] = REGC_DIVIDEND32_LAST - REGC_DIVIDEND32_FIRST + 1,
+ [REGC_MMX] = REGC_MMX_LAST - REGC_MMX_FIRST + 1,
+ [REGC_XMM] = REGC_XMM_LAST - REGC_XMM_FIRST + 1,
+ [REGC_GPR32_8] = REGC_GPR32_8_LAST - REGC_GPR32_8_FIRST + 1,
+ [REGC_GPR16_8] = REGC_GPR16_8_LAST - REGC_GPR16_8_FIRST + 1,
+ [REGC_GPR8_LO] = REGC_GPR8_LO_LAST - REGC_GPR8_LO_FIRST + 1,
+ [REGC_IMM32] = 0,
+ [REGC_IMM16] = 0,
+ [REGC_IMM8] = 0,
};
static const struct {
int first, last;
} regcm_bound[LAST_REGC + 1] = {
- [REGC_FLAGS] = { REGC_FLAGS_FIRST, REGC_FLAGS_LAST },
- [REGC_GPR8] = { REGC_GPR8_FIRST, REGC_GPR8_LAST },
- [REGC_GPR16] = { REGC_GPR16_FIRST, REGC_GPR16_LAST },
- [REGC_GPR32] = { REGC_GPR32_FIRST, REGC_GPR32_LAST },
- [REGC_GPR64] = { REGC_GPR64_FIRST, REGC_GPR64_LAST },
- [REGC_MMX] = { REGC_MMX_FIRST, REGC_MMX_LAST },
- [REGC_XMM] = { REGC_XMM_FIRST, REGC_XMM_LAST },
- [REGC_GPR32_8] = { REGC_GPR32_8_FIRST, REGC_GPR32_8_LAST },
- [REGC_GPR16_8] = { REGC_GPR16_8_FIRST, REGC_GPR16_8_LAST },
- [REGC_IMM32] = { REGC_IMM32_FIRST, REGC_IMM32_LAST },
- [REGC_IMM16] = { REGC_IMM16_FIRST, REGC_IMM16_LAST },
- [REGC_IMM8] = { REGC_IMM8_FIRST, REGC_IMM8_LAST },
+ [REGC_FLAGS] = { REGC_FLAGS_FIRST, REGC_FLAGS_LAST },
+ [REGC_GPR8] = { REGC_GPR8_FIRST, REGC_GPR8_LAST },
+ [REGC_GPR16] = { REGC_GPR16_FIRST, REGC_GPR16_LAST },
+ [REGC_GPR32] = { REGC_GPR32_FIRST, REGC_GPR32_LAST },
+ [REGC_DIVIDEND64] = { REGC_DIVIDEND64_FIRST, REGC_DIVIDEND64_LAST },
+ [REGC_DIVIDEND32] = { REGC_DIVIDEND32_FIRST, REGC_DIVIDEND32_LAST },
+ [REGC_MMX] = { REGC_MMX_FIRST, REGC_MMX_LAST },
+ [REGC_XMM] = { REGC_XMM_FIRST, REGC_XMM_LAST },
+ [REGC_GPR32_8] = { REGC_GPR32_8_FIRST, REGC_GPR32_8_LAST },
+ [REGC_GPR16_8] = { REGC_GPR16_8_FIRST, REGC_GPR16_8_LAST },
+ [REGC_GPR8_LO] = { REGC_GPR8_LO_FIRST, REGC_GPR8_LO_LAST },
+ [REGC_IMM32] = { REGC_IMM32_FIRST, REGC_IMM32_LAST },
+ [REGC_IMM16] = { REGC_IMM16_FIRST, REGC_IMM16_LAST },
+ [REGC_IMM8] = { REGC_IMM8_FIRST, REGC_IMM8_LAST },
};
static int arch_encode_cpu(const char *cpu)
static int arch_regcm_intersect(unsigned regcm1, unsigned regcm2)
{
/* See if two register classes may have overlapping registers */
- unsigned gpr_mask = REGCM_GPR8 | REGCM_GPR16_8 | REGCM_GPR16 |
- REGCM_GPR32_8 | REGCM_GPR32 | REGCM_GPR64;
+ unsigned gpr_mask = REGCM_GPR8 | REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 |
+ REGCM_GPR32_8 | REGCM_GPR32 |
+ REGCM_DIVIDEND32 | REGCM_DIVIDEND64;
/* Special case for the immediates */
if ((regcm1 & (REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8)) &&
#endif
*equiv++ = REG_AX;
*equiv++ = REG_EAX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_AH:
#endif
*equiv++ = REG_AX;
*equiv++ = REG_EAX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_BL:
#endif
*equiv++ = REG_DX;
*equiv++ = REG_EDX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_DH:
#endif
*equiv++ = REG_DX;
*equiv++ = REG_EDX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_AX:
*equiv++ = REG_AL;
*equiv++ = REG_AH;
*equiv++ = REG_EAX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_BX:
*equiv++ = REG_DL;
*equiv++ = REG_DH;
*equiv++ = REG_EDX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_SI:
*equiv++ = REG_AL;
*equiv++ = REG_AH;
*equiv++ = REG_AX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_EBX:
*equiv++ = REG_DL;
*equiv++ = REG_DH;
*equiv++ = REG_DX;
+ *equiv++ = REG_DXAX;
*equiv++ = REG_EDXEAX;
break;
case REG_ESI:
case REG_ESP:
*equiv++ = REG_SP;
break;
+ case REG_DXAX:
+ *equiv++ = REG_AL;
+ *equiv++ = REG_AH;
+ *equiv++ = REG_DL;
+ *equiv++ = REG_DH;
+ *equiv++ = REG_AX;
+ *equiv++ = REG_DX;
+ *equiv++ = REG_EAX;
+ *equiv++ = REG_EDX;
+ *equiv++ = REG_EDXEAX;
+ break;
case REG_EDXEAX:
*equiv++ = REG_AL;
*equiv++ = REG_AH;
*equiv++ = REG_DX;
*equiv++ = REG_EAX;
*equiv++ = REG_EDX;
+ *equiv++ = REG_DXAX;
break;
}
*equiv++ = REG_UNSET;
static unsigned arch_avail_mask(struct compile_state *state)
{
unsigned avail_mask;
- avail_mask = REGCM_GPR8 | REGCM_GPR16_8 | REGCM_GPR16 |
- REGCM_GPR32 | REGCM_GPR32_8 | REGCM_GPR64 |
+ /* REGCM_GPR8 is not available */
+ avail_mask = REGCM_GPR8_LO | REGCM_GPR16_8 | REGCM_GPR16 |
+ REGCM_GPR32 | REGCM_GPR32_8 |
+ REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 | REGCM_FLAGS;
switch(state->cpu) {
case CPU_P3:
avail_mask |= REGCM_MMX | REGCM_XMM;
break;
}
-#if 0
- /* Don't enable 8 bit values until I can force both operands
- * to be 8bits simultaneously.
- */
- avail_mask &= ~(REGCM_GPR8 | REGCM_GPR16_8 | REGCM_GPR16);
-#endif
return avail_mask;
}
unsigned mask, result;
int class, class2;
result = regcm;
- result &= arch_avail_mask(state);
for(class = 0, mask = 1; mask; mask <<= 1, class++) {
if ((result & mask) == 0) {
}
}
}
+ result &= arch_avail_mask(state);
return result;
}
unsigned int mask;
unsigned int reg;
} constraints[] = {
- { 'r', REGCM_GPR32, REG_UNSET },
- { 'g', REGCM_GPR32, REG_UNSET },
- { 'p', REGCM_GPR32, REG_UNSET },
- { 'q', REGCM_GPR8, REG_UNSET },
+ { 'r', REGCM_GPR32, REG_UNSET },
+ { 'g', REGCM_GPR32, REG_UNSET },
+ { 'p', REGCM_GPR32, REG_UNSET },
+ { 'q', REGCM_GPR8_LO, REG_UNSET },
{ 'Q', REGCM_GPR32_8, REG_UNSET },
- { 'x', REGCM_XMM, REG_UNSET },
- { 'y', REGCM_MMX, REG_UNSET },
- { 'a', REGCM_GPR32, REG_EAX },
- { 'b', REGCM_GPR32, REG_EBX },
- { 'c', REGCM_GPR32, REG_ECX },
- { 'd', REGCM_GPR32, REG_EDX },
- { 'D', REGCM_GPR32, REG_EDI },
- { 'S', REGCM_GPR32, REG_ESI },
+ { 'x', REGCM_XMM, REG_UNSET },
+ { 'y', REGCM_MMX, REG_UNSET },
+ { 'a', REGCM_GPR32, REG_EAX },
+ { 'b', REGCM_GPR32, REG_EBX },
+ { 'c', REGCM_GPR32, REG_ECX },
+ { 'd', REGCM_GPR32, REG_EDX },
+ { 'D', REGCM_GPR32, REG_EDI },
+ { 'S', REGCM_GPR32, REG_ESI },
{ '\0', 0, REG_UNSET },
};
unsigned int regcm;
for(i = REGC_GPR8_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR8_LAST); i++) {
reg = do_select_reg(state, used, i, classes);
}
- for(i = REGC_GPR64_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR64_LAST); i++) {
+ for(i = REGC_GPR8_LO_FIRST; (reg == REG_UNSET) && (i <= REGC_GPR8_LO_LAST); i++) {
+ reg = do_select_reg(state, used, i, classes);
+ }
+ for(i = REGC_DIVIDEND32_FIRST; (reg == REG_UNSET) && (i <= REGC_DIVIDEND32_LAST); i++) {
+ reg = do_select_reg(state, used, i, classes);
+ }
+ for(i = REGC_DIVIDEND64_FIRST; (reg == REG_UNSET) && (i <= REGC_DIVIDEND64_LAST); i++) {
reg = do_select_reg(state, used, i, classes);
}
for(i = REGC_FLAGS_FIRST; (reg == REG_UNSET) && (i <= REGC_FLAGS_LAST); i++) {
break;
case TYPE_CHAR:
case TYPE_UCHAR:
- mask = REGCM_GPR8 |
+ mask = REGCM_GPR8 | REGCM_GPR8_LO |
REGCM_GPR16 | REGCM_GPR16_8 |
REGCM_GPR32 | REGCM_GPR32_8 |
- REGCM_GPR64 |
+ REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
REGCM_MMX | REGCM_XMM |
REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8;
break;
case TYPE_USHORT:
mask = REGCM_GPR16 | REGCM_GPR16_8 |
REGCM_GPR32 | REGCM_GPR32_8 |
- REGCM_GPR64 |
+ REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
REGCM_MMX | REGCM_XMM |
REGCM_IMM32 | REGCM_IMM16;
break;
case TYPE_ULONG:
case TYPE_POINTER:
mask = REGCM_GPR32 | REGCM_GPR32_8 |
- REGCM_GPR64 | REGCM_MMX | REGCM_XMM |
+ REGCM_DIVIDEND32 | REGCM_DIVIDEND64 |
+ REGCM_MMX | REGCM_XMM |
REGCM_IMM32;
break;
default:
return 1;
}
-#define TEMPLATE_NOP 0
-#define TEMPLATE_INTCONST8 1
-#define TEMPLATE_INTCONST32 2
-#define TEMPLATE_COPY8_REG 3
-#define TEMPLATE_COPY16_REG 4
-#define TEMPLATE_COPY32_REG 5
-#define TEMPLATE_COPY_IMM8 6
-#define TEMPLATE_COPY_IMM16 7
-#define TEMPLATE_COPY_IMM32 8
-#define TEMPLATE_PHI8 9
-#define TEMPLATE_PHI16 10
-#define TEMPLATE_PHI32 11
-#define TEMPLATE_STORE8 12
-#define TEMPLATE_STORE16 13
-#define TEMPLATE_STORE32 14
-#define TEMPLATE_LOAD8 15
-#define TEMPLATE_LOAD16 16
-#define TEMPLATE_LOAD32 17
-#define TEMPLATE_BINARY_REG 18
-#define TEMPLATE_BINARY_IMM 19
-#define TEMPLATE_SL_CL 20
-#define TEMPLATE_SL_IMM 21
-#define TEMPLATE_UNARY 22
-#define TEMPLATE_CMP_REG 23
-#define TEMPLATE_CMP_IMM 24
-#define TEMPLATE_TEST 25
-#define TEMPLATE_SET 26
-#define TEMPLATE_JMP 27
-#define TEMPLATE_INB_DX 28
-#define TEMPLATE_INB_IMM 29
-#define TEMPLATE_INW_DX 30
-#define TEMPLATE_INW_IMM 31
-#define TEMPLATE_INL_DX 32
-#define TEMPLATE_INL_IMM 33
-#define TEMPLATE_OUTB_DX 34
-#define TEMPLATE_OUTB_IMM 35
-#define TEMPLATE_OUTW_DX 36
-#define TEMPLATE_OUTW_IMM 37
-#define TEMPLATE_OUTL_DX 38
-#define TEMPLATE_OUTL_IMM 39
-#define TEMPLATE_BSF 40
-#define TEMPLATE_RDMSR 41
-#define TEMPLATE_WRMSR 42
-#define TEMPLATE_UMUL 43
-#define TEMPLATE_DIV 44
-#define TEMPLATE_MOD 45
-#define LAST_TEMPLATE TEMPLATE_MOD
+#define TEMPLATE_NOP 0
+#define TEMPLATE_INTCONST8 1
+#define TEMPLATE_INTCONST32 2
+#define TEMPLATE_COPY8_REG 3
+#define TEMPLATE_COPY16_REG 4
+#define TEMPLATE_COPY32_REG 5
+#define TEMPLATE_COPY_IMM8 6
+#define TEMPLATE_COPY_IMM16 7
+#define TEMPLATE_COPY_IMM32 8
+#define TEMPLATE_PHI8 9
+#define TEMPLATE_PHI16 10
+#define TEMPLATE_PHI32 11
+#define TEMPLATE_STORE8 12
+#define TEMPLATE_STORE16 13
+#define TEMPLATE_STORE32 14
+#define TEMPLATE_LOAD8 15
+#define TEMPLATE_LOAD16 16
+#define TEMPLATE_LOAD32 17
+#define TEMPLATE_BINARY8_REG 18
+#define TEMPLATE_BINARY16_REG 19
+#define TEMPLATE_BINARY32_REG 20
+#define TEMPLATE_BINARY8_IMM 21
+#define TEMPLATE_BINARY16_IMM 22
+#define TEMPLATE_BINARY32_IMM 23
+#define TEMPLATE_SL8_CL 24
+#define TEMPLATE_SL16_CL 25
+#define TEMPLATE_SL32_CL 26
+#define TEMPLATE_SL8_IMM 27
+#define TEMPLATE_SL16_IMM 28
+#define TEMPLATE_SL32_IMM 29
+#define TEMPLATE_UNARY8 30
+#define TEMPLATE_UNARY16 31
+#define TEMPLATE_UNARY32 32
+#define TEMPLATE_CMP8_REG 33
+#define TEMPLATE_CMP16_REG 34
+#define TEMPLATE_CMP32_REG 35
+#define TEMPLATE_CMP8_IMM 36
+#define TEMPLATE_CMP16_IMM 37
+#define TEMPLATE_CMP32_IMM 38
+#define TEMPLATE_TEST8 39
+#define TEMPLATE_TEST16 40
+#define TEMPLATE_TEST32 41
+#define TEMPLATE_SET 42
+#define TEMPLATE_JMP 43
+#define TEMPLATE_INB_DX 44
+#define TEMPLATE_INB_IMM 45
+#define TEMPLATE_INW_DX 46
+#define TEMPLATE_INW_IMM 47
+#define TEMPLATE_INL_DX 48
+#define TEMPLATE_INL_IMM 49
+#define TEMPLATE_OUTB_DX 50
+#define TEMPLATE_OUTB_IMM 51
+#define TEMPLATE_OUTW_DX 52
+#define TEMPLATE_OUTW_IMM 53
+#define TEMPLATE_OUTL_DX 54
+#define TEMPLATE_OUTL_IMM 55
+#define TEMPLATE_BSF 56
+#define TEMPLATE_RDMSR 57
+#define TEMPLATE_WRMSR 58
+#define TEMPLATE_UMUL8 59
+#define TEMPLATE_UMUL16 60
+#define TEMPLATE_UMUL32 61
+#define TEMPLATE_DIV8 62
+#define TEMPLATE_DIV16 63
+#define TEMPLATE_DIV32 64
+#define LAST_TEMPLATE TEMPLATE_DIV32
#if LAST_TEMPLATE >= MAX_TEMPLATES
#error "MAX_TEMPLATES to low"
#endif
-#define COPY8_REGCM (REGCM_GPR64 | REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8 | REGCM_MMX | REGCM_XMM)
-#define COPY16_REGCM (REGCM_GPR64 | REGCM_GPR32 | REGCM_GPR16 | REGCM_MMX | REGCM_XMM)
-#define COPY32_REGCM (REGCM_GPR64 | REGCM_GPR32 | REGCM_MMX | REGCM_XMM)
-#define COPYIMM8_REGCM (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8)
-#define COPYIMM16_REGCM (REGCM_GPR32 | REGCM_GPR16)
-#define COPYIMM32_REGCM (REGCM_GPR32)
+#define COPY8_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO | REGCM_MMX | REGCM_XMM)
+#define COPY16_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_GPR16 | REGCM_MMX | REGCM_XMM)
+#define COPY32_REGCM (REGCM_DIVIDEND64 | REGCM_DIVIDEND32 | REGCM_GPR32 | REGCM_MMX | REGCM_XMM)
static struct ins_template templates[] = {
.rhs = { [0] = { REG_UNSET, COPY32_REGCM } },
},
[TEMPLATE_COPY_IMM8] = {
- .lhs = { [0] = { REG_UNSET, COPYIMM8_REGCM } },
+ .lhs = { [0] = { REG_UNSET, COPY8_REGCM } },
.rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
},
[TEMPLATE_COPY_IMM16] = {
- .lhs = { [0] = { REG_UNSET, COPYIMM16_REGCM } },
+ .lhs = { [0] = { REG_UNSET, COPY16_REGCM } },
.rhs = { [0] = { REG_UNNEEDED, REGCM_IMM16 | REGCM_IMM8 } },
},
[TEMPLATE_COPY_IMM32] = {
- .lhs = { [0] = { REG_UNSET, COPYIMM32_REGCM } },
+ .lhs = { [0] = { REG_UNSET, COPY32_REGCM } },
.rhs = { [0] = { REG_UNNEEDED, REGCM_IMM32 | REGCM_IMM16 | REGCM_IMM8 } },
},
[TEMPLATE_PHI8] = {
[15] = { REG_VIRT0, COPY32_REGCM },
}, },
[TEMPLATE_STORE8] = {
- .lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
- .rhs = { [0] = { REG_UNSET, REGCM_GPR8 } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR32 },
+ [1] = { REG_UNSET, REGCM_GPR8_LO },
+ },
},
[TEMPLATE_STORE16] = {
- .lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
- .rhs = { [0] = { REG_UNSET, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR32 },
+ [1] = { REG_UNSET, REGCM_GPR16 },
+ },
},
[TEMPLATE_STORE32] = {
- .lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
- .rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR32 },
+ [1] = { REG_UNSET, REGCM_GPR32 },
+ },
},
[TEMPLATE_LOAD8] = {
- .lhs = { [0] = { REG_UNSET, REGCM_GPR8 } },
+ .lhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
.rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
},
[TEMPLATE_LOAD16] = {
.lhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
.rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
},
- [TEMPLATE_BINARY_REG] = {
+ [TEMPLATE_BINARY8_REG] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR8_LO },
+ [1] = { REG_UNSET, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_BINARY16_REG] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR16 },
+ [1] = { REG_UNSET, REGCM_GPR16 },
+ },
+ },
+ [TEMPLATE_BINARY32_REG] = {
.lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
.rhs = {
[0] = { REG_VIRT0, REGCM_GPR32 },
[1] = { REG_UNSET, REGCM_GPR32 },
},
},
- [TEMPLATE_BINARY_IMM] = {
+ [TEMPLATE_BINARY8_IMM] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR8_LO },
+ [1] = { REG_UNNEEDED, REGCM_IMM8 },
+ },
+ },
+ [TEMPLATE_BINARY16_IMM] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR16 },
+ [1] = { REG_UNNEEDED, REGCM_IMM16 },
+ },
+ },
+ [TEMPLATE_BINARY32_IMM] = {
.lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
.rhs = {
[0] = { REG_VIRT0, REGCM_GPR32 },
[1] = { REG_UNNEEDED, REGCM_IMM32 },
},
},
- [TEMPLATE_SL_CL] = {
+ [TEMPLATE_SL8_CL] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR8_LO },
+ [1] = { REG_CL, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_SL16_CL] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR16 },
+ [1] = { REG_CL, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_SL32_CL] = {
.lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
.rhs = {
[0] = { REG_VIRT0, REGCM_GPR32 },
- [1] = { REG_CL, REGCM_GPR8 },
+ [1] = { REG_CL, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_SL8_IMM] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR8_LO },
+ [1] = { REG_UNNEEDED, REGCM_IMM8 },
},
},
- [TEMPLATE_SL_IMM] = {
+ [TEMPLATE_SL16_IMM] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_VIRT0, REGCM_GPR16 },
+ [1] = { REG_UNNEEDED, REGCM_IMM8 },
+ },
+ },
+ [TEMPLATE_SL32_IMM] = {
.lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
.rhs = {
[0] = { REG_VIRT0, REGCM_GPR32 },
[1] = { REG_UNNEEDED, REGCM_IMM8 },
},
},
- [TEMPLATE_UNARY] = {
+ [TEMPLATE_UNARY8] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ .rhs = { [0] = { REG_VIRT0, REGCM_GPR8_LO } },
+ },
+ [TEMPLATE_UNARY16] = {
+ .lhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ .rhs = { [0] = { REG_VIRT0, REGCM_GPR16 } },
+ },
+ [TEMPLATE_UNARY32] = {
.lhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
.rhs = { [0] = { REG_VIRT0, REGCM_GPR32 } },
},
- [TEMPLATE_CMP_REG] = {
+ [TEMPLATE_CMP8_REG] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR8_LO },
+ [1] = { REG_UNSET, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_CMP16_REG] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR16 },
+ [1] = { REG_UNSET, REGCM_GPR16 },
+ },
+ },
+ [TEMPLATE_CMP32_REG] = {
.lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
.rhs = {
[0] = { REG_UNSET, REGCM_GPR32 },
[1] = { REG_UNSET, REGCM_GPR32 },
},
},
- [TEMPLATE_CMP_IMM] = {
+ [TEMPLATE_CMP8_IMM] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR8_LO },
+ [1] = { REG_UNNEEDED, REGCM_IMM8 },
+ },
+ },
+ [TEMPLATE_CMP16_IMM] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = {
+ [0] = { REG_UNSET, REGCM_GPR16 },
+ [1] = { REG_UNNEEDED, REGCM_IMM16 },
+ },
+ },
+ [TEMPLATE_CMP32_IMM] = {
.lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
.rhs = {
[0] = { REG_UNSET, REGCM_GPR32 },
[1] = { REG_UNNEEDED, REGCM_IMM32 },
},
},
- [TEMPLATE_TEST] = {
+ [TEMPLATE_TEST8] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
+ },
+ [TEMPLATE_TEST16] = {
+ .lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
+ .rhs = { [0] = { REG_UNSET, REGCM_GPR16 } },
+ },
+ [TEMPLATE_TEST32] = {
.lhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
.rhs = { [0] = { REG_UNSET, REGCM_GPR32 } },
},
[TEMPLATE_SET] = {
- .lhs = { [0] = { REG_UNSET, REGCM_GPR8 } },
+ .lhs = { [0] = { REG_UNSET, REGCM_GPR8_LO } },
.rhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
},
[TEMPLATE_JMP] = {
.rhs = { [0] = { REG_EFLAGS, REGCM_FLAGS } },
},
[TEMPLATE_INB_DX] = {
- .lhs = { [0] = { REG_AL, REGCM_GPR8 } },
+ .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } },
.rhs = { [0] = { REG_DX, REGCM_GPR16 } },
},
[TEMPLATE_INB_IMM] = {
- .lhs = { [0] = { REG_AL, REGCM_GPR8 } },
+ .lhs = { [0] = { REG_AL, REGCM_GPR8_LO } },
.rhs = { [0] = { REG_UNNEEDED, REGCM_IMM8 } },
},
[TEMPLATE_INW_DX] = {
},
[TEMPLATE_OUTB_DX] = {
.rhs = {
- [0] = { REG_AL, REGCM_GPR8 },
+ [0] = { REG_AL, REGCM_GPR8_LO },
[1] = { REG_DX, REGCM_GPR16 },
},
},
[TEMPLATE_OUTB_IMM] = {
.rhs = {
- [0] = { REG_AL, REGCM_GPR8 },
+ [0] = { REG_AL, REGCM_GPR8_LO },
[1] = { REG_UNNEEDED, REGCM_IMM8 },
},
},
[2] = { REG_EDX, REGCM_GPR32 },
},
},
- [TEMPLATE_UMUL] = {
- .lhs = { [0] = { REG_EDXEAX, REGCM_GPR64 } },
+ [TEMPLATE_UMUL8] = {
+ .lhs = { [0] = { REG_AX, REGCM_GPR16 } },
+ .rhs = {
+ [0] = { REG_AL, REGCM_GPR8_LO },
+ [1] = { REG_UNSET, REGCM_GPR8_LO },
+ },
+ },
+ [TEMPLATE_UMUL16] = {
+ .lhs = { [0] = { REG_DXAX, REGCM_DIVIDEND32 } },
+ .rhs = {
+ [0] = { REG_AX, REGCM_GPR16 },
+ [1] = { REG_UNSET, REGCM_GPR16 },
+ },
+ },
+ [TEMPLATE_UMUL32] = {
+ .lhs = { [0] = { REG_EDXEAX, REGCM_DIVIDEND64 } },
.rhs = {
[0] = { REG_EAX, REGCM_GPR32 },
[1] = { REG_UNSET, REGCM_GPR32 },
},
},
- [TEMPLATE_DIV] = {
+ [TEMPLATE_DIV8] = {
.lhs = {
- [0] = { REG_EAX, REGCM_GPR32 },
- [1] = { REG_EDX, REGCM_GPR32 },
+ [0] = { REG_AL, REGCM_GPR8_LO },
+ [1] = { REG_AH, REGCM_GPR8 },
},
.rhs = {
- [0] = { REG_EDXEAX, REGCM_GPR64 },
- [1] = { REG_UNSET, REGCM_GPR32 },
+ [0] = { REG_AX, REGCM_GPR16 },
+ [1] = { REG_UNSET, REGCM_GPR8_LO },
},
},
- [TEMPLATE_MOD] = {
+ [TEMPLATE_DIV16] = {
.lhs = {
- [0] = { REG_EDX, REGCM_GPR32 },
- [1] = { REG_EAX, REGCM_GPR32 },
+ [0] = { REG_AX, REGCM_GPR16 },
+ [1] = { REG_DX, REGCM_GPR16 },
},
.rhs = {
- [0] = { REG_EDXEAX, REGCM_GPR64 },
+ [0] = { REG_DXAX, REGCM_DIVIDEND32 },
+ [1] = { REG_UNSET, REGCM_GPR16 },
+ },
+ },
+ [TEMPLATE_DIV32] = {
+ .lhs = {
+ [0] = { REG_EAX, REGCM_GPR32 },
+ [1] = { REG_EDX, REGCM_GPR32 },
+ },
+ .rhs = {
+ [0] = { REG_EDXEAX, REGCM_DIVIDEND64 },
[1] = { REG_UNSET, REGCM_GPR32 },
},
},
branch = entry->member;
test = pre_triple(state, branch,
cmp->op, cmp->type, left, right);
- test->template_id = TEMPLATE_TEST;
+ test->template_id = TEMPLATE_TEST32;
if (cmp->op == OP_CMP) {
- test->template_id = TEMPLATE_CMP_REG;
+ test->template_id = TEMPLATE_CMP32_REG;
if (get_imm32(test, &RHS(test, 1))) {
- test->template_id = TEMPLATE_CMP_IMM;
+ test->template_id = TEMPLATE_CMP32_IMM;
}
}
use_triple(RHS(test, 0), test);
/* Modify the comparison operator */
ins->op = cmp_op;
- ins->template_id = TEMPLATE_TEST;
+ ins->template_id = TEMPLATE_TEST32;
if (cmp_op == OP_CMP) {
- ins->template_id = TEMPLATE_CMP_REG;
+ ins->template_id = TEMPLATE_CMP32_REG;
if (get_imm32(ins, &RHS(ins, 1))) {
- ins->template_id = TEMPLATE_CMP_IMM;
+ ins->template_id = TEMPLATE_CMP32_IMM;
}
}
/* Generate the instruction sequence that will transform the
return result;
}
+static struct triple *mod_div(struct compile_state *state,
+ struct triple *ins, int div_op, int index)
+{
+ struct triple *div, *piece0, *piece1;
+
+ /* Generate a piece to hold the remainder */
+ piece1 = post_triple(state, ins, OP_PIECE, ins->type, 0, 0);
+ piece1->u.cval = 1;
+
+ /* Generate a piece to hold the quotient */
+ piece0 = post_triple(state, ins, OP_PIECE, ins->type, 0, 0);
+ piece0->u.cval = 0;
+
+ /* Generate the appropriate division instruction */
+ div = post_triple(state, ins, div_op, ins->type, 0, 0);
+ RHS(div, 0) = RHS(ins, 0);
+ RHS(div, 1) = RHS(ins, 1);
+ LHS(div, 0) = piece0;
+ LHS(div, 1) = piece1;
+ div->template_id = TEMPLATE_DIV32;
+ use_triple(RHS(div, 0), div);
+ use_triple(RHS(div, 1), div);
+ use_triple(LHS(div, 0), div);
+ use_triple(LHS(div, 1), div);
+
+ /* Hook on piece0 */
+ MISC(piece0, 0) = div;
+ use_triple(div, piece0);
+
+ /* Hook on piece1 */
+ MISC(piece1, 0) = div;
+ use_triple(div, piece1);
+
+ /* Replate uses of ins with the appropriate piece of the div */
+ propogate_use(state, ins, LHS(div, index));
+ release_triple(state, ins);
+
+ /* Return the address of the next instruction */
+ return piece1->next;
+}
+
static struct triple *transform_to_arch_instruction(
struct compile_state *state, struct triple *ins)
{
case OP_XOR:
case OP_OR:
case OP_SMUL:
- ins->template_id = TEMPLATE_BINARY_REG;
+ ins->template_id = TEMPLATE_BINARY32_REG;
if (get_imm32(ins, &RHS(ins, 1))) {
- ins->template_id = TEMPLATE_BINARY_IMM;
+ ins->template_id = TEMPLATE_BINARY32_IMM;
}
break;
-#if 0
- /* This code does not work yet */
+ case OP_SDIVT:
+ case OP_UDIVT:
+ ins->template_id = TEMPLATE_DIV32;
+ next = after_lhs(state, ins);
+ break;
+ /* FIXME UMUL does not work yet.. */
case OP_UMUL:
- ins->template_id = TEMPLATE_UMUL;
+ ins->template_id = TEMPLATE_UMUL32;
break;
case OP_UDIV:
+ next = mod_div(state, ins, OP_UDIVT, 0);
+ break;
case OP_SDIV:
- ins->template_id = TEMPLATE_DIV;
+ next = mod_div(state, ins, OP_SDIVT, 0);
break;
case OP_UMOD:
+ next = mod_div(state, ins, OP_UDIVT, 1);
+ break;
case OP_SMOD:
- ins->template_id = TEMPLATE_MOD;
+ next = mod_div(state, ins, OP_SDIVT, 1);
break;
-#endif
case OP_SL:
case OP_SSR:
case OP_USR:
- ins->template_id = TEMPLATE_SL_CL;
+ ins->template_id = TEMPLATE_SL32_CL;
if (get_imm8(ins, &RHS(ins, 1))) {
- ins->template_id = TEMPLATE_SL_IMM;
+ ins->template_id = TEMPLATE_SL32_IMM;
} else if (size_of(state, RHS(ins, 1)->type) > 1) {
typed_pre_copy(state, &char_type, ins, 1);
}
break;
case OP_INVERT:
case OP_NEG:
- ins->template_id = TEMPLATE_UNARY;
+ ins->template_id = TEMPLATE_UNARY32;
break;
case OP_EQ:
bool_cmp(state, ins, OP_CMP, OP_JMP_EQ, OP_SET_EQ);
break;
/* Already transformed instructions */
case OP_TEST:
- ins->template_id = TEMPLATE_TEST;
+ ins->template_id = TEMPLATE_TEST32;
break;
case OP_CMP:
- ins->template_id = TEMPLATE_CMP_REG;
+ ins->template_id = TEMPLATE_CMP32_REG;
if (get_imm32(ins, &RHS(ins, 1))) {
- ins->template_id = TEMPLATE_CMP_IMM;
+ ins->template_id = TEMPLATE_CMP32_IMM;
}
break;
case OP_JMP_EQ: case OP_JMP_NOTEQ:
return next;
}
+static long next_label(struct compile_state *state)
+{
+ static long label_counter = 0;
+ return ++label_counter;
+}
static void generate_local_labels(struct compile_state *state)
{
struct triple *first, *label;
- int label_counter;
- label_counter = 0;
first = RHS(state->main_function, 0);
label = first;
do {
if ((label->op == OP_LABEL) ||
(label->op == OP_SDECL)) {
if (label->use) {
- label->u.cval = ++label_counter;
+ label->u.cval = next_label(state);
} else {
label->u.cval = 0;
}
static const char *arch_reg_str(int reg)
{
+#if REG_XMM7 != 44
+#error "Registers have renumberd fix arch_reg_str"
+#endif
static const char *regs[] = {
"%unset",
"%unneeded",
"%ax", "%bx", "%cx", "%dx", "%si", "%di", "%bp", "%sp",
"%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp",
"%edx:%eax",
+ "%dx:%ax",
"%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7",
"%xmm0", "%xmm1", "%xmm2", "%xmm3",
"%xmm4", "%xmm5", "%xmm6", "%xmm7",
}
}
+static void print_const(struct compile_state *state,
+ struct triple *ins, FILE *fp)
+{
+ switch(ins->op) {
+ case OP_INTCONST:
+ switch(ins->type->type & TYPE_MASK) {
+ case TYPE_CHAR:
+ case TYPE_UCHAR:
+ fprintf(fp, ".byte 0x%02lx\n", ins->u.cval);
+ break;
+ case TYPE_SHORT:
+ case TYPE_USHORT:
+ fprintf(fp, ".short 0x%04lx\n", ins->u.cval);
+ break;
+ case TYPE_INT:
+ case TYPE_UINT:
+ case TYPE_LONG:
+ case TYPE_ULONG:
+ fprintf(fp, ".int %lu\n", ins->u.cval);
+ break;
+ default:
+ internal_error(state, ins, "Unknown constant type");
+ }
+ break;
+ case OP_ADDRCONST:
+ fprintf(fp, " .int L%s%lu+%lu ",
+ state->label_prefix,
+ MISC(ins, 0)->u.cval,
+ ins->u.cval);
+ break;
+ case OP_BLOBCONST:
+ {
+ unsigned char *blob;
+ size_t size, i;
+ size = size_of(state, ins->type);
+ blob = ins->u.blob;
+ for(i = 0; i < size; i++) {
+ fprintf(fp, ".byte 0x%02x\n",
+ blob[i]);
+ }
+ break;
+ }
+ default:
+ internal_error(state, ins, "Unknown constant type");
+ break;
+ }
+}
+
+#define TEXT_SECTION ".rom.text"
+#define DATA_SECTION ".rom.data"
+
+static long get_const_pool_ref(
+ struct compile_state *state, struct triple *ins, FILE *fp)
+{
+ long ref;
+ ref = next_label(state);
+ fprintf(fp, ".section \"" DATA_SECTION "\"\n");
+ fprintf(fp, ".balign %d\n", align_of(state, ins->type));
+ fprintf(fp, "L%s%lu:\n", state->label_prefix, ref);
+ print_const(state, ins, fp);
+ fprintf(fp, ".section \"" TEXT_SECTION "\"\n");
+ return ref;
+}
+
static void print_binary_op(struct compile_state *state,
const char *op, struct triple *ins, FILE *fp)
{
unsigned mask;
- mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8;
+ mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
if (RHS(ins, 0)->id != ins->id) {
internal_error(state, ins, "invalid register assignment");
}
const char *op, struct triple *ins, FILE *fp)
{
unsigned mask;
- mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8;
+ mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
fprintf(fp, "\t%s %s\n",
op,
reg(state, RHS(ins, 0), mask));
const char *op, struct triple *ins, FILE *fp)
{
unsigned mask;
- mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8;
+ mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
if (RHS(ins, 0)->id != ins->id) {
internal_error(state, ins, "invalid register assignment");
}
else {
fprintf(fp, "\t%s %s, %s\n",
op,
- reg(state, RHS(ins, 1), REGCM_GPR8),
+ reg(state, RHS(ins, 1), REGCM_GPR8_LO),
reg(state, RHS(ins, 0), mask));
}
}
int dreg;
mask = 0;
switch(ins->op) {
- case OP_INB: op = "inb", mask = REGCM_GPR8; break;
+ case OP_INB: op = "inb", mask = REGCM_GPR8_LO; break;
case OP_INW: op = "inw", mask = REGCM_GPR16; break;
case OP_INL: op = "inl", mask = REGCM_GPR32; break;
default:
int lreg;
mask = 0;
switch(ins->op) {
- case OP_OUTB: op = "outb", mask = REGCM_GPR8; break;
+ case OP_OUTB: op = "outb", mask = REGCM_GPR8_LO; break;
case OP_OUTW: op = "outw", mask = REGCM_GPR16; break;
case OP_OUTL: op = "outl", mask = REGCM_GPR32; break;
default:
src = RHS(ins, 0);
dst = ins;
}
- else if (ins->op == OP_WRITE) {
- dst = LHS(ins, 0);
- src = RHS(ins, 0);
- }
else {
internal_error(state, ins, "unknown move operation");
src = dst = 0;
if (!is_const(src)) {
int src_reg, dst_reg;
int src_regcm, dst_regcm;
- src_reg = ID_REG(src->id);
+ src_reg = ID_REG(src->id);
dst_reg = ID_REG(dst->id);
src_regcm = arch_reg_regcm(state, src_reg);
- dst_regcm = arch_reg_regcm(state, dst_reg);
+ dst_regcm = arch_reg_regcm(state, dst_reg);
/* If the class is the same just move the register */
if (src_regcm & dst_regcm &
- (REGCM_GPR8 | REGCM_GPR16 | REGCM_GPR32)) {
+ (REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32)) {
if ((src_reg != dst_reg) || !omit_copy) {
fprintf(fp, "\tmov %s, %s\n",
reg(state, src, src_regcm),
}
/* Move 32bit to 8bit */
else if ((src_regcm & REGCM_GPR32_8) &&
- (dst_regcm & REGCM_GPR8))
+ (dst_regcm & REGCM_GPR8_LO))
{
src_reg = (src_reg - REGC_GPR32_8_FIRST) + REGC_GPR8_FIRST;
if ((src_reg != dst_reg) || !omit_copy) {
}
/* Move 16bit to 8bit */
else if ((src_regcm & REGCM_GPR16_8) &&
- (dst_regcm & REGCM_GPR8))
+ (dst_regcm & REGCM_GPR8_LO))
{
src_reg = (src_reg - REGC_GPR16_8_FIRST) + REGC_GPR8_FIRST;
if ((src_reg != dst_reg) || !omit_copy) {
}
}
/* Move 8/16bit to 16/32bit */
- else if ((src_regcm & (REGCM_GPR8 | REGCM_GPR16)) &&
+ else if ((src_regcm & (REGCM_GPR8_LO | REGCM_GPR16)) &&
(dst_regcm & (REGCM_GPR16 | REGCM_GPR32))) {
const char *op;
op = is_signed(src->type)? "movsx": "movzx";
reg(state, dst, dst_regcm));
}
}
- /* Move between mmx registers or mmx & sse registers */
- else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
- (dst_regcm & (REGCM_MMX | REGCM_XMM))) {
+ /* Move between mmx registers */
+ else if ((src_regcm & dst_regcm & REGCM_MMX)) {
if ((src_reg != dst_reg) || !omit_copy) {
fprintf(fp, "\tmovq %s, %s\n",
reg(state, src, src_regcm),
reg(state, dst, dst_regcm));
}
}
+ /* Move from sse to mmx registers */
+ else if ((src_regcm & REGCM_XMM) && (dst_regcm & REGCM_MMX)) {
+ fprintf(fp, "\tmovdq2q %s, %s\n",
+ reg(state, src, src_regcm),
+ reg(state, dst, dst_regcm));
+ }
+ /* Move from mmx to sse registers */
+ else if ((src_regcm & REGCM_MMX) && (dst_regcm & REGCM_XMM)) {
+ fprintf(fp, "\tmovq2dq %s, %s\n",
+ reg(state, src, src_regcm),
+ reg(state, dst, dst_regcm));
+ }
/* Move between 32bit gprs & mmx/sse registers */
else if ((src_regcm & (REGCM_GPR32 | REGCM_MMX | REGCM_XMM)) &&
(dst_regcm & (REGCM_GPR32 | REGCM_MMX | REGCM_XMM))) {
arch_reg_str(mid_reg),
arch_reg_str(dst_reg));
}
-
/* Move from mmx/sse registers to 16bit gprs */
else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
(dst_regcm & REGCM_GPR16)) {
arch_reg_str(src_reg),
arch_reg_str(dst_reg));
}
-
+ /* Move from gpr to 64bit dividend */
+ else if ((src_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) &&
+ (dst_regcm & REGCM_DIVIDEND64)) {
+ const char *extend;
+ extend = is_signed(src->type)? "cltd":"movl $0, %edx";
+ fprintf(fp, "\tmov %s, %%eax\n\t%s\n",
+ arch_reg_str(src_reg),
+ extend);
+ }
+ /* Move from 64bit gpr to gpr */
+ else if ((src_regcm & REGCM_DIVIDEND64) &&
+ (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO))) {
+ if (dst_regcm & REGCM_GPR32) {
+ src_reg = REG_EAX;
+ }
+ else if (dst_regcm & REGCM_GPR16) {
+ src_reg = REG_AX;
+ }
+ else if (dst_regcm & REGCM_GPR8_LO) {
+ src_reg = REG_AL;
+ }
+ fprintf(fp, "\tmov %s, %s\n",
+ arch_reg_str(src_reg),
+ arch_reg_str(dst_reg));
+ }
+ /* Move from mmx/sse registers to 64bit gpr */
+ else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
+ (dst_regcm & REGCM_DIVIDEND64)) {
+ const char *extend;
+ extend = is_signed(src->type)? "cltd": "movl $0, %edx";
+ fprintf(fp, "\tmovd %s, %%eax\n\t%s\n",
+ arch_reg_str(src_reg),
+ extend);
+ }
+ /* Move from 64bit gpr to mmx/sse register */
+ else if ((src_regcm & REGCM_DIVIDEND64) &&
+ (dst_regcm & (REGCM_XMM | REGCM_MMX))) {
+ fprintf(fp, "\tmovd %%eax, %s\n",
+ arch_reg_str(dst_reg));
+ }
#if X86_4_8BIT_GPRS
/* Move from 8bit gprs to mmx/sse registers */
- else if ((src_regcm & REGCM_GPR8) && (src_reg <= REG_DL) &&
+ else if ((src_regcm & REGCM_GPR8_LO) && (src_reg <= REG_DL) &&
(dst_regcm & (REGCM_MMX | REGCM_XMM))) {
const char *op;
int mid_reg;
}
/* Move from mmx/sse registers and 8bit gprs */
else if ((src_regcm & (REGCM_MMX | REGCM_XMM)) &&
- (dst_regcm & REGCM_GPR8) && (dst_reg <= REG_DL)) {
+ (dst_regcm & REGCM_GPR8_LO) && (dst_reg <= REG_DL)) {
int mid_reg;
mid_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR32_FIRST;
fprintf(fp, "\tmovd %s, %s\n",
}
/* Move from 32bit gprs to 8bit gprs */
else if ((src_regcm & REGCM_GPR32) &&
- (dst_regcm & REGCM_GPR8)) {
+ (dst_regcm & REGCM_GPR8_LO)) {
dst_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR32_FIRST;
if ((src_reg != dst_reg) || !omit_copy) {
fprintf(fp, "\tmov %s, %s\n",
}
/* Move from 16bit gprs to 8bit gprs */
else if ((src_regcm & REGCM_GPR16) &&
- (dst_regcm & REGCM_GPR8)) {
+ (dst_regcm & REGCM_GPR8_LO)) {
dst_reg = (dst_reg - REGC_GPR8_FIRST) + REGC_GPR16_FIRST;
if ((src_reg != dst_reg) || !omit_copy) {
fprintf(fp, "\tmov %s, %s\n",
}
}
else {
- fprintf(fp, "\tmov ");
- print_const_val(state, src, fp);
- fprintf(fp, ", %s\n",
- reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8));
+ int dst_reg;
+ int dst_regcm;
+ dst_reg = ID_REG(dst->id);
+ dst_regcm = arch_reg_regcm(state, dst_reg);
+ if (dst_regcm & (REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO)) {
+ fprintf(fp, "\tmov ");
+ print_const_val(state, src, fp);
+ fprintf(fp, ", %s\n",
+ reg(state, dst, REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO));
+ }
+ else if (dst_regcm & REGCM_DIVIDEND64) {
+ if (size_of(state, dst->type) > 4) {
+ internal_error(state, ins, "64bit constant...");
+ }
+ fprintf(fp, "\tmov $0, %%edx\n");
+ fprintf(fp, "\tmov ");
+ print_const_val(state, src, fp);
+ fprintf(fp, ", %%eax\n");
+ }
+ else if (dst_regcm & REGCM_DIVIDEND32) {
+ if (size_of(state, dst->type) > 2) {
+ internal_error(state, ins, "32bit constant...");
+ }
+ fprintf(fp, "\tmov $0, %%dx\n");
+ fprintf(fp, "\tmov ");
+ print_const_val(state, src, fp);
+ fprintf(fp, ", %%ax");
+ }
+ else if (dst_regcm & (REGCM_XMM | REGCM_MMX)) {
+ long ref;
+ ref = get_const_pool_ref(state, src, fp);
+ fprintf(fp, "\tmovq L%s%lu, %s\n",
+ state->label_prefix, ref,
+ reg(state, dst, (REGCM_XMM | REGCM_MMX)));
+ }
+ else {
+ internal_error(state, ins, "unknown copy immediate type");
+ }
}
}
}
fprintf(fp, "\tmov (%s), %s\n",
reg(state, src, REGCM_GPR32),
- reg(state, dst, REGCM_GPR8 | REGCM_GPR16 | REGCM_GPR32));
+ reg(state, dst, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32));
}
struct triple *ins, FILE *fp)
{
struct triple *dst, *src;
- dst = LHS(ins, 0);
- src = RHS(ins, 0);
+ dst = RHS(ins, 0);
+ src = RHS(ins, 1);
if (is_const(src) && (src->op == OP_INTCONST)) {
long_t value;
value = (long_t)(src->u.cval);
else if (is_const(dst) && (dst->op == OP_INTCONST)) {
fprintf(fp, "\tmov%s %s, 0x%08lx\n",
type_suffix(state, src->type),
- reg(state, src, REGCM_GPR8 | REGCM_GPR16 | REGCM_GPR32),
+ reg(state, src, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32),
dst->u.cval);
}
else {
}
fprintf(fp, "\tmov%s %s, (%s)\n",
type_suffix(state, src->type),
- reg(state, src, REGCM_GPR8 | REGCM_GPR16 | REGCM_GPR32),
+ reg(state, src, REGCM_GPR8_LO | REGCM_GPR16 | REGCM_GPR32),
reg(state, dst, REGCM_GPR32));
}
{
unsigned mask;
int dreg;
- mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8;
+ mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
dreg = check_reg(state, ins, REGCM_FLAGS);
if (!reg_is_reg(state, dreg, REG_EFLAGS)) {
internal_error(state, ins, "bad dest register for cmp");
struct triple *ins, FILE *fp)
{
unsigned mask;
- mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8;
+ mask = REGCM_GPR32 | REGCM_GPR16 | REGCM_GPR8_LO;
fprintf(fp, "\ttest %s, %s\n",
reg(state, RHS(ins, 0), mask),
reg(state, RHS(ins, 0), mask));
break;
}
fprintf(fp, "\t%s %s\n",
- sop, reg(state, set, REGCM_GPR8));
+ sop, reg(state, set, REGCM_GPR8_LO));
}
static void print_op_bit_scan(struct compile_state *state,
reg(state, ins, REGCM_GPR32));
}
-static void print_const(struct compile_state *state,
- struct triple *ins, FILE *fp)
-{
- switch(ins->op) {
- case OP_INTCONST:
- switch(ins->type->type & TYPE_MASK) {
- case TYPE_CHAR:
- case TYPE_UCHAR:
- fprintf(fp, ".byte 0x%02lx\n", ins->u.cval);
- break;
- case TYPE_SHORT:
- case TYPE_USHORT:
- fprintf(fp, ".short 0x%04lx\n", ins->u.cval);
- break;
- case TYPE_INT:
- case TYPE_UINT:
- case TYPE_LONG:
- case TYPE_ULONG:
- fprintf(fp, ".int %lu\n", ins->u.cval);
- break;
- default:
- internal_error(state, ins, "Unknown constant type");
- }
- break;
- case OP_BLOBCONST:
- {
- unsigned char *blob;
- size_t size, i;
- size = size_of(state, ins->type);
- blob = ins->u.blob;
- for(i = 0; i < size; i++) {
- fprintf(fp, ".byte 0x%02x\n",
- blob[i]);
- }
- break;
- }
- default:
- internal_error(state, ins, "Unknown constant type");
- break;
- }
-}
-
-#define TEXT_SECTION ".rom.text"
-#define DATA_SECTION ".rom.data"
static void print_sdecl(struct compile_state *state,
struct triple *ins, FILE *fp)
case OP_SDECL:
print_sdecl(state, ins, fp);
break;
- case OP_WRITE:
case OP_COPY:
print_op_move(state, ins, fp);
break;
case OP_HLT:
fprintf(fp, "\thlt\n");
break;
+ case OP_SDIVT:
+ fprintf(fp, "\tidiv %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
+ break;
+ case OP_UDIVT:
+ fprintf(fp, "\tdiv %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
+ break;
+ case OP_UMUL:
+ fprintf(fp, "\tmul %s\n", reg(state, RHS(ins, 1), REGCM_GPR32));
+ break;
case OP_LABEL:
if (!ins->use) {
return;
/* Ignore OP_PIECE */
case OP_PIECE:
break;
- /* Operations I am not yet certain how to handle */
- case OP_UMUL:
+ /* Operations that should never get here */
case OP_SDIV: case OP_UDIV:
case OP_SMOD: case OP_UMOD:
- /* Operations that should never get here */
case OP_LTRUE: case OP_LFALSE: case OP_EQ: case OP_NOTEQ:
case OP_SLESS: case OP_ULESS: case OP_SMORE: case OP_UMORE:
case OP_SLESSEQ: case OP_ULESSEQ: case OP_SMOREEQ: case OP_UMOREEQ:
int print_location;
struct occurance *last_occurance;
FILE *fp;
+ int max_inline_depth;
+ max_inline_depth = 0;
print_location = 1;
last_occurance = 0;
fp = state->output;
}
else {
struct occurance *ptr;
+ int inline_depth;
fprintf(fp, "\t/*\n");
+ inline_depth = 0;
for(ptr = ins->occurance; ptr; ptr = ptr->parent) {
+ inline_depth++;
fprintf(fp, "\t * %s,%s:%d.%d\n",
ptr->function,
ptr->filename,
ptr->col);
}
fprintf(fp, "\t */\n");
-
+ if (inline_depth > max_inline_depth) {
+ max_inline_depth = inline_depth;
+ }
}
if (last_occurance) {
put_occurance(last_occurance);
print_instruction(state, ins, fp);
ins = ins->next;
} while(ins != first);
-
+ if (print_location) {
+ fprintf(fp, "/* max inline depth %d */\n",
+ max_inline_depth);
+ }
}
+
static void generate_code(struct compile_state *state)
{
generate_local_labels(state);
--- /dev/null
+
+
+
+
+
+
+
+typedef unsigned char uint8_t;
+typedef signed char int8_t;
+
+typedef unsigned short uint16_t;
+typedef signed short int16_t;
+
+typedef unsigned int uint32_t;
+typedef signed int int32_t;
+
+
+
+
+
+
+
+typedef unsigned char uint_least8_t;
+typedef signed char int_least8_t;
+
+typedef unsigned short uint_least16_t;
+typedef signed short int_least16_t;
+
+typedef unsigned int uint_least32_t;
+typedef signed int int_least32_t;
+
+
+
+
+
+
+
+typedef unsigned char uint_fast8_t;
+typedef signed char int_fast8_t;
+
+typedef unsigned int uint_fast16_t;
+typedef signed int int_fast16_t;
+
+typedef unsigned int uint_fast32_t;
+typedef signed int int_fast32_t;
+
+
+
+
+
+
+
+typedef int intptr_t;
+typedef unsigned int uintptr_t;
+
+
+
+
+
+
+typedef long int intmax_t;
+typedef unsigned long int uintmax_t;
+
+
+
+
+static void outb(unsigned char value, unsigned short port)
+{
+ __builtin_outb(value, port);
+}
+
+static void outw(unsigned short value, unsigned short port)
+{
+ __builtin_outw(value, port);
+}
+
+static void outl(unsigned int value, unsigned short port)
+{
+ __builtin_outl(value, port);
+}
+
+
+static unsigned char inb(unsigned short port)
+{
+ return __builtin_inb(port);
+}
+
+
+static unsigned char inw(unsigned short port)
+{
+ return __builtin_inw(port);
+}
+
+static unsigned char inl(unsigned short port)
+{
+ return __builtin_inl(port);
+}
+
+static void hlt(void)
+{
+ __builtin_hlt();
+}
+
+int log2(int value)
+{
+
+
+
+
+
+
+ return __builtin_bsr(value);
+}
+
+
+typedef __builtin_msr_t msr_t;
+
+static msr_t rdmsr(unsigned long index)
+{
+ return __builtin_rdmsr(index);
+}
+
+static void wrmsr(unsigned long index, msr_t msr)
+{
+ __builtin_wrmsr(index, msr.lo, msr.hi);
+}
+
+typedef unsigned device_t;
+
+static unsigned char pci_read_config8(device_t dev, unsigned where)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ return inb(0xCFC + (addr & 3));
+}
+
+static unsigned short pci_read_config16(device_t dev, unsigned where)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ return inw(0xCFC + (addr & 2));
+}
+
+static unsigned int pci_read_config32(device_t dev, unsigned where)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ return inl(0xCFC);
+}
+
+static void pci_write_config8(device_t dev, unsigned where, unsigned char value)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ outb(value, 0xCFC + (addr & 3));
+}
+
+static void pci_write_config16(device_t dev, unsigned where, unsigned short value)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ outw(value, 0xCFC + (addr & 2));
+}
+
+static void pci_write_config32(device_t dev, unsigned where, unsigned int value)
+{
+ unsigned addr;
+ addr = dev | where;
+ outl(0x80000000 | (addr & ~3), 0xCF8);
+ outl(value, 0xCFC);
+}
+
+
+static device_t pci_locate_device(unsigned pci_id, device_t dev)
+{
+ for(; dev <= ( (((255) & 0xFF) << 16) | (((31) & 0x1f) << 11) | (((7) & 0x7) << 8)); dev += ( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((1) & 0x7) << 8))) {
+ unsigned int id;
+ id = pci_read_config32(dev, 0);
+ if (id == pci_id) {
+ return dev;
+ }
+ }
+ return (0xffffffffU);
+}
+
+
+
+
+
+static int uart_can_tx_byte(void)
+{
+ return inb(0x3f8 + 0x05) & 0x20;
+}
+
+static void uart_wait_to_tx_byte(void)
+{
+ while(!uart_can_tx_byte())
+ ;
+}
+
+static void uart_wait_until_sent(void)
+{
+ while(!(inb(0x3f8 + 0x05) & 0x40))
+ ;
+}
+
+static void uart_tx_byte(unsigned char data)
+{
+ uart_wait_to_tx_byte();
+ outb(data, 0x3f8 + 0x00);
+
+ uart_wait_until_sent();
+}
+
+static void uart_init(void)
+{
+
+ outb(0x0, 0x3f8 + 0x01);
+
+ outb(0x01, 0x3f8 + 0x02);
+
+ outb(0x80 | 0x3, 0x3f8 + 0x03);
+
+ outb((115200/115200) & 0xFF, 0x3f8 + 0x00);
+ outb(((115200/115200) >> 8) & 0xFF, 0x3f8 + 0x01);
+
+ outb(0x3, 0x3f8 + 0x03);
+}
+
+
+
+
+
+static void __console_tx_byte(unsigned char byte)
+{
+ uart_tx_byte(byte);
+}
+
+static void __console_tx_nibble(unsigned nibble)
+{
+ unsigned char digit;
+ digit = nibble + '0';
+ if (digit > '9') {
+ digit += 39;
+ }
+ __console_tx_byte(digit);
+}
+
+static void __console_tx_char(int loglevel, unsigned char byte)
+{
+ if (8 > loglevel) {
+ uart_tx_byte(byte);
+ }
+}
+
+static void __console_tx_hex8(int loglevel, unsigned char value)
+{
+ if (8 > loglevel) {
+ __console_tx_nibble((value >> 4U) & 0x0fU);
+ __console_tx_nibble(value & 0x0fU);
+ }
+}
+
+static void __console_tx_hex16(int loglevel, unsigned short value)
+{
+ if (8 > loglevel) {
+ __console_tx_nibble((value >> 12U) & 0x0fU);
+ __console_tx_nibble((value >> 8U) & 0x0fU);
+ __console_tx_nibble((value >> 4U) & 0x0fU);
+ __console_tx_nibble(value & 0x0fU);
+ }
+}
+
+static void __console_tx_hex32(int loglevel, unsigned int value)
+{
+ if (8 > loglevel) {
+ __console_tx_nibble((value >> 28U) & 0x0fU);
+ __console_tx_nibble((value >> 24U) & 0x0fU);
+ __console_tx_nibble((value >> 20U) & 0x0fU);
+ __console_tx_nibble((value >> 16U) & 0x0fU);
+ __console_tx_nibble((value >> 12U) & 0x0fU);
+ __console_tx_nibble((value >> 8U) & 0x0fU);
+ __console_tx_nibble((value >> 4U) & 0x0fU);
+ __console_tx_nibble(value & 0x0fU);
+ }
+}
+
+static void __console_tx_string(int loglevel, const char *str)
+{
+ if (8 > loglevel) {
+ unsigned char ch;
+ while((ch = *str++) != '\0') {
+ __console_tx_byte(ch);
+ }
+ }
+}
+
+static void print_emerg_char(unsigned char byte) { __console_tx_char(0, byte); }
+static void print_emerg_hex8(unsigned char value){ __console_tx_hex8(0, value); }
+static void print_emerg_hex16(unsigned short value){ __console_tx_hex16(0, value); }
+static void print_emerg_hex32(unsigned int value) { __console_tx_hex32(0, value); }
+static void print_emerg(const char *str) { __console_tx_string(0, str); }
+
+static void print_alert_char(unsigned char byte) { __console_tx_char(1, byte); }
+static void print_alert_hex8(unsigned char value) { __console_tx_hex8(1, value); }
+static void print_alert_hex16(unsigned short value){ __console_tx_hex16(1, value); }
+static void print_alert_hex32(unsigned int value) { __console_tx_hex32(1, value); }
+static void print_alert(const char *str) { __console_tx_string(1, str); }
+
+static void print_crit_char(unsigned char byte) { __console_tx_char(2, byte); }
+static void print_crit_hex8(unsigned char value) { __console_tx_hex8(2, value); }
+static void print_crit_hex16(unsigned short value){ __console_tx_hex16(2, value); }
+static void print_crit_hex32(unsigned int value) { __console_tx_hex32(2, value); }
+static void print_crit(const char *str) { __console_tx_string(2, str); }
+
+static void print_err_char(unsigned char byte) { __console_tx_char(3, byte); }
+static void print_err_hex8(unsigned char value) { __console_tx_hex8(3, value); }
+static void print_err_hex16(unsigned short value){ __console_tx_hex16(3, value); }
+static void print_err_hex32(unsigned int value) { __console_tx_hex32(3, value); }
+static void print_err(const char *str) { __console_tx_string(3, str); }
+
+static void print_warning_char(unsigned char byte) { __console_tx_char(4, byte); }
+static void print_warning_hex8(unsigned char value) { __console_tx_hex8(4, value); }
+static void print_warning_hex16(unsigned short value){ __console_tx_hex16(4, value); }
+static void print_warning_hex32(unsigned int value) { __console_tx_hex32(4, value); }
+static void print_warning(const char *str) { __console_tx_string(4, str); }
+
+static void print_notice_char(unsigned char byte) { __console_tx_char(5, byte); }
+static void print_notice_hex8(unsigned char value) { __console_tx_hex8(5, value); }
+static void print_notice_hex16(unsigned short value){ __console_tx_hex16(5, value); }
+static void print_notice_hex32(unsigned int value) { __console_tx_hex32(5, value); }
+static void print_notice(const char *str) { __console_tx_string(5, str); }
+
+static void print_info_char(unsigned char byte) { __console_tx_char(6, byte); }
+static void print_info_hex8(unsigned char value) { __console_tx_hex8(6, value); }
+static void print_info_hex16(unsigned short value){ __console_tx_hex16(6, value); }
+static void print_info_hex32(unsigned int value) { __console_tx_hex32(6, value); }
+static void print_info(const char *str) { __console_tx_string(6, str); }
+
+static void print_debug_char(unsigned char byte) { __console_tx_char(7, byte); }
+static void print_debug_hex8(unsigned char value) { __console_tx_hex8(7, value); }
+static void print_debug_hex16(unsigned short value){ __console_tx_hex16(7, value); }
+static void print_debug_hex32(unsigned int value) { __console_tx_hex32(7, value); }
+static void print_debug(const char *str) { __console_tx_string(7, str); }
+
+static void print_spew_char(unsigned char byte) { __console_tx_char(8, byte); }
+static void print_spew_hex8(unsigned char value) { __console_tx_hex8(8, value); }
+static void print_spew_hex16(unsigned short value){ __console_tx_hex16(8, value); }
+static void print_spew_hex32(unsigned int value) { __console_tx_hex32(8, value); }
+static void print_spew(const char *str) { __console_tx_string(8, str); }
+
+static void console_init(void)
+{
+ static const char console_test[] =
+ "\r\n\r\nLinuxBIOS-"
+ "1.1.0"
+ ".0Fallback"
+ " "
+ "Thu Jun 19 05:42:16 MDT 2003"
+ " starting...\r\n";
+ print_info(console_test);
+}
+
+
+static void die(const char *str)
+{
+ print_emerg(str);
+ do {
+ hlt();
+ } while(1);
+}
+
+
+
+
+
+
+
+
+
+static void write_phys(unsigned long addr, unsigned long value)
+{
+
+ asm volatile(
+ "movnti %1, (%0)"
+ :
+ : "r" (addr), "r" (value)
+ :
+ );
+
+
+
+
+
+}
+
+static unsigned long read_phys(unsigned long addr)
+{
+ volatile unsigned long *ptr;
+ ptr = (void *)addr;
+ return *ptr;
+}
+
+static void ram_fill(unsigned long start, unsigned long stop)
+{
+ unsigned long addr;
+
+
+
+ print_debug("DRAM fill: ");
+ print_debug_hex32(start);
+ print_debug("-");
+ print_debug_hex32(stop);
+ print_debug("\r\n");
+ for(addr = start; addr < stop ; addr += 4) {
+
+ if (!(addr & 0xffff)) {
+ print_debug_hex32(addr);
+ print_debug("\r");
+ }
+ write_phys(addr, addr);
+ };
+
+ print_debug_hex32(addr);
+ print_debug("\r\nDRAM filled\r\n");
+}
+
+static void ram_verify(unsigned long start, unsigned long stop)
+{
+ unsigned long addr;
+
+
+
+ print_debug("DRAM verify: ");
+ print_debug_hex32(start);
+ print_debug_char('-');
+ print_debug_hex32(stop);
+ print_debug("\r\n");
+ for(addr = start; addr < stop ; addr += 4) {
+ unsigned long value;
+
+ if (!(addr & 0xffff)) {
+ print_debug_hex32(addr);
+ print_debug("\r");
+ }
+ value = read_phys(addr);
+ if (value != addr) {
+
+ print_err_hex32(addr);
+ print_err_char(':');
+ print_err_hex32(value);
+ print_err("\r\n");
+ }
+ }
+
+ print_debug_hex32(addr);
+ print_debug("\r\nDRAM verified\r\n");
+}
+
+
+void ram_check(unsigned long start, unsigned long stop)
+{
+ int result;
+
+
+
+
+
+ print_debug("Testing DRAM : ");
+ print_debug_hex32(start);
+ print_debug("-");
+ print_debug_hex32(stop);
+ print_debug("\r\n");
+ ram_fill(start, stop);
+ ram_verify(start, stop);
+ print_debug("Done.\n");
+}
+
+
+static void enumerate_ht_chain(void)
+{
+
+
+
+
+
+ unsigned next_unitid, last_unitid;;
+ next_unitid = 1;
+ do {
+ uint32_t id;
+ uint8_t hdr_type, pos;
+ last_unitid = next_unitid;
+
+ id = pci_read_config32(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), 0x00);
+
+ if (((id & 0xffff) == 0x0000) || ((id & 0xffff) == 0xffff) ||
+ (((id >> 16) & 0xffff) == 0xffff) ||
+ (((id >> 16) & 0xffff) == 0x0000)) {
+ break;
+ }
+ hdr_type = pci_read_config8(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), 0x0e);
+ pos = 0;
+ hdr_type &= 0x7f;
+
+ if ((hdr_type == 0) ||
+ (hdr_type == 1)) {
+ pos = pci_read_config8(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), 0x34);
+ }
+ while(pos != 0) {
+ uint8_t cap;
+ cap = pci_read_config8(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), pos + 0);
+ if (cap == 0x08) {
+ uint16_t flags;
+ flags = pci_read_config16(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), pos + 2);
+ if ((flags >> 13) == 0) {
+ unsigned count;
+ flags &= ~0x1f;
+ flags |= next_unitid & 0x1f;
+ count = (flags >> 5) & 0x1f;
+ pci_write_config16(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), pos + 2, flags);
+ next_unitid += count;
+ break;
+ }
+ }
+ pos = pci_read_config8(( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8)), pos + 1);
+ }
+ } while((last_unitid != next_unitid) && (next_unitid <= 0x1f));
+}
+
+
+
+static void enable_smbus(void)
+{
+ device_t dev;
+ dev = pci_locate_device(((((0x746b) & 0xFFFF) << 16) | ((0x1022) & 0xFFFF)), 0);
+ if (dev == (0xffffffffU)) {
+ die("SMBUS controller not found\r\n");
+ }
+ uint8_t enable;
+ print_debug("SMBus controller enabled\r\n");
+ pci_write_config32(dev, 0x58, 0x1000 | 1);
+ enable = pci_read_config8(dev, 0x41);
+ pci_write_config8(dev, 0x41, enable | (1 << 7));
+}
+
+
+static inline void smbus_delay(void)
+{
+ outb(0x80, 0x80);
+}
+
+static int smbus_wait_until_ready(void)
+{
+ unsigned long loops;
+ loops = (100*1000*10);
+ do {
+ unsigned short val;
+ smbus_delay();
+ val = inw(0x1000 + 0xe0);
+ if ((val & 0x800) == 0) {
+ break;
+ }
+ } while(--loops);
+ return loops?0:-1;
+}
+
+static int smbus_wait_until_done(void)
+{
+ unsigned long loops;
+ loops = (100*1000*10);
+ do {
+ unsigned short val;
+ smbus_delay();
+
+ val = inw(0x1000 + 0xe0);
+ if (((val & 0x8) == 0) | ((val & 0x437) != 0)) {
+ break;
+ }
+ } while(--loops);
+ return loops?0:-1;
+}
+
+static int smbus_read_byte(unsigned device, unsigned address)
+{
+ unsigned char global_control_register;
+ unsigned char global_status_register;
+ unsigned char byte;
+
+ if (smbus_wait_until_ready() < 0) {
+ return -1;
+ }
+
+
+
+ outw(inw(0x1000 + 0xe2) & ~((1<<10)|(1<<9)|(1<<8)|(1<<4)), 0x1000 + 0xe2);
+
+ outw(((device & 0x7f) << 1) | 1, 0x1000 + 0xe4);
+
+ outb(address & 0xFF, 0x1000 + 0xe8);
+
+ outw((inw(0x1000 + 0xe2) & ~7) | (0x2), 0x1000 + 0xe2);
+
+
+
+ outw(inw(0x1000 + 0xe0), 0x1000 + 0xe0);
+
+
+ outw(0, 0x1000 + 0xe6);
+
+
+ outw((inw(0x1000 + 0xe2) | (1 << 3)), 0x1000 + 0xe2);
+
+
+
+ if (smbus_wait_until_done() < 0) {
+ return -1;
+ }
+
+ global_status_register = inw(0x1000 + 0xe0);
+
+
+ byte = inw(0x1000 + 0xe6) & 0xff;
+
+ if (global_status_register != (1 << 4)) {
+ return -1;
+ }
+ return byte;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static void setup_resource_map(const unsigned int *register_values, int max)
+{
+ int i;
+ print_debug("setting up resource map....\r\n");
+ for(i = 0; i < max; i += 3) {
+ device_t dev;
+ unsigned where;
+ unsigned long reg;
+
+
+
+
+
+
+ dev = register_values[i] & ~0xff;
+ where = register_values[i] & 0xff;
+ reg = pci_read_config32(dev, where);
+ reg &= register_values[i+1];
+ reg |= register_values[i+2];
+ pci_write_config32(dev, where, reg);
+
+
+
+
+
+
+ }
+ print_debug("done.\r\n");
+}
+
+static void setup_default_resource_map(void)
+{
+ static const unsigned int register_values[] = {
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x44) & 0xFF)), 0x0000f8f8, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x4C) & 0xFF)), 0x0000f8f8, 0x00000001,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x54) & 0xFF)), 0x0000f8f8, 0x00000002,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x5C) & 0xFF)), 0x0000f8f8, 0x00000003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x64) & 0xFF)), 0x0000f8f8, 0x00000004,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x6C) & 0xFF)), 0x0000f8f8, 0x00000005,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x74) & 0xFF)), 0x0000f8f8, 0x00000006,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x7C) & 0xFF)), 0x0000f8f8, 0x00000007,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x40) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x48) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x50) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x58) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x60) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x68) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x70) & 0xFF)), 0x0000f8fc, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x78) & 0xFF)), 0x0000f8fc, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x84) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x8C) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x94) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x9C) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA4) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xAC) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB4) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xBC) & 0xFF)), 0x00000048, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x80) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x88) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x90) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x98) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA0) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA8) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB0) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB8) & 0xFF)), 0x000000f0, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC4) & 0xFF)), 0xFE000FC8, 0x01fff000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xCC) & 0xFF)), 0xFE000FC8, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD4) & 0xFF)), 0xFE000FC8, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xDC) & 0xFF)), 0xFE000FC8, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC0) & 0xFF)), 0xFE000FCC, 0x00000003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC8) & 0xFF)), 0xFE000FCC, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD0) & 0xFF)), 0xFE000FCC, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD8) & 0xFF)), 0xFE000FCC, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE0) & 0xFF)), 0x0000FC88, 0xff000003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE4) & 0xFF)), 0x0000FC88, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE8) & 0xFF)), 0x0000FC88, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xEC) & 0xFF)), 0x0000FC88, 0x00000000,
+ };
+ int max;
+ max = sizeof(register_values)/sizeof(register_values[0]);
+ setup_resource_map(register_values, max);
+}
+
+static void sdram_set_registers(void)
+{
+ static const unsigned int register_values[] = {
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x44) & 0xFF)), 0x0000f8f8, 0x003f0000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x4C) & 0xFF)), 0x0000f8f8, 0x00000001,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x54) & 0xFF)), 0x0000f8f8, 0x00000002,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x5C) & 0xFF)), 0x0000f8f8, 0x00000003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x64) & 0xFF)), 0x0000f8f8, 0x00000004,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x6C) & 0xFF)), 0x0000f8f8, 0x00000005,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x74) & 0xFF)), 0x0000f8f8, 0x00000006,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x7C) & 0xFF)), 0x0000f8f8, 0x00000007,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x40) & 0xFF)), 0x0000f8fc, 0x00000003,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x48) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x50) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x58) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x60) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x68) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x70) & 0xFF)), 0x0000f8fc, 0x00400000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x78) & 0xFF)), 0x0000f8fc, 0x00400000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x84) & 0xFF)), 0x00000048, 0x00e1ff00,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x8C) & 0xFF)), 0x00000048, 0x00dfff00,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x94) & 0xFF)), 0x00000048, 0x00e3ff00,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x9C) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA4) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xAC) & 0xFF)), 0x00000048, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB4) & 0xFF)), 0x00000048, 0x00000b00,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xBC) & 0xFF)), 0x00000048, 0x00fe0b00,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x80) & 0xFF)), 0x000000f0, 0x00e00003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x88) & 0xFF)), 0x000000f0, 0x00d80003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x90) & 0xFF)), 0x000000f0, 0x00e20003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0x98) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA0) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xA8) & 0xFF)), 0x000000f0, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB0) & 0xFF)), 0x000000f0, 0x00000a03,
+
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xB8) & 0xFF)), 0x000000f0, 0x00400003,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC4) & 0xFF)), 0xFE000FC8, 0x0000d000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xCC) & 0xFF)), 0xFE000FC8, 0x000ff000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD4) & 0xFF)), 0xFE000FC8, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xDC) & 0xFF)), 0xFE000FC8, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC0) & 0xFF)), 0xFE000FCC, 0x0000d003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xC8) & 0xFF)), 0xFE000FCC, 0x00001013,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD0) & 0xFF)), 0xFE000FCC, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xD8) & 0xFF)), 0xFE000FCC, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE0) & 0xFF)), 0x0000FC88, 0xff000003,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE4) & 0xFF)), 0x0000FC88, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xE8) & 0xFF)), 0x0000FC88, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((1) & 0x07) << 8) | ((0xEC) & 0xFF)), 0x0000FC88, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x40) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x44) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x48) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x4C) & 0xFF)), 0x001f01fe, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x50) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x54) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x58) & 0xFF)), 0x001f01fe, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x5C) & 0xFF)), 0x001f01fe, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x60) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x64) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x68) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x6C) & 0xFF)), 0xC01f01ff, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x70) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x74) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x78) & 0xFF)), 0xC01f01ff, 0x00000000,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x7C) & 0xFF)), 0xC01f01ff, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x80) & 0xFF)), 0xffff8888, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x88) & 0xFF)), 0xe8088008, 0x03623125,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x8c) & 0xFF)), 0xff8fe08e, 0x00000930,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x90) & 0xFF)), 0xf0000000,
+ (4 << 25)|(0 << 24)|
+ (0 << 23)|(0 << 22)|(0 << 21)|(0 << 20)|
+ (1 << 19)|(1 << 18)|(0 << 17)|(0 << 16)|
+ (2 << 14)|(0 << 13)|(0 << 12)|
+ (0 << 11)|(0 << 10)|(0 << 9)|(0 << 8)|
+ (0 << 3) |(0 << 1) |(0 << 0),
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x94) & 0xFF)), 0xc180f0f0, 0x0e2b0a05,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x07) << 8) | ((0x98) & 0xFF)), 0xfc00ffff, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((3) & 0x07) << 8) | ((0x58) & 0xFF)), 0xffe0e0e0, 0x00000000,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((3) & 0x07) << 8) | ((0x5C) & 0xFF)), 0x0000003e, 0x00000000,
+
+
+
+
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((3) & 0x07) << 8) | ((0x60) & 0xFF)), 0xffffff00, 0x00000000,
+ };
+ int i;
+ int max;
+ print_debug("setting up CPU0 northbridge registers\r\n");
+ max = sizeof(register_values)/sizeof(register_values[0]);
+ for(i = 0; i < max; i += 3) {
+ device_t dev;
+ unsigned where;
+ unsigned long reg;
+
+
+
+
+
+
+ dev = register_values[i] & ~0xff;
+ where = register_values[i] & 0xff;
+ reg = pci_read_config32(dev, where);
+ reg &= register_values[i+1];
+ reg |= register_values[i+2];
+ pci_write_config32(dev, where, reg);
+
+
+
+
+
+
+
+ }
+ print_debug("done.\r\n");
+}
+
+
+struct dimm_size {
+ unsigned long side1;
+ unsigned long side2;
+};
+static struct dimm_size spd_get_dimm_size(unsigned device)
+{
+
+ struct dimm_size sz;
+ int value, low;
+ sz.side1 = 0;
+ sz.side2 = 0;
+
+
+
+
+
+ value = smbus_read_byte(device, 3);
+ if (value < 0) return sz;
+ sz.side1 += value & 0xf;
+
+ value = smbus_read_byte(device, 4);
+ if (value < 0) return sz;
+ sz.side1 += value & 0xf;
+
+ value = smbus_read_byte(device, 17);
+ if (value < 0) return sz;
+ sz.side1 += log2(value & 0xff);
+
+
+ value = smbus_read_byte(device, 7);
+ if (value < 0) return sz;
+ value &= 0xff;
+ value <<= 8;
+
+ low = smbus_read_byte(device, 6);
+ if (low < 0) return sz;
+ value = value | (low & 0xff);
+ sz.side1 += log2(value);
+
+
+ value = smbus_read_byte(device, 5);
+ if (value <= 1) return sz;
+
+
+ sz.side2 = sz.side1;
+
+ value = smbus_read_byte(device, 3);
+ if (value < 0) return sz;
+ if ((value & 0xf0) == 0) return sz;
+ sz.side2 -= (value & 0x0f);
+ sz.side2 += ((value >> 4) & 0x0f);
+
+ value = smbus_read_byte(device, 4);
+ if (value < 0) return sz;
+ sz.side2 -= (value & 0x0f);
+ sz.side2 += ((value >> 4) & 0x0f);
+ return sz;
+}
+
+static unsigned spd_to_dimm(unsigned device)
+{
+ return (device - (0xa << 3));
+}
+
+static void set_dimm_size(struct dimm_size sz, unsigned index)
+{
+ uint32_t base0, base1, map;
+
+
+ print_debug("set_dimm_size: (");
+ print_debug_hex32(sz.side1);
+ print_debug_char(',');
+ print_debug_hex32(sz.side2);
+ print_debug_char(',');
+ print_debug_hex32(index);
+ print_debug(")\r\n");
+
+ if (sz.side1 != sz.side2) {
+ sz.side2 = 0;
+ }
+ map = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x80);
+ map &= ~(0xf << (index + 4));
+
+
+
+
+
+
+
+ base0 = base1 = 0;
+
+
+ if (sz.side1 >= (25 + 3)) {
+ base0 = (1 << ((sz.side1 - (25 + 3)) + 21)) | 1;
+ map |= (sz.side1 - (25 + 3)) << (index *4);
+ }
+
+
+ if (sz.side2 >= (25 + 3)) {
+ base1 = (1 << ((sz.side2 - (25 + 3)) + 21)) | 1;
+ }
+
+
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x40 + (((index << 1)+0)<<2), base0);
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x40 + (((index << 1)+1)<<2), base1);
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x80, map);
+}
+
+static void spd_set_ram_size(void)
+{
+ unsigned device;
+ for(device = (0xa << 3);
+ device <= ((0xa << 3) +1);
+ device += 1)
+ {
+ struct dimm_size sz;
+ sz = spd_get_dimm_size(device);
+ set_dimm_size(sz, spd_to_dimm(device));
+ }
+}
+
+static void set_top_mem(unsigned tom_k)
+{
+
+ if (!tom_k) {
+ die("No memory");
+ }
+
+ msr_t msr;
+ msr.lo = (tom_k & 0x003fffff) << 10;
+ msr.hi = (tom_k & 0xffc00000) >> 22;
+ wrmsr(0xC001001A, msr);
+
+
+
+
+
+
+
+}
+
+static void order_dimms(void)
+{
+ unsigned long tom;
+ unsigned mask;
+ unsigned index;
+
+
+ tom = 0;
+ for(;;) {
+
+ unsigned canidate;
+ uint32_t csbase, csmask;
+ unsigned size;
+ csbase = 0;
+ canidate = 0;
+ for(index = 0; index < 8; index++) {
+ uint32_t value;
+ value = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x40 + (index << 2));
+
+
+ if (!(value & 1)) {
+ continue;
+ }
+
+
+ if (value <= csbase) {
+ continue;
+ }
+
+
+ if (tom & (1 << (index + 24))) {
+ continue;
+ }
+
+ csbase = value;
+ canidate = index;
+ }
+
+ if (csbase == 0) {
+ break;
+ }
+
+
+ tom |= (1 << (canidate + 24));
+
+
+ size = csbase >> 21;
+
+
+ csbase = (tom << 21) | 1;
+
+
+ tom += size;
+
+
+ csmask = ((size -1) << 21);
+ csmask |= 0xfe00;
+
+
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x40 + (canidate << 2), csbase);
+
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x60 + (canidate << 2), csmask);
+
+ }
+ set_top_mem((tom & ~0xff000000) << 15);
+}
+
+static void spd_set_dram_timing(void)
+{
+
+}
+
+static void spd_set_ecc_mode(void)
+{
+ unsigned long dcl;
+ dcl = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90);
+
+ dcl &= ~(1<<17);
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90, dcl);
+
+}
+static void sdram_set_spd_registers(void)
+{
+ spd_set_ram_size();
+ spd_set_dram_timing();
+ spd_set_ecc_mode();
+ order_dimms();
+}
+
+
+static void sdram_enable(void)
+{
+ unsigned long dcl;
+
+
+ dcl = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90);
+ print_debug("dcl: ");
+ print_debug_hex32(dcl);
+ print_debug("\r\n");
+ dcl |= (1<<3);
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90, dcl);
+ dcl &= ~(1<<3);
+ dcl &= ~(1<<0);
+ dcl &= ~(1<<1);
+ dcl &= ~(1<<2);
+ dcl |= (1<<8);
+ pci_write_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90, dcl);
+
+ print_debug("Initializing memory: ");
+ int loops = 0;
+ do {
+ dcl = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)), 0x90);
+ loops += 1;
+ if ((loops & 1023) == 0) {
+ print_debug(".");
+ }
+ } while(((dcl & (1<<8)) != 0) && (loops < 300000));
+ if (loops >= 300000) {
+ print_debug(" failed\r\n");
+ } else {
+ print_debug(" done\r\n");
+ }
+
+}
+
+static void sdram_first_normal_reference(void) {}
+static void sdram_enable_refresh(void) {}
+static void sdram_special_finishup(void) {}
+
+
+static void setup_coherent_ht_domain(void)
+{
+ static const unsigned int register_values[] = {
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x40) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x44) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x48) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x4c) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x50) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x54) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x58) & 0xFF)), 0xfff0f0f0, 0x00010101,
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x5c) & 0xFF)), 0xfff0f0f0, 0x00010101,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x68) & 0xFF)), 0x00800000, 0x0f00840f,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x6C) & 0xFF)), 0xffffff8c, 0x00000000 | (1 << 6) |(1 << 5)| (1 << 4),
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x84) & 0xFF)), 0x00009c05, 0x11110020,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x88) & 0xFF)), 0xfffff0ff, 0x00000200,
+
+ ( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x07) << 8) | ((0x94) & 0xFF)), 0xff000000, 0x00ff0000,
+
+
+
+
+
+ };
+ int i;
+ int max;
+ print_debug("setting up coherent ht domain....\r\n");
+ max = sizeof(register_values)/sizeof(register_values[0]);
+ for(i = 0; i < max; i += 3) {
+ device_t dev;
+ unsigned where;
+ unsigned long reg;
+
+
+
+
+
+
+ dev = register_values[i] & ~0xff;
+ where = register_values[i] & 0xff;
+ reg = pci_read_config32(dev, where);
+ reg &= register_values[i+1];
+ reg |= register_values[i+2];
+ pci_write_config32(dev, where, reg);
+
+
+
+
+
+
+ }
+ print_debug("done.\r\n");
+}
+
+
+void sdram_no_memory(void)
+{
+ print_err("No memory!!\r\n");
+ while(1) {
+ hlt();
+ }
+}
+
+
+void sdram_initialize(void)
+{
+ print_debug("Ram1\r\n");
+
+ sdram_set_registers();
+
+ print_debug("Ram2\r\n");
+
+ sdram_set_spd_registers();
+
+ print_debug("Ram3\r\n");
+
+
+
+
+ sdram_enable();
+
+ print_debug("Ram4\r\n");
+ sdram_first_normal_reference();
+
+ print_debug("Ram5\r\n");
+ sdram_enable_refresh();
+ sdram_special_finishup();
+
+ print_debug("Ram6\r\n");
+}
+
+
+static int boot_cpu(void)
+{
+ volatile unsigned long *local_apic;
+ unsigned long apic_id;
+ int bsp;
+ msr_t msr;
+ msr = rdmsr(0x1b);
+ bsp = !!(msr.lo & (1 << 8));
+ if (bsp) {
+ print_debug("Bootstrap processor\r\n");
+ } else {
+ print_debug("Application processor\r\n");
+ }
+
+ return bsp;
+}
+
+static int cpu_init_detected(void)
+{
+ unsigned long dcl;
+ int cpu_init;
+
+ unsigned long htic;
+
+ htic = pci_read_config32(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((0) & 0x7) << 8)), 0x6c);
+
+ cpu_init = (htic & (1<<6));
+ if (cpu_init) {
+ print_debug("CPU INIT Detected.\r\n");
+ }
+ return cpu_init;
+}
+
+
+static void print_debug_pci_dev(unsigned dev)
+{
+ print_debug("PCI: ");
+ print_debug_hex8((dev >> 16) & 0xff);
+ print_debug_char(':');
+ print_debug_hex8((dev >> 11) & 0x1f);
+ print_debug_char('.');
+ print_debug_hex8((dev >> 8) & 7);
+}
+
+static void print_pci_devices(void)
+{
+ device_t dev;
+ for(dev = ( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((0) & 0x7) << 8));
+ dev <= ( (((0) & 0xFF) << 16) | (((0x1f) & 0x1f) << 11) | (((0x7) & 0x7) << 8));
+ dev += ( (((0) & 0xFF) << 16) | (((0) & 0x1f) << 11) | (((1) & 0x7) << 8))) {
+ uint32_t id;
+ id = pci_read_config32(dev, 0x00);
+ if (((id & 0xffff) == 0x0000) || ((id & 0xffff) == 0xffff) ||
+ (((id >> 16) & 0xffff) == 0xffff) ||
+ (((id >> 16) & 0xffff) == 0x0000)) {
+ continue;
+ }
+ print_debug_pci_dev(dev);
+ print_debug("\r\n");
+ }
+}
+
+
+static void dump_pci_device(unsigned dev)
+{
+ int i;
+ print_debug_pci_dev(dev);
+ print_debug("\r\n");
+
+ for(i = 0; i <= 255; i++) {
+ unsigned char val;
+ if ((i & 0x0f) == 0) {
+ print_debug_hex8(i);
+ print_debug_char(':');
+ }
+ val = pci_read_config8(dev, i);
+ print_debug_char(' ');
+ print_debug_hex8(val);
+ if ((i & 0x0f) == 0x0f) {
+ print_debug("\r\n");
+ }
+ }
+}
+
+static void dump_spd_registers(void)
+{
+ unsigned device;
+ device = (0xa << 3);
+ print_debug("\r\n");
+ while(device <= ((0xa << 3) +1)) {
+ int i;
+ print_debug("dimm: ");
+ print_debug_hex8(device);
+ for(i = 0; i < 256; i++) {
+ int status;
+ unsigned char byte;
+ if ((i & 0xf) == 0) {
+ print_debug("\r\n");
+ print_debug_hex8(i);
+ print_debug(": ");
+ }
+ status = smbus_read_byte(device, i);
+ if (status < 0) {
+ print_debug("bad device\r\n");
+ break;
+ }
+ byte = status & 0xff;
+ print_debug_hex8(byte);
+ print_debug_char(' ');
+ }
+ device += 1;
+ print_debug("\r\n");
+ }
+}
+
+
+static void main(void)
+{
+ uart_init();
+ console_init();
+
+
+
+
+
+
+
+ if (boot_cpu() && !cpu_init_detected()) {
+ setup_default_resource_map();
+ setup_coherent_ht_domain();
+ enumerate_ht_chain();
+ print_pci_devices();
+ enable_smbus();
+ sdram_initialize();
+
+ dump_spd_registers();
+ dump_pci_device(( (((0) & 0xFF) << 16) | (((0x18) & 0x1f) << 11) | (((2) & 0x7) << 8)));
+
+
+ msr_t msr;
+ msr = rdmsr(0xC001001A);
+ print_debug("TOP_MEM: ");
+ print_debug_hex32(msr.hi);
+ print_debug_hex32(msr.lo);
+ print_debug("\r\n");
+ ram_check(0x00000000, msr.lo);
+ }
+}
--- /dev/null
+struct syscall_result {
+ long val;
+ int errno;
+};
+
+static struct syscall_result syscall_return(long result)
+{
+ struct syscall_result res;
+ if (((unsigned long)result) >= ((unsigned long)-125)) {
+ res.errno = - result;
+ res.val = -1;
+ } else {
+ res.errno = 0;
+ res.val = result;
+ }
+ return res;
+}
+
+static struct syscall_result syscall0(unsigned long nr)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr));
+ return syscall_return(res);
+}
+
+static struct syscall_result syscall1(unsigned long nr, unsigned long arg1)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr), "b" (arg1));
+ return syscall_return(res);
+
+}
+
+static struct syscall_result syscall2(unsigned long nr, unsigned long arg1, unsigned long arg2)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr), "b" (arg1), "c" (arg2));
+ return syscall_return(res);
+
+}
+
+
+static struct syscall_result syscall3(unsigned long nr, unsigned long arg1, unsigned long arg2,
+ unsigned long arg3)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr), "b" (arg1), "c" (arg2), "d" (arg3));
+ return syscall_return(res);
+
+}
+
+static struct syscall_result syscall4(unsigned long nr, unsigned long arg1, unsigned long arg2,
+ unsigned long arg3, unsigned long arg4)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr), "b" (arg1), "c" (arg2), "d" (arg3), "S" (arg4));
+ return syscall_return(res);
+
+}
+
+static struct syscall_result syscall5(unsigned long nr, unsigned long arg1, unsigned long arg2,
+ unsigned long arg3, unsigned long arg4, unsigned long arg5)
+{
+ long res;
+ asm volatile(
+ "int $0x80"
+ : "=a" (res)
+ : "a" (nr), "b" (arg1), "c" (arg2), "d" (arg3),
+ "S" (arg4), "D" (arg5));
+ return syscall_return(res);
+
+}
+
+#define NR_exit 1
+#define NR_fork 2
+#define NR_read 3
+#define NR_write 4
+#define NR_open 5
+#define NR_close 6
+#define NR_waitpid 7
+#define NR_creat 8
+#define NR_link 9
+#define NR_unlink 10
+#define NR_execve 11
+#define NR_chdir 12
+#define NR_time 13
+#define NR_mknod 14
+#define NR_chmod 15
+#define NR_lchown 16
+#define NR_break 17
+#define NR_oldstat 18
+#define NR_lseek 19
+#define NR_getpid 20
+#define NR_mount 21
+#define NR_umount 22
+#define NR_setuid 23
+#define NR_getuid 24
+#define NR_stime 25
+#define NR_ptrace 26
+#define NR_alarm 27
+#define NR_oldfstat 28
+#define NR_pause 29
+#define NR_utime 30
+#define NR_stty 31
+#define NR_gtty 32
+#define NR_access 33
+#define NR_nice 34
+#define NR_ftime 35
+#define NR_sync 36
+#define NR_kill 37
+#define NR_rename 38
+#define NR_mkdir 39
+#define NR_rmdir 40
+#define NR_dup 41
+#define NR_pipe 42
+#define NR_times 43
+#define NR_prof 44
+#define NR_brk 45
+#define NR_setgid 46
+#define NR_getgid 47
+#define NR_signal 48
+#define NR_geteuid 49
+#define NR_getegid 50
+#define NR_acct 51
+#define NR_umount2 52
+#define NR_lock 53
+#define NR_ioctl 54
+#define NR_fcntl 55
+#define NR_mpx 56
+#define NR_setpgid 57
+#define NR_ulimit 58
+#define NR_oldolduname 59
+#define NR_umask 60
+#define NR_chroot 61
+#define NR_ustat 62
+#define NR_dup2 63
+#define NR_getppid 64
+#define NR_getpgrp 65
+#define NR_setsid 66
+#define NR_sigaction 67
+#define NR_sgetmask 68
+#define NR_ssetmask 69
+#define NR_setreuid 70
+#define NR_setregid 71
+#define NR_sigsuspend 72
+#define NR_sigpending 73
+#define NR_sethostname 74
+#define NR_setrlimit 75
+#define NR_getrlimit 76
+#define NR_getrusage 77
+#define NR_gettimeofday 78
+#define NR_settimeofday 79
+#define NR_getgroups 80
+#define NR_setgroups 81
+#define NR_select 82
+#define NR_symlink 83
+#define NR_oldlstat 84
+#define NR_readlink 85
+#define NR_uselib 86
+#define NR_swapon 87
+#define NR_reboot 88
+#define NR_readdir 89
+#define NR_mmap 90
+#define NR_munmap 91
+#define NR_truncate 92
+#define NR_ftruncate 93
+#define NR_fchmod 94
+#define NR_fchown 95
+#define NR_getpriority 96
+#define NR_setpriority 97
+#define NR_profil 98
+#define NR_statfs 99
+#define NR_fstatfs 100
+#define NR_ioperm 101
+#define NR_socketcall 102
+#define NR_syslog 103
+#define NR_setitimer 104
+#define NR_getitimer 105
+#define NR_stat 106
+#define NR_lstat 107
+#define NR_fstat 108
+#define NR_olduname 109
+#define NR_iopl 110
+#define NR_vhangup 111
+#define NR_idle 112
+#define NR_vm86old 113
+#define NR_wait4 114
+#define NR_swapoff 115
+#define NR_sysinfo 116
+#define NR_ipc 117
+#define NR_fsync 118
+#define NR_sigreturn 119
+#define NR_clone 120
+#define NR_setdomainname 121
+#define NR_uname 122
+#define NR_modify_ldt 123
+#define NR_adjtimex 124
+#define NR_mprotect 125
+#define NR_sigprocmask 126
+#define NR_create_module 127
+#define NR_init_module 128
+#define NR_delete_module 129
+#define NR_get_kernel_syms 130
+#define NR_quotactl 131
+#define NR_getpgid 132
+#define NR_fchdir 133
+#define NR_bdflush 134
+#define NR_sysfs 135
+#define NR_personality 136
+#define NR_afs_syscall 137 /* Syscall for Andrew File System */
+#define NR_setfsuid 138
+#define NR_setfsgid 139
+#define NR__llseek 140
+#define NR_getdents 141
+#define NR__newselect 142
+#define NR_flock 143
+#define NR_msync 144
+#define NR_readv 145
+#define NR_writev 146
+#define NR_getsid 147
+#define NR_fdatasync 148
+#define NR__sysctl 149
+#define NR_mlock 150
+#define NR_munlock 151
+#define NR_mlockall 152
+#define NR_munlockall 153
+#define NR_sched_setparam 154
+#define NR_sched_getparam 155
+#define NR_sched_setscheduler 156
+#define NR_sched_getscheduler 157
+#define NR_sched_yield 158
+#define NR_sched_get_priority_max 159
+#define NR_sched_get_priority_min 160
+#define NR_sched_rr_get_interval 161
+#define NR_nanosleep 162
+#define NR_mremap 163
+#define NR_setresuid 164
+#define NR_getresuid 165
+#define NR_vm86 166
+#define NR_query_module 167
+#define NR_poll 168
+#define NR_nfsservctl 169
+#define NR_setresgid 170
+#define NR_getresgid 171
+#define NR_prctl 172
+#define NR_rt_sigreturn 173
+#define NR_rt_sigaction 174
+#define NR_rt_sigprocmask 175
+#define NR_rt_sigpending 176
+#define NR_rt_sigtimedwait 177
+#define NR_rt_sigqueueinfo 178
+#define NR_rt_sigsuspend 179
+#define NR_pread 180
+#define NR_pwrite 181
+#define NR_chown 182
+#define NR_getcwd 183
+#define NR_capget 184
+#define NR_capset 185
+#define NR_sigaltstack 186
+#define NR_sendfile 187
+#define NR_getpmsg 188 /* some people actually want streams */
+#define NR_putpmsg 189 /* some people actually want streams */
+#define NR_vfork 190
+
+typedef long ssize_t;
+typedef unsigned long size_t;
+
+/* Standard file descriptors */
+#define STDIN_FILENO 0 /* Standard input */
+#define STDOUT_FILENO 1 /* Standard output */
+#define STDERR_FILENO 2 /* Standard error output */
+
+static ssize_t write(int fd, const void *buf, size_t count)
+{
+ struct syscall_result res;
+ res = syscall3(NR_write, fd, (unsigned long)buf, count);
+ return res.val;
+}
+
+static void _exit(int status)
+{
+ struct syscall_result res;
+ res = syscall1(NR_exit, status);
+}
+
+static const char *addr_of_char(unsigned char ch)
+{
+ static const char byte[] = {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
+ 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+ 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+ 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+ 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
+ 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+ 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+ 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
+ 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+ 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+ 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+ 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
+ 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+ 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
+ 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+ 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+ 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+ 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+ 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+ 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+ 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+ 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+ 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+ 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+ 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+ 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+ 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+ 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+ 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+ };
+ return byte + ch;
+}
+
+static void console_tx_byte(unsigned char ch)
+{
+ write(STDOUT_FILENO, addr_of_char(ch), 1);
+}
+
+static void console_tx_nibble(unsigned nibble)
+{
+ unsigned char digit;
+ digit = nibble + '0';
+ if (digit > '9') {
+ digit += 39;
+ }
+ console_tx_byte(digit);
+}
+
+static void console_tx_char(unsigned char byte)
+{
+ console_tx_byte(byte);
+}
+
+static void console_tx_hex8(unsigned char value)
+{
+ console_tx_nibble((value >> 4U) & 0x0fU);
+ console_tx_nibble(value & 0x0fU);
+}
+
+static void console_tx_hex16(unsigned short value)
+{
+ console_tx_nibble((value >> 12U) & 0x0FU);
+ console_tx_nibble((value >> 8U) & 0x0FU);
+ console_tx_nibble((value >> 4U) & 0x0FU);
+ console_tx_nibble(value & 0x0FU);
+}
+
+static void console_tx_hex32(unsigned short value)
+{
+ console_tx_nibble((value >> 28U) & 0x0FU);
+ console_tx_nibble((value >> 24U) & 0x0FU);
+ console_tx_nibble((value >> 20U) & 0x0FU);
+ console_tx_nibble((value >> 16U) & 0x0FU);
+ console_tx_nibble((value >> 12U) & 0x0FU);
+ console_tx_nibble((value >> 8U) & 0x0FU);
+ console_tx_nibble((value >> 4U) & 0x0FU);
+ console_tx_nibble(value & 0x0FU);
+}
+
+static void console_tx_string(const char *str)
+{
+ unsigned char ch;
+ while((ch = *str++) != '\0') {
+ console_tx_byte(ch);
+ }
+}
+
+static void print_emerg_char(unsigned char byte) { console_tx_char(byte); }
+static void print_emerg_hex8(unsigned char value) { console_tx_hex8(value); }
+static void print_emerg_hex16(unsigned short value){ console_tx_hex16(value); }
+static void print_emerg_hex32(unsigned int value) { console_tx_hex32(value); }
+static void print_emerg(const char *str) { console_tx_string(str); }
+
+static void print_debug_char(unsigned char byte) { console_tx_char(byte); }
+static void print_debug_hex8(unsigned char value) { console_tx_hex8(value); }
+static void print_debug_hex16(unsigned short value){ console_tx_hex16(value); }
+static void print_debug_hex32(unsigned int value) { console_tx_hex32(value); }
+static void print_debug(const char *str) { console_tx_string(str); }
+
+
+int log2(int value)
+{
+ /* __builtin_bsr is a exactly equivalent to the x86 machine
+ * instruction with the exception that it returns -1
+ * when the value presented to it is zero.
+ * Otherwise __builtin_bsr returns the zero based index of
+ * the highest bit set.
+ */
+ return __builtin_bsr(value);
+}
+
+
+static void die(const char *str)
+{
+ print_emerg(str);
+ do {
+ asm(" ");
+ } while(1);
+
+}
+
+static int smbus_read_byte(unsigned device, unsigned address)
+{
+ static const unsigned char dimm[] = {
+0x80, 0x08, 0x07, 0x0d, 0x0a, 0x02, 0x48, 0x00, 0x04, 0x60, 0x70, 0x02, 0x82, 0x08, 0x08, 0x01,
+0x0e, 0x04, 0x0c, 0x01, 0x02, 0x20, 0x00, 0x75, 0x70, 0x00, 0x00, 0x48, 0x30, 0x48, 0x2a, 0x40,
+0x80, 0x80, 0x45, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+
+0x80, 0x08, 0x07, 0x0d, 0x0a, 0x02, 0x48, 0x00, 0x04, 0x60, 0x70, 0x02, 0x82, 0x08, 0x08, 0x01,
+0x0e, 0x04, 0x0c, 0x01, 0x02, 0x20, 0x00, 0x75, 0x70, 0x00, 0x00, 0x48, 0x30, 0x48, 0x2a, 0x40,
+0x80, 0x80, 0x45, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ };
+ return dimm[(device << 8) + address];
+}
+
+#define SMBUS_MEM_DEVICE_START 0x00
+#define SMBUS_MEM_DEVICE_END 0x01
+#define SMBUS_MEM_DEVICE_INC 1
+
+/* Function 2 */
+#define DRAM_CONFIG_HIGH 0x94
+#define DCH_MEMCLK_SHIFT 20
+#define DCH_MEMCLK_MASK 7
+#define DCH_MEMCLK_100MHZ 0
+#define DCH_MEMCLK_133MHZ 2
+#define DCH_MEMCLK_166MHZ 5
+#define DCH_MEMCLK_200MHZ 7
+
+/* Function 3 */
+#define NORTHBRIDGE_CAP 0xE8
+#define NBCAP_128Bit 0x0001
+#define NBCAP_MP 0x0002
+#define NBCAP_BIG_MP 0x0004
+#define NBCAP_ECC 0x0004
+#define NBCAP_CHIPKILL_ECC 0x0010
+#define NBCAP_MEMCLK_SHIFT 5
+#define NBCAP_MEMCLK_MASK 3
+#define NBCAP_MEMCLK_100MHZ 3
+#define NBCAP_MEMCLK_133MHZ 2
+#define NBCAP_MEMCLK_166MHZ 1
+#define NBCAP_MEMCLK_200MHZ 0
+#define NBCAP_MEMCTRL 0x0100
+
+typedef unsigned char uint8_t;
+typedef unsigned int uint32_t;
+
+static unsigned spd_to_dimm(unsigned device)
+{
+ return (device - SMBUS_MEM_DEVICE_START);
+}
+
+static void disable_dimm(unsigned index)
+{
+ print_debug("disabling dimm");
+ print_debug_hex8(index);
+ print_debug("\r\n");
+#if 0
+ pci_write_config32(PCI_DEV(0, 0x18, 2), DRAM_CSBASE + (((index << 1)+0)<<2), 0);
+ pci_write_config32(PCI_DEV(0, 0x18, 2), DRAM_CSBASE + (((index << 1)+1)<<2), 0);
+#endif
+}
+
+
+struct mem_param {
+ uint8_t cycle_time;
+ uint32_t dch_memclk;
+};
+
+static const struct mem_param *get_mem_param(unsigned min_cycle_time)
+{
+ static const struct mem_param speed[] = {
+ {
+ .cycle_time = 0xa0,
+ .dch_memclk = DCH_MEMCLK_100MHZ << DCH_MEMCLK_SHIFT,
+ },
+ {
+ .cycle_time = 0x75,
+ .dch_memclk = DCH_MEMCLK_133MHZ << DCH_MEMCLK_SHIFT,
+ },
+ {
+ .cycle_time = 0x60,
+ .dch_memclk = DCH_MEMCLK_166MHZ << DCH_MEMCLK_SHIFT,
+ },
+ {
+ .cycle_time = 0x50,
+ .dch_memclk = DCH_MEMCLK_200MHZ << DCH_MEMCLK_SHIFT,
+ },
+ {
+ .cycle_time = 0x00,
+ },
+ };
+ const struct mem_param *param;
+ for(param = &speed[0]; param->cycle_time ; param++) {
+ if (min_cycle_time > (param+1)->cycle_time) {
+ break;
+ }
+ }
+ if (!param->cycle_time) {
+ die("min_cycle_time to low");
+ }
+ return param;
+}
+
+#if 1
+static void debug(int c)
+{
+ print_debug_char(c);
+ print_debug_char('\r');
+ print_debug_char('\n');
+}
+#endif
+static const struct mem_param *spd_set_memclk(void)
+{
+ /* Compute the minimum cycle time for these dimms */
+ const struct mem_param *param;
+ unsigned min_cycle_time, min_latency;
+ unsigned device;
+ uint32_t value;
+
+ static const int latency_indicies[] = { 26, 23, 9 };
+ static const unsigned char min_cycle_times[] = {
+ [NBCAP_MEMCLK_200MHZ] = 0x50, /* 5ns */
+ [NBCAP_MEMCLK_166MHZ] = 0x60, /* 6ns */
+ [NBCAP_MEMCLK_133MHZ] = 0x75, /* 7.5ns */
+ [NBCAP_MEMCLK_100MHZ] = 0xa0, /* 10ns */
+ };
+
+
+#if 0
+ value = pci_read_config32(PCI_DEV(0, 0x18, 3), NORTHBRIDGE_CAP);
+#else
+ value = 0x50;
+#endif
+ min_cycle_time = min_cycle_times[(value >> NBCAP_MEMCLK_SHIFT) & NBCAP_MEMCLK_MASK];
+ min_latency = 2;
+
+#if 1
+ print_debug("min_cycle_time: ");
+ print_debug_hex8(min_cycle_time);
+ print_debug(" min_latency: ");
+ print_debug_hex8(min_latency);
+ print_debug("\r\n");
+#endif
+
+ /* Compute the least latency with the fastest clock supported
+ * by both the memory controller and the dimms.
+ */
+ for(device = SMBUS_MEM_DEVICE_START;
+ device <= SMBUS_MEM_DEVICE_END;
+ device += SMBUS_MEM_DEVICE_INC)
+ {
+ int new_cycle_time, new_latency;
+ int index;
+ int latencies;
+ int latency;
+
+ debug('A');
+ /* First find the supported CAS latencies
+ * Byte 18 for DDR SDRAM is interpreted:
+ * bit 0 == CAS Latency = 1.0
+ * bit 1 == CAS Latency = 1.5
+ * bit 2 == CAS Latency = 2.0
+ * bit 3 == CAS Latency = 2.5
+ * bit 4 == CAS Latency = 3.0
+ * bit 5 == CAS Latency = 3.5
+ * bit 6 == TBD
+ * bit 7 == TBD
+ */
+ new_cycle_time = 0xa0;
+ new_latency = 5;
+
+ latencies = smbus_read_byte(device, 18);
+ if (latencies <= 0) continue;
+
+ debug('B');
+ /* Compute the lowest cas latency supported */
+ latency = log2(latencies) -2;
+
+ /* Loop through and find a fast clock with a low latency */
+ for(index = 0; index < 3; index++, latency++) {
+ int value;
+ debug('C');
+ if ((latency < 2) || (latency > 4) ||
+ (!(latencies & (1 << latency)))) {
+ continue;
+ }
+ debug('D');
+ value = smbus_read_byte(device, latency_indicies[index]);
+ if (value < 0) continue;
+
+ debug('E');
+ /* Only increase the latency if we decreas the clock */
+ if ((value >= min_cycle_time) && (value < new_cycle_time)) {
+ new_cycle_time = value;
+ new_latency = latency;
+#if 1
+ print_debug("device: ");
+ print_debug_hex8(device);
+ print_debug(" new_cycle_time: ");
+ print_debug_hex8(new_cycle_time);
+ print_debug(" new_latency: ");
+ print_debug_hex8(new_latency);
+ print_debug("\r\n");
+#endif
+ }
+ debug('G');
+ }
+ debug('H');
+#if 1
+ print_debug("device: ");
+ print_debug_hex8(device);
+ print_debug(" new_cycle_time: ");
+ print_debug_hex8(new_cycle_time);
+ print_debug(" new_latency: ");
+ print_debug_hex8(new_latency);
+ print_debug("\r\n");
+#endif
+ if (new_latency > 4){
+ continue;
+ }
+ debug('I');
+ /* Does min_latency need to be increased? */
+ if (new_cycle_time > min_cycle_time) {
+ min_cycle_time = new_cycle_time;
+ }
+ /* Does min_cycle_time need to be increased? */
+ if (new_latency > min_latency) {
+ min_latency = new_latency;
+ }
+#if 1
+ print_debug("device: ");
+ print_debug_hex8(device);
+ print_debug(" min_cycle_time: ");
+ print_debug_hex8(min_cycle_time);
+ print_debug(" min_latency: ");
+ print_debug_hex8(min_latency);
+ print_debug("\r\n");
+#endif
+ }
+ /* Make a second pass through the dimms and disable
+ * any that cannot support the selected memclk and cas latency.
+ */
+ for(device = SMBUS_MEM_DEVICE_START;
+ device <= SMBUS_MEM_DEVICE_END;
+ device += SMBUS_MEM_DEVICE_INC)
+ {
+ int latencies;
+ int latency;
+ int index;
+ int value;
+ int dimm;
+ latencies = smbus_read_byte(device, 18);
+ if (latencies <= 0) {
+ goto dimm_err;
+ }
+
+ /* Compute the lowest cas latency supported */
+ latency = log2(latencies) -2;
+
+ /* Walk through searching for the selected latency */
+ for(index = 0; index < 3; index++, latency++) {
+ if (!(latencies & (1 << latency))) {
+ continue;
+ }
+ if (latency == min_latency)
+ break;
+ }
+ /* If I can't find the latency or my index is bad error */
+ if ((latency != min_latency) || (index >= 3)) {
+ goto dimm_err;
+ }
+
+ /* Read the min_cycle_time for this latency */
+ value = smbus_read_byte(device, latency_indicies[index]);
+
+ /* All is good if the selected clock speed
+ * is what I need or slower.
+ */
+ if (value <= min_cycle_time) {
+ continue;
+ }
+ /* Otherwise I have an error, disable the dimm */
+ dimm_err:
+ disable_dimm(spd_to_dimm(device));
+ }
+#if 1
+ print_debug("min_cycle_time: ");
+ print_debug_hex8(min_cycle_time);
+ print_debug(" min_latency: ");
+ print_debug_hex8(min_latency);
+ print_debug("\r\n");
+#endif
+ /* Now that I know the minimum cycle time lookup the memory parameters */
+ param = get_mem_param(min_cycle_time);
+
+#if 0
+ /* Update DRAM Config High with our selected memory speed */
+ value = pci_read_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_HIGH);
+ value &= ~(DCH_MEMCLK_MASK << DCH_MEMCLK_SHIFT);
+ value |= param->dch_memclk;
+ pci_write_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_HIGH, value);
+
+ static const unsigned latencies[] = { 1, 5, 2 };
+ /* Update DRAM Timing Low wiht our selected cas latency */
+ value = pci_read_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_LOW);
+ value &= ~7;
+ value |= latencies[min_latency - 2];
+ pci_write_config32(PCI_DEV(0, 0x18, 2), DRAM_CONFIG_LOW, value);
+#endif
+
+ return param;
+}
+
+static void main(void)
+{
+ const struct mem_param *param;
+ param = spd_set_memclk();
+ _exit(0);
+}
projects / coreboot.git / commitdiff