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...


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@74520 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 140 insertions, 138 deletions

diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
index 5769ef366b5..c44d25285dc 100644
--- a/gcc/cfgrtl.c
+++ b/gcc/cfgrtl.c
@@ -199,7 +199,7 @@ delete_insn_and_edges (rtx insn)
 
   if (INSN_P (insn)
       && BLOCK_FOR_INSN (insn)
-      && BLOCK_FOR_INSN (insn)->end == insn)
+      && BB_END (BLOCK_FOR_INSN (insn)) == insn)
     purge = true;
   x = delete_insn (insn);
   if (purge)
@@ -240,7 +240,7 @@ delete_insn_chain_and_edges (rtx first, rtx last)
 
   if (INSN_P (last)
       && BLOCK_FOR_INSN (last)
-      && BLOCK_FOR_INSN (last)->end == last)
+      && BB_END (BLOCK_FOR_INSN (last)) == last)
     purge = true;
   delete_insn_chain (first, last);
   if (purge)
@@ -310,8 +310,8 @@ create_basic_block_structure (rtx head, rtx end, rtx bb_note, basic_block after)
   if (NEXT_INSN (end) == bb_note)
     end = bb_note;
 
-  bb->head = head;
-  bb->end = end;
+  BB_HEAD (bb) = head;
+  BB_END (bb) = end;
   bb->index = last_basic_block++;
   bb->flags = BB_NEW;
   link_block (bb, after);
@@ -378,7 +378,7 @@ rtl_delete_block (basic_block b)
   /* Get rid of all NOTE_INSN_PREDICTIONs and NOTE_INSN_LOOP_CONTs
      hanging before the block.  */
 
-  for (insn = PREV_INSN (b->head); insn; insn = PREV_INSN (insn))
+  for (insn = PREV_INSN (BB_HEAD (b)); insn; insn = PREV_INSN (insn))
     {
       if (GET_CODE (insn) != NOTE)
 	break;
@@ -387,15 +387,15 @@ rtl_delete_block (basic_block b)
 	NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
     }
 
-  insn = b->head;
+  insn = BB_HEAD (b);
 
-  never_reached_warning (insn, b->end);
+  never_reached_warning (insn, BB_END (b));
 
   if (GET_CODE (insn) == CODE_LABEL)
     maybe_remove_eh_handler (insn);
 
   /* Include any jump table following the basic block.  */
-  end = b->end;
+  end = BB_END (b);
   if (tablejump_p (end, NULL, &tmp))
     end = tmp;
 
@@ -405,7 +405,7 @@ rtl_delete_block (basic_block b)
     end = tmp;
 
   /* Selectively delete the entire chain.  */
-  b->head = NULL;
+  BB_HEAD (b) = NULL;
   delete_insn_chain (insn, end);
 
   /* Remove the edges into and out of this block.  Note that there may
@@ -431,10 +431,10 @@ compute_bb_for_insn (void)
 
   FOR_EACH_BB (bb)
     {
-      rtx end = bb->end;
+      rtx end = BB_END (bb);
       rtx insn;
 
-      for (insn = bb->head; ; insn = NEXT_INSN (insn))
+      for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
 	{
 	  BLOCK_FOR_INSN (insn) = bb;
 	  if (insn == end)
@@ -461,11 +461,11 @@ update_bb_for_insn (basic_block bb)
 {
   rtx insn;
 
-  for (insn = bb->head; ; insn = NEXT_INSN (insn))
+  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
     {
       if (GET_CODE (insn) != BARRIER)
 	set_block_for_insn (insn, bb);
-      if (insn == bb->end)
+      if (insn == BB_END (bb))
 	break;
     }
 }
@@ -484,15 +484,15 @@ rtl_split_block (basic_block bb, void *insnp)
   rtx insn = insnp;
 
   /* There is no point splitting the block after its end.  */
-  if (bb->end == insn)
+  if (BB_END (bb) == insn)
     return 0;
 
   /* Create the new basic block.  */
-  new_bb = create_basic_block (NEXT_INSN (insn), bb->end, bb);
+  new_bb = create_basic_block (NEXT_INSN (insn), BB_END (bb), bb);
   new_bb->count = bb->count;
   new_bb->frequency = bb->frequency;
   new_bb->loop_depth = bb->loop_depth;
-  bb->end = insn;
+  BB_END (bb) = insn;
 
   /* Redirect the outgoing edges.  */
   new_bb->succ = bb->succ;
