*
* FIRM is a dataflow graph. A dataflow graph is a directed graph,
* so that every node has incoming and outgoing edges. A node is
- * executable if every input at it's incoming edges is available.
+ * executable if every input at its incoming edges is available.
* Execution of the dataflow graph is started at the Start node which
* has no incoming edges and ends when the End node executes, even if
* there are still executable or not executed nodes. (Is this true,
* results can be used by several other nodes. Each input can be
* implemented as a single pointer to a predecessor node, outputs
* need to be lists of pointers to successors. Therefore a node
- * contains pointers to it's predecessor so that the implementation is a
+ * contains pointers to its predecessors so that the implementation is a
* dataflow graph with reversed edges. It has to be traversed bottom
* up.
*
* one statically allocated struct ir_op for each opcode.
*
* *mode The ir_mode of the operation represented by this firm
- * node. The mode of the operation is the mode of it's
- * result. A Firm mode is a datatype as known to the target,
- * not a type of the source language.
+ * node. The mode of the operation is the mode of its
+ * result. A Firm mode is a datatype as known to the
+ * target, not a type of the source language.
*
* visit A flag for traversing the IR.
*
* **in An array with pointers to the node's predecessors.
*
* *link A pointer to an ir_node. With this pointer all Phi nodes
- * are attached to a Block, i.e., a Block points to it's
+ * are attached to a Block, i.e. a Block points to its
* first Phi node, this node points to the second Phi node
- * in the Block and so fourth. Used in mature_immBlock
+ * in the Block and so forth. Used in mature_immBlock
* to find all Phi nodes to be matured. It's also used to
- * annotate a node with a better, optimized version of it.
+ * annotate a node with a better, optimized version of it.
*
* attr An attr struct containing the attributes of the nodes. The
* attributes depend on the opcode of the node. The number
- * of these attributes is given in op.
+ * of these attributes is given in op.
*
* The struct ir_op
* ----------------
* ================
*
* current_ir_graph Points to the current ir_graph. All constructors for
- * nodes add nodes to this graph.
+ * nodes add nodes to this graph.
*
* ir_visited An int used as flag to traverse the ir_graph.
*
* reals and pointers. The frontend has to count and number these variables.
*
* First an ir_graph needs to be constructed with new_ir_graph. The
- * constructor gets the number of local variables. The graph is hold in the
+ * constructor gets the number of local variables. The graph is held in the
* global variable irg.
*
* Now the construction of the procedure can start. Several basic blocks can
* The constructors of arithmetic nodes require that their predecessors
* are mentioned. Sometimes these are available in the Frontend as the
* predecessors have just been generated by the frontend. If they are local
- * values the predecessors can be obtained from the library with a call to
+ * values, the predecessors can be obtained from the library with a call to
* get_value(local_val_nr). (local_val_nr needs to be administered by
* the Frontend.) A call to get_value triggers the generation of Phi nodes.
- * If an arithmetic operation produces a local value this value needs to be
+ * If an arithmetic operation produces a local value, this value needs to be
* passed to the library by set_value(node, local_val_nr).
* In straight line code these two operations just remember and return the
* pointer to nodes producing the value. If the value passes block boundaries
ir_node *new_rd_Call(dbg_info *db, ir_node *block, ir_node *store,
ir_node *callee, int arity, ir_node *in[], ir_type *tp);
-/** Constructor for a ยดBuiltin node.
+/** Constructor for a Builtin node.
*
* Represents a call of a backend-specific builtin..
*
*
* Represents an arbitrary value. Places the node in the start block.
*
+ * @param *db A pointer for debug information.
* @param *irg The IR graph the node belongs to.
* @param *m The mode of the unknown value.
*/
* Derives mode from passed tarval.
*
* @param *irg The IR graph the node belongs to.
- * @param *block The IR block the node belongs to.
* @param *con Points to an entry in the constant table.
*/
ir_node *new_r_Const(ir_graph *irg, tarval *con);
/** Constructor for a Minus node.
*
- * @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
* @param *op The operand.
* @param *mode The mode of the operand and the result.
/** Constructor for a Mul node.
*
- * @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
* @param *op1 The first operand.
* @param *op2 The second operand.
/** Constructor for a Mulh node.
*
- * @param *irg The IR graph the node belongs to.
* @param *block The IR block the node belongs to.
* @param *op1 The first operand.
* @param *op2 The second operand.
* Represents an arbitrary value. Places the node in
* the start block.
*
+ * @param *db A pointer for debug information.
* @param *m The mode of the unknown value.
*/
ir_node *new_d_Unknown(dbg_info *db, ir_mode *m);