1 /* The codegenrator (transform FIRM into TEMPLATE FIRM */
19 #include "../benode_t.h"
20 #include "bearch_TEMPLATE_t.h"
22 #include "TEMPLATE_nodes_attr.h"
23 #include "../arch/archop.h" /* we need this for Min and Max nodes */
24 #include "TEMPLATE_transform.h"
25 #include "TEMPLATE_new_nodes.h"
26 #include "TEMPLATE_map_regs.h"
28 #include "gen_TEMPLATE_regalloc_if.h"
30 extern ir_op *get_op_Mulh(void);
34 /****************************************************************************************************
36 * | | | | / _| | | (_)
37 * _ __ ___ __| | ___ | |_ _ __ __ _ _ __ ___| |_ ___ _ __ _ __ ___ __ _| |_ _ ___ _ __
38 * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __| _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
39 * | | | | (_) | (_| | __/ | |_| | | (_| | | | \__ \ || (_) | | | | | | | | (_| | |_| | (_) | | | |
40 * |_| |_|\___/ \__,_|\___| \__|_| \__,_|_| |_|___/_| \___/|_| |_| |_| |_|\__,_|\__|_|\___/|_| |_|
42 ****************************************************************************************************/
45 * Creates an TEMPLATE Add.
47 * @param env The transformation environment
48 * @param op1 first operator
49 * @param op2 second operator
50 * @return the created TEMPLATE Add node
52 static ir_node *gen_Add(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
53 return new_rd_TEMPLATE_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
59 * Creates an TEMPLATE Mul.
61 * @param dbg firm node dbg
62 * @param block the block the new node should belong to
63 * @param op1 first operator
64 * @param op2 second operator
65 * @param mode node mode
66 * @return the created TEMPLATE Mul node
68 static ir_node *gen_Mul(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
69 if (mode_is_float(env->mode)) {
70 return new_rd_TEMPLATE_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
73 return new_rd_TEMPLATE_Mul(env->dbg, env->irg, env->block, op1, op2, env->mode);
80 * Creates an TEMPLATE And.
82 * @param dbg firm node dbg
83 * @param block the block the new node should belong to
84 * @param op1 first operator
85 * @param op2 second operator
86 * @param mode node mode
87 * @return the created TEMPLATE And node
89 static ir_node *gen_And(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
90 return new_rd_TEMPLATE_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
96 * Creates an TEMPLATE Or.
98 * @param dbg firm node dbg
99 * @param block the block the new node should belong to
100 * @param op1 first operator
101 * @param op2 second operator
102 * @param mode node mode
103 * @return the created TEMPLATE Or node
105 static ir_node *gen_Or(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
106 return new_rd_TEMPLATE_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
112 * Creates an TEMPLATE Eor.
114 * @param dbg firm node dbg
115 * @param block the block the new node should belong to
116 * @param op1 first operator
117 * @param op2 second operator
118 * @param mode node mode
119 * @return the created TEMPLATE Eor node
121 static ir_node *gen_Eor(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
122 return new_rd_TEMPLATE_Eor(env->dbg, env->irg, env->block, op1, op2, env->mode);
128 * Creates an TEMPLATE Sub.
130 * @param dbg firm node dbg
131 * @param block the block the new node should belong to
132 * @param op1 first operator
133 * @param op2 second operator
134 * @param mode node mode
135 * @return the created TEMPLATE Sub node
137 static ir_node *gen_Sub(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
138 if (mode_is_float(env->mode)) {
139 return new_rd_TEMPLATE_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
142 return new_rd_TEMPLATE_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
149 * Creates an TEMPLATE floating Div.
151 * @param dbg firm node dbg
152 * @param block the block the new node should belong to
153 * @param op1 first operator
154 * @param op2 second operator
155 * @param mode node mode
156 * @return the created TEMPLATE fDiv node
158 static ir_node *gen_Quot(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
159 return new_rd_TEMPLATE_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
165 * Creates an TEMPLATE Shl.
167 * @param dbg firm node dbg
168 * @param block the block the new node should belong to
169 * @param op1 first operator
170 * @param op2 second operator
171 * @param mode node mode
172 * @return the created TEMPLATE Shl node
174 static ir_node *gen_Shl(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
175 return new_rd_TEMPLATE_Shl(env->dbg, env->irg, env->block, op1, op2, env->mode);
181 * Creates an TEMPLATE Shr.
183 * @param dbg firm node dbg
184 * @param block the block the new node should belong to
185 * @param op1 first operator
186 * @param op2 second operator
187 * @param mode node mode
188 * @return the created TEMPLATE Shr node
190 static ir_node *gen_Shr(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
191 return new_rd_TEMPLATE_Shr(env->dbg, env->irg, env->block, op1, op2, env->mode);
197 * Creates an TEMPLATE RotL.
199 * @param dbg firm node dbg
200 * @param block the block the new node should belong to
201 * @param op1 first operator
202 * @param op2 second operator
203 * @param mode node mode
204 * @return the created TEMPLATE RotL node
206 static ir_node *gen_RotL(TEMPLATE_transform_env_t *env, ir_node *op1, ir_node *op2) {
207 return new_rd_TEMPLATE_RotL(env->dbg, env->irg, env->block, op1, op2, env->mode);
213 * Transforms a Minus node.
215 * @param mod the debug module
216 * @param block the block the new node should belong to
217 * @param node the ir Minus node
219 * @param mode node mode
220 * @return the created TEMPLATE Minus node
222 static ir_node *gen_Minus(TEMPLATE_transform_env_t *env, ir_node *op) {
223 if (mode_is_float(env->mode)) {
224 return new_rd_TEMPLATE_fMinus(env->dbg, env->irg, env->block, op, env->mode);
226 return new_rd_TEMPLATE_Minus(env->dbg, env->irg, env->block, op, env->mode);
232 * Transforms a Not node.
234 * @param mod the debug module
235 * @param block the block the new node should belong to
236 * @param node the ir Not node
238 * @param mode node mode
239 * @return the created TEMPLATE Not node
241 static ir_node *gen_Not(TEMPLATE_transform_env_t *env, ir_node *op) {
242 return new_rd_TEMPLATE_Not(env->dbg, env->irg, env->block, op, env->mode);
250 * @param mod the debug module
251 * @param block the block the new node should belong to
252 * @param node the ir Load node
253 * @param mode node mode
254 * @return the created TEMPLATE Load node
256 static ir_node *gen_Load(TEMPLATE_transform_env_t *env) {
257 ir_node *node = env->irn;
259 if (mode_is_float(env->mode)) {
260 return new_rd_TEMPLATE_fLoad(env->dbg, env->irg, env->block, get_Load_ptr(node), get_Load_mem(node), env->mode);
262 return new_rd_TEMPLATE_Load(env->dbg, env->irg, env->block, get_Load_ptr(node), get_Load_mem(node), env->mode);
268 * Transforms a Store.
270 * @param mod the debug module
271 * @param block the block the new node should belong to
272 * @param node the ir Store node
273 * @param mode node mode
274 * @return the created TEMPLATE Store node
276 static ir_node *gen_Store(TEMPLATE_transform_env_t *env) {
277 ir_node *node = env->irn;
279 if (mode_is_float(env->mode)) {
280 return new_rd_TEMPLATE_fStore(env->dbg, env->irg, env->block, get_Store_ptr(node), get_Store_value(node), get_Store_mem(node), env->mode);
282 return new_rd_TEMPLATE_Store(env->dbg, env->irg, env->block, get_Store_ptr(node), get_Store_value(node), get_Store_mem(node), env->mode);
287 /*********************************************************
290 * _ __ ___ __ _ _ _ __ __| |_ __ ___ _____ _ __
291 * | '_ ` _ \ / _` | | '_ \ / _` | '__| \ \ / / _ \ '__|
292 * | | | | | | (_| | | | | | | (_| | | | |\ V / __/ |
293 * |_| |_| |_|\__,_|_|_| |_| \__,_|_| |_| \_/ \___|_|
295 *********************************************************/
300 * Transforms the given firm node (and maybe some other related nodes)
301 * into one or more assembler nodes.
303 * @param node the firm node
304 * @param env the debug module
306 void TEMPLATE_transform_node(ir_node *node, void *env) {
307 TEMPLATE_code_gen_t *cgenv = (TEMPLATE_code_gen_t *)env;
308 opcode code = get_irn_opcode(node);
309 ir_node *asm_node = NULL;
310 TEMPLATE_transform_env_t tenv;
315 tenv.block = get_nodes_block(node);
316 tenv.dbg = get_irn_dbg_info(node);
317 tenv.irg = current_ir_graph;
319 tenv.mod = cgenv->mod;
320 tenv.mode = get_irn_mode(node);
322 #define UNOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
323 #define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
324 #define GEN(a) case iro_##a: asm_node = gen_##a(&tenv); break
325 #define IGN(a) case iro_##a: break
326 #define BAD(a) case iro_##a: goto bad
328 DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
349 /* TODO: implement these nodes */
364 /* You probably don't need to handle the following nodes */
395 if (get_irn_op(node) == get_op_Max() ||
396 get_irn_op(node) == get_op_Min() ||
397 get_irn_op(node) == get_op_Mulh())
399 /* TODO: implement */
404 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
409 exchange(node, asm_node);
410 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
413 DB((tenv.mod, LEVEL_1, "ignored\n"));