nsz Git - libfirm/blob - ir/ir/irnode.h

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irnode.h
   4  * Purpose:     Representation of an intermediate operation.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 # ifndef _IRNODE_H_
  14 # define _IRNODE_H_
  15
  16 #include <stddef.h>
  17
  18 /**
  19  * Projection numbers of compare: use for Proj nodes!
  20  * @remark there are numbers with normalized names below!
  21  */
  22 typedef enum {
  23   False = 0,    /**< false */
  24   Eq,           /**< equal */
  25   Lt,           /**< less */
  26   Le,           /**< less or equal */
  27   Gt,           /**< greater */
  28   Ge,           /**< greater or equal */
  29   Lg,           /**< less or greater */
  30   Leg = 7,      /**< less, equal or greater = ordered */
  31   Uo,           /**< unordered */
  32   Ue,           /**< unordered or equal */
  33   Ul,           /**< unordered or less */
  34   Ule,          /**< unordered, less or equal */
  35   Ug,           /**< unordered or greater */
  36   Uge,          /**< unordered, greater or equal */
  37   Ne,           /**< unordered, less or greater = not equal */
  38   True = 15     /**< true */
  39   /* not_mask = Leg*/   /* bits to flip to negate comparison * @@ hack for jni interface */
  40 } pnc_number;   /* pnc: Projection Number Cmp */
  41 #define not_mask Leg
  42
  43 # include "tv.h"
  44 # include "irgraph.h"
  45 # include "entity.h"
  46 # include "firm_common.h"
  47 # include "irop.h"
  48 # include "irmode.h"
  49 # include "type.h"
  50 # include "dbginfo.h"
  51 /* # include "exc.h" */
  52
  53 /**
  54  * @file irnode.h
  55  *
  56  * @author Martin Trapp, Christian Schaefer
  57  *
  58  * Declarations of an ir node.
  59  */
  60
  61 /**
  62  * @defgroup ir_node Declarations of an ir node.
  63  *
  64  * The type definition of ir_node is also in irgraph.h to resolve
  65  *  recursion between irnode.h and irgraph.h
  66  *
  67  * ir_node - a datatype representing a Firm node
  68  *
  69  *  The common fields are:
  70  *
  71  *  - firm_kind - A firm_kind tag containing k_type.  This is useful
  72  *                for dynamically checking whether a node is a ir_node.
  73  *  - arity     - The number of predecessors in the Firm graph.
  74  *  - in        - A list with the predecessors in the Firm graph.  There are
  75  *                routines to access individual elements and to obtain the
  76  *                array.  The method returning the array should not be used.
  77  *  - mode      - The mode of the node.  There are routines to get the mode
  78  *                but also to access the mode's fields directly.
  79  *  - opcode    - The opcode of the node. There are routines to get the opcode
  80  *                but also to access the opcode's fields directly.
  81  *  - node_nr   - A unique number for the node.  Available only if debugging
  82  *                is turned on.
  83  * @{
  84  */
  85
  86 #ifndef _IR_NODE_TYPEDEF_
  87 #define _IR_NODE_TYPEDEF_
  88 typedef struct ir_node ir_node;
  89 #endif
  90
  91 #ifdef __cplusplus
  92 extern "C" {
  93 #endif
  94
  95 /**
  96  *   you can work on the graph without considering the different types
  97  *   of nodes, it's just a big graph.
  98  */
  99
 100 /**
 101  *   Checks whether a pointer points to a ir node.
 102  *
 103  *   @param thing   an arbitrary pointer
 104  *   @return        non-zero if the thing is a ir mode, else zero
 105  */
 106 int is_ir_node (const void *thing);
 107
 108 /**
 109  * Returns the number of predecessors without the block predecessor.
 110  *
 111  * @param node   the IR-node
 112  */
 113 int           get_irn_arity         (const ir_node *node);
 114 int           get_irn_intra_arity   (const ir_node *node);
 115 int           get_irn_inter_arity   (const ir_node *node);
 116
 117 /** Replaces the old in array by a new one that will contain the ins given in
 118    the parameters.  Conserves the block predecessor.  It copies the array passed.
 119    This function is necessary to adjust in arrays of blocks, calls and phis.
 120    Assumes that current_ir_graph is set to the graph containing "node".
 121    "in" must contain all predecessors except the block that are required for
 122    the nodes opcode. */
 123 void          set_irn_in            (ir_node *node, int arity,
 124                         ir_node *in[]);
 125 /* to iterate through the predecessors without touching the array. No
 126    order of predecessors guaranteed.
 127    To iterate over the operands iterate from 0 to i < get_irn_arity(),
 128    to iterate including the Block predecessor iterate from i = -1 to
 129    i < get_irn_arity. */
 130 /* Access predecessor n */
 131
 132 /**
 133  * Get the n-th predecessor of a node.
 134  * This function removes Id predecessors.
 135  */
 136 ir_node      *get_irn_n             (const ir_node *node, int n);
 137 ir_node      *get_irn_intra_n       (const ir_node *node, int n);
 138 ir_node      *get_irn_inter_n       (const ir_node *node, int n);
 139
 140 /** Replace the n-th predecessor of a node with a new one. */
 141 void          set_irn_n             (ir_node *node, int n, ir_node *in);
 142 /* Sets the mode struct of node.  */
 143 void          set_irn_mode (ir_node *node, ir_mode *mode);
 144 /** Gets the mode struct of a node.  */
 145 ir_mode      *get_irn_mode          (const ir_node *node);
 146 /** Gets the mode-enum modecode. */
 147 modecode      get_irn_modecode      (const ir_node *node);
 148 /** Gets the ident for a string representation of the mode .*/
 149 ident        *get_irn_modeident     (const ir_node *node);
 150 /** Gets the string representation of the mode .*/
 151 const char   *get_irn_modename      (const ir_node *node);
 152 /** Gets the opcode struct of the node. */
 153 ir_op        *get_irn_op            (const ir_node *node);
 154 /** Sets the opcode struct of the node. */
 155 void          set_irn_op            (ir_node *node, ir_op *op);
 156 /** Gets the opcode-enum of the node. */
 157 opcode        get_irn_opcode        (const ir_node *node);
 158 /** Get the string representation of the opcode. */
 159 const char   *get_irn_opname        (const ir_node *node);
 160 /** Get the ident for a string representation of the opcode. */
 161 ident        *get_irn_opident       (const ir_node *node);
 162 /** Gets the visited counter of a node. */
 163 unsigned long get_irn_visited (const ir_node *node);
 164 /** Sets the visited counter of a node. */
 165 void          set_irn_visited (ir_node *node, unsigned long visited);
 166 /** Sets visited to get_irg_visited(current_ir_graph). */
 167 void          mark_irn_visited (ir_node *node);
 168 /** Returns 1 if visited < get_irg_visited(current_ir_graph). */
 169 int           irn_not_visited  (const ir_node *node);
 170 /** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
 171 int           irn_visited      (const ir_node *node);
 172
 173 /**
 174  * Sets the link of a node.
 175  * Only allowed if the graph is NOT in phase_building.
 176  */
 177 void          set_irn_link     (ir_node *node, void *link);
 178
 179 /** Returns the link of a node.  */
 180 void         *get_irn_link     (const ir_node *node);
 181
 182 /** Returns the ir_graph this node belongs to. Only valid if irg
 183  *  is in state op_pin_state_pinned (irg is only stored in the block. */
 184 ir_graph     *get_irn_irg      (const ir_node *node);
 185
 186 /** Outputs a unique number for this node if libFIRM is compiled for
 187    debugging, (configure with --enable-debug) else returns address
 188    of node cast to long. */
 189 long          get_irn_node_nr  (const ir_node *node);
 190
 191 /** Returns the pinned state of a node. */
 192 op_pin_state get_irn_pinned    (const ir_node *node);
 193
 194 /** Set pin state for nodes with op pin state op_pin_state_exc_pinned */
 195 void set_irn_pinned(ir_node *node, op_pin_state state);
 196
 197 /**
 198  * irnode constructor.
 199  * Create a new irnode in irg, with an op, mode, arity and
 200  * some incoming irnodes.
 201  * This constructor is used in every specified irnode constructor.
 202  *
 203  * @param db    Debug info.
 204  * @param irg   IR-graph on with this new node should be constructed.
 205  * @param op    The opcode of the new node.
 206  * @param mode  The mode of the new node.
 207  * @param arity The arity of the new node, may be <0 if yet.
 208  * @param in    An array of arity predecessor nodes.
 209  */
 210 ir_node *
 211 new_ir_node (dbg_info *db,
 212          ir_graph *irg,
 213          ir_node *block,
 214          ir_op *op,
 215          ir_mode *mode,
 216          int arity,
 217          ir_node *in[]);
 218
 219 /** Return the block the node belongs to.
 220  *
 221  * This works for all except Block.  It can return Blocks or the Bad node.
 222  *
 223  * To express the difference to access routines that work for all
 224  * nodes we use infix "nodes" and do not name this function
 225  * get_irn_block. */
 226 ir_node  *get_nodes_block (const ir_node *node);
 227
 228 /** Sets the Block of a node. */
 229 void      set_nodes_block (ir_node *node, ir_node *block);
 230
 231 /**
 232  * @function get_irn_block()
 233  * @see get_nodes_block()
 234  */
 235 /**
 236  * Projection numbers for result of Start node: use for Proj nodes!
 237  */
 238 typedef enum {
 239   pn_Start_X_initial_exec,   /**< Projection on the initial control flow. */
 240   pn_Start_M,                /**< Projection on the initial memory. */
 241   pn_Start_P_frame_base,     /**< Projection on the frame base pointer. */
 242   pn_Start_P_globals,        /**< Projection on the pointer to the data segment
 243                                   containing _all_ global entities. */
 244   pn_Start_T_args,           /**< Projection on all arguments. */
 245   pn_Start_P_value_arg_base, /**< Pointer to region of compound value arguments as defined by
 246                                   type of this method. */
 247   pn_Start_max               /**< number of projections from a Start */
 248 } pn_Start; /* Projection numbers for Start. */
 249
 250
 251 /** Test whether arbitrary node is frame pointer.
 252  *
 253  * Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
 254  * from Start.  If so returns frame type, else Null. */
 255 type *is_frame_pointer(ir_node *n);
 256
 257 /** Test whether arbitrary node is globals pointer.
 258  *
 259  * Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
 260  * from Start.  If so returns global type, else Null. */
 261 type *is_globals_pointer(ir_node *n);
 262
 263 /** Test whether arbitrary node is value arg base.
 264  *
 265  * Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
 266  * from Start.   If so returns 1, else 0. */
 267 int   is_value_arg_pointer(ir_node *n);
 268
 269
 270 /* @@@ no more supported  */
 271 ir_node **get_Block_cfgpred_arr (ir_node *node);
 272 int       get_Block_n_cfgpreds (ir_node *node);
 273 ir_node  *get_Block_cfgpred (ir_node *node, int pos);
 274 void      set_Block_cfgpred (ir_node *node, int pos, ir_node *pred);
 275 bool      get_Block_matured (ir_node *node);
 276 void      set_Block_matured (ir_node *node, bool matured);
 277 unsigned long get_Block_block_visited (ir_node *node);
 278 void      set_Block_block_visited (ir_node *node, unsigned long visit);
 279 ir_node  *set_Block_dead(ir_node *block);
 280 int       is_Block_dead(const ir_node *block);
 281
 282 /* For this current_ir_graph must be set. */
 283 void      mark_Block_block_visited(ir_node *node);
 284 int       Block_not_block_visited(ir_node *node);
 285
 286 /* Set and remove interprocedural predecessors. If the interprocedural
 287  * predecessors are removed, the node has the same predecessors in
 288  * both views.
 289  * @@@ Maybe better:  arity is zero if no cg preds. */
 290 void      set_Block_cg_cfgpred_arr(ir_node * node, int arity, ir_node ** in);
 291 void      set_Block_cg_cfgpred(ir_node * node, int pos, ir_node * pred);
 292 /* @@@ not supported */
 293 ir_node **get_Block_cg_cfgpred_arr(ir_node * node);
 294 /** Returns the number of interprocedural predecessors.  0 if none. */
 295 int       get_Block_cg_n_cfgpreds(ir_node * node);
 296 /** Return the interprocedural predecessor at position pos. */
 297 ir_node  *get_Block_cg_cfgpred(ir_node * node, int pos);
 298 /* frees the memory. */
 299 void      remove_Block_cg_cfgpred_arr(ir_node * node);
 300
 301 /** Return the number of Keep alive node. */
 302 int  get_End_n_keepalives(ir_node *end);
 303
 304 /** Return the Keep alive node a position pos. */
 305 ir_node *get_End_keepalive(ir_node *end, int pos);
 306
 307 /** Keep alive dedicated nodes.  These must be either PhiM or Block nodes. */
 308 void add_End_keepalive (ir_node *end, ir_node *ka);
 309
 310 /** Set the Keep alive node at position pos. */
 311 void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
 312
 313 /** Some parts of the End node are allocated separately -- their memory
 314    is not recovered by dead_node_elimination if a End node is dead.
 315    free_End() frees these data structures. */
 316 void free_End (ir_node *end);
 317
 318
 319 /* We distinguish three kinds of Cond nodes.  These can be distinguished
 320    by the mode of the selector operand and an internal flag of type cond_kind.
 321    First we distinguish binary Conds and switch Conds.
 322    A binary Cond has as selector a boolean value.  Proj(0) projects the control
 323    flow for case "False", Proj(1) the control flow for "True".  A binary Cond
 324    is recognized by the boolean selector.
 325    The switch Cond has as selector an unsigned integer.  It produces as result
 326    an n+1 Tuple (cf0, ... , cfn) of control flows.
 327    We differ two flavours of this Cond.  The first, the dense Cond, passes
 328    control along output i if the selector value is i, 0 <= i <= n.  If the
 329    selector value is >n it passes control along output n.
 330    The second Cond flavor differes in the treatment of cases not specified in
 331    the source program.  It magically knows about the existence of Proj nodes.
 332    It only passes control along output i, 0 <= i <= n, if a node Proj(Cond, i)
 333    exists.  Else it passes control along output n (even if this Proj does not
 334    exist.)  This Cond we call "fragmentary".  There is a special constructor
 335    new_defaultProj that automatically sets the flavor.
 336    The two switch flavors are distinguished by a flag of type cond_kind.
 337    Default flavor is "dense"
 338 */
 339 typedef enum {
 340   dense,        /**< Default. Missing Proj nodes are dead control flow. */
 341   fragmentary   /**< Special. No control flow optimizations allowed.  Missing
 342            Proj nodes mean default control flow, i.e., Proj(n). */
 343 } cond_kind;
 344
 345 ir_node  *get_Cond_selector (ir_node *node);
 346 void      set_Cond_selector (ir_node *node, ir_node *selector);
 347 cond_kind get_Cond_kind (ir_node *node);
 348 void      set_Cond_kind (ir_node *node, cond_kind kind);
 349 long      get_Cond_defaultProj (ir_node *node);
 350
 351 /**
 352  * Projection numbers for conditions.
 353  */
 354 typedef enum {
 355   pn_Cond_false,    /**< Control flow if operand is "false". */
 356   pn_Cond_true,     /**< Control flow if operand is "true".  */
 357   pn_Cond_max       /**< number of projections from a Cond */
 358 } pn_Cond;  /* Projection numbers for Cond. */
 359
 360 ir_node  *get_Return_mem (ir_node *node);
 361 void      set_Return_mem (ir_node *node, ir_node *mem);
 362 ir_node **get_Return_res_arr (ir_node *node);
 363 int       get_Return_n_ress (ir_node *node);
 364 ir_node  *get_Return_res (ir_node *node, int pos);
 365 void      set_Return_res (ir_node *node, int pos, ir_node *res);
 366
 367 ir_node *get_Raise_mem (ir_node *node);
 368 void     set_Raise_mem (ir_node *node, ir_node *mem);
 369 ir_node *get_Raise_exo_ptr (ir_node *node);  /* PoinTeR to EXception Object */
 370 void     set_Raise_exo_ptr (ir_node *node, ir_node *exoptr);
 371
 372 /**
 373  * Projection numbers for Raise.
 374  */
 375 typedef enum {
 376   pn_Raise_X,    /**< Execution result. */
 377   pn_Raise_M,    /**< Memory result.    */
 378   pn_Raise_max   /**< number of projections from a Raise */
 379 } pn_Raise;  /* Projection numbers for Raise. */
 380
 381 tarval  *get_Const_tarval (ir_node *node);
 382 void     set_Const_tarval (ir_node *node, tarval *con);
 383
 384 /** Returns the source language type of a Const node.
 385  * Must be an atomic type.  Mode of type must be mode of node.
 386  */
 387 type    *get_Const_type   (ir_node *node);
 388
 389 /** Sets the source language type of a Const node. */
 390 void     set_Const_type   (ir_node *node, type *tp);
 391
 392 /**  This enum names the three different kinds of symbolic Constants
 393      represented by SymConst.  The content of the attribute type_or_id
 394      depends on this tag.  Use the proper access routine after testing
 395      this flag. */
 396 typedef enum {
 397   symconst_type_tag,    /**< The SymConst is a type tag for the given type.
 398                            Type_or_id_p is type *. */
 399   symconst_size,        /**< The SymConst is the size of the given type.
 400                            Type_or_id_p is type *. */
 401   symconst_addr_name,   /**< The SymConst is a symbolic pointer to be filled in
 402                            by the linker.  The pointer is represented by a string.
 403                            Type_or_id_p is ident *. */
 404   symconst_addr_ent     /**< The SymConst is a symbolic pointer to be filled in
 405                            by the linker.  The pointer is represented by an entity.
 406                            Type_or_id_p is entity *. */
 407 } symconst_kind;
 408
 409 /** SymConst attributes
 410     This union contains the symbolic information represented by the node  */
 411 union symconst_symbol {
 412   type   *type_p;
 413   ident  *ident_p;
 414   entity *entity_p;
 415 };
 416
 417 typedef union symconst_symbol symconst_symbol;
 418
 419
 420 /** Get the kind of the SymConst. */
 421 symconst_kind get_SymConst_kind (const ir_node *node);
 422 /** Set the kind of the SymConst. */
 423 void          set_SymConst_kind (ir_node *node, symconst_kind num);
 424
 425 /** Only to access SymConst of kind type_tag or size.  Else assertion: */
 426 type    *get_SymConst_type (ir_node *node);
 427 void     set_SymConst_type (ir_node *node, type *tp);
 428
 429 /** Only to access SymConst of kind addr_name.  Else assertion: */
 430 ident   *get_SymConst_name (ir_node *node);
 431 void     set_SymConst_name (ir_node *node, ident *name);
 432
 433 /** Only to access SymConst of kind addr_ent.  Else assertion: */
 434 entity  *get_SymConst_entity (ir_node *node);
 435 void     set_SymConst_entity (ir_node *node, entity *ent);
 436
 437 /** Sets both: type and ptrinfo.  Needed to treat the node independent of
 438    its semantics.  Does a memcpy for the memory sym points to. */
 439 /* write 'union': firmjni then does not create a method... */
 440 union symconst_symbol get_SymConst_symbol (ir_node *node);
 441 void                  set_SymConst_symbol (ir_node *node,
 442                                            union symconst_symbol sym);
 443
 444 /** Access the type of the value represented by the SymConst.
 445  *
 446  *  Example: primitive type int for SymConst size. */
 447 type *get_SymConst_value_type (ir_node *node);
 448 void  set_SymConst_value_type (ir_node *node, type *tp);
 449
 450 ir_node *get_Sel_mem (ir_node *node);
 451 void     set_Sel_mem (ir_node *node, ir_node *mem);
 452 ir_node *get_Sel_ptr (ir_node *node);  /* ptr to the object to select from */
 453 void     set_Sel_ptr (ir_node *node, ir_node *ptr);
 454 ir_node **get_Sel_index_arr (ir_node *node);
 455 int      get_Sel_n_indexs (ir_node *node);
 456 ir_node *get_Sel_index (ir_node *node, int pos);
 457 void     set_Sel_index (ir_node *node, int pos, ir_node *index);
 458 entity  *get_Sel_entity (ir_node *node); /* entity to select */
 459 void     set_Sel_entity (ir_node *node, entity *ent);
 460
 461 /**
 462  * Projection numbers for result of Call node: use for Proj nodes!
 463  */
 464 typedef enum {
 465   pn_Call_M_regular = 0,  /**< The memory result. */
 466   pn_Call_T_result  = 2,  /**< The tuple containing all (0, 1, 2, ...) results */
 467   pn_Call_P_value_res_base = 4,/**< A pointer to the memory region containing copied results
 468                  passed by value (for compound result types). */
 469   pn_Call_X_except  = 1,  /**< The control flow result branching to the exception handler */
 470   pn_Call_M_except  = 3,  /**< The memory result in case the called method terminated with
 471                  an exception */
 472   pn_Call_max       = 5   /**< number of projections from a Call */
 473 } pn_Call;   /* Projection numbers for Call. */
 474
 475 ir_node *get_Call_mem (ir_node *node);
 476 void     set_Call_mem (ir_node *node, ir_node *mem);
 477 ir_node *get_Call_ptr (ir_node *node);
 478 void     set_Call_ptr (ir_node *node, ir_node *ptr);
 479 ir_node **get_Call_param_arr (ir_node *node);
 480 /** Gets the number of parameters of a call. */
 481 int      get_Call_n_params (ir_node *node);
 482 /** Gets the call parameter at position pos. */
 483 ir_node *get_Call_param (ir_node *node, int pos);
 484 /** Sets the call parameter at position pos. */
 485 void     set_Call_param (ir_node *node, int pos, ir_node *param);
 486 /** Gets the type of a call. */
 487 type    *get_Call_type (ir_node *node);
 488 /** Sets the type of a call. */
 489 void     set_Call_type (ir_node *node, type *tp);
 490 /** Gets the arity of a call. Identical to get_Call_n_params(). */
 491 int      get_Call_arity (ir_node *node);
 492
 493 /** Set, get and remove the callee information for a Call node.
 494  *
 495  *  The callee information lists all method entities that can be called
 496  *  from this node.  If the address expression can not be analyzed fully,
 497  *  e.g., as entities can be called that are not in the compilation unit,
 498  *  the array contains the unknown_entity.  The array contains only entities
 499  *  with peculiarity_existent, but with all kinds of visibility.  The entities
 500  *  not necessarily contain an irg.
 501  *
 502  *  The array is only accessible if callee information is valid.  See flag
 503  *  in graph.
 504  *
 505  *  The memory allocated for the array is managed automatically, i.e., it must
 506  *  not be freed if the Call node is removed from the graph.
 507  *
 508  *  @param node A Call node.
 509  */
 510 int     Call_has_callees      (ir_node *node);
 511 int     get_Call_n_callees    (ir_node *node);
 512 entity *get_Call_callee       (ir_node *node, int pos);
 513
 514 /** Set the full callee array.
 515  *
 516  *  The passed array is copied. Assumes current_ir_graph set properly! */
 517 void    set_Call_callee_arr   (ir_node *node, const int n, entity **arr);
 518 void    remove_Call_callee_arr(ir_node *node);
 519
 520 ir_node  *get_CallBegin_ptr  (ir_node *node);
 521 void      set_CallBegin_ptr  (ir_node *node, ir_node *ptr);
 522 ir_node  *get_CallBegin_call (ir_node *node);
 523 void      set_CallBegin_call (ir_node *node, ir_node *call);
 524
 525 /* For unary and binary arithmetic operations the access to the
 526    operands can be factored out.  Left is the first, right the
 527    second arithmetic value  as listed in tech report 1999-44.
 528    unops are: Minus, Abs, Not, Conv, Cast
 529    binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
 530    Shr, Shrs, Rot, Cmp */
 531 int      is_unop (const ir_node *node);
 532 ir_node *get_unop_op (ir_node *node);
 533 void     set_unop_op (ir_node *node, ir_node *op);
 534 int      is_binop (const ir_node *node);
 535 ir_node *get_binop_left (ir_node *node);
 536 void     set_binop_left (ir_node *node, ir_node *left);
 537 ir_node *get_binop_right (ir_node *node);
 538 void     set_binop_right (ir_node *node, ir_node *right);
 539
 540 ir_node *get_Add_left (ir_node *node);
 541 void     set_Add_left (ir_node *node, ir_node *left);
 542 ir_node *get_Add_right (ir_node *node);
 543 void     set_Add_right (ir_node *node, ir_node *right);
 544
 545 ir_node *get_Sub_left (ir_node *node);
 546 void     set_Sub_left (ir_node *node, ir_node *left);
 547 ir_node *get_Sub_right (ir_node *node);
 548 void     set_Sub_right (ir_node *node, ir_node *right);
 549
 550 ir_node *get_Minus_op (ir_node *node);
 551 void     set_Minus_op (ir_node *node, ir_node *op);
 552
 553 ir_node *get_Mul_left (ir_node *node);
 554 void     set_Mul_left (ir_node *node, ir_node *left);
 555 ir_node *get_Mul_right (ir_node *node);
 556 void     set_Mul_right (ir_node *node, ir_node *right);
 557
 558 ir_node *get_Quot_left (ir_node *node);
 559 void     set_Quot_left (ir_node *node, ir_node *left);
 560 ir_node *get_Quot_right (ir_node *node);
 561 void     set_Quot_right (ir_node *node, ir_node *right);
 562 ir_node *get_Quot_mem (ir_node *node);
 563 void     set_Quot_mem (ir_node *node, ir_node *mem);
 564
 565 /**
 566  * Projection numbers for Quot: use for Proj nodes!
 567  */
 568 typedef enum {
 569   pn_Quot_M,           /**< Memory result.    */
 570   pn_Quot_X_except,    /**< Execution result if exception occured. */
 571   pn_Quot_res,         /**< Result of computation. */
 572   pn_Quot_max          /**< number of projections from a Quot */
 573 } pn_Quot;  /* Projection numbers for Quot. */
 574
 575 ir_node *get_DivMod_left (ir_node *node);
 576 void     set_DivMod_left (ir_node *node, ir_node *left);
 577 ir_node *get_DivMod_right (ir_node *node);
 578 void     set_DivMod_right (ir_node *node, ir_node *right);
 579 ir_node *get_DivMod_mem (ir_node *node);
 580 void     set_DivMod_mem (ir_node *node, ir_node *mem);
 581
 582 /**
 583  * Projection numbers for DivMod: use for Proj nodes!
 584  */
 585 typedef enum {
 586   pn_DivMod_M,           /**< Memory result.    */
 587   pn_DivMod_X_except,    /**< Execution result if exception occured. */
 588   pn_DivMod_res_div,     /**< Result of computation a / b. */
 589   pn_DivMod_res_mod,     /**< Result of computation a % b. */
 590   pn_DivMod_max          /**< number of projections from a DivMod */
 591 } pn_DivMod;  /* Projection numbers for DivMod. */
 592
 593 ir_node *get_Div_left (ir_node *node);
 594 void     set_Div_left (ir_node *node, ir_node *left);
 595 ir_node *get_Div_right (ir_node *node);
 596 void     set_Div_right (ir_node *node, ir_node *right);
 597 ir_node *get_Div_mem (ir_node *node);
 598 void     set_Div_mem (ir_node *node, ir_node *mem);
 599
 600 /**
 601  * Projection numbers for Div: use for Proj nodes!
 602  */
 603 typedef enum {
 604   pn_Div_M,           /**< Memory result.    */
 605   pn_Div_X_except,    /**< Execution result if exception occured. */
 606   pn_Div_res          /**< Result of computation. */
 607 } pn_Div;  /* Projection numbers for Div. */
 608
 609 ir_node *get_Mod_left (ir_node *node);
 610 void     set_Mod_left (ir_node *node, ir_node *left);
 611 ir_node *get_Mod_right (ir_node *node);
 612 void     set_Mod_right (ir_node *node, ir_node *right);
 613 ir_node *get_Mod_mem (ir_node *node);
 614 void     set_Mod_mem (ir_node *node, ir_node *mem);
 615
 616 /**
 617  * Projection numbers for Mod: use for Proj nodes!
 618  */
 619 typedef enum {
 620   pn_Mod_M,           /**< Memory result.    */
 621   pn_Mod_X_except,    /**< Execution result if exception occured. */
 622   pn_Mod_res,         /**< Result of computation. */
 623   pn_Mod_max          /**< number of projections from a Mod */
 624 } pn_Mod;  /* Projection numbers for Mod. */
 625
 626 ir_node *get_Abs_op (ir_node *node);
 627 void     set_Abs_op (ir_node *node, ir_node *op);
 628
 629 ir_node *get_And_left (ir_node *node);
 630 void     set_And_left (ir_node *node, ir_node *left);
 631 ir_node *get_And_right (ir_node *node);
 632 void     set_And_right (ir_node *node, ir_node *right);
 633
 634 ir_node *get_Or_left (ir_node *node);
 635 void     set_Or_left (ir_node *node, ir_node *left);
 636 ir_node *get_Or_right (ir_node *node);
 637 void     set_Or_right (ir_node *node, ir_node *right);
 638
 639 ir_node *get_Eor_left (ir_node *node);
 640 void     set_Eor_left (ir_node *node, ir_node *left);
 641 ir_node *get_Eor_right (ir_node *node);
 642 void     set_Eor_right (ir_node *node, ir_node *right);
 643
 644 ir_node *get_Not_op (ir_node *node);
 645 void     set_Not_op (ir_node *node, ir_node *op);
 646
 647 /**
 648  * Projection numbers for Cmp are defined several times.
 649  * The bit patterns are used for various tests, so don't change.
 650  * The "unordered" values are possible results of comparing
 651  * floating point numbers.
 652  * Note that the encoding is imported, so do NOT change the order.
 653  */
 654 typedef enum {
 655   pn_Cmp_False = 0,                             /**< false */
 656   pn_Cmp_Eq    = 1,                             /**< equal */
 657   pn_Cmp_Lt    = 2,                             /**< less */
 658   pn_Cmp_Le    = pn_Cmp_Eq|pn_Cmp_Lt,           /**< less or equal */
 659   pn_Cmp_Gt    = 4,                             /**< greater */
 660   pn_Cmp_Ge    = pn_Cmp_Eq|pn_Cmp_Gt,           /**< greater or equal */
 661   pn_Cmp_Lg    = pn_Cmp_Lt|pn_Cmp_Gt,           /**< less or greater */
 662   pn_Cmp_Leg   = pn_Cmp_Lt|pn_Cmp_Eq|pn_Cmp_Gt, /**< less, equal or greater = ordered */
 663   pn_Cmp_Uo    = 8,                             /**< unordered */
 664   pn_Cmp_Ue    = pn_Cmp_Uo|pn_Cmp_Eq,           /**< unordered or equal */
 665   pn_Cmp_Ul    = pn_Cmp_Uo|pn_Cmp_Lt,           /**< unordered or less */
 666   pn_Cmp_Ule   = pn_Cmp_Uo|pn_Cmp_Eq|pn_Cmp_Lt, /**< unordered, less or equal */
 667   pn_Cmp_Ug    = pn_Cmp_Uo|pn_Cmp_Gt,           /**< unordered or greater */
 668   pn_Cmp_Uge   = pn_Cmp_Uo|pn_Cmp_Eq|pn_Cmp_Gt, /**< unordered, greater or equal */
 669   pn_Cmp_Ne    = pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Gt, /**< unordered, less or greater = not equal */
 670   pn_Cmp_True  = 15                             /**< true */
 671   /* not_mask = Leg*/   /* bits to flip to negate comparison * @@ hack for jni interface */
 672 } pn_Cmp;   /* Projection numbers for Cmp */
 673 /* #define not_mask pn_Cmp_Leg */
 674
 675 const char *get_pnc_string(int pnc);
 676 int         get_negated_pnc(int pnc);
 677 ir_node *get_Cmp_left (ir_node *node);
 678 void     set_Cmp_left (ir_node *node, ir_node *left);
 679 ir_node *get_Cmp_right (ir_node *node);
 680 void     set_Cmp_right (ir_node *node, ir_node *right);
 681
 682 ir_node *get_Shl_left (ir_node *node);
 683 void     set_Shl_left (ir_node *node, ir_node *left);
 684 ir_node *get_Shl_right (ir_node *node);
 685 void     set_Shl_right (ir_node *node, ir_node *right);
 686
 687 ir_node *get_Shr_left (ir_node *node);
 688 void     set_Shr_left (ir_node *node, ir_node *left);
 689 ir_node *get_Shr_right (ir_node *node);
 690 void     set_Shr_right (ir_node *node, ir_node *right);
 691
 692 ir_node *get_Shrs_left (ir_node *node);
 693 void     set_Shrs_left (ir_node *node, ir_node *left);
 694 ir_node *get_Shrs_right (ir_node *node);
 695 void     set_Shrs_right (ir_node *node, ir_node *right);
 696
 697 ir_node *get_Rot_left (ir_node *node);
 698 void     set_Rot_left (ir_node *node, ir_node *left);
 699 ir_node *get_Rot_right (ir_node *node);
 700 void     set_Rot_right (ir_node *node, ir_node *right);
 701
 702 ir_node *get_Conv_op (ir_node *node);
 703 void     set_Conv_op (ir_node *node, ir_node *op);
 704
 705 /* Does Cast need a mem operator?
 706  * Cast should only depend on the type, not on the state of an
 707  * entity.  But:  we initialze various fields after Alloc, that
 708  * are accessed in the cast.  This required some precaution, to
 709  * get the right memory into the Loads generated from the cast.
 710  */
 711 ir_node *get_Cast_op (ir_node *node);
 712 void     set_Cast_op (ir_node *node, ir_node *op);
 713 type    *get_Cast_type (ir_node *node);
 714 void     set_Cast_type (ir_node *node, type *to_tp);
 715
 716 /** Returns true if n is Phi or Filter in interprocedural_view.
 717    Returns false if irg in phase building and the Phi has zero
 718    predecessors: it's a Phi0. */
 719 int       is_Phi (const ir_node *n);
 720 /** Returns true  if irg in phase building and the Phi has zero
 721    predecessors: it's a Phi0. */
 722 int       is_Phi0 (const ir_node *n);
 723 /* These routines also work for Filter nodes in interprocedural view. */
 724 ir_node **get_Phi_preds_arr (ir_node *node);
 725 int       get_Phi_n_preds (ir_node *node);
 726 ir_node  *get_Phi_pred (ir_node *node, int pos);
 727 void      set_Phi_pred (ir_node *node, int pos, ir_node *pred);
 728
 729 ir_node  *get_Filter_pred(ir_node *node);
 730 void      set_Filter_pred(ir_node *node, ir_node *pred);
 731 long      get_Filter_proj(ir_node *node);
 732 void      set_Filter_proj(ir_node *node, long proj);
 733 /* set the interprocedural predecessors, ...d_arr uses current_ir_graph.
 734  * @@@ Maybe better:  arity is zero if no cg preds. */
 735 void     set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in);
 736 void     set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred);
 737 int      get_Filter_n_cg_preds(ir_node *node);
 738 ir_node *get_Filter_cg_pred(ir_node *node, int pos);
 739
 740 /** Return true if parameter is a memory operation.
 741  *
 742  *  A memory operation is an operation that changes the
 743  *  memory.  I.e., a Load or a Store operation.
 744  */
 745 int is_memop(ir_node *node);
 746 ir_node *get_memop_mem (ir_node *node);
 747 void     set_memop_mem (ir_node *node, ir_node *mem);
 748 ir_node *get_memop_ptr (ir_node *node);
 749 void     set_memop_ptr (ir_node *node, ir_node *ptr);
 750
 751 /**
 752  * Projection numbers for Load: use for Proj nodes!
 753  */
 754 typedef enum {
 755   pn_Load_M,         /**< Memory result.    */
 756   pn_Load_X_except,  /**< Execution result if exception occured. */
 757   pn_Load_res,       /**< Result of load operation. */
 758   pn_Load_max        /**< number of projections from a Load */
 759 } pn_Load;  /* Projection numbers for Load. */
 760
 761 ir_node       *get_Load_mem (ir_node *node);
 762 void           set_Load_mem (ir_node *node, ir_node *mem);
 763 ir_node       *get_Load_ptr (ir_node *node);
 764 void           set_Load_ptr (ir_node *node, ir_node *ptr);
 765 ir_mode       *get_Load_mode (ir_node *node);
 766 void           set_Load_mode (ir_node *node, ir_mode *mode);
 767 ent_volatility get_Load_volatility (ir_node *node);
 768 void           set_Load_volatility (ir_node *node, ent_volatility volatility);
 769
 770 /**
 771  * Projection numbers for Store: use for Proj nodes!
 772  */
 773 typedef enum {
 774   pn_Store_M,         /**< Memory result.    */
 775   pn_Store_X_except,  /**< Execution result if exception occured. */
 776   pn_Store_max        /**< number of projections from a Store */
 777 } pn_Store;  /* Projection numbers for Store. */
 778
 779 ir_node       *get_Store_mem (ir_node *node);
 780 void           set_Store_mem (ir_node *node, ir_node *mem);
 781 ir_node       *get_Store_ptr (ir_node *node);
 782 void           set_Store_ptr (ir_node *node, ir_node *ptr);
 783 ir_node       *get_Store_value (ir_node *node);
 784 void           set_Store_value (ir_node *node, ir_node *value);
 785 ent_volatility get_Store_volatility (ir_node *node);
 786 void           set_Store_volatility (ir_node *node, ent_volatility volatility);
 787
 788 /**
 789  * Projection numbers for Alloc: use for Proj nodes!
 790  */
 791 typedef enum {
 792   pn_Alloc_M,          /**< Memory result. */
 793   pn_Alloc_X_except,  /**< Execution result if exception occured. */
 794   pn_Alloc_res,       /**< Result of allocation. */
 795   pn_Alloc_max        /**< number of projections from an Alloc */
 796 } pn_Alloc;  /* Projection numbers for Alloc. */
 797
 798 ir_node *get_Alloc_mem (ir_node *node);
 799 void     set_Alloc_mem (ir_node *node, ir_node *mem);
 800 ir_node *get_Alloc_size (ir_node *node);
 801 void     set_Alloc_size (ir_node *node, ir_node *size);
 802 type    *get_Alloc_type (ir_node *node);
 803 void     set_Alloc_type (ir_node *node, type *tp);
 804
 805 /** The allocation place. */
 806 typedef enum {
 807   stack_alloc,          /**< Alloc allocates the object on the stack. */
 808   heap_alloc            /**< Alloc allocates the object on the heap. */
 809 } where_alloc;
 810
 811 where_alloc  get_Alloc_where (ir_node *node);
 812 void         set_Alloc_where (ir_node *node, where_alloc where);
 813
 814 ir_node *get_Free_mem (ir_node *node);
 815 void     set_Free_mem (ir_node *node, ir_node *mem);
 816 ir_node *get_Free_ptr (ir_node *node);
 817 void     set_Free_ptr (ir_node *node, ir_node *ptr);
 818 ir_node *get_Free_size (ir_node *node);
 819 void     set_Free_size (ir_node *node, ir_node *size);
 820 type    *get_Free_type (ir_node *node);
 821 void     set_Free_type (ir_node *node, type *tp);
 822
 823 ir_node **get_Sync_preds_arr (ir_node *node);
 824 int       get_Sync_n_preds (ir_node *node);
 825 ir_node  *get_Sync_pred (ir_node *node, int pos);
 826 void      set_Sync_pred (ir_node *node, int pos, ir_node *pred);
 827
 828 ir_node  *get_Proj_pred (ir_node *node);
 829 void      set_Proj_pred (ir_node *node, ir_node *pred);
 830 long      get_Proj_proj (ir_node *node);
 831 void      set_Proj_proj (ir_node *node, long proj);
 832
 833 ir_node **get_Tuple_preds_arr (ir_node *node);
 834 int       get_Tuple_n_preds (ir_node *node);
 835 ir_node  *get_Tuple_pred (ir_node *node, int pos);
 836 void      set_Tuple_pred (ir_node *node, int pos, ir_node *pred);
 837
 838 ir_node  *get_Id_pred (ir_node *node);
 839 void      set_Id_pred (ir_node *node, ir_node *pred);
 840
 841 /** Confirm has a single result and returns 'value' unchanged.
 842  *  The node expresses a restriction on 'value':
 843  *  'value' 'cmp' 'bound' == true.                                 */
 844 ir_node *get_Confirm_value (ir_node *node);
 845 void     set_Confirm_value (ir_node *node, ir_node *value);
 846 ir_node *get_Confirm_bound (ir_node *node);
 847 void     set_Confirm_bound (ir_node *node, ir_node *bound);
 848 pn_Cmp   get_Confirm_cmp   (ir_node *node);
 849 void     set_Confirm_cmp   (ir_node *node, pn_Cmp cmp);
 850
 851 /*
 852  *
 853  * NAME Auxiliary routines
 854  *
 855  *  Not properly documented ;-)
 856  *
 857  */
 858
 859 /** returns operand of node if node is a Proj. */
 860 ir_node *skip_Proj (ir_node *node);
 861 /** returns operand of node if node is a Id */
 862 ir_node *skip_Id  (ir_node *node);   /* Same as skip_nop. */
 863 /* returns corresponding operand of Tuple if node is a Proj from
 864    a Tuple. */
 865 ir_node *skip_Tuple (ir_node *node);
 866 /** returns operand of node if node is a Cast */
 867 ir_node *skip_Cast  (ir_node *node);
 868 /** returns true if node is a Bad node. */
 869 int      is_Bad    (const ir_node *node);
 870 /** returns true if the node is not a Block */
 871 int      is_no_Block (const ir_node *node);
 872 /** returns true if the node is a Block */
 873 int      is_Block (const ir_node *node);
 874 /** returns true if node is a Unknown node. */
 875 int      is_Unknown (const ir_node *node);
 876 /** returns true if node is a Proj node or a Filter node in
 877  * intraprocedural view */
 878 int      is_Proj (const ir_node *node);
 879 /** Returns true if the operation manipulates control flow:
 880    Start, End, Jmp, Cond, Return, Raise, Bad, CallBegin, EndReg, EndExcept */
 881 int is_cfop(const ir_node *node);
 882
 883 /** Returns true if the operation manipulates interprocedural control flow:
 884     CallBegin, EndReg, EndExcept */
 885 int is_ip_cfop(const ir_node *node);
 886 /** Returns true if the operation can change the control flow because
 887     of an exception: Call, Quot, DivMod, Div, Mod, Load, Store, Alloc,
 888     Bad. */
 889 int is_fragile_op(const ir_node *node);
 890 /** Returns the memory operand of fragile operations. */
 891 ir_node *get_fragile_op_mem(ir_node *node);
 892
 893 /** Returns true if the operation is a forking control flow
 894  *  operation: Cond. */
 895 int is_forking_op(const ir_node *node);
 896
 897 /**
 898  * Access custom node data.
 899  * The data must have been registered with
 900  * register_additional_node_data() before.
 901  * @param node The ir node to get the data from.
 902  * @param type The type of the data you registered.
 903  * @param off The value returned by register_additional_node_data().
 904  * @return A pointer of type @p type.
 905  */
 906 #define get_irn_data(node,type,off) \
 907   (assert(off > 0 && "Invalid node data offset"), (type *) ((char *) (node) - (off)))
 908
 909 /**
 910  * Get the pointer to the node some custom data belongs to.
 911  * @param data The pointer to the custom data.
 912  * @param off The number as returned by register_additional_node_data().
 913  * @return A pointer to the ir node the custom data belongs to.
 914  */
 915 #define get_irn_data_base(data,off) \
 916   (assert(off > 0 && "Invalid node data offset"), (ir_node *) ((char *) (data) + (off)))
 917
 918 /**
 919  * Request additional data to be allocated with an ir node.
 920  * @param size The size of the additional data required.
 921  * @return A positive number, if the opration was successful, which
 922  * must be passed to the access macro get_irn_data(), 0 if the
 923  * registration failed.
 924  */
 925 unsigned register_additional_node_data(unsigned size);
 926
 927
 928 /*-----------------------------------------------------------------*/
 929 /** Debug aides                                                   **/
 930 /*-----------------------------------------------------------------*/
 931
 932
 933 /** Debug print the node.
 934  *
 935  *  Writes the node, all its attributes and the predecessors to stdout if DEBUG_libfirm
 936  *  is set.  Else does nothing. */
 937 void    dump_irn(ir_node *n);
 938
 939 #include "ident.h"
 940
 941 #ifdef __GNUC__
 942 /* GNU C has the __FUNCTION__ extension */
 943 #define __MYFUNC__ __FUNCTION__
 944 #else
 945 /* use Filename instead */
 946 #define __MYFUNC__ __FILE__
 947 #endif
 948
 949 /* !!!!!!!!! @@@
 950    Don't format with "\", firmjni gets problems */
 951 /** Output location */
 952 #define DDM      printf("%s(l.%i).\n",                       __MYFUNC__, __LINE__);
 953 /** Output the firm kind of the node */
 954 #define DDMK(X)  printf("%s(l.%i) %s: %p\n",                 __MYFUNC__, __LINE__,  print_firm_kind(X), (void *)(X));
 955 /** Output information about a node */
 956 #define DDMN(X)  printf("%s(l.%i) %s%s: %ld (%p)\n",         __MYFUNC__, __LINE__,  get_irn_opname(X), get_mode_name(get_irn_mode(X)), get_irn_node_nr(X), (void *)(X))
 957 /** Output information about a node and its block */
 958 #define DDMNB(X) printf("%s%s: %ld (in block %ld)\n", get_irn_opname(X),  get_mode_name(get_irn_mode(X)), get_irn_node_nr(X), get_irn_node_nr(get_nodes_block(X)))
 959 /** Output information about a type */
 960 #define DDMT(X)  printf("%s(l.%i) %s %s: %ld (%p)\n",        __MYFUNC__, __LINE__, get_type_tpop_name(X), get_type_name(X), get_type_nr(X), (void *)(X))
 961 /** Output information about an entity */
 962 #define DDME(X)  printf("%s(l.%i) %s: %ld (%p)\n",           __MYFUNC__, __LINE__, get_entity_name(X), get_entity_nr(X), (void *)(X))
 963 /** Output information about an entity and its type */
 964 #define DDMET(X) printf("%s(l.%i) %s (typ: %s): %ld (%p)\n", __MYFUNC__, __LINE__, get_entity_name(X), get_type_name(get_entity_type(X)), get_entity_nr(X), (void *)(X))
 965 /** Output information about an entity and its owner */
 966 #define DDMEO(X) printf("%s(l.%i) %s (own: %s): %ld (%p)\n", __MYFUNC__, __LINE__, get_entity_name(X), get_type_name(get_entity_owner(X)), get_entity_nr(X), (void *)(X))
 967 /** Output information about a graph */
 968 #define DDMG(X)  printf("%s(l.%i) graph %s: %ld (%p) in %s %s.\n", __MYFUNC__, __LINE__, get_entity_name(get_irg_entity(X)), get_irg_graph_nr(X), (void *)(X), get_type_tpop_name(get_entity_owner(get_irg_entity(X))), get_type_name(get_entity_owner(get_irg_entity(X))))
 969 /** Output information about an ident */
 970 #define DDMI(X)  printf("%s(l.%i) %s: %p\n",                 __MYFUNC__, __LINE__, get_id_str(X), (void *)(X))
 971 /** Output information about a mode */
 972 #define DDMM(X)  printf("%s(l.%i) %s: %p\n",                 __MYFUNC__, __LINE__, get_mode_name(X), (void *)(X))
 973 /** Output information about a loop */
 974 #define DDML(X)  printf("%s(l.%i) loop with depth %d: %d\n", __MYFUNC__, __LINE__, get_loop_depth(X), get_loop_loop_nr(X))
 975 /** Output information about a tarVal */
 976 #define DDMV(X)  printf("%s(l.%i) tarval: ",__MYFUNC__, __LINE__); tarval_printf(X); printf(" (%p)\n", (void *)(X));
 977
 978 /*@}*/ /* end of ir_node group definition */
 979
 980
 981 #ifdef __cplusplus
 982 }
 983 #endif
 984
 985 # endif /* _IRNODE_H_ */