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

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 University of Karlsruhe.
   4  */
   5
   6 /**
   7  * @file
   8  * @brief       Backend node support for generic backend nodes.
   9  * @author      Sebastian Hack
  10  * @date        17.05.2005
  11  *
  12  * Backend node support for generic backend nodes.
  13  * This file provides Perm, Copy, Spill and Reload nodes.
  14  */
  15 #ifndef FIRM_BE_BENODE_T_H
  16 #define FIRM_BE_BENODE_T_H
  17
  18 #include <limits.h>
  19
  20 #include "firm_types.h"
  21 #include "irnode_t.h"
  22 #include "bearch.h"
  23
  24 /**
  25  * The benode op's.  Must be available to register emitter function.
  26  */
  27 extern ir_op *op_be_Spill;
  28 extern ir_op *op_be_Reload;
  29 extern ir_op *op_be_Perm;
  30 extern ir_op *op_be_MemPerm;
  31 extern ir_op *op_be_Copy;
  32 extern ir_op *op_be_Keep;
  33 extern ir_op *op_be_CopyKeep;
  34 extern ir_op *op_be_Call;
  35 extern ir_op *op_be_Return;
  36 extern ir_op *op_be_IncSP;
  37 extern ir_op *op_be_AddSP;
  38 extern ir_op *op_be_SubSP;
  39 extern ir_op *op_be_Start;
  40 extern ir_op *op_be_FrameAddr;
  41
  42 /**
  43  * Determines if irn is a be_node.
  44  */
  45 int is_be_node(const ir_node *irn);
  46
  47 /**
  48  * Create all BE specific opcodes.
  49  */
  50 void be_init_op(void);
  51
  52 void be_finish_op(void);
  53
  54 /**
  55  * Position numbers for the be_Spill inputs.
  56  */
  57 enum {
  58         n_be_Spill_frame = 0,
  59         n_be_Spill_val   = 1
  60 };
  61
  62 /**
  63  * Make a new Spill node.
  64  */
  65 ir_node *be_new_Spill(const arch_register_class_t *cls,
  66                       const arch_register_class_t *cls_frame, ir_node *block,
  67                       ir_node *frame, ir_node *to_spill);
  68
  69 /**
  70  * Position numbers for the be_Reload inputs.
  71  */
  72 enum {
  73         n_be_Reload_frame = 0,
  74         n_be_Reload_mem   = 1
  75 };
  76
  77 /**
  78  * Make a new Reload node.
  79  */
  80 ir_node *be_new_Reload(const arch_register_class_t *cls,
  81                        const arch_register_class_t *cls_frame, ir_node *block,
  82                        ir_node *frame, ir_node *mem, ir_mode *mode);
  83
  84 /**
  85  * Position numbers for the be_Copy inputs.
  86  */
  87 enum {
  88         n_be_Copy_op = 0
  89 };
  90
  91 /**
  92  * Make a new Copy node.
  93  */
  94 ir_node *be_new_Copy(ir_node *block, ir_node *in);
  95 /** Returns the Copy Argument. */
  96 ir_node *be_get_Copy_op(const ir_node *cpy);
  97
  98 /**
  99  * Make a new Perm node.
 100  */
 101 ir_node *be_new_Perm(const arch_register_class_t *cls, ir_node *block,
 102                      int n, ir_node *in[]);
 103
 104 /**
 105  * Reduce a Perm.
 106  * Basically, we provide a map to remap the Perm's arguments. If an entry in the
 107  * map is -1, the argument gets deleted.
 108  * This function takes care, that the register data and the input array reflects
 109  * the changes described by the map.
 110  * This is needed by the Perm optimization/movement in belower.c, see
 111  * push_through_perm().
 112  * @param perm     The perm node.
 113  * @param new_size The new number of arguments (must be smaller or equal to the
 114  *                 current one).
 115  * @param map      A map assigning each operand a new index (or -1 to indicate
 116  *                 deletion).
 117  */
 118 void be_Perm_reduce(ir_node *perm, int new_size, int *map);
 119
 120 /**
 121  * Create a new MemPerm node.
 122  * A MemPerm node exchanges the values of memory locations. (Typically entities
 123  * used as spillslots). MemPerm nodes perform this operation without modifying
 124  * any register values.
 125  */
 126 ir_node *be_new_MemPerm(ir_node *block, int n, ir_node *in[]);
 127 ir_node *be_new_Keep(ir_node *block, int arity, ir_node *in[]);
 128
 129 void be_Keep_add_node(ir_node *keep, const arch_register_class_t *cls,
 130                       ir_node *node);
 131
 132 /**
 133  * Position numbers for the be_FrameAddr inputs
 134  */
 135 enum {
 136         n_be_FrameAddr_ptr = 0
 137 };
 138
 139 /** Create a new FrameAddr node. */
 140 ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame,
 141                           ir_node *block, ir_node *frame, ir_entity *ent);
 142
 143 /** Return the frame input of a FrameAddr node. */
 144 ir_node *be_get_FrameAddr_frame(const ir_node *node);
 145
 146 ir_entity *be_get_FrameAddr_entity(const ir_node *node);
 147
 148 /**
 149  * Position numbers for the be_AddSP inputs
 150  */
 151 enum {
 152         n_be_AddSP_old_sp = 0,
 153         n_be_AddSP_size   = 1,
 154         n_be_AddSP_last   = 2
 155 };
 156
 157 enum {
 158         pn_be_AddSP_sp   = 0,
 159         pn_be_AddSP_res  = 1,
 160         pn_be_AddSP_M    = 2,
 161         pn_be_AddSP_last = 3
 162 };
 163
 164 /**
 165  * Make a new AddSP node.
 166  * An AddSP node expresses an increase of the stack pointer in the direction
 167  * the stack grows. In contrast to IncSP, the amount of bytes the stack pointer
 168  * is grown, is not given by a constant but an ordinary Firm node.
 169  * @param sp     The stack pointer register.
 170  * @param block  The block.
 171  * @param old_sp The node representing the old stack pointer value.
 172  * @param size   The node expressing the size by which the stack pointer shall
 173  *               be grown.
 174  * @return       A new AddSP node.
 175  */
 176 ir_node *be_new_AddSP(const arch_register_t *sp, ir_node *block,
 177                       ir_node *old_sp, ir_node *size);
 178
 179 /**
 180  * Position numbers for the be_SubSP inputs
 181  */
 182 enum {
 183         n_be_SubSP_old_sp = 0,
 184         n_be_SubSP_size   = 1,
 185         n_be_SubSP_last   = 2
 186 };
 187
 188 enum {
 189         pn_be_SubSP_sp   = 0,
 190         pn_be_SubSP_M    = 1,
 191         pn_be_SubSP_last = 2
 192 };
 193
 194 /**
 195  * Make a new SubSP node.
 196  * A SubSP node expresses a decrease of the stack pointer in the direction the
 197  * stack grows. In contrast to IncSP, the amount of bytes the stack pointer is
 198  * grown, is not given by a constant but an ordinary Firm node.
 199  * @param sp     The stack pointer register.
 200  * @param block  The block.
 201  * @param old_sp The node representing the old stack pointer value.
 202  * @param size   The node expressing the size by which the stack pointer shall
 203  *               be grown.
 204  * @return       A new DecSP node.
 205  */
 206 ir_node *be_new_SubSP(const arch_register_t *sp, ir_node *block,
 207                       ir_node *old_sp, ir_node *size);
 208
 209 /**
 210  * Make a stack pointer increase/decrease node.
 211  * @param sp     The stack pointer register.
 212  * @param block  The block to insert the node into.
 213  * @param old_sp The node defining the former stack pointer.
 214  * @param offset amount the stack should expand (positive offset) or shrink
 215  *               (negative offset). Note that the offset is independent of the
 216  *               natural stack direction of the architecture but just specifies
 217  *               abstract expanding/shrinking of the stack area.
 218  * @param align  force stack alignment to this power of 2. (i.e. specifying 3
 219  *               results in a 2^3 = 8byte stack alignment)
 220  * @return       A new stack pointer increment/decrement node.
 221  * @note         This node sets a register constraint to the @p sp register on
 222  *               its output.
 223  */
 224 ir_node *be_new_IncSP(const arch_register_t *sp, ir_node *block,
 225                       ir_node *old_sp, int offset, int align);
 226
 227 /** Returns the previous node that computes the stack pointer. */
 228 ir_node *be_get_IncSP_pred(ir_node *incsp);
 229
 230 /** Sets the previous node that computes the stack pointer. */
 231 void     be_set_IncSP_pred(ir_node *incsp, ir_node *pred);
 232
 233 /**
 234  * Sets a new offset to a IncSP node.
 235  * A positive offset means expanding the stack, a negative offset shrinking
 236  * an offset is == BE_STACK_FRAME_SIZE will be replaced by the real size of the
 237  * stackframe in the fix_stack_offsets phase.
 238  */
 239 void     be_set_IncSP_offset(ir_node *irn, int offset);
 240
 241 /** Gets the offset from a IncSP node. */
 242 int be_get_IncSP_offset(const ir_node *irn);
 243 int be_get_IncSP_align(const ir_node *irn);
 244
 245 /** Gets the call entity or NULL if this is no static call. */
 246 ir_entity  *be_Call_get_entity(const ir_node *call);
 247 /** Sets the call entity. */
 248 void     be_Call_set_entity(ir_node *call, ir_entity *ent);
 249 /** Gets the call type. */
 250 ir_type *be_Call_get_type(ir_node *call);
 251 /** Sets the call type. */
 252 void     be_Call_set_type(ir_node *call, ir_type *call_tp);
 253
 254 void     be_Call_set_pop(ir_node *call, unsigned pop);
 255
 256 unsigned be_Call_get_pop(const ir_node *call);
 257
 258 /**
 259  * Position numbers for the be_Call inputs.
 260  */
 261 enum {
 262         n_be_Call_mem       = 0,  /**< memory input of a be_Call node */
 263         n_be_Call_sp        = 1,  /**< stack pointer input of a be_Call node */
 264         n_be_Call_ptr       = 2,  /**< call pointer input of a be_Call node */
 265         n_be_Call_first_arg = 3   /**< first argument input of a be_Call node */
 266 };
 267
 268 /**
 269  * Projection numbers for result of be_Call node: use for Proj nodes!
 270  */
 271 typedef enum {
 272         pn_be_Call_M         = pn_Call_M, /**< The memory result of a be_Call. */
 273         pn_be_Call_X_regular = pn_Call_X_regular,
 274         pn_be_Call_X_except  = pn_Call_X_except,
 275         pn_be_Call_sp        = pn_Call_max+1,
 276         pn_be_Call_first_res     /**< The first result proj number of a be_Call. */
 277 } pn_be_Call;
 278
 279 /**
 280  * Construct a new be_Call.
 281  *
 282  * @param dbg      debug info
 283  * @param block    the block where the call is placed
 284  * @param mem      the memory input of the call
 285  * @param sp       the stack pointer input of the call
 286  * @param ptr      the address of the called function, if immediate call set
 287  *                 to sp
 288  * @param n_outs   the number of outcoming values from this call
 289  * @param n        the number of (register) inputs of this call
 290  * @param in       the (register) inputs of this call
 291  * @param call_tp  the call type of this call
 292  */
 293 ir_node *be_new_Call(dbg_info *dbg, ir_node *block, ir_node *mem,
 294                      const arch_register_req_t *sp_req, ir_node *sp,
 295                      const arch_register_req_t *ptr_req, ir_node *ptr,
 296                      int n_outs, int n, ir_node *in[], ir_type *call_tp);
 297
 298 /**
 299  * Position numbers for the be_Return inputs.
 300  */
 301 enum {
 302         n_be_Return_mem  = 0,     /**< memory input of a be_Return node */
 303         n_be_Return_sp   = 1,     /**< stack pointer input of a be_Return node */
 304         n_be_Return_val  = 2,     /**< first "real" return value if any */
 305 };
 306
 307 /**
 308  * Construct a new be_Return.
 309  *
 310  * @param dbg    debug info
 311  * @param block  the block where the new node will be placed
 312  * @param n_res  number of "real" results
 313  * @param pop    pop number of bytes on return
 314  * @param n      number of inputs
 315  * @param in     input array
 316  */
 317 ir_node *be_new_Return(dbg_info *dbg, ir_node *block, int n_res, unsigned pop, int n, ir_node *in[]);
 318
 319 /** Returns the number of real returns values */
 320 int be_Return_get_n_rets(const ir_node *ret);
 321
 322 /**
 323  * Return the number of bytes that should be popped from stack when executing
 324  * the Return.
 325  *
 326  * @param ret  the be_Return node
 327  */
 328 unsigned be_Return_get_pop(const ir_node *ret);
 329
 330 /**
 331  * Return non-zero, if number of popped bytes must be always emitted.
 332  *
 333  * @param ret  the be_Return node
 334  */
 335 int be_Return_get_emit_pop(const ir_node *ret);
 336
 337 /**
 338  * Set the emit_pop flag.
 339  *
 340  * @param ret  the be_Return node
 341  */
 342 void be_Return_set_emit_pop(ir_node *ret, int emit_pop);
 343
 344 ir_node *be_new_Start(dbg_info *dbgi, ir_node *block, int n_out);
 345
 346 enum {
 347         n_be_CopyKeep_op = 0
 348 };
 349 ir_node *be_new_CopyKeep(ir_node *block, ir_node *src,
 350                          int n, ir_node *in_keep[]);
 351
 352 ir_node *be_new_CopyKeep_single(ir_node *block, ir_node *src, ir_node *keep);
 353
 354 ir_node *be_get_CopyKeep_op(const ir_node *cpy);
 355
 356 void be_set_CopyKeep_op(ir_node *cpy, ir_node *op);
 357
 358 /**
 359  * Returns the frame entity of a be node.
 360  * Try to avoid this function and better call arch_get_frame_entity!
 361  *
 362  * @return the frame entity used by the be node
 363  */
 364 ir_entity *be_get_frame_entity(const ir_node *irn);
 365
 366 void be_node_set_frame_entity(ir_node *node, ir_entity *entity);
 367
 368 /**
 369  * Returns the frame offset of this node.
 370  */
 371 int be_get_frame_offset(const ir_node *irn);
 372
 373 ir_node* be_get_Reload_mem(const ir_node *irn);
 374 ir_node *be_get_Reload_frame(const ir_node *irn);
 375 ir_node* be_get_Spill_val(const ir_node *irn);
 376 ir_node *be_get_Spill_frame(const ir_node *irn);
 377
 378 void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity* ent);
 379 ir_entity *be_get_MemPerm_in_entity(const ir_node *irn, int n);
 380
 381 void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity* ent);
 382 ir_entity *be_get_MemPerm_out_entity(const ir_node *irn, int n);
 383
 384 int be_get_MemPerm_entity_arity(const ir_node *irn);
 385
 386 /**
 387  * Impose a register constraint on a backend node.
 388  * @param irn The node.
 389  * @param pos The position of the argument.
 390  * @param reg The register which is admissible for that node, argument/result
 391  *            and position.
 392  */
 393 void be_set_constr_single_reg_in(ir_node *irn, int pos,
 394                 const arch_register_t *reg, arch_register_req_type_t additional_flags);
 395 void be_set_constr_single_reg_out(ir_node *irn, int pos,
 396                 const arch_register_t *reg, arch_register_req_type_t additional_flags);
 397
 398 const arch_register_req_t *be_create_reg_req(struct obstack *obst,
 399                 const arch_register_t *reg, arch_register_req_type_t additional_types);
 400
 401 /**
 402  * Impose register constraints on a backend node.
 403  * The register subsets given by the limited function in @p req are copied to
 404  * the backend node. This requires that the constraint type of the @p req is
 405  * arch_register_req_type_limited.
 406  * @param irn The backend node.
 407  * @param pos The position (@see be_set_constr_single_reg()).
 408  * @param req The register requirements which shall be transferred.
 409  */
 410 void be_set_constr_in(ir_node *irn, int pos, const arch_register_req_t *req);
 411 void be_set_constr_out(ir_node *irn, int pos, const arch_register_req_t *req);
 412
 413 /**
 414  * Set the register class of a node.
 415  * @param irn The node itself.
 416  * @param pos The position (0..n) for arguments
 417  * @param flags The register class to set for that node and position.
 418  */
 419 void be_node_set_reg_class_in(ir_node *irn, int pos,
 420                               const arch_register_class_t *cls);
 421 void be_node_set_reg_class_out(ir_node *irn, int pos,
 422                                const arch_register_class_t *cls);
 423
 424 /**
 425  * Set the register requirements for a phi node.
 426  */
 427 void be_set_phi_reg_req(ir_node *phi, const arch_register_req_t *req);
 428
 429 void be_dump_phi_reg_reqs(FILE *out, const ir_node *node, dump_reason_t reason);
 430
 431 /**
 432  * Creates a new phi with associated backend informations
 433  */
 434 ir_node *be_new_Phi(ir_node *block, int n_ins, ir_node **ins, ir_mode *mode,
 435                     const arch_register_req_t *req);
 436
 437 /**
 438  * Search for output of start node with a specific register
 439  */
 440 ir_node *be_get_initial_reg_value(ir_graph *irg, const arch_register_t *reg);
 441
 442 static inline int be_is_Spill    (const ir_node *irn) { return get_irn_opcode(irn) == beo_Spill    ; }
 443 static inline int be_is_Reload   (const ir_node *irn) { return get_irn_opcode(irn) == beo_Reload   ; }
 444 static inline int be_is_Copy     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Copy     ; }
 445 static inline int be_is_CopyKeep (const ir_node *irn) { return get_irn_opcode(irn) == beo_CopyKeep ; }
 446 static inline int be_is_Perm     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Perm     ; }
 447 static inline int be_is_MemPerm  (const ir_node *irn) { return get_irn_opcode(irn) == beo_MemPerm  ; }
 448 static inline int be_is_Keep     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Keep     ; }
 449 static inline int be_is_Call     (const ir_node *irn) { return get_irn_opcode(irn) == beo_Call     ; }
 450 static inline int be_is_Return   (const ir_node *irn) { return get_irn_opcode(irn) == beo_Return   ; }
 451 static inline int be_is_IncSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_IncSP    ; }
 452 static inline int be_is_AddSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_AddSP    ; }
 453 static inline int be_is_SubSP    (const ir_node *irn) { return get_irn_opcode(irn) == beo_SubSP    ; }
 454 static inline int be_is_Start    (const ir_node *irn) { return get_irn_opcode(irn) == beo_Start    ; }
 455 static inline int be_is_FrameAddr(const ir_node *irn) { return get_irn_opcode(irn) == beo_FrameAddr; }
 456
 457 #endif