nsz Git - libfirm/blob - ir/be/TEMPLATE/TEMPLATE_emitter.c

   1 /* TEMPLATE emitter */
   2 /* $Id$ */
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <limits.h>
   8
   9 #include "xmalloc.h"
  10 #include "tv.h"
  11 #include "iredges.h"
  12 #include "debug.h"
  13 #include "irgwalk.h"
  14 #include "irprintf.h"
  15 #include "irop_t.h"
  16 #include "irargs_t.h"
  17 #include "irprog.h"
  18
  19 #include "../besched.h"
  20
  21 #include "TEMPLATE_emitter.h"
  22 #include "gen_TEMPLATE_emitter.h"
  23 #include "TEMPLATE_nodes_attr.h"
  24 #include "TEMPLATE_new_nodes.h"
  25 #include "TEMPLATE_map_regs.h"
  26
  27 #define SNPRINTF_BUF_LEN 128
  28
  29 /**
  30  * Returns the register at in position pos.
  31  */
  32 static const arch_register_t *get_in_reg(const arch_env_t *arch_env,
  33                                          const ir_node *node, int pos)
  34 {
  35         ir_node                *op;
  36         const arch_register_t  *reg = NULL;
  37
  38         assert(get_irn_arity(node) > pos && "Invalid IN position");
  39
  40         /* The out register of the operator at position pos is the
  41            in register we need. */
  42         op = get_irn_n(node, pos);
  43
  44         reg = arch_get_irn_register(arch_env, op);
  45
  46         assert(reg && "no in register found");
  47         return reg;
  48 }
  49
  50 /**
  51  * Returns the register at out position pos.
  52  */
  53 static const arch_register_t *get_out_reg(const arch_env_t *arch_env,
  54                                           const ir_node *node, int pos)
  55 {
  56         ir_node                *proj;
  57         const arch_register_t  *reg = NULL;
  58
  59         /* 1st case: irn is not of mode_T, so it has only                 */
  60         /*           one OUT register -> good                             */
  61         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
  62         /*           Proj with the corresponding projnum for the register */
  63
  64         if (get_irn_mode(node) != mode_T) {
  65                 reg = arch_get_irn_register(arch_env, node);
  66         } else if (is_TEMPLATE_irn(node)) {
  67                 reg = get_TEMPLATE_out_reg(node, pos);
  68         } else {
  69                 const ir_edge_t *edge;
  70
  71                 foreach_out_edge(node, edge) {
  72                         proj = get_edge_src_irn(edge);
  73                         assert(is_Proj(proj) && "non-Proj from mode_T node");
  74                         if (get_Proj_proj(proj) == pos) {
  75                                 reg = arch_get_irn_register(arch_env, proj);
  76                                 break;
  77                         }
  78                 }
  79         }
  80
  81         assert(reg && "no out register found");
  82         return reg;
  83 }
  84
  85 /*************************************************************
  86  *             _       _    __   _          _
  87  *            (_)     | |  / _| | |        | |
  88  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
  89  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
  90  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
  91  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
  92  * | |                                       | |
  93  * |_|                                       |_|
  94  *************************************************************/
  95
  96 void TEMPLATE_emit_immediate(TEMPLATE_emit_env_t *env, const ir_node *node)
  97 {
  98         /* TODO */
  99 }
 100
 101 void TEMPLATE_emit_source_register(TEMPLATE_emit_env_t *env, const ir_node *node, int pos)
 102 {
 103         const arch_register_t *reg = get_in_reg(env->arch_env, node, pos);
 104         be_emit_string(env->emit, arch_register_get_name(reg));
 105 }
 106
 107 void TEMPLATE_emit_dest_register(TEMPLATE_emit_env_t *env, const ir_node *node, int pos)
 108 {
 109         const arch_register_t *reg = get_out_reg(env->arch_env, node, pos);
 110         be_emit_string(env->emit, arch_register_get_name(reg));
 111 }
 112
 113 /**
 114  * Returns the target label for a control flow node.
 115  */
 116 static void TEMPLATE_emit_cfop_target(TEMPLATE_emit_env_t *env, const ir_node *node) {
 117         ir_node *block = get_irn_link(node);
 118
 119         be_emit_irprintf(env->emit, "BLOCK_%ld", get_irn_node_nr(block));
 120 }
 121
 122 /***********************************************************************************
 123  *                  _          __                                             _
 124  *                 (_)        / _|                                           | |
 125  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 126  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 127  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 128  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 129  *
 130  ***********************************************************************************/
 131
 132 /**
 133  * Emits code for a unconditional jump.
 134  */
 135 static void emit_Jmp(TEMPLATE_emit_env_t *env, const ir_node *node) {
 136         ir_node *block;
 137
 138         /* for now, the code works for scheduled and non-schedules blocks */
 139         block = get_nodes_block(node);
 140
 141         be_emit_cstring(env->emit, "\tjmp ");
 142         TEMPLATE_emit_cfop_target(env, node);
 143         be_emit_finish_line_gas(env->emit, node);
 144 }
 145
 146 /**
 147  * Enters the emitter functions for handled nodes into the generic
 148  * pointer of an opcode.
 149  */
 150 static void TEMPLATE_register_emitters(void) {
 151
 152 /* some convienience macros to register additional emitter functions
 153    (other than the generated ones) */
 154 #define TEMPLATE_EMIT(a) op_TEMPLATE_##a->ops.generic = (op_func)emit_TEMPLATE_##a
 155 #define EMIT(a)          op_##a->ops.generic = (op_func)emit_##a
 156 #define BE_EMIT(a)       op_be_##a->ops.generic = (op_func)emit_be_##a
 157
 158         /* first clear the generic function pointer for all ops */
 159         clear_irp_opcodes_generic_func();
 160
 161         /* register all emitter functions defined in spec */
 162         TEMPLATE_register_spec_emitters();
 163
 164         /* register addtional emitter functions if needed */
 165         EMIT(Jmp);
 166
 167 #undef TEMPLATE_EMIT
 168 #undef BE_EMIT
 169 #undef EMIT
 170 }
 171
 172 typedef void (*emit_func_ptr) (TEMPLATE_emit_env_t *, const ir_node *);
 173
 174 /**
 175  * Emits code for a node.
 176  */
 177 void TEMPLATE_emit_node(TEMPLATE_emit_env_t *env, const ir_node *node) {
 178         ir_op               *op       = get_irn_op(node);
 179         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 180
 181         DBG((mod, LEVEL_1, "emitting code for %+F\n", node));
 182
 183         if (op->ops.generic) {
 184                 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
 185                 (*func) (env, node);
 186         } else {
 187                 ir_fprintf(stderr, "No emitter for node %+F\n", node);
 188         }
 189 }
 190
 191 /**
 192  * Walks over the nodes in a block connected by scheduling edges
 193  * and emits code for each node.
 194  */
 195 void TEMPLATE_gen_block(ir_node *block, void *data) {
 196         TEMPLATE_emit_env_t *env = data;
 197         ir_node *node;
 198
 199         if (! is_Block(block))
 200                 return;
 201
 202         be_emit_cstring(env->emit, "BLOCK_");
 203         be_emit_irprintf(env->emit, "%ld:\n", get_irn_node_nr(block));
 204         be_emit_write_line(env->emit);
 205
 206         sched_foreach(block, node) {
 207                 TEMPLATE_emit_node(env, node);
 208         }
 209 }
 210
 211
 212 /**
 213  * Emits code for function start.
 214  */
 215 void TEMPLATE_emit_func_prolog(TEMPLATE_emit_env_t *env, ir_graph *irg) {
 216         const char *irg_name = get_entity_name(get_irg_entity(irg));
 217
 218         /* TODO: emit function header */
 219         be_emit_cstring(env->emit, "/* start of ");
 220         be_emit_string(env->emit, irg_name);
 221         be_emit_cstring(env->emit, " */\n");
 222         be_emit_write_line(env->emit);
 223 }
 224
 225 /**
 226  * Emits code for function end
 227  */
 228 void TEMPLATE_emit_func_epilog(TEMPLATE_emit_env_t *env, ir_graph *irg) {
 229         const char *irg_name = get_entity_name(get_irg_entity(irg));
 230
 231         /* TODO: emit function end */
 232         be_emit_cstring(env->emit, "/* end of ");
 233         be_emit_string(env->emit, irg_name);
 234         be_emit_cstring(env->emit, " */\n");
 235         be_emit_write_line(env->emit);
 236 }
 237
 238 /**
 239  * Sets labels for control flow nodes (jump target)
 240  * TODO: Jump optimization
 241  */
 242 void TEMPLATE_gen_labels(ir_node *block, void *env) {
 243         ir_node *pred;
 244         int n = get_Block_n_cfgpreds(block);
 245
 246         for (n--; n >= 0; n--) {
 247                 pred = get_Block_cfgpred(block, n);
 248                 set_irn_link(pred, block);
 249         }
 250 }
 251
 252 /**
 253  * Main driver
 254  */
 255 void TEMPLATE_gen_routine(const TEMPLATE_code_gen_t *cg, ir_graph *irg) {
 256         TEMPLATE_emit_env_t env;
 257
 258         env.isa      = (TEMPLATE_isa_t *) cg->arch_env->isa;
 259         env.emit     = &env.isa->emit;
 260         env.arch_env = cg->arch_env;
 261         env.cg       = cg;
 262         FIRM_DBG_REGISTER(env.mod, "firm.be.TEMPLATE.emit");
 263
 264         /* register all emitter functions */
 265         TEMPLATE_register_emitters();
 266
 267         TEMPLATE_emit_func_prolog(&env, irg);
 268         irg_block_walk_graph(irg, TEMPLATE_gen_labels, NULL, &env);
 269         irg_walk_blkwise_graph(irg, NULL, TEMPLATE_gen_block, &env);
 270         TEMPLATE_emit_func_epilog(&env, irg);
 271 }