X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firnode.c;h=94cbf54f2c83c7fd37cb857500f9dd2934b85906;hb=aef37e8f6923edb63c4293f3df0402007cdc530b;hp=701de9eaccd8dfb20ebaeb1579a9920e74590426;hpb=a63062db7f43c0d0bec2779e62fa9493cd74d3af;p=libfirm diff --git a/ir/ir/irnode.c b/ir/ir/irnode.c index 701de9eac..94cbf54f2 100644 --- a/ir/ir/irnode.c +++ b/ir/ir/irnode.c @@ -1,22 +1,32 @@ -/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe -** All rights reserved. -** -** Authors: Martin Trapp, Christian Schaefer, Goetz Lindenmaier -** -*/ +/* + * Project: libFIRM + * File name: ir/ir/irnode.c + * Purpose: Representation of an intermediate operation. + * Author: Martin Trapp, 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. + */ #ifdef HAVE_CONFIG_H # include #endif +#include +#include "ident.h" #include "irnode_t.h" #include "irgraph_t.h" -#include "ident_t.h" #include "irmode_t.h" +#include "typegmod.h" #include "array.h" +#include "irbackedge_t.h" +#include "irdump.h" +#include "irflag.h" #ifdef DEBUG_libfirm -#include "irprog.h" +#include "irprog_t.h" #endif /* some constants fixing the positions of nodes predecessors @@ -24,13 +34,27 @@ #define CALL_PARAM_OFFSET 2 #define SEL_INDEX_OFFSET 2 #define RETURN_RESULT_OFFSET 1 /* mem is not a result */ - -static char *pnc_name_arr [] = {"False", "Eq", "Lt", "Le", - "Gt", "Ge", "Lg", "Leg", "Uo", - "Ue", "Ul", "Ule", "Ug", "Uge", - "Ne", "True" }; - -inline char *get_pnc_string(int pnc) { +#define END_KEEPALIVE_OFFSET 0 + +/* Declarations for inlineing */ +INLINE ir_node ** get_irn_in (const ir_node *node); +INLINE ir_mode *get_irn_mode (const ir_node *node); +INLINE ir_op *get_irn_op (const ir_node *node); +INLINE opcode get_irn_opcode (const ir_node *node); +INLINE ident *get_irn_opident (const ir_node *node); +INLINE type *get_SymConst_type (ir_node *node); +INLINE ir_node *skip_nop (ir_node *node); +INLINE int is_Proj (const ir_node *node); + + +static const char *pnc_name_arr [] = { + "False", "Eq", "Lt", "Le", + "Gt", "Ge", "Lg", "Leg", "Uo", + "Ue", "Ul", "Ule", "Ug", "Uge", + "Ne", "True" +}; + +INLINE const char *get_pnc_string(int pnc) { return pnc_name_arr[pnc]; } @@ -58,10 +82,14 @@ get_negated_pnc(int pnc) { return 99; /* to shut up gcc */ } -static char *pns_name_arr [] = {"initial_exec", "global_store", - "frame_base", "globals", "args"}; +const char *pns_name_arr [] = { + "initial_exec", "global_store", + "frame_base", "globals", "args" +}; -static char *symconst_name_arr [] = {"type_tag", "size", "linkage_ptr_info"}; +const char *symconst_name_arr [] = { + "type_tag", "size", "linkage_ptr_info" +}; void init_irnode (void) @@ -72,8 +100,8 @@ init_irnode (void) /* create a new irnode in irg, with an op, mode, arity and */ /* some incoming irnodes */ /* this constructor is used in every specified irnode constructor */ -inline ir_node * -new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, +INLINE ir_node * +new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node **in) { ir_node *res; @@ -87,12 +115,14 @@ new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, res->visited = 0; res->link = NULL; if (arity < 0) { - res->in = NEW_ARR_F (ir_node *, 1); + res->in = NEW_ARR_F (ir_node *, 1); /* 1: space for block */ } else { res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1)); memcpy (&res->in[1], in, sizeof (ir_node *) * arity); } res->in[0] = block; + set_irn_dbg_info(res, db); + res->out = NULL; #ifdef DEBUG_libfirm res->node_nr = get_irp_new_node_nr(); @@ -105,73 +135,47 @@ new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, Assumes both have the same opcode and sufficient size. */ void copy_attrs (ir_node *old, ir_node *new) { - assert (get_irn_opcode(old) == get_irn_opcode(new)); + assert (get_irn_op(old) == get_irn_op(new)); memcpy (&new->attr, &old->attr, get_op_attr_size(get_irn_op(old))); } -/* IR-Nodes with attributes */ +/** getting some parameters from ir_nodes **/ + int -ir_node_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN) -{ - int printed = 0; - ir_node *np = XP_GETARG (ir_node *, 0); +is_ir_node (void *thing) { + assert(thing); + if (get_kind(thing) == k_ir_node) + return 1; + else + return 0; +} - if (!np) { - XPS (""); - return printed; - } +/* returns the number of predecessors without the block predecessor. */ +INLINE int +get_irn_intra_arity (const ir_node *node) { + assert(node); + return ARR_LEN(node->in) - 1; +} - XPF1 ("%I", get_irn_opident(np)); - - switch (get_irn_opcode (np)) { /* node label */ - case iro_Const: - XPF1 ("%I", get_irn_mode(np)->name); - XPS (" : "); - XPF1 ("%v", get_irn_const_attr); - break; - case iro_Proj: - if (get_irn_modecode (np) == irm_b) { - XPC (" "); - XP (pnc_name_arr[get_irn_proj_attr(np)]); - } else if (get_irn_opcode (get_irn_in (np)[1]) == iro_Start) { - XPC (" "); - XP (pns_name_arr[get_irn_proj_attr(np)]); - } else { - XPF1 ("%I", get_irn_mode(np)->name); - XPC (" "); - XPF1 ("%d", get_irn_proj_attr(np)); - } - break; - case iro_SymConst: - XPF1 ("%I", get_irn_mode(np)->name); - XPC (" "); - XP (symconst_name_arr[get_irn_symconst_attr(np).num]); - XPF1 (" %#N", get_class_ident((type_class *)get_SymConst_type(np))); - break; - case iro_Start: /* don't dump mode of these */ - case iro_Cond: - case iro_Block: - case iro_Call: - case iro_Jmp: - case iro_Return: - case iro_End: - break; - default: - XPF1 ("%I", get_irn_mode(np)->name); +/* returns the number of predecessors without the block predecessor. */ +INLINE int +get_irn_inter_arity (const ir_node *node) { + assert(node); + if (get_irn_opcode(node) == iro_Filter) { + assert(node->attr.filter.in_cg); + return ARR_LEN(node->attr.filter.in_cg) - 1; + } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) { + return ARR_LEN(node->attr.block.in_cg) - 1; } - - return printed; + return get_irn_intra_arity(node); } - -/** getting some parameters from ir_nodes **/ - /* returns the number of predecessors without the block predecessor. */ -inline int -get_irn_arity (ir_node *node) -{ +INLINE int +get_irn_arity (const ir_node *node) { assert(node); - return (ARR_LEN((node)->in)-1); + if (interprocedural_view) return get_irn_inter_arity(node); + return get_irn_intra_arity(node); } /* Returns the array with ins. This array is shifted with respect to the @@ -180,11 +184,62 @@ get_irn_arity (ir_node *node) The order of the predecessors in this array is not guaranteed, except that lists of operands as predecessors of Block or arguments of a Call are consecutive. */ -inline ir_node ** -get_irn_in (ir_node *node) -{ - assert (node); - return ((node)->in); +INLINE ir_node ** +get_irn_in (const ir_node *node) { + assert(node); + if (interprocedural_view) { /* handle Filter and Block specially */ + if (get_irn_opcode(node) == iro_Filter) { + assert(node->attr.filter.in_cg); + return node->attr.filter.in_cg; + } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) { + return node->attr.block.in_cg; + } + /* else fall through */ + } + return node->in; +} + +INLINE void +set_irn_in (ir_node *node, int arity, ir_node **in) { + ir_node *** arr; + assert(node); + if (interprocedural_view) { /* handle Filter and Block specially */ + if (get_irn_opcode(node) == iro_Filter) { + assert(node->attr.filter.in_cg); + arr = &node->attr.filter.in_cg; + } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) { + arr = &node->attr.block.in_cg; + } else { + arr = &node->in; + } + } else { + arr = &node->in; + } + if (arity != ARR_LEN(*arr) - 1) { + ir_node * block = (*arr)[0]; + *arr = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1); + (*arr)[0] = block; + } + fix_backedges(current_ir_graph->obst, node); + memcpy((*arr) + 1, in, sizeof(ir_node *) * arity); +} + +INLINE ir_node * +get_irn_intra_n (ir_node *node, int n) { + return (node->in[n + 1] = skip_nop(node->in[n + 1])); +} + +INLINE ir_node* +get_irn_inter_n (ir_node *node, int n) { + /* handle Filter and Block specially */ + if (get_irn_opcode(node) == iro_Filter) { + assert(node->attr.filter.in_cg); + return (node->attr.filter.in_cg[n + 1] = skip_nop(node->attr.filter.in_cg[n + 1])); + } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) { + return (node->attr.block.in_cg[n + 1] = skip_nop(node->attr.block.in_cg[n + 1])); + } + + return get_irn_intra_n (node, n); } /* to iterate through the predecessors without touching the array */ @@ -192,171 +247,234 @@ get_irn_in (ir_node *node) to iterate includind the Block predecessor iterate from i = -1 to i < get_irn_arity. If it is a block, the entry -1 is NULL. */ -inline ir_node * -get_irn_n (ir_node *node, int n) -{ - assert (node); - assert (get_irn_arity (node) > n); - return skip_nop(node->in[n+1]); +INLINE ir_node * +get_irn_n (ir_node *node, int n) { + /* debug @@@ */ + if (-1 > n || get_irn_arity(node) <= n) { + printf("pos: %d, arity: %d ", n, get_irn_arity(node)); + DDMN(node); + } /**/ + assert(node); assert(-1 <= n && n < get_irn_arity(node)); + if (interprocedural_view) return get_irn_inter_n (node, n); + return get_irn_intra_n (node, n); +} + + +INLINE void +set_irn_n (ir_node *node, int n, ir_node *in) { + assert(node && -1 <= n && n < get_irn_arity(node)); + if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) { + /* Change block pred in both views! */ + node->in[n + 1] = in; + assert(node->attr.filter.in_cg); + node->attr.filter.in_cg[n + 1] = in; + return; + } + if (interprocedural_view) { /* handle Filter and Block specially */ + if (get_irn_opcode(node) == iro_Filter) { + assert(node->attr.filter.in_cg); + node->attr.filter.in_cg[n + 1] = in; + return; + } else if (get_irn_opcode(node) == iro_Block && node->attr.block.in_cg) { + node->attr.block.in_cg[n + 1] = in; + return; + } + /* else fall through */ + } + node->in[n + 1] = in; } -inline void -set_irn_n (ir_node *node, int n, ir_node *in) +INLINE ir_mode * +get_irn_mode (const ir_node *node) { assert (node); - assert (get_irn_arity (node) > n); - node->in[n+1] = in; + return node->mode; } -inline ir_mode * -get_irn_mode (ir_node *node) +INLINE void +set_irn_mode (ir_node *node, ir_mode *mode) { assert (node); - return node->mode; + node->mode=mode; + return; } -inline modecode -get_irn_modecode (ir_node *node) +INLINE modecode +get_irn_modecode (const ir_node *node) { assert (node); return node->mode->code; } +/** Gets the string representation of the mode .*/ +INLINE const char * +get_irn_modename (const ir_node *node) +{ + assert(node); + return get_mode_name(node->mode); +} -inline ident * -get_irn_modeident (ir_node *node) +INLINE ident * +get_irn_modeident (const ir_node *node) { assert(node); - return node->mode->name; + return get_mode_ident(node->mode); } -inline ir_op * -get_irn_op (ir_node *node) +INLINE ir_op * +get_irn_op (const ir_node *node) { assert (node); return node->op; } /* should be private to the library: */ -inline void +INLINE void set_irn_op (ir_node *node, ir_op *op) { assert (node); node->op = op; } -inline opcode -get_irn_opcode (ir_node *node) +INLINE opcode +get_irn_opcode (const ir_node *node) { assert (node); + assert (k_ir_node == get_kind(node)); + assert (node -> op); return node->op->code; } -inline const char * -get_irn_opname (ir_node *node) +INLINE const char * +get_irn_opname (const ir_node *node) { assert(node); - return id_to_str(node->op->name); + return get_id_str(node->op->name); } -inline ident * -get_irn_opident (ir_node *node) +INLINE ident * +get_irn_opident (const ir_node *node) { assert(node); return node->op->name; } -inline unsigned long -get_irn_visited (ir_node *node) +INLINE unsigned long +get_irn_visited (const ir_node *node) { assert (node); return node->visited; } -inline void +INLINE void set_irn_visited (ir_node *node, unsigned long visited) { assert (node); node->visited = visited; } -inline void -set_irn_link (ir_node *node, ir_node *link) { + +INLINE void +mark_irn_visited (ir_node *node) { + assert (node); + node->visited = current_ir_graph->visited; +} + +INLINE int +irn_not_visited (const ir_node *node) { + assert (node); + return (node->visited < current_ir_graph->visited); +} + +INLINE int +irn_visited (const ir_node *node) { + assert (node); + return (node->visited >= current_ir_graph->visited); +} + +INLINE void +set_irn_link (ir_node *node, void *link) { assert (node); + /* Link field is used for Phi construction and various optimizations + in iropt. */ + assert(get_irg_phase_state(current_ir_graph) != phase_building); + node->link = link; } -inline ir_node * -get_irn_link (ir_node *node) { +INLINE void * +get_irn_link (const ir_node *node) { assert (node); return node->link; } -#ifdef DEBUG_libfirm /* Outputs a unique number for this node */ -inline long -get_irn_node_nr(ir_node *node) { +INLINE long +get_irn_node_nr(const ir_node *node) { assert(node); +#ifdef DEBUG_libfirm return node->node_nr; -} +#else + return (long)&node; #endif +} -inline tarval * +INLINE const_attr get_irn_const_attr (ir_node *node) { assert (node->op == op_Const); return node->attr.con; } -inline long +INLINE long get_irn_proj_attr (ir_node *node) { assert (node->op == op_Proj); return node->attr.proj; } -inline alloc_attr +INLINE alloc_attr get_irn_alloc_attr (ir_node *node) { assert (node->op == op_Alloc); return node->attr.a; } -inline type * +INLINE type * get_irn_free_attr (ir_node *node) { assert (node->op == op_Free); - return node->attr.f; + return node->attr.f = skip_tid(node->attr.f); } -inline symconst_attr +INLINE symconst_attr get_irn_symconst_attr (ir_node *node) { assert (node->op == op_SymConst); return node->attr.i; } -inline type_method * +INLINE type * get_irn_call_attr (ir_node *node) { assert (node->op == op_Call); - return node->attr.call; + return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp); } -inline sel_attr +INLINE sel_attr get_irn_sel_attr (ir_node *node) { assert (node->op == op_Sel); return node->attr.s; } -inline int +INLINE int get_irn_phi_attr (ir_node *node) { assert (node->op == op_Phi); return node->attr.phi0_pos; } -inline block_attr +INLINE block_attr get_irn_block_attr (ir_node *node) { assert (node->op == op_Block); @@ -372,17 +490,53 @@ get_nodes_Block (ir_node *node) { return get_irn_n(node, -1); } -inline void +INLINE void set_nodes_Block (ir_node *node, ir_node *block) { assert (!(node->op == op_Block)); set_irn_n(node, -1, block); } +/* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base) + * from Start. If so returns frame type, else Null. */ +type *is_frame_pointer(ir_node *n) { + if ((get_irn_op(n) == op_Proj) && + (get_Proj_proj(n) == pn_Start_P_frame_base)) { + ir_node *start = get_Proj_pred(n); + if (get_irn_op(start) == op_Start) { + return get_irg_frame_type(get_irn_irg(start)); + } + } + return NULL; +} + +/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals) + * from Start. If so returns global type, else Null. */ +type *is_globals_pointer(ir_node *n) { + if ((get_irn_op(n) == op_Proj) && + (get_Proj_proj(n) == pn_Start_P_globals)) { + ir_node *start = get_Proj_pred(n); + if (get_irn_op(start) == op_Start) { + return get_glob_type(); + } + } + return NULL; +} + +/* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base) + * from Start. If so returns 1, else 0. */ +int is_value_arg_pointer(ir_node *n) { + if ((get_irn_op(n) == op_Proj) && + (get_Proj_proj(n) == pn_Start_P_value_arg_base) && + (get_irn_op(get_Proj_pred(n)) == op_Start)) + return 1; + return 0; +} + /* Returns an array with the predecessors of the Block. Depending on the implementation of the graph datastructure this can be a copy of the internal representation of predecessors as well as the internal array itself. Therefore writing to this array might obstruct the ir. */ -inline ir_node ** +INLINE ir_node ** get_Block_cfgpred_arr (ir_node *node) { assert ((node->op == op_Block)); @@ -390,1361 +544,1813 @@ get_Block_cfgpred_arr (ir_node *node) } -inline int +INLINE int get_Block_n_cfgpreds (ir_node *node) { assert ((node->op == op_Block)); return (get_irn_arity(node)); } -/* -inline void -set_Block_n_cfgpreds (ir_node *node, int n_preds) { - assert ((node->op == op_Block)); -} -*/ - -inline ir_node * +INLINE ir_node * get_Block_cfgpred (ir_node *node, int pos) { assert (node->op == op_Block); + /* debug @@@ + if (-1 > pos || get_irn_arity(node) <= pos) { + dump_ir_block_graph(current_ir_graph); + printf("pos: %d, arity: %d ", pos, get_irn_arity(node)); + DDMN(node); + } */ + assert(node); assert(-1 <= pos && pos < get_irn_arity(node)); return get_irn_n(node, pos); } -inline void +INLINE void set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) { assert (node->op == op_Block); set_irn_n(node, pos, pred); } -inline bool +INLINE bool get_Block_matured (ir_node *node) { assert (node->op == op_Block); return node->attr.block.matured; } -inline void +INLINE void set_Block_matured (ir_node *node, bool matured) { assert (node->op == op_Block); node->attr.block.matured = matured; } -inline unsigned long +INLINE unsigned long get_Block_block_visited (ir_node *node) { assert (node->op == op_Block); return node->attr.block.block_visited; } -inline void +INLINE void set_Block_block_visited (ir_node *node, unsigned long visit) { assert (node->op == op_Block); node->attr.block.block_visited = visit; } -inline ir_node * +/* For this current_ir_graph must be set. */ +INLINE void +mark_Block_block_visited (ir_node *node) { + assert (node->op == op_Block); + node->attr.block.block_visited = get_irg_block_visited(current_ir_graph); +} + +INLINE int +Block_not_block_visited(ir_node *node) { + assert (node->op == op_Block); + return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph)); +} + +INLINE ir_node * get_Block_graph_arr (ir_node *node, int pos) { assert (node->op == op_Block); return node->attr.block.graph_arr[pos+1]; } -inline void +INLINE void set_Block_graph_arr (ir_node *node, int pos, ir_node *value) { assert (node->op == op_Block); node->attr.block.graph_arr[pos+1] = value; } -inline ir_node * +/* handler handling for Blocks * / +void +set_Block_handler (ir_node *block, ir_node *handler) { + assert ((block->op == op_Block)); + assert ((handler->op == op_Block)); + block->attr.block.handler_entry = handler; +} + +ir_node * +get_Block_handler (ir_node *block) { + assert ((block->op == op_Block)); + return (block->attr.block.handler_entry); +} + +/ * handler handling for Nodes * / +void +set_Node_handler (ir_node *node, ir_node *handler) { + set_Block_handler (get_nodes_Block (node), handler); +} + +ir_node * +get_Node_handler (ir_node *node) { + return (get_Block_handler (get_nodes_Block (node))); +} + +/ * exc_t handling for Blocks * / +void set_Block_exc (ir_node *block, exc_t exc) { + assert ((block->op == op_Block)); + block->attr.block.exc = exc; +} + +exc_t get_Block_exc (ir_node *block) { + assert ((block->op == op_Block)); + return (block->attr.block.exc); +} + +/ * exc_t handling for Nodes * / +void set_Node_exc (ir_node *node, exc_t exc) { + set_Block_exc (get_nodes_Block (node), exc); +} + +exc_t get_Node_exc (ir_node *node) { + return (get_Block_exc (get_nodes_Block (node))); +} +*/ + +void set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in) { + assert(node->op == op_Block); + if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) { + node->attr.block.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1); + node->attr.block.in_cg[0] = NULL; + node->attr.block.cg_backedge = new_backedge_arr(current_ir_graph->obst, arity); + { + /* Fix backedge array. fix_backedges operates depending on + interprocedural_view. */ + bool ipv = interprocedural_view; + interprocedural_view = true; + fix_backedges(current_ir_graph->obst, node); + interprocedural_view = ipv; + } + } + memcpy(node->attr.block.in_cg + 1, in, sizeof(ir_node *) * arity); +} + +void set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred) { + assert(node->op == op_Block && + node->attr.block.in_cg && + 0 <= pos && pos < ARR_LEN(node->attr.block.in_cg) - 1); + node->attr.block.in_cg[pos + 1] = pred; +} + +ir_node ** get_Block_cg_cfgpred_arr(ir_node * node) { + assert(node->op == op_Block); + return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1; +} + +int get_Block_cg_n_cfgpreds(ir_node * node) { + assert(node->op == op_Block); + return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1; +} + +ir_node * get_Block_cg_cfgpred(ir_node * node, int pos) { + assert(node->op == op_Block && node->attr.block.in_cg); + return node->attr.block.in_cg[pos + 1]; +} + +void remove_Block_cg_cfgpred_arr(ir_node * node) { + assert(node->op == op_Block); + node->attr.block.in_cg = NULL; +} + +/* Start references the irg it is in. */ +INLINE ir_graph * +get_Start_irg(ir_node *node) { + return get_irn_irg(node); +} + +INLINE void +set_Start_irg(ir_node *node, ir_graph *irg) { + assert(node->op == op_Start); + assert(is_ir_graph(irg)); + assert(0 && " Why set irg? "); + //node->attr.start.irg = irg; +} + +INLINE int +get_End_n_keepalives(ir_node *end) { + assert (end->op == op_End); + return (get_irn_arity(end) - END_KEEPALIVE_OFFSET); +} + +INLINE ir_node * +get_End_keepalive(ir_node *end, int pos) { + assert (end->op == op_End); + return get_irn_n(end, pos + END_KEEPALIVE_OFFSET); +} + +INLINE void +add_End_keepalive (ir_node *end, ir_node *ka) { + assert (end->op == op_End); + ARR_APP1 (ir_node *, end->in, ka); +} + +INLINE void +set_End_keepalive(ir_node *end, int pos, ir_node *ka) { + assert (end->op == op_End); + set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka); +} + +INLINE void +free_End (ir_node *end) { + assert (end->op == op_End); + end->kind = k_BAD; + /* DEL_ARR_F(end->in); GL @@@ tut nicht ! */ + end->in = NULL; /* @@@ make sure we get an error if we use the + in array afterwards ... */ +} + +ir_graph *get_EndReg_irg (ir_node *end) { + return get_irn_irg(end); +} + +ir_graph *get_EndExcept_irg (ir_node *end) { + return get_irn_irg(end); +} + +/* +> Implementing the case construct (which is where the constant Proj node is +> important) involves far more than simply determining the constant values. +> We could argue that this is more properly a function of the translator from +> Firm to the target machine. That could be done if there was some way of +> projecting "default" out of the Cond node. +I know it's complicated. +Basically there are two proglems: + - determining the gaps between the projs + - determining the biggest case constant to konw the proj number for + the default node. +I see several solutions: +1. Introduce a ProjDefault node. Solves both problems. + This means to extend all optimizations executed during construction. +2. Give the Cond node for switch two flavors: + a) there are no gaps in the projs (existing flavor) + b) gaps may exist, default proj is still the Proj with the largest + projection number. This covers also the gaps. +3. Fix the semantic of the Cond to that of 2b) + +Solution 2 seems to be the best: +Computing the gaps in the Firm representation is not too hard, i.e., +libfirm can implement a routine that transforms betweeen the two +flavours. This is also possible for 1) but 2) does not require to +change any existing optimization. +Further it should be far simpler to determine the biggest constant than +to compute all gaps. +I don't want to choose 3) as 2a) seems to have advantages for +dataflow analysis and 3) does not allow to convert the representation to +2a). +*/ +INLINE ir_node * get_Cond_selector (ir_node *node) { assert (node->op == op_Cond); return get_irn_n(node, 0); } -inline void +INLINE void set_Cond_selector (ir_node *node, ir_node *selector) { assert (node->op == op_Cond); set_irn_n(node, 0, selector); } -inline ir_node * +INLINE cond_kind +get_Cond_kind (ir_node *node) { + assert (node->op == op_Cond); + return node->attr.c.kind; +} + +INLINE void +set_Cond_kind (ir_node *node, cond_kind kind) { + assert (node->op == op_Cond); + node->attr.c.kind = kind; +} + +INLINE ir_node * get_Return_mem (ir_node *node) { assert (node->op == op_Return); return get_irn_n(node, 0); } -inline void +INLINE void set_Return_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Return); set_irn_n(node, 0, mem); } -inline ir_node ** +INLINE int +get_Return_n_ress (ir_node *node) { + assert (node->op == op_Return); + return (get_irn_arity(node) - RETURN_RESULT_OFFSET); +} + +INLINE ir_node ** get_Return_res_arr (ir_node *node) { assert ((node->op == op_Return)); - if (get_Return_n_res(node) > 0) + if (get_Return_n_ress(node) > 0) return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]); else return NULL; } -inline int -get_Return_n_res (ir_node *node) { - assert (node->op == op_Return); - return (get_irn_arity(node) - RETURN_RESULT_OFFSET); -} - /* -inline void +INLINE void set_Return_n_res (ir_node *node, int results) { assert (node->op == op_Return); } */ -inline ir_node * +INLINE ir_node * get_Return_res (ir_node *node, int pos) { assert (node->op == op_Return); - assert (get_Return_n_res(node) > pos); + assert (get_Return_n_ress(node) > pos); return get_irn_n(node, pos + RETURN_RESULT_OFFSET); } -inline void +INLINE void set_Return_res (ir_node *node, int pos, ir_node *res){ assert (node->op == op_Return); set_irn_n(node, pos + RETURN_RESULT_OFFSET, res); } -inline ir_node * +INLINE ir_node * get_Raise_mem (ir_node *node) { - assert (node->op == op_Return); + assert (node->op == op_Raise); return get_irn_n(node, 0); } -inline void +INLINE void set_Raise_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Raise); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Raise_exo_ptr (ir_node *node) { assert (node->op == op_Raise); return get_irn_n(node, 1); } -inline void +INLINE void set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) { assert (node->op == op_Raise); set_irn_n(node, 1, exo_ptr); } -inline tarval *get_Const_tarval (ir_node *node) { +INLINE tarval *get_Const_tarval (ir_node *node) { assert (node->op == op_Const); - return get_irn_const_attr(node); + return node->attr.con.tv; } -inline void +INLINE void set_Const_tarval (ir_node *node, tarval *con) { assert (node->op == op_Const); - node->attr.con = con; + node->attr.con.tv = con; +} + + +/* The source language type. Must be an atomic type. Mode of type must + be mode of node. For tarvals from entities type must be pointer to + entity type. */ +INLINE type * +get_Const_type (ir_node *node) { + assert (node->op == op_Const); + return node->attr.con.tp; +} + +INLINE void +set_Const_type (ir_node *node, type *tp) { + assert (node->op == op_Const); + if (tp != unknown_type) { + assert (is_atomic_type(tp)); + assert (get_type_mode(tp) == get_irn_mode(node)); + assert (!tarval_is_entity(get_Const_tarval(node)) || + (is_pointer_type(tp) && + (get_pointer_points_to_type(tp) == + get_entity_type(get_tarval_entity(get_Const_tarval(node)))))); + } + + node->attr.con.tp = tp; } -inline symconst_kind -get_SymConst_kind (ir_node *node) { + +INLINE symconst_kind +get_SymConst_kind (const ir_node *node) { assert (node->op == op_SymConst); return node->attr.i.num; } -inline void +INLINE void set_SymConst_kind (ir_node *node, symconst_kind num) { assert (node->op == op_SymConst); node->attr.i.num = num; } -inline type * +INLINE type * get_SymConst_type (ir_node *node) { assert ( (node->op == op_SymConst) && ( get_SymConst_kind(node) == type_tag || get_SymConst_kind(node) == size)); - return node->attr.i.tori.typ; + return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ); } -inline void -set_SymConst_type (ir_node *node, type *type) { +INLINE void +set_SymConst_type (ir_node *node, type *tp) { assert ( (node->op == op_SymConst) && ( get_SymConst_kind(node) == type_tag || get_SymConst_kind(node) == size)); - node->attr.i.tori.typ = type; + node->attr.i.tori.typ = tp; } -inline ident * +INLINE ident * get_SymConst_ptrinfo (ir_node *node) { assert ( (node->op == op_SymConst) && (get_SymConst_kind(node) == linkage_ptr_info)); return node->attr.i.tori.ptrinfo; } -inline void +INLINE void set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) { assert ( (node->op == op_SymConst) && (get_SymConst_kind(node) == linkage_ptr_info)); node->attr.i.tori.ptrinfo = ptrinfo; } -inline type_or_id_p +INLINE type_or_id_p get_SymConst_type_or_id (ir_node *node) { assert (node->op == op_SymConst); return &(node->attr.i.tori); } -inline void +INLINE void set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) { assert (node->op == op_SymConst); memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id)); } -inline ir_node * +INLINE ir_node * get_Sel_mem (ir_node *node) { assert (node->op == op_Sel); return get_irn_n(node, 0); } -inline void +INLINE void set_Sel_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Sel); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Sel_ptr (ir_node *node) { assert (node->op == op_Sel); return get_irn_n(node, 1); } -inline void +INLINE void set_Sel_ptr (ir_node *node, ir_node *ptr) { assert (node->op == op_Sel); set_irn_n(node, 1, ptr); } -inline ir_node ** +INLINE int +get_Sel_n_indexs (ir_node *node) { + assert (node->op == op_Sel); + return (get_irn_arity(node) - SEL_INDEX_OFFSET); +} + +INLINE ir_node ** get_Sel_index_arr (ir_node *node) { assert ((node->op == op_Sel)); - if (get_Sel_n_index(node) > 0) + if (get_Sel_n_indexs(node) > 0) return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1]; else return NULL; } -inline int -get_Sel_n_index (ir_node *node) { - assert (node->op == op_Sel); - return (get_irn_arity(node) - SEL_INDEX_OFFSET); -} - -/* -inline void -set_Sel_n_index (ir_node *node, int n_index) { - assert (node->op == op_Sel); -} -*/ - -inline ir_node * +INLINE ir_node * get_Sel_index (ir_node *node, int pos) { assert (node->op == op_Sel); return get_irn_n(node, pos + SEL_INDEX_OFFSET); } -inline void +INLINE void set_Sel_index (ir_node *node, int pos, ir_node *index) { assert (node->op == op_Sel); set_irn_n(node, pos + SEL_INDEX_OFFSET, index); } -inline entity * +INLINE entity * get_Sel_entity (ir_node *node) { assert (node->op == op_Sel); return node->attr.s.ent; } -inline void +INLINE void set_Sel_entity (ir_node *node, entity *ent) { assert (node->op == op_Sel); node->attr.s.ent = ent; } -inline linkage_type -get_Sel_linkage_type (ir_node *node) { - assert (node->op == op_Sel); - return node->attr.s.ltyp; +type * +get_InstOf_ent (ir_node *node) { + assert (node->op = op_InstOf); + return (node->attr.io.ent); } -inline void -set_Sel_linkage_type (ir_node *node, linkage_type lt) { - assert (node->op == op_Sel); - node->attr.s.ltyp = lt; +void +set_InstOf_ent (ir_node *node, type *ent) { + assert (node->op = op_InstOf); + node->attr.io.ent = ent; +} + +ir_node * +get_InstOf_store (ir_node *node) { + assert (node->op = op_InstOf); + return (get_irn_n (node, 0)); +} + +void +set_InstOf_store (ir_node *node, ir_node *obj) { + assert (node->op = op_InstOf); + set_irn_n (node, 0, obj); +} + +ir_node * +get_InstOf_obj (ir_node *node) { + assert (node->op = op_InstOf); + return (get_irn_n (node, 1)); } -inline ir_node * +void +set_InstOf_obj (ir_node *node, ir_node *obj) { + assert (node->op = op_InstOf); + set_irn_n (node, 1, obj); +} + + +/* For unary and binary arithmetic operations the access to the + operands can be factored out. Left is the first, right the + second arithmetic value as listed in tech report 0999-33. + unops are: Minus, Abs, Not, Conv, Cast + binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl, + Shr, Shrs, Rotate, Cmp */ + + +INLINE ir_node * get_Call_mem (ir_node *node) { assert (node->op == op_Call); return get_irn_n(node, 0); } -inline void +INLINE void set_Call_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Call); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Call_ptr (ir_node *node) { assert (node->op == op_Call); return get_irn_n(node, 1); } -inline void +INLINE void set_Call_ptr (ir_node *node, ir_node *ptr) { assert (node->op == op_Call); set_irn_n(node, 1, ptr); } -inline ir_node ** +INLINE ir_node ** get_Call_param_arr (ir_node *node) { assert (node->op == op_Call); return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1]; } -inline int +INLINE int get_Call_n_params (ir_node *node) { assert (node->op == op_Call); return (get_irn_arity(node) - CALL_PARAM_OFFSET); } -inline int +INLINE int get_Call_arity (ir_node *node) { + assert (node->op == op_Call); return get_Call_n_params(node); } -/* inline void +/* INLINE void set_Call_arity (ir_node *node, ir_node *arity) { assert (node->op == op_Call); } */ -inline ir_node * +INLINE ir_node * get_Call_param (ir_node *node, int pos) { assert (node->op == op_Call); return get_irn_n(node, pos + CALL_PARAM_OFFSET); } -inline void +INLINE void set_Call_param (ir_node *node, int pos, ir_node *param) { assert (node->op == op_Call); set_irn_n(node, pos + CALL_PARAM_OFFSET, param); } -inline type_method * +INLINE type * get_Call_type (ir_node *node) { assert (node->op == op_Call); - return node->attr.call; + return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp); } -inline void -set_Call_type (ir_node *node, type_method *type) { +INLINE void +set_Call_type (ir_node *node, type *tp) { assert (node->op == op_Call); - node->attr.call = type; + assert (is_method_type(tp)); + node->attr.call.cld_tp = tp; } -/* For unary and binary arithmetic operations the access to the - operands can be factored out. Left is the first, right the - second arithmetic value as listed in tech report 0999-33. - unops are: Minus, Abs, Not, Conv - binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl, - Shr, Shrs, Rotate, Cmp */ - -int -is_unop (ir_node *node) { - return ( node->op == op_Minus || - node->op == op_Abs || - node->op == op_Not || - node->op == op_Conv ); +int Call_has_callees(ir_node *node) { + return (node->attr.call.callee_arr != NULL); } -inline ir_node * -get_unop_op (ir_node *node) { - assert ( node->op == op_Minus || - node->op == op_Abs || - node->op == op_Not || - node->op == op_Conv ); - switch (get_irn_opcode (node)) { - case iro_Minus: return get_Minus_op(node); break; - case iro_Abs: return get_Abs_op(node); break; - case iro_Not: return get_Not_op(node); break; - case iro_Conv: return get_Conv_op(node); break; - default: return NULL; - } +int get_Call_n_callees(ir_node * node) { + assert(node->op == op_Call && node->attr.call.callee_arr); + return ARR_LEN(node->attr.call.callee_arr); } -inline void -set_unop_op (ir_node *node, ir_node *op) { - assert (node->op == op_Minus || - node->op == op_Abs || - node->op == op_Not || - node->op == op_Conv ); - switch (get_irn_opcode (node)) { - case iro_Minus: set_Minus_op(node, op); break; - case iro_Abs: set_Abs_op(node, op); break; - case iro_Not: set_Not_op(node, op); break; - case iro_Conv: set_Conv_op(node, op); break; - default: ; - } +entity * get_Call_callee(ir_node * node, int pos) { + assert(node->op == op_Call && node->attr.call.callee_arr); + return node->attr.call.callee_arr[pos]; +} +void set_Call_callee_arr(ir_node * node, int n, entity ** arr) { + assert(node->op == op_Call); + if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) { + node->attr.call.callee_arr = NEW_ARR_D(entity *, current_ir_graph->obst, n); + } + memcpy(node->attr.call.callee_arr, arr, n * sizeof(entity *)); } -int -is_binop (ir_node *node) { - return (node->op == op_Add || - node->op == op_Sub || - node->op == op_Mul || - node->op == op_Quot || - node->op == op_DivMod || - node->op == op_Div || - node->op == op_Mod || - node->op == op_And || - node->op == op_Or || - node->op == op_Eor || - node->op == op_Shl || - node->op == op_Shr || - node->op == op_Shrs || - node->op == op_Rot || - node->op == op_Cmp ); +void remove_Call_callee_arr(ir_node * node) { + assert(node->op == op_Call); + node->attr.call.callee_arr = NULL; } -inline ir_node * -get_binop_left (ir_node *node) { - assert (node->op == op_Add || - node->op == op_Sub || - node->op == op_Mul || - node->op == op_Quot || - node->op == op_DivMod || - node->op == op_Div || - node->op == op_Mod || - node->op == op_And || - node->op == op_Or || - node->op == op_Eor || - node->op == op_Shl || - node->op == op_Shr || - node->op == op_Shrs || - node->op == op_Rot || - node->op == op_Cmp ); - - switch (get_irn_opcode (node)) { - case iro_Add : return get_Add_left(node); break; - case iro_Sub : return get_Sub_left(node); break; - case iro_Mul : return get_Mul_left(node); break; - case iro_Quot : return get_Quot_left(node); break; - case iro_DivMod: return get_DivMod_left(node); break; - case iro_Div : return get_Div_left(node); break; - case iro_Mod : return get_Mod_left(node); break; - case iro_And : return get_And_left(node); break; - case iro_Or : return get_Or_left(node); break; - case iro_Eor : return get_Eor_left(node); break; - case iro_Shl : return get_Shl_left(node); break; - case iro_Shr : return get_Shr_left(node); break; - case iro_Shrs : return get_Shrs_left(node); break; - case iro_Rot : return get_Rot_left(node); break; - case iro_Cmp : return get_Cmp_left(node); break; - default: return NULL; - }; +ir_node * get_CallBegin_ptr (ir_node *node) { + assert(node->op == op_CallBegin); + return get_irn_n(node, 0); } - -inline void -set_binop_left (ir_node *node, ir_node *left) { - assert (node->op == op_Add || - node->op == op_Sub || - node->op == op_Mul || - node->op == op_Quot || - node->op == op_DivMod || - node->op == op_Div || - node->op == op_Mod || - node->op == op_And || - node->op == op_Or || - node->op == op_Eor || - node->op == op_Shl || - node->op == op_Shr || - node->op == op_Shrs || - node->op == op_Rot || - node->op == op_Cmp ); - - switch (get_irn_opcode (node)) { - case iro_Add : set_Add_left(node, left); break; - case iro_Sub : set_Sub_left(node, left); break; - case iro_Mul : set_Mul_left(node, left); break; - case iro_Quot : set_Quot_left(node, left); break; - case iro_DivMod: set_DivMod_left(node, left); break; - case iro_Div : set_Div_left(node, left); break; - case iro_Mod : set_Mod_left(node, left); break; - case iro_And : set_And_left(node, left); break; - case iro_Or : set_Or_left(node, left); break; - case iro_Eor : set_Eor_left(node, left); break; - case iro_Shl : set_Shl_left(node, left); break; - case iro_Shr : set_Shr_left(node, left); break; - case iro_Shrs : set_Shrs_left(node, left); break; - case iro_Rot : set_Rot_left(node, left); break; - case iro_Cmp : set_Cmp_left(node, left); break; - default: ; - }; +void set_CallBegin_ptr (ir_node *node, ir_node *ptr) { + assert(node->op == op_CallBegin); + set_irn_n(node, 0, ptr); } - -inline ir_node * -get_binop_right (ir_node *node) { - assert (node->op == op_Add || - node->op == op_Sub || - node->op == op_Mul || - node->op == op_Quot || - node->op == op_DivMod || - node->op == op_Div || - node->op == op_Mod || - node->op == op_And || - node->op == op_Or || - node->op == op_Eor || - node->op == op_Shl || - node->op == op_Shr || - node->op == op_Shrs || - node->op == op_Rot || - node->op == op_Cmp ); - - switch (get_irn_opcode (node)) { - case iro_Add : return get_Add_right(node); break; - case iro_Sub : return get_Sub_right(node); break; - case iro_Mul : return get_Mul_right(node); break; - case iro_Quot : return get_Quot_right(node); break; - case iro_DivMod: return get_DivMod_right(node); break; - case iro_Div : return get_Div_right(node); break; - case iro_Mod : return get_Mod_right(node); break; - case iro_And : return get_And_right(node); break; - case iro_Or : return get_Or_right(node); break; - case iro_Eor : return get_Eor_right(node); break; - case iro_Shl : return get_Shl_right(node); break; - case iro_Shr : return get_Shr_right(node); break; - case iro_Shrs : return get_Shrs_right(node); break; - case iro_Rot : return get_Rot_right(node); break; - case iro_Cmp : return get_Cmp_right(node); break; - default: return NULL; - }; +ir_graph * get_CallBegin_irg (ir_node *node) { + return get_irn_irg(node); } - -inline void -set_binop_right (ir_node *node, ir_node *right) { - assert (node->op == op_Add || - node->op == op_Sub || - node->op == op_Mul || - node->op == op_Quot || - node->op == op_DivMod || - node->op == op_Div || - node->op == op_Mod || - node->op == op_And || - node->op == op_Or || - node->op == op_Eor || - node->op == op_Shl || - node->op == op_Shr || - node->op == op_Shrs || - node->op == op_Rot || - node->op == op_Cmp ); - - switch (get_irn_opcode (node)) { - case iro_Add : set_Add_right(node, right); break; - case iro_Sub : set_Sub_right(node, right); break; - case iro_Mul : set_Mul_right(node, right); break; - case iro_Quot : set_Quot_right(node, right); break; - case iro_DivMod: set_DivMod_right(node, right); break; - case iro_Div : set_Div_right(node, right); break; - case iro_Mod : set_Mod_right(node, right); break; - case iro_And : set_And_right(node, right); break; - case iro_Or : set_Or_right(node, right); break; - case iro_Eor : set_Eor_right(node, right); break; - case iro_Shl : set_Shl_right(node, right); break; - case iro_Shr : set_Shr_right(node, right); break; - case iro_Shrs : set_Shrs_right(node, right); break; - case iro_Rot : set_Rot_right(node, right); break; - case iro_Cmp : set_Cmp_right(node, right); break; - default: ; - }; +ir_node * get_CallBegin_call (ir_node *node) { + assert(node->op == op_CallBegin); + return node->attr.callbegin.call; +} +void set_CallBegin_call (ir_node *node, ir_node *call) { + assert(node->op == op_CallBegin); + node->attr.callbegin.call = call; } -inline ir_node * +INLINE ir_node * get_Add_left (ir_node *node) { assert (node->op == op_Add); return get_irn_n(node, 0); } -inline void +INLINE void set_Add_left (ir_node *node, ir_node *left) { assert (node->op == op_Add); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Add_right (ir_node *node) { assert (node->op == op_Add); return get_irn_n(node, 1); } -inline void +INLINE void set_Add_right (ir_node *node, ir_node *right) { assert (node->op == op_Add); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Sub_left (ir_node *node) { assert (node->op == op_Sub); return get_irn_n(node, 0); } -inline void +INLINE void set_Sub_left (ir_node *node, ir_node *left) { assert (node->op == op_Sub); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Sub_right (ir_node *node) { assert (node->op == op_Sub); return get_irn_n(node, 1); } -inline void +INLINE void set_Sub_right (ir_node *node, ir_node *right) { assert (node->op == op_Sub); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Minus_op (ir_node *node) { assert (node->op == op_Minus); return get_irn_n(node, 0); } -inline void +INLINE void set_Minus_op (ir_node *node, ir_node *op) { assert (node->op == op_Minus); set_irn_n(node, 0, op); } -inline ir_node * +INLINE ir_node * get_Mul_left (ir_node *node) { assert (node->op == op_Mul); return get_irn_n(node, 0); } -inline void +INLINE void set_Mul_left (ir_node *node, ir_node *left) { assert (node->op == op_Mul); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Mul_right (ir_node *node) { assert (node->op == op_Mul); return get_irn_n(node, 1); } -inline void +INLINE void set_Mul_right (ir_node *node, ir_node *right) { assert (node->op == op_Mul); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Quot_left (ir_node *node) { assert (node->op == op_Quot); return get_irn_n(node, 1); } -inline void +INLINE void set_Quot_left (ir_node *node, ir_node *left) { assert (node->op == op_Quot); set_irn_n(node, 1, left); } -inline ir_node * +INLINE ir_node * get_Quot_right (ir_node *node) { assert (node->op == op_Quot); return get_irn_n(node, 2); } -inline void +INLINE void set_Quot_right (ir_node *node, ir_node *right) { assert (node->op == op_Quot); set_irn_n(node, 2, right); } -inline ir_node * +INLINE ir_node * get_Quot_mem (ir_node *node) { assert (node->op == op_Quot); return get_irn_n(node, 0); } -inline void +INLINE void set_Quot_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Quot); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_DivMod_left (ir_node *node) { assert (node->op == op_DivMod); return get_irn_n(node, 1); } -inline void +INLINE void set_DivMod_left (ir_node *node, ir_node *left) { assert (node->op == op_DivMod); set_irn_n(node, 1, left); } -inline ir_node * +INLINE ir_node * get_DivMod_right (ir_node *node) { assert (node->op == op_DivMod); return get_irn_n(node, 2); } -inline void +INLINE void set_DivMod_right (ir_node *node, ir_node *right) { assert (node->op == op_DivMod); set_irn_n(node, 2, right); } -inline ir_node * +INLINE ir_node * get_DivMod_mem (ir_node *node) { assert (node->op == op_DivMod); return get_irn_n(node, 0); } -inline void +INLINE void set_DivMod_mem (ir_node *node, ir_node *mem) { assert (node->op == op_DivMod); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Div_left (ir_node *node) { assert (node->op == op_Div); return get_irn_n(node, 1); } -inline void +INLINE void set_Div_left (ir_node *node, ir_node *left) { assert (node->op == op_Div); set_irn_n(node, 1, left); } -inline ir_node * +INLINE ir_node * get_Div_right (ir_node *node) { assert (node->op == op_Div); return get_irn_n(node, 2); } -inline void +INLINE void set_Div_right (ir_node *node, ir_node *right) { assert (node->op == op_Div); set_irn_n(node, 2, right); } -inline ir_node * +INLINE ir_node * get_Div_mem (ir_node *node) { assert (node->op == op_Div); return get_irn_n(node, 0); } -inline void +INLINE void set_Div_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Div); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Mod_left (ir_node *node) { assert (node->op == op_Mod); return get_irn_n(node, 1); } -inline void +INLINE void set_Mod_left (ir_node *node, ir_node *left) { assert (node->op == op_Mod); set_irn_n(node, 1, left); } -inline ir_node * +INLINE ir_node * get_Mod_right (ir_node *node) { assert (node->op == op_Mod); return get_irn_n(node, 2); } -inline void +INLINE void set_Mod_right (ir_node *node, ir_node *right) { assert (node->op == op_Mod); set_irn_n(node, 2, right); } -inline ir_node * +INLINE ir_node * get_Mod_mem (ir_node *node) { assert (node->op == op_Mod); return get_irn_n(node, 0); } -inline void +INLINE void set_Mod_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Mod); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Abs_op (ir_node *node) { assert (node->op == op_Abs); return get_irn_n(node, 0); } -inline void +INLINE void set_Abs_op (ir_node *node, ir_node *op) { assert (node->op == op_Abs); set_irn_n(node, 0, op); } -inline ir_node * +INLINE ir_node * get_And_left (ir_node *node) { assert (node->op == op_And); return get_irn_n(node, 0); } -inline void +INLINE void set_And_left (ir_node *node, ir_node *left) { assert (node->op == op_And); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_And_right (ir_node *node) { assert (node->op == op_And); return get_irn_n(node, 1); } -inline void +INLINE void set_And_right (ir_node *node, ir_node *right) { assert (node->op == op_And); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Or_left (ir_node *node) { assert (node->op == op_Or); return get_irn_n(node, 0); } -inline void +INLINE void set_Or_left (ir_node *node, ir_node *left) { assert (node->op == op_Or); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Or_right (ir_node *node) { assert (node->op == op_Or); return get_irn_n(node, 1); } -inline void +INLINE void set_Or_right (ir_node *node, ir_node *right) { assert (node->op == op_Or); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Eor_left (ir_node *node) { assert (node->op == op_Eor); return get_irn_n(node, 0); } -inline void +INLINE void set_Eor_left (ir_node *node, ir_node *left) { assert (node->op == op_Eor); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Eor_right (ir_node *node) { assert (node->op == op_Eor); return get_irn_n(node, 1); } -inline void +INLINE void set_Eor_right (ir_node *node, ir_node *right) { assert (node->op == op_Eor); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Not_op (ir_node *node) { assert (node->op == op_Not); return get_irn_n(node, 0); } -inline void +INLINE void set_Not_op (ir_node *node, ir_node *op) { assert (node->op == op_Not); set_irn_n(node, 0, op); } -inline ir_node * +INLINE ir_node * get_Shl_left (ir_node *node) { assert (node->op == op_Shl); return get_irn_n(node, 0); } -inline void +INLINE void set_Shl_left (ir_node *node, ir_node *left) { assert (node->op == op_Shl); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Shl_right (ir_node *node) { assert (node->op == op_Shl); return get_irn_n(node, 1); } -inline void +INLINE void set_Shl_right (ir_node *node, ir_node *right) { assert (node->op == op_Shl); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Shr_left (ir_node *node) { assert (node->op == op_Shr); return get_irn_n(node, 0); } -inline void +INLINE void set_Shr_left (ir_node *node, ir_node *left) { assert (node->op == op_Shr); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Shr_right (ir_node *node) { assert (node->op == op_Shr); return get_irn_n(node, 1); } -inline void +INLINE void set_Shr_right (ir_node *node, ir_node *right) { assert (node->op == op_Shr); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Shrs_left (ir_node *node) { assert (node->op == op_Shrs); return get_irn_n(node, 0); } -inline void +INLINE void set_Shrs_left (ir_node *node, ir_node *left) { assert (node->op == op_Shrs); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Shrs_right (ir_node *node) { assert (node->op == op_Shrs); return get_irn_n(node, 1); } -inline void +INLINE void set_Shrs_right (ir_node *node, ir_node *right) { assert (node->op == op_Shrs); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Rot_left (ir_node *node) { assert (node->op == op_Rot); return get_irn_n(node, 0); } -inline void +INLINE void set_Rot_left (ir_node *node, ir_node *left) { assert (node->op == op_Rot); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Rot_right (ir_node *node) { assert (node->op == op_Rot); return get_irn_n(node, 1); } -inline void +INLINE void set_Rot_right (ir_node *node, ir_node *right) { assert (node->op == op_Rot); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Cmp_left (ir_node *node) { assert (node->op == op_Cmp); return get_irn_n(node, 0); } -inline void +INLINE void set_Cmp_left (ir_node *node, ir_node *left) { assert (node->op == op_Cmp); set_irn_n(node, 0, left); } -inline ir_node * +INLINE ir_node * get_Cmp_right (ir_node *node) { assert (node->op == op_Cmp); return get_irn_n(node, 1); } -inline void +INLINE void set_Cmp_right (ir_node *node, ir_node *right) { assert (node->op == op_Cmp); set_irn_n(node, 1, right); } -inline ir_node * +INLINE ir_node * get_Conv_op (ir_node *node) { assert (node->op == op_Conv); return get_irn_n(node, 0); } -inline void +INLINE void set_Conv_op (ir_node *node, ir_node *op) { assert (node->op == op_Conv); set_irn_n(node, 0, op); } -inline ir_node ** +INLINE ir_node * +get_Cast_op (ir_node *node) { + assert (node->op == op_Cast); + return get_irn_n(node, 0); +} + +INLINE void +set_Cast_op (ir_node *node, ir_node *op) { + assert (node->op == op_Cast); + set_irn_n(node, 0, op); +} + +INLINE type * +get_Cast_type (ir_node *node) { + assert (node->op == op_Cast); + return node->attr.cast.totype; +} + +INLINE void +set_Cast_type (ir_node *node, type *to_tp) { + assert (node->op == op_Cast); + node->attr.cast.totype = to_tp; +} + +INLINE int +is_unop (ir_node *node) { + return ( node->op == op_Minus || + node->op == op_Abs || + node->op == op_Not || + node->op == op_Conv || + node->op == op_Cast ); +} + +INLINE ir_node * +get_unop_op (ir_node *node) { + assert (is_unop(node)); + switch (get_irn_opcode (node)) { + case iro_Minus: return get_Minus_op(node); break; + case iro_Abs: return get_Abs_op(node); break; + case iro_Not: return get_Not_op(node); break; + case iro_Conv: return get_Conv_op(node); break; + case iro_Cast: return get_Cast_op(node); break; + default: return NULL; + } +} + +INLINE void +set_unop_op (ir_node *node, ir_node *op) { + assert (is_unop(node)); + switch (get_irn_opcode (node)) { + case iro_Minus: set_Minus_op(node, op); break; + case iro_Abs: set_Abs_op(node, op); break; + case iro_Not: set_Not_op(node, op); break; + case iro_Conv: set_Conv_op(node, op); break; + case iro_Cast: set_Cast_op(node, op); break; + default: ; + } + +} + +int +is_binop (ir_node *node) { + return (node->op == op_Add || + node->op == op_Sub || + node->op == op_Mul || + node->op == op_Quot || + node->op == op_DivMod || + node->op == op_Div || + node->op == op_Mod || + node->op == op_And || + node->op == op_Or || + node->op == op_Eor || + node->op == op_Shl || + node->op == op_Shr || + node->op == op_Shrs || + node->op == op_Rot || + node->op == op_Cmp ); +} + +INLINE ir_node * +get_binop_left (ir_node *node) { + assert (node->op == op_Add || + node->op == op_Sub || + node->op == op_Mul || + node->op == op_Quot || + node->op == op_DivMod || + node->op == op_Div || + node->op == op_Mod || + node->op == op_And || + node->op == op_Or || + node->op == op_Eor || + node->op == op_Shl || + node->op == op_Shr || + node->op == op_Shrs || + node->op == op_Rot || + node->op == op_Cmp ); + + switch (get_irn_opcode (node)) { + case iro_Add : return get_Add_left(node); break; + case iro_Sub : return get_Sub_left(node); break; + case iro_Mul : return get_Mul_left(node); break; + case iro_Quot : return get_Quot_left(node); break; + case iro_DivMod: return get_DivMod_left(node); break; + case iro_Div : return get_Div_left(node); break; + case iro_Mod : return get_Mod_left(node); break; + case iro_And : return get_And_left(node); break; + case iro_Or : return get_Or_left(node); break; + case iro_Eor : return get_Eor_left(node); break; + case iro_Shl : return get_Shl_left(node); break; + case iro_Shr : return get_Shr_left(node); break; + case iro_Shrs : return get_Shrs_left(node); break; + case iro_Rot : return get_Rot_left(node); break; + case iro_Cmp : return get_Cmp_left(node); break; + default: return NULL; + }; +} + +INLINE void +set_binop_left (ir_node *node, ir_node *left) { + assert (node->op == op_Add || + node->op == op_Sub || + node->op == op_Mul || + node->op == op_Quot || + node->op == op_DivMod || + node->op == op_Div || + node->op == op_Mod || + node->op == op_And || + node->op == op_Or || + node->op == op_Eor || + node->op == op_Shl || + node->op == op_Shr || + node->op == op_Shrs || + node->op == op_Rot || + node->op == op_Cmp ); + + switch (get_irn_opcode (node)) { + case iro_Add : set_Add_left(node, left); break; + case iro_Sub : set_Sub_left(node, left); break; + case iro_Mul : set_Mul_left(node, left); break; + case iro_Quot : set_Quot_left(node, left); break; + case iro_DivMod: set_DivMod_left(node, left); break; + case iro_Div : set_Div_left(node, left); break; + case iro_Mod : set_Mod_left(node, left); break; + case iro_And : set_And_left(node, left); break; + case iro_Or : set_Or_left(node, left); break; + case iro_Eor : set_Eor_left(node, left); break; + case iro_Shl : set_Shl_left(node, left); break; + case iro_Shr : set_Shr_left(node, left); break; + case iro_Shrs : set_Shrs_left(node, left); break; + case iro_Rot : set_Rot_left(node, left); break; + case iro_Cmp : set_Cmp_left(node, left); break; + default: ; + }; +} + +INLINE ir_node * +get_binop_right (ir_node *node) { + assert (node->op == op_Add || + node->op == op_Sub || + node->op == op_Mul || + node->op == op_Quot || + node->op == op_DivMod || + node->op == op_Div || + node->op == op_Mod || + node->op == op_And || + node->op == op_Or || + node->op == op_Eor || + node->op == op_Shl || + node->op == op_Shr || + node->op == op_Shrs || + node->op == op_Rot || + node->op == op_Cmp ); + + switch (get_irn_opcode (node)) { + case iro_Add : return get_Add_right(node); break; + case iro_Sub : return get_Sub_right(node); break; + case iro_Mul : return get_Mul_right(node); break; + case iro_Quot : return get_Quot_right(node); break; + case iro_DivMod: return get_DivMod_right(node); break; + case iro_Div : return get_Div_right(node); break; + case iro_Mod : return get_Mod_right(node); break; + case iro_And : return get_And_right(node); break; + case iro_Or : return get_Or_right(node); break; + case iro_Eor : return get_Eor_right(node); break; + case iro_Shl : return get_Shl_right(node); break; + case iro_Shr : return get_Shr_right(node); break; + case iro_Shrs : return get_Shrs_right(node); break; + case iro_Rot : return get_Rot_right(node); break; + case iro_Cmp : return get_Cmp_right(node); break; + default: return NULL; + }; +} + +INLINE void +set_binop_right (ir_node *node, ir_node *right) { + assert (node->op == op_Add || + node->op == op_Sub || + node->op == op_Mul || + node->op == op_Quot || + node->op == op_DivMod || + node->op == op_Div || + node->op == op_Mod || + node->op == op_And || + node->op == op_Or || + node->op == op_Eor || + node->op == op_Shl || + node->op == op_Shr || + node->op == op_Shrs || + node->op == op_Rot || + node->op == op_Cmp ); + + switch (get_irn_opcode (node)) { + case iro_Add : set_Add_right(node, right); break; + case iro_Sub : set_Sub_right(node, right); break; + case iro_Mul : set_Mul_right(node, right); break; + case iro_Quot : set_Quot_right(node, right); break; + case iro_DivMod: set_DivMod_right(node, right); break; + case iro_Div : set_Div_right(node, right); break; + case iro_Mod : set_Mod_right(node, right); break; + case iro_And : set_And_right(node, right); break; + case iro_Or : set_Or_right(node, right); break; + case iro_Eor : set_Eor_right(node, right); break; + case iro_Shl : set_Shl_right(node, right); break; + case iro_Shr : set_Shr_right(node, right); break; + case iro_Shrs : set_Shrs_right(node, right); break; + case iro_Rot : set_Rot_right(node, right); break; + case iro_Cmp : set_Cmp_right(node, right); break; + default: ; + }; +} + +INLINE int is_Phi (ir_node *n) { + assert(n); + return ((get_irn_op(n) == op_Phi) || + (get_irn_op(n) == op_Filter && interprocedural_view)); +} + +INLINE ir_node ** get_Phi_preds_arr (ir_node *node) { assert (node->op == op_Phi); return (ir_node **)&(get_irn_in(node)[1]); } -inline int +INLINE int get_Phi_n_preds (ir_node *node) { - assert (node->op == op_Phi); + assert (is_Phi(node)); return (get_irn_arity(node)); } /* -inline void set_Phi_n_preds (ir_node *node, int n_preds) { +INLINE void set_Phi_n_preds (ir_node *node, int n_preds) { assert (node->op == op_Phi); } */ -inline ir_node * +INLINE ir_node * get_Phi_pred (ir_node *node, int pos) { - assert (node->op == op_Phi); + assert (is_Phi(node)); return get_irn_n(node, pos); } -inline void +INLINE void set_Phi_pred (ir_node *node, int pos, ir_node *pred) { - assert (node->op == op_Phi); + assert (is_Phi(node)); set_irn_n(node, pos, pred); } -inline ir_node * +INLINE ir_node * get_Load_mem (ir_node *node) { assert (node->op == op_Load); return get_irn_n(node, 0); } -inline void +INLINE void set_Load_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Load); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Load_ptr (ir_node *node) { assert (node->op == op_Load); return get_irn_n(node, 1); } -inline void +INLINE void set_Load_ptr (ir_node *node, ir_node *ptr) { assert (node->op == op_Load); set_irn_n(node, 1, ptr); } -inline +INLINE ir_node * get_Store_mem (ir_node *node) { assert (node->op == op_Store); return get_irn_n(node, 0); } -inline void +INLINE void set_Store_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Store); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Store_ptr (ir_node *node) { assert (node->op == op_Store); return get_irn_n(node, 1); } -inline void +INLINE void set_Store_ptr (ir_node *node, ir_node *ptr) { assert (node->op == op_Store); set_irn_n(node, 1, ptr); } -inline ir_node * +INLINE ir_node * get_Store_value (ir_node *node) { assert (node->op == op_Store); return get_irn_n(node, 2); } -inline void +INLINE void set_Store_value (ir_node *node, ir_node *value) { assert (node->op == op_Store); set_irn_n(node, 2, value); } -inline ir_node * +INLINE ir_node * get_Alloc_mem (ir_node *node) { assert (node->op == op_Alloc); return get_irn_n(node, 0); } -inline void +INLINE void set_Alloc_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Alloc); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Alloc_size (ir_node *node) { assert (node->op == op_Alloc); return get_irn_n(node, 1); } -inline void +INLINE void set_Alloc_size (ir_node *node, ir_node *size) { assert (node->op == op_Alloc); set_irn_n(node, 1, size); } -inline type * +INLINE type * get_Alloc_type (ir_node *node) { assert (node->op == op_Alloc); - return node->attr.a.type; + return node->attr.a.type = skip_tid(node->attr.a.type); } -inline void -set_Alloc_type (ir_node *node, type *type) { +INLINE void +set_Alloc_type (ir_node *node, type *tp) { assert (node->op == op_Alloc); - node->attr.a.type = type; + node->attr.a.type = tp; } -inline where_alloc +INLINE where_alloc get_Alloc_where (ir_node *node) { assert (node->op == op_Alloc); return node->attr.a.where; } -inline void +INLINE void set_Alloc_where (ir_node *node, where_alloc where) { assert (node->op == op_Alloc); node->attr.a.where = where; } -inline ir_node * +INLINE ir_node * get_Free_mem (ir_node *node) { assert (node->op == op_Free); return get_irn_n(node, 0); } -inline void +INLINE void set_Free_mem (ir_node *node, ir_node *mem) { assert (node->op == op_Free); set_irn_n(node, 0, mem); } -inline ir_node * +INLINE ir_node * get_Free_ptr (ir_node *node) { assert (node->op == op_Free); return get_irn_n(node, 1); } -inline void +INLINE void set_Free_ptr (ir_node *node, ir_node *ptr) { assert (node->op == op_Free); set_irn_n(node, 1, ptr); } -inline ir_node * +INLINE ir_node * get_Free_size (ir_node *node) { assert (node->op == op_Free); return get_irn_n(node, 2); } -inline void +INLINE void set_Free_size (ir_node *node, ir_node *size) { assert (node->op == op_Free); set_irn_n(node, 2, size); } -inline type * +INLINE type * get_Free_type (ir_node *node) { assert (node->op == op_Free); - return node->attr.f; + return node->attr.f = skip_tid(node->attr.f); } -inline void -set_Free_type (ir_node *node, type *type) { +INLINE void +set_Free_type (ir_node *node, type *tp) { assert (node->op == op_Free); - node->attr.f = type; + node->attr.f = tp; } -inline ir_node ** +INLINE ir_node ** get_Sync_preds_arr (ir_node *node) { assert (node->op == op_Sync); return (ir_node **)&(get_irn_in(node)[1]); } -inline int +INLINE int get_Sync_n_preds (ir_node *node) { assert (node->op == op_Sync); return (get_irn_arity(node)); } /* -inline void +INLINE void set_Sync_n_preds (ir_node *node, int n_preds) { assert (node->op == op_Sync); } */ -inline ir_node * +INLINE ir_node * get_Sync_pred (ir_node *node, int pos) { assert (node->op == op_Sync); return get_irn_n(node, pos); } -inline void +INLINE void set_Sync_pred (ir_node *node, int pos, ir_node *pred) { assert (node->op == op_Sync); set_irn_n(node, pos, pred); } -inline ir_node * +INLINE ir_node * get_Proj_pred (ir_node *node) { - assert (node->op == op_Proj); + assert (is_Proj(node)); return get_irn_n(node, 0); } -inline void +INLINE void set_Proj_pred (ir_node *node, ir_node *pred) { - assert (node->op == op_Proj); + assert (is_Proj(node)); set_irn_n(node, 0, pred); } -inline long +INLINE long get_Proj_proj (ir_node *node) { - assert (node->op == op_Proj); - return node->attr.proj; + assert (is_Proj(node)); + if (get_irn_opcode(node) == iro_Proj) { + return node->attr.proj; + } else { + assert(get_irn_opcode(node) == iro_Filter); + return node->attr.filter.proj; + } } -inline void +INLINE void set_Proj_proj (ir_node *node, long proj) { assert (node->op == op_Proj); node->attr.proj = proj; } -inline ir_node ** +INLINE ir_node ** get_Tuple_preds_arr (ir_node *node) { assert (node->op == op_Tuple); return (ir_node **)&(get_irn_in(node)[1]); } -inline int +INLINE int get_Tuple_n_preds (ir_node *node) { assert (node->op == op_Tuple); return (get_irn_arity(node)); } /* -inline void +INLINE void set_Tuple_n_preds (ir_node *node, int n_preds) { assert (node->op == op_Tuple); } */ -inline ir_node * +INLINE ir_node * get_Tuple_pred (ir_node *node, int pos) { assert (node->op == op_Tuple); return get_irn_n(node, pos); } -inline void +INLINE void set_Tuple_pred (ir_node *node, int pos, ir_node *pred) { assert (node->op == op_Tuple); set_irn_n(node, pos, pred); } -inline ir_node * +INLINE ir_node * get_Id_pred (ir_node *node) { assert (node->op == op_Id); return get_irn_n(node, 0); } -inline void +INLINE void set_Id_pred (ir_node *node, ir_node *pred) { assert (node->op == op_Id); set_irn_n(node, 0, pred); } +INLINE ir_node *get_Confirm_value (ir_node *node) { + assert (node->op == op_Confirm); + return get_irn_n(node, 0); +} +INLINE void set_Confirm_value (ir_node *node, ir_node *value) { + assert (node->op == op_Confirm); + set_irn_n(node, 0, value); +} +INLINE ir_node *get_Confirm_bound (ir_node *node) { + assert (node->op == op_Confirm); + return get_irn_n(node, 1); +} +INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) { + assert (node->op == op_Confirm); + set_irn_n(node, 0, bound); +} +INLINE pn_Cmp get_Confirm_cmp (ir_node *node) { + assert (node->op == op_Confirm); + return node->attr.confirm_cmp; +} +INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) { + assert (node->op == op_Confirm); + node->attr.confirm_cmp = cmp; +} + + +INLINE ir_node * +get_Filter_pred (ir_node *node) { + assert(node->op == op_Filter); + return node->in[1]; +} +INLINE void +set_Filter_pred (ir_node *node, ir_node *pred) { + assert(node->op == op_Filter); + node->in[1] = pred; +} +INLINE long +get_Filter_proj(ir_node *node) { + assert(node->op == op_Filter); + return node->attr.filter.proj; +} +INLINE void +set_Filter_proj (ir_node *node, long proj) { + assert(node->op == op_Filter); + node->attr.filter.proj = proj; +} + +/* Don't use get_irn_arity, get_irn_n in implementation as access + shall work independent of view!!! */ +void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) { + assert(node->op == op_Filter); + if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) { + node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1); + node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity); + memset(node->attr.filter.backedge, 0, sizeof(int) * arity); + node->attr.filter.in_cg[0] = node->in[0]; + } + memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity); +} + +void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred) { + assert(node->op == op_Filter && node->attr.filter.in_cg && + 0 <= pos && pos < ARR_LEN(node->attr.filter.in_cg) - 1); + node->attr.filter.in_cg[pos + 1] = pred; +} +int get_Filter_n_cg_preds(ir_node *node) { + assert(node->op == op_Filter && node->attr.filter.in_cg); + return (ARR_LEN(node->attr.filter.in_cg) - 1); +} +ir_node *get_Filter_cg_pred(ir_node *node, int pos) { + int arity; + assert(node->op == op_Filter && node->attr.filter.in_cg && + 0 <= pos); + arity = ARR_LEN(node->attr.filter.in_cg); + assert(pos < arity - 1); + return node->attr.filter.in_cg[pos + 1]; +} + + +INLINE ir_graph * +get_irn_irg(ir_node *node) { + if (get_irn_op(node) != op_Block) + node = get_nodes_block(node); + assert(get_irn_op(node) == op_Block); + return node->attr.block.irg; +} + + /******************************************************************/ /* Auxiliary routines */ /******************************************************************/ -inline ir_node * +INLINE ir_node * skip_Proj (ir_node *node) { /* don't assert node !!! */ - if (node && (node->op == op_Proj)) { + if (node && is_Proj(node)) { return get_Proj_pred(node); } else { return node; } } -inline ir_node * +INLINE ir_node * +skip_Tuple (ir_node *node) { + ir_node *pred; + + if (!get_opt_normalize()) return node; + + node = skip_nop(node); + if (get_irn_op(node) == op_Proj) { + pred = skip_nop(get_Proj_pred(node)); + if (get_irn_op(pred) == op_Proj) /* nested Tuple ? */ + pred = skip_nop(skip_Tuple(pred)); + if (get_irn_op(pred) == op_Tuple) + return get_Tuple_pred(pred, get_Proj_proj(node)); + } + return node; +} + +/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity + than any other approach, as Id chains are resolved and all point to the real node, or + all id's are self loops. */ +INLINE ir_node * skip_nop (ir_node *node) { /* don't assert node !!! */ - if (node && (node->op == op_Id) && (node != get_Id_pred(node))) { - /* Don't use get_Id_pred: We get into an endless loop for - self-referencing Ids. */ + if (!get_opt_normalize()) return node; + + /* Don't use get_Id_pred: We get into an endless loop for + self-referencing Ids. */ + if (node && (node->op == op_Id) && (node != node->in[0+1])) { + ir_node *rem_pred = node->in[0+1]; + ir_node *res; + assert (get_irn_arity (node) > 0); - return node->in[0+1]; + + node->in[0+1] = node; + res = skip_nop(rem_pred); + if (res->op == op_Id) /* self-loop */ return node; + + node->in[0+1] = res; + return res; } else { return node; } } -inline int +INLINE ir_node * +skip_Id (ir_node *node) { + return skip_nop(node); +} + +INLINE int is_Bad (ir_node *node) { assert(node); if ((node) && get_irn_opcode(node) == iro_Bad) @@ -1752,21 +2358,46 @@ is_Bad (ir_node *node) { return 0; } -inline int +INLINE int is_no_Block (ir_node *node) { assert(node); return (get_irn_opcode(node) != iro_Block); } +INLINE int +is_Block (ir_node *node) { + assert(node); + return (get_irn_opcode(node) == iro_Block); +} + +/* returns true if node is a Unknown node. */ +INLINE int +is_Unknown (ir_node *node) { + assert(node); + return (get_irn_opcode(node) == iro_Unknown); +} + +INLINE int +is_Proj (const ir_node *node) { + assert(node); + return node->op == op_Proj + || (!interprocedural_view && node->op == op_Filter); +} + /* Returns true if the operation manipulates control flow. */ int is_cfop(ir_node *node) { - return ( (get_irn_opcode(node) == iro_Start) - || (get_irn_opcode(node) == iro_Jmp) - || (get_irn_opcode(node) == iro_Cond) - || (get_irn_opcode(node) == iro_Return) - || (get_irn_opcode(node) == iro_Raise) - || (get_irn_opcode(node) == iro_Bad)); + return is_cfopcode(get_irn_op(node)); +} + +/* Returns true if the operation manipulates interprocedural control flow: + CallBegin, EndReg, EndExcept */ +INLINE int is_ip_cfop(ir_node *node) { + return is_ip_cfopcode(get_irn_op(node)); +} + +ir_graph *get_ip_cfop_irg(ir_node *n) { + return get_irn_irg(n); } /* Returns true if the operation can change the control flow because @@ -1781,5 +2412,30 @@ is_fragile_op(ir_node *node) { || (get_irn_opcode(node) == iro_Load) || (get_irn_opcode(node) == iro_Store) || (get_irn_opcode(node) == iro_Alloc) - || (get_irn_opcode(node) == iro_Bad)); + || (get_irn_opcode(node) == iro_Bad) + || (get_irn_opcode(node) == iro_Unknown)); +} + + +/* Returns the memory operand of fragile operations. */ +ir_node *get_fragile_op_mem(ir_node *node) { + assert(node && is_fragile_op(node)); + + switch (get_irn_opcode (node)) { + case iro_Call : + case iro_Quot : + case iro_DivMod: + case iro_Div : + case iro_Mod : + case iro_Load : + case iro_Store : + case iro_Alloc : + return get_irn_n(node, 0); + case iro_Bad : + case iro_Unknown: + return node; + default: ; + assert(0 && "not reached"); + return NULL; + } }