X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fsparc%2Fsparc_new_nodes.c;h=7b76a3a42a04c4bcb8ff8f1029637c4354214791;hb=b38e2c8fb2d6b9f713f0948a536a28b623b0732b;hp=af2c957a31b7c340d67cf7c906bf4d8cabeef484;hpb=044ec2b36b5d14946a7e8032a4e595e9fd08ea16;p=libfirm diff --git a/ir/be/sparc/sparc_new_nodes.c b/ir/be/sparc/sparc_new_nodes.c index af2c957a3..7b76a3a42 100644 --- a/ir/be/sparc/sparc_new_nodes.c +++ b/ir/be/sparc/sparc_new_nodes.c @@ -1,20 +1,6 @@ /* - * 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. + * Copyright (C) 2012 University of Karlsruhe. */ /** @@ -22,7 +8,7 @@ * @brief This file implements the creation of the achitecture specific firm * opcodes and the coresponding node constructors for the sparc * assembler irg. - * @version $Id$ + * @author Hannes Rapp, Matthias Braun */ #include "config.h" @@ -38,17 +24,13 @@ #include "irprintf.h" #include "xmalloc.h" -#include "../bearch.h" +#include "bearch.h" +#include "bearch_sparc_t.h" #include "sparc_nodes_attr.h" #include "sparc_new_nodes.h" #include "gen_sparc_regalloc_if.h" -static bool has_symconst_attr(const ir_node *node) -{ - return is_sparc_SymConst(node) || is_sparc_FrameAddr(node); -} - bool sparc_has_load_store_attr(const ir_node *node) { return is_sparc_Ld(node) || is_sparc_St(node) || is_sparc_Ldf(node) @@ -60,16 +42,11 @@ static bool has_jmp_cond_attr(const ir_node *node) return is_sparc_Bicc(node) || is_sparc_fbfcc(node); } -static bool has_jmp_switch_attr(const ir_node *node) +static bool has_switch_jmp_attr(const ir_node *node) { return is_sparc_SwitchJmp(node); } -static bool has_save_attr(const ir_node *node) -{ - return is_sparc_Save(node); -} - static bool has_fp_attr(const ir_node *node) { return is_sparc_fadd(node) || is_sparc_fsub(node) @@ -89,8 +66,10 @@ static bool has_fp_conv_attr(const ir_node *node) * @param n the node to dump * @param reason indicates which kind of information should be dumped */ -static void sparc_dump_node(FILE *F, ir_node *n, dump_reason_t reason) +static void sparc_dump_node(FILE *F, const ir_node *n, dump_reason_t reason) { + const sparc_attr_t *sparc_attr; + switch (reason) { case dump_node_opcode_txt: fprintf(F, "%s", get_irn_opname(n)); @@ -101,36 +80,27 @@ static void sparc_dump_node(FILE *F, ir_node *n, dump_reason_t reason) case dump_node_info_txt: arch_dump_reqs_and_registers(F, n); - if (has_save_attr(n)) { - const sparc_save_attr_t *attr = get_sparc_save_attr_const(n); - fprintf(F, "initial stacksize: %d\n", attr->initial_stacksize); - } - if (has_symconst_attr(n)) { - const sparc_symconst_attr_t *attr = get_sparc_symconst_attr_const(n); - ir_fprintf(F, "entity: %+F\n", attr->entity); - fprintf(F, "fp_offset: %d\n", attr->fp_offset); + sparc_attr = get_sparc_attr_const(n); + if (sparc_attr->immediate_value_entity) { + ir_fprintf(F, "entity: %+F (offset %d)\n", + sparc_attr->immediate_value_entity, + sparc_attr->immediate_value); + } else { + ir_fprintf(F, "immediate value: %d\n", sparc_attr->immediate_value); } if (sparc_has_load_store_attr(n)) { const sparc_load_store_attr_t *attr = get_sparc_load_store_attr_const(n); ir_fprintf(F, "load store mode: %+F\n", attr->load_store_mode); - ir_fprintf(F, "entity: (sign %d) %+F\n", attr->entity_sign, - attr->entity); - fprintf(F, "offset: %ld\n", attr->offset); fprintf(F, "is frame entity: %s\n", attr->is_frame_entity ? "true" : "false"); } if (has_jmp_cond_attr(n)) { const sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr_const(n); - fprintf(F, "pnc: %d (%s)\n", attr->pnc, get_pnc_string(attr->pnc)); + fprintf(F, "relation: %d (%s)\n", (int)attr->relation, + get_relation_string(attr->relation)); fprintf(F, "unsigned: %s\n", attr->is_unsigned ? "true" : "false"); } - if (has_jmp_switch_attr(n)) { - const sparc_jmp_switch_attr_t *attr - = get_sparc_jmp_switch_attr_const(n); - fprintf(F, "n projs: %d\n", attr->n_projs); - fprintf(F, "default proj: %ld\n", attr->default_proj_num); - } if (has_fp_attr(n)) { const sparc_fp_attr_t *attr = get_sparc_fp_attr_const(n); ir_fprintf(F, "fp_mode: %+F\n", attr->fp_mode); @@ -147,45 +117,23 @@ static void sparc_dump_node(FILE *F, ir_node *n, dump_reason_t reason) } } -static void sparc_set_attr_imm(ir_node *res, int32_t immediate_value) +static void sparc_set_attr_imm(ir_node *res, ir_entity *entity, + int32_t immediate_value) { - sparc_attr_t *attr = get_irn_generic_attr(res); - attr->immediate_value = immediate_value; + sparc_attr_t *attr = (sparc_attr_t*)get_irn_generic_attr(res); + attr->immediate_value_entity = entity; + attr->immediate_value = immediate_value; + arch_add_irn_flags(res, (arch_irn_flags_t)sparc_arch_irn_flag_immediate_form); } -static void init_sparc_jmp_cond_attr(ir_node *node, int pnc, bool is_unsigned) +static void init_sparc_jmp_cond_attr(ir_node *node, ir_relation relation, + bool is_unsigned) { sparc_jmp_cond_attr_t *attr = get_sparc_jmp_cond_attr(node); - attr->pnc = pnc; + attr->relation = relation; attr->is_unsigned = is_unsigned; } -void set_sparc_jmp_switch_n_projs(ir_node *node, int n_projs) -{ - sparc_jmp_switch_attr_t *attr = get_sparc_jmp_switch_attr(node); - attr->n_projs = n_projs; -} - -void set_sparc_jmp_switch_default_proj_num(ir_node *node, long def_proj_num) -{ - sparc_jmp_switch_attr_t *attr = get_sparc_jmp_switch_attr(node); - attr->default_proj_num = def_proj_num; -} - - - -int get_sparc_jmp_switch_n_projs(const ir_node *node) -{ - const sparc_jmp_switch_attr_t *attr = get_sparc_jmp_switch_attr_const(node); - return attr->n_projs; -} - -long get_sparc_jmp_switch_default_proj_num(const ir_node *node) -{ - const sparc_jmp_switch_attr_t *attr = get_sparc_jmp_switch_attr_const(node); - return attr->default_proj_num; -} - sparc_attr_t *get_sparc_attr(ir_node *node) { assert(is_sparc_irn(node)); @@ -210,18 +158,6 @@ const sparc_load_store_attr_t *get_sparc_load_store_attr_const(const ir_node *no return (const sparc_load_store_attr_t*) get_irn_generic_attr_const(node); } -sparc_symconst_attr_t *get_sparc_symconst_attr(ir_node *node) -{ - assert(has_symconst_attr(node)); - return (sparc_symconst_attr_t*) get_irn_generic_attr_const(node); -} - -const sparc_symconst_attr_t *get_sparc_symconst_attr_const(const ir_node *node) -{ - assert(has_symconst_attr(node)); - return (const sparc_symconst_attr_t*) get_irn_generic_attr_const(node); -} - sparc_jmp_cond_attr_t *get_sparc_jmp_cond_attr(ir_node *node) { assert(has_jmp_cond_attr(node)); @@ -234,28 +170,16 @@ const sparc_jmp_cond_attr_t *get_sparc_jmp_cond_attr_const(const ir_node *node) return (const sparc_jmp_cond_attr_t*) get_irn_generic_attr_const(node); } -sparc_jmp_switch_attr_t *get_sparc_jmp_switch_attr(ir_node *node) +sparc_switch_jmp_attr_t *get_sparc_switch_jmp_attr(ir_node *node) { - assert(has_jmp_switch_attr(node)); - return (sparc_jmp_switch_attr_t*) get_irn_generic_attr_const(node); + assert(has_switch_jmp_attr(node)); + return (sparc_switch_jmp_attr_t*) get_irn_generic_attr_const(node); } -const sparc_jmp_switch_attr_t *get_sparc_jmp_switch_attr_const(const ir_node *node) +const sparc_switch_jmp_attr_t *get_sparc_switch_jmp_attr_const(const ir_node *node) { - assert(has_jmp_switch_attr(node)); - return (const sparc_jmp_switch_attr_t*) get_irn_generic_attr_const(node); -} - -sparc_save_attr_t *get_sparc_save_attr(ir_node *node) -{ - assert(has_save_attr(node)); - return (sparc_save_attr_t*) get_irn_generic_attr_const(node); -} - -const sparc_save_attr_t *get_sparc_save_attr_const(const ir_node *node) -{ - assert(has_save_attr(node)); - return (const sparc_save_attr_t*) get_irn_generic_attr_const(node); + assert(has_switch_jmp_attr(node)); + return (const sparc_switch_jmp_attr_t*) get_irn_generic_attr_const(node); } sparc_fp_attr_t *get_sparc_fp_attr(ir_node *node) @@ -282,85 +206,35 @@ const sparc_fp_conv_attr_t *get_sparc_fp_conv_attr_const(const ir_node *node) return (const sparc_fp_conv_attr_t*) get_irn_generic_attr_const(node); } -/** - * Returns the argument register requirements of a sparc node. - */ -const arch_register_req_t **get_sparc_in_req_all(const ir_node *node) -{ - const sparc_attr_t *attr = get_sparc_attr_const(node); - return attr->in_req; -} - -void set_sparc_in_req_all(ir_node *node, const arch_register_req_t **reqs) -{ - sparc_attr_t *attr = get_sparc_attr(node); - attr->in_req = reqs; -} - -/** - * Returns the argument register requirement at position pos of an sparc node. - */ -const arch_register_req_t *get_sparc_in_req(const ir_node *node, int pos) -{ - const sparc_attr_t *attr = get_sparc_attr_const(node); - return attr->in_req[pos]; -} - -/** - * Sets the IN register requirements at position pos. - */ -void set_sparc_req_in(ir_node *node, const arch_register_req_t *req, int pos) -{ - sparc_attr_t *attr = get_sparc_attr(node); - attr->in_req[pos] = req; -} - /** * Initializes the nodes attributes. */ static void init_sparc_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) { ir_graph *irg = get_irn_irg(node); struct obstack *obst = get_irg_obstack(irg); - sparc_attr_t *attr = get_sparc_attr(node); backend_info_t *info; - (void) execution_units; - arch_irn_set_flags(node, flags); - attr->in_req = in_reqs; + arch_set_irn_flags(node, flags); + arch_set_irn_register_reqs_in(node, in_reqs); info = be_get_info(node); - info->out_infos = NEW_ARR_D(reg_out_info_t, obst, n_res); - memset(info->out_infos, 0, n_res * sizeof(info->out_infos[0])); + info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, n_res); } static void init_sparc_load_store_attributes(ir_node *res, ir_mode *ls_mode, - ir_entity *entity, - int entity_sign, long offset, - bool is_frame_entity) + ir_entity *entity, int32_t offset, + bool is_frame_entity, + bool is_reg_reg) { - sparc_load_store_attr_t *attr = get_sparc_load_store_attr(res); - attr->load_store_mode = ls_mode; - attr->entity = entity; - attr->entity_sign = entity_sign; - attr->is_frame_entity = is_frame_entity; - attr->offset = offset; -} - -static void init_sparc_symconst_attributes(ir_node *res, ir_entity *entity) -{ - sparc_symconst_attr_t *attr = get_sparc_symconst_attr(res); - attr->entity = entity; - attr->fp_offset = 0; -} - -static void init_sparc_save_attributes(ir_node *res, int initial_stacksize) -{ - sparc_save_attr_t *attr = get_sparc_save_attr(res); - attr->initial_stacksize = initial_stacksize; + sparc_load_store_attr_t *attr = get_sparc_load_store_attr(res); + attr->base.immediate_value_entity = entity; + attr->base.immediate_value = offset; + attr->load_store_mode = ls_mode; + attr->is_frame_entity = is_frame_entity; + attr->is_reg_reg = is_reg_reg; } static void init_sparc_fp_attributes(ir_node *res, ir_mode *fp_mode) @@ -377,6 +251,19 @@ static void init_sparc_fp_conv_attributes(ir_node *res, ir_mode *src_mode, attr->dest_mode = dest_mode; } +static void init_sparc_switch_jmp_attributes(ir_node *node, + const ir_switch_table *table, + ir_entity *table_entity) +{ + sparc_switch_jmp_attr_t *attr = get_sparc_switch_jmp_attr(node); + attr->table = table; + attr->table_entity = table_entity; + + be_foreach_out(node, o) { + arch_set_irn_register_req_out(node, o, arch_no_register_req); + } +} + /** * copies sparc attributes of node */ @@ -392,14 +279,16 @@ static void sparc_copy_attr(ir_graph *irg, const ir_node *old_node, /* copy the attributes */ memcpy(attr_new, attr_old, get_op_attr_size(get_irn_op(old_node))); /* copy out flags */ + new_info->flags = old_info->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; } /** * compare some node's attributes */ -static int cmp_attr_sparc(ir_node *a, ir_node *b) +static int cmp_attr_sparc(const ir_node *a, const ir_node *b) { const sparc_attr_t *attr_a = get_sparc_attr_const(a); const sparc_attr_t *attr_b = get_sparc_attr_const(b); @@ -408,7 +297,7 @@ static int cmp_attr_sparc(ir_node *a, ir_node *b) || attr_a->immediate_value_entity != attr_b->immediate_value_entity; } -static int cmp_attr_sparc_load_store(ir_node *a, ir_node *b) +static int cmp_attr_sparc_load_store(const ir_node *a, const ir_node *b) { const sparc_load_store_attr_t *attr_a = get_sparc_load_store_attr_const(a); const sparc_load_store_attr_t *attr_b = get_sparc_load_store_attr_const(b); @@ -416,26 +305,11 @@ static int cmp_attr_sparc_load_store(ir_node *a, ir_node *b) if (cmp_attr_sparc(a, b)) return 1; - return attr_a->entity != attr_b->entity - || attr_a->entity_sign != attr_b->entity_sign - || attr_a->is_frame_entity != attr_b->is_frame_entity - || attr_a->load_store_mode != attr_b->load_store_mode - || attr_a->offset != attr_b->offset; + return attr_a->is_frame_entity != attr_b->is_frame_entity + || attr_a->load_store_mode != attr_b->load_store_mode; } -static int cmp_attr_sparc_symconst(ir_node *a, ir_node *b) -{ - const sparc_symconst_attr_t *attr_a = get_sparc_symconst_attr_const(a); - const sparc_symconst_attr_t *attr_b = get_sparc_symconst_attr_const(b); - - if (cmp_attr_sparc(a, b)) - return 1; - - return attr_a->entity != attr_b->entity - || attr_a->fp_offset != attr_b->fp_offset; -} - -static int cmp_attr_sparc_jmp_cond(ir_node *a, ir_node *b) +static int cmp_attr_sparc_jmp_cond(const ir_node *a, const ir_node *b) { const sparc_jmp_cond_attr_t *attr_a = get_sparc_jmp_cond_attr_const(a); const sparc_jmp_cond_attr_t *attr_b = get_sparc_jmp_cond_attr_const(b); @@ -443,34 +317,11 @@ static int cmp_attr_sparc_jmp_cond(ir_node *a, ir_node *b) if (cmp_attr_sparc(a, b)) return 1; - return attr_a->pnc != attr_b->pnc + return attr_a->relation != attr_b->relation || attr_a->is_unsigned != attr_b->is_unsigned; } -static int cmp_attr_sparc_jmp_switch(ir_node *a, ir_node *b) -{ - const sparc_jmp_switch_attr_t *attr_a = get_sparc_jmp_switch_attr_const(a); - const sparc_jmp_switch_attr_t *attr_b = get_sparc_jmp_switch_attr_const(b); - - if (cmp_attr_sparc(a, b)) - return 1; - - return attr_a->default_proj_num != attr_b->default_proj_num - || attr_a->n_projs != attr_b->n_projs; -} - -static int cmp_attr_sparc_save(ir_node *a, ir_node *b) -{ - const sparc_save_attr_t *attr_a = get_sparc_save_attr_const(a); - const sparc_save_attr_t *attr_b = get_sparc_save_attr_const(b); - - if (cmp_attr_sparc(a, b)) - return 1; - - return attr_a->initial_stacksize != attr_b->initial_stacksize; -} - -static int cmp_attr_sparc_fp(ir_node *a, ir_node *b) +static int cmp_attr_sparc_fp(const ir_node *a, const ir_node *b) { const sparc_fp_attr_t *attr_a = get_sparc_fp_attr_const(a); const sparc_fp_attr_t *attr_b = get_sparc_fp_attr_const(b); @@ -481,7 +332,7 @@ static int cmp_attr_sparc_fp(ir_node *a, ir_node *b) return attr_a->fp_mode != attr_b->fp_mode; } -static int cmp_attr_sparc_fp_conv(ir_node *a, ir_node *b) +static int cmp_attr_sparc_fp_conv(const ir_node *a, const ir_node *b) { const sparc_fp_conv_attr_t *attr_a = get_sparc_fp_conv_attr_const(a); const sparc_fp_conv_attr_t *attr_b = get_sparc_fp_conv_attr_const(b); @@ -490,7 +341,7 @@ static int cmp_attr_sparc_fp_conv(ir_node *a, ir_node *b) return 1; return attr_a->src_mode != attr_b->src_mode - || attr_a->dest_mode != attr_b->dest_mode;; + || attr_a->dest_mode != attr_b->dest_mode; } /* Include the generated constructor functions */