2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Representation of an intermediate operation.
23 * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
25 #ifndef FIRM_IR_IRNODE_H
26 #define FIRM_IR_IRNODE_H
30 #include "firm_common.h"
39 * @defgroup ir_node Nodes
41 * ir_node - a datatype representing a Firm node
43 * The common fields are:
45 * - arity - The number of predecessors in the Firm graph.
46 * - in - A list with the predecessors in the Firm graph. There are
47 * routines to access individual elements and to obtain the
48 * array. The method returning the array should not be used.
49 * - mode - The mode of the node. There are routines to get the mode
50 * but also to access the mode's fields directly.
51 * - opcode - The opcode of the node. There are routines to get the opcode
52 * but also to access the opcode's fields directly.
53 * - node_nr - A unique number for the node. Available only if debugging
59 * Checks whether a pointer points to a ir node. This is guessed by looking
60 * at the few bytes of the thing. Most things used in firm have a firm_kind
61 * attribute there. This function might falsely return true though for things
62 * without a firm_kind at the beginning.
64 * @param thing an arbitrary pointer
65 * @return non-zero if the thing is a ir mode, else zero
67 FIRM_API int is_ir_node(const void *thing);
70 * Returns the number of predecessors without the block predecessor.
72 * @param node the IR-node
74 FIRM_API int get_irn_arity(const ir_node *node);
77 * Returns the n-th predecessor of a node.
78 * This function removes Id predecessors.
80 FIRM_API ir_node *get_irn_n(const ir_node *node, int n);
83 * Replaces the old in array by a new one that will contain the ins given in
84 * the parameters. Conserves the block predecessor. It copies the array passed.
85 * This function is necessary to adjust in arrays of blocks, calls and phis.
86 * "in" must contain all predecessors except the block that are required for
87 * the nodes opcode. */
88 FIRM_API void set_irn_in(ir_node *node, int arity, ir_node *in[]);
91 * Add an artificial dependency to the node.
93 * @param node The node.
94 * @param dep The dependency target.
96 FIRM_API void add_irn_dep(ir_node *node, ir_node *dep);
99 * Copy all dependencies from a node to another.
100 * This is only allowed in phase_backend!
102 * @param tgt The node which should be enriched.
103 * @param src The node whose dependencies shall be copied.
105 FIRM_API void add_irn_deps(ir_node *tgt, ir_node *src);
108 * Returns the length of the dependency array.
109 * @param node The node.
110 * @return The length of the dependency array or 0 if it has not yet been allocated.
112 FIRM_API int get_irn_deps(const ir_node *node);
115 * Returns an entry of the dependency array.
116 * @param node The node.
117 * @param pos The position.
118 * @return The node at that position.
120 FIRM_API ir_node *get_irn_dep(const ir_node *node, int pos);
123 * Sets an entry of the dependency array.
124 * @param node The node.
125 * @param pos The position.
126 * @param dep The dependency target.
128 FIRM_API void set_irn_dep(ir_node *node, int pos, ir_node *dep);
131 * Deletes the entry of the dependency array, that points to dep. Does nothing
132 * if no dependency exists.
134 * @param node the node to delete the dependency at
135 * @param dep the target of the dependency to delete
137 FIRM_API void delete_irn_dep(ir_node *node, ir_node *dep);
139 /** Replaces the n-th predecessor of a node with a new one. */
140 FIRM_API void set_irn_n(ir_node *node, int n, ir_node *in);
142 * Appends a new predecessor to a node. This only works for nodes with
144 * @returns the number of the new input
146 FIRM_API int add_irn_n(ir_node *node, ir_node *in);
147 /** Sets the mode struct of node. */
148 FIRM_API void set_irn_mode(ir_node *node, ir_mode *mode);
149 /** Returns the mode struct of a node. */
150 FIRM_API ir_mode *get_irn_mode(const ir_node *node);
151 /** Returns the opcode struct of the node. */
152 FIRM_API ir_op *get_irn_op(const ir_node *node);
153 /** Sets the opcode struct of the node. */
154 FIRM_API void set_irn_op(ir_node *node, ir_op *op);
155 /** Returns the opcode-enum of the node. */
156 FIRM_API unsigned get_irn_opcode(const ir_node *node);
157 /** Returns the string representation of the opcode. */
158 FIRM_API const char *get_irn_opname(const ir_node *node);
159 /** Returns the ident for a string representation of the opcode. */
160 FIRM_API ident *get_irn_opident(const ir_node *node);
161 /** Returns the visited counter of a node. */
162 FIRM_API ir_visited_t get_irn_visited(const ir_node *node);
163 /** Sets the visited counter of a node. */
164 FIRM_API void set_irn_visited(ir_node *node, ir_visited_t visited);
165 /** Sets visited to get_irg_visited(get_irn_irg(node)). */
166 FIRM_API void mark_irn_visited(ir_node *node);
167 /** Returns 1 if visited >= get_irg_visited(get_irn_irg(node)). */
168 FIRM_API int irn_visited(const ir_node *node);
169 /** Returns 1 if visited >= get_irg_visited(get_irn_irg(node)). Marks the node
170 * visited, if it was not. */
171 FIRM_API int irn_visited_else_mark(ir_node *node);
174 * Sets the link of a node.
175 * Only allowed if the graph is NOT in phase_building.
177 FIRM_API void set_irn_link(ir_node *node, void *link);
179 /** Returns the link of a node. */
180 FIRM_API void *get_irn_link(const ir_node *node);
182 /** Returns the ir_graph this node belongs to. */
183 FIRM_API ir_graph *get_irn_irg(const ir_node *node);
185 /** Outputs a unique number for this node if libFIRM is compiled for
186 debugging, (configure with --enable-debug) else returns address
187 of node cast to long. */
188 FIRM_API long get_irn_node_nr(const ir_node *node);
190 /** Returns the pinned state of a node.
192 * Returns whether the node _always_ must be pinned.
193 * I.e., the node is not floating after global cse.
195 * @returns Either state op_pin_state_pinned or op_pin_state_floats.
197 FIRM_API op_pin_state get_irn_pinned(const ir_node *node);
199 /** Sets pin state for nodes with op pin state op_pin_state_exc_pinned */
200 FIRM_API void set_irn_pinned(ir_node *node, op_pin_state state);
202 /** Returns whether the node is currently pinned.
204 * If get_irn_pinned returns op_pin_state_floats and the graph the
205 * node belongs to is in state op_poin_state_floats then this function
206 * returns 'floats', else 'pinned'.
208 FIRM_API op_pin_state is_irn_pinned_in_irg(const ir_node *node);
211 * IR node constructor.
212 * Create a new IR node in irg, with an op, mode, arity and
213 * some incoming IR nodes.
214 * This constructor is used in every specific IR node constructor.
216 * @param db Debug info.
217 * @param irg IR-graph on with this new node should be constructed.
218 * @param block The block the new node belongs to
219 * @param op The opcode of the new node.
220 * @param mode The mode of the new node.
221 * @param arity The arity of the new node, <0 if can be changed dynamically.
222 * @param in An array of arity predecessor nodes.
224 FIRM_API ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
225 ir_op *op, ir_mode *mode,
226 int arity, ir_node *const *in);
234 * Returns the block the node belongs to. This is only
235 * possible for pinned nodes or if the graph is in pinned state.
236 * Otherwise the block may be incorrect. This condition is
237 * now checked by an assertion.
239 * This works for all except Block. It can return Blocks or the Bad node.
241 * To express the difference to access routines that work for all
242 * nodes we use infix "nodes" and do not name this function
243 * get_irn_block(). */
244 FIRM_API ir_node *get_nodes_block(const ir_node *node);
246 /** Sets the Block of a node. */
247 FIRM_API void set_nodes_block(ir_node *node, ir_node *block);
249 /** Returns the number of control flow predecessors of a block. */
250 FIRM_API int get_Block_n_cfgpreds(const ir_node *block);
251 /** Returns the control flow predecessor of a block at a given position. */
252 FIRM_API ir_node *get_Block_cfgpred(const ir_node *block, int pos);
253 /** Sets the control flow predecessor of a block at a given position. */
254 FIRM_API void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);
257 * Returns the position of the predecessor block pred in the inputs
258 * of the block block.
260 * @param block the block
261 * @param pred a predecessor block of block
263 * @return the position of pred in block or -1
265 FIRM_API int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
267 /** Returns the predecessor block.
269 * Returns the block corresponding to the predecessor pos of block.
271 * There are several ambiguities we resolve with this function:
272 * - The direct predecessor can be a Proj, which is not pinned.
273 * We walk from the predecessor to the next pinned node
274 * (skip_Proj) and return the block that node is in.
275 * - If we encounter the Bad node, this function does not return
276 * Start block, but the Bad node.
278 FIRM_API ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
280 /** Returns the matured flag of a block */
281 FIRM_API int get_Block_matured(const ir_node *block);
282 /** set the matured flag of a block. */
283 FIRM_API void set_Block_matured(ir_node *block, int matured);
285 /** A visited flag only for block nodes.
286 * @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
287 FIRM_API ir_visited_t get_Block_block_visited(const ir_node *block);
288 /** set block visited flag */
289 FIRM_API void set_Block_block_visited(ir_node *block, ir_visited_t visit);
291 /** Marks a block as visited by setting its visited counter */
292 FIRM_API void mark_Block_block_visited(ir_node *node);
293 /** Returns 1 if a block is marked as visited */
294 FIRM_API int Block_block_visited(const ir_node *node);
296 /** Returns the ir_graph this Block belongs to. */
297 FIRM_API ir_graph *get_Block_irg(const ir_node *block);
298 /** Returns the entity for a Block (creating it if necessary) */
299 FIRM_API ir_entity *create_Block_entity(ir_node *block);
300 /** Returns the head of the Phi list for this block. */
301 FIRM_API ir_node *get_Block_phis(const ir_node *block);
302 /** Sets the head of the Phi list for this block. */
303 FIRM_API void set_Block_phis(ir_node *block, ir_node *phi);
304 /** Add a Phi node to the list of Block Phi's. */
305 FIRM_API void add_Block_phi(ir_node *block, ir_node *phi);
306 /** Returns the Block mark (single bit). */
307 FIRM_API unsigned get_Block_mark(const ir_node *block);
308 /** Sets the Block mark (single bit). */
309 FIRM_API void set_Block_mark(ir_node *block, unsigned mark);
313 /** Tests whether arbitrary node is frame pointer.
315 * Tests whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
316 * from Start. If so returns frame type, else Null. */
317 FIRM_API ir_type *is_frame_pointer(const ir_node *n);
323 /** Returns the number of Keep alive node. */
324 FIRM_API int get_End_n_keepalives(const ir_node *end);
325 /** Returns the Keep alive node a position pos. */
326 FIRM_API ir_node *get_End_keepalive(const ir_node *end, int pos);
327 /** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
328 FIRM_API void add_End_keepalive(ir_node *end, ir_node *ka);
329 /** Sets the Keep alive node at position pos. */
330 FIRM_API void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
333 * Sets new keep-alives.
334 * Beware: This might be an expensive operation if dynamic edges are enabled,
335 * so avoid it in the backend.
337 FIRM_API void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
339 /** Removes irn from the keep-alive set. */
340 FIRM_API void remove_End_keepalive(ir_node *end, ir_node *irn);
342 /** Removes Bads, NoMem and doublets from the keep-alive set. */
343 FIRM_API void remove_End_Bads_and_doublets(ir_node *end);
345 /** Some parts of the End node are allocated separately -- their memory
346 * is not recovered by dead_node_elimination if a End node is dead.
347 * free_End() frees these data structures.
349 FIRM_API void free_End(ir_node *end);
353 /** @addtogroup Return
357 /** Returns return value inputs of Return node @p node as array. */
358 FIRM_API ir_node **get_Return_res_arr(ir_node *node);
359 /** Returns number of return value inputs of Return node @p node. */
360 FIRM_API size_t get_Return_n_ress(const ir_node *node);
361 /** Returns return value input @p pos of Return node @p node. */
362 FIRM_API ir_node *get_Return_res(const ir_node *node, int pos);
363 /** Sets return value input @p pos of Return node @p node to value @p res. */
364 FIRM_API void set_Return_res(ir_node *node, int pos, ir_node *res);
368 /** @addtogroup Const
372 /** Returns non-zero if the given Const node represents the 0 constant. */
373 FIRM_API int is_Const_null(const ir_node *node);
375 /** Returns non-zero if the given Const node represents the 1 constant. */
376 FIRM_API int is_Const_one(const ir_node *node);
378 /** Returns non-zero if the given Const node represents the constant with all bits set. */
379 FIRM_API int is_Const_all_one(const ir_node *node);
384 * @addtogroup SymConst
389 * Returns true if node is a SymConst node with kind symconst_addr_ent.
391 FIRM_API int is_SymConst_addr_ent(const ir_node *node);
393 /** Returns non-zero if s symconst kind has a type attribute */
394 #define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)
396 /** Returns non-zero if s symconst kind has an entity attribute */
397 #define SYMCONST_HAS_ENT(kind) ((kind) == symconst_addr_ent || (kind) == symconst_ofs_ent)
399 /** Returns non-zero if s symconst kind has an enum_const attribute */
400 #define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)
402 /** Returns the kind of the SymConst. */
403 FIRM_API symconst_kind get_SymConst_kind(const ir_node *node);
404 /** Sets the kind of the SymConst. */
405 FIRM_API void set_SymConst_kind(ir_node *node, symconst_kind num);
407 /** Returns the type attribute of SymConst node @p node.
408 * @note Only to access SymConst of kind type_siz, else assertion.
410 FIRM_API ir_type *get_SymConst_type(const ir_node *node);
411 /** Sets the type attribute of SymConst node @p node. */
412 FIRM_API void set_SymConst_type(ir_node *node, ir_type *tp);
414 /** Returns the entity attribute of SymConst node @p node.
415 * @note Only to access SymConst of kind addr_ent, else assertion.
417 FIRM_API ir_entity *get_SymConst_entity(const ir_node *node);
418 /** Sets the entity attribute of Symconst node @p node. */
419 FIRM_API void set_SymConst_entity(ir_node *node, ir_entity *ent);
421 /** Returns the enum attribute of SymConst node @p node.
422 * Only to access SymConst of kind symconst_enum_const, else assertion
424 FIRM_API ir_enum_const *get_SymConst_enum(const ir_node *node);
425 /** Sets the enum attribute of SymConst node @p node. */
426 FIRM_API void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
428 /** Returns the symbol attribute of SymConst node @p node. */
429 FIRM_API union symconst_symbol get_SymConst_symbol(const ir_node *node);
430 /** Sets the symbol attribute of SymConst node @p node. */
431 FIRM_API void set_SymConst_symbol(ir_node *node, union symconst_symbol sym);
439 /** Returns index inputs of Sel node @p node as array. */
440 FIRM_API ir_node **get_Sel_index_arr(ir_node *node);
441 /** Returns number of index inputs of Sel node @p node. */
442 FIRM_API int get_Sel_n_indexs(const ir_node *node);
443 /** Returns value of index input @p pos of Sel node @p node. */
444 FIRM_API ir_node *get_Sel_index(const ir_node *node, int pos);
445 /** Sets @p index as index input @p pos of Sel node @p node. */
446 FIRM_API void set_Sel_index(ir_node *node, int pos, ir_node *index);
454 /** Returns parameter inputs of Call node @p node as array. */
455 FIRM_API ir_node **get_Call_param_arr(ir_node *node);
456 /** Returns the number of parameters of a call. */
457 FIRM_API int get_Call_n_params(const ir_node *node);
458 /** Returns the call parameter at position pos. */
459 FIRM_API ir_node *get_Call_param(const ir_node *node, int pos);
460 /** Sets the call parameter at position pos. */
461 FIRM_API void set_Call_param(ir_node *node, int pos, ir_node *param);
463 /** Sets, get and remove the callee information for a Call node.
465 * The callee information lists all method entities that can be called
466 * from this node. If the address expression can not be analyzed fully,
467 * e.g., as entities can be called that are not in the compilation unit,
468 * the array contains the unknown_entity. The array contains only entities
469 * with peculiarity_existent, but with all kinds of visibility. The entities
470 * not necessarily contain an irg.
472 * The array is only accessible if callee information is valid. See flag
475 * The memory allocated for the array is managed automatically, i.e., it must
476 * not be freed if the Call node is removed from the graph.
478 * @param node A Call node.
480 FIRM_API int Call_has_callees(const ir_node *node);
481 /** Returns the number of callees of Call node @p node. */
482 FIRM_API size_t get_Call_n_callees(const ir_node *node);
483 /** Returns callee number @p pos of Call node @p node. */
484 FIRM_API ir_entity *get_Call_callee(const ir_node *node, size_t pos);
486 /** Sets the full callee array.
488 * The passed array is copied. */
489 FIRM_API void set_Call_callee_arr(ir_node *node, size_t n, ir_entity **arr);
490 /** Frees callee array of call node @p node */
491 FIRM_API void remove_Call_callee_arr(ir_node *node);
495 /** @addtogroup Builtin
499 /** Returns the parameter inputs of Builtin node @p node as array. */
500 FIRM_API ir_node **get_Builtin_param_arr(ir_node *node);
501 /** Returns the number of parameters of a Builtin. */
502 FIRM_API int get_Builtin_n_params(const ir_node *node);
503 /** Returns the Builtin parameter at position pos. */
504 FIRM_API ir_node *get_Builtin_param(const ir_node *node, int pos);
505 /** Sets the Builtin parameter at position pos. */
506 FIRM_API void set_Builtin_param(ir_node *node, int pos, ir_node *param);
510 /** Returns a human readable string for the ir_builtin_kind. */
511 FIRM_API const char *get_builtin_kind_name(ir_builtin_kind kind);
513 /** Tests whether node is an unary operation (opcode arity is #oparity_unary)
514 * @returns 1 if @p node is an unary operation, 0 otherwise
516 FIRM_API int is_unop(const ir_node *node);
517 /** Returns (arithmetic) operand of unary operation @p node. */
518 FIRM_API ir_node *get_unop_op(const ir_node *node);
519 /** Sets (arithmetic) operand of unary operation @p node. */
520 FIRM_API void set_unop_op(ir_node *node, ir_node *op);
522 /** Tests whether node is a binary operation (opcode arity is #oparity_binary)
523 * @returns 1 if @p node is an binary operation, 0 otherwise
525 FIRM_API int is_binop(const ir_node *node);
526 /** Returns left operand of binary operation @p node. */
527 FIRM_API ir_node *get_binop_left(const ir_node *node);
528 /** Sets left operand of binary operation @p node. */
529 FIRM_API void set_binop_left(ir_node *node, ir_node *left);
530 /** Returns rights operand of binary operation @p node. */
531 FIRM_API ir_node *get_binop_right(const ir_node *node);
532 /** Sets right operand of binary operation @p node. */
533 FIRM_API void set_binop_right(ir_node *node, ir_node *right);
536 * Tests whether a node is the X_except Proj of a fragile operation
538 FIRM_API int is_x_except_Proj(const ir_node *node);
541 * Tests whether a node is the X_regular Proj of a fragile operation
543 FIRM_API int is_x_regular_Proj(const ir_node *node);
546 * Sets throws exception attribute of a fragile node
547 * @p throws_exception must be 0 or 1
549 FIRM_API void ir_set_throws_exception(ir_node *node, int throws_exception);
551 /** Returns throws_exception attribute of a fragile node */
552 FIRM_API int ir_throws_exception(const ir_node *node);
554 /** Returns the name of an ir_relation */
555 FIRM_API const char *get_relation_string(ir_relation relation);
557 /** Calculates the negated (Complement(R)) relation, i.e. "<" --> ">=" */
558 FIRM_API ir_relation get_negated_relation(ir_relation relation);
560 /** Calculates the inversed (R^-1) relation, i.e., "<" --> ">" */
561 FIRM_API ir_relation get_inversed_relation(ir_relation relation);
568 /** Checks for upcast.
570 * Returns true if the Cast node casts a class type to a super type.
571 * Works also for pointers to classes (recursively).
573 * Needs typeinfo calculated.
575 FIRM_API int is_Cast_upcast(ir_node *node);
577 /** Checks for downcast.
579 * Returns true if the Cast node casts a class type to a sub type.
580 * Works also for pointers to classes (recursively).
582 * Needs typeinfo calculated.
584 FIRM_API int is_Cast_downcast(ir_node *node);
594 * Returns all phi predecessors as array
596 FIRM_API ir_node **get_Phi_preds_arr(ir_node *node);
598 * Returns number of predecessors of phi node @p node
600 FIRM_API int get_Phi_n_preds(const ir_node *node);
602 * Returns the predecessor with number @p pos of phi node @p node.
603 * This is the value selected when control flow comes from predecessor @p pos
604 * of the containing basic block.
606 FIRM_API ir_node *get_Phi_pred(const ir_node *node, int pos);
608 * Sets value @p pred as predecessor number @p pos of phi node @p node.
610 FIRM_API void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
612 * Returns the next element of a block phi list.
614 FIRM_API ir_node *get_Phi_next(const ir_node *phi);
616 * Sets the next link of a block Phi list.
618 FIRM_API void set_Phi_next(ir_node *phi, ir_node *next);
622 /** Returns true if @p node is a memory operation.
624 * A memory operation is a node with an opcode that has irop_flag_uses_memory
625 * set. It is guaranteed to have (exactly) one memory input.
627 FIRM_API int is_memop(const ir_node *node);
629 * Returns the memory input of a memory operation.
631 FIRM_API ir_node *get_memop_mem(const ir_node *node);
633 * Sets the memory input of a memory operation.
635 FIRM_API void set_memop_mem(ir_node *node, ir_node *mem);
641 /** Returns all predecessors of Sync node @p node as array */
642 FIRM_API ir_node **get_Sync_preds_arr(ir_node *node);
643 /** Returns number of predecessors of Sync node @p node. */
644 FIRM_API int get_Sync_n_preds(const ir_node *node);
645 /** Returns predecessor number @p pos of Sync node @p node. */
646 FIRM_API ir_node *get_Sync_pred(const ir_node *node, int pos);
647 /** Sets value @p pred as predecessor number @p pos of Sync node @p node. */
648 FIRM_API void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
649 /** Adds @p pred to predecessor list of Sync node @p node. */
650 FIRM_API void add_Sync_pred(ir_node *node, ir_node *pred);
651 /** Removes predecessor i from Sync n */
652 FIRM_API void del_Sync_n(ir_node *n, int i);
657 * Returns non-zero if a node is a routine parameter.
659 * @param node the Proj node to test
661 FIRM_API int is_arg_Proj(const ir_node *node);
663 /** @addtogroup Tuple
667 /** Returns all predecessors of Tuple node @p node as array. */
668 FIRM_API ir_node **get_Tuple_preds_arr(ir_node *node);
669 /** Returns number of predecessors of Tuple node @p node. */
670 FIRM_API int get_Tuple_n_preds(const ir_node *node);
671 /** Returns predecessor number @p pos of Tuple node @p node. */
672 FIRM_API ir_node *get_Tuple_pred(const ir_node *node, int pos);
673 /** Sets value @p pred as predecessor number @p pos of Tuple node @p node. */
674 FIRM_API void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
682 /** Returns the number of input constraints for an ASM node. */
683 FIRM_API int get_ASM_n_inputs(const ir_node *node);
684 /** Returns input number @p pos of an ASM node. */
685 FIRM_API ir_node *get_ASM_input(const ir_node *node, int pos);
686 /** Returns the number of output constraints for an ASM node. */
687 FIRM_API size_t get_ASM_n_output_constraints(const ir_node *node);
688 /** Returns the number of clobbered registers for an ASM node. */
689 FIRM_API size_t get_ASM_n_clobbers(const ir_node *node);
693 /** Returns operand of node if node is a Proj. */
694 FIRM_API ir_node *skip_Proj(ir_node *node);
695 /** Returns operand of node if node is a Proj. */
696 FIRM_API const ir_node *skip_Proj_const(const ir_node *node);
697 /** Returns operand of node if node is a Id. */
698 FIRM_API ir_node *skip_Id(ir_node *node);
699 /** Returns corresponding operand of Tuple if node is a Proj from a Tuple. */
700 FIRM_API ir_node *skip_Tuple(ir_node *node);
701 /** Returns operand of node if node is a Cast. */
702 FIRM_API ir_node *skip_Cast(ir_node *node);
703 /** Returns operand of node if node is a Cast. */
704 FIRM_API const ir_node *skip_Cast_const(const ir_node *node);
705 /** Returns operand of node if node is a Pin. */
706 FIRM_API ir_node *skip_Pin(ir_node *node);
707 /** Returns operand of node if node is a Confirm */
708 FIRM_API ir_node *skip_Confirm(ir_node *node);
709 /** Skip all high-level Operations (including Cast, Confirm). */
710 FIRM_API ir_node *skip_HighLevel_ops(ir_node *node);
711 /** Returns true if the operation manipulates control flow */
712 FIRM_API int is_cfop(const ir_node *node);
713 /** Returns true if the operation jumps to an unknown destination.
714 * See irop_flag_unknown_jump for a detailed explanation */
715 FIRM_API int is_unknown_jump(const ir_node *node);
718 * Returns true if the operation can change the control flow because
719 * of an exception: Call, Div, Mod, Load, Store, Alloc,
720 * Bad. Raise is not fragile, but a unconditional jump.
722 FIRM_API int is_fragile_op(const ir_node *node);
724 /** Returns true if the operation is a forking control flow
725 * operation: Cond. */
726 FIRM_API int is_irn_forking(const ir_node *node);
729 * Copies attributes stored in the old node to a new node.
730 * Assumes both have the same opcode and sufficient size.
732 * @param irg The irg of the new_node (get_irn_irg on it might not work
734 * @param old_node the node where the attributes are copied from
735 * @param new_node node the attributes get copies to.
737 * This copies all essential information to the new node. It does not copy
738 * temporal or calculated information like visited flags or results of dominance
739 * or loop calculations
741 FIRM_API void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
743 /** Returns the type attribute of a node n (SymConst, Call, Alloc, Free,
745 FIRM_API ir_type *get_irn_type_attr(ir_node *n);
747 /** Returns the entity attribute of a node n (SymConst, Sel) or NULL. */
748 FIRM_API ir_entity *get_irn_entity_attr(ir_node *n);
750 /** Returns non-zero for constant-like nodes. */
751 FIRM_API int is_irn_constlike(const ir_node *node);
754 * Returns non-zero for nodes that are allowed to have keep-alives and
755 * are neither Block nor PhiM.
757 FIRM_API int is_irn_keep(const ir_node *node);
760 * Returns non-zero for nodes that are always placed in the start block.
762 FIRM_API int is_irn_start_block_placed(const ir_node *node);
765 * Returns non-zero for nodes that are CSE neutral to its users.
767 FIRM_API int is_irn_cse_neutral(const ir_node *node);
769 /** Returns the string representation of the jump prediction. */
770 FIRM_API const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
773 * Returns a pointer to the node attributes.
774 * Used for accessing attributes of user-defined nodes.
776 FIRM_API void *get_irn_generic_attr(ir_node *node);
778 * Returns a pointer to the node attributes.
779 * Used for accessing attributes of user-defined nodes.
781 FIRM_API const void *get_irn_generic_attr_const(const ir_node *node);
784 * Returns the unique node index for the node in its graph.
785 * This index is used to access phase information for this node.
788 FIRM_API unsigned get_irn_idx(const ir_node *node);
791 * Sets the debug information of a node.
794 * @param db The debug info.
796 FIRM_API void set_irn_dbg_info(ir_node *n, dbg_info *db);
799 * Returns the debug information of an node.
803 FIRM_API dbg_info *get_irn_dbg_info(const ir_node *n);
806 * Returns a descriptive name of a node (containing type+number)
808 FIRM_API const char *gdb_node_helper(void *firm_object);
816 * Creates a new switch_table datastructure with @p n_entries entries.
817 * The datastructure is allocated on the obstack of @p irg.
819 FIRM_API ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries);
822 * Returns number of entries available in switch table @p table.
824 FIRM_API size_t ir_switch_table_get_n_entries(const ir_switch_table *table);
827 * Sets entry number @p entry in the switch table @p table.
828 * @param table the switch table
829 * @param entry entry number to set
830 * @param min The minimum tarval that matches this entry
831 * @param max The maximum tarval that matches this entry
832 * @param pn Proj number taken on match
834 FIRM_API void ir_switch_table_set(ir_switch_table *table, size_t entry,
835 ir_tarval *min, ir_tarval *max, long pn);
837 /** Returns maximum tarval value of switch table entry @p entry */
838 FIRM_API ir_tarval *ir_switch_table_get_max(const ir_switch_table *table,
841 /** Returns minimum tarval value of switch table entry @p entry */
842 FIRM_API ir_tarval *ir_switch_table_get_min(const ir_switch_table *table,
845 /** Returns proj number taken if switch table entry @p entry matches */
846 FIRM_API long ir_switch_table_get_pn(const ir_switch_table *table, size_t entry);
848 /** Duplicates switch table @p table on obstack of @p irg */
849 FIRM_API ir_switch_table *ir_switch_table_duplicate(ir_graph *irg, const ir_switch_table *table);