basic-block.h (BLOCK_HEAD, BLOCK_END): Remove.

2003-12-11  Steven Bosscher  <steven@gcc.gnu.org>

	* basic-block.h (BLOCK_HEAD, BLOCK_END): Remove.
	(BLOCK_HEAD_TREE, BLOCK_END_TREE): Remove.
	(basic_block_def): Rename `head' to `head_' and `end' to `end_'.
	(BB_HEAD, BB_END): New accessor macros for the `head_' and `end_'
	fields of a basic block.
	* bb-reorder.c, bt-load.c, caller-save.c, cfg.c, cfganal.c,
	cfgbuild.c, cfgcleanup.c, cfglayout.c, cfgloop.c, cfgloopanal.c,
	cfgloopmanip.c, cfgrtl.c, combine.c, conflict.c, df.c, emit-rtl.c,
	final.c, flow.c, function.c, gcse.c, global.c, graph.c,
	haifa-sched.c, ifcvt.c, lcm.c, local-alloc.c, loop-unswitch.c,
	loop.c, postreload.c, predict.c, profile.c, ra-build.c, ra-debug.c,
	ra-rewrite.c, ra.c, recog.c, reg-stack.c, regclass.c, regmove.c,
	regrename.c, reload1.c, resource.c, sched-ebb.c, sched-rgn.c,
	sibcall.c, tracer.c, config/frv/frv.c, config/i386/i386.c,
	config/ia64/ia64.c: Use the BB_HEAD and BB_END macros instead of
	accessing the `head' and `end' fields of a basic block directly.

	* gengtype.c: Add missing piece from earlier patch.  Dunno what
	I was thinking...

From-SVN: r74520

1 files changed, 76 insertions, 76 deletions

diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
index 32a9e653228..c0b929badd0 100644
--- a/gcc/cfgcleanup.c
+++ b/gcc/cfgcleanup.c
@@ -129,7 +129,7 @@ try_simplify_condjump (basic_block cbranch_block)
 
   /* Verify that we've got a normal conditional branch at the end
      of the block.  */
-  cbranch_insn = cbranch_block->end;
+  cbranch_insn = BB_END (cbranch_block);
   if (!any_condjump_p (cbranch_insn))
     return false;
 
@@ -159,7 +159,7 @@ try_simplify_condjump (basic_block cbranch_block)
 
   if (rtl_dump_file)
     fprintf (rtl_dump_file, "Simplifying condjump %i around jump %i\n",
-	     INSN_UID (cbranch_insn), INSN_UID (jump_block->end));
+	     INSN_UID (cbranch_insn), INSN_UID (BB_END (jump_block)));
 
   /* Success.  Update the CFG to match.  Note that after this point
      the edge variable names appear backwards; the redirection is done
@@ -172,19 +172,19 @@ try_simplify_condjump (basic_block cbranch_block)
   cbranch_fallthru_edge->flags &= ~EDGE_FALLTHRU;
   update_br_prob_note (cbranch_block);
 
-  end = jump_block->end;
+  end = BB_END (jump_block);
   /* Deleting a block may produce unreachable code warning even when we are
      not deleting anything live.  Supress it by moving all the line number
      notes out of the block.  */
