/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* @author Matthias Braun, Mehdi
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
#include <limits.h>
/**
* Returns the register at in position pos.
*/
-static const arch_register_t *get_in_reg(const arch_env_t *arch_env,
- const ir_node *node, int pos)
+static const arch_register_t *get_in_reg(const ir_node *node, int pos)
{
ir_node *op;
const arch_register_t *reg = NULL;
in register we need. */
op = get_irn_n(node, pos);
- reg = arch_get_irn_register(arch_env, op);
+ reg = arch_get_irn_register(op);
assert(reg && "no in register found");
return reg;
/**
* Returns the register at out position pos.
*/
-static const arch_register_t *get_out_reg(const arch_env_t *arch_env,
- const ir_node *node, int pos)
+static const arch_register_t *get_out_reg(const ir_node *node, int pos)
{
ir_node *proj;
const arch_register_t *reg = NULL;
/* Proj with the corresponding projnum for the register */
if (get_irn_mode(node) != mode_T) {
- reg = arch_get_irn_register(arch_env, node);
+ reg = arch_get_irn_register(node);
} else if (is_mips_irn(node)) {
reg = get_mips_out_reg(node, pos);
} else {
proj = get_edge_src_irn(edge);
assert(is_Proj(proj) && "non-Proj from mode_T node");
if (get_Proj_proj(proj) == pos) {
- reg = arch_get_irn_register(arch_env, proj);
+ reg = arch_get_irn_register(proj);
break;
}
}
/**
* Emit the name of the source register at given input position.
*/
-void mips_emit_source_register(mips_emit_env_t *env, const ir_node *node,
- int pos)
+void mips_emit_source_register(const ir_node *node, int pos)
{
- const arch_register_t *reg = get_in_reg(env->arch_env, node, pos);
- be_emit_char(env->emit, '$');
- be_emit_string(env->emit, arch_register_get_name(reg));
+ const arch_register_t *reg = get_in_reg(node, pos);
+ be_emit_char('$');
+ be_emit_string(arch_register_get_name(reg));
}
/**
* Emit the name of the destination register at given output position.
*/
-void mips_emit_dest_register(mips_emit_env_t *env, const ir_node *node,
- int pos)
+void mips_emit_dest_register(const ir_node *node, int pos)
{
- const arch_register_t *reg = get_out_reg(env->arch_env, node, pos);
- be_emit_char(env->emit, '$');
- be_emit_string(env->emit, arch_register_get_name(reg));
+ const arch_register_t *reg = get_out_reg(node, pos);
+ be_emit_char('$');
+ be_emit_string(arch_register_get_name(reg));
}
#if 0
id = get_entity_ident(get_SymConst_entity(node));
return get_id_str(id);
default:
- assert(0);
+ panic("Unsupported SymConst kind");
}
return NULL;
}
#endif
-void mips_emit_load_store_address(mips_emit_env_t *env, const ir_node *node,
- int pos)
+void mips_emit_load_store_address(const ir_node *node, int pos)
{
const mips_load_store_attr_t *attr = get_mips_load_store_attr_const(node);
- be_emit_irprintf(env->emit, "%d(", attr->offset);
- mips_emit_source_register(env, node, pos);
- be_emit_char(env->emit, ')');
+ be_emit_irprintf("%d(", attr->offset);
+ mips_emit_source_register(node, pos);
+ be_emit_char(')');
}
-void mips_emit_immediate_suffix(mips_emit_env_t *env, const ir_node *node,
- int pos)
+void mips_emit_immediate_suffix(const ir_node *node, int pos)
{
ir_node *op = get_irn_n(node, pos);
if(is_mips_Immediate(op))
- be_emit_char(env->emit, 'i');
+ be_emit_char('i');
}
-void mips_emit_immediate(mips_emit_env_t *env, const ir_node *node)
+void mips_emit_immediate(const ir_node *node)
{
const mips_immediate_attr_t *attr = get_mips_immediate_attr_const(node);
switch(attr->imm_type) {
case MIPS_IMM_CONST:
- be_emit_irprintf(env->emit, "%d", attr->val);
+ be_emit_irprintf("%d", attr->val);
break;
case MIPS_IMM_SYMCONST_LO:
- be_emit_cstring(env->emit, "%lo($");
- be_emit_ident(env->emit, get_entity_ld_ident(attr->entity));
+ be_emit_cstring("%lo($");
+ be_emit_ident(get_entity_ld_ident(attr->entity));
if(attr->val != 0) {
- be_emit_irprintf(env->emit, "%+d", attr->val);
+ be_emit_irprintf("%+d", attr->val);
}
- be_emit_char(env->emit, ')');
+ be_emit_char(')');
break;
case MIPS_IMM_SYMCONST_HI:
- be_emit_cstring(env->emit, "%hi($");
- be_emit_ident(env->emit, get_entity_ld_ident(attr->entity));
+ be_emit_cstring("%hi($");
+ be_emit_ident(get_entity_ld_ident(attr->entity));
if(attr->val != 0) {
- be_emit_irprintf(env->emit, "%+d", attr->val);
+ be_emit_irprintf("%+d", attr->val);
}
- be_emit_char(env->emit, ')');
+ be_emit_char(')');
break;
default:
panic("invalid immediate type found");
/**
* Emit the name of the destination register at given output position.
*/
-void mips_emit_source_register_or_immediate(mips_emit_env_t *env,
- const ir_node *node, int pos)
+void mips_emit_source_register_or_immediate(const ir_node *node, int pos)
{
const ir_node *op = get_irn_n(node, pos);
if(is_mips_Immediate(op)) {
- mips_emit_immediate(env, op);
+ mips_emit_immediate(op);
} else {
- mips_emit_source_register(env, node, pos);
+ mips_emit_source_register(node, pos);
}
}
/************************************************************************/
static
-void mips_emit_IncSP(mips_emit_env_t *env, const ir_node *node)
+void mips_emit_IncSP(const ir_node *node)
{
int offset = be_get_IncSP_offset(node);
if(offset == 0) {
- be_emit_cstring(env->emit, "\t/* omitted IncSP with 0 */");
- be_emit_finish_line_gas(env->emit, node);
return;
}
if(offset > 0xffff || offset < -0xffff) {
- panic("stackframe > 2^16 bytes not supported yet\n");
+ panic("stackframe > 2^16 bytes not supported yet");
}
if(offset > 0) {
- be_emit_irprintf(env->emit, "\tsubu $sp, $sp, %d", offset);
+ be_emit_irprintf("\tsubu $sp, $sp, %d", offset);
} else {
- be_emit_irprintf(env->emit, "\taddu $sp, $sp, %d", -offset);
+ be_emit_irprintf("\taddu $sp, $sp, %d", -offset);
}
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_finish_line_gas(node);
}
-static void mips_emit_Copy(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_Copy(const ir_node *node)
{
- be_emit_cstring(env->emit, "\tmove ");
- mips_emit_dest_register(env, node, 0);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 0);
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\tmove ");
+ mips_emit_dest_register(node, 0);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 0);
+ be_emit_finish_line_gas(node);
}
-static void mips_emit_Return(mips_emit_env_t *env, const ir_node* node)
+static void mips_emit_Return(const ir_node* node)
{
- be_emit_cstring(env->emit, "\tj $ra");
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\tj $ra");
+ be_emit_finish_line_gas(node);
}
static __attribute__((unused))
-void mips_emit_nops(mips_emit_env_t *env, int n)
+void mips_emit_nops(int n)
{
int i;
for(i = 0; i < n; ++i) {
- be_emit_cstring(env->emit, "\tnop\n");
- be_emit_write_line(env->emit);
+ be_emit_cstring("\tnop\n");
+ be_emit_write_line();
}
}
-static void mips_emit_Perm(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_Perm(const ir_node *node)
{
assert(get_irn_arity(node) == 2);
- be_emit_cstring(env->emit, "\txor ");
- mips_emit_source_register(env, node, 0);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 0);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 1);
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\txor ");
+ mips_emit_source_register(node, 0);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 0);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 1);
+ be_emit_finish_line_gas(node);
- /* mips_emit_nops(env, 3); */
+ /* mips_emit_nops(3); */
- be_emit_cstring(env->emit, "\txor ");
- mips_emit_source_register(env, node, 1);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 1);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 0);
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\txor ");
+ mips_emit_source_register(node, 1);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 1);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 0);
+ be_emit_finish_line_gas(node);
- /* mips_emit_nops(env, 3); */
+ /* mips_emit_nops(3); */
- be_emit_cstring(env->emit, "\txor ");
- mips_emit_source_register(env, node, 0);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 0);
- be_emit_cstring(env->emit, ", ");
- mips_emit_source_register(env, node, 1);
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\txor ");
+ mips_emit_source_register(node, 0);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 0);
+ be_emit_cstring(", ");
+ mips_emit_source_register(node, 1);
+ be_emit_finish_line_gas(node);
- /* mips_emit_nops(env, 3); */
+ /* mips_emit_nops(3); */
}
/************************************************************************/
/* Calls */
/************************************************************************/
-static void mips_emit_Call(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_Call(const ir_node *node)
{
ir_entity *callee;
- be_emit_cstring(env->emit, "\tjal ");
+ be_emit_cstring("\tjal ");
/* call of immediate value (label) */
callee = be_Call_get_entity(node);
if(callee != NULL) {
- be_emit_ident(env->emit, get_entity_ld_ident(callee));
+ be_emit_ident(get_entity_ld_ident(callee));
} else {
- mips_emit_source_register(env, node, be_pos_Call_ptr);
+ mips_emit_source_register(node, be_pos_Call_ptr);
}
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_finish_line_gas(node);
}
/************************************************************************
/**
* Emits a block label from the given block.
*/
-static
-void mips_emit_block_label(mips_emit_env_t *env, const ir_node *block)
+static void mips_emit_block_label(const ir_node *block)
{
if (has_Block_label(block)) {
- be_emit_string(env->emit, be_gas_label_prefix());
- be_emit_irprintf(env->emit, "%lu", get_Block_label(block));
+ be_emit_string(be_gas_block_label_prefix());
+ be_emit_irprintf("%lu", get_Block_label(block));
} else {
- be_emit_cstring(env->emit, BLOCK_PREFIX);
- be_emit_irprintf(env->emit, "%d", get_irn_node_nr(block));
+ be_emit_cstring(BLOCK_PREFIX);
+ be_emit_irprintf("%ld", get_irn_node_nr(block));
}
}
-static void mips_emit_Jump(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_Jump(const ir_node *node)
{
const ir_node *block = get_irn_link(node);
assert(is_Block(block));
- be_emit_cstring(env->emit, "\tb ");
- mips_emit_block_label(env, block);
- be_emit_finish_line_gas(env->emit, node);
+ be_emit_cstring("\tb ");
+ mips_emit_block_label(block);
+ be_emit_finish_line_gas(node);
}
ir_node *mips_get_jump_block(const ir_node* node, long projn)
return NULL;
}
-void mips_emit_jump_target_proj(mips_emit_env_t *env, const ir_node *node,
- long projn)
+void mips_emit_jump_target_proj(const ir_node *node, long projn)
{
ir_node *jumpblock = mips_get_jump_block(node, projn);
assert(jumpblock != NULL);
- mips_emit_block_label(env, jumpblock);
+ mips_emit_block_label(jumpblock);
}
-void mips_emit_jump_target(mips_emit_env_t *env, const ir_node *node)
+void mips_emit_jump_target(const ir_node *node)
{
ir_node *jumpblock = get_irn_link(node);
assert(jumpblock != NULL);
- mips_emit_block_label(env, jumpblock);
+ mips_emit_block_label(jumpblock);
}
-void mips_emit_jump_or_fallthrough(mips_emit_env_t *env, const ir_node *node,
- long pn)
+void mips_emit_jump_or_fallthrough(const ir_node *node, long pn)
{
ir_node *jumpblock = mips_get_jump_block(node, pn);
assert(jumpblock != NULL);
/* TODO: use fallthrough when possible */
- be_emit_cstring(env->emit, "b ");
- mips_emit_block_label(env, jumpblock);
+ be_emit_cstring("b ");
+ mips_emit_block_label(jumpblock);
}
/************************************************************************
* Emits code for a SwitchJmp (creates a jump table if
* possible otherwise a cmp-jmp cascade). Stolen from ia32
*/
-void emit_mips_jump_table(mips_emit_env_t *env, const ir_node *irn) {
+void emit_mips_jump_table(const ir_node *irn)
+{
int lastval, i, i2, pn;
jmp_tbl_t tbl;
ir_node *proj;
const mips_attr_t *attr = get_mips_attr_const(irn);
/* fill the table structure */
- tbl.label = xmalloc(SNPRINTF_BUF_LEN);
+ tbl.label = XMALLOCN(char, SNPRINTF_BUF_LEN);
tbl.label = get_unique_label(tbl.label, SNPRINTF_BUF_LEN, "JMPTBL_");
tbl.defBlock = NULL;
tbl.num_branches = get_irn_n_edges(irn);
- tbl.branches = xcalloc(tbl.num_branches, sizeof(tbl.branches[0]));
+ tbl.branches = XMALLOCNZ(branch_t, tbl.num_branches);
tbl.min_value = INT_MAX;
tbl.max_value = INT_MIN;
/* sort the branches by their number */
qsort(tbl.branches, tbl.num_branches, sizeof(tbl.branches[0]), mips_cmp_branch_t);
- be_emit_string(env->emit, mips_get_jumptbl_label(irn));
- be_emit_cstring(env->emit, ":\n");
- be_emit_write_line(env->emit);
+ be_emit_string(mips_get_jumptbl_label(irn));
+ be_emit_cstring(":\n");
+ be_emit_write_line();
lastval = tbl.min_value;
for(i = 0; i < tbl.num_branches; ++i) {
const branch_t *branch = &tbl.branches[i];
int value = branch->value;
for(i2 = lastval + 1; i2 < value; ++i2) {
- be_emit_cstring(env->emit, "\t.word ");
- be_emit_ident(env->emit, get_entity_ld_ident(attr->symconst));
- be_emit_char(env->emit, '\n');
- be_emit_write_line(env->emit);
+ be_emit_cstring("\t.word ");
+ be_emit_ident(get_entity_ld_ident(attr->symconst));
+ be_emit_char('\n');
+ be_emit_write_line();
}
- be_emit_cstring(env->emit, "\t.word ");
- mips_emit_block_label(env, branch->target);
- be_emit_char(env->emit, '\n');
- be_emit_write_line(env->emit);
+ be_emit_cstring("\t.word ");
+ mips_emit_block_label(branch->target);
+ be_emit_char('\n');
+ be_emit_write_line();
lastval = branch->value;
}
free(tbl.branches);
}
-static
-void dump_jump_tables(ir_node* node, void *data)
+static void dump_jump_tables(ir_node* node, void *data)
{
- mips_emit_env_t *env = data;
+ (void) data;
// emit jump tables
if(is_mips_SwitchJump(node)) {
- be_emit_cstring(env->emit, ".data\n");
- be_emit_write_line(env->emit);
+ be_emit_cstring(".data\n");
+ be_emit_write_line();
- emit_mips_jump_table(env, node);
+ emit_mips_jump_table(node);
- be_emit_cstring(env->emit, ".text\n");
- be_emit_write_line(env->emit);
+ be_emit_cstring(".text\n");
+ be_emit_write_line();
}
}
#endif
*
***********************************************************************************/
-static void mips_emit_nothing(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_nothing(const ir_node *node)
{
- (void) env;
(void) node;
}
-static void mips_emit_this_shouldnt_happen(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_this_shouldnt_happen(const ir_node *node)
{
- (void) env;
panic("Found non-lowered node %+F while emitting", node);
}
/**
* The type of a emitter function.
*/
-typedef void (*emit_func) (mips_emit_env_t *, const ir_node *);
+typedef void (*emit_func) (const ir_node *);
/**
* Set a node emitter. Make it a bit more type safe.
*/
-static void register_emitter(ir_op *op, emit_func func) {
+static void register_emitter(ir_op *op, emit_func func)
+{
op->ops.generic = (op_func) func;
}
/**
* Register emitter functions for mips backend
*/
-void mips_register_emitters(void) {
+void mips_register_emitters(void)
+{
/* first clear the generic function pointer for all ops */
clear_irp_opcodes_generic_func();
/**
* Emits assembly for a single node
*/
-static void mips_emit_node(mips_emit_env_t *env, const ir_node *node)
+static void mips_emit_node(const ir_node *node)
{
ir_op *op = get_irn_op(node);
if (op->ops.generic) {
emit_func emit = (emit_func) op->ops.generic;
- (*emit) (env, node);
+ (*emit) (node);
} else {
panic("No emitter defined for node %+F", node);
}
* Walks over the nodes in a block connected by scheduling edges
* and emits code for each node.
*/
-void mips_gen_block(mips_emit_env_t *env, ir_node *block)
+void mips_gen_block(const ir_node *block)
{
ir_node *node;
if (! is_Block(block))
return;
- mips_emit_block_label(env, block);
- be_emit_cstring(env->emit, ":\n");
- be_emit_write_line(env->emit);
+ mips_emit_block_label(block);
+ be_emit_cstring(":\n");
+ be_emit_write_line();
sched_foreach(block, node) {
- mips_emit_node(env, node);
+ mips_emit_node(node);
}
- be_emit_char(env->emit, '\n');
- be_emit_write_line(env->emit);
+ be_emit_char('\n');
+ be_emit_write_line();
}
/**
* Emits code for function start.
*/
-void mips_emit_func_prolog(mips_emit_env_t *env, ir_graph *irg)
+void mips_emit_func_prolog(ir_graph *irg)
{
ident *irg_ident = get_entity_ld_ident(get_irg_entity(irg));
- be_emit_env_t *eenv = env->emit;
// dump jump tables
//irg_walk_graph(irg, NULL, dump_jump_tables, env);
- be_emit_write_line(eenv);
- be_gas_emit_switch_section(eenv, GAS_SECTION_TEXT);
+ be_emit_write_line();
+ be_gas_emit_switch_section(GAS_SECTION_TEXT);
- be_emit_cstring(eenv, "\t.balign\t4\n");
+ be_emit_cstring("\t.balign\t4\n");
- be_emit_cstring(eenv, "\t.global\t");
- be_emit_ident(eenv, irg_ident);
- be_emit_char(eenv, '\n');
+ be_emit_cstring("\t.global\t");
+ be_emit_ident(irg_ident);
+ be_emit_char('\n');
- be_emit_cstring(eenv, "\t.set\tnomips16\n");
+ be_emit_cstring("\t.set\tnomips16\n");
- be_emit_cstring(eenv, "\t.ent\t");
- be_emit_ident(eenv, irg_ident);
- be_emit_char(eenv, '\n');
+ be_emit_cstring("\t.ent\t");
+ be_emit_ident(irg_ident);
+ be_emit_char('\n');
- be_emit_ident(eenv, irg_ident);
- be_emit_cstring(eenv, ":\n");
+ be_emit_ident(irg_ident);
+ be_emit_cstring(":\n");
- be_emit_cstring(eenv, "\t.frame\t$fp, 24, $ra\n");
- be_emit_cstring(eenv, "\t.mask\t0xc0000000, -4\n");
- be_emit_cstring(eenv, "\t.fmask\t0x00000000, 0\n");
+ be_emit_cstring("\t.frame\t$fp, 24, $ra\n");
+ be_emit_cstring("\t.mask\t0xc0000000, -4\n");
+ be_emit_cstring("\t.fmask\t0x00000000, 0\n");
- be_emit_write_line(eenv);
+ be_emit_write_line();
}
/**
* Emits code for function end
*/
-void mips_emit_func_epilog(mips_emit_env_t *env, ir_graph *irg)
+void mips_emit_func_epilog(ir_graph *irg)
{
ident *irg_ident = get_entity_ident(get_irg_entity(irg));
- be_emit_cstring(env->emit, "\t.end\t");
- be_emit_ident(env->emit, irg_ident);
- be_emit_char(env->emit, '\n');
- be_emit_write_line(env->emit);
+ be_emit_cstring("\t.end\t");
+ be_emit_ident(irg_ident);
+ be_emit_char('\n');
+ be_emit_write_line();
}
/**
/**
* Main driver
*/
-void mips_gen_routine(mips_code_gen_t *cg, ir_graph *irg)
+void mips_gen_routine(mips_code_gen_t *mips_cg, ir_graph *irg)
{
- mips_emit_env_t env;
int i, n;
- env.isa = (mips_isa_t*) cg->arch_env->isa;
- env.emit = &env.isa->emit;
- env.arch_env = cg->arch_env;
- env.cg = cg;
-
mips_register_emitters();
- irg_block_walk_graph(irg, mips_gen_labels, NULL, &env);
-
- mips_emit_func_prolog(&env, irg);
+ irg_block_walk_graph(irg, mips_gen_labels, NULL, NULL);
- dump_ir_block_graph_sched(irg, "-kaputtelist");
+ mips_emit_func_prolog(irg);
- for (i = 0, n = mips_get_sched_n_blocks(cg); i < n; ++i) {
- ir_node *block = mips_get_sched_block(cg, i);
- mips_gen_block(&env, block);
+ n = ARR_LEN(mips_cg->block_schedule);
+ for (i = 0; i < n; ++i) {
+ ir_node *block = mips_cg->block_schedule[i];
+ mips_gen_block(block);
}
- mips_emit_func_epilog(&env, irg);
+ mips_emit_func_epilog(irg);
}
void mips_init_emitter(void)
projects / libfirm / blobdiff