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
26 #ifndef FIRM_IR_IRNODE_H
27 #define FIRM_IR_IRNODE_H
31 #include "firm_common.h"
39 * @defgroup ir_node Declarations of an ir node.
41 * The type definition of ir_node is also in irgraph.h to resolve
42 * recursion between irnode.h and irgraph.h
44 * ir_node - a datatype representing a Firm node
46 * The common fields are:
48 * - arity - The number of predecessors in the Firm graph.
49 * - in - A list with the predecessors in the Firm graph. There are
50 * routines to access individual elements and to obtain the
51 * array. The method returning the array should not be used.
52 * - mode - The mode of the node. There are routines to get the mode
53 * but also to access the mode's fields directly.
54 * - opcode - The opcode of the node. There are routines to get the opcode
55 * but also to access the opcode's fields directly.
56 * - node_nr - A unique number for the node. Available only if debugging
62 * Checks whether a pointer points to a ir node. This is guessed by looking
63 * at the few bytes of the thing. Most things used in firm have a firm_kind
64 * attribute there. This function might falsely return true though for things
65 * without a firm_kind at the beginning.
67 * @param thing an arbitrary pointer
68 * @return non-zero if the thing is a ir mode, else zero
70 FIRM_API int is_ir_node(const void *thing);
73 * Returns the number of predecessors without the block predecessor.
75 * @param node the IR-node
77 FIRM_API int get_irn_arity(const ir_node *node);
80 * Get the n-th predecessor of a node.
81 * This function removes Id predecessors.
83 FIRM_API ir_node *get_irn_n(const ir_node *node, int n);
86 * Replaces the old in array by a new one that will contain the ins given in
87 * the parameters. Conserves the block predecessor. It copies the array passed.
88 * This function is necessary to adjust in arrays of blocks, calls and phis.
89 * Assumes that current_ir_graph is set to the graph containing "node".
90 * "in" must contain all predecessors except the block that are required for
91 * the nodes opcode. */
92 FIRM_API void set_irn_in(ir_node *node, int arity, ir_node *in[]);
95 * Add a artificial dependency to the node.
96 * The dependency is only inserted if it is not there already.
97 * This is only allowed in phase_backend!
99 * @param node The node.
100 * @param dep The dependency target.
102 * @return The index in the array (get_irn_dep with that index returns @p dep).
104 FIRM_API int add_irn_dep(ir_node *node, ir_node *dep);
107 * Copy all dependencies from a node to another.
108 * This is only allowed in phase_backend!
110 * @param tgt The node which should be enriched.
111 * @param src The node whose dependencies shall be copied.
113 FIRM_API void add_irn_deps(ir_node *tgt, ir_node *src);
116 * Get the length of the dependency array.
117 * @param node The node.
118 * @return The length of the dependency array or 0 if it has not yet been allocated.
120 FIRM_API int get_irn_deps(const ir_node *node);
123 * Get an entry of the dependency array.
124 * @param node The node.
125 * @param pos The position.
126 * @return The node at that position.
128 FIRM_API ir_node *get_irn_dep(const ir_node *node, int pos);
131 * Set an entry of the dependency array.
132 * @param node The node.
133 * @param pos The position.
134 * @param dep The dependency target.
136 FIRM_API void set_irn_dep(ir_node *node, int pos, ir_node *dep);
138 /** Replace the n-th predecessor of a node with a new one. */
139 FIRM_API void set_irn_n(ir_node *node, int n, ir_node *in);
141 * Appends a new predecessor to a node. This only works for nodes with
143 * @returns the number of the new input
145 FIRM_API int add_irn_n(ir_node *node, ir_node *in);
146 /** Remove predecessor i from Sync n */
147 FIRM_API void del_Sync_n(ir_node *n, int i);
148 /** Sets the mode struct of node. */
149 FIRM_API void set_irn_mode(ir_node *node, ir_mode *mode);
150 /** Gets the mode struct of a node. */
151 FIRM_API ir_mode *get_irn_mode(const ir_node *node);
152 /** Gets the opcode struct of the node. */
153 FIRM_API ir_op *get_irn_op(const ir_node *node);
154 /** Sets the opcode struct of the node. */
155 FIRM_API void set_irn_op(ir_node *node, ir_op *op);
156 /** Gets the opcode-enum of the node. */
157 FIRM_API unsigned get_irn_opcode(const ir_node *node);
158 /** Get the string representation of the opcode. */
159 FIRM_API const char *get_irn_opname(const ir_node *node);
160 /** Get the ident for a string representation of the opcode. */
161 FIRM_API ident *get_irn_opident(const ir_node *node);
162 /** If arg is an argument of the node, returns its position, -1 otherwise */
163 FIRM_API int get_irn_pred_pos(ir_node *node, ir_node *arg);
164 /** Gets the visited counter of a node. */
165 FIRM_API ir_visited_t get_irn_visited(const ir_node *node);
166 /** Sets the visited counter of a node. */
167 FIRM_API void set_irn_visited(ir_node *node, ir_visited_t visited);
168 /** Sets visited to get_irg_visited(current_ir_graph). */
169 FIRM_API void mark_irn_visited(ir_node *node);
170 /** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
171 FIRM_API int irn_visited(const ir_node *node);
172 /** Returns 1 if visited >= get_irg_visited(current_ir_graph). Marks the node
173 * visited, if it was not. */
174 FIRM_API int irn_visited_else_mark(ir_node *node);
177 * Sets the link of a node.
178 * Only allowed if the graph is NOT in phase_building.
180 FIRM_API void set_irn_link(ir_node *node, void *link);
182 /** Returns the link of a node. */
183 FIRM_API void *get_irn_link(const ir_node *node);
185 /** Returns the ir_graph this node belongs to. */
186 FIRM_API ir_graph *get_irn_irg(const ir_node *node);
188 /** Outputs a unique number for this node if libFIRM is compiled for
189 debugging, (configure with --enable-debug) else returns address
190 of node cast to long. */
191 FIRM_API long get_irn_node_nr(const ir_node *node);
193 /** Returns the pinned state of a node.
195 * Returns whether the node _always_ must be pinned.
196 * I.e., the node is not floating after global cse.
198 * @returns Either state op_pin_state_pinned or op_pin_state_floats.
200 FIRM_API op_pin_state get_irn_pinned(const ir_node *node);
202 /** Set pin state for nodes with op pin state op_pin_state_exc_pinned */
203 FIRM_API void set_irn_pinned(ir_node *node, op_pin_state state);
205 /** Returns whether the node is currently pinned.
207 * If get_irn_pinned returns op_pin_state_floats and the graph the
208 * node belongs to is in state op_poin_state_floats then this function
209 * returns 'floats', else 'pinned'.
211 FIRM_API op_pin_state is_irn_pinned_in_irg(const ir_node *node);
214 * IR node constructor.
215 * Create a new IR node in irg, with an op, mode, arity and
216 * some incoming IR nodes.
217 * This constructor is used in every specific IR node constructor.
219 * @param db Debug info.
220 * @param irg IR-graph on with this new node should be constructed.
221 * @param block The block the new node belongs to
222 * @param op The opcode of the new node.
223 * @param mode The mode of the new node.
224 * @param arity The arity of the new node, <0 if can be changed dynamically.
225 * @param in An array of arity predecessor nodes.
227 FIRM_API ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block,
228 ir_op *op, ir_mode *mode,
229 int arity, ir_node *const *in);
232 * Return the block the node belongs to. This is only
233 * possible for pinned nodes or if the graph is in pinned state.
234 * Otherwise the block may be incorrect. This condition is
235 * now checked by an assertion.
237 * This works for all except Block. It can return Blocks or the Bad node.
239 * To express the difference to access routines that work for all
240 * nodes we use infix "nodes" and do not name this function
241 * get_irn_block(). */
242 FIRM_API ir_node *get_nodes_block(const ir_node *node);
244 /** Sets the Block of a node. */
245 FIRM_API void set_nodes_block(ir_node *node, ir_node *block);
247 /** Test whether arbitrary node is frame pointer.
249 * Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
250 * from Start. If so returns frame type, else Null. */
251 FIRM_API ir_type *is_frame_pointer(const ir_node *n);
253 /** Return the number of control flow predecessors of a block. */
254 FIRM_API int get_Block_n_cfgpreds(const ir_node *block);
255 /** Return the control flow predecessor of a block at a given position. */
256 FIRM_API ir_node *get_Block_cfgpred(const ir_node *block, int pos);
257 /** Set the control flow predecessor of a block at a given position. */
258 FIRM_API void set_Block_cfgpred(ir_node *block, int pos, ir_node *pred);
261 * Return the position of the predecessor block pred in the inputs
262 * of the block block.
264 * @param block the block
265 * @param pred a predecessor block of block
267 * @return the position of pred in block or -1
269 * @note When using the old extended basic block form for blocks
270 * with exception exists, a predecessor block might have more
271 * than one position. In that case it is not specified, with is returned.
273 FIRM_API int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred);
275 /** Get the predecessor block.
277 * Returns the block corresponding to the predecessor pos of block.
279 * There are several ambiguities we resolve with this function:
280 * - The direct predecessor can be a Proj, which is not pinned.
281 * We walk from the predecessor to the next pinned node
282 * (skip_Proj) and return the block that node is in.
283 * - If we encounter the Bad node, this function does not return
284 * Start block, but the Bad node.
286 FIRM_API ir_node *get_Block_cfgpred_block(const ir_node *node, int pos);
288 /** Return the matured flag of a block */
289 FIRM_API int get_Block_matured(const ir_node *block);
290 /** set the matured flag of a block. */
291 FIRM_API void set_Block_matured(ir_node *block, int matured);
293 /** A visited flag only for block nodes.
294 * @see also: get_irn_visited() inc_irg_visited() inc_irg_block_visited()*/
295 FIRM_API ir_visited_t get_Block_block_visited(const ir_node *block);
296 /** set block visited flag */
297 FIRM_API void set_Block_block_visited(ir_node *block, ir_visited_t visit);
299 /** mark a block as visited by setting its visited counter */
300 FIRM_API void mark_Block_block_visited(ir_node *node);
301 /** returns 1 if a block is marked as visited */
302 FIRM_API int Block_block_visited(const ir_node *node);
304 /** Returns the extended basic block a block belongs to. */
305 FIRM_API ir_extblk *get_Block_extbb(const ir_node *block);
306 /** Sets the extended basic block a block belongs to. */
307 FIRM_API void set_Block_extbb(ir_node *block, ir_extblk *extblk);
308 /** Returns the ir_graph this Block belongs to. */
309 FIRM_API ir_graph *get_Block_irg(const ir_node *block);
310 /** Returns non-zero if the block has an entity assigned */
311 FIRM_API int has_Block_entity(const ir_node *block);
312 /** Returns the entity for a Block */
313 FIRM_API ir_entity *get_Block_entity(const ir_node *block);
314 /** Returns the entity for a Block (creating it if necessary) */
315 FIRM_API ir_entity *create_Block_entity(ir_node *block);
316 /** Set a new entity for a block */
317 FIRM_API void set_Block_entity(ir_node *block, ir_entity *entity);
318 /** Gets the head of the Phi list for this block. */
319 FIRM_API ir_node *get_Block_phis(const ir_node *block);
320 /** Sets the head of the Phi list for this block. */
321 FIRM_API void set_Block_phis(ir_node *block, ir_node *phi);
322 /** Add a Phi node to the list of Block Phi's. */
323 FIRM_API void add_Block_phi(ir_node *block, ir_node *phi);
324 /** Get the Block mark (single bit). */
325 FIRM_API unsigned get_Block_mark(const ir_node *block);
326 /** Set the Block mark (single bit). */
327 FIRM_API void set_Block_mark(ir_node *block, unsigned mark);
329 /** Return the number of Keep alive node. */
330 FIRM_API int get_End_n_keepalives(const ir_node *end);
331 /** Return the Keep alive node a position pos. */
332 FIRM_API ir_node *get_End_keepalive(const ir_node *end, int pos);
333 /** Keep alive dedicated nodes. These must be either PhiM or Block nodes. */
334 FIRM_API void add_End_keepalive(ir_node *end, ir_node *ka);
335 /** Set the Keep alive node at position pos. */
336 FIRM_API void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
339 * Set new keep-alives.
340 * Beware: This might be an expensive operation if dynamic edges are enabled,
341 * so avoid it in the backend.
343 FIRM_API void set_End_keepalives(ir_node *end, int n, ir_node *in[]);
345 /** Remove irn from the keep-alive set. */
346 FIRM_API void remove_End_keepalive(ir_node *end, ir_node *irn);
348 /** Remove Bads, NoMem and doublets from the keep-alive set. */
349 FIRM_API void remove_End_Bads_and_doublets(ir_node *end);
351 /** Some parts of the End node are allocated separately -- their memory
352 is not recovered by dead_node_elimination if a End node is dead.
353 free_End() frees these data structures. */
354 FIRM_API void free_End(ir_node *end);
356 FIRM_API ir_node **get_Return_res_arr(ir_node *node);
357 FIRM_API size_t get_Return_n_ress(const ir_node *node);
358 FIRM_API ir_node *get_Return_res(const ir_node *node, int pos);
359 FIRM_API void set_Return_res(ir_node *node, int pos, ir_node *res);
361 /** Return non-zero if the given Const node represents the 0 constant. */
362 FIRM_API int is_Const_null(const ir_node *node);
364 /** Return non-zero if the given Const node represents the 1 constant. */
365 FIRM_API int is_Const_one(const ir_node *node);
367 /** Return non-zero if the given Const node represents the constant with all bits set. */
368 FIRM_API int is_Const_all_one(const ir_node *node);
370 /** Returns true if a node is a Conv node with strict attribute set. */
371 FIRM_API int is_strictConv(const ir_node *node);
373 /** Returns true if node is a SymConst node with kind symconst_addr_ent. */
374 FIRM_API int is_SymConst_addr_ent(const ir_node *node);
376 /** Returns non-zero if s symconst kind has a type attribute */
377 #define SYMCONST_HAS_TYPE(kind) ((kind) <= symconst_type_align)
379 /** Returns non-zero if s symconst kind has an entity attribute */
380 #define SYMCONST_HAS_ENT(kind) ((kind) == symconst_addr_ent || (kind) == symconst_ofs_ent)
382 /** Returns non-zero if s symconst kind has an enum_const attribute */
383 #define SYMCONST_HAS_ENUM(kind) ((kind) == symconst_enum_const)
385 /** Get the kind of the SymConst. */
386 FIRM_API symconst_kind get_SymConst_kind(const ir_node *node);
387 /** Set the kind of the SymConst. */
388 FIRM_API void set_SymConst_kind(ir_node *node, symconst_kind num);
390 /** Only to access SymConst of kind type_tag or size. Else assertion: */
391 FIRM_API ir_type *get_SymConst_type(const ir_node *node);
392 FIRM_API void set_SymConst_type(ir_node *node, ir_type *tp);
394 /** Only to access SymConst of kind addr_ent. Else assertion: */
395 FIRM_API ir_entity *get_SymConst_entity(const ir_node *node);
396 FIRM_API void set_SymConst_entity(ir_node *node, ir_entity *ent);
398 /** Only to access SymConst of kind symconst_enum_const. Else assertion: */
399 FIRM_API ir_enum_const *get_SymConst_enum(const ir_node *node);
400 FIRM_API void set_SymConst_enum(ir_node *node, ir_enum_const *ec);
402 FIRM_API union symconst_symbol get_SymConst_symbol(const ir_node *node);
403 FIRM_API void set_SymConst_symbol(ir_node *node,
404 union symconst_symbol sym);
406 FIRM_API ir_node **get_Sel_index_arr(ir_node *node);
407 FIRM_API int get_Sel_n_indexs(const ir_node *node);
408 FIRM_API ir_node *get_Sel_index(const ir_node *node, int pos);
409 FIRM_API void set_Sel_index(ir_node *node, int pos, ir_node *index);
411 FIRM_API ir_node **get_Call_param_arr(ir_node *node);
412 /** Gets the number of parameters of a call. */
413 FIRM_API size_t get_Call_n_params(const ir_node *node);
414 /** Gets the call parameter at position pos. */
415 FIRM_API ir_node *get_Call_param(const ir_node *node, int pos);
416 /** Sets the call parameter at position pos. */
417 FIRM_API void set_Call_param(ir_node *node, int pos, ir_node *param);
419 /** Set, get and remove the callee information for a Call node.
421 * The callee information lists all method entities that can be called
422 * from this node. If the address expression can not be analyzed fully,
423 * e.g., as entities can be called that are not in the compilation unit,
424 * the array contains the unknown_entity. The array contains only entities
425 * with peculiarity_existent, but with all kinds of visibility. The entities
426 * not necessarily contain an irg.
428 * The array is only accessible if callee information is valid. See flag
431 * The memory allocated for the array is managed automatically, i.e., it must
432 * not be freed if the Call node is removed from the graph.
434 * @param node A Call node.
436 FIRM_API int Call_has_callees(const ir_node *node);
437 FIRM_API size_t get_Call_n_callees(const ir_node *node);
438 FIRM_API ir_entity *get_Call_callee(const ir_node *node, size_t pos);
440 /** Set the full callee array.
442 * The passed array is copied. Assumes current_ir_graph set properly! */
443 FIRM_API void set_Call_callee_arr(ir_node *node, size_t n, ir_entity **arr);
444 FIRM_API void remove_Call_callee_arr(ir_node *node);
446 FIRM_API ir_node **get_Builtin_param_arr(ir_node *node);
447 /** Gets the number of parameters of a Builtin. */
448 FIRM_API int get_Builtin_n_params(const ir_node *node);
449 /** Gets the Builtin parameter at position pos. */
450 FIRM_API ir_node *get_Builtin_param(const ir_node *node, int pos);
451 /** Sets the Builtin parameter at position pos. */
452 FIRM_API void set_Builtin_param(ir_node *node, int pos, ir_node *param);
453 /** Returns a human readable string for the ir_builtin_kind. */
454 FIRM_API const char *get_builtin_kind_name(ir_builtin_kind kind);
456 FIRM_API int is_unop(const ir_node *node);
457 FIRM_API ir_node *get_unop_op(const ir_node *node);
458 FIRM_API void set_unop_op(ir_node *node, ir_node *op);
459 FIRM_API int is_binop(const ir_node *node);
460 FIRM_API ir_node *get_binop_left(const ir_node *node);
461 FIRM_API void set_binop_left(ir_node *node, ir_node *left);
462 FIRM_API ir_node *get_binop_right(const ir_node *node);
463 FIRM_API void set_binop_right(ir_node *node, ir_node *right);
466 * Test wether a node is the X_except Proj of a fragile operation
468 FIRM_API int is_x_except_Proj(const ir_node *node);
471 * Test wether a node is the X_regular Proj of a fragile operation
473 FIRM_API int is_x_regular_Proj(const ir_node *node);
476 * Set throws exception attribute of a fragile node
477 * @p throws_exception must be 0 or 1
479 FIRM_API void ir_set_throws_exception(ir_node *node, int throws_exception);
482 * Returns throws_exception attribute of a fragile node
484 FIRM_API int ir_throws_exception(const ir_node *node);
486 /** returns the name of an ir_relation */
487 FIRM_API const char *get_relation_string(ir_relation relation);
489 /** Calculates the negated (Complement(R)) relation, i.e. "<" --> ">=" */
490 FIRM_API ir_relation get_negated_relation(ir_relation relation);
492 /** Calculates the inversed (R^-1) relation, i.e., "<" --> ">" */
493 FIRM_API ir_relation get_inversed_relation(ir_relation relation);
495 /** Checks for upcast.
497 * Returns true if the Cast node casts a class type to a super type.
498 * Works also for pointers to classes (recursively).
500 * Needs typeinfo calculated.
502 FIRM_API int is_Cast_upcast(ir_node *node);
504 /** Checks for downcast.
506 * Returns true if the Cast node casts a class type to a sub type.
507 * Works also for pointers to classes (recursively).
509 * Needs typeinfo calculated.
511 FIRM_API int is_Cast_downcast(ir_node *node);
513 /** Returns true if irg in phase phase_building and the Phi has zero
514 predecessors. It's a Phi0 then. */
515 FIRM_API int is_Phi0(const ir_node *n);
516 FIRM_API ir_node **get_Phi_preds_arr(ir_node *node);
517 FIRM_API int get_Phi_n_preds(const ir_node *node);
518 FIRM_API ir_node *get_Phi_pred(const ir_node *node, int pos);
519 FIRM_API void set_Phi_pred(ir_node *node, int pos, ir_node *pred);
521 * Returns the next element of a block phi list.
523 FIRM_API ir_node *get_Phi_next(const ir_node *phi);
525 * Sets the next link of a block Phi list.
527 FIRM_API void set_Phi_next(ir_node *phi, ir_node *next);
529 /** Return true if parameter is a memory operation.
531 * A memory operation is an operation that changes the
532 * memory. I.e., a Load or a Store operation.
534 FIRM_API int is_memop(const ir_node *node);
535 FIRM_API ir_node *get_memop_mem(const ir_node *node);
536 FIRM_API void set_memop_mem(ir_node *node, ir_node *mem);
537 FIRM_API ir_node *get_memop_ptr(const ir_node *node);
538 FIRM_API void set_memop_ptr(ir_node *node, ir_node *ptr);
540 FIRM_API ir_node **get_Sync_preds_arr(ir_node *node);
541 FIRM_API int get_Sync_n_preds(const ir_node *node);
542 FIRM_API ir_node *get_Sync_pred(const ir_node *node, int pos);
543 FIRM_API void set_Sync_pred(ir_node *node, int pos, ir_node *pred);
544 FIRM_API void add_Sync_pred(ir_node *node, ir_node *pred);
547 * Returns non-zero if a node is a routine parameter.
549 * @param node the Proj node to test
551 FIRM_API int is_arg_Proj(const ir_node *node);
553 FIRM_API ir_node **get_Tuple_preds_arr(ir_node *node);
554 FIRM_API int get_Tuple_n_preds(const ir_node *node);
555 FIRM_API ir_node *get_Tuple_pred(const ir_node *node, int pos);
556 FIRM_API void set_Tuple_pred(ir_node *node, int pos, ir_node *pred);
558 /** Return the number of input constraints for an ASM node. */
559 FIRM_API int get_ASM_n_input_constraints(const ir_node *node);
560 /** Return the number of output constraints for an ASM node. */
561 FIRM_API int get_ASM_n_output_constraints(const ir_node *node);
562 /** Return the number of clobbered registers for an ASM node. */
563 FIRM_API int get_ASM_n_clobbers(const ir_node *node);
565 /** Returns operand of node if node is a Proj. */
566 FIRM_API ir_node *skip_Proj(ir_node *node);
567 /** Returns operand of node if node is a Proj. */
568 FIRM_API const ir_node *skip_Proj_const(const ir_node *node);
569 /** Returns operand of node if node is a Id. */
570 FIRM_API ir_node *skip_Id(ir_node *node);
571 /** Returns corresponding operand of Tuple if node is a Proj from a Tuple. */
572 FIRM_API ir_node *skip_Tuple(ir_node *node);
573 /** Returns operand of node if node is a Cast. */
574 FIRM_API ir_node *skip_Cast(ir_node *node);
575 FIRM_API const ir_node *skip_Cast_const(const ir_node *node);
576 /** Returns operand of node if node is a Pin. */
577 FIRM_API ir_node *skip_Pin(ir_node *node);
578 /** Returns operand of node if node is a Confirm */
579 FIRM_API ir_node *skip_Confirm(ir_node *node);
580 /** Skip all high-level Operations (including Cast, Confirm). */
581 FIRM_API ir_node *skip_HighLevel_ops(ir_node *node);
582 /** Returns true if the operation manipulates control flow */
583 FIRM_API int is_cfop(const ir_node *node);
584 /** returns true if the operation jumps to an unknown destination.
585 * See irop_flag_unknown_jump for a detailed explanation */
586 FIRM_API int is_unknown_jump(const ir_node *node);
589 * Returns true if the operation can change the control flow because
590 * of an exception: Call, Div, Mod, Load, Store, Alloc,
591 * Bad. Raise is not fragile, but a unconditional jump.
593 FIRM_API int is_fragile_op(const ir_node *node);
594 /** Returns the memory operand of fragile operations. */
595 FIRM_API ir_node *get_fragile_op_mem(ir_node *node);
597 /** Returns true if the operation is a forking control flow
598 * operation: Cond. */
599 FIRM_API int is_irn_forking(const ir_node *node);
602 * Copies attributes stored in the old node to a new node.
603 * Assumes both have the same opcode and sufficient size.
605 * @param irg The irg of the new_node (get_irn_irg on it might not work
607 * @param old_node the node where the attributes are copied from
608 * @param new_node node the attributes get copies to.
610 * This copies all essential information to the new node. It does not copy
611 * temporal or calculated information like visited flags or results of dominance
612 * or loop calculations
614 FIRM_API void copy_node_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node);
616 /** Return the type attribute of a node n (SymConst, Call, Alloc, Free,
618 FIRM_API ir_type *get_irn_type_attr(ir_node *n);
620 /** Return the entity attribute of a node n (SymConst, Sel) or NULL. */
621 FIRM_API ir_entity *get_irn_entity_attr(ir_node *n);
623 /** Returns non-zero for constant-like nodes. */
624 FIRM_API int is_irn_constlike(const ir_node *node);
627 * Returns non-zero for nodes that are allowed to have keep-alives and
628 * are neither Block nor PhiM.
630 FIRM_API int is_irn_keep(const ir_node *node);
633 * Returns non-zero for nodes that are always placed in the start block.
635 FIRM_API int is_irn_start_block_placed(const ir_node *node);
638 * Returns non-zero for nodes that are machine operations.
640 FIRM_API int is_irn_machine_op(const ir_node *node);
643 * Returns non-zero for nodes that are machine operands.
645 FIRM_API int is_irn_machine_operand(const ir_node *node);
648 * Returns non-zero for nodes that have the n'th user machine flag set.
650 FIRM_API int is_irn_machine_user(const ir_node *node, unsigned n);
653 * Returns non-zero for nodes that are CSE neutral to its users.
655 FIRM_API int is_irn_cse_neutral(const ir_node *node);
657 /** Gets the string representation of the jump prediction. */
658 FIRM_API const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred);
661 * Access custom node data.
662 * The data must have been registered with
663 * register_additional_node_data() before.
664 * @param node The ir node to get the data from.
665 * @param type The type of the data you registered.
666 * @param off The value returned by register_additional_node_data().
667 * @return A pointer of type @p type.
669 #define get_irn_data(node,type,off) \
670 (assert(off > 0 && "Invalid node data offset"), (type *) ((char *) (node) - (off)))
673 * Get the pointer to the node some custom data belongs to.
674 * @param data The pointer to the custom data.
675 * @param off The number as returned by register_additional_node_data().
676 * @return A pointer to the ir node the custom data belongs to.
678 #define get_irn_data_base(data,off) \
679 (assert(off > 0 && "Invalid node data offset"), (ir_node *) ((char *) (data) + (off)))
682 * Request additional data to be allocated with an ir node.
683 * @param size The size of the additional data required.
684 * @return A positive number, if the operation was successful, which
685 * must be passed to the access macro get_irn_data(), 0 if the
686 * registration failed.
688 FIRM_API unsigned firm_register_additional_node_data(unsigned size);
691 * Return a pointer to the node attributes.
692 * Needed for user-defined nodes.
694 FIRM_API void *get_irn_generic_attr(ir_node *node);
695 FIRM_API const void *get_irn_generic_attr_const(const ir_node *node);
698 * Returns the unique node index for the node in its graph.
699 * This index is used to access phase information for this node.
701 FIRM_API unsigned get_irn_idx(const ir_node *node);
704 * Sets the debug information of a node.
707 * @param db The debug info.
709 FIRM_API void set_irn_dbg_info(ir_node *n, dbg_info *db);
712 * Returns the debug information of an node.
716 FIRM_API dbg_info *get_irn_dbg_info(const ir_node *n);
719 * Calculate a hash value of a node. Only inputs, mode and opcode are used.
721 * @param node the node to hash
723 FIRM_API unsigned firm_default_hash(const ir_node *node);
726 * returns a descriptive name of a node (containing type+number)
728 FIRM_API const char *gdb_node_helper(void *firm_object);
730 FIRM_API ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries);
732 FIRM_API size_t ir_switch_table_get_n_entries(const ir_switch_table *table);
734 FIRM_API void ir_switch_table_set(ir_switch_table *table, size_t entry,
735 ir_tarval *min, ir_tarval *max, long pn);
737 FIRM_API ir_tarval *ir_switch_table_get_max(const ir_switch_table *table,
740 FIRM_API ir_tarval *ir_switch_table_get_min(const ir_switch_table *table,
743 FIRM_API long ir_switch_table_get_pn(const ir_switch_table *table, size_t entry);
745 FIRM_API ir_switch_table *ir_switch_table_duplicate(ir_graph *irg, const ir_switch_table *table);