@@ -564,7 +564,7 @@ update_cfg_after_block_merging (basic_block a, basic_block b)
 static void
 rtl_merge_blocks (basic_block a, basic_block b)
 {
-  rtx b_head = b->head, b_end = b->end, a_end = a->end;
+  rtx b_head = BB_HEAD (b), b_end = BB_END (b), a_end = BB_END (a);
   rtx del_first = NULL_RTX, del_last = NULL_RTX;
   int b_empty = 0;
 
@@ -601,7 +601,7 @@ rtl_merge_blocks (basic_block a, basic_block b)
       for (prev = PREV_INSN (a_end); ; prev = PREV_INSN (prev))
 	if (GET_CODE (prev) != NOTE
 	    || NOTE_LINE_NUMBER (prev) == NOTE_INSN_BASIC_BLOCK
-	    || prev == a->head)
+	    || prev == BB_HEAD (a))
 	  break;
 
       del_first = a_end;
@@ -615,7 +615,7 @@ rtl_merge_blocks (basic_block a, basic_block b)
 
 	  prev = prev_nonnote_insn (prev);
 	  if (!prev)
-	    prev = a->head;
+	    prev = BB_HEAD (a);
 	  del_first = tmp;
 	}
 #endif
@@ -644,7 +644,7 @@ rtl_merge_blocks (basic_block a, basic_block b)
       a_end = b_end;
     }
 
-  a->end = a_end;
+  BB_END (a) = a_end;
 }
 
 /* Return true when block A and B can be merged.  */
@@ -660,9 +660,9 @@ rtl_can_merge_blocks (basic_block a,basic_block b)
 	  && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR
 	  /* If the jump insn has side effects,
 	     we can't kill the edge.  */
-	  && (GET_CODE (a->end) != JUMP_INSN
+	  && (GET_CODE (BB_END (a)) != JUMP_INSN
 	      || (flow2_completed
-		  ? simplejump_p (a->end) : onlyjump_p (a->end))));
+		  ? simplejump_p (BB_END (a)) : onlyjump_p (BB_END (a)))));
 }
 
 /* Return the label in the head of basic block BLOCK.  Create one if it doesn't
@@ -674,12 +674,12 @@ block_label (basic_block block)
   if (block == EXIT_BLOCK_PTR)
     return NULL_RTX;
 
-  if (GET_CODE (block->head) != CODE_LABEL)
+  if (GET_CODE (BB_HEAD (block)) != CODE_LABEL)
     {
-      block->head = emit_label_before (gen_label_rtx (), block->head);
+      BB_HEAD (block) = emit_label_before (gen_label_rtx (), BB_HEAD (block));
     }
 
-  return block->head;
+  return BB_HEAD (block);
 }
 
 /* Attempt to perform edge redirection by replacing possibly complex jump
@@ -691,7 +691,7 @@ static bool
 try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 {
   basic_block src = e->src;
-  rtx insn = src->end, kill_from;
+  rtx insn = BB_END (src), kill_from;
   edge tmp;
   rtx set;
   int fallthru = 0;
@@ -731,7 +731,7 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 	{
 	  rtx insn = src->rbi->footer;
 
-          delete_insn_chain (kill_from, src->end);
+          delete_insn_chain (kill_from, BB_END (src));
 
 	  /* Remove barriers but keep jumptables.  */
 	  while (insn)
@@ -751,7 +751,7 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 	    }
 	}
       else
-        delete_insn_chain (kill_from, PREV_INSN (target->head));
+        delete_insn_chain (kill_from, PREV_INSN (BB_HEAD (target)));
     }
 
   /* If this already is simplejump, redirect it.  */
@@ -781,11 +781,11 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
       rtx barrier, label, table;
 
       emit_jump_insn_after (gen_jump (target_label), insn);
-      JUMP_LABEL (src->end) = target_label;
+      JUMP_LABEL (BB_END (src)) = target_label;
       LABEL_NUSES (target_label)++;
       if (rtl_dump_file)
 	fprintf (rtl_dump_file, "Replacing insn %i by jump %i\n",
-		 INSN_UID (insn), INSN_UID (src->end));
+		 INSN_UID (insn), INSN_UID (BB_END (src)));
 
 
       delete_insn_chain (kill_from, insn);
@@ -796,20 +796,20 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
       if (tablejump_p (insn, &label, &table))
 	delete_insn_chain (label, table);
 
-      barrier = next_nonnote_insn (src->end);
+      barrier = next_nonnote_insn (BB_END (src));
       if (!barrier || GET_CODE (barrier) != BARRIER)
