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

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irgraph.c
   4  * Purpose:     Entry point to the representation of procedure code -- internal header.
   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 /**
  14  * @file irgraph_t.h
  15  *
  16  * ir graph construction.
  17  *
  18  * @author Martin Trapp, Christian Schaefer
  19  */
  20
  21
  22 # ifndef _IRGRAPH_T_H_
  23 # define _IRGRAPH_T_H_
  24 # include "obst.h"
  25 # include "pset.h"
  26 # include "irgraph.h"
  27 # include "firm_common_t.h"
  28 # include "irtypeinfo.h"
  29
  30 #define FRAME_TP_SUFFIX "frame_tp"
  31
  32 /** ir_graph holds all information for a procedure */
  33 struct ir_graph {
  34   firm_kind         kind;            /**<  always set to k_ir_graph*/
  35   /* --  Basics of the representation -- */
  36   struct entity  *ent;               /**< The entity of this procedure, i.e.,
  37                     the type of the procedure and the
  38                     class it belongs to. */
  39   struct type    *frame_type;        /**< A class type representing the stack frame.
  40                     Can include "inner" methods. */
  41   struct ir_node *start_block;       /**< block the start node will belong to */
  42   struct ir_node *start;         /**< start node of this ir_graph */
  43   struct ir_node *end_block;         /**< block the end node will belong to */
  44   struct ir_node *end;           /**< end node of this ir_graph */
  45   struct ir_node *end_reg;       /**< end node of this ir_graph */
  46   struct ir_node *end_except;    /**< end node of this ir_graph */
  47   struct ir_node *cstore;        /**< constant store -- no more needed!! */
  48   struct ir_node *frame;             /**< method's frame */
  49   struct ir_node *globals;           /**< pointer to the data segment containing all
  50                         globals as well as global procedures. */
  51   struct ir_node *args;              /**< methods arguments */
  52   struct ir_node *bad;           /**< bad node of this ir_graph, the one and
  53                                         only in this graph */
  54   /* GL removed: we need unknown with mode for analyses. */
  55   /*   struct ir_node *unknown;*/           /**< unknown node of this ir_graph */
  56   struct obstack *obst;          /**< obstack where all of the ir_nodes live */
  57   struct ir_node *current_block;     /**< block for newly gen_*()-erated
  58                     ir_nodes */
  59
  60   /* -- Fields indicating different states of irgraph -- */
  61   irg_phase_state phase_state;       /**< compiler phase */
  62   op_pinned pinned;                  /**< Flag for status of nodes */
  63   irg_outs_state outs_state;         /**< Out edges. */
  64   irg_dom_state dom_state;           /**< Dominator information */
  65   irg_typeinfo_state typeinfo_state; /**< Validity of type information */
  66   irg_callee_info_state callee_info_state; /**< Validity of callee information */
  67   irg_inline_property inline_property;     /**< How to handle inlineing. */
  68   irg_loopinfo_state loopinfo_state; /**< state of loop information */
  69
  70   /* -- Fields for construction -- */
  71 #if USE_EXPLICIT_PHI_IN_STACK
  72   struct Phi_in_stack *Phi_in_stack; /**< needed for automatic Phi construction */
  73 #endif
  74   int n_loc;                         /**< number of local variable in this
  75                     procedure including procedure parameters. */
  76
  77   /* -- Fields for optimizations / analysis information -- */
  78   pset *value_table;                 /**< hash table for global value numbering (cse)
  79                     for optimizing use in iropt.c */
  80   struct ir_node **outs;             /**< Space for the out arrays. */
  81   int             n_outs;       /* < Size wasted for outs */
  82   struct ir_loop *loop;              /**< The outermost loop */
  83   void *link;                        /**< A void* field to link any information to
  84                     the node. */
  85
  86   /* -- Fields for Walking the graph -- */
  87   unsigned long visited;             /**< this flag is an identifier for
  88                     ir walk. it will be incremented
  89                     every time someone walks through
  90                     the graph */
  91   unsigned long block_visited;       /**< same as visited, for a complete block */
  92 #ifdef DEBUG_libfirm
  93   int graph_nr;             /**< a unique graph number for each graph to make output
  94                   readable. */
  95 #endif
  96 };
  97
  98 void init_irgraph(void);
  99
 100 /** Make a rudimentary ir graph for the constant code.
 101    Must look like a correct irg, spare everything else. */
 102 ir_graph *new_const_code_irg(void);
 103
 104 /**
 105  * Set the pinned state of a graph.
 106  *
 107  * @irg     the IR graph
 108  * @p       new pin state
 109  */
 110 INLINE void
 111 set_irg_pinned (ir_graph *irg, op_pinned p);
 112
 113 /** Returns the obstack associated with the graph. */
 114 struct obstack *get_irg_obstack(ir_graph *irg);
 115
 116 /**
 117  * Returns true if the node n is allocated on the storage of graph irg.
 118  *
 119  * @param irg   the IR graph
 120  * @param n the IR node
 121  */
 122 int node_is_in_irgs_storage(ir_graph *irg, ir_node *n);
 123
 124 /*-------------------------------------------------------------------*/
 125 /* inline functions for graphs                                       */
 126 /*-------------------------------------------------------------------*/
 127
 128 /** Returns the start block of a graph. */
 129 static INLINE ir_node *
 130 __get_irg_start_block(ir_graph *irg)
 131 {
 132   return irg->start_block;
 133 }
 134
 135 static INLINE void
 136 __set_irg_start_block(ir_graph *irg, ir_node *node)
 137 {
 138   irg->start_block = node;
 139 }
 140
 141 static INLINE ir_node *
 142 __get_irg_start(ir_graph *irg)
 143 {
 144   return irg->start;
 145 }
 146
 147 static INLINE void
 148 __set_irg_start(ir_graph *irg, ir_node *node)
 149 {
 150   irg->start = node;
 151 }
 152
 153 static INLINE ir_node *
 154 __get_irg_end_block(ir_graph *irg)
 155 {
 156   return irg->end_block;
 157 }
 158
 159 static INLINE void
 160 __set_irg_end_block(ir_graph *irg, ir_node *node)
 161 {
 162   irg->end_block = node;
 163 }
 164
 165 static INLINE ir_node *
 166 __get_irg_end(ir_graph *irg)
 167 {
 168   return irg->end;
 169 }
 170
 171 static INLINE void
 172 __set_irg_end(ir_graph *irg, ir_node *node)
 173 {
 174   irg->end = node;
 175 }
 176
 177 static INLINE ir_node *
 178 __get_irg_end_reg(ir_graph *irg) {
 179   return irg->end_reg;
 180 }
 181
 182 static INLINE ir_node *
 183 __get_irg_end_except (ir_graph *irg) {
 184   return irg->end_except;
 185 }
 186
 187 static INLINE ir_node *
 188 __get_irg_cstore(ir_graph *irg)
 189 {
 190   return irg->cstore;
 191 }
 192
 193 static INLINE void
 194 __set_irg_cstore(ir_graph *irg, ir_node *node)
 195 {
 196   irg->cstore = node;
 197 }
 198
 199 static INLINE ir_node *
 200 __get_irg_frame(ir_graph *irg)
 201 {
 202   return irg->frame;
 203 }
 204
 205 static INLINE void
 206 __set_irg_frame(ir_graph *irg, ir_node *node)
 207 {
 208   irg->frame = node;
 209 }
 210
 211 static INLINE ir_node *
 212 __get_irg_globals(ir_graph *irg)
 213 {
 214   return irg->globals;
 215 }
 216
 217 static INLINE void
 218 __set_irg_globals(ir_graph *irg, ir_node *node)
 219 {
 220   irg->globals = node;
 221 }
 222
 223 static INLINE ir_node *
 224 __get_irg_args(ir_graph *irg)
 225 {
 226   return irg->args;
 227 }
 228
 229 static INLINE void
 230 __set_irg_args(ir_graph *irg, ir_node *node)
 231 {
 232   irg->args = node;
 233 }
 234
 235 static INLINE ir_node *
 236 __get_irg_bad(ir_graph *irg)
 237 {
 238   return irg->bad;
 239 }
 240
 241 static INLINE void
 242 __set_irg_bad(ir_graph *irg, ir_node *node)
 243 {
 244   irg->bad = node;
 245 }
 246
 247 static INLINE ir_node *
 248 __get_irg_current_block(ir_graph *irg)
 249 {
 250   return irg->current_block;
 251 }
 252
 253 static INLINE void
 254 __set_irg_current_block(ir_graph *irg, ir_node *node)
 255 {
 256   irg->current_block = node;
 257 }
 258
 259 static INLINE entity *
 260 __get_irg_ent(ir_graph *irg)
 261 {
 262   assert(irg && irg->ent);
 263   return irg->ent;
 264 }
 265
 266 static INLINE void
 267 __set_irg_ent(ir_graph *irg, entity *ent)
 268 {
 269   irg->ent = ent;
 270 }
 271
 272 static INLINE type *
 273 __get_irg_frame_type(ir_graph *irg)
 274 {
 275   assert(irg && irg->frame_type);
 276   return irg->frame_type;
 277 }
 278
 279 static INLINE void
 280 __set_irg_frame_type(ir_graph *irg, type *ftp)
 281 {
 282   assert(is_class_type(ftp));
 283   irg->frame_type = ftp;
 284 }
 285
 286 static INLINE struct obstack *
 287 __get_irg_obstack(ir_graph *irg) {
 288   return irg->obst;
 289 }
 290
 291
 292 static INLINE void
 293 __set_irg_link(ir_graph *irg, void *thing) {
 294   irg->link = thing;
 295 }
 296
 297 static INLINE void *
 298 __get_irg_link(ir_graph *irg) {
 299   return irg->link;
 300 }
 301
 302 static INLINE unsigned long
 303 __get_irg_visited(ir_graph *irg)
 304 {
 305   return irg->visited;
 306 }
 307
 308 static INLINE unsigned long
 309 __get_irg_block_visited(ir_graph *irg)
 310 {
 311   return irg->block_visited;
 312 }
 313
 314 static INLINE void
 315 __set_irg_block_visited(ir_graph *irg, unsigned long visited)
 316 {
 317   irg->block_visited = visited;
 318 }
 319
 320 static INLINE void
 321 __inc_irg_block_visited(ir_graph *irg)
 322 {
 323   ++irg->block_visited;
 324 }
 325
 326 #define get_irg_start_block(irg)         __get_irg_start_block(irg)
 327 #define set_irg_start_block(irg, node)   __set_irg_start_block(irg, node)
 328 #define get_irg_start(irg)               __get_irg_start(irg)
 329 #define set_irg_start(irg, node)         __set_irg_start(irg, node)
 330 #define get_irg_end_block(irg)           __get_irg_end_block(irg)
 331 #define set_irg_end_block(irg, node)     __set_irg_end_block(irg, node)
 332 #define get_irg_end(irg)                 __get_irg_end(irg)
 333 #define set_irg_end(irg, node)           __set_irg_end(irg, node)
 334 #define get_irg_end_reg(irg)             __get_irg_end_reg(irg)
 335 #define get_irg_end_except(irg)          __get_irg_end_except(irg)
 336 #define get_irg_cstore(irg)              __get_irg_cstore(irg)
 337 #define set_irg_cstore(irg, node)        __set_irg_cstore(irg, node)
 338 #define get_irg_frame(irg)               __get_irg_frame(irg)
 339 #define set_irg_frame(irg, node)         __set_irg_frame(irg, node)
 340 #define get_irg_globals(irg)             __get_irg_globals(irg)
 341 #define set_irg_globals(irg, node)       __set_irg_globals(irg, node)
 342 #define get_irg_args(irg)                __get_irg_args(irg)
 343 #define set_irg_args(irg, node)          __set_irg_args(irg, node)
 344 #define get_irg_bad(irg)                 __get_irg_bad(irg)
 345 #define set_irg_bad(irg, node)           __set_irg_bad(irg, node)
 346 #define get_irg_current_block(irg)       __get_irg_current_block(irg)
 347 #define set_irg_current_block(irg, node) __set_irg_current_block(irg, node)
 348 #define get_irg_ent(irg)                 __get_irg_ent(irg)
 349 #define set_irg_ent(irg, ent)            __set_irg_ent(irg, ent)
 350 #define get_irg_frame_type(irg)          __get_irg_frame_type(irg)
 351 #define set_irg_frame_type(irg, ftp)     __set_irg_frame_type(irg, ftp)
 352 #define get_irg_obstack(irg)             __get_irg_obstack(irg)
 353 #define set_irg_link(irg, thing)         __set_irg_link(irg, thing)
 354 #define get_irg_link(irg)                __get_irg_link(irg)
 355 #define get_irg_visited(irg)             __get_irg_visited(irg)
 356 #define get_irg_block_visited(irg)       __get_irg_block_visited(irg)
 357 #define set_irg_block_visited(irg, v)    __set_irg_block_visited(irg, v)
 358 #define inc_irg_block_visited(irg)       __inc_irg_block_visited(irg)
 359
 360 # endif /* _IRGRAPH_T_H_ */