- False, /* false */
- Eq, /* equal */
- Lt, /* less */
- Le, /* less or equal */
- Gt, /* greater */
- Ge, /* greater or equal */
- Lg, /* less or greater */
- Leg, /* less, equal or greater = ordered */
- Uo, /* unordered */
- Ue, /* unordered or equal */
- Ul, /* unordered or less */
- Ule, /* unordered, less or equal */
- Ug, /* unordered or greater */
- Uge, /* unordered, greater or equal */
- Ne, /* unordered, less or greater = not equal */
- True, /* true */
- not_mask = Leg /* bits to flip to negate comparison */
-} pnc_number;
-inline char *get_pnc_string(int pnc);
-inline int get_negated_pnc(int pnc);
-inline ir_node *get_Cmp_left (ir_node *node);
-inline void set_Cmp_left (ir_node *node, ir_node *left);
-inline ir_node *get_Cmp_right (ir_node *node);
-inline void set_Cmp_right (ir_node *node, ir_node *right);
-
-inline ir_node *get_Shl_left (ir_node *node);
-inline void set_Shl_left (ir_node *node, ir_node *left);
-inline ir_node *get_Shl_right (ir_node *node);
-inline void set_Shl_right (ir_node *node, ir_node *right);
-
-inline ir_node *get_Shr_left (ir_node *node);
-inline void set_Shr_left (ir_node *node, ir_node *left);
-inline ir_node *get_Shr_right (ir_node *node);
-inline void set_Shr_right (ir_node *node, ir_node *right);
-
-inline ir_node *get_Shrs_left (ir_node *node);
-inline void set_Shrs_left (ir_node *node, ir_node *left);
-inline ir_node *get_Shrs_right (ir_node *node);
-inline void set_Shrs_right (ir_node *node, ir_node *right);
-
-inline ir_node *get_Rot_left (ir_node *node);
-inline void set_Rot_left (ir_node *node, ir_node *left);
-inline ir_node *get_Rot_right (ir_node *node);
-inline void set_Rot_right (ir_node *node, ir_node *right);
-
-inline ir_node *get_Conv_op (ir_node *node);
-inline void set_Conv_op (ir_node *node, ir_node *op);
-
-inline ir_node **get_Phi_preds_arr (ir_node *node);
-inline int get_Phi_n_preds (ir_node *node);
-/* inline void set_Phi_n_preds (ir_node *node, int n_preds); */
-inline ir_node *get_Phi_pred (ir_node *node, int pos);
-inline void set_Phi_pred (ir_node *node, int pos, ir_node *pred);
-
-inline ir_node *get_Load_mem (ir_node *node);
-inline void set_Load_mem (ir_node *node, ir_node *mem);
-inline ir_node *get_Load_ptr (ir_node *node);
-inline void set_Load_ptr (ir_node *node, ir_node *ptr);
-
-inline ir_node *get_Store_mem (ir_node *node);
-inline void set_Store_mem (ir_node *node, ir_node *mem);
-inline ir_node *get_Store_ptr (ir_node *node);
-inline void set_Store_ptr (ir_node *node, ir_node *ptr);
-inline ir_node *get_Store_value (ir_node *node);
-inline void set_Store_value (ir_node *node, ir_node *value);
-
-inline ir_node *get_Alloc_mem (ir_node *node);
-inline void set_Alloc_mem (ir_node *node, ir_node *mem);
-inline ir_node *get_Alloc_size (ir_node *node);
-inline void set_Alloc_size (ir_node *node, ir_node *size);
-inline type *get_Alloc_type (ir_node *node);
-inline void set_Alloc_type (ir_node *node, type *type);
+ pn_DivMod_M, /**< Memory result. */
+ pn_DivMod_X_except, /**< Execution result if exception occurred. */
+ pn_DivMod_res_div, /**< Result of computation a / b. */
+ pn_DivMod_res_mod, /**< Result of computation a % b. */
+ pn_DivMod_max /**< number of projections from a DivMod */
+} pn_DivMod; /* Projection numbers for DivMod. */
+
+ir_node *get_Div_left (ir_node *node);
+void set_Div_left (ir_node *node, ir_node *left);
+ir_node *get_Div_right (ir_node *node);
+void set_Div_right (ir_node *node, ir_node *right);
+ir_node *get_Div_mem (ir_node *node);
+void set_Div_mem (ir_node *node, ir_node *mem);
+
+/**
+ * Projection numbers for Div: use for Proj nodes!
+ */
+typedef enum {
+ pn_Div_M, /**< Memory result. */
+ pn_Div_X_except, /**< Execution result if exception occurred. */
+ pn_Div_res /**< Result of computation. */
+} pn_Div; /* Projection numbers for Div. */
+
+ir_node *get_Mod_left (ir_node *node);
+void set_Mod_left (ir_node *node, ir_node *left);
+ir_node *get_Mod_right (ir_node *node);
+void set_Mod_right (ir_node *node, ir_node *right);
+ir_node *get_Mod_mem (ir_node *node);
+void set_Mod_mem (ir_node *node, ir_node *mem);
+
+/**
+ * Projection numbers for Mod: use for Proj nodes!
+ */
+typedef enum {
+ pn_Mod_M, /**< Memory result. */
+ pn_Mod_X_except, /**< Execution result if exception occurred. */
+ pn_Mod_res, /**< Result of computation. */
+ pn_Mod_max /**< number of projections from a Mod */
+} pn_Mod; /* Projection numbers for Mod. */
+
+ir_node *get_Abs_op (ir_node *node);
+void set_Abs_op (ir_node *node, ir_node *op);
+
+ir_node *get_And_left (ir_node *node);
+void set_And_left (ir_node *node, ir_node *left);
+ir_node *get_And_right (ir_node *node);
+void set_And_right (ir_node *node, ir_node *right);
+
+ir_node *get_Or_left (ir_node *node);
+void set_Or_left (ir_node *node, ir_node *left);
+ir_node *get_Or_right (ir_node *node);
+void set_Or_right (ir_node *node, ir_node *right);
+
+ir_node *get_Eor_left (ir_node *node);
+void set_Eor_left (ir_node *node, ir_node *left);
+ir_node *get_Eor_right (ir_node *node);
+void set_Eor_right (ir_node *node, ir_node *right);
+
+ir_node *get_Not_op (ir_node *node);
+void set_Not_op (ir_node *node, ir_node *op);
+
+/**
+ * Projection numbers for Cmp are defined several times.
+ * The bit patterns are used for various tests, so don't change.
+ * The "unordered" values are possible results of comparing
+ * floating point numbers.
+ * Note that the encoding is imported, so do NOT change the order.
+ */
+typedef enum {
+ pn_Cmp_False = 0, /**< false */
+ pn_Cmp_Eq = 1, /**< equal */
+ pn_Cmp_Lt = 2, /**< less */
+ pn_Cmp_Le = pn_Cmp_Eq|pn_Cmp_Lt, /**< less or equal */
+ pn_Cmp_Gt = 4, /**< greater */
+ pn_Cmp_Ge = pn_Cmp_Eq|pn_Cmp_Gt, /**< greater or equal */
+ pn_Cmp_Lg = pn_Cmp_Lt|pn_Cmp_Gt, /**< less or greater */
+ pn_Cmp_Leg = pn_Cmp_Lt|pn_Cmp_Eq|pn_Cmp_Gt, /**< less, equal or greater = ordered */
+ pn_Cmp_Uo = 8, /**< unordered */
+ pn_Cmp_Ue = pn_Cmp_Uo|pn_Cmp_Eq, /**< unordered or equal */
+ pn_Cmp_Ul = pn_Cmp_Uo|pn_Cmp_Lt, /**< unordered or less */
+ pn_Cmp_Ule = pn_Cmp_Uo|pn_Cmp_Eq|pn_Cmp_Lt, /**< unordered, less or equal */
+ pn_Cmp_Ug = pn_Cmp_Uo|pn_Cmp_Gt, /**< unordered or greater */
+ pn_Cmp_Uge = pn_Cmp_Uo|pn_Cmp_Eq|pn_Cmp_Gt, /**< unordered, greater or equal */
+ pn_Cmp_Ne = pn_Cmp_Uo|pn_Cmp_Lt|pn_Cmp_Gt, /**< unordered, less or greater = not equal */
+ pn_Cmp_True = 15 /**< true */
+ /* not_mask = Leg*/ /* bits to flip to negate comparison * @@ hack for jni interface */
+} pn_Cmp; /* Projection numbers for Cmp */
+/* #define not_mask pn_Cmp_Leg */
+
+const char *get_pnc_string(int pnc);
+int get_negated_pnc(int pnc);
+ir_node *get_Cmp_left (ir_node *node);
+void set_Cmp_left (ir_node *node, ir_node *left);
+ir_node *get_Cmp_right (ir_node *node);
+void set_Cmp_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shl_left (ir_node *node);
+void set_Shl_left (ir_node *node, ir_node *left);
+ir_node *get_Shl_right (ir_node *node);
+void set_Shl_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shr_left (ir_node *node);
+void set_Shr_left (ir_node *node, ir_node *left);
+ir_node *get_Shr_right (ir_node *node);
+void set_Shr_right (ir_node *node, ir_node *right);
+
+ir_node *get_Shrs_left (ir_node *node);
+void set_Shrs_left (ir_node *node, ir_node *left);
+ir_node *get_Shrs_right (ir_node *node);
+void set_Shrs_right (ir_node *node, ir_node *right);
+
+ir_node *get_Rot_left (ir_node *node);
+void set_Rot_left (ir_node *node, ir_node *left);
+ir_node *get_Rot_right (ir_node *node);
+void set_Rot_right (ir_node *node, ir_node *right);
+
+ir_node *get_Conv_op (ir_node *node);
+void set_Conv_op (ir_node *node, ir_node *op);
+
+/* Does Cast need a mem operator?
+ * Cast should only depend on the type, not on the state of an
+ * entity. But: we initialize various fields after Alloc, that
+ * are accessed in the cast. This required some precaution, to
+ * get the right memory into the Loads generated from the cast.
+ */
+ir_node *get_Cast_op (ir_node *node);
+void set_Cast_op (ir_node *node, ir_node *op);
+type *get_Cast_type (ir_node *node);
+void set_Cast_type (ir_node *node, type *to_tp);
+
+/** Returns true if n is Phi or Filter in interprocedural_view.
+ Returns false if irg in phase building and the Phi has zero
+ predecessors: it's a Phi0. */
+int is_Phi (const ir_node *n);
+/** Returns true if irg in phase building and the Phi has zero
+ predecessors: it's a Phi0. */
+int is_Phi0 (const ir_node *n);
+/* These routines also work for Filter nodes in interprocedural view. */
+ir_node **get_Phi_preds_arr (ir_node *node);
+int get_Phi_n_preds (ir_node *node);
+ir_node *get_Phi_pred (ir_node *node, int pos);
+void set_Phi_pred (ir_node *node, int pos, ir_node *pred);
+
+ir_node *get_Filter_pred(ir_node *node);
+void set_Filter_pred(ir_node *node, ir_node *pred);
+long get_Filter_proj(ir_node *node);
+void set_Filter_proj(ir_node *node, long proj);
+/* set the interprocedural predecessors, ...d_arr uses current_ir_graph.
+ * @@@ Maybe better: arity is zero if no cg preds. */
+void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in);
+void set_Filter_cg_pred(ir_node * node, int pos, ir_node * pred);
+int get_Filter_n_cg_preds(ir_node *node);
+ir_node *get_Filter_cg_pred(ir_node *node, int pos);
+
+/** Return true if parameter is a memory operation.
+ *
+ * A memory operation is an operation that changes the
+ * memory. I.e., a Load or a Store operation.
+ */
+int is_memop(ir_node *node);
+ir_node *get_memop_mem (ir_node *node);
+void set_memop_mem (ir_node *node, ir_node *mem);
+ir_node *get_memop_ptr (ir_node *node);
+void set_memop_ptr (ir_node *node, ir_node *ptr);
+
+/**
+ * Projection numbers for Load: use for Proj nodes!
+ */
+typedef enum {
+ pn_Load_M, /**< Memory result. */
+ pn_Load_X_except, /**< Execution result if exception occurred. */
+ pn_Load_res, /**< Result of load operation. */
+ pn_Load_max /**< number of projections from a Load */
+} pn_Load; /* Projection numbers for Load. */
+
+ir_node *get_Load_mem (ir_node *node);
+void set_Load_mem (ir_node *node, ir_node *mem);
+ir_node *get_Load_ptr (ir_node *node);
+void set_Load_ptr (ir_node *node, ir_node *ptr);
+ir_mode *get_Load_mode (ir_node *node);
+void set_Load_mode (ir_node *node, ir_mode *mode);
+ent_volatility get_Load_volatility (ir_node *node);
+void set_Load_volatility (ir_node *node, ent_volatility volatility);
+
+/**
+ * Projection numbers for Store: use for Proj nodes!
+ */
+typedef enum {
+ pn_Store_M, /**< Memory result. */
+ pn_Store_X_except, /**< Execution result if exception occurred. */
+ pn_Store_max /**< number of projections from a Store */
+} pn_Store; /* Projection numbers for Store. */
+
+ir_node *get_Store_mem (ir_node *node);
+void set_Store_mem (ir_node *node, ir_node *mem);
+ir_node *get_Store_ptr (ir_node *node);
+void set_Store_ptr (ir_node *node, ir_node *ptr);
+ir_node *get_Store_value (ir_node *node);
+void set_Store_value (ir_node *node, ir_node *value);
+ent_volatility get_Store_volatility (ir_node *node);
+void set_Store_volatility (ir_node *node, ent_volatility volatility);
+
+/**
+ * Projection numbers for Alloc: use for Proj nodes!
+ */
+typedef enum {
+ pn_Alloc_M, /**< Memory result. */
+ pn_Alloc_X_except, /**< Execution result if exception occurred. */
+ pn_Alloc_res, /**< Result of allocation. */
+ pn_Alloc_max /**< number of projections from an Alloc */
+} pn_Alloc; /* Projection numbers for Alloc. */
+
+ir_node *get_Alloc_mem (ir_node *node);
+void set_Alloc_mem (ir_node *node, ir_node *mem);
+ir_node *get_Alloc_size (ir_node *node);
+void set_Alloc_size (ir_node *node, ir_node *size);
+type *get_Alloc_type (ir_node *node);
+void set_Alloc_type (ir_node *node, type *tp);
+
+/** The allocation place. */