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"
38 * @defgroup ir_node Declarations of an ir node.
40 * The type definition of ir_node is also in irgraph.h to resolve
41 * recursion between irnode.h and irgraph.h
43 * ir_node - a datatype representing a Firm node
45 * The common fields are:
47 * - arity - The number of predecessors in the Firm graph.
48 * - in - A list with the predecessors in the Firm graph. There are
49 * routines to access individual elements and to obtain the
50 * array. The method returning the array should not be used.
51 * - mode - The mode of the node. There are routines to get the mode
52 * but also to access the mode's fields directly.
53 * - opcode - The opcode of the node. There are routines to get the opcode
54 * but also to access the opcode's fields directly.
55 * - node_nr - A unique number for the node. Available only if debugging
61 * Checks whether a pointer points to a ir node. This is guessed by looking
62 * at the few bytes of the thing. Most things used in firm have a firm_kind
63 * attribute there. This function might falsely return true though for things
64 * without a firm_kind at the beginning.
66 * @param thing an arbitrary pointer
67 * @return non-zero if the thing is a ir mode, else zero
69 FIRM_API int is_ir_node(const void *thing);
72 * Returns the number of predecessors without the block predecessor.
74 * @param node the IR-node
76 FIRM_API int get_irn_arity(const ir_node *node);
79 * Get the n-th predecessor of a node.
80 * This function removes Id predecessors.
82 FIRM_API ir_node *get_irn_n(const ir_node *node, int n);
85 * Replaces the old in array by a new one that will contain the ins given in
86 * the parameters. Conserves the block predecessor. It copies the array passed.
87 * This function is necessary to adjust in arrays of blocks, calls and phis.
88 * Assumes that current_ir_graph is set to the graph containing "node".
89 * "in" must contain all predecessors except the block that are required for
90 * the nodes opcode. */
91 FIRM_API void set_irn_in(ir_node *node, int arity, ir_node *in[]);
94 * Add a artificial dependency to the node.
95 * The dependency is only inserted if it is not there already.
96 * This is only allowed in phase_backend!
98 * @param node The node.
99 * @param dep The dependency target.
101 * @return The index in the array (get_irn_dep with that index returns @p dep).
103 FIRM_API int add_irn_dep(ir_node *node, ir_node *dep);
106 * Copy all dependencies from a node to another.
107 * This is only allowed in phase_backend!
109 * @param tgt The node which should be enriched.
110 * @param src The node whose dependencies shall be copied.
112 FIRM_API void add_irn_deps(ir_node *tgt, ir_node *src);
115 * Get the length of the dependency array.
116 * @param node The node.
117 * @return The length of the dependency array or 0 if it has not yet been allocated.
119 FIRM_API int get_irn_deps(const ir_node *node);
122 * Get an entry of the dependency array.
123 * @param node The node.
124 * @param pos The position.
125 * @return The node at that position.
127 FIRM_API ir_node *get_irn_dep(const ir_node *node, int pos);
130 * Set an entry of the dependency array.
131 * @param node The node.
132 * @param pos The position.
133 * @param dep The dependency target.
135 FIRM_API void set_irn_dep(ir_node *node, int pos, ir_node *dep);
137 /** Replace the n-th predecessor of a node with a new one. */
138 FIRM_API void set_irn_n(ir_node *node, int n, ir_node *in);
140 * Appends a new predecessor to a node. This only works for nodes with
142 * @returns the number of the new input
144 FIRM_API int add_irn_n(ir_node *node, ir_node *in);
145 /** Remove predecessor i from Sync n */
146 FIRM_API void del_Sync_n(ir_node *n, int i);
147 /** Sets the mode struct of node. */
148 FIRM_API void set_irn_mode(ir_node *node, ir_mode *mode);
149 /** Gets the mode struct of a node. */
150 FIRM_API ir_mode *get_irn_mode(const ir_node *node);
151 /** Gets 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 /** Gets the opcode-enum of the node. */
156 FIRM_API unsigned get_irn_opcode(const ir_node *node);
157 /** Get the string representation of the opcode. */
158 FIRM_API const char *get_irn_opname(const ir_node *node);
159 /** Get the ident for a string representation of the opcode. */
160 FIRM_API ident *get_irn_opident(const ir_node *node);
161 /** If arg is an argument of the node, returns its position, -1 otherwise */
162 FIRM_API int get_irn_pred_pos(ir_node *node, ir_node *arg);
163 /** Gets the visited counter of a node. */
164 FIRM_API ir_visited_t get_irn_visited(const ir_node *node);
165 /** Sets the visited counter of a node. */
166 FIRM_API void set_irn_visited(ir_node *node, ir_visited_t visited);
167 /** Sets visited to get_irg_visited(current_ir_graph). */
168 FIRM_API void mark_irn_visited(ir_node *node);
169 /** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
170 FIRM_API int irn_visited(const ir_node *node);
171 /** Returns 1 if visited >= get_irg_visited(current_ir_graph). Marks the node
172 * visited, if it was not. */
173 FIRM_API int irn_visited_else_mark(ir_node *node);
176 * Sets the link of a node.
177 * Only allowed if the graph is NOT in phase_building.
179 FIRM_API void set_irn_link(ir_node *node, void *link);
181 /** Returns the link of a node. */
182 FIRM_API void *get_irn_link(const ir_node *node);
184 /** Returns the ir_graph this node belongs to. */
185 FIRM_API ir_graph *get_irn_irg(const ir_node *node);
187 /** Outputs a unique number for this node if libFIRM is compiled for
188 debugging, (configure with --enable-debug) else returns address
189 of node cast to long. */
190 FIRM_API long get_irn_node_nr(const ir_node *node);
192 /** Returns the pinned state of a node.
194 * Returns whether the node _always_ must be pinned.
195 * I.e., the node is not floating after global cse.
197 * @returns Either state op_pin_state_pinned or op_pin_state_floats.
199 FIRM_API op_pin_state get_irn_pinned(const ir_node *node);
201 /** Set pin state for nodes with op pin state op_pin_state_exc_pinned */
202 FIRM_API void set_irn_pinned(ir_node *node, op_pin_state state);
204 /** Returns whether the node is currently pinned.
206 * If get_irn_pinned returns op_pin_state_floats and the graph the
207 * node belongs to is in state op_poin_state_floats then this function
208 * returns 'floats', else 'pinned'.
210 FIRM_API op_pin_state is_irn_pinned_in_irg(const ir_node *node);
213 * IR node constructor.
214 * Create a new IR node in irg, with an op, mode, arity and
215 * some incoming IR nodes.
216 * This constructor is used in every specific IR node constructor.
218 * @param db Debug info.
219 * @param irg IR-graph on with this new node should be constructed.
220 * @param block The block the new node belongs to
221 * @param op The opcode of the new node.
222 * @param mode The mode of the new node.
223 * @param arity The arity of the new node, <0 if can be changed dynamically.
224 * @param in An array of arity predecessor nodes.
226 FIRM_API ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
227 ir_op *op, ir_mode *mode,
228 int arity, ir_node *const *in);
231 * Return the block the node belongs to. This is only
232 * possible for pinned nodes or if the graph is in pinned state.
233 * Otherwise the block may be incorrect. This condition is
234 * now checked by an assertion.
236 * This works for all except Block. It can return Blocks or the Bad node.
238 * To express the difference to access routines that work for all
239 * nodes we use infix "nodes" and do not name this function
240 * get_irn_block(). */
241 FIRM_API ir_node *get_nodes_block(const ir_node *node);
243 /** Sets the Block of a node. */
244 FIRM_API void set_nodes_block(ir_node *node, ir_node *block);
246 /** Test whether arbitrary node is frame pointer.
248 * Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
249 * from Start. If so returns frame type, else Null. */
250 FIRM_API ir_type *is_frame_pointer(const ir_node *n);
252 /** Return the number of control flow predecessors of a block. */
253 FIRM_API int get_Block_n_cfgpreds(const ir_node *block);
254 /** Return the control flow predecessor of a block at a given position. */
255 FIRM_API ir_node *get_Block_cfgpred(const ir_node *block, int pos);
256 /** Set the control flow predecessor of a block at a given position. */
257 FIRM_API void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);
260 * Return the position of the predecessor block pred in the inputs
261 * of the block block.
263 * @param block the block
264 * @param pred a predecessor block of block
266 * @return the position of pred in block or -1
268 * @note When using the old extended basic block form for blocks
269 * with exception exists, a predecessor block might have more
270 * than one position. In that case it is not specified, with is returned.
272 FIRM_API int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
274 /** Get the predecessor block.
276 * Returns the block corresponding to the predecessor pos of block.
278 * There are several ambiguities we resolve with this function:
279 * - The direct predecessor can be a Proj, which is not pinned.
280 * We walk from the predecessor to the next pinned node
281 * (skip_Proj) and return the block that node is in.
282 * - If we encounter the Bad node, this function does not return
283 * Start block, but the Bad node.
285 FIRM_API ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
287 /** Return the matured flag of a block */
288 FIRM_API int get_Block_matured(const ir_node *block);
289 /** set the matured flag of a block. */
290 FIRM_API void set_Block_matured(ir_node *block, int matured);
292 /** A visited flag only for block nodes.
293 * @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
294 FIRM_API ir_visited_t get_Block_block_visited(const ir_node *block);
295 /** set block visited flag */
296 FIRM_API void set_Block_block_visited(ir_node *block, ir_visited_t visit);
298 /** mark a block as visited by setting its visited counter */
299 FIRM_API void mark_Block_block_visited(ir_node *node);
300 /** returns 1 if a block is marked as visited */
301 FIRM_API int Block_block_visited(const ir_node *node);
303 /** Returns the extended basic block a block belongs to. */
304 FIRM_API ir_extblk *get_Block_extbb(const ir_node *block);
305 /** Sets the extended basic block a block belongs to. */
306 FIRM_API void set_Block_extbb(ir_node *block, ir_extblk *extblk);
307 /** Returns the ir_graph this Block belongs to. */
308 FIRM_API ir_graph *get_Block_irg(const ir_node *block);
309 /** Returns non-zero if the block has an entity assigned */
310 FIRM_API int has_Block_entity(const ir_node *block);
311 /** Returns the entity for a Block */
312 FIRM_API ir_entity *get_Block_entity(const ir_node *block);
313 /** Returns the entity for a Block (creating it if necessary) */
314 FIRM_API ir_entity *create_Block_entity(ir_node *block);
315 /** Set a new entity for a block */
316 FIRM_API void set_Block_entity(ir_node *block, ir_entity *entity);
317 /** Gets the head of the Phi list for this block. */
318 FIRM_API ir_node *get_Block_phis(const ir_node *block);
319 /** Sets the head of the Phi list for this block. */
320 FIRM_API void set_Block_phis(ir_node *block, ir_node *phi);
321 /** Add a Phi node to the list of Block Phi's. */
322 FIRM_API void add_Block_phi(ir_node *block, ir_node *phi);
323 /** Get the Block mark (single bit). */
324 FIRM_API unsigned get_Block_mark(const ir_node *block);
325 /** Set the Block mark (single bit). */
326 FIRM_API void set_Block_mark(ir_node *block, unsigned mark);
328 /** Return the number of Keep alive node. */
329 FIRM_API int get_End_n_keepalives(const ir_node *end);
330 /** Return the Keep alive node a position pos. */
331 FIRM_API ir_node *get_End_keepalive(const ir_node *end, int pos);
332 /** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
333 FIRM_API void add_End_keepalive(ir_node *end, ir_node *ka);
334 /** Set the Keep alive node at position pos. */
335 FIRM_API void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
338 * Set new keep-alives.
339 * Beware: This might be an expensive operation if dynamic edges are enabled,
340 * so avoid it in the backend.
342 FIRM_API void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
344 /** Remove irn from the keep-alive set. */
345 FIRM_API void remove_End_keepalive(ir_node *end, ir_node *irn);
347 /** Remove Bads, NoMem and doublets from the keep-alive set. */
348 FIRM_API void remove_End_Bads_and_doublets(ir_node *end);
350 /** Some parts of the End node are allocated separately -- their memory
351 is not recovered by dead_node_elimination if a End node is dead.
352 free_End() frees these data structures. */
353 FIRM_API void free_End(ir_node *end);
355 FIRM_API ir_node **get_Return_res_arr(ir_node *node);
356 FIRM_API size_t get_Return_n_ress(const ir_node *node);
357 FIRM_API ir_node *get_Return_res(const ir_node *node, int pos);
358 FIRM_API void set_Return_res(ir_node *node, int pos, ir_node *res);
360 /** Return non-zero if the given Const node represents the 0 constant. */
361 FIRM_API int is_Const_null(const ir_node *node);
363 /** Return non-zero if the given Const node represents the 1 constant. */
364 FIRM_API int is_Const_one(const ir_node *node);
366 /** Return non-zero if the given Const node represents the constant with all bits set. */
367 FIRM_API int is_Const_all_one(const ir_node *node);
369 /** Returns true if a node is a Conv node with strict attribute set. */
370 FIRM_API int is_strictConv(const ir_node *node);
372 /** Returns true if node is a SymConst node with kind symconst_addr_ent. */
373 FIRM_API int is_SymConst_addr_ent(const ir_node *node);
375 /** Returns non-zero if s symconst kind has a type attribute */
376 #define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)
378 /** Returns non-zero if s symconst kind has an entity attribute */
379 #define SYMCONST_HAS_ENT(kind) ((kind) == symconst_addr_ent || (kind) == symconst_ofs_ent)
381 /** Returns non-zero if s symconst kind has an enum_const attribute */
382 #define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)
384 /** Get the kind of the SymConst. */
385 FIRM_API symconst_kind get_SymConst_kind(const ir_node *node);
386 /** Set the kind of the SymConst. */
387 FIRM_API void set_SymConst_kind(ir_node *node, symconst_kind num);
389 /** Only to access SymConst of kind type_tag or size. Else assertion: */
390 FIRM_API ir_type *get_SymConst_type(const ir_node *node);
391 FIRM_API void set_SymConst_type(ir_node *node, ir_type *tp);
393 /** Only to access SymConst of kind addr_ent. Else assertion: */
394 FIRM_API ir_entity *get_SymConst_entity(const ir_node *node);
395 FIRM_API void set_SymConst_entity(ir_node *node, ir_entity *ent);
397 /** Only to access SymConst of kind symconst_enum_const. Else assertion: */
398 FIRM_API ir_enum_const *get_SymConst_enum(const ir_node *node);
399 FIRM_API void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
401 FIRM_API union symconst_symbol get_SymConst_symbol(const ir_node *node);
402 FIRM_API void set_SymConst_symbol(ir_node *node,
403 union symconst_symbol sym);
405 FIRM_API ir_node **get_Sel_index_arr(ir_node *node);
406 FIRM_API int get_Sel_n_indexs(const ir_node *node);
407 FIRM_API ir_node *get_Sel_index(const ir_node *node, int pos);
408 FIRM_API void set_Sel_index(ir_node *node, int pos, ir_node *index);
410 FIRM_API ir_node **get_Call_param_arr(ir_node *node);
411 /** Gets the number of parameters of a call. */
412 FIRM_API size_t get_Call_n_params(const ir_node *node);
413 /** Gets the call parameter at position pos. */
414 FIRM_API ir_node *get_Call_param(const ir_node *node, int pos);
415 /** Sets the call parameter at position pos. */
416 FIRM_API void set_Call_param(ir_node *node, int pos, ir_node *param);
418 /** Set, get and remove the callee information for a Call node.
420 * The callee information lists all method entities that can be called
421 * from this node. If the address expression can not be analyzed fully,
422 * e.g., as entities can be called that are not in the compilation unit,
423 * the array contains the unknown_entity. The array contains only entities
424 * with peculiarity_existent, but with all kinds of visibility. The entities
425 * not necessarily contain an irg.
427 * The array is only accessible if callee information is valid. See flag
430 * The memory allocated for the array is managed automatically, i.e., it must
431 * not be freed if the Call node is removed from the graph.
433 * @param node A Call node.
435 FIRM_API int Call_has_callees(const ir_node *node);
436 FIRM_API size_t get_Call_n_callees(const ir_node *node);
437 FIRM_API ir_entity *get_Call_callee(const ir_node *node, size_t pos);
439 /** Set the full callee array.
441 * The passed array is copied. Assumes current_ir_graph set properly! */
442 FIRM_API void set_Call_callee_arr(ir_node *node, size_t n, ir_entity **arr);
443 FIRM_API void remove_Call_callee_arr(ir_node *node);
445 FIRM_API ir_node **get_Builtin_param_arr(ir_node *node);
446 /** Gets the number of parameters of a Builtin. */
447 FIRM_API int get_Builtin_n_params(const ir_node *node);
448 /** Gets the Builtin parameter at position pos. */
449 FIRM_API ir_node *get_Builtin_param(const ir_node *node, int pos);
450 /** Sets the Builtin parameter at position pos. */
451 FIRM_API void set_Builtin_param(ir_node *node, int pos, ir_node *param);
452 /** Returns a human readable string for the ir_builtin_kind. */
453 FIRM_API const char *get_builtin_kind_name(ir_builtin_kind kind);
455 FIRM_API int is_unop(const ir_node *node);
456 FIRM_API ir_node *get_unop_op(const ir_node *node);
457 FIRM_API void set_unop_op(ir_node *node, ir_node *op);
458 FIRM_API int is_binop(const ir_node *node);
459 FIRM_API ir_node *get_binop_left(const ir_node *node);
460 FIRM_API void set_binop_left(ir_node *node, ir_node *left);
461 FIRM_API ir_node *get_binop_right(const ir_node *node);
462 FIRM_API void set_binop_right(ir_node *node, ir_node *right);
465 * Test wether a node is the X_except Proj of a fragile operation
467 FIRM_API int is_x_except_Proj(const ir_node *node);
470 * Test wether a node is the X_regular Proj of a fragile operation
472 FIRM_API int is_x_regular_Proj(const ir_node *node);
475 * Set throws exception attribute of a fragile node
476 * @p throws_exception must be 0 or 1
478 FIRM_API void ir_set_throws_exception(ir_node *node, int throws_exception);
481 * Returns throws_exception attribute of a fragile node
483 FIRM_API int ir_throws_exception(const ir_node *node);
485 /** returns the name of an ir_relation */
486 FIRM_API const char *get_relation_string(ir_relation relation);
488 /** Calculates the negated (Complement(R)) relation, i.e. "<" --> ">=" */
489 FIRM_API ir_relation get_negated_relation(ir_relation relation);
491 /** Calculates the inversed (R^-1) relation, i.e., "<" --> ">" */
492 FIRM_API ir_relation get_inversed_relation(ir_relation relation);
494 /** Checks for upcast.
496 * Returns true if the Cast node casts a class type to a super type.
497 * Works also for pointers to classes (recursively).
499 * Needs typeinfo calculated.
501 FIRM_API int is_Cast_upcast(ir_node *node);
503 /** Checks for downcast.
505 * Returns true if the Cast node casts a class type to a sub type.
506 * Works also for pointers to classes (recursively).
508 * Needs typeinfo calculated.
510 FIRM_API int is_Cast_downcast(ir_node *node);
512 /** Returns true if irg in phase phase_building and the Phi has zero
513 predecessors. It's a Phi0 then. */
514 FIRM_API int is_Phi0(const ir_node *n);
515 FIRM_API ir_node **get_Phi_preds_arr(ir_node *node);
516 FIRM_API int get_Phi_n_preds(const ir_node *node);
517 FIRM_API ir_node *get_Phi_pred(const ir_node *node, int pos);
518 FIRM_API void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
520 * Returns the next element of a block phi list.
522 FIRM_API ir_node *get_Phi_next(const ir_node *phi);
524 * Sets the next link of a block Phi list.
526 FIRM_API void set_Phi_next(ir_node *phi, ir_node *next);
528 /** Return true if parameter is a memory operation.
530 * A memory operation is an operation that changes the
531 * memory. I.e., a Load or a Store operation.
533 FIRM_API int is_memop(const ir_node *node);
534 FIRM_API ir_node *get_memop_mem(const ir_node *node);
535 FIRM_API void set_memop_mem(ir_node *node, ir_node *mem);
536 FIRM_API ir_node *get_memop_ptr(const ir_node *node);
537 FIRM_API void set_memop_ptr(ir_node *node, ir_node *ptr);
539 FIRM_API ir_node **get_Sync_preds_arr(ir_node *node);
540 FIRM_API int get_Sync_n_preds(const ir_node *node);
541 FIRM_API ir_node *get_Sync_pred(const ir_node *node, int pos);
542 FIRM_API void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
543 FIRM_API void add_Sync_pred(ir_node *node, ir_node *pred);
546 * Returns non-zero if a node is a routine parameter.
548 * @param node the Proj node to test
550 FIRM_API int is_arg_Proj(const ir_node *node);
552 FIRM_API ir_node **get_Tuple_preds_arr(ir_node *node);
553 FIRM_API int get_Tuple_n_preds(const ir_node *node);
554 FIRM_API ir_node *get_Tuple_pred(const ir_node *node, int pos);
555 FIRM_API void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
557 /** Return the number of input constraints for an ASM node. */
558 FIRM_API int get_ASM_n_input_constraints(const ir_node *node);
559 /** Return the number of output constraints for an ASM node. */
560 FIRM_API int get_ASM_n_output_constraints(const ir_node *node);
561 /** Return the number of clobbered registers for an ASM node. */
562 FIRM_API int get_ASM_n_clobbers(const ir_node *node);
564 /** Returns operand of node if node is a Proj. */
565 FIRM_API ir_node *skip_Proj(ir_node *node);
566 /** Returns operand of node if node is a Proj. */
567 FIRM_API const ir_node *skip_Proj_const(const ir_node *node);
568 /** Returns operand of node if node is a Id. */
569 FIRM_API ir_node *skip_Id(ir_node *node);
570 /** Returns corresponding operand of Tuple if node is a Proj from a Tuple. */
571 FIRM_API ir_node *skip_Tuple(ir_node *node);
572 /** Returns operand of node if node is a Cast. */
573 FIRM_API ir_node *skip_Cast(ir_node *node);
574 FIRM_API const ir_node *skip_Cast_const(const ir_node *node);
575 /** Returns operand of node if node is a Pin. */
576 FIRM_API ir_node *skip_Pin(ir_node *node);
577 /** Returns operand of node if node is a Confirm */
578 FIRM_API ir_node *skip_Confirm(ir_node *node);
579 /** Skip all high-level Operations (including Cast, Confirm). */
580 FIRM_API ir_node *skip_HighLevel_ops(ir_node *node);
581 /** Returns true if the operation manipulates control flow */
582 FIRM_API int is_cfop(const ir_node *node);
583 /** returns true if the operation jumps to an unknown destination.
584 * See irop_flag_unknown_jump for a detailed explanation */
585 FIRM_API int is_unknown_jump(const ir_node *node);
588 * Returns true if the operation can change the control flow because
589 * of an exception: Call, Div, Mod, Load, Store, Alloc,
590 * Bad. Raise is not fragile, but a unconditional jump.
592 FIRM_API int is_fragile_op(const ir_node *node);
593 /** Returns the memory operand of fragile operations. */
594 FIRM_API ir_node *get_fragile_op_mem(ir_node *node);
596 /** Returns true if the operation is a forking control flow
597 * operation: Cond. */
598 FIRM_API int is_irn_forking(const ir_node *node);
601 * Copies attributes stored in the old node to a new node.
602 * Assumes both have the same opcode and sufficient size.
604 * @param irg The irg of the new_node (get_irn_irg on it might not work
606 * @param old_node the node where the attributes are copied from
607 * @param new_node node the attributes get copies to.
609 * This copies all essential information to the new node. It does not copy
610 * temporal or calculated information like visited flags or results of dominance
611 * or loop calculations
613 FIRM_API void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
615 /** Return the type attribute of a node n (SymConst, Call, Alloc, Free,
617 FIRM_API ir_type *get_irn_type_attr(ir_node *n);
619 /** Return the entity attribute of a node n (SymConst, Sel) or NULL. */
620 FIRM_API ir_entity *get_irn_entity_attr(ir_node *n);
622 /** Returns non-zero for constant-like nodes. */
623 FIRM_API int is_irn_constlike(const ir_node *node);
626 * Returns non-zero for nodes that are allowed to have keep-alives and
627 * are neither Block nor PhiM.
629 FIRM_API int is_irn_keep(const ir_node *node);
632 * Returns non-zero for nodes that are always placed in the start block.
634 FIRM_API int is_irn_start_block_placed(const ir_node *node);
637 * Returns non-zero for nodes that are machine operations.
639 FIRM_API int is_irn_machine_op(const ir_node *node);
642 * Returns non-zero for nodes that are machine operands.
644 FIRM_API int is_irn_machine_operand(const ir_node *node);
647 * Returns non-zero for nodes that have the n'th user machine flag set.
649 FIRM_API int is_irn_machine_user(const ir_node *node, unsigned n);
652 * Returns non-zero for nodes that are CSE neutral to its users.
654 FIRM_API int is_irn_cse_neutral(const ir_node *node);
656 /** Gets the string representation of the jump prediction. */
657 FIRM_API const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
660 * Access custom node data.
661 * The data must have been registered with
662 * register_additional_node_data() before.
663 * @param node The ir node to get the data from.
664 * @param type The type of the data you registered.
665 * @param off The value returned by register_additional_node_data().
666 * @return A pointer of type @p type.
668 #define get_irn_data(node,type,off) \
669 (assert(off > 0 && "Invalid node data offset"), (type *) ((char *) (node) - (off)))
672 * Get the pointer to the node some custom data belongs to.
673 * @param data The pointer to the custom data.
674 * @param off The number as returned by register_additional_node_data().
675 * @return A pointer to the ir node the custom data belongs to.
677 #define get_irn_data_base(data,off) \
678 (assert(off > 0 && "Invalid node data offset"), (ir_node *) ((char *) (data) + (off)))
681 * Request additional data to be allocated with an ir node.
682 * @param size The size of the additional data required.
683 * @return A positive number, if the operation was successful, which
684 * must be passed to the access macro get_irn_data(), 0 if the
685 * registration failed.
687 FIRM_API unsigned firm_register_additional_node_data(unsigned size);
690 * Return a pointer to the node attributes.
691 * Needed for user-defined nodes.
693 FIRM_API void *get_irn_generic_attr(ir_node *node);
694 FIRM_API const void *get_irn_generic_attr_const(const ir_node *node);
697 * Returns the unique node index for the node in its graph.
698 * This index is used to access phase information for this node.
700 FIRM_API unsigned get_irn_idx(const ir_node *node);
703 * Sets the debug information of a node.
706 * @param db The debug info.
708 FIRM_API void set_irn_dbg_info(ir_node *n, dbg_info *db);
711 * Returns the debug information of an node.
715 FIRM_API dbg_info *get_irn_dbg_info(const ir_node *n);
718 * Calculate a hash value of a node. Only inputs, mode and opcode are used.
720 * @param node the node to hash
722 FIRM_API unsigned firm_default_hash(const ir_node *node);
725 * returns a descriptive name of a node (containing type+number)
727 FIRM_API const char *gdb_node_helper(void *firm_object);
729 FIRM_API ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries);
731 FIRM_API size_t ir_switch_table_get_n_entries(const ir_switch_table *table);
733 FIRM_API void ir_switch_table_set(ir_switch_table *table, size_t entry,
734 ir_tarval *min, ir_tarval *max, long pn);
736 FIRM_API ir_tarval *ir_switch_table_get_max(const ir_switch_table *table,
739 FIRM_API ir_tarval *ir_switch_table_get_min(const ir_switch_table *table,
742 FIRM_API long ir_switch_table_get_pn(const ir_switch_table *table, size_t entry);
744 FIRM_API ir_switch_table *ir_switch_table_duplicate(ir_graph *irg, const ir_switch_table *table);