-/* 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 "error.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(ir_entity *ent);
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))
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));
}
}
return new_rd_ppc32_Add(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 NULL;
+ panic("Mode for Add not supported: %F", 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_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);
}
}
return new_rd_ppc32_Sub(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 NULL;
+ panic("Mode for Sub not supported: %F", env->mode);
}
}
return new_rd_ppc32_fDivs(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 NULL;
+ panic("Mode for Quot not supported: %F", env->mode);
}
}
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(op1)));
- assert(0);
- return NULL;
+ panic("Mode for Div not supported: %F", get_irn_mode(op1));
}
}
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)
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;
}
/**
- * 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))
{
return new_rd_ppc32_Neg(env->dbg, env->irg, 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);
}
}
*/
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
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
}
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;
}
else if (mode_is_int(env->mode))
return new_rd_ppc32_Unknown(env->dbg, env->irg, 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) {
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)
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)
{
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);
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;
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;
- ir_entity *ent;
+ ir_entity *ent = NULL;
if(!const_set)
const_set = new_set(cmp_tv_ent, 10);
}
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;
}
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!");
}
* or false, if the address must be loaded first
*/
int is_direct_entity(ir_entity *ent) {
- return get_entity_visibility(ent)!=visibility_external_allocated;
+ return get_entity_visibility(ent) != visibility_external_allocated;
/* visibility vis = get_entity_visibility(ent);
if(is_Method_type(get_entity_type(ent)))
{
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;
}
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