X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firop.c;h=b4a926717c4fade2b7d5f8ad3a6cd3ec65033702;hb=eda9d668d0e8c8246015b4c5e743316a6a835a23;hp=70233da90e1504a1ebe8e324b6fb11b36d91bb1a;hpb=9f638a249857887ab86fefe24aef4063779875fb;p=libfirm diff --git a/ir/ir/irop.c b/ir/ir/irop.c index 70233da90..b4a926717 100644 --- a/ir/ir/irop.c +++ b/ir/ir/irop.c @@ -1,15 +1,28 @@ /* - * Project: libFIRM - * File name: ir/ir/irop.c - * Purpose: Representation of opcode of intermediate operation. - * Author: Christian Schaefer - * Modified by: Goetz Lindenmaier - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1998-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2007 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 Representation of opcode of intermediate operation. + * @author Christian Schaefer, Goetz Lindenmaier, Michael Beck + * @version $Id$ + */ #ifdef HAVE_CONFIG_H # include "config.h" #endif @@ -18,15 +31,16 @@ # include #endif -# include "irop_t.h" -# include "irnode_t.h" -# include "irhooks.h" +#include "irop_t.h" +#include "irnode_t.h" +#include "irhooks.h" +#include "irbackedge_t.h" -# include "iropt_t.h" /* for firm_set_default_operations */ -# include "irvrfy_t.h" -# include "reassoc_t.h" +#include "iropt_t.h" /* for firm_set_default_operations */ +#include "irvrfy_t.h" +#include "reassoc_t.h" -# include "xmalloc.h" +#include "xmalloc.h" /** the available next opcode */ static unsigned next_iro = iro_MaxOpcode; @@ -131,10 +145,36 @@ call_copy_attr(const ir_node *old_node, ir_node *new_node) { */ static void block_copy_attr(const ir_node *old_node, ir_node *new_node) { + ir_graph *irg = current_ir_graph; + default_copy_attr(old_node, new_node); + new_node->attr.block.cg_backedge = NULL; + new_node->attr.block.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node)); INIT_LIST_HEAD(&new_node->attr.block.succ_head); } /* block_copy_attr */ +/** + * Copies all phi attributes stored in old node to the new node + */ +static void +phi_copy_attr(const ir_node *old_node, ir_node *new_node) { + ir_graph *irg = current_ir_graph; + + default_copy_attr(old_node, new_node); + new_node->attr.phi_backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node)); +} + +/** + * Copies all filter attributes stored in old node to the new node + */ +static void +filter_copy_attr(const ir_node *old_node, ir_node *new_node) { + ir_graph *irg = current_ir_graph; + + default_copy_attr(old_node, new_node); + new_node->attr.filter.backedge = new_backedge_arr(irg->obst, get_irn_arity(new_node)); +} + /** * Sets the default copy_attr operation for an ir_ops * @@ -144,11 +184,15 @@ block_copy_attr(const ir_node *old_node, ir_node *new_node) { * @return * The operations. */ -static ir_op_ops *firm_set_default_copy_attr(opcode code, ir_op_ops *ops) { +static ir_op_ops *firm_set_default_copy_attr(ir_opcode code, ir_op_ops *ops) { if (code == iro_Call) ops->copy_attr = call_copy_attr; else if (code == iro_Block) ops->copy_attr = block_copy_attr; + else if (code == iro_Phi) + ops->copy_attr = phi_copy_attr; + else if (code == iro_Filter) + ops->copy_attr = filter_copy_attr; else { /* not allowed to be NULL */ if (! ops->copy_attr) @@ -159,7 +203,7 @@ static ir_op_ops *firm_set_default_copy_attr(opcode code, ir_op_ops *ops) { /* Creates a new ir operation. */ ir_op * -new_ir_op(opcode code, const char *name, op_pin_state p, +new_ir_op(ir_opcode code, const char *name, op_pin_state p, unsigned flags, op_arity opar, int op_index, size_t attr_size, const ir_op_ops *ops) { @@ -213,7 +257,9 @@ init_op(void) #define H irop_flag_highlevel #define c irop_flag_constlike #define K irop_flag_keep +#define S irop_flag_start_block + /* Caution: A great deal of Firm optimizations depend an right operations flags. */ op_Block = new_ir_op(iro_Block, "Block", op_pin_state_pinned, L, oparity_variable, -1, sizeof(block_attr), NULL); op_Start = new_ir_op(iro_Start, "Start", op_pin_state_pinned, X, oparity_zero, -1, 0, NULL); @@ -221,10 +267,10 @@ init_op(void) op_Jmp = new_ir_op(iro_Jmp, "Jmp", op_pin_state_pinned, X, oparity_zero, -1, 0, NULL); op_IJmp = new_ir_op(iro_IJmp, "IJmp", op_pin_state_pinned, X|K, oparity_unary, -1, 0, NULL); op_Cond = new_ir_op(iro_Cond, "Cond", op_pin_state_pinned, X|Y, oparity_any, -1, sizeof(cond_attr), NULL); - op_Return = new_ir_op(iro_Return, "Return", op_pin_state_pinned, X, oparity_zero, -1, 0, NULL); + op_Return = new_ir_op(iro_Return, "Return", op_pin_state_pinned, X, oparity_variable, -1, 0, NULL); - op_Const = new_ir_op(iro_Const, "Const", op_pin_state_floats, c, oparity_zero, -1, sizeof(const_attr), NULL); - op_SymConst = new_ir_op(iro_SymConst, "SymConst", op_pin_state_floats, c, oparity_zero, -1, sizeof(symconst_attr), NULL); + op_Const = new_ir_op(iro_Const, "Const", op_pin_state_floats, c|S, oparity_zero, -1, sizeof(const_attr), NULL); + op_SymConst = new_ir_op(iro_SymConst, "SymConst", op_pin_state_floats, c|S, oparity_zero, -1, sizeof(symconst_attr), NULL); op_Sel = new_ir_op(iro_Sel, "Sel", op_pin_state_floats, H, oparity_any, -1, sizeof(sel_attr), NULL); @@ -258,20 +304,20 @@ init_op(void) op_Store = new_ir_op(iro_Store, "Store", op_pin_state_exc_pinned, F, oparity_any, -1, sizeof(store_attr), NULL); op_Alloc = new_ir_op(iro_Alloc, "Alloc", op_pin_state_pinned, F, oparity_any, -1, sizeof(alloc_attr), NULL); op_Free = new_ir_op(iro_Free, "Free", op_pin_state_pinned, N, oparity_any, -1, sizeof(free_attr), NULL); - op_Sync = new_ir_op(iro_Sync, "Sync", op_pin_state_pinned, N, oparity_any, -1, 0, NULL); + op_Sync = new_ir_op(iro_Sync, "Sync", op_pin_state_pinned, N, oparity_dynamic, -1, 0, NULL); - op_Proj = new_ir_op(iro_Proj, "Proj", op_pin_state_floats, N, oparity_any, -1, sizeof(long), NULL); + op_Proj = new_ir_op(iro_Proj, "Proj", op_pin_state_floats, N, oparity_unary, -1, sizeof(long), NULL); op_Tuple = new_ir_op(iro_Tuple, "Tuple", op_pin_state_floats, L, oparity_variable, -1, 0, NULL); op_Id = new_ir_op(iro_Id, "Id", op_pin_state_floats, N, oparity_any, -1, 0, NULL); - op_Bad = new_ir_op(iro_Bad, "Bad", op_pin_state_pinned, X|F, oparity_zero, -1, 0, NULL); + op_Bad = new_ir_op(iro_Bad, "Bad", op_pin_state_pinned, X|F|S, oparity_zero, -1, 0, NULL); op_Confirm = new_ir_op(iro_Confirm, "Confirm", op_pin_state_pinned, H, oparity_any, -1, sizeof(confirm_attr), NULL); - op_Unknown = new_ir_op(iro_Unknown, "Unknown", op_pin_state_pinned, X|F, oparity_zero, -1, 0, NULL); + op_Unknown = new_ir_op(iro_Unknown, "Unknown", op_pin_state_pinned, X|F|S, oparity_zero, -1, 0, NULL); op_Filter = new_ir_op(iro_Filter, "Filter", op_pin_state_pinned, N, oparity_variable, -1, sizeof(filter_attr), NULL); op_Break = new_ir_op(iro_Break, "Break", op_pin_state_pinned, X, oparity_zero, -1, 0, NULL); op_CallBegin = new_ir_op(iro_CallBegin, "CallBegin", op_pin_state_pinned, X|I, oparity_any, -1, sizeof(callbegin_attr), NULL); - op_EndReg = new_ir_op(iro_EndReg, "EndReg", op_pin_state_pinned, X|I, oparity_any, -1, sizeof(end_attr), NULL); - op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", op_pin_state_pinned, X|I, oparity_any, -1, sizeof(end_attr), NULL); + op_EndReg = new_ir_op(iro_EndReg, "EndReg", op_pin_state_pinned, X|I, oparity_dynamic, -1, sizeof(end_attr), NULL); + op_EndExcept = new_ir_op(iro_EndExcept, "EndExcept", op_pin_state_pinned, X|I, oparity_dynamic, -1, sizeof(end_attr), NULL); op_NoMem = new_ir_op(iro_NoMem, "NoMem", op_pin_state_pinned, N, oparity_zero, -1, 0, NULL); op_Mux = new_ir_op(iro_Mux, "Mux", op_pin_state_floats, N, oparity_trinary, -1, 0, NULL); @@ -284,6 +330,7 @@ init_op(void) op_Pin = new_ir_op(iro_Pin, "Pin", op_pin_state_pinned, H, oparity_unary, -1, 0, NULL); +#undef S #undef H #undef Y #undef F @@ -371,7 +418,7 @@ const char *get_op_name (const ir_op *op) { return get_id_str(op->name); } /* get_op_name */ -opcode (get_op_code)(const ir_op *op){ +ir_opcode (get_op_code)(const ir_op *op){ return _get_op_code(op); } /* get_op_code */