nsz Git - libfirm/blob - ir/be/bearch.h

   1 #ifndef _FIRM_BEARCH_H
   2 #define _FIRM_BEARCH_H
   3
   4 #include "firm_config.h"
   5
   6 #include "firm_types.h"
   7
   8 #include "bitset.h"
   9
  10 #include "belistsched.h"
  11 #include "beilpsched.h"
  12 #include "beabi_t.h"
  13 #include "bearch_t.h"
  14 #include "be_t.h"
  15 #include "bemachine.h"
  16 #include "beirg.h"
  17
  18 typedef enum _arch_register_type_t {
  19         arch_register_type_none         = 0,
  20         arch_register_type_caller_save  = 1,  /**< The register must be saved by the caller
  21                                              upon a function call. It thus can be overwritten
  22                                              in the called function. */
  23         arch_register_type_callee_save  = 2,  /**< The register must be saved by the caller
  24                                              upon a function call. It thus can be overwritten
  25                                              in the called function. */
  26         arch_register_type_ignore       = 4,  /**< Do not consider this register when allocating. */
  27         arch_register_type_joker        = 8,  /**< The emitter can choose an arbitrary register */
  28         arch_register_type_virtual      = 16, /**< This is just a virtual register  */
  29 } arch_register_type_t;
  30
  31 /**
  32  * Convenience macro to check for register type.
  33  * @param req   A pointer to register.
  34  * @param kind  The kind of type to check for (see arch_register_type_t).
  35  * @return      1, If register is of given kind, 0 if not.
  36  */
  37 #define arch_register_type_is(reg, kind) \
  38   (((reg)->type & arch_register_type_ ## kind) != 0)
  39
  40 /**
  41  * A register.
  42  */
  43 struct _arch_register_t {
  44         const char                  *name;        /**< The name of the register. */
  45         const arch_register_class_t *reg_class;   /**< The class the register belongs to. */
  46         int                         index;        /**< The index of the register in the class. */
  47         arch_register_type_t        type;         /**< The type of the register. */
  48         void                        *data;        /**< Custom data. */
  49 };
  50
  51 static INLINE const arch_register_class_t *
  52 _arch_register_get_class(const arch_register_t *reg)
  53 {
  54         return reg->reg_class;
  55 }
  56
  57 static INLINE int _arch_register_get_index(const arch_register_t *reg)
  58 {
  59         return reg->index;
  60 }
  61
  62 static INLINE const char *_arch_register_get_name(const arch_register_t *reg)
  63 {
  64         return reg->name;
  65 }
  66
  67 #define arch_register_get_class(reg)      _arch_register_get_class(reg)
  68 #define arch_register_get_index(reg)      _arch_register_get_index(reg)
  69 #define arch_register_get_name(reg)       _arch_register_get_name(reg)
  70
  71 /**
  72  * A class of registers.
  73  * Like general purpose or floating point.
  74  */
  75 struct _arch_register_class_t {
  76         const char *name;               /**< The name of the register class. */
  77         int n_regs;                     /**< Number of registers in this class. */
  78         ir_mode *mode;                  /**< The mode of the register class. */
  79         const arch_register_t *regs;    /**< The array of registers. */
  80 };
  81
  82 /** return the number of registers in this register class */
  83 #define arch_register_class_n_regs(cls) ((cls)->n_regs)
  84
  85 /** return the largest mode of this register class */
  86 #define arch_register_class_mode(cls) ((cls)->mode)
  87
  88 /** return the name of this register class */
  89 #define arch_register_class_name(cls) ((cls)->name)
  90
  91 /**
  92  * Put all registers in a class into a bitset.
  93  * @param cls The class.
  94  * @param bs The bitset. May be NULL.
  95  * @return The number of registers in the class.
  96  */
  97 extern int arch_register_class_put(const arch_register_class_t *cls, bitset_t *bs);
  98
  99 static INLINE const arch_register_t *
 100 _arch_register_for_index(const arch_register_class_t *cls, int idx)
 101 {
 102         assert(0 <= idx && idx < cls->n_regs);
 103         return &cls->regs[idx];
 104 }
 105
 106 #define arch_register_for_index(cls, idx) \
 107   _arch_register_for_index(cls, idx)
 108
 109 typedef enum _arch_operand_type_t {
 110         arch_operand_type_invalid,
 111         arch_operand_type_memory,
 112         arch_operand_type_register,
 113         arch_operand_type_immediate,
 114         arch_operand_type_symconst,
 115         arch_operand_type_last
 116 } arch_operand_type_t;
 117
 118 /**
 119  * Different types of register allocation requirements.
 120  */
 121 typedef enum _arch_register_req_type_t {
 122         arch_register_req_type_none                         = 0,  /**< No register requirement. */
 123         arch_register_req_type_normal                       = 1,  /**< All registers in the class are allowed. */
 124         arch_register_req_type_limited                      = 2,  /**< Only a real subset of the class is allowed. */
 125         arch_register_req_type_should_be_same               = 4,  /**< The register should be equal another one at the node. */
 126         arch_register_req_type_should_be_different          = 8,  /**< The register must be unequal to some other at the node. */
 127         arch_register_req_type_should_be_different_from_all = 16, /**< The register must be different from all in's at the node */
 128 } arch_register_req_type_t;
 129
 130 /**
 131  * Convenience macro to check for set constraints.
 132  * @param req   A pointer to register requirements.
 133  * @param kind  The kind of constraint to check for (see arch_register_req_type_t).
 134  * @return      1, If the kind of constraint is present, 0 if not.
 135  */
 136 #define arch_register_req_is(req, kind) \
 137         (((req)->type & (arch_register_req_type_ ## kind)) != 0)
 138
 139 /**
 140  * Expresses requirements to register allocation for an operand.
 141  */
 142 typedef struct _arch_register_req_t {
 143         arch_register_req_type_t type;      /**< The type of the constraint. */
 144         const arch_register_class_t *cls;   /**< The register class this constraint belongs to. */
 145
 146         const unsigned *limited;            /**< allowed register bitset */
 147
 148         int other_same;                     /**< The in number which shall have
 149                                                                                      the same res (should_be_same)*/
 150         int other_different;                /**< The other node from which this
 151                                                                                      one's register must be different
 152                                                                                          (case must_be_different). */
 153 } arch_register_req_t;
 154
 155 extern const arch_register_req_t *arch_no_register_req;
 156
 157 /**
 158  * Format a register requirements information into a string.
 159  * @param buf The string where to put it to.
 160  * @param len The size of @p buf.
 161  * @param req The requirements structure to format.
 162  * @return    A pointer to buf.
 163  */
 164 extern char *arch_register_req_format(char *buf, size_t len, const arch_register_req_t *req, const ir_node *node);
 165
 166
 167 /**
 168  * Certain node classes which are relevant for the register allocator.
 169  */
 170 typedef enum _arch_irn_class_t {
 171         arch_irn_class_normal     = 1 << 0,
 172         arch_irn_class_spill      = 1 << 1,
 173         arch_irn_class_reload     = 1 << 2,
 174         arch_irn_class_copy       = 1 << 3,
 175         arch_irn_class_perm       = 1 << 4,
 176         arch_irn_class_branch     = 1 << 5,
 177         arch_irn_class_call       = 1 << 6,
 178         arch_irn_class_const      = 1 << 7,
 179         arch_irn_class_load       = 1 << 8,
 180         arch_irn_class_store      = 1 << 9,
 181         arch_irn_class_stackparam = 1 << 10,
 182 } arch_irn_class_t;
 183
 184 /**
 185  * An inverse operation returned by the backend
 186  */
 187 typedef struct _arch_inverse_t {
 188         int      n;       /**< count of nodes returned in nodes array */
 189         int      costs;   /**< costs of this remat */
 190
 191         /**< nodes for this inverse operation. shall be in
 192          *  schedule order. last element is the target value
 193          */
 194         ir_node  **nodes;
 195 } arch_inverse_t;
 196
 197 /**
 198  * Some flags describing a node in more detail.
 199  */
 200 typedef enum _arch_irn_flags_t {
 201         arch_irn_flags_none             = 0, /**< Node flags. */
 202         arch_irn_flags_dont_spill       = 1, /**< This must not be spilled. */
 203         arch_irn_flags_rematerializable = 2, /**< This can be replicated instead of spilled/reloaded. */
 204         arch_irn_flags_ignore           = 4, /**< Ignore node during register allocation. */
 205         arch_irn_flags_modify_sp        = 8, /**< I modify the stack pointer. */
 206         arch_irn_flags_last             = arch_irn_flags_modify_sp
 207 } arch_irn_flags_t;
 208
 209 /**
 210  * Get the string representation of a flag.
 211  * This functions does not handle or'ed bitmasks of flags.
 212  * @param flag The flag.
 213  * @return The flag as a string.
 214  */
 215 extern const char *arch_irn_flag_str(arch_irn_flags_t flag);
 216
 217 struct _arch_irn_ops_if_t {
 218
 219         /**
 220          * Get the register requirements for a given operand.
 221          * @param self The self pointer.
 222          * @param irn The node.
 223          * @param pos The operand's position
 224          *        (-1 for the result of the node, 0..n for the input operands).
 225          * @return    The register requirements for the selected operand.
 226          *            The pointer returned is never NULL.
 227          */
 228         const arch_register_req_t *(*get_irn_reg_req)(const void *self,
 229                                                       const ir_node *irn, int pos);
 230
 231         /**
 232          * Set the register for an output operand.
 233          * @param irn The node.
 234          * @param reg The register allocated to that operand.
 235          * @note      If the operand is not a register operand,
 236          *            the call is ignored.
 237          */
 238         void (*set_irn_reg)(const void *self, ir_node *irn, const arch_register_t *reg);
 239
 240         /**
 241          * Get the register allocated for an output operand.
 242          * @param irn The node.
 243          * @return    The register allocated at that operand. NULL, if
 244          *            the operand was no register operand or
 245          *            @c arch_register_invalid, if no register has yet been
 246          *            allocated for this node.
 247          */
 248         const arch_register_t *(*get_irn_reg)(const void *self, const ir_node *irn);
 249
 250         /**
 251          * Classify the node.
 252          * @param irn The node.
 253          * @return A classification.
 254          */
 255         arch_irn_class_t (*classify)(const void *self, const ir_node *irn);
 256
 257         /**
 258          * Get the flags of a node.
 259          * @param self The irn ops themselves.
 260          * @param irn The node.
 261          * @return A set of flags.
 262          */
 263         arch_irn_flags_t (*get_flags)(const void *self, const ir_node *irn);
 264
 265         /**
 266          * Get the entity on the stack frame this node depends on.
 267          * @param self The this pointer.
 268          * @param irn  The node in question.
 269          * @return The entity on the stack frame or NULL, if the node does not have a
 270          *         stack frame entity.
 271          */
 272         ir_entity *(*get_frame_entity)(const void *self, const ir_node *irn);
 273
 274         /**
 275          * Set the entity on the stack frame this node depends on.
 276          * @param self The this pointer.
 277          * @param irn  The node in question.
 278          * @param ent  The entity to set
 279          */
 280         void (*set_frame_entity)(const void *self, ir_node *irn, ir_entity *ent);
 281
 282         /**
 283          * Set the offset of a node carrying an entity on the stack frame.
 284          * @param self The this pointer.
 285          * @param irn  The node.
 286          * @param offset The offset of the node's stack frame entity.
 287          */
 288         void (*set_frame_offset)(const void *self, ir_node *irn, int offset);
 289
 290         /**
 291          * Returns the delta of the stackpointer for nodes that increment or
 292          * decrement the stackpointer with a constant value. (push, pop
 293          * nodes on most architectures).
 294          * A positive value stands for an expanding stack area, a negative value for
 295          * a shrinking one.
 296          *
 297          * @param self      The this pointer
 298          * @param irn       The node
 299          * @return          0 if the stackpointer is not modified with a constant
 300          *                  value, otherwise the increment/decrement value
 301          */
 302         int (*get_sp_bias)(const void *self, const ir_node *irn);
 303
 304         /**
 305          * Returns an inverse operation which yields the i-th argument
 306          * of the given node as result.
 307          *
 308          * @param self      The this pointer.
 309          * @param irn       The original operation
 310          * @param i         Index of the argument we want the inverse operation to yield
 311          * @param inverse   struct to be filled with the resulting inverse op
 312          * @param obstack   The obstack to use for allocation of the returned nodes array
 313          * @return          The inverse operation or NULL if operation invertible
 314          */
 315         arch_inverse_t *(*get_inverse)(const void *self, const ir_node *irn, int i, arch_inverse_t *inverse, struct obstack *obstack);
 316
 317         /**
 318          * Get the estimated cycle count for @p irn.
 319          *
 320          * @param self The this pointer.
 321          * @param irn  The node.
 322          *
 323          * @return     The estimated cycle count for this operation
 324          */
 325         int (*get_op_estimated_cost)(const void *self, const ir_node *irn);
 326
 327         /**
 328          * Asks the backend whether operand @p i of @p irn can be loaded form memory internally
 329          *
 330          * @param self The this pointer.
 331          * @param irn  The node.
 332          * @param i    Index of the argument we would like to know whether @p irn can load it form memory internally
 333          *
 334          * @return     nonzero if argument can be loaded or zero otherwise
 335          */
 336         int (*possible_memory_operand)(const void *self, const ir_node *irn, unsigned int i);
 337
 338         /**
 339          * Ask the backend to assimilate @p reload of operand @p i into @p irn.
 340          *
 341          * @param self   The this pointer.
 342          * @param irn    The node.
 343          * @param spill  The spill.
 344          * @param i      The position of the reload.
 345          */
 346         void (*perform_memory_operand)(const void *self, ir_node *irn, ir_node *spill, unsigned int i);
 347 };
 348
 349 /**
 350  * irn_ops base class.
 351  */
 352 struct _arch_irn_ops_t {
 353         const arch_irn_ops_if_t *impl;
 354 };
 355
 356 extern const arch_irn_ops_t *arch_get_irn_ops(const arch_env_t *env, const ir_node *irn);
 357
 358 extern void arch_set_frame_offset(const arch_env_t *env, ir_node *irn, int bias);
 359
 360 extern ir_entity *arch_get_frame_entity(const arch_env_t *env, ir_node *irn);
 361 extern void arch_set_frame_entity(const arch_env_t *env, ir_node *irn, ir_entity *ent);
 362 extern int arch_get_sp_bias(const arch_env_t *env, ir_node *irn);
 363
 364 extern int arch_get_op_estimated_cost(const arch_env_t *env, const ir_node *irn);
 365 extern arch_inverse_t *arch_get_inverse(const arch_env_t *env, const ir_node *irn, int i, arch_inverse_t *inverse, struct obstack *obstack);
 366 extern int arch_possible_memory_operand(const arch_env_t *env, const ir_node *irn, unsigned int i);
 367 extern void arch_perform_memory_operand(const arch_env_t *env, ir_node *irn, ir_node *spill, unsigned int i);
 368
 369 /**
 370  * Get the register requirements for a node.
 371  * @param env The architecture environment.
 372  * @param req A pointer to a requirements structure, where the data can
 373  *            be put into.
 374  * @param irn The node.
 375  * @param pos The position of the operand you're interested in.
 376  * @return    A pointer to the register requirements which may <b>not</b>
 377  *            neccessarily be equal to @p req. If NULL is returned, the
 378  *            operand was no register operand.
 379  */
 380 extern const arch_register_req_t *
 381 arch_get_register_req(const arch_env_t *env, const ir_node *irn, int pos);
 382
 383 /**
 384  * Check if an operand is a register operand.
 385  * @param env The environment.
 386  * @param irn The node.
 387  * @param pos The position of the operand.
 388  * @return 1, if the operand is significant for register allocation, 0
 389  * if not.
 390  */
 391 extern int arch_is_register_operand(const arch_env_t *env,
 392     const ir_node *irn, int pos);
 393
 394 /**
 395  * Get the number of allocatable registers concerning
 396  * a register class for an operand of a node.
 397  * @param env The environment.
 398  * @param irn The node.
 399  * @param pos The postition of the node's operand.
 400  * @param bs  The bitset all allocatable registers shall be put into.
 401  *            Note, that you can also pass NULL here. If you don't,
 402  *            make sure, the bitset is as large as the register class
 403  *            has registers.
 404  * @return    The amount of registers allocatable for that operand.
 405  */
 406 extern int arch_get_allocatable_regs(const arch_env_t *env, const ir_node *irn, int pos, bitset_t *bs);
 407
 408 /**
 409  * Put all registers which shall not be ignored by the register
 410  * allocator in a bit set.
 411  * @param env The arch env.
 412  * @param cls The register class to consider.
 413  * @param bs  The bit set to put the registers to.
 414  */
 415 extern void arch_put_non_ignore_regs(const arch_env_t *env, const arch_register_class_t *cls, bitset_t *bs);
 416
 417 /**
 418  * Check, if a register is assignable to an operand of a node.
 419  * @param env The architecture environment.
 420  * @param irn The node.
 421  * @param pos The position of the operand.
 422  * @param reg The register.
 423  * @return    1, if the register might be allocated to the operand 0 if not.
 424  */
 425 extern int arch_reg_is_allocatable(const arch_env_t *env,
 426     const ir_node *irn, int pos, const arch_register_t *reg);
 427
 428 /**
 429  * Get the register class of an operand of a node.
 430  * @param env The architecture environment.
 431  * @param irn The node.
 432  * @param pos The position of the operand, -1 for the output.
 433  * @return    The register class of the operand or NULL, if
 434  *            operand is a non-register operand.
 435  */
 436 extern const arch_register_class_t *
 437 arch_get_irn_reg_class(const arch_env_t *env, const ir_node *irn, int pos);
 438
 439 /**
 440  * Get the register allocated at a certain output operand of a node.
 441  * @param env The arch environment.
 442  * @param irn The node.
 443  * @return    The register allocated for this operand
 444  */
 445 extern const arch_register_t *
 446 arch_get_irn_register(const arch_env_t *env, const ir_node *irn);
 447
 448 /**
 449  * Set the register for a certain output operand.
 450  * @param env The architecture environment.
 451  * @param irn The node.
 452  * @param idx The index of the output operand.
 453  * @param reg The register.
 454  */
 455 extern void arch_set_irn_register(const arch_env_t *env, ir_node *irn,
 456                 const arch_register_t *reg);
 457
 458 /**
 459  * Classify a node.
 460  * @param env The architecture environment.
 461  * @param irn The node.
 462  * @return A classification of the node.
 463  */
 464 extern arch_irn_class_t arch_irn_classify(const arch_env_t *env, const ir_node *irn);
 465
 466 #define arch_irn_class_is(env, irn, irn_class) ((arch_irn_classify(env, irn) & arch_irn_class_ ## irn_class) != 0)
 467
 468 /**
 469  * Get the flags of a node.
 470  * @param env The architecture environment.
 471  * @param irn The node.
 472  * @return The flags.
 473  */
 474 extern arch_irn_flags_t arch_irn_get_flags(const arch_env_t *env, const ir_node *irn);
 475
 476 #define arch_irn_is(env, irn, flag) ((arch_irn_get_flags(env, irn) & arch_irn_flags_ ## flag) != 0)
 477
 478 #define arch_irn_has_reg_class(env, irn, pos, cls) \
 479         ((cls) == arch_get_irn_reg_class(env, irn, pos))
 480
 481 #define arch_irn_consider_in_reg_alloc(env, cls, irn) \
 482         (arch_irn_has_reg_class(env, irn, -1, cls) && !arch_irn_is(env, irn, ignore))
 483
 484 /**
 485  * Somebody who can be asked about IR nodes.
 486  */
 487 struct _arch_irn_handler_t {
 488
 489   /**
 490     * Get the operations of an irn.
 491     * @param self The handler from which the method is invoked.
 492     * @param irn Some node.
 493     * @return Operations for that irn.
 494     */
 495   const void *(*get_irn_ops)(const arch_irn_handler_t *handler,
 496       const ir_node *irn);
 497 };
 498
 499 /**
 500  * The code generator interface.
 501  */
 502 struct _arch_code_generator_if_t {
 503         /**
 504          * Initialize the code generator.
 505          * @param birg A backend IRG session.
 506          * @return     A newly created code generator.
 507          */
 508         void *(*init)(be_irg_t *birg);
 509
 510         /**
 511          * Called before abi introduce.
 512          */
 513         void (*before_abi)(void *self);
 514
 515         /**
 516          * Called, when the graph is being normalized.
 517          */
 518         void (*prepare_graph)(void *self);
 519
 520         /**
 521          * Backend may provide an own spiller.
 522          * This spiller needs to spill all register classes.
 523          */
 524         void (*spill)(void *self, be_irg_t *birg);
 525
 526         /**
 527          * Called before scheduling.
 528          */
 529         void (*before_sched)(void *self);
 530
 531         /**
 532          * Called before register allocation.
 533          */
 534         void (*before_ra)(void *self);
 535
 536         /**
 537          * Called after register allocation.
 538          */
 539         void (*after_ra)(void *self);
 540
 541         /**
 542          * Called directly before done is called. This should be the last place
 543          * where the irg is modified.
 544          */
 545         void (*finish)(void *self);
 546
 547         /**
 548          * Called after everything happened. This call should emit the final
 549          * assembly code but avoid changing the irg.
 550          * The code generator must also be de-allocated here.
 551          */
 552         void (*done)(void *self);
 553 };
 554
 555 /**
 556  * helper macro: call function func from the code generator
 557  * if it's implemented.
 558  */
 559 #define _arch_cg_call(cg, func) \
 560 do { \
 561         if((cg)->impl->func) \
 562                 (cg)->impl->func(cg); \
 563 } while(0)
 564
 565 #define _arch_cg_call_env(cg, env, func) \
 566 do { \
 567         if((cg)->impl->func) \
 568                 (cg)->impl->func(cg, env); \
 569 } while(0)
 570
 571 #define arch_code_generator_before_abi(cg)      _arch_cg_call(cg, before_abi)
 572 #define arch_code_generator_prepare_graph(cg)   _arch_cg_call(cg, prepare_graph)
 573 #define arch_code_generator_before_sched(cg)    _arch_cg_call(cg, before_sched)
 574 #define arch_code_generator_before_ra(cg)       _arch_cg_call(cg, before_ra)
 575 #define arch_code_generator_after_ra(cg)        _arch_cg_call(cg, after_ra)
 576 #define arch_code_generator_finish(cg)          _arch_cg_call(cg, finish)
 577 #define arch_code_generator_done(cg)            _arch_cg_call(cg, done)
 578 #define arch_code_generator_spill(cg, birg)     _arch_cg_call_env(cg, birg, spill)
 579 #define arch_code_generator_has_spiller(cg)     ((cg)->impl->spill != NULL)
 580
 581 /**
 582  * Code generator base class.
 583  */
 584 struct _arch_code_generator_t {
 585         const arch_code_generator_if_t *impl;
 586 };
 587
 588 /**
 589  * ISA base class.
 590  */
 591 struct _arch_isa_t {
 592         const arch_isa_if_t   *impl;
 593         const arch_register_t *sp;        /** The stack pointer register. */
 594         const arch_register_t *bp;        /** The base pointer register. */
 595         const int             stack_dir;  /** -1 for decreasing, 1 for increasing. */
 596         const be_main_env_t   *main_env;  /** the be main environment */
 597 };
 598
 599 #define arch_isa_stack_dir(isa)  ((isa)->stack_dir)
 600 #define arch_isa_sp(isa)         ((isa)->sp)
 601 #define arch_isa_bp(isa)         ((isa)->bp)
 602
 603 /**
 604  * Architecture interface.
 605  */
 606 struct _arch_isa_if_t {
 607         /**
 608          * Initialize the isa interface.
 609          * @param file_handle  the file handle to write the output to
 610          * @param main_env     the be main environment
 611          * @return a new isa instance
 612          */
 613         void *(*init)(FILE *file_handle);
 614
 615         /**
 616          * Free the isa instance.
 617          */
 618         void (*done)(void *self);
 619
 620         /**
 621          * Get the the number of register classes in the isa.
 622          * @return The number of register classes.
 623          */
 624         int (*get_n_reg_class)(const void *self);
 625
 626         /**
 627          * Get the i-th register class.
 628          * @param i The number of the register class.
 629          * @return The register class.
 630          */
 631         const arch_register_class_t *(*get_reg_class)(const void *self, int i);
 632
 633         /**
 634          * Get the register class which shall be used to store a value of a given mode.
 635          * @param self The this pointer.
 636          * @param mode The mode in question.
 637          * @return A register class which can hold values of the given mode.
 638          */
 639         const arch_register_class_t *(*get_reg_class_for_mode)(const void *self, const ir_mode *mode);
 640
 641         /**
 642          * Get the ABI restrictions for procedure calls.
 643          * @param self        The this pointer.
 644          * @param method_type The type of the method (procedure) in question.
 645          * @param p           The array of parameter locations to be filled.
 646          */
 647         void (*get_call_abi)(const void *self, ir_type *method_type, be_abi_call_t *abi);
 648
 649         /**
 650          * The irn handler for this architecture.
 651          * The irn handler is registered by the Firm back end
 652          * when the architecture is initialized.
 653          * (May be NULL).
 654          */
 655         const arch_irn_handler_t *(*get_irn_handler)(const void *self);
 656
 657         /**
 658          * Get the code generator interface.
 659          * @param self The this pointer.
 660          * @return     Some code generator interface.
 661          */
 662         const arch_code_generator_if_t *(*get_code_generator_if)(void *self);
 663
 664         /**
 665          * Get the list scheduler to use. There is already a selector given, the
 666          * backend is free to modify and/or ignore it.
 667          *
 668          * @param self     The isa object.
 669          * @param selector The selector given by options.
 670          * @return         The list scheduler selector.
 671          */
 672         const list_sched_selector_t *(*get_list_sched_selector)(const void *self, list_sched_selector_t *selector);
 673
 674         /**
 675          * Get the ILP scheduler to use.
 676          * @param self  The isa object.
 677          * @return      The ILP scheduler selector
 678          */
 679         const ilp_sched_selector_t *(*get_ilp_sched_selector)(const void *self);
 680
 681         /**
 682          * Get the necessary alignment for storing a register of given class.
 683          * @param self  The isa object.
 684          * @param cls   The register class.
 685          * @return      The alignment in bytes.
 686          */
 687         int (*get_reg_class_alignment)(const void *self, const arch_register_class_t *cls);
 688
 689         /**
 690          * A "static" function, returns the frontend settings
 691          * needed for this backend.
 692          */
 693         const backend_params *(*get_params)(void);
 694
 695         /**
 696          * Returns an 2-dim array of execution units, @p irn can be executed on.
 697          * The first dimension is the type, the second the allowed units of this type.
 698          * Each dimension is a NULL terminated list.
 699          * @param self  The isa object.
 700          * @param irn   The node.
 701          * @return An array of allowed execution units.
 702          *         exec_unit = {
 703          *                       { unit1_of_tp1, ..., unitX1_of_tp1, NULL },
 704          *                       ...,
 705          *                       { unit1_of_tpY, ..., unitXn_of_tpY, NULL },
 706          *                       NULL
 707          *                     };
 708          */
 709         const be_execution_unit_t ***(*get_allowed_execution_units)(const void *self, const ir_node *irn);
 710
 711         /**
 712          * Return the abstract machine for this isa.
 713          * @param self  The isa object.
 714          */
 715         const be_machine_t *(*get_machine)(const void *self);
 716
 717         /**
 718          * Return an ordered list of irgs where code should be generated for.
 719          * If NULL is returned, all irg will be taken into account and they will be
 720          * generated in an arbitrary order.
 721          * @param self   The isa object.
 722          * @param irgs   A flexible array ARR_F of length 0 where the backend cann append the desired irgs.
 723          * @return A flexible array ARR_F containing all desired irgs in the desired order.
 724          */
 725         ir_graph **(*get_backend_irg_list)(const void *self, ir_graph ***irgs);
 726 };
 727
 728 #define arch_isa_get_n_reg_class(isa)                  ((isa)->impl->get_n_reg_class(isa))
 729 #define arch_isa_get_reg_class(isa,i)                  ((isa)->impl->get_reg_class(isa, i))
 730 #define arch_isa_get_irn_handler(isa)                  ((isa)->impl->get_irn_handler(isa))
 731 #define arch_isa_get_call_abi(isa,tp,abi)              ((isa)->impl->get_call_abi((isa), (tp), (abi)))
 732 #define arch_isa_get_reg_class_for_mode(isa,mode)      ((isa)->impl->get_reg_class_for_mode((isa), (mode)))
 733 #define arch_isa_make_code_generator(isa,irg)          ((isa)->impl->make_code_generator((isa), (irg)))
 734 #define arch_isa_get_reg_class_alignment(isa, cls)     ((isa)->impl->get_reg_class_alignment((isa), (cls)))
 735 #define arch_isa_get_allowed_execution_units(isa, irn) ((isa)->impl->get_allowed_execution_units((isa), (irn)))
 736 #define arch_isa_get_machine(isa)                      ((isa)->impl->get_machine((isa)))
 737 #define arch_isa_get_backend_irg_list(isa, irgs)       ((isa)->impl->get_backend_irg_list((isa), (irgs)))
 738
 739 #define ARCH_MAX_HANDLERS         8
 740
 741 /**
 742  * Environment for the architecture infrastructure.
 743  * Keep this everywhere you're going.
 744  */
 745 struct _arch_env_t {
 746         arch_isa_t *isa;                                /**< The isa about which everything is. */
 747
 748         arch_irn_handler_t const *handlers[ARCH_MAX_HANDLERS]; /**< The handlers are organized as
 749                                                            a stack. */
 750
 751         int handlers_tos;                                   /**< The stack pointer of the handler
 752                                                         stack. */
 753 };
 754
 755 /**
 756  * Get the isa of an arch environment.
 757  * @param env The environment.
 758  * @return The isa with which the env was initialized with.
 759  */
 760 #define arch_env_get_isa(env)   ((env)->isa)
 761
 762 /**
 763  * Initialize the architecture environment struct.
 764  * @param isa           The isa which shall be put into the environment.
 765  * @param file_handle   The file handle
 766  * @return The environment.
 767  */
 768 extern arch_env_t *arch_env_init(arch_env_t *env, const arch_isa_if_t *isa, FILE *file_handle, be_main_env_t *main_env);
 769
 770 /**
 771  * Add a node handler to the environment.
 772  * @param env The environment.
 773  * @param handler A node handler.
 774  * @return The environment itself.
 775  */
 776 extern arch_env_t *arch_env_push_irn_handler(arch_env_t *env, const arch_irn_handler_t *handler);
 777
 778 /**
 779  * Remove a node handler from the handler stack.
 780  * @param env The architecture environment.
 781  * @return The popped handler.
 782  */
 783 extern const arch_irn_handler_t *arch_env_pop_irn_handler(arch_env_t *env);
 784
 785 /**
 786  * Register an instruction set architecture
 787  */
 788 void be_register_isa_if(const char *name, const arch_isa_if_t *isa);
 789
 790 #endif /* _FIRM_BEARCH_H */