-/* The codegenerator (transform FIRM into ppc FIRM) */
-/* $Id$ */
+/*
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+/**
+ * @file
+ * @brief The codegenerator (transform FIRM into ppc FIRM)
+ * @author Moritz Kroll, Jens Mueller
+ * @version $Id$
+ */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "iredges_t.h"
#include "irvrfy.h"
#include "ircons.h"
-#include "dbginfo.h"
#include "iropt_t.h"
+#include "irprintf.h"
#include "debug.h"
#include "../benode_t.h"
#include "bearch_ppc32_t.h"
#include "ppc32_nodes_attr.h"
-#include "../arch/archop.h" /* we need this for Min and Max nodes */
+#include "archop.h"
#include "ppc32_transform.h"
#include "ppc32_new_nodes.h"
#include "ppc32_map_regs.h"
#include "gen_ppc32_regalloc_if.h"
-extern pset *symbol_pset;
extern ir_op *get_op_Mulh(void);
-int is_direct_entity(entity *ent);
+int is_direct_entity(ir_entity *ent);
ir_mode* ppc32_mode_Cond = NULL;
if (ppc32_mode_Cond)
return ppc32_mode_Cond;
else {
- ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_character, 4, 0, irma_none, 0);
+ ppc32_mode_Cond = new_ir_mode("mode_Cond", irms_int_number, 4, 0, irma_none, 0);
return ppc32_mode_Cond;
}
}
/**
- * Calculates the modecode with size, sort and signed attributes
+ * Calculates the ir_modecode with size, sort and signed attributes
*/
-modecode get_nice_modecode(ir_mode *irmode)
+ir_modecode get_nice_modecode(ir_mode *irmode)
{
- modecode mode = irm_max;
+ ir_modecode mode = irm_max;
int sign = mode_is_signed(irmode);
int bits = get_mode_size_bits(irmode);
if(mode_is_int(irmode))
* Creates an ppc Add.
*
* @param env The transformation environment
- * @param op1 first operator
- * @param op2 second operator
* @return the created ppc Add node
*/
-static ir_node *gen_Add(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Add(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Add_left(env->irn);
+ ir_node *op2 = get_Add_right(env->irn);
+
switch(get_nice_modecode(env->mode)){
case irm_D:
return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
default:
fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
-
-
/**
* Creates an ppc Mul.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Mul node
*/
-static ir_node *gen_Mul(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Mul(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Mul_left(env->irn);
+ ir_node *op2 = get_Mul_right(env->irn);
+
switch(get_nice_modecode(env->mode)){
case irm_D:
return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
default:
fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
/**
* Creates an ppc Mulh.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Mulh node
*/
-static ir_node *gen_Mulh(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Mulh(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_irn_n(env->irn, 0);
+ ir_node *op2 = get_irn_n(env->irn, 1);
+
switch(get_nice_modecode(env->mode)){
case irm_Is:
case irm_Hs:
default:
fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
-
/**
* Creates an ppc And.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc And node
*/
-static ir_node *gen_And(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_And(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_And_left(env->irn);
+ ir_node *op2 = get_And_right(env->irn);
+
return new_rd_ppc32_And(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
-
/**
* Creates an ppc Or.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Or node
*/
-static ir_node *gen_Or(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Or(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Or_left(env->irn);
+ ir_node *op2 = get_Or_right(env->irn);
+
return new_rd_ppc32_Or(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
-
/**
* Creates an ppc Xor.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Xor node
*/
-static ir_node *gen_Eor(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Eor(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Eor_left(env->irn);
+ ir_node *op2 = get_Eor_right(env->irn);
+
return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
-
/**
* Creates an ppc Sub.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Sub node
*/
-static ir_node *gen_Sub(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Sub(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Sub_left(env->irn);
+ ir_node *op2 = get_Sub_right(env->irn);
+
switch(get_nice_modecode(env->mode)){
case irm_D:
return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
default:
fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
-
-
/**
* Creates an ppc floating Div.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc fDiv node
*/
-static ir_node *gen_Quot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Quot(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Quot_left(env->irn);
+ ir_node *op2 = get_Quot_right(env->irn);
+
switch(get_nice_modecode(env->mode)){
case irm_D:
return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
default:
fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
-
/**
* Creates an ppc integer Div.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Div node
*/
-static ir_node *gen_Div(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
- ir_node *proj_div = NULL;
- const ir_edge_t *edge;
-
- foreach_out_edge(env->irn, edge)
- {
- if (is_Proj(edge->src) && get_Proj_proj(edge->src) == pn_DivMod_res_div)
- proj_div = edge->src;
- }
+static ir_node *gen_Div(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Div_left(env->irn);
+ ir_node *op2 = get_Div_right(env->irn);
- switch(get_nice_modecode(get_irn_mode(proj_div))){
+ switch(get_nice_modecode(get_irn_mode(op1))){
case irm_Is:
case irm_Hs:
case irm_Bs:
return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
default:
- fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(proj_div)));
+ fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
assert(0);
- return 0;
+ return NULL;
}
}
/**
* Creates an ppc integer Div and Mod.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Div node
*/
-static ir_node *gen_DivMod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_DivMod(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_DivMod_left(env->irn);
+ ir_node *op2 = get_DivMod_right(env->irn);
ir_node *proj_div = NULL, *proj_mod = NULL;
ir_node *div_result;
const ir_edge_t *edge;
/**
* Creates an ppc integer Mod.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Mod result node
*/
-static ir_node *gen_Mod(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Mod(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Mod_left(env->irn);
+ ir_node *op2 = get_Mod_right(env->irn);
ir_node *proj_div = NULL, *proj_mod = NULL;
ir_node *div_result;
ir_mode *res_mode;
proj_mod = get_succ_Proj(env->irn, pn_Mod_res);
- assert(proj_mod!=NULL);
+ assert(proj_mod != NULL);
res_mode = get_irn_mode(proj_mod);
switch(get_nice_modecode(res_mode))
default:
fprintf(stderr, "Mode for Mod not supported: %s\n", get_mode_name(res_mode));
assert(0);
- return 0;
+ return NULL;
}
exchange(proj_mod, mod_result);
-
-
return div_result;
}
-
/**
* Creates an ppc Shl.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Shl node
*/
-static ir_node *gen_Shl(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Shl(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Shl_left(env->irn);
+ ir_node *op2 = get_Shl_right(env->irn);
+
if(is_ppc32_Const(op2))
{
ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
-
/**
* Creates an ppc Srw.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Shr node
*/
-static ir_node *gen_Shr(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Shr(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Shr_left(env->irn);
+ ir_node *op2 = get_Shr_right(env->irn);
+
if(is_ppc32_Const(op2))
{
ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
/**
* Creates an ppc Sraw.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Sraw node
*/
-static ir_node *gen_Shrs(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Shrs(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Shrs_left(env->irn);
+ ir_node *op2 = get_Shrs_right(env->irn);
+
if(is_ppc32_Const(op2))
{
ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
tarval *tv_const = get_ppc32_constant_tarval(op2);
int sh = get_tarval_long(tv_const);
assert(0<=sh && sh<=31);
+ (void) sh;
set_ppc32_constant_tarval(shift, tv_const);
set_ppc32_offset_mode(shift, ppc32_ao_None);
return shift;
return new_rd_ppc32_Sraw(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
/**
- * Creates an ppc RotL.
+ * Creates an ppc Rotl.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
- * @return the created ppc RotL node
+ * @param env The transformation environment
+ * @return the created ppc Rotl node
*/
-static ir_node *gen_Rot(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Rotl(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Rotl_left(env->irn);
+ ir_node *op2 = get_Rotl_right(env->irn);
+
if(is_ppc32_Const(op2))
{
ir_node *rot = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
}
-
/**
* Creates an ppc Cmp.
*
- * @param dbg firm node dbg
- * @param block the block the new node should belong to
- * @param op1 first operator
- * @param op2 second operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Cmp node
*/
-static ir_node *gen_Cmp(ppc32_transform_env_t *env, ir_node *op1, ir_node *op2) {
+static ir_node *gen_Cmp(ppc32_transform_env_t *env) {
+ ir_node *op1 = get_Cmp_left(env->irn);
+ ir_node *op2 = get_Cmp_right(env->irn);
+
const ir_edge_t *edge;
foreach_out_edge(env->irn, edge)
{
}
}
-
/**
* Transforms a Minus node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Minus node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Minus node
*/
-static ir_node *gen_Minus(ppc32_transform_env_t *env, ir_node *op) {
+static ir_node *gen_Minus(ppc32_transform_env_t *env) {
+ ir_node *op = get_Minus_op(env->irn);
+
switch(get_nice_modecode(env->mode)){
case irm_D:
case irm_F:
default:
fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
}
-
-
/**
* Transforms a Not node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Not node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Not node
*/
-static ir_node *gen_Not(ppc32_transform_env_t *env, ir_node *op) {
- return new_rd_ppc32_Not(env->dbg, env->irg, env->block, op, env->mode);
+static ir_node *gen_Not(ppc32_transform_env_t *env) {
+ return new_rd_ppc32_Not(env->dbg, env->irg, env->block, get_Not_op(env->irn), env->mode);
}
/**
* Transforms a Conv node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Conv node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Conv node
*/
-static ir_node *gen_Conv(ppc32_transform_env_t *env, ir_node *op) {
- modecode from_mode=get_nice_modecode(get_irn_mode(get_irn_n(env->irn,0)));
- modecode to_mode=get_nice_modecode(env->mode);
+static ir_node *gen_Conv(ppc32_transform_env_t *env) {
+ ir_node *op = get_Conv_op(env->irn);
+ ir_modecode from_mode=get_nice_modecode(get_irn_mode(op));
+ ir_modecode to_mode=get_nice_modecode(env->mode);
-#define SKIP return get_irn_n(env->irn, 0)
+#define SKIP return op
if(from_mode == to_mode) SKIP;
fprintf(stderr, "Mode for Conv not supported: %s -> %s\n",
get_mode_name(get_irn_mode(get_irn_n(env->irn,0))),get_mode_name(env->mode));
assert(0);
- return 0;
-}
+ return NULL;
#undef SKIP
-
+}
/**
* Transforms an Abs node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Not node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return the ppc node generating the absolute value
*/
-static ir_node *gen_Abs(ppc32_transform_env_t *env, ir_node *op) {
+static ir_node *gen_Abs(ppc32_transform_env_t *env) {
+ ir_node *op = get_Abs_op(env->irn);
int shift = 7;
ir_node *n1,*n2;
shift += 16;
case irm_Hs:
shift += 8;
- case irm_Bs: ;
+ case irm_Bs:
n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
set_ppc32_constant_tarval(n1, new_tarval_from_long(shift, mode_Is));
set_ppc32_offset_mode(n1, ppc32_ao_None);
}
fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
assert(0);
- return 0;
+ return NULL;
}
/**
* Transforms an Cond node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Not node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return a ppc branch node
*/
static ir_node *gen_Cond(ppc32_transform_env_t *env) {
return switch_node;
}
-
}
/**
* Transforms an Unknown node.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Not node
- * @param op operator
- * @param mode node mode
+ * @param env The transformation environment
* @return a ppc Unknown node
*/
static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
}
else if(is_ppc32_SymConst(ptr))
{
- entity *ent = get_ppc32_frame_entity(ptr);
+ ir_entity *ent = get_ppc32_frame_entity(ptr);
if(is_direct_entity(ent))
{
id_symconst = get_entity_ident(ent);
/**
* Transforms a Load.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Load node
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Load node
*/
static ir_node *gen_Load(ppc32_transform_env_t *env) {
loadptr = ldst_insert_const(loadptr, &tv_const, &id_symconst, env);
switch(get_nice_modecode(mode)){
case irm_Bu:
- load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
case irm_Bs:
{
ir_node *proj_load, *extsb_node;
- load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
proj_load = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
extsb_node = new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, proj_load, mode);
exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
case irm_Hu:
- load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
case irm_Hs:
- load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load =new_rd_ppc32_Lha(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
case irm_Is:
case irm_Iu:
case irm_P:
- load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
case irm_D:
- load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
case irm_F:
- load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node), env->mode);
+ load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
break;
default:
/**
* Transforms a Store.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Store node
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc Store node
*/
static ir_node *gen_Store(ppc32_transform_env_t *env) {
switch(get_nice_modecode(mode)){
case irm_Bu:
case irm_Bs:
- store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
+ store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
case irm_Hu:
case irm_Hs:
- store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
+ store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
case irm_Is:
case irm_Iu:
case irm_P:
- store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
+ store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
case irm_D:
- store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
+ store = new_rd_ppc32_Stfd(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
case irm_F:
- store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node), env->mode);
+ store = new_rd_ppc32_Stfs(env->dbg, env->irg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
default:
/**
* Transforms a CopyB.
*
- * @param mod the debug module
- * @param block the block the new node should belong to
- * @param node the ir Store node
- * @param mode node mode
+ * @param env The transformation environment
* @return the created ppc CopyB node
*/
static ir_node *gen_CopyB(ppc32_transform_env_t *env) {
int size = get_type_size_bytes(type);
int offset = 0;
- ir_node *load, *store;
+ ir_node *load, *store = NULL;
- if(size/4>=1)
+ if(size/4 >= 1)
{
ir_node *res;
tarval *offset0 = new_tarval_from_long(0, mode_Is);
tarval *offset4 = new_tarval_from_long(4, mode_Is);
- load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T);
+ load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
set_ppc32_constant_tarval(load, offset0);
set_ppc32_offset_mode(load, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
- store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
+ store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
set_ppc32_constant_tarval(store, offset0);
set_ppc32_offset_mode(store, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
if(size/4==2)
{
- load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem, mode_T);
+ load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, src, mem);
set_ppc32_constant_tarval(load, offset4);
set_ppc32_offset_mode(load, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
- store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
+ store = new_rd_ppc32_Stw(env->dbg, env->irg, env->block, dest, res, mem);
set_ppc32_constant_tarval(store, offset4);
set_ppc32_offset_mode(store, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 1); // src
in[1] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 2); // dest
in[2] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 4); // temp
- be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_general_purpose], env->irg, env->block, 3, in);
+ be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_gp], env->irg, env->block, 3, in);
in[0] = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_Is, 3); // ctr
be_new_Keep(&ppc32_reg_classes[CLASS_ppc32_count], env->irg, env->block, 1, in);
}
}
- if((size & 2) == 2)
+ if(size & 2)
{
ir_node *res;
tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
- load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem, mode_T);
+ load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, src, mem);
set_ppc32_constant_tarval(load, offset_tarval);
set_ppc32_offset_mode(load, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
- store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
+ store = new_rd_ppc32_Sth(env->dbg, env->irg, env->block, dest, res, mem);
set_ppc32_constant_tarval(store, offset_tarval);
set_ppc32_offset_mode(store, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
offset += 2;
}
- if((size & 1) == 1)
+ if(size & 1)
{
ir_node *res;
tarval* offset_tarval = new_tarval_from_long(offset, mode_Is);
- load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem, mode_T);
+ load = new_rd_ppc32_Lbz(env->dbg, env->irg, env->block, src, mem);
set_ppc32_constant_tarval(load, offset_tarval);
set_ppc32_offset_mode(load, ppc32_ao_None);
mem = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_M, pn_Load_M);
res = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Is, pn_Load_res);
- store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem, mode_T);
+ store = new_rd_ppc32_Stb(env->dbg, env->irg, env->block, dest, res, mem);
set_ppc32_constant_tarval(store, offset_tarval);
set_ppc32_offset_mode(store, ppc32_ao_None);
// mem = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
/**
* Transforms a FrameAddr into a ppc Add.
+ *
+ * @param env The transformation environment
*/
-static ir_node *gen_FrameAddr(ppc32_transform_env_t *env) {
+static ir_node *gen_be_FrameAddr(ppc32_transform_env_t *env) {
ir_node *op = get_irn_n(env->irn, 0);
ir_node *add = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op, mode_P);
set_ppc32_frame_entity(add, be_get_frame_entity(env->irn));
return add;
}
-/**
- * Transforms a StackParam into a ppc Load
- */
-static ir_node *gen_StackParam(ppc32_transform_env_t *env) {
- ir_node *load = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, get_irn_n(env->irn, 0), new_NoMem(), mode_T);
- ir_node *proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
- set_ppc32_frame_entity(load, be_get_frame_entity(env->irn));
- return proj;
-}
-
/*********************************************************
* _ _ _
*
*********************************************************/
+/**
+ * the BAD transformer.
+ */
+static ir_node *bad_transform(ppc32_transform_env_t *env) {
+ ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
+ assert(0);
+ return NULL;
+}
+
+/**
+ * Enters all transform functions into the generic pointer
+ */
+void ppc32_register_transformers(void) {
+ ir_op *op_Max, *op_Min, *op_Mulh;
+
+ /* first clear the generic function pointer for all ops */
+ clear_irp_opcodes_generic_func();
+
+#define FIRM_OP(a) op_##a->ops.generic = (op_func)gen_##a
+#define BAD(a) op_##a->ops.generic = (op_func)bad_transform
+#define IGN(a)
+
+ FIRM_OP(Add);
+ FIRM_OP(Mul);
+ FIRM_OP(And);
+ FIRM_OP(Or);
+ FIRM_OP(Eor);
+
+ FIRM_OP(Sub);
+ FIRM_OP(Shl);
+ FIRM_OP(Shr);
+ FIRM_OP(Shrs);
+ FIRM_OP(Rotl);
+ FIRM_OP(Quot);
+ FIRM_OP(Div);
+ FIRM_OP(DivMod);
+ FIRM_OP(Mod);
+ FIRM_OP(Cmp);
+
+ FIRM_OP(Minus);
+ FIRM_OP(Not);
+ FIRM_OP(Conv);
+ FIRM_OP(Abs);
+
+ FIRM_OP(Load);
+ FIRM_OP(Store);
+ FIRM_OP(Cond);
+ FIRM_OP(Unknown);
+ FIRM_OP(CopyB);
+
+ /* TODO: implement these nodes */
+ BAD(Mux);
+
+ /* You probably don't need to handle the following nodes */
+
+ IGN(Call);
+ IGN(Proj);
+ IGN(Alloc);
+
+ IGN(Block);
+ IGN(Start);
+ IGN(End);
+ IGN(NoMem);
+ IGN(Phi);
+ IGN(IJmp);
+ IGN(Jmp);
+ IGN(Break);
+ IGN(Sync);
+
+ BAD(Raise);
+ BAD(Sel);
+ BAD(InstOf);
+ BAD(Cast);
+ BAD(Free);
+ BAD(Tuple);
+ BAD(Id);
+ BAD(Bad);
+ BAD(Confirm);
+ BAD(Filter);
+ BAD(CallBegin);
+ BAD(EndReg);
+ BAD(EndExcept);
+
+ FIRM_OP(be_FrameAddr);
+ op_Mulh = get_op_Mulh();
+ if (op_Mulh)
+ FIRM_OP(Mulh);
+ op_Max = get_op_Max();
+ if (op_Max)
+ BAD(Max);
+ op_Min = get_op_Min();
+ if (op_Min)
+ BAD(Min);
+}
+typedef ir_node *(transform_func)(ppc32_transform_env_t *env);
/**
* Transforms the given firm node (and maybe some other related nodes)
* @param env the debug module
*/
void ppc32_transform_node(ir_node *node, void *env) {
- ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
- opcode code = get_irn_opcode(node);
- ir_node *asm_node = NULL;
- ppc32_transform_env_t tenv;
+ ppc32_code_gen_t *cg = (ppc32_code_gen_t *)env;
+ ir_op *op = get_irn_op(node);
+ ir_node *asm_node = NULL;
+ (void) cg;
- if (is_Block(node))
+ if (op == op_Block)
return;
- tenv.block = get_nodes_block(node);
- tenv.dbg = get_irn_dbg_info(node);
- tenv.irg = current_ir_graph;
- tenv.irn = node;
- DEBUG_ONLY(tenv.mod = cgenv->mod;)
- tenv.mode = get_irn_mode(node);
-
-#define UNOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
-#define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
-#define GEN(a) case iro_##a: asm_node = gen_##a(&tenv); break
-#define IGN(a) case iro_##a: break
-#define BAD(a) case iro_##a: goto bad
-#define OTHER_BIN(a) \
- if (get_irn_op(node) == get_op_##a()) { \
- asm_node = gen_##a(&tenv, get_irn_n(node, 0), get_irn_n(node, 1)); \
- break; \
- }
-#define BE_GEN(a) \
- if (be_is_##a(node)) { \
- asm_node = gen_##a(&tenv); \
- break; \
- }
+ DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
- DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
+ if (op->ops.generic) {
+ ppc32_transform_env_t tenv;
+ transform_func *transform = (transform_func *)op->ops.generic;
- switch (code) {
- BINOP(Add);
- BINOP(Mul);
- BINOP(And);
- BINOP(Or);
- BINOP(Eor);
-
- BINOP(Sub);
- BINOP(Shl);
- BINOP(Shr);
- BINOP(Shrs);
- BINOP(Rot);
- BINOP(Quot);
- BINOP(Div);
- BINOP(DivMod);
- BINOP(Mod);
- BINOP(Cmp);
-
- UNOP(Minus);
- UNOP(Not);
- UNOP(Conv);
- UNOP(Abs);
-
- GEN(Load);
- GEN(Store);
- GEN(Cond);
- GEN(Unknown);
- GEN(CopyB);
-
- /* TODO: implement these nodes */
- IGN(Mux);
-
- /* You probably don't need to handle the following nodes */
-
- IGN(Call);
- IGN(Proj);
- IGN(Alloc);
-
- IGN(Block);
- IGN(Start);
- IGN(End);
- IGN(NoMem);
- IGN(Phi);
- IGN(IJmp);
- IGN(Jmp);
- IGN(Break);
- IGN(Sync);
-
- BAD(Raise);
- BAD(Sel);
- BAD(InstOf);
- BAD(Cast);
- BAD(Free);
- BAD(Tuple);
- BAD(Id);
- BAD(Bad);
- BAD(Confirm);
- BAD(Filter);
- BAD(CallBegin);
- BAD(EndReg);
- BAD(EndExcept);
+ tenv.block = get_nodes_block(node);
+ tenv.dbg = get_irn_dbg_info(node);
+ tenv.irg = current_ir_graph;
+ tenv.irn = node;
+ tenv.mode = get_irn_mode(node);
+ DEBUG_ONLY(tenv.mod = cg->mod;)
- default:
- OTHER_BIN(Mulh);
- BE_GEN(FrameAddr);
- BE_GEN(StackParam);
- if (get_irn_op(node) == get_op_Max() ||
- get_irn_op(node) == get_op_Min())
- {
- /* TODO: implement */
- /* ignore for now */
- }
- break;
-bad:
- fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
- assert(0);
+ asm_node = (*transform)(&tenv);
}
if (asm_node) {
exchange(node, asm_node);
- DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
+ DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
}
else {
- DB((tenv.mod, LEVEL_1, "ignored\n"));
+ DB((cg->mod, LEVEL_1, "ignored\n"));
}
}
*/
struct tv_ent {
- entity *ent;
+ ir_entity *ent;
tarval *tv;
};
static int cmp_tv_ent(const void *a, const void *b, size_t len) {
const struct tv_ent *e1 = a;
const struct tv_ent *e2 = b;
+ (void) len;
return !(e1->tv == e2->tv);
}
struct tv_ent *entry;
ir_node *cnst,*symcnst;
ir_graph *rem;
- entity *ent;
+ ir_entity *ent = NULL;
if(!const_set)
const_set = new_set(cmp_tv_ent, 10);
{
ir_node *addr, *load;
ir_mode *mode = env->mode;
- entity *ent;
+ ir_entity *ent;
env->irn = gen_fp_known_symconst(env, tv_const);
env->mode = mode_P;
ent = get_ppc32_frame_entity(env->irn);
ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
if(mode==mode_D)
- load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
+ load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, node_addis, new_NoMem());
else // mode_F
- load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
+ load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
set_ppc32_symconst_ident(load, id_symconst);
set_ppc32_offset_mode(load, ppc32_ao_Lo16);
{
addr = gen_ppc32_SymConst (env);
if(mode==mode_D)
- load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T);
+ load = new_rd_ppc32_Lfd(env->dbg, env->irg, env->block, addr, new_NoMem());
else // mode_F
- load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem(), mode_T);
+ load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
}
return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
}
* Returns true, if the entity can be accessed directly,
* or false, if the address must be loaded first
*/
-int is_direct_entity(entity *ent) {
- return get_entity_visibility(ent)!=visibility_external_allocated;
+int is_direct_entity(ir_entity *ent) {
+ return get_entity_visibility(ent) != visibility_external_allocated;
/* visibility vis = get_entity_visibility(ent);
if(is_Method_type(get_entity_type(ent)))
{
* @return the created ppc Load immediate node
*/
static ir_node *gen_ppc32_SymConst(ppc32_transform_env_t *env) {
- entity *ent = get_ppc32_frame_entity(env->irn);
+ ir_entity *ent = get_ppc32_frame_entity(env->irn);
ident *id_symconst = get_entity_ident(ent);
ir_node *node;
switch(get_nice_modecode(env->mode)){
else
{
ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
- node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem(), mode_T);
+ node = new_rd_ppc32_Lwz(env->dbg, env->irg, env->block, node_addis, new_NoMem());
set_ppc32_symconst_ident(node, id_symconst);
set_ppc32_offset_mode(node, ppc32_ao_Lo16);
node = new_rd_Proj(env->dbg, env->irg, env->block, node, env->mode, pn_Load_res);
-// pset_insert_ptr(symbol_pset, ent);
}
break;
}
ppc32_code_gen_t *cgenv = (ppc32_code_gen_t *)env;
ir_node *asm_node = NULL;
ppc32_transform_env_t tenv;
+ (void) cgenv;
if (is_Block(node))
return;
projects / libfirm / blobdiff