2 * This file is part of libFirm.
3 * Copyright (C) 2012 University of Karlsruhe.
8 * @brief Representation of an intermediate operation.
9 * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
11 #ifndef FIRM_IR_IRNODE_H
12 #define FIRM_IR_IRNODE_H
16 #include "firm_common.h"
25 * @defgroup ir_node Nodes
27 * ir_node - a datatype representing a Firm node
29 * The common fields are:
31 * - arity - The number of predecessors in the Firm graph.
32 * - in - A list with the predecessors in the Firm graph. There are
33 * routines to access individual elements and to obtain the
34 * array. The method returning the array should not be used.
35 * - mode - The mode of the node. There are routines to get the mode
36 * but also to access the mode's fields directly.
37 * - opcode - The opcode of the node. There are routines to get the opcode
38 * but also to access the opcode's fields directly.
39 * - node_nr - A unique number for the node. Available only if debugging
45 * Checks whether a pointer points to a ir node. This is guessed by looking
46 * at the few bytes of the thing. Most things used in firm have a firm_kind
47 * attribute there. This function might falsely return true though for things
48 * without a firm_kind at the beginning.
50 * @param thing an arbitrary pointer
51 * @return non-zero if the thing is a ir mode, else zero
53 FIRM_API int is_ir_node(const void *thing);
56 * Returns the number of predecessors without the block predecessor.
58 * @param node the IR-node
60 FIRM_API int get_irn_arity(const ir_node *node);
63 * Returns the n-th predecessor of a node.
64 * This function removes Id predecessors.
66 FIRM_API ir_node *get_irn_n(const ir_node *node, int n);
69 * Replaces the old in array by a new one that will contain the ins given in
70 * the parameters. Conserves the block predecessor. It copies the array passed.
71 * This function is necessary to adjust in arrays of blocks, calls and phis.
72 * "in" must contain all predecessors except the block that are required for
73 * the nodes opcode. */
74 FIRM_API void set_irn_in(ir_node *node, int arity, ir_node *const in[]);
77 * Add an artificial dependency to the node.
79 * @param node The node.
80 * @param dep The dependency target.
82 FIRM_API void add_irn_dep(ir_node *node, ir_node *dep);
85 * Copy all dependencies from a node to another.
86 * This is only allowed in phase_backend!
88 * @param tgt The node which should be enriched.
89 * @param src The node whose dependencies shall be copied.
91 FIRM_API void add_irn_deps(ir_node *tgt, ir_node *src);
94 * Returns the length of the dependency array.
95 * @param node The node.
96 * @return The length of the dependency array or 0 if it has not yet been allocated.
98 FIRM_API int get_irn_deps(const ir_node *node);
101 * Returns an entry of the dependency array.
102 * @param node The node.
103 * @param pos The position.
104 * @return The node at that position.
106 FIRM_API ir_node *get_irn_dep(const ir_node *node, int pos);
109 * Sets an entry of the dependency array.
110 * @param node The node.
111 * @param pos The position.
112 * @param dep The dependency target.
114 FIRM_API void set_irn_dep(ir_node *node, int pos, ir_node *dep);
117 * Deletes the entry of the dependency array, that points to dep. Does nothing
118 * if no dependency exists.
120 * @param node the node to delete the dependency at
121 * @param dep the target of the dependency to delete
123 FIRM_API void delete_irn_dep(ir_node *node, ir_node *dep);
125 /** Replaces the n-th predecessor of a node with a new one. */
126 FIRM_API void set_irn_n(ir_node *node, int n, ir_node *in);
128 * Appends a new predecessor to a node. This only works for nodes with
130 * @returns the number of the new input
132 FIRM_API int add_irn_n(ir_node *node, ir_node *in);
133 /** Sets the mode struct of node. */
134 FIRM_API void set_irn_mode(ir_node *node, ir_mode *mode);
135 /** Returns the mode struct of a node. */
136 FIRM_API ir_mode *get_irn_mode(const ir_node *node);
137 /** Returns the opcode struct of the node. */
138 FIRM_API ir_op *get_irn_op(const ir_node *node);
139 /** Sets the opcode struct of the node. */
140 FIRM_API void set_irn_op(ir_node *node, ir_op *op);
141 /** Returns the opcode-enum of the node. */
142 FIRM_API unsigned get_irn_opcode(const ir_node *node);
143 /** Returns the string representation of the opcode. */
144 FIRM_API const char *get_irn_opname(const ir_node *node);
145 /** Returns the ident for a string representation of the opcode. */
146 FIRM_API ident *get_irn_opident(const ir_node *node);
147 /** Returns the visited counter of a node. */
148 FIRM_API ir_visited_t get_irn_visited(const ir_node *node);
149 /** Sets the visited counter of a node. */
150 FIRM_API void set_irn_visited(ir_node *node, ir_visited_t visited);
151 /** Sets visited to get_irg_visited(get_irn_irg(node)). */
152 FIRM_API void mark_irn_visited(ir_node *node);
153 /** Returns 1 if visited >= get_irg_visited(get_irn_irg(node)). */
154 FIRM_API int irn_visited(const ir_node *node);
155 /** Returns 1 if visited >= get_irg_visited(get_irn_irg(node)). Marks the node
156 * visited, if it was not. */
157 FIRM_API int irn_visited_else_mark(ir_node *node);
160 * Sets the link of a node.
161 * Only allowed if the graph is NOT in phase_building.
163 FIRM_API void set_irn_link(ir_node *node, void *link);
165 /** Returns the link of a node. */
166 FIRM_API void *get_irn_link(const ir_node *node);
168 /** Returns the ir_graph this node belongs to. */
169 FIRM_API ir_graph *get_irn_irg(const ir_node *node);
171 /** Outputs a unique number for this node if libFIRM is compiled for
172 debugging, (configure with --enable-debug) else returns address
173 of node cast to long. */
174 FIRM_API long get_irn_node_nr(const ir_node *node);
176 /** Returns the pinned state of a node.
178 * Returns whether the node _always_ must be pinned.
179 * I.e., the node is not floating after global cse.
181 * @returns Either state op_pin_state_pinned or op_pin_state_floats.
183 FIRM_API op_pin_state get_irn_pinned(const ir_node *node);
185 /** Sets pin state for nodes with op pin state op_pin_state_exc_pinned */
186 FIRM_API void set_irn_pinned(ir_node *node, op_pin_state state);
188 /** Returns whether the node is currently pinned.
190 * If get_irn_pinned returns op_pin_state_floats and the graph the
191 * node belongs to is in state op_poin_state_floats then this function
192 * returns 'floats', else 'pinned'.
194 FIRM_API op_pin_state is_irn_pinned_in_irg(const ir_node *node);
197 * IR node constructor.
198 * Create a new IR node in irg, with an op, mode, arity and
199 * some incoming IR nodes.
200 * Normally you should not use this constructor directly unless you registered
201 * custom opcodes. For the default opcodes firm provides specific constructors.
203 * @param db Debug info.
204 * @param irg IR-graph on with this new node should be constructed.
205 * @param block The block the new node belongs to
206 * @param op The opcode of the new node.
207 * @param mode The mode of the new node.
208 * @param arity The arity of the new node, <0 if can be changed dynamically.
209 * @param in An array of arity predecessor nodes.
211 FIRM_API ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
212 ir_op *op, ir_mode *mode,
213 int arity, ir_node *const *in);
216 * Returns the block the node belongs to. This is only
217 * possible for pinned nodes or if the graph is in pinned state.
218 * Otherwise the block may be incorrect. This condition is
219 * now checked by an assertion.
221 * This works for all except Block. It can return Blocks or the Bad node.
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 FIRM_API ir_node *get_nodes_block(const ir_node *node);
228 /** Sets the Block of a node. */
229 FIRM_API void set_nodes_block(ir_node *node, ir_node *block);
237 * Returns the position of the predecessor block pred in the inputs
238 * of the block block.
240 * @param block the block
241 * @param pred a predecessor block of block
243 * @return the position of pred in block or -1
245 FIRM_API int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
248 * Returns the predecessor block.
250 * Returns the block corresponding to the predecessor pos of block.
252 * If we encounter the Bad node, this function does not return Start block, but
255 FIRM_API ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
257 /** Returns the matured flag of a block */
258 FIRM_API int get_Block_matured(const ir_node *block);
259 /** set the matured flag of a block. */
260 FIRM_API void set_Block_matured(ir_node *block, int matured);
262 /** A visited flag only for block nodes.
263 * @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
264 FIRM_API ir_visited_t get_Block_block_visited(const ir_node *block);
265 /** set block visited flag */
266 FIRM_API void set_Block_block_visited(ir_node *block, ir_visited_t visit);
268 /** Marks a block as visited by setting its visited counter */
269 FIRM_API void mark_Block_block_visited(ir_node *node);
270 /** Returns 1 if a block is marked as visited */
271 FIRM_API int Block_block_visited(const ir_node *node);
273 /** Returns the ir_graph this Block belongs to. */
274 FIRM_API ir_graph *get_Block_irg(const ir_node *block);
275 /** Returns the entity for a Block (creating it if necessary) */
276 FIRM_API ir_entity *create_Block_entity(ir_node *block);
277 /** Returns the head of the Phi list for this block. */
278 FIRM_API ir_node *get_Block_phis(const ir_node *block);
279 /** Sets the head of the Phi list for this block. */
280 FIRM_API void set_Block_phis(ir_node *block, ir_node *phi);
281 /** Add a Phi node to the list of Block Phi's. */
282 FIRM_API void add_Block_phi(ir_node *block, ir_node *phi);
283 /** Returns the Block mark (single bit). */
284 FIRM_API unsigned get_Block_mark(const ir_node *block);
285 /** Sets the Block mark (single bit). */
286 FIRM_API void set_Block_mark(ir_node *block, unsigned mark);
290 /** Tests whether arbitrary node is frame pointer.
292 * Tests whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
293 * from Start. If so returns frame type, else Null. */
294 FIRM_API ir_type *is_frame_pointer(const ir_node *n);
300 /** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
301 FIRM_API void add_End_keepalive(ir_node *end, ir_node *ka);
304 * Sets new keep-alives.
305 * Beware: This might be an expensive operation if dynamic edges are enabled,
306 * so avoid it in the backend.
308 FIRM_API void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
310 /** Removes irn from the keep-alive set. */
311 FIRM_API void remove_End_keepalive(ir_node *end, ir_node *irn);
313 /** Removes Bads, NoMem and doublets from the keep-alive set. */
314 FIRM_API void remove_End_Bads_and_doublets(ir_node *end);
316 /** Some parts of the End node are allocated separately -- their memory
317 * is not recovered by dead_node_elimination if a End node is dead.
318 * free_End() frees these data structures.
320 FIRM_API void free_End(ir_node *end);
324 /** @addtogroup Const
328 /** Returns non-zero if the given Const node represents the 0 constant. */
329 FIRM_API int is_Const_null(const ir_node *node);
331 /** Returns non-zero if the given Const node represents the 1 constant. */
332 FIRM_API int is_Const_one(const ir_node *node);
334 /** Returns non-zero if the given Const node represents the constant with all bits set. */
335 FIRM_API int is_Const_all_one(const ir_node *node);
340 * @addtogroup SymConst
345 * Returns true if node is a SymConst node with kind symconst_addr_ent.
347 FIRM_API int is_SymConst_addr_ent(const ir_node *node);
349 /** Returns non-zero if s symconst kind has a type attribute */
350 #define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)
352 /** Returns non-zero if s symconst kind has an entity attribute */
353 #define SYMCONST_HAS_ENT(kind) ((kind) == symconst_addr_ent || (kind) == symconst_ofs_ent)
355 /** Returns non-zero if s symconst kind has an enum_const attribute */
356 #define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)
358 /** Returns the kind of the SymConst. */
359 FIRM_API symconst_kind get_SymConst_kind(const ir_node *node);
360 /** Sets the kind of the SymConst. */
361 FIRM_API void set_SymConst_kind(ir_node *node, symconst_kind num);
363 /** Returns the type attribute of SymConst node @p node.
364 * @note Only to access SymConst of kind type_siz, else assertion.
366 FIRM_API ir_type *get_SymConst_type(const ir_node *node);
367 /** Sets the type attribute of SymConst node @p node. */
368 FIRM_API void set_SymConst_type(ir_node *node, ir_type *tp);
370 /** Returns the entity attribute of SymConst node @p node.
371 * @note Only to access SymConst of kind addr_ent, else assertion.
373 FIRM_API ir_entity *get_SymConst_entity(const ir_node *node);
374 /** Sets the entity attribute of Symconst node @p node. */
375 FIRM_API void set_SymConst_entity(ir_node *node, ir_entity *ent);
377 /** Returns the enum attribute of SymConst node @p node.
378 * Only to access SymConst of kind symconst_enum_const, else assertion
380 FIRM_API ir_enum_const *get_SymConst_enum(const ir_node *node);
381 /** Sets the enum attribute of SymConst node @p node. */
382 FIRM_API void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
384 /** Returns the symbol attribute of SymConst node @p node. */
385 FIRM_API union symconst_symbol get_SymConst_symbol(const ir_node *node);
386 /** Sets the symbol attribute of SymConst node @p node. */
387 FIRM_API void set_SymConst_symbol(ir_node *node, union symconst_symbol sym);
395 /** Sets, get and remove the callee information for a Call node.
397 * The callee information lists all method entities that can be called
398 * from this node. If the address expression can not be analyzed fully,
399 * e.g., as entities can be called that are not in the compilation unit,
400 * the array contains the unknown_entity. The array contains only entities
401 * with peculiarity_existent, but with all kinds of visibility. The entities
402 * not necessarily contain an irg.
404 * The array is only accessible if callee information is valid. See flag
407 * The memory allocated for the array is managed automatically, i.e., it must
408 * not be freed if the Call node is removed from the graph.
410 * @param node A Call node.
412 FIRM_API int Call_has_callees(const ir_node *node);
413 /** Returns the number of callees of Call node @p node. */
414 FIRM_API size_t get_Call_n_callees(const ir_node *node);
415 /** Returns callee number @p pos of Call node @p node. */
416 FIRM_API ir_entity *get_Call_callee(const ir_node *node, size_t pos);
418 /** Sets the full callee array.
420 * The passed array is copied. */
421 FIRM_API void set_Call_callee_arr(ir_node *node, size_t n, ir_entity **arr);
422 /** Frees callee array of call node @p node */
423 FIRM_API void remove_Call_callee_arr(ir_node *node);
427 /** Returns a human readable string for the ir_builtin_kind. */
428 FIRM_API const char *get_builtin_kind_name(ir_builtin_kind kind);
430 /** Tests whether node is an unary operation (opcode arity is #oparity_unary)
431 * @returns 1 if @p node is an unary operation, 0 otherwise
433 FIRM_API int is_unop(const ir_node *node);
434 /** Returns (arithmetic) operand of unary operation @p node. */
435 FIRM_API ir_node *get_unop_op(const ir_node *node);
436 /** Sets (arithmetic) operand of unary operation @p node. */
437 FIRM_API void set_unop_op(ir_node *node, ir_node *op);
439 /** Tests whether node is a binary operation (opcode arity is #oparity_binary)
440 * @returns 1 if @p node is an binary operation, 0 otherwise
442 FIRM_API int is_binop(const ir_node *node);
443 /** Returns left operand of binary operation @p node. */
444 FIRM_API ir_node *get_binop_left(const ir_node *node);
445 /** Sets left operand of binary operation @p node. */
446 FIRM_API void set_binop_left(ir_node *node, ir_node *left);
447 /** Returns rights operand of binary operation @p node. */
448 FIRM_API ir_node *get_binop_right(const ir_node *node);
449 /** Sets right operand of binary operation @p node. */
450 FIRM_API void set_binop_right(ir_node *node, ir_node *right);
453 * Tests whether a node is the X_except Proj of a fragile operation
455 FIRM_API int is_x_except_Proj(const ir_node *node);
458 * Tests whether a node is the X_regular Proj of a fragile operation
460 FIRM_API int is_x_regular_Proj(const ir_node *node);
463 * Sets throws exception attribute of a fragile node
464 * @p throws_exception must be 0 or 1
466 FIRM_API void ir_set_throws_exception(ir_node *node, int throws_exception);
468 /** Returns throws_exception attribute of a fragile node */
469 FIRM_API int ir_throws_exception(const ir_node *node);
471 /** Returns the name of an ir_relation */
472 FIRM_API const char *get_relation_string(ir_relation relation);
474 /** Calculates the negated (Complement(R)) relation, i.e. "<" --> ">=" */
475 FIRM_API ir_relation get_negated_relation(ir_relation relation);
477 /** Calculates the inversed (R^-1) relation, i.e., "<" --> ">" */
478 FIRM_API ir_relation get_inversed_relation(ir_relation relation);
486 * Returns the next element of a block phi list.
488 FIRM_API ir_node *get_Phi_next(const ir_node *phi);
490 * Sets the next link of a block Phi list.
492 FIRM_API void set_Phi_next(ir_node *phi, ir_node *next);
496 /** Returns true if @p node is a memory operation.
498 * A memory operation is a node with an opcode that has irop_flag_uses_memory
499 * set. It is guaranteed to have (exactly) one memory input.
501 FIRM_API int is_memop(const ir_node *node);
503 * Returns the memory input of a memory operation.
505 FIRM_API ir_node *get_memop_mem(const ir_node *node);
507 * Sets the memory input of a memory operation.
509 FIRM_API void set_memop_mem(ir_node *node, ir_node *mem);
515 /** Adds @p pred to predecessor list of Sync node @p node. */
516 FIRM_API void add_Sync_pred(ir_node *node, ir_node *pred);
517 /** Removes predecessor i from Sync n */
518 FIRM_API void del_Sync_n(ir_node *n, int i);
523 * Returns non-zero if a node is a routine parameter.
525 * @param node the Proj node to test
527 FIRM_API int is_arg_Proj(const ir_node *node);
533 /** Returns the number of output constraints for an ASM node. */
534 FIRM_API size_t get_ASM_n_output_constraints(const ir_node *node);
535 /** Returns the number of clobbered registers for an ASM node. */
536 FIRM_API size_t get_ASM_n_clobbers(const ir_node *node);
540 /** Returns operand of node if node is a Proj. */
541 FIRM_API ir_node *skip_Proj(ir_node *node);
542 /** Returns operand of node if node is a Proj. */
543 FIRM_API const ir_node *skip_Proj_const(const ir_node *node);
544 /** Returns operand of node if node is a Id. */
545 FIRM_API ir_node *skip_Id(ir_node *node);
546 /** Returns corresponding operand of Tuple if node is a Proj from a Tuple. */
547 FIRM_API ir_node *skip_Tuple(ir_node *node);
548 /** Returns operand of node if node is a Pin. */
549 FIRM_API ir_node *skip_Pin(ir_node *node);
550 /** Returns operand of node if node is a Confirm */
551 FIRM_API ir_node *skip_Confirm(ir_node *node);
552 /** Skip all high-level Operations (including Confirm). */
553 FIRM_API ir_node *skip_HighLevel_ops(ir_node *node);
554 /** Returns true if the operation manipulates control flow */
555 FIRM_API int is_cfop(const ir_node *node);
556 /** Returns true if the operation jumps to an unknown destination.
557 * See irop_flag_unknown_jump for a detailed explanation */
558 FIRM_API int is_unknown_jump(const ir_node *node);
561 * Returns true if the operation can change the control flow because
562 * of an exception: Call, Div, Mod, Load, Store, Alloc,
563 * Bad. Raise is not fragile, but a unconditional jump.
565 FIRM_API int is_fragile_op(const ir_node *node);
567 /** Returns true if the operation is a forking control flow
568 * operation: Cond. */
569 FIRM_API int is_irn_forking(const ir_node *node);
572 * Copies attributes stored in the old node to a new node.
573 * Assumes both have the same opcode and sufficient size.
575 * @param irg The irg of the new_node (get_irn_irg on it might not work
577 * @param old_node the node where the attributes are copied from
578 * @param new_node node the attributes get copies to.
580 * This copies all essential information to the new node. It does not copy
581 * temporary or calculated information like visited flags or results of
582 * dominance or loop calculations.
584 FIRM_API void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
586 /** Returns the type attribute of a node n (SymConst, Call, Alloc, Free)
588 FIRM_API ir_type *get_irn_type_attr(ir_node *n);
590 /** Returns the entity attribute of a node n (SymConst, Sel) or NULL. */
591 FIRM_API ir_entity *get_irn_entity_attr(ir_node *n);
593 /** Returns non-zero for constant-like nodes. */
594 FIRM_API int is_irn_constlike(const ir_node *node);
597 * Returns non-zero for nodes that are allowed to have keep-alives and
598 * are neither Block nor PhiM.
600 FIRM_API int is_irn_keep(const ir_node *node);
603 * Returns non-zero for nodes that are always placed in the start block.
605 FIRM_API int is_irn_start_block_placed(const ir_node *node);
608 * Returns non-zero for nodes that are CSE neutral to its users.
610 FIRM_API int is_irn_cse_neutral(const ir_node *node);
612 /** Returns the string representation of the jump prediction. */
613 FIRM_API const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
616 * Returns a pointer to the node attributes.
617 * Used for accessing attributes of user-defined nodes.
619 FIRM_API void *get_irn_generic_attr(ir_node *node);
621 * Returns a pointer to the node attributes.
622 * Used for accessing attributes of user-defined nodes.
624 FIRM_API const void *get_irn_generic_attr_const(const ir_node *node);
627 * Returns the unique node index for the node in its graph.
628 * This index is used to access phase information for this node.
631 FIRM_API unsigned get_irn_idx(const ir_node *node);
634 * Sets the debug information of a node.
637 * @param db The debug info.
639 FIRM_API void set_irn_dbg_info(ir_node *n, dbg_info *db);
642 * Returns the debug information of an node.
646 FIRM_API dbg_info *get_irn_dbg_info(const ir_node *n);
649 * Returns a descriptive name of a node (containing type+number)
651 FIRM_API const char *gdb_node_helper(void *firm_object);
659 * Creates a new switch_table datastructure with @p n_entries entries.
660 * The datastructure is allocated on the obstack of @p irg.
662 FIRM_API ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries);
665 * Returns number of entries available in switch table @p table.
667 FIRM_API size_t ir_switch_table_get_n_entries(const ir_switch_table *table);
670 * Sets entry number @p entry in the switch table @p table.
671 * @param table the switch table
672 * @param entry entry number to set
673 * @param min The minimum tarval that matches this entry
674 * @param max The maximum tarval that matches this entry
675 * @param pn Proj number taken on match
677 FIRM_API void ir_switch_table_set(ir_switch_table *table, size_t entry,
678 ir_tarval *min, ir_tarval *max, long pn);
680 /** Returns maximum tarval value of switch table entry @p entry */
681 FIRM_API ir_tarval *ir_switch_table_get_max(const ir_switch_table *table,
684 /** Returns minimum tarval value of switch table entry @p entry */
685 FIRM_API ir_tarval *ir_switch_table_get_min(const ir_switch_table *table,
688 /** Returns proj number taken if switch table entry @p entry matches */
689 FIRM_API long ir_switch_table_get_pn(const ir_switch_table *table, size_t entry);
691 /** Duplicates switch table @p table on obstack of @p irg */
692 FIRM_API ir_switch_table *ir_switch_table_duplicate(ir_graph *irg, const ir_switch_table *table);