+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief Check irnodes for correctness.
+ * @author Christian Schaefer, Goetz Lindenmaier, Till Riedel, Michael Beck
+ * @version $Id$
+ */
+#include "config.h"
+
+#include "irprog.h"
+#include "irop_t.h"
+#include "irgraph_t.h"
+#include "ircgcons.h"
+#include "irvrfy_t.h"
+#include "irgwalk.h"
+#include "irdump.h"
+#include "irdom_t.h"
+#include "irprintf.h"
+#include "irouts.h"
+#include "irflag_t.h"
+#include "irpass_t.h"
+
+/** if this flag is set, verify entity types in Load & Store nodes */
+static int vrfy_entities = 0;
+
+const char *firm_vrfy_failure_msg;
+
+/* enable verification of Load/Store entities */
+void vrfy_enable_entity_tests(int enable)
+{
+ vrfy_entities = enable;
+}
+
+#ifndef NDEBUG
+
+/**
+ * little helper for NULL modes
+ */
+static const char *get_mode_name_ex(ir_mode *mode)
+{
+ if (! mode)
+ return "<no mode>";
+ return get_mode_name(mode);
+}
+
+/** the last IRG, on which a verification error was found */
+static ir_graph *last_irg_error = NULL;
+
+/**
+ * print the name of the entity of an verification failure
+ *
+ * @param node the node caused the failure
+ */
+static void show_entity_failure(ir_node *node)
+{
+ ir_graph *irg = get_irn_irg(node);
+
+ if (last_irg_error == irg)
+ return;
+
+ last_irg_error = irg;
+
+ if (irg == get_const_code_irg()) {
+ fprintf(stderr, "\nFIRM: irn_vrfy_irg() <of CONST_CODE_IRG> failed\n");
+ } else {
+ ir_entity *ent = get_irg_entity(irg);
+
+ if (ent) {
+ ir_type *ent_type = get_entity_owner(ent);
+
+ if (ent_type) {
+ ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() %+F::%s failed\n",
+ ent_type, get_entity_name(ent));
+ } else {
+ fprintf(stderr, "\nFIRM: irn_vrfy_irg() <NULL>::%s failed\n", get_entity_name(ent));
+ }
+ } else {
+ fprintf(stderr, "\nFIRM: irn_vrfy_irg() <IRG %p> failed\n", (void *)irg);
+ }
+ }
+}
+
+/**
+ * Prints a failure for a Node
+ */
+static void show_node_failure(ir_node *n)
+{
+ show_entity_failure(n);
+ fprintf(stderr, " node %ld %s%s\n" ,
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n)
+ );
+}
+
+/**
+ * Prints a failure message for a binop
+ */
+static void show_binop_failure(ir_node *n, const char *text)
+{
+ ir_node *left = get_binop_left(n);
+ ir_node *right = get_binop_right(n);
+
+ show_entity_failure(n);
+ fprintf(stderr, " node %ld %s%s(%s%s, %s%s) did not match (%s)\n",
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n),
+ get_irn_opname(left), get_irn_modename(left),
+ get_irn_opname(right), get_irn_modename(right),
+ text);
+}
+
+/**
+ * Prints a failure message for an unop
+ */
+static void show_unop_failure(ir_node *n, const char *text)
+{
+ ir_node *op = get_unop_op(n);
+
+ show_entity_failure(n);
+ fprintf(stderr, " node %ld %s%s(%s%s) did not match (%s)\n",
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n),
+ get_irn_opname(op), get_irn_modename(op),
+ text);
+}
+
+/**
+ * Prints a failure message for an op with 3 operands
+ */
+static void show_triop_failure(ir_node *n, const char *text)
+{
+ ir_node *op0 = get_irn_n(n, 0);
+ ir_node *op1 = get_irn_n(n, 1);
+ ir_node *op2 = get_irn_n(n, 2);
+
+ show_entity_failure(n);
+ fprintf(stderr, " of node %ld %s%s(%s%s, %s%s, %s%s) did not match (%s)\n",
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n),
+ get_irn_opname(op0), get_irn_modename(op0),
+ get_irn_opname(op1), get_irn_modename(op1),
+ get_irn_opname(op2), get_irn_modename(op2),
+ text);
+}
+
+/**
+ * Prints a failure message for a proj
+ */
+static void show_proj_failure(ir_node *n)
+{
+ ir_node *op = get_Proj_pred(n);
+ int proj = get_Proj_proj(n);
+
+ show_entity_failure(n);
+ fprintf(stderr, " node %ld %s%s %d(%s%s) failed\n" ,
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n), proj,
+ get_irn_opname(op), get_irn_modename(op));
+}
+
+/**
+ * Prints a failure message for a proj from Start
+ */
+static void show_proj_mode_failure(ir_node *n, ir_type *ty)
+{
+ long proj = get_Proj_proj(n);
+ ir_mode *m = get_type_mode(ty);
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), ty);
+
+ show_entity_failure(n);
+ fprintf(stderr, " Proj %ld mode %s proj %ld (type %s mode %s) failed\n" ,
+ get_irn_node_nr(n),
+ get_irn_modename(n),
+ proj,
+ type_name,
+ get_mode_name_ex(m));
+}
+
+/**
+ * Prints a failure message for a proj
+ */
+static void show_proj_failure_ent(ir_node *n, ir_entity *ent)
+{
+ ir_node *op = get_Proj_pred(n);
+ int proj = get_Proj_proj(n);
+ ir_mode *m = get_type_mode(get_entity_type(ent));
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), get_entity_type(ent));
+
+ show_entity_failure(n);
+ fprintf(stderr, " node %ld %s%s %d(%s%s) entity %s(type %s mode %s)failed\n" ,
+ get_irn_node_nr(n),
+ get_irn_opname(n), get_irn_modename(n), proj,
+ get_irn_opname(op), get_irn_modename(op),
+ get_entity_name(ent), type_name,
+ get_mode_name_ex(m));
+}
+
+/**
+ * Show a node and a graph
+ */
+static void show_node_on_graph(ir_graph *irg, ir_node *n)
+{
+ ir_fprintf(stderr, "\nFIRM: irn_vrfy_irg() of %+F, node %+F\n", irg, n);
+}
+
+/**
+ * Show call parameters
+ */
+static void show_call_param(ir_node *n, ir_type *mt)
+{
+ int i;
+ char type_name[256];
+ ir_print_type(type_name, sizeof(type_name), mt);
+
+ show_entity_failure(n);
+ fprintf(stderr, " Call type-check failed: %s(", type_name);
+ for (i = 0; i < get_method_n_params(mt); ++i) {
+ fprintf(stderr, "%s ", get_mode_name_ex(get_type_mode(get_method_param_type(mt, i))));
+ }
+ fprintf(stderr, ") != CALL(");
+
+ for (i = 0; i < get_Call_n_params(n); ++i) {
+ fprintf(stderr, "%s ", get_mode_name_ex(get_irn_mode(get_Call_param(n, i))));
+ }
+ fprintf(stderr, ")\n");
+}
+
+/**
+ * Show return modes
+ */
+static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i)
+{
+ ir_entity *ent = get_irg_entity(irg);
+
+ show_entity_failure(n);
+ fprintf(stderr, " Return node %ld in entity \"%s\" mode %s different from type mode %s\n",
+ get_irn_node_nr(n), get_entity_name(ent),
+ get_mode_name_ex(get_irn_mode(get_Return_res(n, i))),
+ get_mode_name_ex(get_type_mode(get_method_res_type(mt, i)))
+ );
+}
+
+/**
+ * Show return number of results
+ */
+static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt)
+{
+ ir_entity *ent = get_irg_entity(irg);
+
+ show_entity_failure(n);
+ fprintf(stderr, " Return node %ld in entity \"%s\" has %d results different from type %d\n",
+ get_irn_node_nr(n), get_entity_name(ent),
+ get_Return_n_ress(n), get_method_n_ress(mt));
+}
+
+/**
+ * Show Phi input
+ */
+static void show_phi_failure(ir_node *phi, ir_node *pred, int pos)
+{
+ (void) pos;
+ show_entity_failure(phi);
+ fprintf(stderr, " Phi node %ld has mode %s different from predeccessor node %ld mode %s\n",
+ get_irn_node_nr(phi), get_mode_name_ex(get_irn_mode(phi)),
+ get_irn_node_nr(pred), get_mode_name_ex(get_irn_mode(pred)));
+}
+
+/**
+ * Show Phi inputs
+ */
+static void show_phi_inputs(ir_node *phi, ir_node *block)
+{
+ show_entity_failure(phi);
+ fprintf(stderr, " Phi node %ld has %d inputs, its Block %ld has %d\n",
+ get_irn_node_nr(phi), get_irn_arity(phi),
+ get_irn_node_nr(block), get_irn_arity(block));
+}
+
+#endif /* #ifndef NDEBUG */
+
+/**
+ * If the address is Sel or SymConst, return the entity.
+ *
+ * @param ptr the node representing the address
+ */
+static ir_entity *get_ptr_entity(ir_node *ptr)
+{
+ if (is_Sel(ptr)) {
+ return get_Sel_entity(ptr);
+ } else if (is_SymConst_addr_ent(ptr)) {
+ return get_SymConst_entity(ptr);
+ }
+ return NULL;
+}
+
+/**
+ * verify a Proj(Start) node
+ */
+static int verify_node_Proj_Start(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ (void) n;
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Start_X_initial_exec && mode == mode_X) ||
+ (proj == pn_Start_M && mode == mode_M) ||
+ (proj == pn_Start_P_frame_base && mode_is_reference(mode)) ||
+ (proj == pn_Start_P_tls && mode_is_reference(mode)) ||
+ (proj == pn_Start_T_args && mode == mode_T)
+ ),
+ "wrong Proj from Start", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(Cond) node
+ */
+static int verify_node_Proj_Cond(ir_node *pred, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj >= 0 && mode == mode_X && get_irn_mode(get_Cond_selector(pred)) == mode_b) || /* compare */
+ (mode == mode_X && mode_is_int(get_irn_mode(get_Cond_selector(pred)))) || /* switch */
+ is_Bad(get_Cond_selector(pred)) /* rare */
+ ),
+ "wrong Proj from Cond", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(Raise) node
+ */
+static int verify_node_Proj_Raise(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ (void) n;
+
+ ASSERT_AND_RET_DBG(
+ ((proj == pn_Raise_X && mode == mode_X) || (proj == pn_Raise_M && mode == mode_M)),
+ "wrong Proj from Raise", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(InstOf) node
+ */
+static int verify_node_Proj_InstOf(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ (void) n;
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_InstOf_M && mode == mode_M) ||
+ (proj == pn_InstOf_X_regular && mode == mode_X) ||
+ (proj == pn_InstOf_X_except && mode == mode_X) ||
+ (proj == pn_InstOf_res && mode_is_reference(mode))
+ ),
+ "wrong Proj from InstOf", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(Call) node
+ */
+static int verify_node_Proj_Call(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Call_M && mode == mode_M) ||
+ (proj == pn_Call_X_regular && mode == mode_X) ||
+ (proj == pn_Call_X_except && mode == mode_X) ||
+ (proj == pn_Call_T_result && mode == mode_T) ||
+ (proj == pn_Call_P_value_res_base && mode_is_reference(mode))
+ ),
+ "wrong Proj from Call", 0,
+ show_proj_failure(p);
+ );
+ /* if we have exception flow, we must have a real Memory input */
+ if (proj == pn_Call_X_regular)
+ ASSERT_AND_RET(
+ !is_NoMem(get_Call_mem(n)),
+ "Regular Proj from FunctionCall", 0);
+ else if (proj == pn_Call_X_except)
+ ASSERT_AND_RET(
+ !is_NoMem(get_Call_mem(n)),
+ "Exception Proj from FunctionCall", 0);
+ else if (proj == pn_Call_M)
+ ASSERT_AND_RET(
+ (!is_NoMem(get_Call_mem(n)) || 1),
+ "Memory Proj from FunctionCall", 0);
+ return 1;
+}
+
+/**
+ * verify a Proj(Quot) node
+ */
+static int verify_node_Proj_Quot(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Quot_M && mode == mode_M) ||
+ (proj == pn_Quot_X_regular && mode == mode_X) ||
+ (proj == pn_Quot_X_except && mode == mode_X) ||
+ (proj == pn_Quot_res && mode_is_float(mode) && mode == get_Quot_resmode(n))
+ ),
+ "wrong Proj from Quot", 0,
+ show_proj_failure(p);
+ );
+ if (proj == pn_Quot_X_regular)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned Quot", 0);
+ else if (proj == pn_Quot_X_except)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned Quot", 0);
+ else if (proj == pn_Quot_M)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Memory Proj from unpinned Quot", 0);
+ return 1;
+}
+
+/**
+ * verify a Proj(DivMod) node
+ */
+static int verify_node_Proj_DivMod(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_DivMod_M && mode == mode_M) ||
+ (proj == pn_DivMod_X_regular && mode == mode_X) ||
+ (proj == pn_DivMod_X_except && mode == mode_X) ||
+ (proj == pn_DivMod_res_div && mode_is_int(mode) && mode == get_DivMod_resmode(n)) ||
+ (proj == pn_DivMod_res_mod && mode_is_int(mode) && mode == get_DivMod_resmode(n))
+ ),
+ "wrong Proj from DivMod", 0,
+ show_proj_failure(p);
+ );
+ if (proj == pn_DivMod_X_regular)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned DivMod", 0);
+ else if (proj == pn_DivMod_X_except)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned DivMod", 0);
+ else if (proj == pn_DivMod_M)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Memory Proj from unpinned DivMod", 0);
+ return 1;
+}
+
+/**
+ * verify a Proj(Div) node
+ */
+static int verify_node_Proj_Div(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Div_M && mode == mode_M) ||
+ (proj == pn_Div_X_regular && mode == mode_X) ||
+ (proj == pn_Div_X_except && mode == mode_X) ||
+ (proj == pn_Div_res && mode_is_int(mode) && mode == get_Div_resmode(n))
+ ),
+ "wrong Proj from Div", 0,
+ show_proj_failure(p);
+ );
+ if (proj == pn_Div_X_regular)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned Div", 0);
+ else if (proj == pn_Div_X_except)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned Div", 0);
+ else if (proj == pn_Div_M)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Memory Proj from unpinned Div", 0);
+ return 1;
+}
+
+/**
+ * verify a Proj(Mod) node
+ */
+static int verify_node_Proj_Mod(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Mod_M && mode == mode_M) ||
+ (proj == pn_Mod_X_regular && mode == mode_X) ||
+ (proj == pn_Mod_X_except && mode == mode_X) ||
+ (proj == pn_Mod_res && mode_is_int(mode) && mode == get_Mod_resmode(n))
+ ),
+ "wrong Proj from Mod", 0,
+ show_proj_failure(p);
+ );
+ if (proj == pn_Mod_X_regular)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned Mod", 0);
+ else if (proj == pn_Mod_X_except)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned Mod", 0);
+ else if (proj == pn_Mod_M)
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Memory Proj from unpinned Div", 0);
+ return 1;
+}
+
+/**
+ * verify a Proj(Cmp) node
+ */
+static int verify_node_Proj_Cmp(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ (void) n;
+
+ ASSERT_AND_RET_DBG(
+ (proj >= 0 && proj <= 15 && mode == mode_b),
+ "wrong Proj from Cmp", 0,
+ show_proj_failure(p);
+ );
+ ASSERT_AND_RET_DBG(
+ (mode_is_float(get_irn_mode(get_Cmp_left(n))) || !(proj & pn_Cmp_Uo)),
+ "unordered Proj for non-float Cmp", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(Load) node
+ */
+static int verify_node_Proj_Load(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ if (proj == pn_Load_res) {
+ ir_node *ptr = get_Load_ptr(n);
+ ir_entity *ent = get_ptr_entity(ptr);
+
+ if (vrfy_entities && ent && get_irg_phase_state(current_ir_graph) == phase_high) {
+ /* do NOT check this for lowered phases, see comment on Store */
+ ASSERT_AND_RET_DBG(
+ (mode == get_type_mode(get_entity_type(ent))),
+ "wrong data Proj from Load, entity type_mode failed", 0,
+ show_proj_failure_ent(p, ent);
+ );
+ }
+ else {
+ ASSERT_AND_RET_DBG(
+ mode_is_data(mode) && mode == get_Load_mode(n),
+ "wrong data Proj from Load", 0,
+ show_proj_failure(p);
+ );
+ }
+ }
+ else {
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Load_M && mode == mode_M) ||
+ (proj == pn_Load_X_regular && mode == mode_X) ||
+ (proj == pn_Load_X_except && mode == mode_X)
+ ),
+ "wrong Proj from Load", 0,
+ show_proj_failure(p);
+ );
+ }
+ if (proj == pn_Load_X_regular) {
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned Load", 0);
+ } else if (proj == pn_Load_X_except) {
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned Load", 0);
+ }
+ return 1;
+}
+
+/**
+ * verify a Proj(Store) node
+ */
+static int verify_node_Proj_Store(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Store_M && mode == mode_M) ||
+ (proj == pn_Store_X_regular && mode == mode_X) ||
+ (proj == pn_Store_X_except && mode == mode_X)
+ ),
+ "wrong Proj from Store", 0,
+ show_proj_failure(p);
+ );
+ if (proj == pn_Store_X_regular) {
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Regular Proj from unpinned Store", 0);
+ } else if (proj == pn_Store_X_except) {
+ ASSERT_AND_RET(
+ get_irn_pinned(n) == op_pin_state_pinned,
+ "Exception Proj from unpinned Store", 0);
+ }
+ return 1;
+}
+
+/**
+ * verify a Proj(Alloc) node
+ */
+static int verify_node_Proj_Alloc(ir_node *n, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ (void) n;
+
+ ASSERT_AND_RET_DBG(
+ (
+ (proj == pn_Alloc_M && mode == mode_M) ||
+ (proj == pn_Alloc_X_regular && mode == mode_X) ||
+ (proj == pn_Alloc_X_except && mode == mode_X) ||
+ (proj == pn_Alloc_res && mode_is_reference(mode))
+ ),
+ "wrong Proj from Alloc", 0,
+ show_proj_failure(p);
+ );
+ return 1;
+}
+
+/**
+ * verify a Proj(Proj) node
+ */
+static int verify_node_Proj_Proj(ir_node *pred, ir_node *p)
+{
+ ir_mode *mode = get_irn_mode(p);
+ long proj = get_Proj_proj(p);
+ long nr = get_Proj_proj(pred);
+ ir_type *mt; /* A method type */
+
+ pred = skip_Id(get_Proj_pred(pred));
+ ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0);
+
+ switch (get_irn_opcode(pred)) {
+ case iro_Start:
+ mt = get_entity_type(get_irg_entity(get_irn_irg(pred)));
+
+ if (nr == pn_Start_T_args) {
+ ASSERT_AND_RET(
+ (proj >= 0 && mode_is_datab(mode)),
+ "wrong Proj from Proj from Start", 0);
+ ASSERT_AND_RET(
+ (proj < get_method_n_params(mt)),
+ "More Projs for args than args in type", 0
+ );
+ if ((mode_is_reference(mode)) && is_compound_type(get_method_param_type(mt, proj)))
+ /* value argument */ break;
+
+ if (get_irg_phase_state(get_irn_irg(pred)) != phase_backend) {
+ ASSERT_AND_RET_DBG(
+ (mode == get_type_mode(get_method_param_type(mt, proj))),
+ "Mode of Proj from Start doesn't match mode of param type.", 0,
+ show_proj_mode_failure(p, get_method_param_type(mt, proj));
+ );
+ }
+ }
+ break;
+
+ case iro_Call:
+ {
+ ASSERT_AND_RET(
+ (proj >= 0 && mode_is_datab(mode)),
+ "wrong Proj from Proj from Call", 0);
+ mt = get_Call_type(pred);
+ ASSERT_AND_RET(
+ (proj < get_method_n_ress(mt)),
+ "More Projs for results than results in type.", 0);
+ if ((mode_is_reference(mode)) && is_compound_type(get_method_res_type(mt, proj)))
+ /* value result */ break;
+
+ ASSERT_AND_RET(
+ (mode == get_type_mode(get_method_res_type(mt, proj))),
+ "Mode of Proj from Call doesn't match mode of result type.", 0);
+ }
+ break;
+
+ case iro_Tuple:
+ /* We don't test */
+ break;
+
+ case iro_Bad:
+ /* hmm, optimization did not remove it */
+ break;
+
+ default:
+ /* ASSERT_AND_RET(0, "Unknown opcode", 0); */
+ break;
+ }
+ return 1;
+}
+
+/**
+ * verify a Proj(Tuple) node
+ */
+static int verify_node_Proj_Tuple(ir_node *n, ir_node *p)
+{
+ (void) n;
+ (void) p;
+ /* We don't test */
+ return 1;
+}
+
+/**
+ * verify a Proj(CallBegin) node
+ */
+static int verify_node_Proj_CallBegin(ir_node *n, ir_node *p)
+{
+ (void) n;
+ (void) p;
+ return 1;
+}
+
+/**
+ * verify a Proj(EndReg) node
+ */
+static int verify_node_Proj_EndReg(ir_node *n, ir_node *p)
+{
+ (void) n;
+ (void) p;
+#ifdef INTERPROCEDURAL_VIEW
+ ASSERT_AND_RET(
+ (get_irp_ip_view_state() != ip_view_no),
+ "EndReg may only appear if ip view is constructed.", 0);