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
  82 #ifdef DEBUG_libfirm
  83   int             n_outs;       /* < Size wasted for outs */
  84 #endif /* defined DEBUG_libfirm */
  85   struct ir_loop *loop;              /**< The outermost loop */
  86   void *link;                        /**< A void* field to link any information to
  87                     the node. */
  88
  89   /* -- Fields for Walking the graph -- */
  90   unsigned long visited;             /**< this flag is an identifier for
  91                                         ir walk. it will be incremented
  92                                         every time someone walks through
  93                                         the graph */
  94   unsigned long block_visited;       /**< same as visited, for a complete block */
  95 #ifdef DEBUG_libfirm
  96   int graph_nr;             /**< a unique graph number for each graph to make output
  97                                readable. */
  98 #endif
  99 };
 100
 101 void init_irgraph(void);
 102
 103 /** Make a rudimentary ir graph for the constant code.
 104    Must look like a correct irg, spare everything else. */
 105 ir_graph *new_const_code_irg(void);
 106
 107 /**
 108  * Set the pinned state of a graph.
 109  *
 110  * @irg     the IR graph
 111  * @p       new pin state
 112  */
 113 INLINE void
 114 set_irg_pinned (ir_graph *irg, op_pinned p);
 115
 116 /** Returns the obstack associated with the graph. */
 117 struct obstack *get_irg_obstack(ir_graph *irg);
 118
 119 /**
 120  * Returns true if the node n is allocated on the storage of graph irg.
 121  *
 122  * @param irg   the IR graph
 123  * @param n the IR node
 124  */
 125 int node_is_in_irgs_storage(ir_graph *irg, ir_node *n);
 126
 127 /*-------------------------------------------------------------------*/
 128 /* inline functions for graphs                                       */
 129 /*-------------------------------------------------------------------*/
 130
 131 /** Returns the start block of a graph. */
 132 static INLINE ir_node *
 133 __get_irg_start_block(ir_graph *irg)
 134 {
 135   return irg->start_block;
 136 }
 137
 138 static INLINE void
 139 __set_irg_start_block(ir_graph *irg, ir_node *node)
 140 {
 141   irg->start_block = node;
 142 }
 143
 144 static INLINE ir_node *
 145 __get_irg_start(ir_graph *irg)
 146 {
 147   return irg->start;
 148 }
 149
 150 static INLINE void
 151 __set_irg_start(ir_graph *irg, ir_node *node)
 152 {
 153   irg->start = node;
 154 }
 155
 156 static INLINE ir_node *
 157 __get_irg_end_block(ir_graph *irg)
 158 {
 159   return irg->end_block;
 160 }
 161
 162 static INLINE void
 163 __set_irg_end_block(ir_graph *irg, ir_node *node)
 164 {
 165   irg->end_block = node;
 166 }
 167
 168 static INLINE ir_node *
 169 __get_irg_end(ir_graph *irg)
 170 {
 171   return irg->end;
 172 }
 173
 174 static INLINE void
 175 __set_irg_end(ir_graph *irg, ir_node *node)
 176 {
 177   irg->end = node;
 178 }
 179
 180 static INLINE ir_node *
 181 __get_irg_end_reg(ir_graph *irg) {
 182   return irg->end_reg;
 183 }
 184
 185 static INLINE ir_node *
 186 __get_irg_end_except (ir_graph *irg) {
 187   return irg->end_except;
 188 }
 189
 190 static INLINE ir_node *
 191 __get_irg_cstore(ir_graph *irg)
 192 {
 193   return irg->cstore;
 194 }
 195
 196 static INLINE void
 197 __set_irg_cstore(ir_graph *irg, ir_node *node)
 198 {
 199   irg->cstore = node;
 200 }
 201
 202 static INLINE ir_node *
 203 __get_irg_frame(ir_graph *irg)
 204 {
 205   return irg->frame;
 206 }
 207
 208 static INLINE void
 209 __set_irg_frame(ir_graph *irg, ir_node *node)
 210 {
 211   irg->frame = node;
 212 }
 213
 214 static INLINE ir_node *
 215 __get_irg_globals(ir_graph *irg)
 216 {
 217   return irg->globals;
 218 }
 219
 220 static INLINE void
 221 __set_irg_globals(ir_graph *irg, ir_node *node)
 222 {
 223   irg->globals = node;
 224 }
 225
 226 static INLINE ir_node *
 227 __get_irg_args(ir_graph *irg)
 228 {
 229   return irg->args;
 230 }
 231
 232 static INLINE void
 233 __set_irg_args(ir_graph *irg, ir_node *node)
 234 {
 235   irg->args = node;
 236 }
 237
 238 static INLINE ir_node *
 239 __get_irg_bad(ir_graph *irg)
 240 {
 241   return irg->bad;
 242 }
 243
 244 static INLINE void
 245 __set_irg_bad(ir_graph *irg, ir_node *node)
 246 {
 247   irg->bad = node;
 248 }
 249
 250 static INLINE ir_node *
 251 __get_irg_current_block(ir_graph *irg)
 252 {
 253   return irg->current_block;
 254 }
 255
 256 static INLINE void
 257 __set_irg_current_block(ir_graph *irg, ir_node *node)
 258 {
 259   irg->current_block = node;
 260 }
 261
 262 static INLINE entity *
 263 __get_irg_ent(ir_graph *irg)
 264 {
 265   assert(irg && irg->ent);
 266   return irg->ent;
 267 }
 268
 269 static INLINE void
 270 __set_irg_ent(ir_graph *irg, entity *ent)
 271 {
 272   irg->ent = ent;
 273 }
 274
 275 static INLINE type *
 276 __get_irg_frame_type(ir_graph *irg)
 277 {
 278   assert(irg && irg->frame_type);
 279   return irg->frame_type;
 280 }
 281
 282 static INLINE void
 283 __set_irg_frame_type(ir_graph *irg, type *ftp)
 284 {
 285   assert(is_class_type(ftp));
 286   irg->frame_type = ftp;
 287 }
 288
 289 static INLINE struct obstack *
 290 __get_irg_obstack(ir_graph *irg) {
 291   return irg->obst;
 292 }
 293
 294
 295 static INLINE void
 296 __set_irg_link(ir_graph *irg, void *thing) {
 297   irg->link = thing;
 298 }
 299
 300 static INLINE void *
 301 __get_irg_link(ir_graph *irg) {
 302   return irg->link;
 303 }
 304
 305 static INLINE unsigned long
 306 __get_irg_visited(ir_graph *irg)
 307 {
 308   return irg->visited;
 309 }
 310
 311 static INLINE unsigned long
 312 __get_irg_block_visited(ir_graph *irg)
 313 {
 314   return irg->block_visited;
 315 }
 316
 317 static INLINE void
 318 __set_irg_block_visited(ir_graph *irg, unsigned long visited)
 319 {
 320   irg->block_visited = visited;
 321 }
 322
 323 static INLINE void
 324 __inc_irg_block_visited(ir_graph *irg)
 325 {
 326   ++irg->block_visited;
 327 }
 328
 329 #define get_irg_start_block(irg)         __get_irg_start_block(irg)
 330 #define set_irg_start_block(irg, node)   __set_irg_start_block(irg, node)
 331 #define get_irg_start(irg)               __get_irg_start(irg)
 332 #define set_irg_start(irg, node)         __set_irg_start(irg, node)
 333 #define get_irg_end_block(irg)           __get_irg_end_block(irg)
 334 #define set_irg_end_block(irg, node)     __set_irg_end_block(irg, node)
 335 #define get_irg_end(irg)                 __get_irg_end(irg)
 336 #define set_irg_end(irg, node)           __set_irg_end(irg, node)
 337 #define get_irg_end_reg(irg)             __get_irg_end_reg(irg)
 338 #define get_irg_end_except(irg)          __get_irg_end_except(irg)
 339 #define get_irg_cstore(irg)              __get_irg_cstore(irg)
 340 #define set_irg_cstore(irg, node)        __set_irg_cstore(irg, node)
 341 #define get_irg_frame(irg)               __get_irg_frame(irg)
 342 #define set_irg_frame(irg, node)         __set_irg_frame(irg, node)
 343 #define get_irg_globals(irg)             __get_irg_globals(irg)
 344 #define set_irg_globals(irg, node)       __set_irg_globals(irg, node)
 345 #define get_irg_args(irg)                __get_irg_args(irg)
 346 #define set_irg_args(irg, node)          __set_irg_args(irg, node)
 347 #define get_irg_bad(irg)                 __get_irg_bad(irg)
 348 #define set_irg_bad(irg, node)           __set_irg_bad(irg, node)
 349 #define get_irg_current_block(irg)       __get_irg_current_block(irg)
 350 #define set_irg_current_block(irg, node) __set_irg_current_block(irg, node)
 351 #define get_irg_ent(irg)                 __get_irg_ent(irg)
 352 #define set_irg_ent(irg, ent)            __set_irg_ent(irg, ent)
 353 #define get_irg_frame_type(irg)          __get_irg_frame_type(irg)
 354 #define set_irg_frame_type(irg, ftp)     __set_irg_frame_type(irg, ftp)
 355 #define get_irg_obstack(irg)             __get_irg_obstack(irg)
 356 #define set_irg_link(irg, thing)         __set_irg_link(irg, thing)
 357 #define get_irg_link(irg)                __get_irg_link(irg)
 358 #define get_irg_visited(irg)             __get_irg_visited(irg)
 359 #define get_irg_block_visited(irg)       __get_irg_block_visited(irg)
 360 #define set_irg_block_visited(irg, v)    __set_irg_block_visited(irg, v)
 361 #define inc_irg_block_visited(irg)       __inc_irg_block_visited(irg)
 362
 363 # endif /* _IRGRAPH_T_H_ */