cleanup: Remove pointless assert(is_${NODE}(x)) just before get_${NODE}_${FOO}(x...

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index a4052fa..759e9af 100644 (file)
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -249,14 +249,11 @@ static void sel_methods_init(void)
 static ir_entity ** get_Sel_arr(ir_node * sel)
 {
        static ir_entity ** NULL_ARRAY = NULL;
-       ir_entity * ent;
-       ir_entity ** arr;
-
-       assert(is_Sel(sel));
-       ent = get_Sel_entity(sel);
 
+       ir_entity *const ent = get_Sel_entity(sel);
        assert(is_Method_type(get_entity_type(ent))); /* what else? */
-       arr = (ir_entity**) get_entity_link(ent);
+
+       ir_entity **const arr = (ir_entity**)get_entity_link(ent);
        if (arr) {
                return arr;
        } else {

diff --git a/ir/ana/ircfscc.c b/ir/ana/ircfscc.c
index 53074ca..89dd5bd 100644 (file)
--- a/ir/ana/ircfscc.c
+++ b/ir/ana/ircfscc.c
@@ -327,14 +327,11 @@ static inline void finish_scc(void)
  */
 static int is_head(ir_node *n, ir_node *root)
 {
-       int i, arity;
        int some_outof_loop = 0, some_in_loop = 0;
        (void) root;
 
-       assert(is_Block(n));
-
-       arity = get_Block_n_cfgpreds(n);
-       for (i = 0; i < arity; i++) {
+       int const arity = get_Block_n_cfgpreds(n);
+       for (int i = 0; i < arity; i++) {
                ir_node *pred = get_Block_cfgpred_block(n, i);
                /* ignore Bad control flow: it cannot happen */
                if (is_Bad(pred))
@@ -362,14 +359,12 @@ static int is_head(ir_node *n, ir_node *root)
  */
 static int is_endless_head(ir_node *n, ir_node *root)
 {
-       int i, arity;
        int none_outof_loop = 1, some_in_loop = 0;
        (void) root;
 
-       assert(is_Block(n));
        /* Test for legal loop header: Block, Phi, ... */
-       arity = get_Block_n_cfgpreds(n);
-       for (i = 0; i < arity; i++) {
+       int const arity = get_Block_n_cfgpreds(n);
+       for (int i = 0; i < arity; i++) {
                ir_node *pred = get_Block_cfgpred_block(n, i);
                /* ignore Bad control flow: it cannot happen */
                if (is_Bad(pred))

diff --git a/ir/ana/irdom.c b/ir/ana/irdom.c
index c259536..2b98e13 100644 (file)
--- a/ir/ana/irdom.c
+++ b/ir/ana/irdom.c
@@ -44,7 +44,6 @@
 
 ir_node *get_Block_idom(const ir_node *bl)
 {
-       assert(is_Block(bl));
        if (get_Block_dom_depth(bl) == -1) {
                /* This block is not reachable from Start */
                ir_graph *irg = get_irn_irg(bl);
@@ -76,7 +75,6 @@ void set_Block_idom(ir_node *bl, ir_node *n)
 
 ir_node *get_Block_ipostdom(const ir_node *bl)
 {
-       assert(is_Block(bl));
        if (get_Block_postdom_depth(bl) == -1) {
                /* This block is not reachable from Start */
                ir_graph *irg = get_irn_irg(bl);
@@ -432,7 +430,6 @@ static void init_tmp_dom_info(ir_node *bl, tmp_dom_info *parent,
        tmp_dom_info *tdi;
        int i;
 
-       assert(is_Block(bl));
        if (Block_block_visited(bl))
          return;
        mark_Block_block_visited(bl);
@@ -471,7 +468,6 @@ static void init_tmp_pdom_info(ir_node *bl, tmp_dom_info *parent,
        tmp_dom_info *tdi;
        int i;
 
-       assert(is_Block(bl));
        if (get_irg_block_visited(current_ir_graph) == get_Block_block_visited(bl))
          return;
        mark_Block_block_visited(bl);
@@ -493,7 +489,6 @@ static void init_tmp_pdom_info(ir_node *bl, tmp_dom_info *parent,
                ir_node *pred = get_Block_cfgpred_block(bl, i);
                if (is_Bad(pred))
                        continue;
-               assert(is_Block(pred));
                init_tmp_pdom_info(pred, tdi, tdi_list, used, n_blocks);
        }
 

diff --git a/ir/be/amd64/amd64_transform.c b/ir/be/amd64/amd64_transform.c
index 97a16e7..52af451 100644 (file)
--- a/ir/be/amd64/amd64_transform.c
+++ b/ir/be/amd64/amd64_transform.c
@@ -219,22 +219,16 @@ static ir_node *gen_Cond(ir_node *node)
 {
        ir_node    *selector = get_Cond_selector(node);
        ir_mode    *mode     = get_irn_mode(selector);
-       ir_node    *block;
-       ir_node    *flag_node;
-       ir_relation relation;
-       dbg_info   *dbgi;
 
        if (mode != mode_b) {
                panic ("create_Switch not implemented yet!");
                // return gen_SwitchJmp(node);
        }
-       assert(is_Cmp(selector));
-
-       block     = be_transform_node(get_nodes_block(node));
-       dbgi      = get_irn_dbg_info(node);
-       flag_node = be_transform_node(selector);
-       relation  = get_Cmp_relation(selector);
 
+       ir_node    *const block     = be_transform_node(get_nodes_block(node));
+       dbg_info   *const dbgi      = get_irn_dbg_info(node);
+       ir_node    *const flag_node = be_transform_node(selector);
+       ir_relation const relation  = get_Cmp_relation(selector);
        return new_bd_amd64_Jcc(dbgi, block, flag_node, relation);
 }
 

diff --git a/ir/be/arm/arm_transform.c b/ir/be/arm/arm_transform.c
index 22f6b86..0db11bd 100644 (file)
--- a/ir/be/arm/arm_transform.c
+++ b/ir/be/arm/arm_transform.c
@@ -1065,19 +1065,11 @@ static ir_node *gen_Cmp(ir_node *node)
 
 static ir_node *gen_Cond(ir_node *node)
 {
-       ir_node    *selector = get_Cond_selector(node);
-       ir_relation relation;
-       ir_node    *block;
-       ir_node    *flag_node;
-       dbg_info   *dbgi;
-
-       assert(is_Cmp(selector));
-
-       block     = be_transform_node(get_nodes_block(node));
-       dbgi      = get_irn_dbg_info(node);
-       flag_node = be_transform_node(selector);
-       relation  = get_Cmp_relation(selector);
-
+       ir_node    *const block     = be_transform_node(get_nodes_block(node));
+       dbg_info   *const dbgi      = get_irn_dbg_info(node);
+       ir_node    *const selector  = get_Cond_selector(node);
+       ir_node    *const flag_node = be_transform_node(selector);
+       ir_relation const relation  = get_Cmp_relation(selector);
        return new_bd_arm_B(dbgi, block, flag_node, relation);
 }
 

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index dc875fd..bd6c48d 100644 (file)
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -505,12 +505,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
                        continue;
 
                foreach_out_edge(irn, res_edge) {
-                       int proj;
-                       ir_node *res = get_edge_src_irn(res_edge);
-
-                       assert(is_Proj(res));
-
-                       proj = get_Proj_proj(res);
+                       ir_node *const res  = get_edge_src_irn(res_edge);
+                       long     const proj = get_Proj_proj(res);
                        assert(proj < n_res);
                        assert(res_projs[proj] == NULL);
                        res_projs[proj] = res;
@@ -775,7 +771,6 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
        foreach_out_edge(alloc, edge) {
                ir_node *irn = get_edge_src_irn(edge);
 
-               assert(is_Proj(irn));
                switch (get_Proj_proj(irn)) {
                case pn_Alloc_M:
                        alloc_mem = irn;

diff --git a/ir/be/becopystat.c b/ir/be/becopystat.c
index 7063e98..f37983f 100644 (file)
--- a/ir/be/becopystat.c
+++ b/ir/be/becopystat.c
@@ -142,10 +142,9 @@ static inline int was_edge_critical(const ir_node *bl, int pos)
 {
        const ir_edge_t *edge;
        const ir_node *bl_at_pos, *bl_before;
-       assert(is_Block(bl));
 
        /* Does bl have several predecessors ?*/
-       if (get_irn_arity(bl) <= 1)
+       if (get_Block_n_cfgpreds(bl) <= 1)
                return 0;
 
        /* Does the pred have exactly one predecessor */

diff --git a/ir/be/bespillutil.c b/ir/be/bespillutil.c
index b4b2005..44c933b 100644 (file)
--- a/ir/be/bespillutil.c
+++ b/ir/be/bespillutil.c
@@ -426,20 +426,16 @@ static void spill_phi(spill_env_t *env, spill_info_t *spillinfo)
        ir_graph *irg   = env->irg;
        ir_node  *phi   = spillinfo->to_spill;
        ir_node  *block = get_nodes_block(phi);
-       ir_node  *unknown;
-       ir_node **ins;
        spill_t  *spill;
        int       i;
-       int       arity;
 
-       assert(is_Phi(phi));
        assert(!get_opt_cse());
        DBG((dbg, LEVEL_1, "spilling Phi %+F:\n", phi));
 
        /* build a new PhiM */
-       arity   = get_irn_arity(phi);
-       ins     = ALLOCAN(ir_node*, arity);
-       unknown = new_r_Unknown(irg, mode_M);
+       int       const arity   = get_Phi_n_preds(phi);
+       ir_node **const ins     = ALLOCAN(ir_node*, arity);
+       ir_node  *const unknown = new_r_Unknown(irg, mode_M);
        for (i = 0; i < arity; ++i) {
                ins[i] = unknown;
        }

diff --git a/ir/be/beverify.c b/ir/be/beverify.c
index d8b2db4..0e47ce8 100644 (file)
--- a/ir/be/beverify.c
+++ b/ir/be/beverify.c
@@ -381,8 +381,6 @@ static void collect_spill(be_verify_spillslots_env_t *env, ir_node *node, ir_nod
 
 static void collect_memperm(be_verify_spillslots_env_t *env, ir_node *node, ir_node *reload, ir_entity* ent)
 {
-       assert(is_Proj(node));
-
        ir_node *memperm = get_Proj_pred(node);
        int      out     = get_Proj_proj(node);
 

diff --git a/ir/be/ia32/ia32_optimize.c b/ir/be/ia32/ia32_optimize.c
index 17e42dc..ff35459 100644 (file)
--- a/ir/be/ia32/ia32_optimize.c
+++ b/ir/be/ia32/ia32_optimize.c
@@ -381,7 +381,6 @@ static void peephole_IncSP_Store_to_push(ir_node *irn)
 {
        int       i;
        int       maxslot;
-       int       inc_ofs;
        ir_node  *node;
        ir_node  *stores[MAXPUSH_OPTIMIZE];
        ir_node  *block;
@@ -392,9 +391,7 @@ static void peephole_IncSP_Store_to_push(ir_node *irn)
 
        memset(stores, 0, sizeof(stores));
 
-       assert(be_is_IncSP(irn));
-
-       inc_ofs = be_get_IncSP_offset(irn);
+       int inc_ofs = be_get_IncSP_offset(irn);
        if (inc_ofs < 4)
                return;
 
@@ -653,16 +650,15 @@ static inline int mode_needs_gp_reg(ir_mode *mode)
 static void peephole_Load_IncSP_to_pop(ir_node *irn)
 {
        const arch_register_t *esp = &ia32_registers[REG_ESP];
-       int      i, maxslot, inc_ofs, ofs;
+       int      i, maxslot, ofs;
        ir_node  *node, *pred_sp, *block;
        ir_node  *loads[MAXPUSH_OPTIMIZE];
        unsigned regmask = 0;
        unsigned copymask = ~0;
 
        memset(loads, 0, sizeof(loads));
-       assert(be_is_IncSP(irn));
 
-       inc_ofs = -be_get_IncSP_offset(irn);
+       int inc_ofs = -be_get_IncSP_offset(irn);
        if (inc_ofs < 4)
                return;
 

diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c
index c0e0339..134fd1c 100644 (file)
--- a/ir/be/ia32/ia32_transform.c
+++ b/ir/be/ia32/ia32_transform.c
@@ -204,8 +204,6 @@ static ir_node *gen_Const(ir_node *node)
        ir_mode   *mode      = get_irn_mode(node);
        ir_tarval *tv        = get_Const_tarval(node);
 
-       assert(is_Const(node));
-
        if (mode_is_float(mode)) {
                ir_graph         *irg      = get_irn_irg(node);
                const arch_env_t *arch_env = be_get_irg_arch_env(irg);

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index 06c627b..881616c 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -313,7 +313,6 @@ void mature_immBlock(ir_node *block)
        ir_node  *phi;
        ir_graph *irg;
 
-       assert(is_Block(block));
        if (get_Block_matured(block))
                return;
 

diff --git a/ir/opt/boolopt.c b/ir/opt/boolopt.c
index 95a20f0..2fbca70 100644 (file)
--- a/ir/opt/boolopt.c
+++ b/ir/opt/boolopt.c
@@ -612,8 +612,6 @@ restart:
                for (up_idx = 0; up_idx < n_cfgpreds; ++up_idx) {
                        ir_node   *upper_block;
                        ir_node   *upper_cf;
-                       ir_node   *upper_cond;
-                       ir_node   *upper_cond_selector;
                        ir_node   *replacement;
                        cond_pair  cpair;
 
@@ -627,10 +625,8 @@ restart:
                        if (!block_dominates(upper_block, block))
                                continue;
 
-                       assert(is_Proj(upper_cf));
-                       upper_cond = get_Proj_pred(upper_cf);
-                       assert(is_Cond(upper_cond));
-                       upper_cond_selector = get_Cond_selector(upper_cond);
+                       ir_node *const upper_cond          = get_Proj_pred(upper_cf);
+                       ir_node *const upper_cond_selector = get_Cond_selector(upper_cond);
                        if (get_irn_mode(upper_cond_selector) != mode_b)
                                continue;
 

diff --git a/ir/opt/cfopt.c b/ir/opt/cfopt.c
index 7ca15da..43be0a2 100644 (file)
--- a/ir/opt/cfopt.c
+++ b/ir/opt/cfopt.c
@@ -355,8 +355,6 @@ static void optimize_blocks(ir_node *b, void *ctx)
 
                                        if (get_nodes_block(phi_pred) == pred) {
                                                /* case Phi 2a: */
-                                               assert(is_Phi(phi_pred));  /* Block is empty!! */
-
                                                in[p_preds++] = get_Phi_pred(phi_pred, j);
                                        } else {
                                                /* case Phi 2b: */

diff --git a/ir/opt/ircgopt.c b/ir/opt/ircgopt.c
index ce9e411..9ec21ea 100644 (file)
--- a/ir/opt/ircgopt.c
+++ b/ir/opt/ircgopt.c
@@ -100,10 +100,7 @@ void gc_irgs(size_t n_keep, ir_entity ** keep_arr)
                        /* iterate calls */
                        for (node = (ir_node*)get_irn_link(node); node != NULL;
                             node = (ir_node*)get_irn_link(node)) {
-                               size_t i;
-                               assert(is_Call(node));
-
-                               for (i = get_Call_n_callees(node); i > 0;) {
+                               for (size_t i = get_Call_n_callees(node); i > 0;) {
                                        ir_entity *ent = get_Call_callee(node, --i);
 
                                        if (get_entity_irg(ent) && get_entity_link(ent) != MARK) {

diff --git a/ir/opt/jumpthreading.c b/ir/opt/jumpthreading.c
index 48fba5e..6340309 100644 (file)
--- a/ir/opt/jumpthreading.c
+++ b/ir/opt/jumpthreading.c
@@ -58,14 +58,10 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 static void add_pred(ir_node* node, ir_node* x)
 {
        ir_node** ins;
-       int n;
-       int i;
-
-       assert(is_Block(node));
 
-       n = get_irn_arity(node);
+       int const n = get_Block_n_cfgpreds(node);
        NEW_ARR_A(ir_node*, ins, n + 1);
-       for (i = 0; i < n; i++)
+       for (int i = 0; i < n; i++)
                ins[i] = get_irn_n(node, i);
        ins[n] = x;
        set_irn_in(node, n + 1, ins);
@@ -298,13 +294,8 @@ static void copy_and_fix(const jumpthreading_env_t *env, ir_node *block,
                 * mode_bs which can't be handled in all backends. Instead we duplicate
                 * the node and move it to its users */
                if (mode == mode_b) {
-                       ir_node *pred;
-                       int      pn;
-
-                       assert(is_Proj(node));
-
-                       pred = get_Proj_pred(node);
-                       pn   = get_Proj_proj(node);
+                       ir_node *const pred = get_Proj_pred(node);
+                       long     const pn   = get_Proj_proj(node);
 
                        foreach_out_edge_safe(node, edge) {
                                ir_node *cmp_copy;

diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c
index f40db3d..6c86243 100644 (file)
--- a/ir/opt/ldstopt.c
+++ b/ir/opt/ldstopt.c
@@ -330,7 +330,6 @@ static ir_entity *find_constant_entity(ir_node *ptr)
 static long get_Sel_array_index_long(ir_node *n, int dim)
 {
        ir_node *index = get_Sel_index(n, dim);
-       assert(is_Const(index));
        return get_tarval_long(get_Const_tarval(index));
 }
 
@@ -1431,12 +1430,9 @@ static unsigned optimize_phi(ir_node *phi, walk_env_t *wenv)
           memory Proj.
         */
        for (i = n - 1; i >= 0; --i) {
-               ir_node *store;
-
                projMs[i] = get_Phi_pred(phi, i);
-               assert(is_Proj(projMs[i]));
 
-               store = get_Proj_pred(projMs[i]);
+               ir_node *const store = get_Proj_pred(projMs[i]);
                info  = (ldst_info_t*)get_irn_link(store);
 
                inM[i] = get_Store_mem(store);

diff --git a/ir/opt/loop.c b/ir/opt/loop.c
index b9d98a8..96d0ab2 100644 (file)
--- a/ir/opt/loop.c
+++ b/ir/opt/loop.c
@@ -595,7 +595,6 @@ static void extend_ins_by_copy(ir_node *block, int pos)
 {
        ir_node *new_in;
        ir_node *phi;
-       assert(is_Block(block));
 
        /* Extend block by copy of definition at pos */
        ir_node *const pred = get_Block_cfgpred(block, pos);
@@ -1554,12 +1553,11 @@ static void copy_loop(entry_edge *cur_loop_outs, int copies)
 static ir_node *clone_phis_sans_bes(ir_node *phi, ir_node *be_block, ir_node *dest_block)
 {
        ir_node **ins;
-       int arity = get_irn_arity(phi);
        int i, c = 0;
        ir_node *newphi;
 
-       assert(get_irn_arity(phi) == get_irn_arity(be_block));
-       assert(is_Phi(phi));
+       int const arity = get_Phi_n_preds(phi);
+       assert(arity == get_Block_n_cfgpreds(be_block));
 
        ins = NEW_ARR_F(ir_node *, arity);
        for (i = 0; i < arity; ++i) {
@@ -1581,12 +1579,11 @@ static ir_node *clone_phis_sans_bes(ir_node *phi, ir_node *be_block, ir_node *de
  * using be_block as supplier of backedge informations. */
 static ir_node *clone_block_sans_bes(ir_node *node, ir_node *be_block)
 {
-       int arity = get_irn_arity(node);
        int i, c = 0;
        ir_node **ins;
 
-       assert(get_irn_arity(node) == get_irn_arity(be_block));
-       assert(is_Block(node));
+       int const arity = get_Block_n_cfgpreds(node);
+       assert(arity == get_irn_arity(be_block));
 
        NEW_ARR_A(ir_node *, ins, arity);
        for (i = 0; i < arity; ++i) {

diff --git a/ir/opt/opt_ldst.c b/ir/opt/opt_ldst.c
index 1ed62db..75e6ace 100644 (file)
--- a/ir/opt/opt_ldst.c
+++ b/ir/opt/opt_ldst.c
@@ -626,7 +626,6 @@ static ir_entity *find_constant_entity(ir_node *ptr)
 static long get_Sel_array_index_long(ir_node *n, int dim)
 {
        ir_node *index = get_Sel_index(n, dim);
-       assert(is_Const(index));
        return get_tarval_long(get_Const_tarval(index));
 }
 

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index d61b233..4b1f5d8 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -514,7 +514,6 @@ static void reorder_weights(q_set *hmap, float threshold)
 {
        entry_t **adr, *p, *entry;
        size_t i, len;
-       ir_entity *callee;
 
 restart:
        entry = hmap->heavy_uses;
@@ -530,9 +529,8 @@ restart:
 
                /* we know, that a SymConst is here */
                ptr = get_Call_ptr(call);
-               assert(is_SymConst(ptr));
 
-               callee = get_SymConst_entity(ptr);
+               ir_entity *const callee = get_SymConst_entity(ptr);
                if (callee != entry->q.ent) {
                        /*
                         * This call is already changed because of a previous

diff --git a/ir/opt/tailrec.c b/ir/opt/tailrec.c
index a9bb369..e1945ea 100644 (file)
--- a/ir/opt/tailrec.c
+++ b/ir/opt/tailrec.c
@@ -304,15 +304,13 @@ static void do_opt_tail_rec(ir_graph *irg, tr_env *env)
                /* no: we can kill all returns */
                for (p = env->rets; p; p = n) {
                        ir_node *block = get_nodes_block(p);
-                       ir_node *call, *mem, *jmp, *tuple;
+                       ir_node *jmp, *tuple;
 
                        set_r_cur_block(irg, block);
                        n = (ir_node*)get_irn_link(p);
 
-                       call = skip_Proj(get_Return_mem(p));
-                       assert(is_Call(call));
-
-                       mem = get_Call_mem(call);
+                       ir_node *const call = skip_Proj(get_Return_mem(p));
+                       ir_node *const mem  = get_Call_mem(call);
 
                        /* create a new jump, free of CSE */
                        set_optimize(0);

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index 40b6ebe..4b44c43 100644 (file)
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -58,7 +58,6 @@ static void copy_entities_from_superclass(ir_type *clss, void *env)
 
        for (i = 0; i < get_class_n_supertypes(clss); i++) {
                super = get_class_supertype(clss, i);
-               assert(is_Class_type(super) && "not a class");
                for (j = 0; j < get_class_n_members(super); j++) {
                        inhent = get_class_member(super, j);
                        /* check whether inhent is already overwritten */
@@ -231,8 +230,6 @@ static void compute_down_closure(ir_type *tp)
        size_t i, n_subtypes, n_members, n_supertypes;
        ir_visited_t master_visited = get_master_type_visited();
 
-       assert(is_Class_type(tp));
-
        set_type_visited(tp, master_visited-1);
 
        /* Recursive descend. */
@@ -286,8 +283,6 @@ static void compute_up_closure(ir_type *tp)
        size_t i, n_subtypes, n_members, n_supertypes;
        ir_visited_t master_visited = get_master_type_visited();
 
-       assert(is_Class_type(tp));
-
        set_type_visited(tp, master_visited-1);
 
        /* Recursive descend. */

diff --git a/ir/tr/type.c b/ir/tr/type.c
index f4a22ea..f6d14c5 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -1547,7 +1547,6 @@ long get_array_lower_bound_int(const ir_type *array, size_t dimension)
        ir_node *node;
        assert(array->type_op == type_array);
        node = array->attr.aa.lower_bound[dimension];
-       assert(is_Const(node));
        return get_tarval_long(get_Const_tarval(node));
 }
 
@@ -1568,7 +1567,6 @@ long get_array_upper_bound_int(const ir_type *array, size_t dimension)
        ir_node *node;
        assert(array->type_op == type_array);
        node = array->attr.aa.upper_bound[dimension];
-       assert(is_Const(node));
        return get_tarval_long(get_Const_tarval(node));
 }
 

diff --git a/ir/tr/typewalk.c b/ir/tr/typewalk.c
index dbef3f2..2f07ca9 100644 (file)
--- a/ir/tr/typewalk.c
+++ b/ir/tr/typewalk.c
@@ -494,7 +494,6 @@ static void class_walk_s2s_2(ir_type *tp, class_walk_func *pre,
        /* marked? */
        if (type_visited(tp)) return;
 
-       assert(is_Class_type(tp));
        /* Assure all supertypes are visited before */
        n = get_class_n_supertypes(tp);
        for (i = 0; i < n; ++i) {