/*
- * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include "ircons_t.h"
#include "iropt_t.h"
#include "irop.h"
-#include "irvrfy_t.h"
#include "irprintf.h"
#include "xmalloc.h"
fprintf(F, "%s", get_irn_opname(n));
if (arm_has_symconst_attr(n)) {
- const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(n);
+ const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(n);
if (attr->entity != NULL) {
fputc(' ', F);
fputs(get_entity_name(attr->entity), F);
fputc('\n', F);
}
if (arm_has_symconst_attr(n)) {
- const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(n);
+ const arm_SymConst_attr_t *attr = get_arm_SymConst_attr_const(n);
fprintf(F, "entity = ");
if (attr->entity != NULL) {
arm_attr_t *get_arm_attr(ir_node *node)
{
assert(is_arm_irn(node) && "need arm node to get attributes");
- return get_irn_generic_attr(node);
+ return (arm_attr_t*)get_irn_generic_attr(node);
}
const arm_attr_t *get_arm_attr_const(const ir_node *node)
{
assert(is_arm_irn(node) && "need arm node to get attributes");
- return get_irn_generic_attr_const(node);
+ return (const arm_attr_t*)get_irn_generic_attr_const(node);
}
static bool has_symconst_attr(const ir_node *node)
arm_SymConst_attr_t *get_arm_SymConst_attr(ir_node *node)
{
assert(has_symconst_attr(node));
- return get_irn_generic_attr(node);
+ return (arm_SymConst_attr_t*)get_irn_generic_attr(node);
}
const arm_SymConst_attr_t *get_arm_SymConst_attr_const(const ir_node *node)
{
assert(has_symconst_attr(node));
- return get_irn_generic_attr_const(node);
+ return (const arm_SymConst_attr_t*)get_irn_generic_attr_const(node);
}
static const arm_fConst_attr_t *get_arm_fConst_attr_const(const ir_node *node)
{
assert(is_arm_fConst(node));
- return get_irn_generic_attr_const(node);
+ return (const arm_fConst_attr_t*)get_irn_generic_attr_const(node);
}
static arm_fConst_attr_t *get_arm_fConst_attr(ir_node *node)
{
assert(is_arm_fConst(node));
- return get_irn_generic_attr(node);
+ return (arm_fConst_attr_t*)get_irn_generic_attr(node);
}
arm_farith_attr_t *get_arm_farith_attr(ir_node *node)
{
assert(has_farith_attr(node));
- return get_irn_generic_attr(node);
+ return (arm_farith_attr_t*)get_irn_generic_attr(node);
}
const arm_farith_attr_t *get_arm_farith_attr_const(const ir_node *node)
{
assert(has_farith_attr(node));
- return get_irn_generic_attr_const(node);
+ return (const arm_farith_attr_t*)get_irn_generic_attr_const(node);
}
arm_CondJmp_attr_t *get_arm_CondJmp_attr(ir_node *node)
{
assert(is_arm_B(node));
- return get_irn_generic_attr(node);
+ return (arm_CondJmp_attr_t*)get_irn_generic_attr(node);
}
const arm_CondJmp_attr_t *get_arm_CondJmp_attr_const(const ir_node *node)
{
assert(is_arm_B(node));
- return get_irn_generic_attr_const(node);
+ return (const arm_CondJmp_attr_t*)get_irn_generic_attr_const(node);
}
arm_SwitchJmp_attr_t *get_arm_SwitchJmp_attr(ir_node *node)
{
assert(is_arm_SwitchJmp(node));
- return get_irn_generic_attr(node);
+ return (arm_SwitchJmp_attr_t*)get_irn_generic_attr(node);
}
const arm_SwitchJmp_attr_t *get_arm_SwitchJmp_attr_const(const ir_node *node)
{
assert(is_arm_SwitchJmp(node));
- return get_irn_generic_attr_const(node);
+ return (const arm_SwitchJmp_attr_t*)get_irn_generic_attr_const(node);
}
-void set_arm_in_req_all(ir_node *node, const arch_register_req_t **reqs)
+arm_CopyB_attr_t *get_arm_CopyB_attr(ir_node *node)
{
- arm_attr_t *attr = get_arm_attr(node);
- attr->in_req = reqs;
+ assert(is_arm_CopyB(node));
+ return (arm_CopyB_attr_t*)get_irn_generic_attr(node);
}
-const arch_register_req_t *get_arm_in_req(const ir_node *node, int pos)
+const arm_CopyB_attr_t *get_arm_CopyB_attr_const(const ir_node *node)
{
- const arm_attr_t *attr = get_arm_attr_const(node);
- return attr->in_req[pos];
+ assert(is_arm_CopyB(node));
+ return (const arm_CopyB_attr_t*)get_irn_generic_attr_const(node);
}
-void set_arm_req_in(ir_node *node, const arch_register_req_t *req, int pos)
-{
- arm_attr_t *attr = get_arm_attr(node);
- attr->in_req[pos] = req;
-}
-
-tarval *get_fConst_value(const ir_node *node)
+ir_tarval *get_fConst_value(const ir_node *node)
{
const arm_fConst_attr_t *attr = get_arm_fConst_attr_const(node);
return attr->tv;
}
-void set_fConst_value(ir_node *node, tarval *tv)
+void set_fConst_value(ir_node *node, ir_tarval *tv)
{
arm_fConst_attr_t *attr = get_arm_fConst_attr(node);
attr->tv = tv;
}
-pn_Cmp get_arm_CondJmp_pnc(const ir_node *node)
+ir_relation get_arm_CondJmp_relation(const ir_node *node)
{
const arm_CondJmp_attr_t *attr = get_arm_CondJmp_attr_const(node);
- return attr->pnc;
+ return attr->relation;
}
-void set_arm_CondJmp_pnc(ir_node *node, pn_Cmp pnc)
+void set_arm_CondJmp_relation(ir_node *node, ir_relation relation)
{
arm_CondJmp_attr_t *attr = get_arm_CondJmp_attr(node);
- attr->pnc = pnc;
+ attr->relation = relation;
}
int get_arm_SwitchJmp_n_projs(const ir_node *node)
}
/* Set the ARM machine node attributes to default values. */
-static void init_arm_attributes(ir_node *node, int flags,
+static void init_arm_attributes(ir_node *node, arch_irn_flags_t flags,
const arch_register_req_t ** in_reqs,
const be_execution_unit_t ***execution_units,
int n_res)
(void) execution_units;
arch_irn_set_flags(node, flags);
- attr->in_req = in_reqs;
+ arch_set_in_register_reqs(node, in_reqs);
attr->is_load_store = false;
info = be_get_info(node);
int entity_sign, long offset,
bool is_frame_entity)
{
- arm_load_store_attr_t *attr = get_irn_generic_attr(res);
+ arm_load_store_attr_t *attr = get_arm_load_store_attr(res);
attr->load_store_mode = ls_mode;
attr->entity = entity;
attr->entity_sign = entity_sign;
arm_shift_modifier_t shift_modifier,
unsigned shift_immediate)
{
- arm_shifter_operand_t *attr = get_irn_generic_attr(res);
+ arm_shifter_operand_t *attr = get_arm_shifter_operand_attr(res);
attr->immediate_value = immediate_value;
attr->shift_modifier = shift_modifier;
attr->shift_immediate = shift_immediate;
static void init_arm_cmp_attr(ir_node *res, bool ins_permuted, bool is_unsigned)
{
- arm_cmp_attr_t *attr = get_irn_generic_attr(res);
+ arm_cmp_attr_t *attr = get_arm_cmp_attr(res);
attr->ins_permuted = ins_permuted;
attr->is_unsigned = is_unsigned;
}
static void init_arm_SymConst_attributes(ir_node *res, ir_entity *entity,
int symconst_offset)
{
- arm_SymConst_attr_t *attr = get_irn_generic_attr(res);
+ arm_SymConst_attr_t *attr = get_arm_SymConst_attr(res);
attr->entity = entity;
attr->fp_offset = symconst_offset;
}
static void init_arm_farith_attributes(ir_node *res, ir_mode *mode)
{
- arm_farith_attr_t *attr = get_irn_generic_attr(res);
+ arm_farith_attr_t *attr = get_arm_farith_attr(res);
attr->mode = mode;
}
static void init_arm_CopyB_attributes(ir_node *res, unsigned size)
{
- arm_CopyB_attr_t *attr = get_irn_generic_attr(res);
+ arm_CopyB_attr_t *attr = get_arm_CopyB_attr(res);
attr->size = size;
}
-static int cmp_attr_arm(ir_node *a, ir_node *b)
+static int cmp_attr_arm(const ir_node *a, const ir_node *b)
{
(void) a;
(void) b;
return 0;
}
-static int cmp_attr_arm_SymConst(ir_node *a, ir_node *b)
+static int cmp_attr_arm_SymConst(const ir_node *a, const ir_node *b)
{
const arm_SymConst_attr_t *attr_a;
const arm_SymConst_attr_t *attr_b;
if (cmp_attr_arm(a, b))
return 1;
- attr_a = get_irn_generic_attr_const(a);
- attr_b = get_irn_generic_attr_const(b);
+ attr_a = get_arm_SymConst_attr_const(a);
+ attr_b = get_arm_SymConst_attr_const(b);
return attr_a->entity != attr_b->entity
|| attr_a->fp_offset != attr_b->fp_offset;
}
-static int cmp_attr_arm_CopyB(ir_node *a, ir_node *b)
+static int cmp_attr_arm_CopyB(const ir_node *a, const ir_node *b)
{
const arm_CopyB_attr_t *attr_a;
const arm_CopyB_attr_t *attr_b;
if (cmp_attr_arm(a, b))
return 1;
- attr_a = get_irn_generic_attr_const(a);
- attr_b = get_irn_generic_attr_const(b);
+ attr_a = get_arm_CopyB_attr_const(a);
+ attr_b = get_arm_CopyB_attr_const(b);
return attr_a->size != attr_b->size;
}
-static int cmp_attr_arm_CondJmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_CondJmp(const ir_node *a, const ir_node *b)
{
(void) a;
(void) b;
return 1;
}
-static int cmp_attr_arm_SwitchJmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_SwitchJmp(const ir_node *a, const ir_node *b)
{
(void) a;
(void) b;
return 1;
}
-static int cmp_attr_arm_fConst(ir_node *a, ir_node *b)
+static int cmp_attr_arm_fConst(const ir_node *a, const ir_node *b)
{
const arm_fConst_attr_t *attr_a;
const arm_fConst_attr_t *attr_b;
return (const arm_cmp_attr_t*) get_irn_generic_attr_const(node);
}
-static int cmp_attr_arm_load_store(ir_node *a, ir_node *b)
+static int cmp_attr_arm_load_store(const ir_node *a, const ir_node *b)
{
const arm_load_store_attr_t *attr_a;
const arm_load_store_attr_t *attr_b;
if (cmp_attr_arm(a, b))
return 1;
- attr_a = get_arm_load_store_attr(a);
- attr_b = get_arm_load_store_attr(b);
+ attr_a = get_arm_load_store_attr_const(a);
+ attr_b = get_arm_load_store_attr_const(b);
if (attr_a->entity != attr_b->entity
|| attr_a->entity_sign != attr_b->entity_sign
|| attr_a->offset != attr_b->offset)
return 0;
}
-static int cmp_attr_arm_shifter_operand(ir_node *a, ir_node *b)
+static int cmp_attr_arm_shifter_operand(const ir_node *a, const ir_node *b)
{
const arm_shifter_operand_t *attr_a;
const arm_shifter_operand_t *attr_b;
if (cmp_attr_arm(a, b))
return 1;
- attr_a = get_arm_shifter_operand_attr(a);
- attr_b = get_arm_shifter_operand_attr(b);
+ attr_a = get_arm_shifter_operand_attr_const(a);
+ attr_b = get_arm_shifter_operand_attr_const(b);
if (attr_a->shift_modifier != attr_b->shift_modifier
|| attr_a->immediate_value != attr_b->immediate_value
|| attr_a->shift_immediate != attr_b->shift_immediate)
return 0;
}
-static int cmp_attr_arm_cmp(ir_node *a, ir_node *b)
+static int cmp_attr_arm_cmp(const ir_node *a, const ir_node *b)
{
const arm_cmp_attr_t *attr_a;
const arm_cmp_attr_t *attr_b;
if (cmp_attr_arm(a, b))
return 1;
- attr_a = get_irn_generic_attr_const(a);
- attr_b = get_irn_generic_attr_const(b);
+ attr_a = get_arm_cmp_attr_const(a);
+ attr_b = get_arm_cmp_attr_const(b);
if (attr_a->ins_permuted != attr_b->ins_permuted
|| attr_a->is_unsigned != attr_b->is_unsigned)
return 1;
return 0;
}
-static int cmp_attr_arm_farith(ir_node *a, ir_node *b)
+static int cmp_attr_arm_farith(const ir_node *a, const ir_node *b)
{
const arm_farith_attr_t *attr_a;
const arm_farith_attr_t *attr_b;
/* copy out flags */
new_info->out_infos =
DUP_ARR_D(reg_out_info_t, obst, old_info->out_infos);
+ new_info->in_reqs = old_info->in_reqs;
}
projects / libfirm / blobdiff