-  for (insn = jump_block->head; insn != NEXT_INSN (jump_block->end);
+  for (insn = BB_HEAD (jump_block); insn != NEXT_INSN (BB_END (jump_block));
        insn = next)
     {
       next = NEXT_INSN (insn);
       if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
 	{
-	  if (insn == jump_block->end)
+	  if (insn == BB_END (jump_block))
 	    {
-	      jump_block->end = PREV_INSN (insn);
+	      BB_END (jump_block) = PREV_INSN (insn);
 	      if (insn == end)
 	        break;
 	    }
@@ -300,17 +300,17 @@ thread_jump (int mode, edge e, basic_block b)
     }
 
   /* Second branch must end with onlyjump, as we will eliminate the jump.  */
-  if (!any_condjump_p (e->src->end))
+  if (!any_condjump_p (BB_END (e->src)))
     return NULL;
 
-  if (!any_condjump_p (b->end) || !onlyjump_p (b->end))
+  if (!any_condjump_p (BB_END (b)) || !onlyjump_p (BB_END (b)))
     {
       BB_SET_FLAG (b, BB_NONTHREADABLE_BLOCK);
       return NULL;
     }
 
-  set1 = pc_set (e->src->end);
-  set2 = pc_set (b->end);
+  set1 = pc_set (BB_END (e->src));
+  set2 = pc_set (BB_END (b));
   if (((e->flags & EDGE_FALLTHRU) != 0)
       != (XEXP (SET_SRC (set1), 1) == pc_rtx))
     reverse1 = true;
@@ -318,12 +318,12 @@ thread_jump (int mode, edge e, basic_block b)
   cond1 = XEXP (SET_SRC (set1), 0);
   cond2 = XEXP (SET_SRC (set2), 0);
   if (reverse1)
-    code1 = reversed_comparison_code (cond1, e->src->end);
+    code1 = reversed_comparison_code (cond1, BB_END (e->src));
   else
     code1 = GET_CODE (cond1);
 
   code2 = GET_CODE (cond2);
-  reversed_code2 = reversed_comparison_code (cond2, b->end);
+  reversed_code2 = reversed_comparison_code (cond2, BB_END (b));
 
   if (!comparison_dominates_p (code1, code2)
       && !comparison_dominates_p (code1, reversed_code2))
@@ -339,7 +339,7 @@ thread_jump (int mode, edge e, basic_block b)
 
   /* Short circuit cases where block B contains some side effects, as we can't
      safely bypass it.  */
-  for (insn = NEXT_INSN (b->head); insn != NEXT_INSN (b->end);
+  for (insn = NEXT_INSN (BB_HEAD (b)); insn != NEXT_INSN (BB_END (b));
        insn = NEXT_INSN (insn))
     if (INSN_P (insn) && side_effects_p (PATTERN (insn)))
       {
@@ -350,7 +350,7 @@ thread_jump (int mode, edge e, basic_block b)
   cselib_init ();
 
   /* First process all values computed in the source basic block.  */
-  for (insn = NEXT_INSN (e->src->head); insn != NEXT_INSN (e->src->end);
+  for (insn = NEXT_INSN (BB_HEAD (e->src)); insn != NEXT_INSN (BB_END (e->src));
        insn = NEXT_INSN (insn))
     if (INSN_P (insn))
       cselib_process_insn (insn);
@@ -362,7 +362,7 @@ thread_jump (int mode, edge e, basic_block b)
      processing as if it were same basic block.
      Our goal is to prove that whole block is an NOOP.  */
 
-  for (insn = NEXT_INSN (b->head); insn != NEXT_INSN (b->end) && !failed;
+  for (insn = NEXT_INSN (BB_HEAD (b)); insn != NEXT_INSN (BB_END (b)) && !failed;
        insn = NEXT_INSN (insn))
     {
       if (INSN_P (insn))
@@ -509,7 +509,7 @@ try_forward_edges (int mode, basic_block b)
 	  if ((mode & CLEANUP_PRE_LOOP) && optimize)
 	    {
 	      rtx insn = (target->succ->flags & EDGE_FALLTHRU
-			  ? target->head : prev_nonnote_insn (target->end));
+			  ? BB_HEAD (target) : prev_nonnote_insn (BB_END (target)));
 
 	      if (GET_CODE (insn) != NOTE)
 		insn = NEXT_INSN (insn);
@@ -527,7 +527,7 @@ try_forward_edges (int mode, basic_block b)
 		 at this time; it can mess up the loop optimizer's
 		 recognition of some patterns.  */
 
-	      insn = PREV_INSN (target->head);
+	      insn = PREV_INSN (BB_HEAD (target));
 	      if (insn && GET_CODE (insn) == NOTE
 		    && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
 		break;
@@ -696,7 +696,7 @@ merge_blocks_move_predecessor_nojumps (basic_block a, basic_block b)
 {
   rtx barrier;
 
-  barrier = next_nonnote_insn (a->end);
+  barrier = next_nonnote_insn (BB_END (a));
   if (GET_CODE (barrier) != BARRIER)
     abort ();
   delete_insn (barrier);
@@ -708,12 +708,12 @@ merge_blocks_move_predecessor_nojumps (basic_block a, basic_block b)
      and adjust the block trees appropriately.   Even better would be to have
      a tighter connection between block trees and rtl so that this is not
      necessary.  */
-  if (squeeze_notes (&a->head, &a->end))
+  if (squeeze_notes (&BB_HEAD (a), &BB_END (a)))
     abort ();
 
   /* Scramble the insn chain.  */
-  if (a->end != PREV_INSN (b->head))
-    reorder_insns_nobb (a->head, a->end, PREV_INSN (b->head));
+  if (BB_END (a) != PREV_INSN (BB_HEAD (b)))
+    reorder_insns_nobb (BB_HEAD (a), BB_END (a), PREV_INSN (BB_HEAD (b)));
   a->flags |= BB_DIRTY;
 
   if (rtl_dump_file)
@@ -739,18 +739,18 @@ merge_blocks_move_successor_nojumps (basic_block a, basic_block b)
   rtx barrier, real_b_end;
   rtx label, table;
 
-  real_b_end = b->end;
+  real_b_end = BB_END (b);
 
   /* If there is a jump table following block B temporarily add the jump table
      to block B so that it will also be moved to the correct location.  */
-  if (tablejump_p (b->end, &label, &table)
-      && prev_active_insn (label) == b->end)
+  if (tablejump_p (BB_END (b), &label, &table)
+      && prev_active_insn (label) == BB_END (b))
     {
-      b->end = table;
+      BB_END (b) = table;
     }
 
   /* There had better have been a barrier there.  Delete it.  */
-  barrier = NEXT_INSN (b->end);
+  barrier = NEXT_INSN (BB_END (b));
   if (barrier && GET_CODE (barrier) == BARRIER)
     delete_insn (barrier);
 
@@ -761,14 +761,14 @@ merge_blocks_move_successor_nojumps (basic_block a, basic_block b)
      and adjust the block trees appropriately.   Even better would be to have
      a tighter connection between block trees and rtl so that this is not
      necessary.  */
-  if (squeeze_notes (&b->head, &b->end))
+  if (squeeze_notes (&BB_HEAD (b), &BB_END (b)))
     abort ();
 
   /* Scramble the insn chain.  */
-  reorder_insns_nobb (b->head, b->end, a->end);
+  reorder_insns_nobb (BB_HEAD (b), BB_END (b), BB_END (a));
 
   /* Restore the real end of b.  */
-  b->end = real_b_end;
+  BB_END (b) = real_b_end;
 
   if (rtl_dump_file)
     fprintf (rtl_dump_file, "Moved block %d after %d and merged.\n",
@@ -799,8 +799,8 @@ merge_blocks_move (edge e, basic_block b, basic_block c, int mode)
      that would make optimize_sibling_and_tail_recursive_calls more
      complex for no gain.  */
   if ((mode & CLEANUP_PRE_SIBCALL)
-      && GET_CODE (c->head) == CODE_LABEL
-      && tail_recursion_label_p (c->head))
+      && GET_CODE (BB_HEAD (c)) == CODE_LABEL
+      && tail_recursion_label_p (BB_HEAD (c)))
     return NULL;
 
   /* If B has a fallthru edge to C, no need to move anything.  */
@@ -1010,7 +1010,7 @@ flow_find_cross_jump (int mode ATTRIBUTE_UNUSED, basic_block bb1,
   /* Skip simple jumps at the end of the blocks.  Complex jumps still
      need to be compared for equivalence, which we'll do below.  */
 
-  i1 = bb1->end;
+  i1 = BB_END (bb1);
   last1 = afterlast1 = last2 = afterlast2 = NULL_RTX;
   if (onlyjump_p (i1)
       || (returnjump_p (i1) && !side_effects_p (PATTERN (i1))))
@@ -1019,7 +1019,7 @@ flow_find_cross_jump (int mode ATTRIBUTE_UNUSED, basic_block bb1,
       i1 = PREV_INSN (i1);
     }
 
-  i2 = bb2->end;
+  i2 = BB_END (bb2);
   if (onlyjump_p (i2)
       || (returnjump_p (i2) && !side_effects_p (PATTERN (i2))))
     {
@@ -1033,13 +1033,13 @@ flow_find_cross_jump (int mode ATTRIBUTE_UNUSED, basic_block bb1,
   while (true)
     {
       /* Ignore notes.  */
-      while (!INSN_P (i1) && i1 != bb1->head)
+      while (!INSN_P (i1) && i1 != BB_HEAD (bb1))
 	i1 = PREV_INSN (i1);
 
-      while (!INSN_P (i2) && i2 != bb2->head)
+      while (!INSN_P (i2) && i2 != BB_HEAD (bb2))
 	i2 = PREV_INSN (i2);
 
-      if (i1 == bb1->head || i2 == bb2->head)
+      if (i1 == BB_HEAD (bb1) || i2 == BB_HEAD (bb2))
 	break;
 
       if (!insns_match_p (mode, i1, i2))
@@ -1085,16 +1085,16 @@ flow_find_cross_jump (int mode ATTRIBUTE_UNUSED, basic_block bb1,
      Two, it keeps line number notes as matched as may be.  */
   if (ninsns)
     {
-      while (last1 != bb1->head && !INSN_P (PREV_INSN (last1)))
+      while (last1 != BB_HEAD (bb1) && !INSN_P (PREV_INSN (last1)))
 	last1 = PREV_INSN (last1);
 
-      if (last1 != bb1->head && GET_CODE (PREV_INSN (last1)) == CODE_LABEL)
+      if (last1 != BB_HEAD (bb1) && GET_CODE (PREV_INSN (last1)) == CODE_LABEL)
 	last1 = PREV_INSN (last1);
 
-      while (last2 != bb2->head && !INSN_P (PREV_INSN (last2)))
+      while (last2 != BB_HEAD (bb2) && !INSN_P (PREV_INSN (last2)))
 	last2 = PREV_INSN (last2);
 
-      if (last2 != bb2->head && GET_CODE (PREV_INSN (last2)) == CODE_LABEL)
+      if (last2 != BB_HEAD (bb2) && GET_CODE (PREV_INSN (last2)) == CODE_LABEL)
 	last2 = PREV_INSN (last2);
 
       *f1 = last1;
@@ -1121,18 +1121,18 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
      unconditional jump, or a fake edge to exit.  */
   if (bb1->succ && !bb1->succ->succ_next
       && (bb1->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0
-      && (GET_CODE (bb1->end) != JUMP_INSN || simplejump_p (bb1->end)))
+      && (GET_CODE (BB_END (bb1)) != JUMP_INSN || simplejump_p (BB_END (bb1))))
     return (bb2->succ &&  !bb2->succ->succ_next
 	    && (bb2->succ->flags & (EDGE_COMPLEX | EDGE_FAKE)) == 0
-	    && (GET_CODE (bb2->end) != JUMP_INSN || simplejump_p (bb2->end)));
+	    && (GET_CODE (BB_END (bb2)) != JUMP_INSN || simplejump_p (BB_END (bb2))));
 
   /* Match conditional jumps - this may get tricky when fallthru and branch
      edges are crossed.  */
   if (bb1->succ
       && bb1->succ->succ_next
       && !bb1->succ->succ_next->succ_next
-      && any_condjump_p (bb1->end)
-      && onlyjump_p (bb1->end))
+      && any_condjump_p (BB_END (bb1))
+      && onlyjump_p (BB_END (bb1)))
     {
       edge b1, f1, b2, f2;
       bool reverse, match;
@@ -1142,8 +1142,8 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
       if (!bb2->succ
 	  || !bb2->succ->succ_next
 	  || bb2->succ->succ_next->succ_next
-	  || !any_condjump_p (bb2->end)
-	  || !onlyjump_p (bb2->end))
+	  || !any_condjump_p (BB_END (bb2))
+	  || !onlyjump_p (BB_END (bb2)))
 	return false;
 
       b1 = BRANCH_EDGE (bb1);
@@ -1175,8 +1175,8 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
       else
 	return false;
 
-      set1 = pc_set (bb1->end);
-      set2 = pc_set (bb2->end);
+      set1 = pc_set (BB_END (bb1));
+      set2 = pc_set (BB_END (bb2));
       if ((XEXP (SET_SRC (set1), 1) == pc_rtx)
 	  != (XEXP (SET_SRC (set2), 1) == pc_rtx))
 	reverse = !reverse;
@@ -1185,7 +1185,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
       cond2 = XEXP (SET_SRC (set2), 0);
       code1 = GET_CODE (cond1);
       if (reverse)
-	code2 = reversed_comparison_code (cond2, bb2->end);
+	code2 = reversed_comparison_code (cond2, BB_END (bb2));
       else
 	code2 = GET_CODE (cond2);
 
@@ -1250,8 +1250,8 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
       rtx label1, label2;
       rtx table1, table2;
 
-      if (tablejump_p (bb1->end, &label1, &table1)
-	  && tablejump_p (bb2->end, &label2, &table2)
+      if (tablejump_p (BB_END (bb1), &label1, &table1)
+	  && tablejump_p (BB_END (bb2), &label2, &table2)
 	  && GET_CODE (PATTERN (table1)) == GET_CODE (PATTERN (table2)))
 	{
 	  /* The labels should never be the same rtx.  If they really are same
@@ -1261,7 +1261,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 	  /* If LABEL2 is referenced in BB1->END do not do anything
 	     because we would loose information when replacing
 	     LABEL1 by LABEL2 and then LABEL2 by LABEL1 in BB1->END.  */
-	  if (label1 != label2 && !rtx_referenced_p (label2, bb1->end))
+	  if (label1 != label2 && !rtx_referenced_p (label2, BB_END (bb1)))
 	    {
 	      /* Set IDENTICAL to true when the tables are identical.  */
 	      bool identical = false;
@@ -1296,9 +1296,9 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 		  rr.r1 = label1;
 		  rr.r2 = label2;
 		  rr.update_label_nuses = false;
-		  for_each_rtx (&bb1->end, replace_label, &rr);
+		  for_each_rtx (&BB_END (bb1), replace_label, &rr);
 
-		  match = insns_match_p (mode, bb1->end, bb2->end);
+		  match = insns_match_p (mode, BB_END (bb1), BB_END (bb2));
 		  if (rtl_dump_file && match)
 		    fprintf (rtl_dump_file,
 			     "Tablejumps in bb %i and %i match.\n",
@@ -1309,7 +1309,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 		     from the instruction is deleted too.  */
 		  rr.r1 = label2;
 		  rr.r2 = label1;
-		  for_each_rtx (&bb1->end, replace_label, &rr);
+		  for_each_rtx (&BB_END (bb1), replace_label, &rr);
 
 		  return match;
 		}
@@ -1321,7 +1321,7 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 
   /* First ensure that the instructions match.  There may be many outgoing
      edges so this test is generally cheaper.  */
-  if (!insns_match_p (mode, bb1->end, bb2->end))
+  if (!insns_match_p (mode, BB_END (bb1), BB_END (bb2)))
     return false;
 
   /* Search the outgoing edges, ensure that the counts do match, find possible
@@ -1362,8 +1362,8 @@ outgoing_edges_match (int mode, basic_block bb1, basic_block bb2)
 
   /* Ensure the same EH region.  */
   {
-    rtx n1 = find_reg_note (bb1->end, REG_EH_REGION, 0);
-    rtx n2 = find_reg_note (bb2->end, REG_EH_REGION, 0);
+    rtx n1 = find_reg_note (BB_END (bb1), REG_EH_REGION, 0);
+    rtx n2 = find_reg_note (BB_END (bb2), REG_EH_REGION, 0);
 
     if (!n1 && n2)
       return false;
@@ -1443,8 +1443,8 @@ try_crossjump_to_edge (int mode, edge e1, edge e2)
       rtx label1, label2;
       rtx table1, table2;
 
-      if (tablejump_p (src1->end, &label1, &table1)
-	  && tablejump_p (src2->end, &label2, &table2)
+      if (tablejump_p (BB_END (src1), &label1, &table1)
+	  && tablejump_p (BB_END (src2), &label2, &table2)
 	  && label1 != label2)
 	{
 	  replace_label_data rr;
@@ -1459,7 +1459,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2)
 	      /* Do not replace the label in SRC1->END because when deleting
 		 a block whose end is a tablejump, the tablejump referenced
 		 from the instruction is deleted too.  */
-	      if (insn != src1->end)
+	      if (insn != BB_END (src1))
 		for_each_rtx (&insn, replace_label, &rr);
 	    }
 	}
@@ -1467,7 +1467,7 @@ try_crossjump_to_edge (int mode, edge e1, edge e2)
 #endif
 
   /* Avoid splitting if possible.  */
-  if (newpos2 == src2->head)
+  if (newpos2 == BB_HEAD (src2))
     redirect_to = src2;
   else
     {
@@ -1716,9 +1716,9 @@ try_optimize_cfg (int mode)
 	      if (b->pred->pred_next == NULL
 		  && (b->pred->flags & EDGE_FALLTHRU)
 		  && !(b->pred->flags & EDGE_COMPLEX)
-		  && GET_CODE (b->head) == CODE_LABEL
+		  && GET_CODE (BB_HEAD (b)) == CODE_LABEL
 		  && (!(mode & CLEANUP_PRE_SIBCALL)
-		      || !tail_recursion_label_p (b->head))
+		      || !tail_recursion_label_p (BB_HEAD (b)))
 		  /* If the previous block ends with a branch to this
 		     block, we can't delete the label.  Normally this
 		     is a condjump that is yet to be simplified, but
@@ -1726,21 +1726,21 @@ try_optimize_cfg (int mode)
 		     some element going to the same place as the
 		     default (fallthru).  */
 		  && (b->pred->src == ENTRY_BLOCK_PTR
-		      || GET_CODE (b->pred->src->end) != JUMP_INSN
-		      || ! label_is_jump_target_p (b->head,
-						   b->pred->src->end)))
+		      || GET_CODE (BB_END (b->pred->src)) != JUMP_INSN
+		      || ! label_is_jump_target_p (BB_HEAD (b),
+						   BB_END (b->pred->src))))
 		{
-		  rtx label = b->head;
+		  rtx label = BB_HEAD (b);
 
 		  delete_insn_chain (label, label);
 		  /* In the case label is undeletable, move it after the
 		     BASIC_BLOCK note.  */
-		  if (NOTE_LINE_NUMBER (b->head) == NOTE_INSN_DELETED_LABEL)
+		  if (NOTE_LINE_NUMBER (BB_HEAD (b)) == NOTE_INSN_DELETED_LABEL)
 		    {
-		      rtx bb_note = NEXT_INSN (b->head);
+		      rtx bb_note = NEXT_INSN (BB_HEAD (b));
 
 		      reorder_insns_nobb (label, label, bb_note);
-		      b->head = bb_note;
+		      BB_HEAD (b) = bb_note;
 		    }
 		  if (rtl_dump_file)
 		    fprintf (rtl_dump_file, "Deleted label in block %i.\n",
@@ -1751,7 +1751,7 @@ try_optimize_cfg (int mode)
 	      if (!(mode & CLEANUP_CFGLAYOUT)
 		  && b->pred->pred_next == NULL
 		  && (b->pred->flags & EDGE_FALLTHRU)
-		  && GET_CODE (b->head) != CODE_LABEL
+		  && GET_CODE (BB_HEAD (b)) != CODE_LABEL
 		  && FORWARDER_BLOCK_P (b)
 		  /* Note that forwarder_block_p true ensures that
 		     there is a successor for this block.  */
@@ -1793,10 +1793,10 @@ try_optimize_cfg (int mode)
 		  else if (!(mode & CLEANUP_CFGLAYOUT)
 			   /* If the jump insn has side effects,
 			      we can't kill the edge.  */
-			   && (GET_CODE (b->end) != JUMP_INSN
+			   && (GET_CODE (BB_END (b)) != JUMP_INSN
 			       || (flow2_completed
-				   ? simplejump_p (b->end)
-				   : onlyjump_p (b->end)))
+				   ? simplejump_p (BB_END (b))
+				   : onlyjump_p (BB_END (b))))
 			   && (next = merge_blocks_move (s, b, c, mode)))
 		      {
 			b = next;
@@ -1818,7 +1818,7 @@ try_optimize_cfg (int mode)
 	      if (b->succ
 		  && ! b->succ->succ_next
 		  && b->succ->dest != EXIT_BLOCK_PTR
-		  && onlyjump_p (b->end)
+		  && onlyjump_p (BB_END (b))
 		  && redirect_edge_and_branch (b->succ, b->succ->dest))
 		{
 		  update_forwarder_flag (b);