/*
- * 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 Moritz Kroll, Jens Mueller
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
#include "config.h"
-#endif
#include "irnode_t.h"
#include "irgraph_t.h"
#include "iropt_t.h"
#include "irprintf.h"
#include "debug.h"
+#include "error.h"
#include "../benode_t.h"
#include "bearch_ppc32_t.h"
#include "ppc32_nodes_attr.h"
-#include "archop.h"
#include "ppc32_transform.h"
#include "ppc32_new_nodes.h"
#include "ppc32_map_regs.h"
/**
* Returns the proj of a given node with the given proj number
*/
-static INLINE ir_node *get_succ_Proj(ir_node *node, long proj)
+static inline ir_node *get_succ_Proj(ir_node *node, long proj)
{
const ir_edge_t *edge;
foreach_out_edge(node, edge)
}
/**
- * 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))
return 0;
}
default:
- fprintf(stderr, "is_16bit_signed_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
- assert(0);
- return 0;
+ panic("is_16bit_signed_const(): Mode not supported: %F", get_irn_mode(node));
}
}
return 1;
}
default:
- fprintf(stderr, "is_16bit_unsigned_const(): Mode not supported: %s\n", get_mode_name(get_irn_mode(node)));
- assert(0);
- return 0;
+ panic("is_16bit_unsigned_const(): Mode not supported: %F", get_irn_mode(node));
}
}
switch(get_nice_modecode(env->mode)){
case irm_D:
- return new_rd_ppc32_fAdd(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fAdd(env->dbg, env->block, op1, op2, env->mode);
case irm_F:
- return new_rd_ppc32_fAdds(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fAdds(env->dbg, env->block, op1, op2, env->mode);
case irm_Is:
case irm_Iu:
case irm_Hs:
case irm_P:
if(is_16bit_signed_const(op1))
{
- ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op2, env->mode);
+ ir_node *addnode = new_bd_ppc32_Addi(env->dbg, env->block, op2, env->mode);
set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op1));
set_ppc32_offset_mode(addnode, ppc32_ao_None);
return addnode;
}
if(is_16bit_signed_const(op2))
{
- ir_node *addnode = new_rd_ppc32_Addi(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *addnode = new_bd_ppc32_Addi(env->dbg, env->block, op1, env->mode);
set_ppc32_constant_tarval(addnode, get_ppc32_constant_tarval(op2));
set_ppc32_offset_mode(addnode, ppc32_ao_None);
return addnode;
}
- return new_rd_ppc32_Add(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Add(env->dbg, env->block, op1, op2, env->mode);
default:
- fprintf(stderr, "Mode for Add not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Add not supported: %F", env->mode);
}
}
switch(get_nice_modecode(env->mode)){
case irm_D:
- return new_rd_ppc32_fMul(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fMul(env->dbg, env->block, op1, op2, env->mode);
case irm_F:
- return new_rd_ppc32_fMuls(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fMuls(env->dbg, env->block, op1, op2, env->mode);
case irm_Is:
case irm_Iu:
case irm_Hs:
case irm_Hu:
case irm_Bs:
case irm_Bu:
- return new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Mullw(env->dbg, env->block, op1, op2, env->mode);
case irm_P:
default:
- fprintf(stderr, "Mode for Mul not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Mul not supported: %F", env->mode);
}
}
case irm_Is:
case irm_Hs:
case irm_Bs:
- return new_rd_ppc32_Mulhw(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Mulhw(env->dbg, env->block, op1, op2, env->mode);
case irm_Iu:
case irm_Hu:
case irm_Bu:
- return new_rd_ppc32_Mulhwu(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Mulhwu(env->dbg, env->block, op1, op2, env->mode);
case irm_D:
case irm_F:
case irm_P:
default:
- fprintf(stderr, "Mode for Mulh not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Mulh not supported: %F", env->mode);
}
}
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);
+ return new_bd_ppc32_And(env->dbg, env->block, op1, op2, env->mode);
}
/**
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);
+ return new_bd_ppc32_Or(env->dbg, env->block, op1, op2, env->mode);
}
/**
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);
+ return new_bd_ppc32_Xor(env->dbg, env->block, op1, op2, env->mode);
}
/**
switch(get_nice_modecode(env->mode)){
case irm_D:
- return new_rd_ppc32_fSub(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fSub(env->dbg, env->block, op1, op2, env->mode);
case irm_F:
- return new_rd_ppc32_fSubs(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fSubs(env->dbg, env->block, op1, op2, env->mode);
case irm_Is:
case irm_Iu:
case irm_Hs:
case irm_Bs:
case irm_Bu:
case irm_P:
- return new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Sub(env->dbg, env->block, op1, op2, env->mode);
default:
- fprintf(stderr, "Mode for Sub not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Sub not supported: %F", env->mode);
}
}
switch(get_nice_modecode(env->mode)){
case irm_D:
- return new_rd_ppc32_fDiv(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fDiv(env->dbg, env->block, op1, op2, env->mode);
case irm_F:
- return new_rd_ppc32_fDivs(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fDivs(env->dbg, env->block, op1, op2, env->mode);
default:
- fprintf(stderr, "Mode for Quot not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Quot not supported: %F", env->mode);
}
}
case irm_Is:
case irm_Hs:
case irm_Bs:
- return new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ return new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
case irm_Iu:
case irm_Hu:
case irm_Bu:
- return new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ return new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
default:
- fprintf(stderr, "Mode for Div not supported: %s\n", get_mode_name(get_irn_mode(op1)));
- assert(0);
- return NULL;
+ panic("Mode for Div not supported: %F", get_irn_mode(op1));
}
}
case irm_Is:
case irm_Hs:
case irm_Bs:
- div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ div_result = new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
break;
case irm_Iu:
case irm_Hu:
case irm_Bu:
- div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ div_result = new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
break;
default:
- fprintf(stderr, "Mode for DivMod not supported: %s\n", get_mode_name(res_mode));
- assert(0);
- return 0;
-
+ panic("Mode for DivMod not supported: %F", res_mode);
}
if (proj_div == NULL)
ir_node *mul_result;
ir_node *mod_result;
- mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
- mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
+ mul_result = new_bd_ppc32_Mullw(env->dbg, env->block, proj_div, op2, res_mode);
+ mod_result = new_bd_ppc32_Sub(env->dbg, env->block, op1, mul_result, res_mode);
exchange(proj_mod, mod_result);
}
case irm_Is:
case irm_Hs:
case irm_Bs:
- div_result = new_rd_ppc32_Divw(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ div_result = new_bd_ppc32_Divw(env->dbg, env->block, op1, op2, mode_T);
break;
case irm_Iu:
case irm_Hu:
case irm_Bu:
- div_result = new_rd_ppc32_Divwu(env->dbg, env->irg, env->block, op1, op2, mode_T);
+ div_result = new_bd_ppc32_Divwu(env->dbg, env->block, op1, op2, mode_T);
break;
default:
proj_div = new_rd_Proj(env->dbg, env->irg, env->block, div_result, res_mode, pn_DivMod_res_div);
- mul_result = new_rd_ppc32_Mullw(env->dbg, env->irg, env->block, proj_div, op2, res_mode);
- mod_result = new_rd_ppc32_Sub(env->dbg, env->irg, env->block, op1, mul_result, res_mode);
+ mul_result = new_bd_ppc32_Mullw(env->dbg, env->block, proj_div, op2, res_mode);
+ mod_result = new_bd_ppc32_Sub(env->dbg, env->block, op1, mul_result, res_mode);
exchange(proj_mod, mod_result);
if(is_ppc32_Const(op2))
{
- ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *shift = new_bd_ppc32_Rlwinm(env->dbg, 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);
set_ppc32_rlwimi_const(shift, sh, 0, 31-sh);
return shift;
}
- return new_rd_ppc32_Slw(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Slw(env->dbg, env->block, op1, op2, env->mode);
}
/**
if(is_ppc32_Const(op2))
{
- ir_node *shift = new_rd_ppc32_Rlwinm(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *shift = new_bd_ppc32_Rlwinm(env->dbg, 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);
set_ppc32_rlwimi_const(shift, 32-sh, sh, 31);
return shift;
}
- return new_rd_ppc32_Srw(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Srw(env->dbg, env->block, op1, op2, env->mode);
}
/**
if(is_ppc32_Const(op2))
{
- ir_node *shift = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *shift = new_bd_ppc32_Srawi(env->dbg, 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);
+ return new_bd_ppc32_Sraw(env->dbg, env->block, op1, op2, env->mode);
}
/**
- * Creates an ppc RotL.
+ * Creates an ppc Rotl.
*
* @param env The transformation environment
- * @return the created ppc RotL node
+ * @return the created ppc Rotl node
*/
-static ir_node *gen_Rot(ppc32_transform_env_t *env) {
- ir_node *op1 = get_Rot_left(env->irn);
- ir_node *op2 = get_Rot_right(env->irn);
+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);
+ ir_node *rot = new_bd_ppc32_Rlwinm(env->dbg, 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);
set_ppc32_rlwimi_const(rot, sh, 0, 31);
return rot;
}
- return new_rd_ppc32_Rlwnm(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Rlwnm(env->dbg, env->block, op1, op2, env->mode);
}
/**
}
if(mode_is_float(env->mode))
- return new_rd_ppc32_fCmpu(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_fCmpu(env->dbg, env->block, op1, op2, env->mode);
else if(mode_is_signed(env->mode))
{
if(is_16bit_signed_const(op2))
{
- ir_node *cmp = new_rd_ppc32_Cmpi(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *cmp = new_bd_ppc32_Cmpi(env->dbg, env->block, op1, env->mode);
tarval *tv_const = get_ppc32_constant_tarval(op2);
set_ppc32_constant_tarval(cmp, tv_const);
set_ppc32_offset_mode(cmp, ppc32_ao_None);
}
else
{
- return new_rd_ppc32_Cmp(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Cmp(env->dbg, env->block, op1, op2, env->mode);
}
}
else
{
if(is_16bit_unsigned_const(op2))
{
- ir_node *cmp = new_rd_ppc32_Cmpli(env->dbg, env->irg, env->block, op1, env->mode);
+ ir_node *cmp = new_bd_ppc32_Cmpli(env->dbg, env->block, op1, env->mode);
tarval *tv_const = get_ppc32_constant_tarval(op2);
set_ppc32_constant_tarval(cmp, tv_const);
set_ppc32_offset_mode(cmp, ppc32_ao_None);
}
else
{
- return new_rd_ppc32_Cmpl(env->dbg, env->irg, env->block, op1, op2, env->mode);
+ return new_bd_ppc32_Cmpl(env->dbg, env->block, op1, op2, env->mode);
}
}
}
switch(get_nice_modecode(env->mode)){
case irm_D:
case irm_F:
- return new_rd_ppc32_fNeg(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_fNeg(env->dbg, env->block, op, env->mode);
case irm_Is:
case irm_Iu:
case irm_Hs:
case irm_Bs:
case irm_Bu:
case irm_P:
- return new_rd_ppc32_Neg(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Neg(env->dbg, env->block, op, env->mode);
default:
- fprintf(stderr, "Mode for Neg not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return NULL;
+ panic("Mode for Neg not supported: %F", env->mode);
}
}
* @return the created ppc Not node
*/
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);
+ return new_bd_ppc32_Not(env->dbg, env->block, get_Not_op(env->irn), env->mode);
}
static ir_node *own_gen_Andi_dot_lo16(ppc32_transform_env_t *env, ir_node *op, int mask)
{
- ir_node *andi = new_rd_ppc32_Andi_dot(env->dbg, env->irg, env->block, op, mode_T);
+ ir_node *andi = new_bd_ppc32_Andi_dot(env->dbg, env->block, op, mode_T);
ir_node* in[1];
set_ppc32_offset_mode(andi, ppc32_ao_Lo16);
set_ppc32_constant_tarval(andi, new_tarval_from_long(mask, mode_Is));
*/
static ir_node *gen_Conv(ppc32_transform_env_t *env) {
ir_node *op = get_Conv_op(env->irn);
- modecode from_mode=get_nice_modecode(get_irn_mode(op));
- modecode to_mode=get_nice_modecode(env->mode);
+ ir_modecode from_mode=get_nice_modecode(get_irn_mode(op));
+ ir_modecode to_mode=get_nice_modecode(env->mode);
#define SKIP return op
switch(to_mode)
{
case irm_F:
- return new_rd_ppc32_fRsp(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_fRsp(env->dbg, env->block, op, env->mode);
default:
break;
}
switch(to_mode)
{
case irm_Hs:
- return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Extsh(env->dbg, env->block, op, env->mode);
case irm_Hu:
return own_gen_Andi_dot_lo16(env, op, 0xffff);
case irm_Bs:
- return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
case irm_Bu:
return own_gen_Andi_dot_lo16(env, op, 0xff);
case irm_Is:
case irm_Is:
SKIP;
case irm_Bs:
- return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
case irm_Bu:
return own_gen_Andi_dot_lo16(env, op, 0xff);
case irm_Hs:
- return new_rd_ppc32_Extsh(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Extsh(env->dbg, env->block, op, env->mode);
default:
break;
}
case irm_Hs:
SKIP;
case irm_Bs:
- return new_rd_ppc32_Extsb(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_Extsb(env->dbg, env->block, op, env->mode);
default:
break;
}
break;
}
- 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 NULL;
-
+ panic("Mode for Conv not supported: %F -> %F", get_irn_mode(op), env->mode);
#undef SKIP
}
{
case irm_F:
case irm_D:
- return new_rd_ppc32_fAbs(env->dbg, env->irg, env->block, op, env->mode);
+ return new_bd_ppc32_fAbs(env->dbg, env->block, op, env->mode);
case irm_Is:
shift += 16;
case irm_Hs:
shift += 8;
case irm_Bs:
- n1 = new_rd_ppc32_Srawi(env->dbg, env->irg, env->block, op, env->mode);
+ n1 = new_bd_ppc32_Srawi(env->dbg, 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);
- n2 = new_rd_ppc32_Add(env->dbg, env->irg, env->block, op, n1, env->mode);
- return new_rd_ppc32_Xor(env->dbg, env->irg, env->block, n2, n1, env->mode);
+ n2 = new_bd_ppc32_Add(env->dbg, env->block, op, n1, env->mode);
+ return new_bd_ppc32_Xor(env->dbg, env->block, n2, n1, env->mode);
default:
break;
}
- fprintf(stderr, "Mode for Abs not supported: %s\n", get_mode_name(env->mode));
- assert(0);
+ panic("Mode for Abs not supported: %F", env->mode);
return NULL;
}
if(is_Proj(selector) && projmode==get_ppc32_mode_Cond())
{
int projnum = get_Proj_proj(selector);
- ir_node *branch = new_rd_ppc32_Branch(env->dbg, env->irg, env->block, selector, env->mode);
+ ir_node *branch = new_bd_ppc32_Branch(env->dbg, env->block, selector, env->mode);
set_ppc32_proj_nr(branch, projnum);
return branch;
}
else
{
- ir_node *unknown_gpr = new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, mode_Is);
- ir_node *unknown_cond = new_rd_ppc32_cUnknown(env->dbg, env->irg, env->block, get_ppc32_mode_Cond());
+ ir_node *unknown_gpr = new_bd_ppc32_Unknown(env->dbg, env->block, mode_Is);
+ ir_node *unknown_cond = new_bd_ppc32_cUnknown(env->dbg, env->block, get_ppc32_mode_Cond());
- ir_node *switch_node = new_rd_ppc32_Switch(env->dbg, env->irg, env->block, selector,
+ ir_node *switch_node = new_bd_ppc32_Switch(env->dbg, env->block, selector,
unknown_gpr, unknown_cond, env->mode);
set_ppc32_proj_nr(switch_node, get_Cond_defaultProj(env->irn));
*/
static ir_node *gen_Unknown(ppc32_transform_env_t *env) {
if(mode_is_float(env->mode))
- return new_rd_ppc32_fUnknown(env->dbg, env->irg, env->block, env->mode);
+ return new_bd_ppc32_fUnknown(env->dbg, env->block, env->mode);
else if (mode_is_int(env->mode))
- return new_rd_ppc32_Unknown(env->dbg, env->irg, env->block, env->mode);
+ return new_bd_ppc32_Unknown(env->dbg, env->block, env->mode);
else
- {
- fprintf(stderr, "Mode %s for unknown value not supported.\n", get_mode_name(env->mode));
- assert(0);
- return 0;
- }
+ panic("Mode %F for unknown value not supported.", env->mode);
}
static ir_node *ldst_insert_const(ir_node *ptr, tarval **ptv, ident **pid, ppc32_transform_env_t *env) {
if(is_ppc32_Const(ptr))
{
tv_const = get_ppc32_constant_tarval(ptr);
- ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
+ ptr = new_bd_ppc32_Addis_zero(env->dbg, env->block, mode_P, ppc32_ao_Ha16, tv_const, NULL);
}
else if(is_ppc32_SymConst(ptr))
{
if(is_direct_entity(ent))
{
id_symconst = get_entity_ident(ent);
- ptr = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
+ ptr = new_bd_ppc32_Addis_zero(env->dbg, env->block, mode_P, ppc32_ao_Ha16, NULL, id_symconst);
}
}
*ptv = tv_const;
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));
+ load = new_bd_ppc32_Lbz(env->dbg, 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));
+ load = new_bd_ppc32_Lbz(env->dbg, 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);
+ extsb_node = new_bd_ppc32_Extsb(env->dbg, env->block, proj_load, mode);
exchange(get_succ_Proj(env->irn, pn_Load_res), extsb_node);
break;
}
case irm_Hu:
- load = new_rd_ppc32_Lhz(env->dbg, env->irg, env->block, loadptr, get_Load_mem(node));
+ load = new_bd_ppc32_Lhz(env->dbg, 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));
+ load =new_bd_ppc32_Lha(env->dbg, 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));
+ load = new_bd_ppc32_Lwz(env->dbg, 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));
+ load = new_bd_ppc32_Lfd(env->dbg, 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));
+ load = new_bd_ppc32_Lfs(env->dbg, env->block, loadptr, get_Load_mem(node));
break;
default:
- fprintf(stderr, "Mode for Load not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return 0;
+ panic("Mode for Load not supported: %F", env->mode);
}
if(tv_const)
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));
+ store = new_bd_ppc32_Stb(env->dbg, 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));
+ store = new_bd_ppc32_Sth(env->dbg, 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));
+ store = new_bd_ppc32_Stw(env->dbg, 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));
+ store = new_bd_ppc32_Stfd(env->dbg, 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));
+ store = new_bd_ppc32_Stfs(env->dbg, env->block, storeptr, get_Store_value(node), get_Store_mem(node));
break;
default:
- fprintf(stderr, "Mode for Store not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return 0;
+ panic("Mode for Store not supported: %F", env->mode);
}
if(tv_const)
{
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);
+ load = new_bd_ppc32_Lwz(env->dbg, 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);
+ store = new_bd_ppc32_Stw(env->dbg, 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);
+ load = new_bd_ppc32_Lwz(env->dbg, 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);
+ store = new_bd_ppc32_Stw(env->dbg, 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);
assert(size/4-1<=0xffff);
if(size/4-1<0x8000)
{
- ornode = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
+ ornode = new_bd_ppc32_Addi_zero(env->dbg, env->block, mode_Is);
set_ppc32_offset_mode(ornode, ppc32_ao_None);
}
else
{
- ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
+ ir_node *zeroreg = new_bd_ppc32_Addi_zero(env->dbg, env->block, mode_Is);
set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
- ornode = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
+ ornode = new_bd_ppc32_Ori(env->dbg, env->block, zeroreg, mode_Is);
set_ppc32_offset_mode(ornode, ppc32_ao_Lo16);
}
set_ppc32_constant_tarval(ornode, new_tarval_from_long(size/4-1, mode_Is));
- mtctrnode = new_rd_ppc32_Mtctr(env->dbg, env->irg, env->block, ornode, mode_Is);
- store = new_rd_ppc32_LoopCopy(env->dbg, env->irg, env->block, src, dest, mtctrnode, mem, mode_T);
+ mtctrnode = new_bd_ppc32_Mtctr(env->dbg, env->block, ornode, mode_Is);
+ store = new_bd_ppc32_LoopCopy(env->dbg, env->block, src, dest, mtctrnode, mem, mode_T);
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
{
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);
+ load = new_bd_ppc32_Lhz(env->dbg, 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);
+ store = new_bd_ppc32_Sth(env->dbg, 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);
{
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);
+ load = new_bd_ppc32_Lbz(env->dbg, 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);
+ store = new_bd_ppc32_Stb(env->dbg, 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);
*/
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);
+ ir_node *add = new_bd_ppc32_Addi(env->dbg, 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
- *
- * @param env The transformation environment
- */
-static ir_node *gen_be_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());
- 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;
+ panic("Transformation not implemented: %+F\n", env->irn);
}
/**
FIRM_OP(Shl);
FIRM_OP(Shr);
FIRM_OP(Shrs);
- FIRM_OP(Rot);
+ FIRM_OP(Rotl);
FIRM_OP(Quot);
FIRM_OP(Div);
FIRM_OP(DivMod);
BAD(Free);
BAD(Tuple);
BAD(Id);
- BAD(Bad);
+ //BAD(Bad);
BAD(Confirm);
BAD(Filter);
BAD(CallBegin);
BAD(EndExcept);
FIRM_OP(be_FrameAddr);
- FIRM_OP(be_StackParam);
op_Mulh = get_op_Mulh();
if (op_Mulh)
FIRM_OP(Mulh);
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 (op == op_Block)
return;
const code irg */
rem = current_ir_graph;
current_ir_graph = get_const_code_irg();
- cnst = new_Const(env->mode, key.tv);
+ cnst = new_Const(key.tv);
current_ir_graph = rem;
set_atomic_ent_value(ent, cnst);
entry->ent = ent;
} // TODO: Wird nicht richtig in global type gesteckt, ppc32_gen_decls.c findet ihn nicht
- symcnst = new_rd_ppc32_SymConst(env->dbg, env->irg, env->block, env->mode);
+ symcnst = new_bd_ppc32_SymConst(env->dbg, env->block, env->mode);
set_ppc32_frame_entity(symcnst, ent);
return symcnst;
}
unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
if(val1&0x80)
{
- ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
+ ir_node *zeroreg = new_bd_ppc32_Addi_zero(env->dbg, env->block, mode_Is);
set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
- node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
+ node = new_bd_ppc32_Ori(env->dbg, env->block, zeroreg, mode_Is);
set_ppc32_offset_mode(node, ppc32_ao_Lo16);
break;
}
case irm_Bu:
case irm_Bs:
case irm_Hs:
- node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
+ node = new_bd_ppc32_Addi_zero(env->dbg, env->block, env->mode);
set_ppc32_offset_mode(node, ppc32_ao_None);
break;
case irm_Is:
unsigned char val1 = get_tarval_sub_bits(tv_const, 1);
if(val1&0x80)
{
- ir_node *zeroreg = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, mode_Is);
+ ir_node *zeroreg = new_bd_ppc32_Addi_zero(env->dbg, env->block, mode_Is);
set_ppc32_constant_tarval(zeroreg, new_tarval_from_long(0, mode_Is));
set_ppc32_offset_mode(zeroreg, ppc32_ao_None);
- node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, zeroreg, mode_Is);
+ node = new_bd_ppc32_Ori(env->dbg, env->block, zeroreg, mode_Is);
set_ppc32_offset_mode(node, ppc32_ao_Lo16);
}
else
{
- node = new_rd_ppc32_Addi_zero(env->dbg, env->irg, env->block, env->mode);
+ node = new_bd_ppc32_Addi_zero(env->dbg, env->block, env->mode);
set_ppc32_offset_mode(node, ppc32_ao_None);
}
}
{
unsigned char val0 = get_tarval_sub_bits(tv_const,0);
unsigned char val1 = get_tarval_sub_bits(tv_const,1);
- node = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
+ node = new_bd_ppc32_Addis_zero(env->dbg, env->block, env->mode, ppc32_ao_Hi16, tv_const, NULL);
if(val0 || val1)
{
set_ppc32_constant_tarval(node, tv_const);
- node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node, env->mode);
+ node = new_bd_ppc32_Ori(env->dbg, env->block, node, env->mode);
set_ppc32_offset_mode(node, ppc32_ao_Lo16);
}
}
}
default:
- fprintf(stderr, "Mode for Const not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return 0;
+ panic("Mode for Const not supported: %F", env->mode);
}
set_ppc32_constant_tarval(node, tv_const);
return node;
if(is_direct_entity(ent))
{
ident *id_symconst = get_entity_ident(ent);
- ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
+ ir_node *node_addis = new_bd_ppc32_Addis_zero(env->dbg, 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());
+ load = new_bd_ppc32_Lfd(env->dbg, env->block, node_addis, new_NoMem());
else // mode_F
- load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, node_addis, new_NoMem());
+ load = new_bd_ppc32_Lfs(env->dbg, 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());
+ load = new_bd_ppc32_Lfd(env->dbg, env->block, addr, new_NoMem());
else // mode_F
- load = new_rd_ppc32_Lfs(env->dbg, env->irg, env->block, addr, new_NoMem());
+ load = new_bd_ppc32_Lfs(env->dbg, env->block, addr, new_NoMem());
}
return new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
}
default:
- fprintf(stderr, "Mode for fConst not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return 0;
+ panic("Mode for fConst not supported: %F", env->mode);
}
- assert(0 && "Dead end!");
}
{
if (is_direct_entity(ent))
{
- ir_node *node_addis = new_rd_ppc32_Addis_zero(env->dbg, env->irg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
- node = new_rd_ppc32_Ori(env->dbg, env->irg, env->block, node_addis, env->mode);
+ ir_node *node_addis = new_bd_ppc32_Addis_zero(env->dbg, env->block, env->mode, ppc32_ao_Hi16, NULL, id_symconst);
+ node = new_bd_ppc32_Ori(env->dbg, env->block, node_addis, env->mode);
set_ppc32_symconst_ident(node, id_symconst);
set_ppc32_offset_mode(node, ppc32_ao_Lo16);
}
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());
+ ir_node *node_addis = new_bd_ppc32_Addis_zero(env->dbg, env->block, env->mode, ppc32_ao_Ha16, NULL, id_symconst);
+ node = new_bd_ppc32_Lwz(env->dbg, 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);
}
default:
- fprintf(stderr, "Mode for SymConst not supported: %s\n", get_mode_name(env->mode));
- assert(0);
- return 0;
+ panic("Mode for SymConst not supported: %F", env->mode);
}
return node;
}
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