-	emit_barrier_after (src->end);
+	emit_barrier_after (BB_END (src));
       else
 	{
-	  if (barrier != NEXT_INSN (src->end))
+	  if (barrier != NEXT_INSN (BB_END (src)))
 	    {
 	      /* Move the jump before barrier so that the notes
 		 which originally were or were created before jump table are
 		 inside the basic block.  */
-	      rtx new_insn = src->end;
+	      rtx new_insn = BB_END (src);
 	      rtx tmp;
 
-	      for (tmp = NEXT_INSN (src->end); tmp != barrier;
+	      for (tmp = NEXT_INSN (BB_END (src)); tmp != barrier;
 		   tmp = NEXT_INSN (tmp))
 		set_block_for_insn (tmp, src);
 
@@ -839,9 +839,9 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
 
   /* We don't want a block to end on a line-number note since that has
      the potential of changing the code between -g and not -g.  */
-  while (GET_CODE (e->src->end) == NOTE
-	 && NOTE_LINE_NUMBER (e->src->end) >= 0)
-    delete_insn (e->src->end);
+  while (GET_CODE (BB_END (e->src)) == NOTE
+	 && NOTE_LINE_NUMBER (BB_END (e->src)) >= 0)
+    delete_insn (BB_END (e->src));
 
   if (e->dest != target)
     redirect_edge_succ (e, target);
@@ -876,9 +876,9 @@ static bool
 redirect_branch_edge (edge e, basic_block target)
 {
   rtx tmp;
-  rtx old_label = e->dest->head;
+  rtx old_label = BB_HEAD (e->dest);
   basic_block src = e->src;
-  rtx insn = src->end;
+  rtx insn = BB_END (src);
 
   /* We can only redirect non-fallthru edges of jump insn.  */
   if (e->flags & EDGE_FALLTHRU)
@@ -1000,18 +1000,18 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
      instruction, first redirect the jump itself and then continue
      by creating a basic block afterwards to redirect fallthru edge.  */
   if (e->src != ENTRY_BLOCK_PTR && e->dest != EXIT_BLOCK_PTR
-      && any_condjump_p (e->src->end)
+      && any_condjump_p (BB_END (e->src))
       /* When called from cfglayout, fallthru edges do not
          necessarily go to the next block.  */
       && e->src->next_bb == e->dest
-      && JUMP_LABEL (e->src->end) == e->dest->head)
+      && JUMP_LABEL (BB_END (e->src)) == BB_HEAD (e->dest))
     {
       rtx note;
       edge b = unchecked_make_edge (e->src, target, 0);
 
-      if (!redirect_jump (e->src->end, block_label (target), 0))
+      if (!redirect_jump (BB_END (e->src), block_label (target), 0))
 	abort ();
-      note = find_reg_note (e->src->end, REG_BR_PROB, NULL_RTX);
+      note = find_reg_note (BB_END (e->src), REG_BR_PROB, NULL_RTX);
       if (note)
 	{
 	  int prob = INTVAL (XEXP (note, 0));
@@ -1046,7 +1046,7 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
       /* We can't redirect the entry block.  Create an empty block at the
          start of the function which we use to add the new jump.  */
       edge *pe1;
-      basic_block bb = create_basic_block (e->dest->head, NULL, ENTRY_BLOCK_PTR);
+      basic_block bb = create_basic_block (BB_HEAD (e->dest), NULL, ENTRY_BLOCK_PTR);
 
       /* Change the existing edge's source to be the new block, and add
 	 a new edge from the entry block to the new block.  */
@@ -1069,8 +1069,8 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
       /* If the old block ended with a tablejump, skip its table
 	 by searching forward from there.  Otherwise start searching
 	 forward from the last instruction of the old block.  */
-      if (!tablejump_p (e->src->end, NULL, &note))
-	note = e->src->end;
+      if (!tablejump_p (BB_END (e->src), NULL, &note))
+	note = BB_END (e->src);
 
       /* Position the new block correctly relative to loop notes.  */
       note = last_loop_beg_note (note);
@@ -1111,19 +1111,19 @@ force_nonfallthru_and_redirect (edge e, basic_block target)
   if (target == EXIT_BLOCK_PTR)
     {
       if (HAVE_return)
-	emit_jump_insn_after (gen_return (), jump_block->end);
+	emit_jump_insn_after (gen_return (), BB_END (jump_block));
       else
 	abort ();
     }
   else
     {
       rtx label = block_label (target);
-      emit_jump_insn_after (gen_jump (label), jump_block->end);
-      JUMP_LABEL (jump_block->end) = label;
+      emit_jump_insn_after (gen_jump (label), BB_END (jump_block));
+      JUMP_LABEL (BB_END (jump_block)) = label;
       LABEL_NUSES (label)++;
     }
 
-  emit_barrier_after (jump_block->end);
+  emit_barrier_after (BB_END (jump_block));
   redirect_edge_succ_nodup (e, target);
 
   if (abnormal_edge_flags)
@@ -1176,14 +1176,14 @@ tidy_fallthru_edge (edge e, basic_block b, basic_block c)
      So search through a sequence of barriers, labels, and notes for
      the head of block C and assert that we really do fall through.  */
 
-  for (q = NEXT_INSN (b->end); q != c->head; q = NEXT_INSN (q))
+  for (q = NEXT_INSN (BB_END (b)); q != BB_HEAD (c); q = NEXT_INSN (q))
     if (INSN_P (q))
       return;
 
   /* Remove what will soon cease being the jump insn from the source block.
      If block B consisted only of this single jump, turn it into a deleted
      note.  */
-  q = b->end;
+  q = BB_END (b);
   if (GET_CODE (q) == JUMP_INSN
       && onlyjump_p (q)
       && (any_uncondjump_p (q)
@@ -1205,8 +1205,8 @@ tidy_fallthru_edge (edge e, basic_block b, basic_block c)
     }
 
   /* Selectively unlink the sequence.  */
-  if (q != PREV_INSN (c->head))
-    delete_insn_chain (NEXT_INSN (q), PREV_INSN (c->head));
+  if (q != PREV_INSN (BB_HEAD (c)))
+    delete_insn_chain (NEXT_INSN (q), PREV_INSN (BB_HEAD (c)));
 
   e->flags |= EDGE_FALLTHRU;
 }
@@ -1247,8 +1247,8 @@ tidy_fallthru_edges (void)
 	  && s->succ_next == NULL
 	  && s->dest == c
 	  /* If the jump insn has side effects, we can't tidy the edge.  */
-	  && (GET_CODE (b->end) != JUMP_INSN
-	      || onlyjump_p (b->end)))
+	  && (GET_CODE (BB_END (b)) != JUMP_INSN
+	      || onlyjump_p (BB_END (b))))
 	tidy_fallthru_edge (s, b, c);
     }
 }
@@ -1274,7 +1274,7 @@ back_edge_of_syntactic_loop_p (basic_block bb1, basic_block bb2)
   if (!bb)
     return false;
 
-  for (insn = bb1->end; insn != bb2->head && count >= 0;
+  for (insn = BB_END (bb1); insn != BB_HEAD (bb2) && count >= 0;
        insn = NEXT_INSN (insn))
     if (GET_CODE (insn) == NOTE)
       {
@@ -1337,14 +1337,14 @@ rtl_split_edge (edge edge_in)
       we confuse the loop optimizer into thinking the loop is a phony.  */
 
   if (edge_in->dest != EXIT_BLOCK_PTR
-      && PREV_INSN (edge_in->dest->head)
-      && GET_CODE (PREV_INSN (edge_in->dest->head)) == NOTE
-      && (NOTE_LINE_NUMBER (PREV_INSN (edge_in->dest->head))
+      && PREV_INSN (BB_HEAD (edge_in->dest))
+      && GET_CODE (PREV_INSN (BB_HEAD (edge_in->dest))) == NOTE
+      && (NOTE_LINE_NUMBER (PREV_INSN (BB_HEAD (edge_in->dest)))
 	  == NOTE_INSN_LOOP_BEG)
       && !back_edge_of_syntactic_loop_p (edge_in->dest, edge_in->src))
-    before = PREV_INSN (edge_in->dest->head);
+    before = PREV_INSN (BB_HEAD (edge_in->dest));
   else if (edge_in->dest != EXIT_BLOCK_PTR)
-    before = edge_in->dest->head;
+    before = BB_HEAD (edge_in->dest);
   else
     before = NULL_RTX;
 
@@ -1512,11 +1512,11 @@ commit_one_edge_insertion (edge e, int watch_calls)
      its return value.  */
   if (watch_calls && (e->flags & EDGE_FALLTHRU) && !e->dest->pred->pred_next
       && e->src != ENTRY_BLOCK_PTR
-      && GET_CODE (e->src->end) == CALL_INSN)
+      && GET_CODE (BB_END (e->src)) == CALL_INSN)
     {
-      rtx next = next_nonnote_insn (e->src->end);
+      rtx next = next_nonnote_insn (BB_END (e->src));
 
-      after = e->dest->head;
+      after = BB_HEAD (e->dest);
       /* The first insn after the call may be a stack pop, skip it.  */
       while (next
 	     && keep_with_call_p (next))
@@ -1536,12 +1536,12 @@ commit_one_edge_insertion (edge e, int watch_calls)
 
 	  /* Get the location correct wrt a code label, and "nice" wrt
 	     a basic block note, and before everything else.  */
-	  tmp = bb->head;
+	  tmp = BB_HEAD (bb);
 	  if (GET_CODE (tmp) == CODE_LABEL)
 	    tmp = NEXT_INSN (tmp);
 	  if (NOTE_INSN_BASIC_BLOCK_P (tmp))
 	    tmp = NEXT_INSN (tmp);
-	  if (tmp == bb->head)
+	  if (tmp == BB_HEAD (bb))
 	    before = tmp;
 	  else if (tmp)
 	    after = PREV_INSN (tmp);
@@ -1563,8 +1563,8 @@ commit_one_edge_insertion (edge e, int watch_calls)
 
 	     We know this block has a single successor, so we can just emit
 	     the queued insns before the jump.  */
-	  if (GET_CODE (bb->end) == JUMP_INSN)
-	    for (before = bb->end;
+	  if (GET_CODE (BB_END (bb)) == JUMP_INSN)
+	    for (before = BB_END (bb);
 		 GET_CODE (PREV_INSN (before)) == NOTE
 		 && NOTE_LINE_NUMBER (PREV_INSN (before)) ==
 		 NOTE_INSN_LOOP_BEG; before = PREV_INSN (before))
@@ -1575,14 +1575,14 @@ commit_one_edge_insertion (edge e, int watch_calls)
 	      if ((e->flags & EDGE_FALLTHRU) == 0)
 		abort ();
 
-	      after = bb->end;
+	      after = BB_END (bb);
 	    }
 	}
       /* Otherwise we must split the edge.  */
       else
 	{
 	  bb = split_edge (e);
-	  after = bb->end;
+	  after = BB_END (bb);
 	}
     }
 
@@ -1728,7 +1728,7 @@ rtl_dump_bb (basic_block bb, FILE *outf)
   dump_regset (bb->global_live_at_start, outf);
   putc ('\n', outf);
 
-  for (insn = bb->head, last = NEXT_INSN (bb->end); insn != last;
+  for (insn = BB_HEAD (bb), last = NEXT_INSN (BB_END (bb)); insn != last;
        insn = NEXT_INSN (insn))
     print_rtl_single (outf, insn);
 
@@ -1761,9 +1761,9 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
 	{
 	  rtx x;
 
-	  start[INSN_UID (bb->head)] = bb;
-	  end[INSN_UID (bb->end)] = bb;
-	  for (x = bb->head; x != NULL_RTX; x = NEXT_INSN (x))
+	  start[INSN_UID (BB_HEAD (bb))] = bb;
+	  end[INSN_UID (BB_END (bb))] = bb;
+	  for (x = BB_HEAD (bb); x != NULL_RTX; x = NEXT_INSN (x))
 	    {
 	      enum bb_state state = IN_MULTIPLE_BB;
 
@@ -1771,7 +1771,7 @@ print_rtl_with_bb (FILE *outf, rtx rtx_first)
 		state = IN_ONE_BB;
 	      in_bb_p[INSN_UID (x)] = state;
 
-	      if (x == bb->end)
+	      if (x == BB_END (bb))
 		break;
 	    }
 	}
@@ -1827,9 +1827,9 @@ void
 update_br_prob_note (basic_block bb)
 {
   rtx note;
-  if (GET_CODE (bb->end) != JUMP_INSN)
+  if (GET_CODE (BB_END (bb)) != JUMP_INSN)
     return;
-  note = find_reg_note (bb->end, REG_BR_PROB, NULL_RTX);
+  note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX);
   if (!note || INTVAL (XEXP (note, 0)) == BRANCH_EDGE (bb)->probability)
     return;
   XEXP (note, 0) = GEN_INT (BRANCH_EDGE (bb)->probability);
@@ -1866,8 +1866,8 @@ rtl_verify_flow_info_1 (void)
 
   FOR_EACH_BB_REVERSE (bb)
     {
-      rtx head = bb->head;
-      rtx end = bb->end;
+      rtx head = BB_HEAD (bb);
+      rtx end = BB_END (bb);
 
       /* Verify the end of the basic block is in the INSN chain.  */
       for (x = last_head; x != NULL_RTX; x = PREV_INSN (x))
@@ -1917,10 +1917,10 @@ rtl_verify_flow_info_1 (void)
       edge e, fallthru = NULL;
       rtx note;
 
-      if (INSN_P (bb->end)
-	  && (note = find_reg_note (bb->end, REG_BR_PROB, NULL_RTX))
+      if (INSN_P (BB_END (bb))
+	  && (note = find_reg_note (BB_END (bb), REG_BR_PROB, NULL_RTX))
 	  && bb->succ && bb->succ->succ_next
-	  && any_condjump_p (bb->end))
+	  && any_condjump_p (BB_END (bb)))
 	{
 	  if (INTVAL (XEXP (note, 0)) != BRANCH_EDGE (bb)->probability)
 	    {
@@ -1949,52 +1949,52 @@ rtl_verify_flow_info_1 (void)
 	    n_abnormal++;
 	}
 
-      if (n_eh && GET_CODE (PATTERN (bb->end)) != RESX
-	  && !find_reg_note (bb->end, REG_EH_REGION, NULL_RTX))
+      if (n_eh && GET_CODE (PATTERN (BB_END (bb))) != RESX
+	  && !find_reg_note (BB_END (bb), REG_EH_REGION, NULL_RTX))
 	{
 	  error ("Missing REG_EH_REGION note in the end of bb %i", bb->index);
 	  err = 1;
 	}
       if (n_branch
-	  && (GET_CODE (bb->end) != JUMP_INSN
-	      || (n_branch > 1 && (any_uncondjump_p (bb->end)
-				   || any_condjump_p (bb->end)))))
+	  && (GET_CODE (BB_END (bb)) != JUMP_INSN
+	      || (n_branch > 1 && (any_uncondjump_p (BB_END (bb))
+				   || any_condjump_p (BB_END (bb))))))
 	{
 	  error ("Too many outgoing branch edges from bb %i", bb->index);
 	  err = 1;
 	}
-      if (n_fallthru && any_uncondjump_p (bb->end))
+      if (n_fallthru && any_uncondjump_p (BB_END (bb)))
 	{
 	  error ("Fallthru edge after unconditional jump %i", bb->index);
 	  err = 1;
 	}
-      if (n_branch != 1 && any_uncondjump_p (bb->end))
+      if (n_branch != 1 && any_uncondjump_p (BB_END (bb)))
 	{
 	  error ("Wrong amount of branch edges after unconditional jump %i", bb->index);
 	  err = 1;
 	}
-      if (n_branch != 1 && any_condjump_p (bb->end)
-	  && JUMP_LABEL (bb->end) != fallthru->dest->head)
+      if (n_branch != 1 && any_condjump_p (BB_END (bb))
+	  && JUMP_LABEL (BB_END (bb)) != BB_HEAD (fallthru->dest))
 	{
 	  error ("Wrong amount of branch edges after conditional jump %i", bb->index);
 	  err = 1;
 	}
-      if (n_call && GET_CODE (bb->end) != CALL_INSN)
+      if (n_call && GET_CODE (BB_END (bb)) != CALL_INSN)
 	{
 	  error ("Call edges for non-call insn in bb %i", bb->index);
 	  err = 1;
 	}
       if (n_abnormal
-	  && (GET_CODE (bb->end) != CALL_INSN && n_call != n_abnormal)
-	  && (GET_CODE (bb->end) != JUMP_INSN
-	      || any_condjump_p (bb->end)
-	      || any_uncondjump_p (bb->end)))
+	  && (GET_CODE (BB_END (bb)) != CALL_INSN && n_call != n_abnormal)
+	  && (GET_CODE (BB_END (bb)) != JUMP_INSN
+	      || any_condjump_p (BB_END (bb))
+	      || any_uncondjump_p (BB_END (bb))))
 	{
 	  error ("Abnormal edges for no purpose in bb %i", bb->index);
 	  err = 1;
 	}
 
-      for (x = bb->head; x != NEXT_INSN (bb->end); x = NEXT_INSN (x))
+      for (x = BB_HEAD (bb); x != NEXT_INSN (BB_END (bb)); x = NEXT_INSN (x))
 	if (BLOCK_FOR_INSN (x) != bb)
 	  {
 	    debug_rtx (x);
@@ -2013,10 +2013,10 @@ rtl_verify_flow_info_1 (void)
       /* OK pointers are correct.  Now check the header of basic
          block.  It ought to contain optional CODE_LABEL followed
 	 by NOTE_BASIC_BLOCK.  */
-      x = bb->head;
+      x = BB_HEAD (bb);
       if (GET_CODE (x) == CODE_LABEL)
 	{
-	  if (bb->end == x)
+	  if (BB_END (bb) == x)
 	    {
 	      error ("NOTE_INSN_BASIC_BLOCK is missing for block %d",
 		     bb->index);
@@ -2033,7 +2033,7 @@ rtl_verify_flow_info_1 (void)
 	  err = 1;
 	}
 
-      if (bb->end == x)
+      if (BB_END (bb) == x)
 	/* Do checks for empty blocks her. e */
 	;
       else
@@ -2046,7 +2046,7 @@ rtl_verify_flow_info_1 (void)
 		err = 1;
 	      }
 
-	    if (x == bb->end)
+	    if (x == BB_END (bb))
 	      break;
 
 	    if (control_flow_insn_p (x))
@@ -2092,7 +2092,7 @@ rtl_verify_flow_info (void)
 	  rtx insn;
 
 	  /* Ensure existence of barrier in BB with no fallthru edges.  */
-	  for (insn = bb->end; !insn || GET_CODE (insn) != BARRIER;
+	  for (insn = BB_END (bb); !insn || GET_CODE (insn) != BARRIER;
 	       insn = NEXT_INSN (insn))
 	    if (!insn
 		|| (GET_CODE (insn) == NOTE
@@ -2116,7 +2116,7 @@ rtl_verify_flow_info (void)
 	      err = 1;
 	    }
 	  else
-	    for (insn = NEXT_INSN (e->src->end); insn != e->dest->head;
+	    for (insn = NEXT_INSN (BB_END (e->src)); insn != BB_HEAD (e->dest);
 		 insn = NEXT_INSN (insn))
 	      if (GET_CODE (insn) == BARRIER
 #ifndef CASE_DROPS_THROUGH
@@ -2179,7 +2179,7 @@ rtl_verify_flow_info (void)
 	  && returnjump_p (x) && ! condjump_p (x)
 	  && ! (NEXT_INSN (x) && GET_CODE (NEXT_INSN (x)) == BARRIER))
 	    fatal_insn ("return not followed by barrier", x);
-      if (curr_bb && x == curr_bb->end)
+      if (curr_bb && x == BB_END (curr_bb))
 	curr_bb = NULL;
     }
 
@@ -2199,7 +2199,7 @@ bool
 purge_dead_edges (basic_block bb)
 {
   edge e, next;
-  rtx insn = bb->end, note;
+  rtx insn = BB_END (bb), note;
   bool purged = false;
 
   /* If this instruction cannot trap, remove REG_EH_REGION notes.  */
@@ -2220,12 +2220,12 @@ purge_dead_edges (basic_block bb)
       next = e->succ_next;
       if (e->flags & EDGE_EH)
 	{
-	  if (can_throw_internal (bb->end))
+	  if (can_throw_internal (BB_END (bb)))
 	    continue;
 	}
       else if (e->flags & EDGE_ABNORMAL_CALL)
 	{
-	  if (GET_CODE (bb->end) == CALL_INSN
+	  if (GET_CODE (BB_END (bb)) == CALL_INSN
 	      && (! (note = find_reg_note (insn, REG_EH_REGION, NULL))
 		  || INTVAL (XEXP (note, 0)) >= 0))
 	    continue;
@@ -2275,7 +2275,7 @@ purge_dead_edges (basic_block bb)
 	       block, so we should keep the edge.  */
 	    continue;
 	  else if (e->dest != EXIT_BLOCK_PTR
-		   && e->dest->head == JUMP_LABEL (insn))
+		   && BB_HEAD (e->dest) == JUMP_LABEL (insn))
 	    /* If the destination block is the target of the jump,
 	       keep the edge.  */
 	    continue;
@@ -2462,10 +2462,10 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
   if (e->flags & EDGE_FALLTHRU)
     {
       /* Redirect any branch edges unified with the fallthru one.  */
-      if (GET_CODE (src->end) == JUMP_INSN
-	  && JUMP_LABEL (src->end) == e->dest->head)
+      if (GET_CODE (BB_END (src)) == JUMP_INSN
+	  && JUMP_LABEL (BB_END (src)) == BB_HEAD (e->dest))
 	{
-          if (!redirect_jump (src->end, block_label (dest), 0))
+          if (!redirect_jump (BB_END (src), block_label (dest), 0))
 	    abort ();
 	}
       /* In case we are redirecting fallthru edge to the branch edge
@@ -2475,9 +2475,9 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
 	{
 	  edge s = e->succ_next ? e->succ_next : src->succ;
 	  if (s->dest == dest
-	      && any_condjump_p (src->end)
-	      && onlyjump_p (src->end))
-	    delete_insn (src->end);
+	      && any_condjump_p (BB_END (src))
+	      && onlyjump_p (BB_END (src)))
+	    delete_insn (BB_END (src));
 	}
       redirect_edge_succ_nodup (e, dest);
       if (rtl_dump_file)
@@ -2490,7 +2490,7 @@ cfg_layout_redirect_edge_and_branch (edge e, basic_block dest)
     ret = redirect_branch_edge (e, dest);
 
   /* We don't want simplejumps in the insn stream during cfglayout.  */
-  if (simplejump_p (src->end))
+  if (simplejump_p (BB_END (src)))
     abort ();
 
   return ret;
@@ -2509,11 +2509,11 @@ cfg_layout_redirect_edge_and_branch_force (edge e, basic_block dest)
 static void
 cfg_layout_delete_block (basic_block bb)
 {
-  rtx insn, next, prev = PREV_INSN (bb->head), *to, remaints;
+  rtx insn, next, prev = PREV_INSN (BB_HEAD (bb)), *to, remaints;
 
   if (bb->rbi->header)
     {
-      next = bb->head;
+      next = BB_HEAD (bb);
       if (prev)
 	NEXT_INSN (prev) = bb->rbi->header;
       else
@@ -2525,7 +2525,7 @@ cfg_layout_delete_block (basic_block bb)
       NEXT_INSN (insn) = next;
       PREV_INSN (next) = insn;
     }
-  next = NEXT_INSN (bb->end);
+  next = NEXT_INSN (BB_END (bb));
   if (bb->rbi->footer)
     {
       insn = bb->rbi->footer;
@@ -2546,7 +2546,7 @@ cfg_layout_delete_block (basic_block bb)
 	}
       if (bb->rbi->footer)
 	{
-	  insn = bb->end;
+	  insn = BB_END (bb);
 	  NEXT_INSN (insn) = bb->rbi->footer;
 	  PREV_INSN (bb->rbi->footer) = insn;
 	  while (NEXT_INSN (insn))
@@ -2598,9 +2598,9 @@ cfg_layout_can_merge_blocks_p (basic_block a, basic_block b)
 	  && a != ENTRY_BLOCK_PTR && b != EXIT_BLOCK_PTR
 	  /* If the jump insn has side effects,
 	     we can't kill the edge.  */
-	  && (GET_CODE (a->end) != JUMP_INSN
+	  && (GET_CODE (BB_END (a)) != JUMP_INSN
 	      || (flow2_completed
-		  ? simplejump_p (a->end) : onlyjump_p (a->end))));
+		  ? simplejump_p (BB_END (a)) : onlyjump_p (BB_END (a)))));
 }
 
 /* Merge block A and B, abort when it is not possible.  */
@@ -2613,38 +2613,38 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
 #endif
 
   /* If there was a CODE_LABEL beginning B, delete it.  */
-  if (GET_CODE (b->head) == CODE_LABEL)
-    delete_insn (b->head);
+  if (GET_CODE (BB_HEAD (b)) == CODE_LABEL)
+    delete_insn (BB_HEAD (b));
 
   /* We should have fallthru edge in a, or we can do dummy redirection to get
      it cleaned up.  */
-  if (GET_CODE (a->end) == JUMP_INSN)
+  if (GET_CODE (BB_END (a)) == JUMP_INSN)
     redirect_edge_and_branch (a->succ, b);
-  if (GET_CODE (a->end) == JUMP_INSN)
+  if (GET_CODE (BB_END (a)) == JUMP_INSN)
     abort ();
 
   /* Possible line number notes should appear in between.  */
   if (b->rbi->header)
     {
-      rtx first = a->end, last;
+      rtx first = BB_END (a), last;
 
-      last = emit_insn_after (b->rbi->header, a->end);
+      last = emit_insn_after (b->rbi->header, BB_END (a));
       delete_insn_chain (NEXT_INSN (first), last);
       b->rbi->header = NULL;
     }
 
   /* In the case basic blocks are not adjacent, move them around.  */
-  if (NEXT_INSN (a->end) != b->head)
+  if (NEXT_INSN (BB_END (a)) != BB_HEAD (b))
     {
-      rtx first = unlink_insn_chain (b->head, b->end);
+      rtx first = unlink_insn_chain (BB_HEAD (b), BB_END (b));
 
-      emit_insn_after (first, a->end);
+      emit_insn_after (first, BB_END (a));
       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (first))
 	first = NEXT_INSN (first);
       if (!NOTE_INSN_BASIC_BLOCK_P (first))
 	abort ();
-      b->head = NULL;
+      BB_HEAD (b) = NULL;
       delete_insn (first);
     }
   /* Otherwise just re-associate the instructions.  */
@@ -2652,16 +2652,18 @@ cfg_layout_merge_blocks (basic_block a, basic_block b)
     {
       rtx insn;
 
-      for (insn = b->head; insn != NEXT_INSN (b->end); insn = NEXT_INSN (insn))
+      for (insn = BB_HEAD (b);
+	   insn != NEXT_INSN (BB_END (b));
+	   insn = NEXT_INSN (insn))
 	set_block_for_insn (insn, a);
-      insn = b->head;
+      insn = BB_HEAD (b);
       /* Skip possible DELETED_LABEL insn.  */
       if (!NOTE_INSN_BASIC_BLOCK_P (insn))
 	insn = NEXT_INSN (insn);
       if (!NOTE_INSN_BASIC_BLOCK_P (insn))
 	abort ();
-      b->head = NULL;
-      a->end = b->end;
+      BB_HEAD (b) = NULL;
+      BB_END (a) = BB_END (b);
       delete_insn (insn);
     }
 
@@ -2696,7 +2698,7 @@ cfg_layout_split_edge (edge e)
   edge new_e;
   basic_block new_bb =
     create_basic_block (e->src != ENTRY_BLOCK_PTR
-			? NEXT_INSN (e->src-> end) : get_insns (),
+			? NEXT_INSN (BB_END (e->src)) : get_insns (),
 			NULL_RTX, e->src);
 
   new_bb->count = e->count;