This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH, RFC]: Next stage1, refactoring: propagating rtx subclasses


On Tue, Mar 31, 2015 at 07:37:40AM +0300, Mikhail Maltsev wrote:
> Hi!
> 
> I'm currently working on the proposed task of replacing rtx objects
> (i.e. struct rtx_def) with derived classes. I would like to get some
> feedback on this work (it's far from being finished, but basically I
> would like to know, whether my modifications are appropriate, e.g. one
> may consider that this is "too much" for just refactoring, because
> sometimes they involve small modification of semantics).

I don't see why "too much" would makesense if the change improves
maintainability.

> The attached patch is not well tested, i.e. I bootstrapped and regtested
> it only on x86_64, but I'll perform more extensive testing before
> submitting the next version.
> 
> The key points I would like to ask about:
> 
> 1. The original task was to replace the rtx type by rtx_insn *, where it
> is appropriate. But rtx_insn has several derived classes, such as
> rtx_code_label, for example. So I tried to use the most derived type
> when possible. Is it OK?

sure why not?

> 2. Not all of these "type promotions" can be done by just looking at
> function callers and callees (and some functions will only be generated
> during the build of some rare architecture) and checks already done in
> them. In a couple of cases I referred to comments and my general
> understanding of code semantics. In one case this actually caused a
> regression (in the patch it is fixed, of course), because of somewhat
> misleading comment (see "live_label_rtx" function added in patch for
> details) The question is - are such changes OK for refactoring (or it
> should strictly preserve semantics)?

I think correct semantic changes are just fine if they make things
easier to use and read.

> 3. In lra-constraints.c I added a new class rtx_usage_list, which, IMHO,
> allows to group the functions which work with usage list in a more
> explicit manner and make some conditions more self-explaining. I hope
> that Vladimir Makarov (in this case, because it concerns LRA) and other
> authors will not object against such "intrusion" into their code (or
> would rather tell me what should be fixed in my patch(es), instead of
> just refusing to apply it/them). In general, are such changes OK or
> should better be avoided?

I wouldn't avoidthem, though I would definitely break this patch up into
smaller ones that each make one set of related changes.

> A couple of questions related to further work:
> 
> 1. I noticed that emit_insn function, in fact, does two kinds of things:
> it can either add it's argument to the chain, or, if the argument is a
> pattern, it creates a new instruction based on that pattern. Shouldn't
> this logic be separated in the callers?

That might well make sense.

> 2. Are there any plans on implementing a better class hierarchy on AST's
> ("union tree_node" type). I see that C++ FE uses a huge number of macros
> (which check TREE_CODE and some boolean flags). Could this be improved
> somehow?

people have talked about doing it, and Andrew MacLeod's work on
seperating types out of tree is related, but not too much has happened
yet.

Trev

> 
> -- 
> Regards,
>     Mikhail Maltsev

> diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c
> index c2a3be3..7179faa 100644
> --- a/gcc/bb-reorder.c
> +++ b/gcc/bb-reorder.c
> @@ -1745,9 +1745,11 @@ set_edge_can_fallthru_flag (void)
>  	continue;
>        if (!any_condjump_p (BB_END (bb)))
>  	continue;
> -      if (!invert_jump (BB_END (bb), JUMP_LABEL (BB_END (bb)), 0))
> +
> +      rtx_jump_insn *bb_end_jump = as_a <rtx_jump_insn *> (BB_END (bb));
> +      if (!invert_jump (bb_end_jump, JUMP_LABEL (bb_end_jump), 0))
>  	continue;
> -      invert_jump (BB_END (bb), JUMP_LABEL (BB_END (bb)), 0);
> +      invert_jump (bb_end_jump, JUMP_LABEL (bb_end_jump), 0);
>        EDGE_SUCC (bb, 0)->flags |= EDGE_CAN_FALLTHRU;
>        EDGE_SUCC (bb, 1)->flags |= EDGE_CAN_FALLTHRU;
>      }
> @@ -1902,9 +1904,15 @@ fix_up_fall_thru_edges (void)
>  
>  		      fall_thru_label = block_label (fall_thru->dest);
>  
> -		      if (old_jump && JUMP_P (old_jump) && fall_thru_label)
> -			invert_worked = invert_jump (old_jump,
> -						     fall_thru_label,0);
> +		      if (old_jump && fall_thru_label)
> +                        {
> +                          rtx_jump_insn *old_jump_insn =
> +                                  dyn_cast <rtx_jump_insn *> (old_jump);
> +                          if (old_jump_insn)
> +                            invert_worked = invert_jump (old_jump_insn,
> +						     fall_thru_label, 0);
> +                        }
> +
>  		      if (invert_worked)
>  			{
>  			  fall_thru->flags &= ~EDGE_FALLTHRU;
> @@ -2024,7 +2032,7 @@ fix_crossing_conditional_branches (void)
>    rtx_insn *old_jump;
>    rtx set_src;
>    rtx old_label = NULL_RTX;
> -  rtx new_label;
> +  rtx_code_label *new_label;
>  
>    FOR_EACH_BB_FN (cur_bb, cfun)
>      {
> @@ -2088,7 +2096,7 @@ fix_crossing_conditional_branches (void)
>  	      else
>  		{
>  		  basic_block last_bb;
> -		  rtx_insn *new_jump;
> +		  rtx_insn *new_jump, *old_label_insn;
>  
>  		  /* Create new basic block to be dest for
>  		     conditional jump.  */
> @@ -2099,9 +2107,9 @@ fix_crossing_conditional_branches (void)
>  		  emit_label (new_label);
>  
>  		  gcc_assert (GET_CODE (old_label) == LABEL_REF);
> -		  old_label = JUMP_LABEL (old_jump);
> -		  new_jump = emit_jump_insn (gen_jump (old_label));
> -		  JUMP_LABEL (new_jump) = old_label;
> +		  old_label_insn = JUMP_LABEL_AS_INSN (old_jump);
> +		  new_jump = emit_jump_insn (gen_jump (old_label_insn));
> +		  JUMP_LABEL (new_jump) = old_label_insn;
>  
>  		  last_bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
>  		  new_bb = create_basic_block (new_label, new_jump, last_bb);
> @@ -2117,7 +2125,7 @@ fix_crossing_conditional_branches (void)
>  
>  	      /* Make old jump branch to new bb.  */
>  
> -	      redirect_jump (old_jump, new_label, 0);
> +	      redirect_jump (as_a <rtx_jump_insn *> (old_jump), new_label, 0);
>  
>  	      /* Remove crossing_edge as predecessor of 'dest'.  */
>  
> diff --git a/gcc/bt-load.c b/gcc/bt-load.c
> index c028281..2280124 100644
> --- a/gcc/bt-load.c
> +++ b/gcc/bt-load.c
> @@ -1212,7 +1212,7 @@ move_btr_def (basic_block new_def_bb, int btr, btr_def def, bitmap live_range,
>    btr_mode = GET_MODE (SET_DEST (set));
>    btr_rtx = gen_rtx_REG (btr_mode, btr);
>  
> -  new_insn = as_a <rtx_insn *> (gen_move_insn (btr_rtx, src));
> +  new_insn = gen_move_insn (btr_rtx, src);
>  
>    /* Insert target register initialization at head of basic block.  */
>    def->insn = emit_insn_after (new_insn, insp);
> diff --git a/gcc/builtins.c b/gcc/builtins.c
> index 9263777..945492e 100644
> --- a/gcc/builtins.c
> +++ b/gcc/builtins.c
> @@ -2001,7 +2001,7 @@ expand_errno_check (tree exp, rtx target)
>    /* Test the result; if it is NaN, set errno=EDOM because
>       the argument was not in the domain.  */
>    do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
> -			   NULL_RTX, NULL_RTX, lab,
> +			   NULL_RTX, NULL, lab,
>  			   /* The jump is very likely.  */
>  			   REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
>  
> @@ -5938,9 +5938,9 @@ expand_builtin_acc_on_device (tree exp, rtx target)
>    emit_move_insn (target, const1_rtx);
>    rtx_code_label *done_label = gen_label_rtx ();
>    do_compare_rtx_and_jump (v, v1, EQ, false, v_mode, NULL_RTX,
> -			   NULL_RTX, done_label, PROB_EVEN);
> +			   NULL, done_label, PROB_EVEN);
>    do_compare_rtx_and_jump (v, v2, EQ, false, v_mode, NULL_RTX,
> -			   NULL_RTX, done_label, PROB_EVEN);
> +			   NULL, done_label, PROB_EVEN);
>    emit_move_insn (target, const0_rtx);
>    emit_label (done_label);
>  
> diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c
> index cee152e..05146b6 100644
> --- a/gcc/cfgcleanup.c
> +++ b/gcc/cfgcleanup.c
> @@ -190,7 +190,8 @@ try_simplify_condjump (basic_block cbranch_block)
>      return false;
>  
>    /* Invert the conditional branch.  */
> -  if (!invert_jump (cbranch_insn, block_label (jump_dest_block), 0))
> +  if (!invert_jump (as_a <rtx_jump_insn *> (cbranch_insn),
> +                    block_label (jump_dest_block), 0))
>      return false;
>  
>    if (dump_file)
> diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c
> index 97e7a25..aedc4b8 100644
> --- a/gcc/cfgexpand.c
> +++ b/gcc/cfgexpand.c
> @@ -2051,7 +2051,7 @@ static hash_map<basic_block, rtx_code_label *> *lab_rtx_for_bb;
>  
>  /* Returns the label_rtx expression for a label starting basic block BB.  */
>  
> -static rtx
> +static rtx_code_label *
>  label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
>  {
>    gimple_stmt_iterator gsi;
> @@ -2078,7 +2078,7 @@ label_rtx_for_bb (basic_block bb ATTRIBUTE_UNUSED)
>        if (DECL_NONLOCAL (lab))
>  	break;
>  
> -      return label_rtx (lab);
> +      return live_label_rtx (lab);
>      }
>  
>    rtx_code_label *l = gen_label_rtx ();
> @@ -5579,7 +5579,7 @@ construct_init_block (void)
>      {
>        tree label = gimple_block_label (e->dest);
>  
> -      emit_jump (label_rtx (label));
> +      emit_jump (live_label_rtx (label));
>        flags = 0;
>      }
>    else
> diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c
> index 0e27edd..7da23e7 100644
> --- a/gcc/cfgrtl.c
> +++ b/gcc/cfgrtl.c
> @@ -1001,18 +1001,18 @@ rtl_can_merge_blocks (basic_block a, basic_block b)
>  /* Return the label in the head of basic block BLOCK.  Create one if it doesn't
>     exist.  */
>  
> -rtx
> +rtx_code_label *
>  block_label (basic_block block)
>  {
>    if (block == EXIT_BLOCK_PTR_FOR_FN (cfun))
> -    return NULL_RTX;
> +    return NULL;
>  
>    if (!LABEL_P (BB_HEAD (block)))
>      {
>        BB_HEAD (block) = emit_label_before (gen_label_rtx (), BB_HEAD (block));
>      }
>  
> -  return BB_HEAD (block);
> +  return as_a <rtx_code_label *> (BB_HEAD (block));
>  }
>  
>  /* Attempt to perform edge redirection by replacing possibly complex jump
> @@ -1114,7 +1114,8 @@ try_redirect_by_replacing_jump (edge e, basic_block target, bool in_cfglayout)
>        if (dump_file)
>  	fprintf (dump_file, "Redirecting jump %i from %i to %i.\n",
>  		 INSN_UID (insn), e->dest->index, target->index);
> -      if (!redirect_jump (insn, block_label (target), 0))
> +      if (!redirect_jump (as_a <rtx_jump_insn *> (insn),
> +                          block_label (target), 0))
>  	{
>  	  gcc_assert (target == EXIT_BLOCK_PTR_FOR_FN (cfun));
>  	  return NULL;
> @@ -1298,7 +1299,8 @@ patch_jump_insn (rtx_insn *insn, rtx_insn *old_label, basic_block new_bb)
>  	  /* If the substitution doesn't succeed, die.  This can happen
>  	     if the back end emitted unrecognizable instructions or if
>  	     target is exit block on some arches.  */
> -	  if (!redirect_jump (insn, block_label (new_bb), 0))
> +	  if (!redirect_jump (as_a <rtx_jump_insn *> (insn),
> +                              block_label (new_bb), 0))
>  	    {
>  	      gcc_assert (new_bb == EXIT_BLOCK_PTR_FOR_FN (cfun));
>  	      return false;
> @@ -1326,7 +1328,7 @@ redirect_branch_edge (edge e, basic_block target)
>  
>    if (!currently_expanding_to_rtl)
>      {
> -      if (!patch_jump_insn (insn, old_label, target))
> +      if (!patch_jump_insn (as_a <rtx_jump_insn *> (insn), old_label, target))
>  	return NULL;
>      }
>    else
> @@ -1334,7 +1336,8 @@ redirect_branch_edge (edge e, basic_block target)
>         jumps (i.e. not yet split by find_many_sub_basic_blocks).
>         Redirect all of those that match our label.  */
>      FOR_BB_INSNS (src, insn)
> -      if (JUMP_P (insn) && !patch_jump_insn (insn, old_label, target))
> +      if (JUMP_P (insn) && !patch_jump_insn (as_a <rtx_jump_insn *> (insn),
> +                                             old_label, target))
>  	return NULL;
>  
>    if (dump_file)
> @@ -1525,7 +1528,8 @@ force_nonfallthru_and_redirect (edge e, basic_block target, rtx jump_label)
>        edge b = unchecked_make_edge (e->src, target, 0);
>        bool redirected;
>  
> -      redirected = redirect_jump (BB_END (e->src), block_label (target), 0);
> +      redirected = redirect_jump (as_a <rtx_jump_insn *> (BB_END (e->src)),
> +                                  block_label (target), 0);
>        gcc_assert (redirected);
>  
>        note = find_reg_note (BB_END (e->src), REG_BR_PROB, NULL_RTX);
> @@ -3783,10 +3787,10 @@ fixup_reorder_chain (void)
>  	  e_taken = e;
>  
>        bb_end_insn = BB_END (bb);
> -      if (JUMP_P (bb_end_insn))
> +      if (rtx_jump_insn *bb_end_jump = dyn_cast <rtx_jump_insn *> (bb_end_insn))
>  	{
> -	  ret_label = JUMP_LABEL (bb_end_insn);
> -	  if (any_condjump_p (bb_end_insn))
> +	  ret_label = JUMP_LABEL (bb_end_jump);
> +	  if (any_condjump_p (bb_end_jump))
>  	    {
>  	      /* This might happen if the conditional jump has side
>  		 effects and could therefore not be optimized away.
> @@ -3794,10 +3798,10 @@ fixup_reorder_chain (void)
>  		 to prevent rtl_verify_flow_info from complaining.  */
>  	      if (!e_fall)
>  		{
> -		  gcc_assert (!onlyjump_p (bb_end_insn)
> -			      || returnjump_p (bb_end_insn)
> +		  gcc_assert (!onlyjump_p (bb_end_jump)
> +			      || returnjump_p (bb_end_jump)
>                                || (e_taken->flags & EDGE_CROSSING));
> -		  emit_barrier_after (bb_end_insn);
> +		  emit_barrier_after (bb_end_jump);
>  		  continue;
>  		}
>  
> @@ -3819,11 +3823,11 @@ fixup_reorder_chain (void)
>  		 edge based on known or assumed probability.  */
>  	      else if (bb->aux != e_taken->dest)
>  		{
> -		  rtx note = find_reg_note (bb_end_insn, REG_BR_PROB, 0);
> +		  rtx note = find_reg_note (bb_end_jump, REG_BR_PROB, 0);
>  
>  		  if (note
>  		      && XINT (note, 0) < REG_BR_PROB_BASE / 2
> -		      && invert_jump (bb_end_insn,
> +		      && invert_jump (bb_end_jump,
>  				      (e_fall->dest
>  				       == EXIT_BLOCK_PTR_FOR_FN (cfun)
>  				       ? NULL_RTX
> @@ -3846,7 +3850,7 @@ fixup_reorder_chain (void)
>  
>  	      /* Otherwise we can try to invert the jump.  This will
>  		 basically never fail, however, keep up the pretense.  */
> -	      else if (invert_jump (bb_end_insn,
> +	      else if (invert_jump (bb_end_jump,
>  				    (e_fall->dest
>  				     == EXIT_BLOCK_PTR_FOR_FN (cfun)
>  				     ? NULL_RTX
> @@ -4967,7 +4971,7 @@ rtl_lv_add_condition_to_bb (basic_block first_head ,
>  			    basic_block second_head ATTRIBUTE_UNUSED,
>  			    basic_block cond_bb, void *comp_rtx)
>  {
> -  rtx label;
> +  rtx_code_label *label;
>    rtx_insn *seq, *jump;
>    rtx op0 = XEXP ((rtx)comp_rtx, 0);
>    rtx op1 = XEXP ((rtx)comp_rtx, 1);
> @@ -4983,8 +4987,7 @@ rtl_lv_add_condition_to_bb (basic_block first_head ,
>    start_sequence ();
>    op0 = force_operand (op0, NULL_RTX);
>    op1 = force_operand (op1, NULL_RTX);
> -  do_compare_rtx_and_jump (op0, op1, comp, 0,
> -			   mode, NULL_RTX, NULL_RTX, label, -1);
> +  do_compare_rtx_and_jump (op0, op1, comp, 0, mode, NULL_RTX, NULL, label, -1);
>    jump = get_last_insn ();
>    JUMP_LABEL (jump) = label;
>    LABEL_NUSES (label)++;
> diff --git a/gcc/cfgrtl.h b/gcc/cfgrtl.h
> index 32c8ff6..cdf1477 100644
> --- a/gcc/cfgrtl.h
> +++ b/gcc/cfgrtl.h
> @@ -33,7 +33,7 @@ extern bool contains_no_active_insn_p (const_basic_block);
>  extern bool forwarder_block_p (const_basic_block);
>  extern bool can_fallthru (basic_block, basic_block);
>  extern rtx_note *bb_note (basic_block);
> -extern rtx block_label (basic_block);
> +extern rtx_code_label *block_label (basic_block);
>  extern edge try_redirect_by_replacing_jump (edge, basic_block, bool);
>  extern void emit_barrier_after_bb (basic_block bb);
>  extern basic_block force_nonfallthru_and_redirect (edge, basic_block, rtx);
> diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
> index 22bc81f..b6c71b2 100644
> --- a/gcc/config/i386/i386.c
> +++ b/gcc/config/i386/i386.c
> @@ -38448,7 +38448,7 @@ ix86_emit_cmove (rtx dst, rtx src, enum rtx_code code, rtx op1, rtx op2)
>      }
>    else
>      {
> -      rtx nomove = gen_label_rtx ();
> +      rtx_code_label *nomove = gen_label_rtx ();
>        emit_cmp_and_jump_insns (op1, op2, reverse_condition (code),
>  			       const0_rtx, GET_MODE (op1), 1, nomove);
>        emit_move_insn (dst, src);
> diff --git a/gcc/dojump.c b/gcc/dojump.c
> index ad356ba..42dc479 100644
> --- a/gcc/dojump.c
> +++ b/gcc/dojump.c
> @@ -61,10 +61,12 @@ along with GCC; see the file COPYING3.  If not see
>  #include "tm_p.h"
>  
>  static bool prefer_and_bit_test (machine_mode, int);
> -static void do_jump_by_parts_greater (tree, tree, int, rtx, rtx, int);
> -static void do_jump_by_parts_equality (tree, tree, rtx, rtx, int);
> -static void do_compare_and_jump	(tree, tree, enum rtx_code, enum rtx_code, rtx,
> -				 rtx, int);
> +static void do_jump_by_parts_greater (tree, tree, int,
> +				      rtx_code_label *, rtx_code_label *, int);
> +static void do_jump_by_parts_equality (tree, tree, rtx_code_label *,
> +				       rtx_code_label *, int);
> +static void do_compare_and_jump	(tree, tree, enum rtx_code, enum rtx_code,
> +				 rtx_code_label *, rtx_code_label *, int);
>  
>  /* Invert probability if there is any.  -1 stands for unknown.  */
>  
> @@ -146,34 +148,34 @@ restore_pending_stack_adjust (saved_pending_stack_adjust *save)
>  
>  /* Expand conditional expressions.  */
>  
> -/* Generate code to evaluate EXP and jump to LABEL if the value is zero.
> -   LABEL is an rtx of code CODE_LABEL, in this function and all the
> -   functions here.  */
> +/* Generate code to evaluate EXP and jump to LABEL if the value is zero.  */
>  
>  void
> -jumpifnot (tree exp, rtx label, int prob)
> +jumpifnot (tree exp, rtx_code_label *label, int prob)
>  {
> -  do_jump (exp, label, NULL_RTX, inv (prob));
> +  do_jump (exp, label, NULL, inv (prob));
>  }
>  
>  void
> -jumpifnot_1 (enum tree_code code, tree op0, tree op1, rtx label, int prob)
> +jumpifnot_1 (enum tree_code code, tree op0, tree op1, rtx_code_label *label,
> +	     int prob)
>  {
> -  do_jump_1 (code, op0, op1, label, NULL_RTX, inv (prob));
> +  do_jump_1 (code, op0, op1, label, NULL, inv (prob));
>  }
>  
>  /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
>  
>  void
> -jumpif (tree exp, rtx label, int prob)
> +jumpif (tree exp, rtx_code_label *label, int prob)
>  {
> -  do_jump (exp, NULL_RTX, label, prob);
> +  do_jump (exp, NULL, label, prob);
>  }
>  
>  void
> -jumpif_1 (enum tree_code code, tree op0, tree op1, rtx label, int prob)
> +jumpif_1 (enum tree_code code, tree op0, tree op1,
> +	  rtx_code_label *label, int prob)
>  {
> -  do_jump_1 (code, op0, op1, NULL_RTX, label, prob);
> +  do_jump_1 (code, op0, op1, NULL, label, prob);
>  }
>  
>  /* Used internally by prefer_and_bit_test.  */
> @@ -225,7 +227,8 @@ prefer_and_bit_test (machine_mode mode, int bitnum)
>  
>  void
>  do_jump_1 (enum tree_code code, tree op0, tree op1,
> -	   rtx if_false_label, rtx if_true_label, int prob)
> +	   rtx_code_label *if_false_label, rtx_code_label *if_true_label,
> +	   int prob)
>  {
>    machine_mode mode;
>    rtx_code_label *drop_through_label = 0;
> @@ -378,15 +381,15 @@ do_jump_1 (enum tree_code code, tree op0, tree op1,
>              op0_prob = inv (op0_false_prob);
>              op1_prob = inv (op1_false_prob);
>            }
> -        if (if_false_label == NULL_RTX)
> +        if (if_false_label == NULL)
>            {
>              drop_through_label = gen_label_rtx ();
> -            do_jump (op0, drop_through_label, NULL_RTX, op0_prob);
> -            do_jump (op1, NULL_RTX, if_true_label, op1_prob);
> +            do_jump (op0, drop_through_label, NULL, op0_prob);
> +            do_jump (op1, NULL, if_true_label, op1_prob);
>            }
>          else
>            {
> -            do_jump (op0, if_false_label, NULL_RTX, op0_prob);
> +            do_jump (op0, if_false_label, NULL, op0_prob);
>              do_jump (op1, if_false_label, if_true_label, op1_prob);
>            }
>          break;
> @@ -405,18 +408,18 @@ do_jump_1 (enum tree_code code, tree op0, tree op1,
>            {
>              op0_prob = prob / 2;
>              op1_prob = GCOV_COMPUTE_SCALE ((prob / 2), inv (op0_prob));
> -          }
> -        if (if_true_label == NULL_RTX)
> -          {
> -            drop_through_label = gen_label_rtx ();
> -            do_jump (op0, NULL_RTX, drop_through_label, op0_prob);
> -            do_jump (op1, if_false_label, NULL_RTX, op1_prob);
> -          }
> -        else
> -          {
> -            do_jump (op0, NULL_RTX, if_true_label, op0_prob);
> -            do_jump (op1, if_false_label, if_true_label, op1_prob);
> -          }
> +	  }
> +	if (if_true_label == NULL)
> +	  {
> +	    drop_through_label = gen_label_rtx ();
> +	    do_jump (op0, NULL, drop_through_label, op0_prob);
> +	    do_jump (op1, if_false_label, NULL, op1_prob);
> +	  }
> +	else
> +	  {
> +	    do_jump (op0, NULL, if_true_label, op0_prob);
> +	    do_jump (op1, if_false_label, if_true_label, op1_prob);
> +	  }
>          break;
>        }
>  
> @@ -443,14 +446,15 @@ do_jump_1 (enum tree_code code, tree op0, tree op1,
>     PROB is probability of jump to if_true_label, or -1 if unknown.  */
>  
>  void
> -do_jump (tree exp, rtx if_false_label, rtx if_true_label, int prob)
> +do_jump (tree exp, rtx_code_label *if_false_label,
> +	 rtx_code_label *if_true_label, int prob)
>  {
>    enum tree_code code = TREE_CODE (exp);
>    rtx temp;
>    int i;
>    tree type;
>    machine_mode mode;
> -  rtx_code_label *drop_through_label = 0;
> +  rtx_code_label *drop_through_label = NULL;
>  
>    switch (code)
>      {
> @@ -458,10 +462,13 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label, int prob)
>        break;
>  
>      case INTEGER_CST:
> -      temp = integer_zerop (exp) ? if_false_label : if_true_label;
> -      if (temp)
> -        emit_jump (temp);
> -      break;
> +      {
> +	rtx_code_label *lab = integer_zerop (exp) ? if_false_label
> +						  : if_true_label;
> +	if (lab)
> +	  emit_jump (lab);
> +	break;
> +      }
>  
>  #if 0
>        /* This is not true with #pragma weak  */
> @@ -511,7 +518,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label, int prob)
>  	  }
>  
>          do_pending_stack_adjust ();
> -	do_jump (TREE_OPERAND (exp, 0), label1, NULL_RTX, -1);
> +	do_jump (TREE_OPERAND (exp, 0), label1, NULL, -1);
>  	do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label, prob);
>          emit_label (label1);
>  	do_jump (TREE_OPERAND (exp, 2), if_false_label, if_true_label, prob);
> @@ -555,7 +562,7 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label, int prob)
>        if (integer_onep (TREE_OPERAND (exp, 1)))
>  	{
>  	  tree exp0 = TREE_OPERAND (exp, 0);
> -	  rtx set_label, clr_label;
> +	  rtx_code_label *set_label, *clr_label;
>  	  int setclr_prob = prob;
>  
>  	  /* Strip narrowing integral type conversions.  */
> @@ -684,11 +691,12 @@ do_jump (tree exp, rtx if_false_label, rtx if_true_label, int prob)
>  
>  static void
>  do_jump_by_parts_greater_rtx (machine_mode mode, int unsignedp, rtx op0,
> -			      rtx op1, rtx if_false_label, rtx if_true_label,
> +			      rtx op1, rtx_code_label *if_false_label,
> +			      rtx_code_label *if_true_label,
>  			      int prob)
>  {
>    int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
> -  rtx drop_through_label = 0;
> +  rtx_code_label *drop_through_label = 0;
>    bool drop_through_if_true = false, drop_through_if_false = false;
>    enum rtx_code code = GT;
>    int i;
> @@ -735,7 +743,7 @@ do_jump_by_parts_greater_rtx (machine_mode mode, int unsignedp, rtx op0,
>  
>        /* All but high-order word must be compared as unsigned.  */
>        do_compare_rtx_and_jump (op0_word, op1_word, code, (unsignedp || i > 0),
> -			       word_mode, NULL_RTX, NULL_RTX, if_true_label,
> +			       word_mode, NULL_RTX, NULL, if_true_label,
>  			       prob);
>  
>        /* Emit only one comparison for 0.  Do not emit the last cond jump.  */
> @@ -744,7 +752,7 @@ do_jump_by_parts_greater_rtx (machine_mode mode, int unsignedp, rtx op0,
>  
>        /* Consider lower words only if these are equal.  */
>        do_compare_rtx_and_jump (op0_word, op1_word, NE, unsignedp, word_mode,
> -			       NULL_RTX, NULL_RTX, if_false_label, inv (prob));
> +			       NULL_RTX, NULL, if_false_label, inv (prob));
>      }
>  
>    if (!drop_through_if_false)
> @@ -760,7 +768,8 @@ do_jump_by_parts_greater_rtx (machine_mode mode, int unsignedp, rtx op0,
>  
>  static void
>  do_jump_by_parts_greater (tree treeop0, tree treeop1, int swap,
> -			  rtx if_false_label, rtx if_true_label, int prob)
> +			  rtx_code_label *if_false_label,
> +			  rtx_code_label *if_true_label, int prob)
>  {
>    rtx op0 = expand_normal (swap ? treeop1 : treeop0);
>    rtx op1 = expand_normal (swap ? treeop0 : treeop1);
> @@ -773,17 +782,18 @@ do_jump_by_parts_greater (tree treeop0, tree treeop1, int swap,
>  
>  /* Jump according to whether OP0 is 0.  We assume that OP0 has an integer
>     mode, MODE, that is too wide for the available compare insns.  Either
> -   Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL_RTX
> +   Either (but not both) of IF_TRUE_LABEL and IF_FALSE_LABEL may be NULL
>     to indicate drop through.  */
>  
>  static void
>  do_jump_by_parts_zero_rtx (machine_mode mode, rtx op0,
> -			   rtx if_false_label, rtx if_true_label, int prob)
> +			   rtx_code_label *if_false_label,
> +			   rtx_code_label *if_true_label, int prob)
>  {
>    int nwords = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
>    rtx part;
>    int i;
> -  rtx drop_through_label = 0;
> +  rtx_code_label *drop_through_label = NULL;
>  
>    /* The fastest way of doing this comparison on almost any machine is to
>       "or" all the words and compare the result.  If all have to be loaded
> @@ -806,12 +816,12 @@ do_jump_by_parts_zero_rtx (machine_mode mode, rtx op0,
>  
>    /* If we couldn't do the "or" simply, do this with a series of compares.  */
>    if (! if_false_label)
> -    drop_through_label = if_false_label = gen_label_rtx ();
> +    if_false_label = drop_through_label = gen_label_rtx ();
>  
>    for (i = 0; i < nwords; i++)
>      do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
>                               const0_rtx, EQ, 1, word_mode, NULL_RTX,
> -			     if_false_label, NULL_RTX, prob);
> +			     if_false_label, NULL, prob);
>  
>    if (if_true_label)
>      emit_jump (if_true_label);
> @@ -827,10 +837,11 @@ do_jump_by_parts_zero_rtx (machine_mode mode, rtx op0,
>  
>  static void
>  do_jump_by_parts_equality_rtx (machine_mode mode, rtx op0, rtx op1,
> -			       rtx if_false_label, rtx if_true_label, int prob)
> +			       rtx_code_label *if_false_label,
> +			       rtx_code_label *if_true_label, int prob)
>  {
>    int nwords = (GET_MODE_SIZE (mode) / UNITS_PER_WORD);
> -  rtx drop_through_label = 0;
> +  rtx_code_label *drop_through_label = NULL;
>    int i;
>  
>    if (op1 == const0_rtx)
> @@ -853,7 +864,7 @@ do_jump_by_parts_equality_rtx (machine_mode mode, rtx op0, rtx op1,
>      do_compare_rtx_and_jump (operand_subword_force (op0, i, mode),
>                               operand_subword_force (op1, i, mode),
>                               EQ, 0, word_mode, NULL_RTX,
> -			     if_false_label, NULL_RTX, prob);
> +			     if_false_label, NULL, prob);
>  
>    if (if_true_label)
>      emit_jump (if_true_label);
> @@ -865,8 +876,9 @@ do_jump_by_parts_equality_rtx (machine_mode mode, rtx op0, rtx op1,
>     with one insn, test the comparison and jump to the appropriate label.  */
>  
>  static void
> -do_jump_by_parts_equality (tree treeop0, tree treeop1, rtx if_false_label,
> -			   rtx if_true_label, int prob)
> +do_jump_by_parts_equality (tree treeop0, tree treeop1,
> +			   rtx_code_label *if_false_label,
> +			   rtx_code_label *if_true_label, int prob)
>  {
>    rtx op0 = expand_normal (treeop0);
>    rtx op1 = expand_normal (treeop1);
> @@ -961,11 +973,12 @@ split_comparison (enum rtx_code code, machine_mode mode,
>  
>  void
>  do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
> -			 machine_mode mode, rtx size, rtx if_false_label,
> -			 rtx if_true_label, int prob)
> +			 machine_mode mode, rtx size,
> +			 rtx_code_label *if_false_label,
> +			 rtx_code_label *if_true_label, int prob)
>  {
>    rtx tem;
> -  rtx dummy_label = NULL;
> +  rtx_code_label *dummy_label = NULL;
>  
>    /* Reverse the comparison if that is safe and we want to jump if it is
>       false.  Also convert to the reverse comparison if the target can
> @@ -987,9 +1000,7 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>        if (can_compare_p (rcode, mode, ccp_jump)
>  	  || (code == ORDERED && ! can_compare_p (ORDERED, mode, ccp_jump)))
>  	{
> -          tem = if_true_label;
> -          if_true_label = if_false_label;
> -          if_false_label = tem;
> +	  std::swap (if_true_label, if_false_label);
>  	  code = rcode;
>  	  prob = inv (prob);
>  	}
> @@ -1000,9 +1011,7 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>  
>    if (swap_commutative_operands_p (op0, op1))
>      {
> -      tem = op0;
> -      op0 = op1;
> -      op1 = tem;
> +      std::swap (op0, op1);
>        code = swap_condition (code);
>      }
>  
> @@ -1014,8 +1023,9 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>      {
>        if (CONSTANT_P (tem))
>  	{
> -	  rtx label = (tem == const0_rtx || tem == CONST0_RTX (mode))
> -		      ? if_false_label : if_true_label;
> +	  rtx_code_label *label = (tem == const0_rtx
> +				   || tem == CONST0_RTX (mode)) ?
> +				       if_false_label : if_true_label;
>  	  if (label)
>  	    emit_jump (label);
>  	  return;
> @@ -1134,7 +1144,7 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>  		first_prob = REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100;
>  	      if (and_them)
>  		{
> -		  rtx dest_label;
> +		  rtx_code_label *dest_label;
>  		  /* If we only jump if true, just bypass the second jump.  */
>  		  if (! if_false_label)
>  		    {
> @@ -1145,13 +1155,11 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>  		  else
>  		    dest_label = if_false_label;
>                    do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
> -					   size, dest_label, NULL_RTX,
> -					   first_prob);
> +					   size, dest_label, NULL, first_prob);
>  		}
>                else
>                  do_compare_rtx_and_jump (op0, op1, first_code, unsignedp, mode,
> -					 size, NULL_RTX, if_true_label,
> -					 first_prob);
> +					 size, NULL, if_true_label, first_prob);
>  	    }
>  	}
>  
> @@ -1177,8 +1185,9 @@ do_compare_rtx_and_jump (rtx op0, rtx op1, enum rtx_code code, int unsignedp,
>  
>  static void
>  do_compare_and_jump (tree treeop0, tree treeop1, enum rtx_code signed_code,
> -		     enum rtx_code unsigned_code, rtx if_false_label,
> -		     rtx if_true_label, int prob)
> +		     enum rtx_code unsigned_code,
> +		     rtx_code_label *if_false_label,
> +		     rtx_code_label *if_true_label, int prob)
>  {
>    rtx op0, op1;
>    tree type;
> diff --git a/gcc/dojump.h b/gcc/dojump.h
> index 74d3f37..1b64ea7 100644
> --- a/gcc/dojump.h
> +++ b/gcc/dojump.h
> @@ -57,20 +57,23 @@ extern void save_pending_stack_adjust (saved_pending_stack_adjust *);
>  extern void restore_pending_stack_adjust (saved_pending_stack_adjust *);
>  
>  /* Generate code to evaluate EXP and jump to LABEL if the value is zero.  */
> -extern void jumpifnot (tree, rtx, int);
> -extern void jumpifnot_1 (enum tree_code, tree, tree, rtx, int);
> +extern void jumpifnot (tree exp, rtx_code_label *label, int prob);
> +extern void jumpifnot_1 (enum tree_code, tree, tree, rtx_code_label *, int);
>  
>  /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
> -extern void jumpif (tree, rtx, int);
> -extern void jumpif_1 (enum tree_code, tree, tree, rtx, int);
> +extern void jumpif (tree exp, rtx_code_label *label, int prob);
> +extern void jumpif_1 (enum tree_code, tree, tree, rtx_code_label *, int);
>  
>  /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
>     the result is zero, or IF_TRUE_LABEL if the result is one.  */
> -extern void do_jump (tree, rtx, rtx, int);
> -extern void do_jump_1 (enum tree_code, tree, tree, rtx, rtx, int);
> +extern void do_jump (tree exp, rtx_code_label *if_false_label,
> +		     rtx_code_label *if_true_label, int prob);
> +extern void do_jump_1 (enum tree_code, tree, tree, rtx_code_label *,
> +		       rtx_code_label *, int);
>  
>  extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int,
> -				     machine_mode, rtx, rtx, rtx, int);
> +				     machine_mode, rtx, rtx_code_label *,
> +				     rtx_code_label *, int);
>  
>  extern bool split_comparison (enum rtx_code, machine_mode,
>  			      enum rtx_code *, enum rtx_code *);
> diff --git a/gcc/dse.c b/gcc/dse.c
> index 2bb20d7..e923ea6 100644
> --- a/gcc/dse.c
> +++ b/gcc/dse.c
> @@ -907,7 +907,7 @@ emit_inc_dec_insn_before (rtx mem ATTRIBUTE_UNUSED,
>        end_sequence ();
>      }
>    else
> -    new_insn = as_a <rtx_insn *> (gen_move_insn (dest, src));
> +    new_insn = gen_move_insn (dest, src);
>    info.first = new_insn;
>    info.fixed_regs_live = insn_info->fixed_regs_live;
>    info.failure = false;
> diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
> index 483eacb..8b12b10 100644
> --- a/gcc/emit-rtl.c
> +++ b/gcc/emit-rtl.c
> @@ -4463,13 +4463,15 @@ emit_barrier_before (rtx before)
>  
>  /* Emit the label LABEL before the insn BEFORE.  */
>  
> -rtx_insn *
> -emit_label_before (rtx label, rtx_insn *before)
> +rtx_code_label *
> +emit_label_before (rtx uncast_label, rtx_insn *before)
>  {
> +  rtx_code_label *label = as_a <rtx_code_label *> (uncast_label);
> +
>    gcc_checking_assert (INSN_UID (label) == 0);
>    INSN_UID (label) = cur_insn_uid++;
>    add_insn_before (label, before, NULL);
> -  return as_a <rtx_insn *> (label);
> +  return label;
>  }
>  
>  /* Helper for emit_insn_after, handles lists of instructions
> @@ -5090,13 +5092,15 @@ emit_call_insn (rtx x)
>  
>  /* Add the label LABEL to the end of the doubly-linked list.  */
>  
> -rtx_insn *
> -emit_label (rtx label)
> +rtx_code_label *
> +emit_label (rtx uncast_label)
>  {
> +  rtx_code_label *label = as_a <rtx_code_label *> (uncast_label);
> +
>    gcc_checking_assert (INSN_UID (label) == 0);
>    INSN_UID (label) = cur_insn_uid++;
> -  add_insn (as_a <rtx_insn *> (label));
> -  return as_a <rtx_insn *> (label);
> +  add_insn (label);
> +  return label;
>  }
>  
>  /* Make an insn of code JUMP_TABLE_DATA
> @@ -5357,7 +5361,7 @@ emit (rtx x)
>    switch (code)
>      {
>      case CODE_LABEL:
> -      return emit_label (x);
> +      return emit_label (as_a <rtx_code_label *> (x));
>      case INSN:
>        return emit_insn (x);
>      case  JUMP_INSN:
> diff --git a/gcc/except.c b/gcc/except.c
> index 833ec21..90ffbd1 100644
> --- a/gcc/except.c
> +++ b/gcc/except.c
> @@ -1354,7 +1354,7 @@ sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
>      if (lp && lp->post_landing_pad)
>        {
>  	rtx_insn *seq2;
> -	rtx label;
> +	rtx_code_label *label;
>  
>  	start_sequence ();
>  
> @@ -1368,7 +1368,7 @@ sjlj_emit_dispatch_table (rtx_code_label *dispatch_label, int num_dispatch)
>  	    t = build_int_cst (integer_type_node, disp_index);
>  	    case_elt = build_case_label (t, NULL, t_label);
>  	    dispatch_labels.quick_push (case_elt);
> -	    label = label_rtx (t_label);
> +	    label = live_label_rtx (t_label);
>  	  }
>  	else
>  	  label = gen_label_rtx ();
> diff --git a/gcc/explow.c b/gcc/explow.c
> index de446a9..57cb767 100644
> --- a/gcc/explow.c
> +++ b/gcc/explow.c
> @@ -984,7 +984,7 @@ emit_stack_save (enum save_level save_level, rtx *psave)
>  {
>    rtx sa = *psave;
>    /* The default is that we use a move insn and save in a Pmode object.  */
> -  rtx (*fcn) (rtx, rtx) = gen_move_insn;
> +  rtx_insn * (*fcn) (rtx, rtx) = gen_move_insn;
>    machine_mode mode = STACK_SAVEAREA_MODE (save_level);
>  
>    /* See if this machine has anything special to do for this kind of save.  */
> @@ -1039,7 +1039,7 @@ void
>  emit_stack_restore (enum save_level save_level, rtx sa)
>  {
>    /* The default is that we use a move insn.  */
> -  rtx (*fcn) (rtx, rtx) = gen_move_insn;
> +  rtx_insn * (*fcn) (rtx, rtx) = gen_move_insn;
>  
>    /* If stack_realign_drap, the x86 backend emits a prologue that aligns both
>       STACK_POINTER and HARD_FRAME_POINTER.
> diff --git a/gcc/expmed.c b/gcc/expmed.c
> index e0b2619..ccfb25a 100644
> --- a/gcc/expmed.c
> +++ b/gcc/expmed.c
> @@ -5799,8 +5799,8 @@ emit_store_flag_force (rtx target, enum rtx_code code, rtx op0, rtx op1,
>        && op1 == const0_rtx)
>      {
>        label = gen_label_rtx ();
> -      do_compare_rtx_and_jump (target, const0_rtx, EQ, unsignedp,
> -			       mode, NULL_RTX, NULL_RTX, label, -1);
> +      do_compare_rtx_and_jump (target, const0_rtx, EQ, unsignedp, mode,
> +			       NULL_RTX, NULL, label, -1);
>        emit_move_insn (target, trueval);
>        emit_label (label);
>        return target;
> @@ -5837,8 +5837,8 @@ emit_store_flag_force (rtx target, enum rtx_code code, rtx op0, rtx op1,
>  
>    emit_move_insn (target, trueval);
>    label = gen_label_rtx ();
> -  do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, NULL_RTX,
> -			   NULL_RTX, label, -1);
> +  do_compare_rtx_and_jump (op0, op1, code, unsignedp, mode, NULL_RTX, NULL,
> +			   label, -1);
>  
>    emit_move_insn (target, falseval);
>    emit_label (label);
> @@ -5855,6 +5855,6 @@ do_cmp_and_jump (rtx arg1, rtx arg2, enum rtx_code op, machine_mode mode,
>  		 rtx_code_label *label)
>  {
>    int unsignedp = (op == LTU || op == LEU || op == GTU || op == GEU);
> -  do_compare_rtx_and_jump (arg1, arg2, op, unsignedp, mode,
> -			   NULL_RTX, NULL_RTX, label, -1);
> +  do_compare_rtx_and_jump (arg1, arg2, op, unsignedp, mode, NULL_RTX,
> +			   NULL, label, -1);
>  }
> diff --git a/gcc/expr.c b/gcc/expr.c
> index dc13a14..a7066be 100644
> --- a/gcc/expr.c
> +++ b/gcc/expr.c
> @@ -3652,7 +3652,7 @@ emit_move_insn (rtx x, rtx y)
>  /* Generate the body of an instruction to copy Y into X.
>     It may be a list of insns, if one insn isn't enough.  */
>  
> -rtx
> +rtx_insn *
>  gen_move_insn (rtx x, rtx y)
>  {
>    rtx_insn *seq;
> @@ -8122,6 +8122,7 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>  		    enum expand_modifier modifier)
>  {
>    rtx op0, op1, op2, temp;
> +  rtx_code_label *lab;
>    tree type;
>    int unsignedp;
>    machine_mode mode;
> @@ -8864,11 +8865,7 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>  
>        /* If op1 was placed in target, swap op0 and op1.  */
>        if (target != op0 && target == op1)
> -	{
> -	  temp = op0;
> -	  op0 = op1;
> -	  op1 = temp;
> -	}
> +	std::swap (op0, op1);
>  
>        /* We generate better code and avoid problems with op1 mentioning
>  	 target by forcing op1 into a pseudo if it isn't a constant.  */
> @@ -8935,13 +8932,13 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>  	if (target != op0)
>  	  emit_move_insn (target, op0);
>  
> -	temp = gen_label_rtx ();
> +	lab = gen_label_rtx ();
>  	do_compare_rtx_and_jump (target, cmpop1, comparison_code,
> -				 unsignedp, mode, NULL_RTX, NULL_RTX, temp,
> +				 unsignedp, mode, NULL_RTX, NULL, lab,
>  				 -1);
>        }
>        emit_move_insn (target, op1);
> -      emit_label (temp);
> +      emit_label (lab);
>        return target;
>  
>      case BIT_NOT_EXPR:
> @@ -9019,38 +9016,39 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>      case UNGE_EXPR:
>      case UNEQ_EXPR:
>      case LTGT_EXPR:
> -      temp = do_store_flag (ops,
> -			    modifier != EXPAND_STACK_PARM ? target : NULL_RTX,
> -			    tmode != VOIDmode ? tmode : mode);
> -      if (temp)
> -	return temp;
> -
> -      /* Use a compare and a jump for BLKmode comparisons, or for function
> -	 type comparisons is HAVE_canonicalize_funcptr_for_compare.  */
> -
> -      if ((target == 0
> -	   || modifier == EXPAND_STACK_PARM
> -	   || ! safe_from_p (target, treeop0, 1)
> -	   || ! safe_from_p (target, treeop1, 1)
> -	   /* Make sure we don't have a hard reg (such as function's return
> -	      value) live across basic blocks, if not optimizing.  */
> -	   || (!optimize && REG_P (target)
> -	       && REGNO (target) < FIRST_PSEUDO_REGISTER)))
> -	target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
> +      {
> +	temp = do_store_flag (ops,
> +			      modifier != EXPAND_STACK_PARM ? target : NULL_RTX,
> +			      tmode != VOIDmode ? tmode : mode);
> +	if (temp)
> +	  return temp;
>  
> -      emit_move_insn (target, const0_rtx);
> +	/* Use a compare and a jump for BLKmode comparisons, or for function
> +	   type comparisons is HAVE_canonicalize_funcptr_for_compare.  */
> +
> +	if ((target == 0
> +	     || modifier == EXPAND_STACK_PARM
> +	     || ! safe_from_p (target, treeop0, 1)
> +	     || ! safe_from_p (target, treeop1, 1)
> +	     /* Make sure we don't have a hard reg (such as function's return
> +		value) live across basic blocks, if not optimizing.  */
> +	     || (!optimize && REG_P (target)
> +		 && REGNO (target) < FIRST_PSEUDO_REGISTER)))
> +	  target = gen_reg_rtx (tmode != VOIDmode ? tmode : mode);
>  
> -      op1 = gen_label_rtx ();
> -      jumpifnot_1 (code, treeop0, treeop1, op1, -1);
> +	emit_move_insn (target, const0_rtx);
>  
> -      if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
> -	emit_move_insn (target, constm1_rtx);
> -      else
> -	emit_move_insn (target, const1_rtx);
> +	rtx_code_label *lab1 = gen_label_rtx ();
> +	jumpifnot_1 (code, treeop0, treeop1, lab1, -1);
>  
> -      emit_label (op1);
> -      return target;
> +	if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
> +	  emit_move_insn (target, constm1_rtx);
> +	else
> +	  emit_move_insn (target, const1_rtx);
>  
> +	emit_label (lab1);
> +	return target;
> +      }
>      case COMPLEX_EXPR:
>        /* Get the rtx code of the operands.  */
>        op0 = expand_normal (treeop0);
> @@ -9273,58 +9271,60 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>        }
>  
>      case COND_EXPR:
> -      /* A COND_EXPR with its type being VOID_TYPE represents a
> -	 conditional jump and is handled in
> -	 expand_gimple_cond_expr.  */
> -      gcc_assert (!VOID_TYPE_P (type));
> -
> -      /* Note that COND_EXPRs whose type is a structure or union
> -	 are required to be constructed to contain assignments of
> -	 a temporary variable, so that we can evaluate them here
> -	 for side effect only.  If type is void, we must do likewise.  */
> -
> -      gcc_assert (!TREE_ADDRESSABLE (type)
> -		  && !ignore
> -		  && TREE_TYPE (treeop1) != void_type_node
> -		  && TREE_TYPE (treeop2) != void_type_node);
> -
> -      temp = expand_cond_expr_using_cmove (treeop0, treeop1, treeop2);
> -      if (temp)
> -	return temp;
> -
> -      /* If we are not to produce a result, we have no target.  Otherwise,
> -	 if a target was specified use it; it will not be used as an
> -	 intermediate target unless it is safe.  If no target, use a
> -	 temporary.  */
> -
> -      if (modifier != EXPAND_STACK_PARM
> -	  && original_target
> -	  && safe_from_p (original_target, treeop0, 1)
> -	  && GET_MODE (original_target) == mode
> -	  && !MEM_P (original_target))
> -	temp = original_target;
> -      else
> -	temp = assign_temp (type, 0, 1);
> -
> -      do_pending_stack_adjust ();
> -      NO_DEFER_POP;
> -      op0 = gen_label_rtx ();
> -      op1 = gen_label_rtx ();
> -      jumpifnot (treeop0, op0, -1);
> -      store_expr (treeop1, temp,
> -		  modifier == EXPAND_STACK_PARM,
> -		  false);
> -
> -      emit_jump_insn (gen_jump (op1));
> -      emit_barrier ();
> -      emit_label (op0);
> -      store_expr (treeop2, temp,
> -		  modifier == EXPAND_STACK_PARM,
> -		  false);
> +      {
> +	/* A COND_EXPR with its type being VOID_TYPE represents a
> +	   conditional jump and is handled in
> +	   expand_gimple_cond_expr.  */
> +	gcc_assert (!VOID_TYPE_P (type));
> +
> +	/* Note that COND_EXPRs whose type is a structure or union
> +	   are required to be constructed to contain assignments of
> +	   a temporary variable, so that we can evaluate them here
> +	   for side effect only.  If type is void, we must do likewise.  */
> +
> +	gcc_assert (!TREE_ADDRESSABLE (type)
> +		    && !ignore
> +		    && TREE_TYPE (treeop1) != void_type_node
> +		    && TREE_TYPE (treeop2) != void_type_node);
> +
> +	temp = expand_cond_expr_using_cmove (treeop0, treeop1, treeop2);
> +	if (temp)
> +	  return temp;
>  
> -      emit_label (op1);
> -      OK_DEFER_POP;
> -      return temp;
> +	/* If we are not to produce a result, we have no target.  Otherwise,
> +	   if a target was specified use it; it will not be used as an
> +	   intermediate target unless it is safe.  If no target, use a
> +	   temporary.  */
> +
> +	if (modifier != EXPAND_STACK_PARM
> +	    && original_target
> +	    && safe_from_p (original_target, treeop0, 1)
> +	    && GET_MODE (original_target) == mode
> +	    && !MEM_P (original_target))
> +	  temp = original_target;
> +	else
> +	  temp = assign_temp (type, 0, 1);
> +
> +	do_pending_stack_adjust ();
> +	NO_DEFER_POP;
> +	rtx_code_label *lab0 = gen_label_rtx ();
> +	rtx_code_label *lab1 = gen_label_rtx ();
> +	jumpifnot (treeop0, lab0, -1);
> +	store_expr (treeop1, temp,
> +		    modifier == EXPAND_STACK_PARM,
> +		    false);
> +
> +	emit_jump_insn (gen_jump (lab1));
> +	emit_barrier ();
> +	emit_label (lab0);
> +	store_expr (treeop2, temp,
> +		    modifier == EXPAND_STACK_PARM,
> +		    false);
> +
> +	emit_label (lab1);
> +	OK_DEFER_POP;
> +	return temp;
> +      }
>  
>      case VEC_COND_EXPR:
>        target = expand_vec_cond_expr (type, treeop0, treeop1, treeop2, target);
> diff --git a/gcc/expr.h b/gcc/expr.h
> index 867852e..6c4afc4 100644
> --- a/gcc/expr.h
> +++ b/gcc/expr.h
> @@ -203,7 +203,7 @@ extern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT,
>  
>  /* Emit insns to set X from Y.  */
>  extern rtx_insn *emit_move_insn (rtx, rtx);
> -extern rtx gen_move_insn (rtx, rtx);
> +extern rtx_insn *gen_move_insn (rtx, rtx);
>  
>  /* Emit insns to set X from Y, with no frills.  */
>  extern rtx_insn *emit_move_insn_1 (rtx, rtx);
> diff --git a/gcc/function.c b/gcc/function.c
> index 2c3d142..97ecf3a 100644
> --- a/gcc/function.c
> +++ b/gcc/function.c
> @@ -5760,7 +5760,7 @@ convert_jumps_to_returns (basic_block last_bb, bool simple_p,
>  	    dest = simple_return_rtx;
>  	  else
>  	    dest = ret_rtx;
> -	  if (!redirect_jump (jump, dest, 0))
> +	  if (!redirect_jump (as_a <rtx_jump_insn *> (jump), dest, 0))
>  	    {
>  #ifdef HAVE_simple_return
>  	      if (simple_p)
> diff --git a/gcc/gcse.c b/gcc/gcse.c
> index 37aac6a..20e79e0 100644
> --- a/gcc/gcse.c
> +++ b/gcc/gcse.c
> @@ -2227,7 +2227,8 @@ pre_insert_copy_insn (struct gcse_expr *expr, rtx_insn *insn)
>    int regno = REGNO (reg);
>    int indx = expr->bitmap_index;
>    rtx pat = PATTERN (insn);
> -  rtx set, first_set, new_insn;
> +  rtx set, first_set;
> +  rtx_insn *new_insn;
>    rtx old_reg;
>    int i;
>  
> diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c
> index a3e3e5c..bf79122 100644
> --- a/gcc/ifcvt.c
> +++ b/gcc/ifcvt.c
> @@ -4444,9 +4444,10 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
>        else
>  	new_dest_label = block_label (new_dest);
>  
> +      rtx_jump_insn *jump_insn = as_a <rtx_jump_insn *> (jump);
>        if (reversep
> -	  ? ! invert_jump_1 (jump, new_dest_label)
> -	  : ! redirect_jump_1 (jump, new_dest_label))
> +	  ? ! invert_jump_1 (jump_insn, new_dest_label)
> +	  : ! redirect_jump_1 (jump_insn, new_dest_label))
>  	goto cancel;
>      }
>  
> @@ -4457,7 +4458,8 @@ dead_or_predicable (basic_block test_bb, basic_block merge_bb,
>  
>    if (other_bb != new_dest)
>      {
> -      redirect_jump_2 (jump, old_dest, new_dest_label, 0, reversep);
> +      redirect_jump_2 (as_a <rtx_jump_insn *> (jump), old_dest, new_dest_label,
> +                       0, reversep);
>  
>        redirect_edge_succ (BRANCH_EDGE (test_bb), new_dest);
>        if (reversep)
> diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c
> index e402825..af9baff 100644
> --- a/gcc/internal-fn.c
> +++ b/gcc/internal-fn.c
> @@ -422,7 +422,7 @@ expand_arith_overflow_result_store (tree lhs, rtx target,
>        lres = convert_modes (tgtmode, mode, res, uns);
>        gcc_assert (GET_MODE_PRECISION (tgtmode) < GET_MODE_PRECISION (mode));
>        do_compare_rtx_and_jump (res, convert_modes (mode, tgtmode, lres, uns),
> -			       EQ, true, mode, NULL_RTX, NULL_RTX, done_label,
> +			       EQ, true, mode, NULL_RTX, NULL, done_label,
>  			       PROB_VERY_LIKELY);
>        write_complex_part (target, const1_rtx, true);
>        emit_label (done_label);
> @@ -569,7 +569,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>  	      : CONST_SCALAR_INT_P (op1)))
>  	tem = op1;
>        do_compare_rtx_and_jump (res, tem, code == PLUS_EXPR ? GEU : LEU,
> -			       true, mode, NULL_RTX, NULL_RTX, done_label,
> +			       true, mode, NULL_RTX, NULL, done_label,
>  			       PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
> @@ -584,7 +584,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        rtx tem = expand_binop (mode, add_optab,
>  			      code == PLUS_EXPR ? res : op0, sgn,
>  			      NULL_RTX, false, OPTAB_LIB_WIDEN);
> -      do_compare_rtx_and_jump (tem, op1, GEU, true, mode, NULL_RTX, NULL_RTX,
> +      do_compare_rtx_and_jump (tem, op1, GEU, true, mode, NULL_RTX, NULL,
>  			       done_label, PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
> @@ -627,8 +627,8 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        else if (pos_neg == 3)
>  	/* If ARG0 is not known to be always positive, check at runtime.  */
>  	do_compare_rtx_and_jump (op0, const0_rtx, LT, false, mode, NULL_RTX,
> -				 NULL_RTX, do_error, PROB_VERY_UNLIKELY);
> -      do_compare_rtx_and_jump (op1, op0, LEU, true, mode, NULL_RTX, NULL_RTX,
> +				 NULL, do_error, PROB_VERY_UNLIKELY);
> +      do_compare_rtx_and_jump (op1, op0, LEU, true, mode, NULL_RTX, NULL,
>  			       done_label, PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
> @@ -642,7 +642,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>  			  OPTAB_LIB_WIDEN);
>        rtx tem = expand_binop (mode, add_optab, op1, sgn, NULL_RTX, false,
>  			      OPTAB_LIB_WIDEN);
> -      do_compare_rtx_and_jump (op0, tem, LTU, true, mode, NULL_RTX, NULL_RTX,
> +      do_compare_rtx_and_jump (op0, tem, LTU, true, mode, NULL_RTX, NULL,
>  			       done_label, PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
> @@ -655,7 +655,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        res = expand_binop (mode, add_optab, op0, op1, NULL_RTX, false,
>  			  OPTAB_LIB_WIDEN);
>        do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode, NULL_RTX,
> -			       NULL_RTX, do_error, PROB_VERY_UNLIKELY);
> +			       NULL, do_error, PROB_VERY_UNLIKELY);
>        rtx tem = op1;
>        /* The operation is commutative, so we can pick operand to compare
>  	 against.  For prec <= BITS_PER_WORD, I think preferring REG operand
> @@ -668,7 +668,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>  	  ? (CONST_SCALAR_INT_P (op1) && REG_P (op0))
>  	  : CONST_SCALAR_INT_P (op0))
>  	tem = op0;
> -      do_compare_rtx_and_jump (res, tem, GEU, true, mode, NULL_RTX, NULL_RTX,
> +      do_compare_rtx_and_jump (res, tem, GEU, true, mode, NULL_RTX, NULL,
>  			       done_label, PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
> @@ -698,26 +698,26 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>  	  tem = expand_binop (mode, ((pos_neg == 1) ^ (code == MINUS_EXPR))
>  				    ? and_optab : ior_optab,
>  			      op0, res, NULL_RTX, false, OPTAB_LIB_WIDEN);
> -	  do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +	  do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL,
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	}
>        else
>  	{
>  	  rtx_code_label *do_ior_label = gen_label_rtx ();
>  	  do_compare_rtx_and_jump (op1, const0_rtx,
>  				   code == MINUS_EXPR ? GE : LT, false, mode,
> -				   NULL_RTX, NULL_RTX, do_ior_label,
> +				   NULL_RTX, NULL, do_ior_label,
>  				   PROB_EVEN);
>  	  tem = expand_binop (mode, and_optab, op0, res, NULL_RTX, false,
>  			      OPTAB_LIB_WIDEN);
>  	  do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	  emit_jump (do_error);
>  	  emit_label (do_ior_label);
>  	  tem = expand_binop (mode, ior_optab, op0, res, NULL_RTX, false,
>  			      OPTAB_LIB_WIDEN);
>  	  do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	}
>        goto do_error_label;
>      }
> @@ -730,14 +730,14 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        res = expand_binop (mode, sub_optab, op0, op1, NULL_RTX, false,
>  			  OPTAB_LIB_WIDEN);
>        rtx_code_label *op0_geu_op1 = gen_label_rtx ();
> -      do_compare_rtx_and_jump (op0, op1, GEU, true, mode, NULL_RTX, NULL_RTX,
> +      do_compare_rtx_and_jump (op0, op1, GEU, true, mode, NULL_RTX, NULL,
>  			       op0_geu_op1, PROB_EVEN);
>        do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode, NULL_RTX,
> -			       NULL_RTX, done_label, PROB_VERY_LIKELY);
> +			       NULL, done_label, PROB_VERY_LIKELY);
>        emit_jump (do_error);
>        emit_label (op0_geu_op1);
>        do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode, NULL_RTX,
> -			       NULL_RTX, done_label, PROB_VERY_LIKELY);
> +			       NULL, done_label, PROB_VERY_LIKELY);
>        goto do_error_label;
>      }
>  
> @@ -816,12 +816,12 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        /* If the op1 is negative, we have to use a different check.  */
>        if (pos_neg == 3)
>  	do_compare_rtx_and_jump (op1, const0_rtx, LT, false, mode, NULL_RTX,
> -				 NULL_RTX, sub_check, PROB_EVEN);
> +				 NULL, sub_check, PROB_EVEN);
>  
>        /* Compare the result of the operation with one of the operands.  */
>        if (pos_neg & 1)
>  	do_compare_rtx_and_jump (res, op0, code == PLUS_EXPR ? GE : LE,
> -				 false, mode, NULL_RTX, NULL_RTX, done_label,
> +				 false, mode, NULL_RTX, NULL, done_label,
>  				 PROB_VERY_LIKELY);
>  
>        /* If we get here, we have to print the error.  */
> @@ -835,7 +835,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
>        /* We have k = a + b for b < 0 here.  k <= a must hold.  */
>        if (pos_neg & 2)
>  	do_compare_rtx_and_jump (res, op0, code == PLUS_EXPR ? LE : GE,
> -				 false, mode, NULL_RTX, NULL_RTX, done_label,
> +				 false, mode, NULL_RTX, NULL, done_label,
>  				 PROB_VERY_LIKELY);
>      }
>  
> @@ -931,7 +931,7 @@ expand_neg_overflow (location_t loc, tree lhs, tree arg1, bool is_ubsan)
>  
>        /* Compare the operand with the most negative value.  */
>        rtx minv = expand_normal (TYPE_MIN_VALUE (TREE_TYPE (arg1)));
> -      do_compare_rtx_and_jump (op1, minv, NE, true, mode, NULL_RTX, NULL_RTX,
> +      do_compare_rtx_and_jump (op1, minv, NE, true, mode, NULL_RTX, NULL,
>  			       done_label, PROB_VERY_LIKELY);
>      }
>  
> @@ -1068,15 +1068,15 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	  ops.location = loc;
>  	  res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
>  	  do_compare_rtx_and_jump (op1, const0_rtx, EQ, true, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	  goto do_error_label;
>  	case 3:
>  	  rtx_code_label *do_main_label;
>  	  do_main_label = gen_label_rtx ();
>  	  do_compare_rtx_and_jump (op0, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, do_main_label, PROB_VERY_LIKELY);
> +				   NULL, do_main_label, PROB_VERY_LIKELY);
>  	  do_compare_rtx_and_jump (op1, const0_rtx, EQ, true, mode, NULL_RTX,
> -				   NULL_RTX, do_main_label, PROB_VERY_LIKELY);
> +				   NULL, do_main_label, PROB_VERY_LIKELY);
>  	  write_complex_part (target, const1_rtx, true);
>  	  emit_label (do_main_label);
>  	  goto do_main;
> @@ -1113,15 +1113,15 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	  ops.location = loc;
>  	  res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
>  	  do_compare_rtx_and_jump (op0, const0_rtx, EQ, true, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	  do_compare_rtx_and_jump (op0, constm1_rtx, NE, true, mode, NULL_RTX,
> -				   NULL_RTX, do_error, PROB_VERY_UNLIKELY);
> +				   NULL, do_error, PROB_VERY_UNLIKELY);
>  	  int prec;
>  	  prec = GET_MODE_PRECISION (mode);
>  	  rtx sgn;
>  	  sgn = immed_wide_int_const (wi::min_value (prec, SIGNED), mode);
>  	  do_compare_rtx_and_jump (op1, sgn, EQ, true, mode, NULL_RTX,
> -				   NULL_RTX, done_label, PROB_VERY_LIKELY);
> +				   NULL, done_label, PROB_VERY_LIKELY);
>  	  goto do_error_label;
>  	case 3:
>  	  /* Rest of handling of this case after res is computed.  */
> @@ -1167,7 +1167,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	      tem = expand_binop (mode, and_optab, op0, op1, NULL_RTX, false,
>  				  OPTAB_LIB_WIDEN);
>  	      do_compare_rtx_and_jump (tem, const0_rtx, EQ, true, mode,
> -				       NULL_RTX, NULL_RTX, done_label,
> +				       NULL_RTX, NULL, done_label,
>  				       PROB_VERY_LIKELY);
>  	      goto do_error_label;
>  	    }
> @@ -1185,8 +1185,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	  tem = expand_binop (mode, and_optab, op0, op1, NULL_RTX, false,
>  			      OPTAB_LIB_WIDEN);
>  	  do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, after_negate_label,
> -				   PROB_VERY_LIKELY);
> +				   NULL, after_negate_label, PROB_VERY_LIKELY);
>  	  /* Both arguments negative here, negate them and continue with
>  	     normal unsigned overflow checking multiplication.  */
>  	  emit_move_insn (op0, expand_unop (mode, neg_optab, op0,
> @@ -1202,13 +1201,13 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	  tem2 = expand_binop (mode, xor_optab, op0, op1, NULL_RTX, false,
>  			       OPTAB_LIB_WIDEN);
>  	  do_compare_rtx_and_jump (tem2, const0_rtx, GE, false, mode, NULL_RTX,
> -				   NULL_RTX, do_main_label, PROB_VERY_LIKELY);
> +				   NULL, do_main_label, PROB_VERY_LIKELY);
>  	  /* One argument is negative here, the other positive.  This
>  	     overflows always, unless one of the arguments is 0.  But
>  	     if e.g. s2 is 0, (U) s1 * 0 doesn't overflow, whatever s1
>  	     is, thus we can keep do_main code oring in overflow as is.  */
>  	  do_compare_rtx_and_jump (tem, const0_rtx, EQ, true, mode, NULL_RTX,
> -				   NULL_RTX, do_main_label, PROB_VERY_LIKELY);
> +				   NULL, do_main_label, PROB_VERY_LIKELY);
>  	  write_complex_part (target, const1_rtx, true);
>  	  emit_label (do_main_label);
>  	  goto do_main;
> @@ -1274,7 +1273,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  	    /* For the unsigned multiplication, there was overflow if
>  	       HIPART is non-zero.  */
>  	    do_compare_rtx_and_jump (hipart, const0_rtx, EQ, true, mode,
> -				     NULL_RTX, NULL_RTX, done_label,
> +				     NULL_RTX, NULL, done_label,
>  				     PROB_VERY_LIKELY);
>  	  else
>  	    {
> @@ -1284,7 +1283,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		 the high half.  There was overflow if
>  		 HIPART is different from RES < 0 ? -1 : 0.  */
>  	      do_compare_rtx_and_jump (signbit, hipart, EQ, true, mode,
> -				       NULL_RTX, NULL_RTX, done_label,
> +				       NULL_RTX, NULL, done_label,
>  				       PROB_VERY_LIKELY);
>  	    }
>  	}
> @@ -1377,12 +1376,12 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  
>  	  if (!op0_small_p)
>  	    do_compare_rtx_and_jump (signbit0, hipart0, NE, true, hmode,
> -				     NULL_RTX, NULL_RTX, large_op0,
> +				     NULL_RTX, NULL, large_op0,
>  				     PROB_UNLIKELY);
>  
>  	  if (!op1_small_p)
>  	    do_compare_rtx_and_jump (signbit1, hipart1, NE, true, hmode,
> -				     NULL_RTX, NULL_RTX, small_op0_large_op1,
> +				     NULL_RTX, NULL, small_op0_large_op1,
>  				     PROB_UNLIKELY);
>  
>  	  /* If both op0 and op1 are sign (!uns) or zero (uns) extended from
> @@ -1428,7 +1427,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  
>  	  if (!op1_small_p)
>  	    do_compare_rtx_and_jump (signbit1, hipart1, NE, true, hmode,
> -				     NULL_RTX, NULL_RTX, both_ops_large,
> +				     NULL_RTX, NULL, both_ops_large,
>  				     PROB_UNLIKELY);
>  
>  	  /* If op1 is sign (!uns) or zero (uns) extended from hmode to mode,
> @@ -1465,7 +1464,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		emit_jump (after_hipart_neg);
>  	      else if (larger_sign != -1)
>  		do_compare_rtx_and_jump (hipart, const0_rtx, GE, false, hmode,
> -					 NULL_RTX, NULL_RTX, after_hipart_neg,
> +					 NULL_RTX, NULL, after_hipart_neg,
>  					 PROB_EVEN);
>  
>  	      tem = convert_modes (mode, hmode, lopart, 1);
> @@ -1481,7 +1480,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		emit_jump (after_lopart_neg);
>  	      else if (smaller_sign != -1)
>  		do_compare_rtx_and_jump (lopart, const0_rtx, GE, false, hmode,
> -					 NULL_RTX, NULL_RTX, after_lopart_neg,
> +					 NULL_RTX, NULL, after_lopart_neg,
>  					 PROB_EVEN);
>  
>  	      tem = expand_simple_binop (mode, MINUS, loxhi, larger, NULL_RTX,
> @@ -1510,7 +1509,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  					 hprec - 1, NULL_RTX, 0);
>  
>  	  do_compare_rtx_and_jump (signbitloxhi, hipartloxhi, NE, true, hmode,
> -				   NULL_RTX, NULL_RTX, do_overflow,
> +				   NULL_RTX, NULL, do_overflow,
>  				   PROB_VERY_UNLIKELY);
>  
>  	  /* res = (loxhi << (bitsize / 2)) | (hmode) lo0xlo1;  */
> @@ -1546,7 +1545,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		  tem = expand_simple_binop (hmode, PLUS, hipart0, const1_rtx,
>  					     NULL_RTX, 1, OPTAB_DIRECT);
>  		  do_compare_rtx_and_jump (tem, const1_rtx, GTU, true, hmode,
> -					   NULL_RTX, NULL_RTX, do_error,
> +					   NULL_RTX, NULL, do_error,
>  					   PROB_VERY_UNLIKELY);
>  		}
>  
> @@ -1555,7 +1554,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		  tem = expand_simple_binop (hmode, PLUS, hipart1, const1_rtx,
>  					     NULL_RTX, 1, OPTAB_DIRECT);
>  		  do_compare_rtx_and_jump (tem, const1_rtx, GTU, true, hmode,
> -					   NULL_RTX, NULL_RTX, do_error,
> +					   NULL_RTX, NULL, do_error,
>  					   PROB_VERY_UNLIKELY);
>  		}
>  
> @@ -1566,18 +1565,18 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>  		emit_jump (hipart_different);
>  	      else if (op0_sign == 1 || op1_sign == 1)
>  		do_compare_rtx_and_jump (hipart0, hipart1, NE, true, hmode,
> -					 NULL_RTX, NULL_RTX, hipart_different,
> +					 NULL_RTX, NULL, hipart_different,
>  					 PROB_EVEN);
>  
>  	      do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode,
> -				       NULL_RTX, NULL_RTX, do_error,
> +				       NULL_RTX, NULL, do_error,
>  				       PROB_VERY_UNLIKELY);
>  	      emit_jump (done_label);
>  
>  	      emit_label (hipart_different);
>  
>  	      do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode,
> -				       NULL_RTX, NULL_RTX, do_error,
> +				       NULL_RTX, NULL, do_error,
>  				       PROB_VERY_UNLIKELY);
>  	      emit_jump (done_label);
>  	    }
> @@ -1623,7 +1622,7 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>      {
>        rtx_code_label *all_done_label = gen_label_rtx ();
>        do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode, NULL_RTX,
> -			       NULL_RTX, all_done_label, PROB_VERY_LIKELY);
> +			       NULL, all_done_label, PROB_VERY_LIKELY);
>        write_complex_part (target, const1_rtx, true);
>        emit_label (all_done_label);
>      }
> @@ -1634,13 +1633,13 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
>        rtx_code_label *all_done_label = gen_label_rtx ();
>        rtx_code_label *set_noovf = gen_label_rtx ();
>        do_compare_rtx_and_jump (op1, const0_rtx, GE, false, mode, NULL_RTX,
> -			       NULL_RTX, all_done_label, PROB_VERY_LIKELY);
> +			       NULL, all_done_label, PROB_VERY_LIKELY);
>        write_complex_part (target, const1_rtx, true);
>        do_compare_rtx_and_jump (op0, const0_rtx, EQ, true, mode, NULL_RTX,
> -			       NULL_RTX, set_noovf, PROB_VERY_LIKELY);
> +			       NULL, set_noovf, PROB_VERY_LIKELY);
>        do_compare_rtx_and_jump (op0, constm1_rtx, NE, true, mode, NULL_RTX,
> -			       NULL_RTX, all_done_label, PROB_VERY_UNLIKELY);
> -      do_compare_rtx_and_jump (op1, res, NE, true, mode, NULL_RTX, NULL_RTX,
> +			       NULL, all_done_label, PROB_VERY_UNLIKELY);
> +      do_compare_rtx_and_jump (op1, res, NE, true, mode, NULL_RTX, NULL,
>  			       all_done_label, PROB_VERY_UNLIKELY);
>        emit_label (set_noovf);
>        write_complex_part (target, const0_rtx, true);
> diff --git a/gcc/ira.c b/gcc/ira.c
> index ea2b69f..bdf81e6 100644
> --- a/gcc/ira.c
> +++ b/gcc/ira.c
> @@ -4994,7 +4994,7 @@ split_live_ranges_for_shrink_wrap (void)
>  
>        if (newreg)
>  	{
> -	  rtx new_move = gen_move_insn (newreg, dest);
> +	  rtx_insn *new_move = gen_move_insn (newreg, dest);
>  	  emit_insn_after (new_move, bb_note (call_dom));
>  	  if (dump_file)
>  	    {
> diff --git a/gcc/is-a.h b/gcc/is-a.h
> index 58917eb..4fb9dde 100644
> --- a/gcc/is-a.h
> +++ b/gcc/is-a.h
> @@ -46,6 +46,11 @@ TYPE as_a <TYPE> (pointer)
>  
>        do_something_with (as_a <cgraph_node *> *ptr);
>  
> +TYPE assert_as_a <TYPE> (pointer)
> +
> +    Like as_a <TYPE> (pointer), but uses assertion, which is enabled even in
> +    non-checking (release) build.
> +
>  TYPE safe_as_a <TYPE> (pointer)
>  
>      Like as_a <TYPE> (pointer), but where pointer could be NULL.  This
> @@ -193,6 +198,17 @@ as_a (U *p)
>    return is_a_helper <T>::cast (p);
>  }
>  
> +/* Same as above, but checks the condition even in release build.  */
> +
> +template <typename T, typename U>
> +inline T
> +assert_as_a (U *p)
> +{
> +  gcc_assert (is_a <T> (p));
> +  return is_a_helper <T>::cast (p);
> +}
> +
> +
>  /* Similar to as_a<>, but where the pointer can be NULL, even if
>     is_a_helper<T> doesn't check for NULL.  */
>  
> diff --git a/gcc/jump.c b/gcc/jump.c
> index 34b3b7b..0cc0be5 100644
> --- a/gcc/jump.c
> +++ b/gcc/jump.c
> @@ -1583,7 +1583,7 @@ redirect_jump_1 (rtx jump, rtx nlabel)
>     (this can only occur when trying to produce return insns).  */
>  
>  int
> -redirect_jump (rtx jump, rtx nlabel, int delete_unused)
> +redirect_jump (rtx_jump_insn *jump, rtx nlabel, int delete_unused)
>  {
>    rtx olabel = JUMP_LABEL (jump);
>  
> @@ -1615,7 +1615,7 @@ redirect_jump (rtx jump, rtx nlabel, int delete_unused)
>     If DELETE_UNUSED is positive, delete related insn to OLABEL if its ref
>     count has dropped to zero.  */
>  void
> -redirect_jump_2 (rtx jump, rtx olabel, rtx nlabel, int delete_unused,
> +redirect_jump_2 (rtx_jump_insn *jump, rtx olabel, rtx nlabel, int delete_unused,
>  		 int invert)
>  {
>    rtx note;
> @@ -1703,7 +1703,7 @@ invert_exp_1 (rtx x, rtx insn)
>     inversion and redirection.  */
>  
>  int
> -invert_jump_1 (rtx_insn *jump, rtx nlabel)
> +invert_jump_1 (rtx_jump_insn *jump, rtx nlabel)
>  {
>    rtx x = pc_set (jump);
>    int ochanges;
> @@ -1727,7 +1727,7 @@ invert_jump_1 (rtx_insn *jump, rtx nlabel)
>     NLABEL instead of where it jumps now.  Return true if successful.  */
>  
>  int
> -invert_jump (rtx_insn *jump, rtx nlabel, int delete_unused)
> +invert_jump (rtx_jump_insn *jump, rtx nlabel, int delete_unused)
>  {
>    rtx olabel = JUMP_LABEL (jump);
>  
> diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
> index 2befb61..2f3ff35 100644
> --- a/gcc/loop-unroll.c
> +++ b/gcc/loop-unroll.c
> @@ -794,10 +794,11 @@ split_edge_and_insert (edge e, rtx_insn *insns)
>     in order to create a jump.  */
>  
>  static rtx_insn *
> -compare_and_jump_seq (rtx op0, rtx op1, enum rtx_code comp, rtx label, int prob,
> -		      rtx_insn *cinsn)
> +compare_and_jump_seq (rtx op0, rtx op1, enum rtx_code comp,
> +		      rtx_code_label *label, int prob, rtx_insn *cinsn)
>  {
> -  rtx_insn *seq, *jump;
> +  rtx_insn *seq;
> +  rtx_jump_insn *jump;
>    rtx cond;
>    machine_mode mode;
>  
> @@ -816,8 +817,7 @@ compare_and_jump_seq (rtx op0, rtx op1, enum rtx_code comp, rtx label, int prob,
>        gcc_assert (rtx_equal_p (op0, XEXP (cond, 0)));
>        gcc_assert (rtx_equal_p (op1, XEXP (cond, 1)));
>        emit_jump_insn (copy_insn (PATTERN (cinsn)));
> -      jump = get_last_insn ();
> -      gcc_assert (JUMP_P (jump));
> +      jump = assert_as_a <rtx_jump_insn *> (get_last_insn ());
>        JUMP_LABEL (jump) = JUMP_LABEL (cinsn);
>        LABEL_NUSES (JUMP_LABEL (jump))++;
>        redirect_jump (jump, label, 0);
> @@ -829,9 +829,8 @@ compare_and_jump_seq (rtx op0, rtx op1, enum rtx_code comp, rtx label, int prob,
>        op0 = force_operand (op0, NULL_RTX);
>        op1 = force_operand (op1, NULL_RTX);
>        do_compare_rtx_and_jump (op0, op1, comp, 0,
> -			       mode, NULL_RTX, NULL_RTX, label, -1);
> -      jump = get_last_insn ();
> -      gcc_assert (JUMP_P (jump));
> +			       mode, NULL_RTX, NULL, label, -1);
> +      jump = assert_as_a <rtx_jump_insn *> (get_last_insn ());
>        JUMP_LABEL (jump) = label;
>        LABEL_NUSES (label)++;
>      }
> diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
> index 57d731a..db4765f 100644
> --- a/gcc/lra-constraints.c
> +++ b/gcc/lra-constraints.c
> @@ -1060,9 +1060,8 @@ emit_spill_move (bool to_p, rtx mem_pseudo, rtx val)
>  	  LRA_SUBREG_P (mem_pseudo) = 1;
>  	}
>      }
> -  return as_a <rtx_insn *> (to_p
> -			    ? gen_move_insn (mem_pseudo, val)
> -			    : gen_move_insn (val, mem_pseudo));
> +  return to_p ? gen_move_insn (mem_pseudo, val)
> +	      : gen_move_insn (val, mem_pseudo);
>  }
>  
>  /* Process a special case insn (register move), return true if we
> @@ -4501,6 +4500,107 @@ static int calls_num;
>     USAGE_INSNS.	 */
>  static int curr_usage_insns_check;
>  
> +namespace
> +{
> +
> +class rtx_usage_list GTY(()) : public rtx_def
> +{
> +public:
> +  /* This class represents an element in a singly-linked list, which:
> +     1. Ends with non-debug INSN
> +     2. May contain several INSN_LIST nodes with DEBUG_INSNs attached to them
> +
> +     I.e.:   INSN_LIST--> INSN_LIST-->..--> INSN
> +               |            |
> +             DEBUG_INSN   DEBUG_INSN
> +
> +   See struct usage_insns for description of how it is used.  */
> +
> +  /* Get next node of the list.  */
> +  rtx_usage_list *next () const;
> +
> +  /* Get the current instruction.  */
> +  rtx_insn *insn ();
> +
> +  /* Check, if current INSN is debug info.  */
> +  bool debug_p () const;
> +
> +  /* Add debug information to the chain.  */
> +  rtx_usage_list *push_front (rtx_debug_insn *debug_insn);
> +};
> +
> +/* If current node is an INSN return it.  Otherwise it as an INSN_LIST node,
> +   in this case return the attached INSN.  */
> +
> +rtx_insn *
> +rtx_usage_list::insn ()
> +{
> +  if (rtx_insn *as_insn = dyn_cast <rtx_insn *> (this))
> +    return as_insn;
> +  return safe_as_a <rtx_debug_insn *> (XEXP (this, 0));
> +}
> +
> +/* Get next node.  */
> +
> +rtx_usage_list *
> +rtx_usage_list::next () const
> +{
> +  return reinterpret_cast <rtx_usage_list *> (XEXP (this, 1));
> +}
> +
> +/* Check, if current INSN is debug info.  */
> +
> +bool
> +rtx_usage_list::debug_p () const
> +{
> +  return is_a <const rtx_insn_list *> (this);
> +}
> +
> +/* Add debug information to the chain.  */
> +
> +rtx_usage_list *
> +rtx_usage_list::push_front (rtx_debug_insn *debug_insn)
> +{
> +  /* ??? Maybe it would be better to store DEBUG_INSNs in a separate
> +     homogeneous list (or vec) and use another pointer for actual INSN?
> +     Then we won't have to traverse the list and some checks will also
> +     become simpler.  */
> +  return reinterpret_cast <rtx_usage_list *>
> +                (gen_rtx_INSN_LIST (VOIDmode,
> +                                    debug_insn, this));
> +}
> +
> +} // anon namespace
> +
> +/* Helpers for as-a casts.  */
> +
> +template <>
> +template <>
> +inline bool
> +is_a_helper <rtx_insn_list *>::test (rtx_usage_list *list)
> +{
> +  return list->code == INSN_LIST;
> +}
> +
> +template <>
> +template <>
> +inline bool
> +is_a_helper <const rtx_insn_list *>::test (const rtx_usage_list *list)
> +{
> +  return list->code == INSN_LIST;
> +}
> +
> +/* rtx_usage_list is either an INSN_LIST node or an INSN (no other
> +   options).  Therefore, this check is valid.  */
> +
> +template <>
> +template <>
> +inline bool
> +is_a_helper <rtx_insn *>::test (rtx_usage_list *list)
> +{
> +  return list->code != INSN_LIST;
> +}
> +
>  /* Info about last usage of registers in EBB to do inheritance/split
>     transformation.  Inheritance transformation is done from a spilled
>     pseudo and split transformations from a hard register or a pseudo
> @@ -4526,17 +4626,17 @@ struct usage_insns
>       to use the original reg value again in the next insns we can try
>       to use the value in a hard register from a reload insn of the
>       current insn.  */
> -  rtx insns;
> +  rtx_usage_list *insns;
>  };
>  
>  /* Map: regno -> corresponding pseudo usage insns.  */
>  static struct usage_insns *usage_insns;
>  
>  static void
> -setup_next_usage_insn (int regno, rtx insn, int reloads_num, bool after_p)
> +setup_next_usage_insn (int regno, rtx_insn *insn, int reloads_num, bool after_p)
>  {
>    usage_insns[regno].check = curr_usage_insns_check;
> -  usage_insns[regno].insns = insn;
> +  usage_insns[regno].insns = reinterpret_cast <rtx_usage_list *> (insn);
>    usage_insns[regno].reloads_num = reloads_num;
>    usage_insns[regno].calls_num = calls_num;
>    usage_insns[regno].after_p = after_p;
> @@ -4546,20 +4646,19 @@ setup_next_usage_insn (int regno, rtx insn, int reloads_num, bool after_p)
>     optional debug insns finished by a non-debug insn using REGNO.
>     RELOADS_NUM is current number of reload insns processed so far.  */
>  static void
> -add_next_usage_insn (int regno, rtx insn, int reloads_num)
> +add_next_usage_insn (int regno, rtx_insn *insn, int reloads_num)
>  {
> -  rtx next_usage_insns;
> +  rtx_usage_list *next_usage_insns;
> +  rtx_debug_insn *debug_insn;
>  
>    if (usage_insns[regno].check == curr_usage_insns_check
> -      && (next_usage_insns = usage_insns[regno].insns) != NULL_RTX
> -      && DEBUG_INSN_P (insn))
> +      && (next_usage_insns = usage_insns[regno].insns) != NULL
> +      && (debug_insn = dyn_cast <rtx_debug_insn *> (insn)) != NULL)
>      {
>        /* Check that we did not add the debug insn yet.	*/
> -      if (next_usage_insns != insn
> -	  && (GET_CODE (next_usage_insns) != INSN_LIST
> -	      || XEXP (next_usage_insns, 0) != insn))
> -	usage_insns[regno].insns = gen_rtx_INSN_LIST (VOIDmode, insn,
> -						      next_usage_insns);
> +      if (next_usage_insns->insn () != debug_insn)
> +	usage_insns[regno].insns =
> +                usage_insns[regno].insns->push_front (debug_insn);
>      }
>    else if (NONDEBUG_INSN_P (insn))
>      setup_next_usage_insn (regno, insn, reloads_num, false);
> @@ -4569,16 +4668,13 @@ add_next_usage_insn (int regno, rtx insn, int reloads_num)
>  
>  /* Return first non-debug insn in list USAGE_INSNS.  */
>  static rtx_insn *
> -skip_usage_debug_insns (rtx usage_insns)
> +skip_usage_debug_insns (rtx_usage_list *usage_insns)
>  {
> -  rtx insn;
> -
>    /* Skip debug insns.  */
> -  for (insn = usage_insns;
> -       insn != NULL_RTX && GET_CODE (insn) == INSN_LIST;
> -       insn = XEXP (insn, 1))
> +  for (; usage_insns != NULL && usage_insns->debug_p ();
> +       usage_insns = usage_insns->next ())
>      ;
> -  return safe_as_a <rtx_insn *> (insn);
> +  return safe_as_a <rtx_insn *> (usage_insns);
>  }
>  
>  /* Return true if we need secondary memory moves for insn in
> @@ -4586,7 +4682,7 @@ skip_usage_debug_insns (rtx usage_insns)
>     into the insn.  */
>  static bool
>  check_secondary_memory_needed_p (enum reg_class inher_cl ATTRIBUTE_UNUSED,
> -				 rtx usage_insns ATTRIBUTE_UNUSED)
> +				 rtx_usage_list *usage_insns ATTRIBUTE_UNUSED)
>  {
>  #ifndef SECONDARY_MEMORY_NEEDED
>    return false;
> @@ -4639,15 +4735,16 @@ static bitmap_head check_only_regs;
>     class of ORIGINAL REGNO.  */
>  static bool
>  inherit_reload_reg (bool def_p, int original_regno,
> -		    enum reg_class cl, rtx_insn *insn, rtx next_usage_insns)
> +		    enum reg_class cl, rtx_insn *insn,
> +                    rtx_usage_list *next_usage_insns)
>  {
>    if (optimize_function_for_size_p (cfun))
>      return false;
>  
>    enum reg_class rclass = lra_get_allocno_class (original_regno);
>    rtx original_reg = regno_reg_rtx[original_regno];
> -  rtx new_reg, usage_insn;
> -  rtx_insn *new_insns;
> +  rtx new_reg;
> +  rtx_insn *usage_insn, *new_insns;
>  
>    lra_assert (! usage_insns[original_regno].after_p);
>    if (lra_dump_file != NULL)
> @@ -4746,22 +4843,21 @@ inherit_reload_reg (bool def_p, int original_regno,
>    else
>      lra_process_new_insns (insn, new_insns, NULL,
>  			   "Add inheritance<-original");
> -  while (next_usage_insns != NULL_RTX)
> +  while (next_usage_insns != NULL)
>      {
> -      if (GET_CODE (next_usage_insns) != INSN_LIST)
> +      if (! next_usage_insns->debug_p ())
>  	{
> -	  usage_insn = next_usage_insns;
> -	  lra_assert (NONDEBUG_INSN_P (usage_insn));
> +	  usage_insn = assert_as_a <rtx_insn *> (next_usage_insns);
> +	  lra_assert (! is_a <rtx_debug_insn *> (usage_insn));
>  	  next_usage_insns = NULL;
>  	}
>        else
>  	{
> -	  usage_insn = XEXP (next_usage_insns, 0);
> -	  lra_assert (DEBUG_INSN_P (usage_insn));
> -	  next_usage_insns = XEXP (next_usage_insns, 1);
> +	  usage_insn = next_usage_insns->insn ();
> +	  next_usage_insns = next_usage_insns->next ();
>  	}
> -      lra_substitute_pseudo (&usage_insn, original_regno, new_reg);
> -      lra_update_insn_regno_info (as_a <rtx_insn *> (usage_insn));
> +      lra_substitute_pseudo_within_insn (usage_insn, original_regno, new_reg);
> +      lra_update_insn_regno_info (usage_insn);
>        if (lra_dump_file != NULL)
>  	{
>  	  fprintf (lra_dump_file,
> @@ -4913,13 +5009,13 @@ choose_split_class (enum reg_class allocno_class,
>     transformation.  */
>  static bool
>  split_reg (bool before_p, int original_regno, rtx_insn *insn,
> -	   rtx next_usage_insns)
> +	   rtx_usage_list *next_usage_insns)
>  {
>    enum reg_class rclass;
>    rtx original_reg;
>    int hard_regno, nregs;
> -  rtx new_reg, usage_insn;
> -  rtx_insn *restore, *save;
> +  rtx new_reg;
> +  rtx_insn *restore, *save, *usage_insn;
>    bool after_p;
>    bool call_save_p;
>  
> @@ -5016,14 +5112,13 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn,
>      {
>        if (GET_CODE (next_usage_insns) != INSN_LIST)
>  	{
> -	  usage_insn = next_usage_insns;
> +	  usage_insn = as_a <rtx_insn *> (next_usage_insns);
>  	  break;
>  	}
> -      usage_insn = XEXP (next_usage_insns, 0);
> -      lra_assert (DEBUG_INSN_P (usage_insn));
> -      next_usage_insns = XEXP (next_usage_insns, 1);
> -      lra_substitute_pseudo (&usage_insn, original_regno, new_reg);
> -      lra_update_insn_regno_info (as_a <rtx_insn *> (usage_insn));
> +      usage_insn = next_usage_insns->insn ();
> +      next_usage_insns = next_usage_insns->next ();
> +      lra_substitute_pseudo_within_insn (usage_insn, original_regno, new_reg);
> +      lra_update_insn_regno_info (usage_insn);
>        if (lra_dump_file != NULL)
>  	{
>  	  fprintf (lra_dump_file, "    Split reuse change %d->%d:\n",
> @@ -5031,9 +5126,9 @@ split_reg (bool before_p, int original_regno, rtx_insn *insn,
>  	  dump_insn_slim (lra_dump_file, usage_insn);
>  	}
>      }
> -  lra_assert (NOTE_P (usage_insn) || NONDEBUG_INSN_P (usage_insn));
> +  lra_assert (! DEBUG_INSN_P (usage_insn));
>    lra_assert (usage_insn != insn || (after_p && before_p));
> -  lra_process_new_insns (as_a <rtx_insn *> (usage_insn),
> +  lra_process_new_insns (usage_insn,
>  			 after_p ? NULL : restore,
>  			 after_p ? restore : NULL,
>  			 call_save_p
> @@ -5069,18 +5164,15 @@ split_if_necessary (int regno, machine_mode mode,
>  {
>    bool res = false;
>    int i, nregs = 1;
> -  rtx next_usage_insns;
> +  rtx_usage_list *next_usage_insns;
>  
>    if (regno < FIRST_PSEUDO_REGISTER)
>      nregs = hard_regno_nregs[regno][mode];
>    for (i = 0; i < nregs; i++)
>      if (usage_insns[regno + i].check == curr_usage_insns_check
> -	&& (next_usage_insns = usage_insns[regno + i].insns) != NULL_RTX
> +	&& (next_usage_insns = usage_insns[regno + i].insns) != NULL
>  	/* To avoid processing the register twice or more.  */
> -	&& ((GET_CODE (next_usage_insns) != INSN_LIST
> -	     && INSN_UID (next_usage_insns) < max_uid)
> -	    || (GET_CODE (next_usage_insns) == INSN_LIST
> -		&& (INSN_UID (XEXP (next_usage_insns, 0)) < max_uid)))
> +	&& (INSN_UID (next_usage_insns->insn ()) < max_uid)
>  	&& need_for_split_p (potential_reload_hard_regs, regno + i)
>  	&& split_reg (before_p, regno + i, insn, next_usage_insns))
>      res = true;
> @@ -5209,7 +5301,7 @@ struct to_inherit
>    /* Original regno.  */
>    int regno;
>    /* Subsequent insns which can inherit original reg value.  */
> -  rtx insns;
> +  rtx_usage_list *insns;
>  };
>  
>  /* Array containing all info for doing inheritance from the current
> @@ -5222,7 +5314,7 @@ static int to_inherit_num;
>  /* Add inheritance info REGNO and INSNS. Their meaning is described in
>     structure to_inherit.  */
>  static void
> -add_to_inherit (int regno, rtx insns)
> +add_to_inherit (int regno, rtx_usage_list *insns)
>  {
>    int i;
>  
> @@ -5301,7 +5393,8 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail)
>    int i, src_regno, dst_regno, nregs;
>    bool change_p, succ_p, update_reloads_num_p;
>    rtx_insn *prev_insn, *last_insn;
> -  rtx next_usage_insns, set;
> +  rtx_usage_list *next_usage_insns;
> +  rtx set;
>    enum reg_class cl;
>    struct lra_insn_reg *reg;
>    basic_block last_processed_bb, curr_bb = NULL;
> @@ -5569,7 +5662,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail)
>  			   || reg_renumber[src_regno] >= 0)
>  		    {
>  		      bool before_p;
> -		      rtx use_insn = curr_insn;
> +		      rtx_insn *use_insn = curr_insn;
>  
>  		      before_p = (JUMP_P (curr_insn)
>  				  || (CALL_P (curr_insn) && reg->type == OP_IN));
> diff --git a/gcc/lra.c b/gcc/lra.c
> index 269a0f1..6d3c73e 100644
> --- a/gcc/lra.c
> +++ b/gcc/lra.c
> @@ -1825,7 +1825,7 @@ lra_substitute_pseudo (rtx *loc, int old_regno, rtx new_reg)
>    const char *fmt;
>    int i, j;
>  
> -  if (x == NULL_RTX)
> +  if (x == NULL)
>      return false;
>  
>    code = GET_CODE (x);
> diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c
> index 22cd216..4afe43e 100644
> --- a/gcc/modulo-sched.c
> +++ b/gcc/modulo-sched.c
> @@ -790,8 +790,7 @@ schedule_reg_moves (partial_schedule_ptr ps)
>  	  move->old_reg = old_reg;
>  	  move->new_reg = gen_reg_rtx (GET_MODE (prev_reg));
>  	  move->num_consecutive_stages = distances[0] && distances[1] ? 2 : 1;
> -	  move->insn = as_a <rtx_insn *> (gen_move_insn (move->new_reg,
> -							 copy_rtx (prev_reg)));
> +	  move->insn = gen_move_insn (move->new_reg, copy_rtx (prev_reg));
>  	  bitmap_clear (move->uses);
>  
>  	  prev_reg = move->new_reg;
> diff --git a/gcc/optabs.c b/gcc/optabs.c
> index e9dc798..9a51ba3 100644
> --- a/gcc/optabs.c
> +++ b/gcc/optabs.c
> @@ -1416,7 +1416,7 @@ expand_binop_directly (machine_mode mode, optab binoptab,
>    machine_mode mode0, mode1, tmp_mode;
>    struct expand_operand ops[3];
>    bool commutative_p;
> -  rtx pat;
> +  rtx_insn *pat;
>    rtx xop0 = op0, xop1 = op1;
>    rtx swap;
>  
> @@ -1499,8 +1499,8 @@ expand_binop_directly (machine_mode mode, optab binoptab,
>        /* If PAT is composed of more than one insn, try to add an appropriate
>  	 REG_EQUAL note to it.  If we can't because TEMP conflicts with an
>  	 operand, call expand_binop again, this time without a target.  */
> -      if (INSN_P (pat) && NEXT_INSN (as_a <rtx_insn *> (pat)) != NULL_RTX
> -	  && ! add_equal_note (as_a <rtx_insn *> (pat), ops[0].value,
> +      if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
> +	  && ! add_equal_note (pat, ops[0].value,
>  			       optab_to_code (binoptab),
>  			       ops[1].value, ops[2].value))
>  	{
> @@ -3016,15 +3016,15 @@ expand_unop_direct (machine_mode mode, optab unoptab, rtx op0, rtx target,
>        struct expand_operand ops[2];
>        enum insn_code icode = optab_handler (unoptab, mode);
>        rtx_insn *last = get_last_insn ();
> -      rtx pat;
> +      rtx_insn *pat;
>  
>        create_output_operand (&ops[0], target, mode);
>        create_convert_operand_from (&ops[1], op0, mode, unsignedp);
>        pat = maybe_gen_insn (icode, 2, ops);
>        if (pat)
>  	{
> -	  if (INSN_P (pat) && NEXT_INSN (as_a <rtx_insn *> (pat)) != NULL_RTX
> -	      && ! add_equal_note (as_a <rtx_insn *> (pat), ops[0].value,
> +	  if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
> +	      && ! add_equal_note (pat, ops[0].value,
>  				   optab_to_code (unoptab),
>  				   ops[1].value, NULL_RTX))
>  	    {
> @@ -3508,7 +3508,7 @@ expand_abs (machine_mode mode, rtx op0, rtx target,
>    NO_DEFER_POP;
>  
>    do_compare_rtx_and_jump (target, CONST0_RTX (mode), GE, 0, mode,
> -			   NULL_RTX, NULL_RTX, op1, -1);
> +			   NULL_RTX, NULL, op1, -1);
>  
>    op0 = expand_unop (mode, result_unsignedp ? neg_optab : negv_optab,
>                       target, target, 0);
> @@ -3817,7 +3817,7 @@ maybe_emit_unop_insn (enum insn_code icode, rtx target, rtx op0,
>  		      enum rtx_code code)
>  {
>    struct expand_operand ops[2];
> -  rtx pat;
> +  rtx_insn *pat;
>  
>    create_output_operand (&ops[0], target, GET_MODE (target));
>    create_input_operand (&ops[1], op0, GET_MODE (op0));
> @@ -3825,10 +3825,9 @@ maybe_emit_unop_insn (enum insn_code icode, rtx target, rtx op0,
>    if (!pat)
>      return false;
>  
> -  if (INSN_P (pat) && NEXT_INSN (as_a <rtx_insn *> (pat)) != NULL_RTX
> +  if (INSN_P (pat) && NEXT_INSN (pat) != NULL_RTX
>        && code != UNKNOWN)
> -    add_equal_note (as_a <rtx_insn *> (pat), ops[0].value, code, ops[1].value,
> -		    NULL_RTX);
> +    add_equal_note (pat, ops[0].value, code, ops[1].value, NULL_RTX);
>  
>    emit_insn (pat);
>  
> @@ -8370,13 +8369,13 @@ maybe_legitimize_operands (enum insn_code icode, unsigned int opno,
>     and emit any necessary set-up code.  Return null and emit no
>     code on failure.  */
>  
> -rtx
> +rtx_insn *
>  maybe_gen_insn (enum insn_code icode, unsigned int nops,
>  		struct expand_operand *ops)
>  {
>    gcc_assert (nops == (unsigned int) insn_data[(int) icode].n_generator_args);
>    if (!maybe_legitimize_operands (icode, 0, nops, ops))
> -    return NULL_RTX;
> +    return NULL;
>  
>    switch (nops)
>      {
> diff --git a/gcc/optabs.h b/gcc/optabs.h
> index 152af87..5c30ce5 100644
> --- a/gcc/optabs.h
> +++ b/gcc/optabs.h
> @@ -541,8 +541,8 @@ extern void create_convert_operand_from_type (struct expand_operand *op,
>  extern bool maybe_legitimize_operands (enum insn_code icode,
>  				       unsigned int opno, unsigned int nops,
>  				       struct expand_operand *ops);
> -extern rtx maybe_gen_insn (enum insn_code icode, unsigned int nops,
> -			   struct expand_operand *ops);
> +extern rtx_insn *maybe_gen_insn (enum insn_code icode, unsigned int nops,
> +				 struct expand_operand *ops);
>  extern bool maybe_expand_insn (enum insn_code icode, unsigned int nops,
>  			       struct expand_operand *ops);
>  extern bool maybe_expand_jump_insn (enum insn_code icode, unsigned int nops,
> diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c
> index 83048bd..21228ac 100644
> --- a/gcc/postreload-gcse.c
> +++ b/gcc/postreload-gcse.c
> @@ -1115,8 +1115,8 @@ eliminate_partially_redundant_load (basic_block bb, rtx_insn *insn,
>  
>  	  /* Make sure we can generate a move from register avail_reg to
>  	     dest.  */
> -	  rtx_insn *move = as_a <rtx_insn *>
> -	    (gen_move_insn (copy_rtx (dest), copy_rtx (avail_reg)));
> +	  rtx_insn *move = gen_move_insn (copy_rtx (dest),
> +					  copy_rtx (avail_reg));
>  	  extract_insn (move);
>  	  if (! constrain_operands (1, get_preferred_alternatives (insn,
>  								   pred_bb))
> diff --git a/gcc/recog.c b/gcc/recog.c
> index a9d3b1f..8fee5a7 100644
> --- a/gcc/recog.c
> +++ b/gcc/recog.c
> @@ -3068,7 +3068,7 @@ split_all_insns_noflow (void)
>  #ifdef HAVE_peephole2
>  struct peep2_insn_data
>  {
> -  rtx insn;
> +  rtx_insn *insn;
>    regset live_before;
>  };
>  
> @@ -3084,7 +3084,7 @@ int peep2_current_count;
>  /* A non-insn marker indicating the last insn of the block.
>     The live_before regset for this element is correct, indicating
>     DF_LIVE_OUT for the block.  */
> -#define PEEP2_EOB	pc_rtx
> +#define PEEP2_EOB	(static_cast<rtx_insn *> (pc_rtx))
>  
>  /* Wrap N to fit into the peep2_insn_data buffer.  */
>  
> @@ -3287,7 +3287,7 @@ peep2_reinit_state (regset live)
>  
>    /* Indicate that all slots except the last holds invalid data.  */
>    for (i = 0; i < MAX_INSNS_PER_PEEP2; ++i)
> -    peep2_insn_data[i].insn = NULL_RTX;
> +    peep2_insn_data[i].insn = NULL;
>    peep2_current_count = 0;
>  
>    /* Indicate that the last slot contains live_after data.  */
> @@ -3315,7 +3315,7 @@ peep2_attempt (basic_block bb, rtx uncast_insn, int match_len, rtx_insn *attempt
>  
>    /* If we are splitting an RTX_FRAME_RELATED_P insn, do not allow it to
>       match more than one insn, or to be split into more than one insn.  */
> -  old_insn = as_a <rtx_insn *> (peep2_insn_data[peep2_current].insn);
> +  old_insn = peep2_insn_data[peep2_current].insn;
>    if (RTX_FRAME_RELATED_P (old_insn))
>      {
>        bool any_note = false;
> @@ -3403,7 +3403,7 @@ peep2_attempt (basic_block bb, rtx uncast_insn, int match_len, rtx_insn *attempt
>        rtx note;
>  
>        j = peep2_buf_position (peep2_current + i);
> -      old_insn = as_a <rtx_insn *> (peep2_insn_data[j].insn);
> +      old_insn = peep2_insn_data[j].insn;
>        if (!CALL_P (old_insn))
>  	continue;
>        was_call = true;
> @@ -3442,7 +3442,7 @@ peep2_attempt (basic_block bb, rtx uncast_insn, int match_len, rtx_insn *attempt
>        while (++i <= match_len)
>  	{
>  	  j = peep2_buf_position (peep2_current + i);
> -	  old_insn = as_a <rtx_insn *> (peep2_insn_data[j].insn);
> +	  old_insn = peep2_insn_data[j].insn;
>  	  gcc_assert (!CALL_P (old_insn));
>  	}
>        break;
> @@ -3454,7 +3454,7 @@ peep2_attempt (basic_block bb, rtx uncast_insn, int match_len, rtx_insn *attempt
>    for (i = match_len; i >= 0; --i)
>      {
>        int j = peep2_buf_position (peep2_current + i);
> -      old_insn = as_a <rtx_insn *> (peep2_insn_data[j].insn);
> +      old_insn = peep2_insn_data[j].insn;
>  
>        as_note = find_reg_note (old_insn, REG_ARGS_SIZE, NULL);
>        if (as_note)
> @@ -3465,7 +3465,7 @@ peep2_attempt (basic_block bb, rtx uncast_insn, int match_len, rtx_insn *attempt
>    eh_note = find_reg_note (peep2_insn_data[i].insn, REG_EH_REGION, NULL_RTX);
>  
>    /* Replace the old sequence with the new.  */
> -  rtx_insn *peepinsn = as_a <rtx_insn *> (peep2_insn_data[i].insn);
> +  rtx_insn *peepinsn = peep2_insn_data[i].insn;
>    last = emit_insn_after_setloc (attempt,
>  				 peep2_insn_data[i].insn,
>  				 INSN_LOCATION (peepinsn));
> @@ -3582,7 +3582,7 @@ peep2_update_life (basic_block bb, int match_len, rtx_insn *last,
>     add more instructions to the buffer.  */
>  
>  static bool
> -peep2_fill_buffer (basic_block bb, rtx insn, regset live)
> +peep2_fill_buffer (basic_block bb, rtx_insn *insn, regset live)
>  {
>    int pos;
>  
> @@ -3608,7 +3608,7 @@ peep2_fill_buffer (basic_block bb, rtx insn, regset live)
>    COPY_REG_SET (peep2_insn_data[pos].live_before, live);
>    peep2_current_count++;
>  
> -  df_simulate_one_insn_forwards (bb, as_a <rtx_insn *> (insn), live);
> +  df_simulate_one_insn_forwards (bb, insn, live);
>    return true;
>  }
>  
> diff --git a/gcc/recog.h b/gcc/recog.h
> index 45ea671..7c95885 100644
> --- a/gcc/recog.h
> +++ b/gcc/recog.h
> @@ -278,43 +278,43 @@ typedef const char * (*insn_output_fn) (rtx *, rtx_insn *);
>  
>  struct insn_gen_fn
>  {
> -  typedef rtx (*f0) (void);
> -  typedef rtx (*f1) (rtx);
> -  typedef rtx (*f2) (rtx, rtx);
> -  typedef rtx (*f3) (rtx, rtx, rtx);
> -  typedef rtx (*f4) (rtx, rtx, rtx, rtx);
> -  typedef rtx (*f5) (rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f6) (rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f7) (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f8) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f9) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f10) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f11) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f12) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f13) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f14) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f15) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> -  typedef rtx (*f16) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f0) (void);
> +  typedef rtx_insn * (*f1) (rtx);
> +  typedef rtx_insn * (*f2) (rtx, rtx);
> +  typedef rtx_insn * (*f3) (rtx, rtx, rtx);
> +  typedef rtx_insn * (*f4) (rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f5) (rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f6) (rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f7) (rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f8) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f9) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f10) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f11) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f12) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f13) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f14) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f15) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
> +  typedef rtx_insn * (*f16) (rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx, rtx);
>  
>    typedef f0 stored_funcptr;
>  
> -  rtx operator () (void) const { return ((f0)func) (); }
> -  rtx operator () (rtx a0) const { return ((f1)func) (a0); }
> -  rtx operator () (rtx a0, rtx a1) const { return ((f2)func) (a0, a1); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2) const { return ((f3)func) (a0, a1, a2); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3) const { return ((f4)func) (a0, a1, a2, a3); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4) const { return ((f5)func) (a0, a1, a2, a3, a4); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5) const { return ((f6)func) (a0, a1, a2, a3, a4, a5); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6) const { return ((f7)func) (a0, a1, a2, a3, a4, a5, a6); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7) const { return ((f8)func) (a0, a1, a2, a3, a4, a5, a6, a7); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8) const { return ((f9)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9) const { return ((f10)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10) const { return ((f11)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11) const { return ((f12)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12) const { return ((f13)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13) const { return ((f14)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13, rtx a14) const { return ((f15)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
> -  rtx operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13, rtx a14, rtx a15) const { return ((f16)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
> +  rtx_insn * operator () (void) const { return ((f0)func) (); }
> +  rtx_insn * operator () (rtx a0) const { return ((f1)func) (a0); }
> +  rtx_insn * operator () (rtx a0, rtx a1) const { return ((f2)func) (a0, a1); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2) const { return ((f3)func) (a0, a1, a2); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3) const { return ((f4)func) (a0, a1, a2, a3); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4) const { return ((f5)func) (a0, a1, a2, a3, a4); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5) const { return ((f6)func) (a0, a1, a2, a3, a4, a5); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6) const { return ((f7)func) (a0, a1, a2, a3, a4, a5, a6); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7) const { return ((f8)func) (a0, a1, a2, a3, a4, a5, a6, a7); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8) const { return ((f9)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9) const { return ((f10)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10) const { return ((f11)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11) const { return ((f12)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12) const { return ((f13)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13) const { return ((f14)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13, rtx a14) const { return ((f15)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14); }
> +  rtx_insn * operator () (rtx a0, rtx a1, rtx a2, rtx a3, rtx a4, rtx a5, rtx a6, rtx a7, rtx a8, rtx a9, rtx a10, rtx a11, rtx a12, rtx a13, rtx a14, rtx a15) const { return ((f16)func) (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); }
>  
>    // This is for compatibility of code that invokes functions like
>    //   (*funcptr) (arg)
> diff --git a/gcc/rtl.h b/gcc/rtl.h
> index e5e4560..e88f3c8 100644
> --- a/gcc/rtl.h
> +++ b/gcc/rtl.h
> @@ -636,6 +636,8 @@ class GTY(()) rtx_note : public rtx_insn
>  
>  #define NULL_RTX (rtx) 0
>  
> +#define NULL_INSN (rtx_insn *) 0
> +
>  /* The "next" and "previous" RTX, relative to this one.  */
>  
>  #define RTX_NEXT(X) (rtx_next[GET_CODE (X)] == 0 ? NULL			\
> @@ -827,6 +829,14 @@ is_a_helper <rtx_debug_insn *>::test (rtx rt)
>  template <>
>  template <>
>  inline bool
> +is_a_helper <rtx_debug_insn *>::test (rtx_insn *insn)
> +{
> +  return DEBUG_INSN_P (insn);
> +}
> +
> +template <>
> +template <>
> +inline bool
>  is_a_helper <rtx_nonjump_insn *>::test (rtx rt)
>  {
>    return NONJUMP_INSN_P (rt);
> @@ -843,6 +853,14 @@ is_a_helper <rtx_jump_insn *>::test (rtx rt)
>  template <>
>  template <>
>  inline bool
> +is_a_helper <rtx_jump_insn *>::test (rtx_insn *insn)
> +{
> +  return JUMP_P (insn);
> +}
> +
> +template <>
> +template <>
> +inline bool
>  is_a_helper <rtx_call_insn *>::test (rtx rt)
>  {
>    return CALL_P (rt);
> @@ -2662,7 +2680,7 @@ extern rtx_insn *emit_debug_insn_before (rtx, rtx);
>  extern rtx_insn *emit_debug_insn_before_noloc (rtx, rtx);
>  extern rtx_insn *emit_debug_insn_before_setloc (rtx, rtx, int);
>  extern rtx_barrier *emit_barrier_before (rtx);
> -extern rtx_insn *emit_label_before (rtx, rtx_insn *);
> +extern rtx_code_label *emit_label_before (rtx , rtx_insn *);
>  extern rtx_note *emit_note_before (enum insn_note, rtx);
>  extern rtx_insn *emit_insn_after (rtx, rtx);
>  extern rtx_insn *emit_insn_after_noloc (rtx, rtx, basic_block);
> @@ -2683,7 +2701,7 @@ extern rtx_insn *emit_insn (rtx);
>  extern rtx_insn *emit_debug_insn (rtx);
>  extern rtx_insn *emit_jump_insn (rtx);
>  extern rtx_insn *emit_call_insn (rtx);
> -extern rtx_insn *emit_label (rtx);
> +extern rtx_code_label *emit_label (rtx);
>  extern rtx_jump_table_data *emit_jump_table_data (rtx);
>  extern rtx_barrier *emit_barrier (void);
>  extern rtx_note *emit_note (enum insn_note);
> @@ -3336,14 +3354,14 @@ extern int eh_returnjump_p (rtx_insn *);
>  extern int onlyjump_p (const rtx_insn *);
>  extern int only_sets_cc0_p (const_rtx);
>  extern int sets_cc0_p (const_rtx);
> -extern int invert_jump_1 (rtx_insn *, rtx);
> -extern int invert_jump (rtx_insn *, rtx, int);
> +extern int invert_jump_1 (rtx_jump_insn *, rtx);
> +extern int invert_jump (rtx_jump_insn *, rtx, int);
>  extern int rtx_renumbered_equal_p (const_rtx, const_rtx);
>  extern int true_regnum (const_rtx);
>  extern unsigned int reg_or_subregno (const_rtx);
>  extern int redirect_jump_1 (rtx, rtx);
> -extern void redirect_jump_2 (rtx, rtx, rtx, int, int);
> -extern int redirect_jump (rtx, rtx, int);
> +extern void redirect_jump_2 (rtx_jump_insn *, rtx, rtx, int, int);
> +extern int redirect_jump (rtx_jump_insn *, rtx, int);
>  extern void rebuild_jump_labels (rtx_insn *);
>  extern void rebuild_jump_labels_chain (rtx_insn *);
>  extern rtx reversed_comparison (const_rtx, machine_mode);
> @@ -3426,7 +3444,7 @@ extern void print_inline_rtx (FILE *, const_rtx, int);
>     not be in sched-vis.c but in rtl.c, because they are not only used
>     by the scheduler anymore but for all "slim" RTL dumping.  */
>  extern void dump_value_slim (FILE *, const_rtx, int);
> -extern void dump_insn_slim (FILE *, const_rtx);
> +extern void dump_insn_slim (FILE *, const rtx_insn *);
>  extern void dump_rtl_slim (FILE *, const rtx_insn *, const rtx_insn *,
>  			   int, int);
>  extern void print_value (pretty_printer *, const_rtx, int);
> @@ -3438,7 +3456,7 @@ extern const char *str_pattern_slim (const_rtx);
>  /* In stmt.c */
>  extern void expand_null_return (void);
>  extern void expand_naked_return (void);
> -extern void emit_jump (rtx);
> +extern void emit_jump (rtx_code_label *);
>  
>  /* In expr.c */
>  extern rtx move_by_pieces (rtx, rtx, unsigned HOST_WIDE_INT,
> diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
> index 743aad6..7d10abe 100644
> --- a/gcc/rtlanal.c
> +++ b/gcc/rtlanal.c
> @@ -2914,14 +2914,14 @@ rtx_referenced_p (const_rtx x, const_rtx body)
>  bool
>  tablejump_p (const rtx_insn *insn, rtx *labelp, rtx_jump_table_data **tablep)
>  {
> -  rtx label, table;
> +  rtx table;
>  
>    if (!JUMP_P (insn))
>      return false;
>  
> -  label = JUMP_LABEL (insn);
> -  if (label != NULL_RTX && !ANY_RETURN_P (label)
> -      && (table = NEXT_INSN (as_a <rtx_insn *> (label))) != NULL_RTX
> +  rtx_insn *label = JUMP_LABEL_AS_INSN (insn);
> +  if (label && !ANY_RETURN_P (label)
> +      && (table = NEXT_INSN (label)) != NULL_RTX
>        && JUMP_TABLE_DATA_P (table))
>      {
>        if (labelp)
> diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
> index 5434831..e6f1003 100644
> --- a/gcc/sched-deps.c
> +++ b/gcc/sched-deps.c
> @@ -2649,7 +2649,7 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
>      case MEM:
>        {
>  	/* Reading memory.  */
> -	rtx u;
> +	rtx_insn_list *u;
>  	rtx_insn_list *pending;
>  	rtx_expr_list *pending_mem;
>  	rtx t = x;
> @@ -2700,11 +2700,10 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
>  		pending_mem = pending_mem->next ();
>  	      }
>  
> -	    for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
> -	      add_dependence (insn, as_a <rtx_insn *> (XEXP (u, 0)),
> -			      REG_DEP_ANTI);
> +	    for (u = deps->last_pending_memory_flush; u; u = u->next ())
> +	      add_dependence (insn, u->insn (), REG_DEP_ANTI);
>  
> -	    for (u = deps->pending_jump_insns; u; u = XEXP (u, 1))
> +	    for (u = deps->pending_jump_insns; u; u = u->next ())
>  	      if (deps_may_trap_p (x))
>  		{
>  		  if ((sched_deps_info->generate_spec_deps)
> @@ -2713,11 +2712,10 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
>  		      ds_t ds = set_dep_weak (DEP_ANTI, BEGIN_CONTROL,
>  					      MAX_DEP_WEAK);
>  		      
> -		      note_dep (as_a <rtx_insn *> (XEXP (u, 0)), ds);
> +		      note_dep (u->insn (), ds);
>  		    }
>  		  else
> -		    add_dependence (insn, as_a <rtx_insn *> (XEXP (u, 0)),
> -				    REG_DEP_CONTROL);
> +		    add_dependence (insn, u->insn (), REG_DEP_CONTROL);
>  		}
>  	  }
>  
> @@ -3088,7 +3086,7 @@ sched_analyze_insn (struct deps_desc *deps, rtx x, rtx_insn *insn)
>    if (DEBUG_INSN_P (insn))
>      {
>        rtx_insn *prev = deps->last_debug_insn;
> -      rtx u;
> +      rtx_insn_list *u;
>  
>        if (!deps->readonly)
>  	deps->last_debug_insn = insn;
> @@ -3100,8 +3098,8 @@ sched_analyze_insn (struct deps_desc *deps, rtx x, rtx_insn *insn)
>  			   REG_DEP_ANTI, false);
>  
>        if (!sel_sched_p ())
> -	for (u = deps->last_pending_memory_flush; u; u = XEXP (u, 1))
> -	  add_dependence (insn, as_a <rtx_insn *> (XEXP (u, 0)), REG_DEP_ANTI);
> +	for (u = deps->last_pending_memory_flush; u; u = u->next ())
> +	  add_dependence (insn, u->insn (), REG_DEP_ANTI);
>  
>        EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
>  	{
> diff --git a/gcc/sched-vis.c b/gcc/sched-vis.c
> index 32f7a7c..31794e6 100644
> --- a/gcc/sched-vis.c
> +++ b/gcc/sched-vis.c
> @@ -67,7 +67,7 @@ along with GCC; see the file COPYING3.  If not see
>     pointer, via str_pattern_slim, but this usage is discouraged.  */
>  
>  /* For insns we print patterns, and for some patterns we print insns...  */
> -static void print_insn_with_notes (pretty_printer *, const_rtx);
> +static void print_insn_with_notes (pretty_printer *, const rtx_insn *);
>  
>  /* This recognizes rtx'en classified as expressions.  These are always
>     represent some action on values or results of other expression, that
> @@ -669,7 +669,7 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
>     with their INSN_UIDs.  */
>  
>  void
> -print_insn (pretty_printer *pp, const_rtx x, int verbose)
> +print_insn (pretty_printer *pp, const rtx_insn *x, int verbose)
>  {
>    if (verbose)
>      {
> @@ -787,7 +787,7 @@ print_insn (pretty_printer *pp, const_rtx x, int verbose)
>     note attached to the instruction.  */
>  
>  static void
> -print_insn_with_notes (pretty_printer *pp, const_rtx x)
> +print_insn_with_notes (pretty_printer *pp, const rtx_insn *x)
>  {
>    pp_string (pp, print_rtx_head);
>    print_insn (pp, x, 1);
> @@ -823,7 +823,7 @@ dump_value_slim (FILE *f, const_rtx x, int verbose)
>  /* Emit a slim dump of X (an insn) to the file F, including any register
>     note attached to the instruction.  */
>  void
> -dump_insn_slim (FILE *f, const_rtx x)
> +dump_insn_slim (FILE *f, const rtx_insn *x)
>  {
>    pretty_printer rtl_slim_pp;
>    rtl_slim_pp.buffer->stream = f;
> @@ -893,9 +893,9 @@ str_pattern_slim (const_rtx x)
>  }
>  
>  /* Emit a slim dump of X (an insn) to stderr.  */
> -extern void debug_insn_slim (const_rtx);
> +extern void debug_insn_slim (const rtx_insn *);
>  DEBUG_FUNCTION void
> -debug_insn_slim (const_rtx x)
> +debug_insn_slim (const rtx_insn *x)
>  {
>    dump_insn_slim (stderr, x);
>  }
> diff --git a/gcc/stmt.c b/gcc/stmt.c
> index 45dc45f..a6418ff 100644
> --- a/gcc/stmt.c
> +++ b/gcc/stmt.c
> @@ -135,12 +135,13 @@ static void balance_case_nodes (case_node_ptr *, case_node_ptr);
>  static int node_has_low_bound (case_node_ptr, tree);
>  static int node_has_high_bound (case_node_ptr, tree);
>  static int node_is_bounded (case_node_ptr, tree);
> -static void emit_case_nodes (rtx, case_node_ptr, rtx, int, tree);
> +static void emit_case_nodes (rtx, case_node_ptr, rtx_code_label *, int, tree);
>  
>  /* Return the rtx-label that corresponds to a LABEL_DECL,
> -   creating it if necessary.  */
> +   creating it if necessary.  If label was deleted, the corresponding
> +   note (NOTE_INSN_DELETED{_DEBUG,}_LABEL) insn will be returned.  */
>  
> -rtx
> +rtx_insn *
>  label_rtx (tree label)
>  {
>    gcc_assert (TREE_CODE (label) == LABEL_DECL);
> @@ -153,15 +154,15 @@ label_rtx (tree label)
>  	LABEL_PRESERVE_P (r) = 1;
>      }
>  
> -  return DECL_RTL (label);
> +  return as_a <rtx_insn *> (DECL_RTL (label));
>  }
>  
>  /* As above, but also put it on the forced-reference list of the
>     function that contains it.  */
> -rtx
> +rtx_insn *
>  force_label_rtx (tree label)
>  {
> -  rtx_insn *ref = as_a <rtx_insn *> (label_rtx (label));
> +  rtx_insn *ref = label_rtx (label);
>    tree function = decl_function_context (label);
>  
>    gcc_assert (function);
> @@ -170,10 +171,18 @@ force_label_rtx (tree label)
>    return ref;
>  }
>  
> +/* As label_rtx, but ensures (in check build), that returned value is
> +   an existing label (i.e. rtx with code CODE_LABEL).  */
> +rtx_code_label *
> +live_label_rtx (tree label)
> +{
> +  return as_a <rtx_code_label *> (label_rtx (label));
> +}
> +
>  /* Add an unconditional jump to LABEL as the next sequential instruction.  */
>  
>  void
> -emit_jump (rtx label)
> +emit_jump (rtx_code_label *label)
>  {
>    do_pending_stack_adjust ();
>    emit_jump_insn (gen_jump (label));
> @@ -196,7 +205,7 @@ emit_jump (rtx label)
>  void
>  expand_label (tree label)
>  {
> -  rtx_insn *label_r = as_a <rtx_insn *> (label_rtx (label));
> +  rtx_code_label *label_r = live_label_rtx (label);
>  
>    do_pending_stack_adjust ();
>    emit_label (label_r);
> @@ -717,7 +726,7 @@ resolve_operand_name_1 (char *p, tree outputs, tree inputs, tree labels)
>  void
>  expand_naked_return (void)
>  {
> -  rtx end_label;
> +  rtx_code_label *end_label;
>  
>    clear_pending_stack_adjust ();
>    do_pending_stack_adjust ();
> @@ -732,12 +741,12 @@ expand_naked_return (void)
>  /* Generate code to jump to LABEL if OP0 and OP1 are equal in mode MODE. PROB
>     is the probability of jumping to LABEL.  */
>  static void
> -do_jump_if_equal (machine_mode mode, rtx op0, rtx op1, rtx label,
> +do_jump_if_equal (machine_mode mode, rtx op0, rtx op1, rtx_code_label *label,
>  		  int unsignedp, int prob)
>  {
>    gcc_assert (prob <= REG_BR_PROB_BASE);
>    do_compare_rtx_and_jump (op0, op1, EQ, unsignedp, mode,
> -			   NULL_RTX, NULL_RTX, label, prob);
> +			   NULL_RTX, NULL, label, prob);
>  }
>  
>  /* Do the insertion of a case label into case_list.  The labels are
> @@ -894,8 +903,8 @@ expand_switch_as_decision_tree_p (tree range,
>  
>  static void
>  emit_case_decision_tree (tree index_expr, tree index_type,
> -			 struct case_node *case_list, rtx default_label,
> -                         int default_prob)
> +			 case_node_ptr case_list, rtx_code_label *default_label,
> +			 int default_prob)
>  {
>    rtx index = expand_normal (index_expr);
>  
> @@ -1153,7 +1162,7 @@ void
>  expand_case (gswitch *stmt)
>  {
>    tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE;
> -  rtx default_label = NULL_RTX;
> +  rtx_code_label *default_label = NULL;
>    unsigned int count, uniq;
>    int i;
>    int ncases = gimple_switch_num_labels (stmt);
> @@ -1185,7 +1194,7 @@ expand_case (gswitch *stmt)
>    do_pending_stack_adjust ();
>  
>    /* Find the default case target label.  */
> -  default_label = label_rtx (CASE_LABEL (gimple_switch_default_label (stmt)));
> +  default_label = live_label_rtx (CASE_LABEL (gimple_switch_default_label (stmt)));
>    edge default_edge = EDGE_SUCC (bb, 0);
>    int default_prob = default_edge->probability;
>  
> @@ -1335,7 +1344,7 @@ expand_sjlj_dispatch_table (rtx dispatch_index,
>        for (int i = 0; i < ncases; i++)
>          {
>  	  tree elt = dispatch_table[i];
> -	  rtx lab = label_rtx (CASE_LABEL (elt));
> +	  rtx_code_label *lab = live_label_rtx (CASE_LABEL (elt));
>  	  do_jump_if_equal (index_mode, index, zero, lab, 0, -1);
>  	  force_expand_binop (index_mode, sub_optab,
>  			      index, CONST1_RTX (index_mode),
> @@ -1604,7 +1613,7 @@ node_is_bounded (case_node_ptr node, tree index_type)
>     tests for the value 50, then this node need not test anything.  */
>  
>  static void
> -emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
> +emit_case_nodes (rtx index, case_node_ptr node, rtx_code_label *default_label,
>  		 int default_prob, tree index_type)
>  {
>    /* If INDEX has an unsigned type, we must make unsigned branches.  */
> @@ -1632,7 +1641,8 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  			convert_modes (mode, imode,
>  				       expand_normal (node->low),
>  				       unsignedp),
> -			label_rtx (node->code_label), unsignedp, probability);
> +			live_label_rtx (node->code_label),
> +			unsignedp, probability);
>        /* Since this case is taken at this point, reduce its weight from
>           subtree_weight.  */
>        subtree_prob -= prob;
> @@ -1699,7 +1709,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  				convert_modes (mode, imode,
>  					       expand_normal (node->right->low),
>  					       unsignedp),
> -				label_rtx (node->right->code_label),
> +				live_label_rtx (node->right->code_label),
>  				unsignedp, probability);
>  
>  	      /* See if the value matches what the left hand side
> @@ -1711,7 +1721,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  				convert_modes (mode, imode,
>  					       expand_normal (node->left->low),
>  					       unsignedp),
> -				label_rtx (node->left->code_label),
> +				live_label_rtx (node->left->code_label),
>  				unsignedp, probability);
>  	    }
>  
> @@ -1798,7 +1808,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  			        (mode, imode,
>  			         expand_normal (node->right->low),
>  			         unsignedp),
> -			        label_rtx (node->right->code_label), unsignedp, probability);
> +			        live_label_rtx (node->right->code_label), unsignedp, probability);
>              }
>  	  }
>  
> @@ -1840,7 +1850,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  			        (mode, imode,
>  			         expand_normal (node->left->low),
>  			         unsignedp),
> -			        label_rtx (node->left->code_label), unsignedp, probability);
> +			        live_label_rtx (node->left->code_label), unsignedp, probability);
>              }
>  	}
>      }
> @@ -2063,7 +2073,7 @@ emit_case_nodes (rtx index, case_node_ptr node, rtx default_label,
>  				       mode, 1, default_label, probability);
>  	    }
>  
> -	  emit_jump (label_rtx (node->code_label));
> +	  emit_jump (live_label_rtx (node->code_label));
>  	}
>      }
>  }
> diff --git a/gcc/stmt.h b/gcc/stmt.h
> index 620b0f1..7b142ce 100644
> --- a/gcc/stmt.h
> +++ b/gcc/stmt.h
> @@ -31,13 +31,18 @@ extern tree resolve_asm_operand_names (tree, tree, tree, tree);
>  extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
>  #endif
>  
> -/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary.  */
> -extern rtx label_rtx (tree);
> +/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary.
> +   If label was deleted, the corresponding note
> +   (NOTE_INSN_DELETED{_DEBUG,}_LABEL) insn will be returned.  */
> +extern rtx_insn *label_rtx (tree);
>  
>  /* As label_rtx, but additionally the label is placed on the forced label
>     list of its containing function (i.e. it is treated as reachable even
>     if how is not obvious).  */
> -extern rtx force_label_rtx (tree);
> +extern rtx_insn *force_label_rtx (tree);
> +
> +/* As label_rtx, but checks that label was not deleted.  */
> +extern rtx_code_label *live_label_rtx (tree);
>  
>  /* Expand a GIMPLE_SWITCH statement.  */
>  extern void expand_case (gswitch *);
> diff --git a/gcc/store-motion.c b/gcc/store-motion.c
> index 530766f..11e2dec 100644
> --- a/gcc/store-motion.c
> +++ b/gcc/store-motion.c
> @@ -813,7 +813,7 @@ insert_store (struct st_expr * expr, edge e)
>      return 0;
>  
>    reg = expr->reaching_reg;
> -  insn = as_a <rtx_insn *> (gen_move_insn (copy_rtx (expr->pattern), reg));
> +  insn = gen_move_insn (copy_rtx (expr->pattern), reg);
>  
>    /* If we are inserting this expression on ALL predecessor edges of a BB,
>       insert it at the start of the BB, and reset the insert bits on the other
> @@ -954,7 +954,7 @@ replace_store_insn (rtx reg, rtx_insn *del, basic_block bb,
>    rtx mem, note, set, ptr;
>  
>    mem = smexpr->pattern;
> -  insn = as_a <rtx_insn *> (gen_move_insn (reg, SET_SRC (single_set (del))));
> +  insn = gen_move_insn (reg, SET_SRC (single_set (del)));
>  
>    for (ptr = smexpr->antic_stores; ptr; ptr = XEXP (ptr, 1))
>      if (XEXP (ptr, 0) == del)


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]