--- a/gcc/df-problems.c	Thu Oct 25 07:37:49 2018 +0900
+++ b/gcc/df-problems.c	Thu Feb 13 11:34:05 2020 +0900
@@ -1,5 +1,5 @@
 /* Standard problems for dataflow support routines.
-   Copyright (C) 1999-2018 Free Software Foundation, Inc.
+   Copyright (C) 1999-2020 Free Software Foundation, Inc.
    Originally contributed by Michael P. Hayes
              (m.hayes@elec.canterbury.ac.nz, mhayes@redhat.com)
    Major rewrite contributed by Danny Berlin (dberlin@dberlin.org)
@@ -36,6 +36,8 @@
 #include "valtrack.h"
 #include "dumpfile.h"
 #include "rtl-iter.h"
+#include "regs.h"
+#include "function-abi.h"
 
 /* Note that turning REG_DEAD_DEBUGGING on will cause
    gcc.c-torture/unsorted/dump-noaddr.c to fail because it prints
@@ -139,17 +141,17 @@
    these along with the bitmap_clear_range call to remove ranges of
    bits without actually generating a knockout vector.
 
-   The kill and sparse_kill and the dense_invalidated_by_call and
-   sparse_invalidated_by_call both play this game.  */
+   The kill and sparse_kill and the dense_invalidated_by_eh and
+   sparse_invalidated_by_eh both play this game.  */
 
 /* Private data used to compute the solution for this problem.  These
    data structures are not accessible outside of this module.  */
-struct df_rd_problem_data
+class df_rd_problem_data
 {
-  /* The set of defs to regs invalidated by call.  */
-  bitmap_head sparse_invalidated_by_call;
-  /* The set of defs to regs invalidate by call for rd.  */
-  bitmap_head dense_invalidated_by_call;
+public:
+  /* The set of defs to regs invalidated by EH edges.  */
+  bitmap_head sparse_invalidated_by_eh;
+  bitmap_head dense_invalidated_by_eh;
   /* An obstack for the bitmaps we need for this problem.  */
   bitmap_obstack rd_bitmaps;
 };
@@ -161,7 +163,7 @@
 df_rd_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
 		    void *vbb_info)
 {
-  struct df_rd_bb_info *bb_info = (struct df_rd_bb_info *) vbb_info;
+  class df_rd_bb_info *bb_info = (class df_rd_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->kill);
@@ -181,23 +183,23 @@
 {
   unsigned int bb_index;
   bitmap_iterator bi;
-  struct df_rd_problem_data *problem_data;
+  class df_rd_problem_data *problem_data;
 
   if (df_rd->problem_data)
     {
-      problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
-      bitmap_clear (&problem_data->sparse_invalidated_by_call);
-      bitmap_clear (&problem_data->dense_invalidated_by_call);
+      problem_data = (class df_rd_problem_data *) df_rd->problem_data;
+      bitmap_clear (&problem_data->sparse_invalidated_by_eh);
+      bitmap_clear (&problem_data->dense_invalidated_by_eh);
     }
   else
     {
-      problem_data = XNEW (struct df_rd_problem_data);
+      problem_data = XNEW (class df_rd_problem_data);
       df_rd->problem_data = problem_data;
 
       bitmap_obstack_initialize (&problem_data->rd_bitmaps);
-      bitmap_initialize (&problem_data->sparse_invalidated_by_call,
+      bitmap_initialize (&problem_data->sparse_invalidated_by_eh,
 			 &problem_data->rd_bitmaps);
-      bitmap_initialize (&problem_data->dense_invalidated_by_call,
+      bitmap_initialize (&problem_data->dense_invalidated_by_eh,
 			 &problem_data->rd_bitmaps);
     }
 
@@ -208,7 +210,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+      class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
       
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->kill.obstack)
@@ -282,7 +284,7 @@
    of kill sets.   */
 
 static void
-df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
+df_rd_bb_local_compute_process_def (class df_rd_bb_info *bb_info,
 				    df_ref def,
 				    int top_flag)
 {
@@ -339,7 +341,7 @@
 df_rd_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+  class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
   rtx_insn *insn;
 
   bitmap_clear (&seen_in_block);
@@ -388,11 +390,10 @@
 {
   unsigned int bb_index;
   bitmap_iterator bi;
-  unsigned int regno;
-  struct df_rd_problem_data *problem_data
-    = (struct df_rd_problem_data *) df_rd->problem_data;
-  bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
-  bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
+  class df_rd_problem_data *problem_data
+    = (class df_rd_problem_data *) df_rd->problem_data;
+  bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
+  bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
 
   bitmap_initialize (&seen_in_block, &df_bitmap_obstack);
   bitmap_initialize (&seen_in_insn, &df_bitmap_obstack);
@@ -404,11 +405,13 @@
       df_rd_bb_local_compute (bb_index);
     }
 
-  /* Set up the knockout bit vectors to be applied across EH_EDGES.  */
-  EXECUTE_IF_SET_IN_BITMAP (regs_invalidated_by_call_regset, 0, regno, bi)
-    {
-      if (! HARD_REGISTER_NUM_P (regno)
-	  || !(df->changeable_flags & DF_NO_HARD_REGS))
+  /* Set up the knockout bit vectors to be applied across EH_EDGES.
+     Conservatively treat partially-clobbered registers as surviving
+     across the EH edge, i.e. assume that definitions before the edge
+     is taken *might* reach uses after it has been taken.  */
+  if (!(df->changeable_flags & DF_NO_HARD_REGS))
+    for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
+      if (eh_edge_abi.clobbers_full_reg_p (regno))
 	{
 	  if (DF_DEFS_COUNT (regno) > DF_SPARSE_THRESHOLD)
 	    bitmap_set_bit (sparse_invalidated, regno);
@@ -417,10 +420,9 @@
 			      DF_DEFS_BEGIN (regno),
 			      DF_DEFS_COUNT (regno));
 	}
-    }
-
-  bitmap_clear (&seen_in_block);
-  bitmap_clear (&seen_in_insn);
+
+  bitmap_release (&seen_in_block);
+  bitmap_release (&seen_in_insn);
 }
 
 
@@ -434,7 +436,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+      class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
 
       bitmap_copy (&bb_info->out, &bb_info->gen);
       bitmap_clear (&bb_info->in);
@@ -455,10 +457,10 @@
 
   if (e->flags & EDGE_EH)
     {
-      struct df_rd_problem_data *problem_data
-	= (struct df_rd_problem_data *) df_rd->problem_data;
-      bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
-      bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
+      class df_rd_problem_data *problem_data
+	= (class df_rd_problem_data *) df_rd->problem_data;
+      bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
+      bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
       bitmap_iterator bi;
       unsigned int regno;
 
@@ -484,7 +486,7 @@
 static bool
 df_rd_transfer_function (int bb_index)
 {
-  struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+  class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
   unsigned int regno;
   bitmap_iterator bi;
   bitmap in = &bb_info->in;
@@ -498,12 +500,12 @@
     changed = bitmap_ior_and_compl (out, gen, in, kill);
   else
     {
-      struct df_rd_problem_data *problem_data;
+      class df_rd_problem_data *problem_data;
       bitmap_head tmp;
 
       /* Note that TMP is _not_ a temporary bitmap if we end up replacing
 	 OUT with TMP.  Therefore, allocate TMP in the RD bitmaps obstack.  */
-      problem_data = (struct df_rd_problem_data *) df_rd->problem_data;
+      problem_data = (class df_rd_problem_data *) df_rd->problem_data;
       bitmap_initialize (&tmp, &problem_data->rd_bitmaps);
 
       bitmap_and_compl (&tmp, in, kill);
@@ -527,7 +529,7 @@
 	 basic block, and mask out DEFs of registers that are not live.
 	 Computing the mask looks costly, but the benefit of the pruning
 	 outweighs the cost.  */
-      struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+      class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
       bitmap regs_live_out = &df_lr_get_bb_info (bb_index)->out;
       bitmap live_defs = BITMAP_ALLOC (&df_bitmap_obstack);
       unsigned int regno;
@@ -549,8 +551,8 @@
 static void
 df_rd_free (void)
 {
-  struct df_rd_problem_data *problem_data
-    = (struct df_rd_problem_data *) df_rd->problem_data;
+  class df_rd_problem_data *problem_data
+    = (class df_rd_problem_data *) df_rd->problem_data;
 
   if (problem_data)
     {
@@ -570,8 +572,8 @@
 static void
 df_rd_start_dump (FILE *file)
 {
-  struct df_rd_problem_data *problem_data
-    = (struct df_rd_problem_data *) df_rd->problem_data;
+  class df_rd_problem_data *problem_data
+    = (class df_rd_problem_data *) df_rd->problem_data;
   unsigned int m = DF_REG_SIZE (df);
   unsigned int regno;
 
@@ -581,9 +583,9 @@
   fprintf (file, ";; Reaching defs:\n");
 
   fprintf (file, ";;  sparse invalidated \t");
-  dump_bitmap (file, &problem_data->sparse_invalidated_by_call);
+  dump_bitmap (file, &problem_data->sparse_invalidated_by_eh);
   fprintf (file, ";;  dense invalidated \t");
-  dump_bitmap (file, &problem_data->dense_invalidated_by_call);
+  dump_bitmap (file, &problem_data->dense_invalidated_by_eh);
 
   fprintf (file, ";;  reg->defs[] map:\t");
   for (regno = 0; regno < m; regno++)
@@ -643,7 +645,7 @@
 static void
 df_rd_top_dump (basic_block bb, FILE *file)
 {
-  struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
+  class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -658,7 +660,7 @@
 static void
 df_rd_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
+  class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -691,7 +693,7 @@
   NULL,                       /* Incremental solution verify start.  */
   NULL,                       /* Incremental solution verify end.  */
   NULL,                       /* Dependent problem.  */
-  sizeof (struct df_rd_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_rd_bb_info),/* Size of entry of block_info array.  */
   TV_DF_RD,                   /* Timing variable.  */
   true                        /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
@@ -733,7 +735,7 @@
 df_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
 		    void *vbb_info)
 {
-  struct df_lr_bb_info *bb_info = (struct df_lr_bb_info *) vbb_info;
+  class df_lr_bb_info *bb_info = (class df_lr_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->use);
@@ -769,7 +771,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (df_lr->out_of_date_transfer_functions, 0, bb_index, bi)
     {
-      struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+      class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
       
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->use.obstack)
@@ -800,7 +802,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+      class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
       gcc_assert (bb_info);
       bitmap_clear (&bb_info->in);
       bitmap_clear (&bb_info->out);
@@ -814,7 +816,7 @@
 df_lr_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+  class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
   rtx_insn *insn;
   df_ref def, use;
 
@@ -929,7 +931,7 @@
 	{
 	  /* The exit block is special for this problem and its bits are
 	     computed from thin air.  */
-	  struct df_lr_bb_info *bb_info = df_lr_get_bb_info (EXIT_BLOCK);
+	  class df_lr_bb_info *bb_info = df_lr_get_bb_info (EXIT_BLOCK);
 	  bitmap_copy (&bb_info->use, df->exit_block_uses);
 	}
       else
@@ -950,7 +952,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+      class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
       bitmap_copy (&bb_info->in, &bb_info->use);
       bitmap_clear (&bb_info->out);
     }
@@ -978,11 +980,17 @@
   bitmap op2 = &df_lr_get_bb_info (e->dest->index)->in;
   bool changed = false;
 
-  /* Call-clobbered registers die across exception and call edges.  */
+  /* Call-clobbered registers die across exception and call edges.
+     Conservatively treat partially-clobbered registers as surviving
+     across the edges; they might or might not, depending on what
+     mode they have.  */
   /* ??? Abnormal call edges ignored for the moment, as this gets
      confused by sibling call edges, which crashes reg-stack.  */
   if (e->flags & EDGE_EH)
-    changed = bitmap_ior_and_compl_into (op1, op2, regs_invalidated_by_call_regset);
+    {
+      bitmap_view<HARD_REG_SET> eh_kills (eh_edge_abi.full_reg_clobbers ());
+      changed = bitmap_ior_and_compl_into (op1, op2, eh_kills);
+    }
   else
     changed = bitmap_ior_into (op1, op2);
 
@@ -996,7 +1004,7 @@
 static bool
 df_lr_transfer_function (int bb_index)
 {
-  struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
+  class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb_index);
   bitmap in = &bb_info->in;
   bitmap out = &bb_info->out;
   bitmap use = &bb_info->use;
@@ -1068,7 +1076,7 @@
 static void
 df_lr_top_dump (basic_block bb, FILE *file)
 {
-  struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+  class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
   struct df_lr_problem_data *problem_data;
   if (!bb_info)
     return;
@@ -1096,7 +1104,7 @@
 static void
 df_lr_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+  class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
   struct df_lr_problem_data *problem_data;
   if (!bb_info)
     return;
@@ -1213,7 +1221,7 @@
   df_lr_verify_solution_start,/* Incremental solution verify start.  */
   df_lr_verify_solution_end,  /* Incremental solution verify end.  */
   NULL,                       /* Dependent problem.  */
-  sizeof (struct df_lr_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_lr_bb_info),/* Size of entry of block_info array.  */
   TV_DF_LR,                   /* Timing variable.  */
   false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
@@ -1253,7 +1261,7 @@
 
   FOR_ALL_BB_FN (bb, cfun)
     {
-      struct df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
+      class df_lr_bb_info *bb_info = df_lr_get_bb_info (bb->index);
       bitmap_set_bit (&all_blocks, bb->index);
 
       if (bb_info)
@@ -1339,7 +1347,7 @@
 df_live_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
 		    void *vbb_info)
 {
-  struct df_live_bb_info *bb_info = (struct df_live_bb_info *) vbb_info;
+  class df_live_bb_info *bb_info = (class df_live_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->gen);
@@ -1377,7 +1385,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (df_live->out_of_date_transfer_functions, 0, bb_index, bi)
     {
-      struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+      class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
       
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->kill.obstack)
@@ -1407,7 +1415,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+      class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
       gcc_assert (bb_info);
       bitmap_clear (&bb_info->in);
       bitmap_clear (&bb_info->out);
@@ -1421,7 +1429,7 @@
 df_live_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+  class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
   rtx_insn *insn;
   df_ref def;
   int luid = 0;
@@ -1497,8 +1505,8 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
-      struct df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
+      class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+      class df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
 
       /* No register may reach a location where it is not used.  Thus
 	 we trim the rr result to the places where it is used.  */
@@ -1527,8 +1535,8 @@
 static bool
 df_live_transfer_function (int bb_index)
 {
-  struct df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
-  struct df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
+  class df_live_bb_info *bb_info = df_live_get_bb_info (bb_index);
+  class df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
   bitmap in = &bb_info->in;
   bitmap out = &bb_info->out;
   bitmap gen = &bb_info->gen;
@@ -1559,8 +1567,8 @@
 
       EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
 	{
-	  struct df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
-	  struct df_live_bb_info *bb_live_info = df_live_get_bb_info (bb_index);
+	  class df_lr_bb_info *bb_lr_info = df_lr_get_bb_info (bb_index);
+	  class df_live_bb_info *bb_live_info = df_live_get_bb_info (bb_index);
 
 	  /* No register may reach a location where it is not used.  Thus
 	     we trim the rr result to the places where it is used.  */
@@ -1585,7 +1593,7 @@
       df_live->block_info_size = 0;
       free (df_live->block_info);
       df_live->block_info = NULL;
-      bitmap_clear (&df_live_scratch);
+      bitmap_release (&df_live_scratch);
       bitmap_obstack_release (&problem_data->live_bitmaps);
       free (problem_data);
       df_live->problem_data = NULL;
@@ -1600,7 +1608,7 @@
 static void
 df_live_top_dump (basic_block bb, FILE *file)
 {
-  struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+  class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
   struct df_live_problem_data *problem_data;
 
   if (!bb_info)
@@ -1629,7 +1637,7 @@
 static void
 df_live_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+  class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
   struct df_live_problem_data *problem_data;
 
   if (!bb_info)
@@ -1741,7 +1749,7 @@
   df_live_verify_solution_start,/* Incremental solution verify start.  */
   df_live_verify_solution_end,  /* Incremental solution verify end.  */
   &problem_LR,                  /* Dependent problem.  */
-  sizeof (struct df_live_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_live_bb_info),/* Size of entry of block_info array.  */
   TV_DF_LIVE,                   /* Timing variable.  */
   false                         /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
@@ -1796,7 +1804,7 @@
 
   FOR_ALL_BB_FN (bb, cfun)
     {
-      struct df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
+      class df_live_bb_info *bb_info = df_live_get_bb_info (bb->index);
       bitmap_set_bit (&all_blocks, bb->index);
 
       if (bb_info)
@@ -1858,7 +1866,7 @@
 df_mir_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
 		     void *vbb_info)
 {
-  struct df_mir_bb_info *bb_info = (struct df_mir_bb_info *) vbb_info;
+  class df_mir_bb_info *bb_info = (class df_mir_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->gen);
@@ -1895,7 +1903,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+      class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
 
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->kill.obstack)
@@ -1928,7 +1936,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+      class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
 
       gcc_assert (bb_info);
 
@@ -1946,7 +1954,7 @@
 df_mir_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+  class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
   rtx_insn *insn;
   int luid = 0;
 
@@ -2010,7 +2018,7 @@
 static void
 df_mir_confluence_0 (basic_block bb)
 {
-  struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+  class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
 
   bitmap_clear (&bb_info->in);
 }
@@ -2038,7 +2046,7 @@
 static bool
 df_mir_transfer_function (int bb_index)
 {
-  struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
+  class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb_index);
   bitmap in = &bb_info->in;
   bitmap out = &bb_info->out;
   bitmap gen = &bb_info->gen;
@@ -2073,7 +2081,7 @@
 static void
 df_mir_top_dump (basic_block bb, FILE *file)
 {
-  struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+  class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
 
   if (!bb_info)
     return;
@@ -2091,7 +2099,7 @@
 static void
 df_mir_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
+  class df_mir_bb_info *bb_info = df_mir_get_bb_info (bb->index);
 
   if (!bb_info)
     return;
@@ -2192,7 +2200,7 @@
   df_mir_verify_solution_start, /* Incremental solution verify start.  */
   df_mir_verify_solution_end,   /* Incremental solution verify end.  */
   NULL,                         /* Dependent problem.  */
-  sizeof (struct df_mir_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_mir_bb_info),/* Size of entry of block_info array.  */
   TV_DF_MIR,                    /* Timing variable.  */
   false                         /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
@@ -2455,7 +2463,7 @@
 df_chain_create_bb (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
+  class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index);
   rtx_insn *insn;
   bitmap_head cpy;
 
@@ -2710,7 +2718,7 @@
 df_word_lr_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
 			 void *vbb_info)
 {
-  struct df_word_lr_bb_info *bb_info = (struct df_word_lr_bb_info *) vbb_info;
+  class df_word_lr_bb_info *bb_info = (class df_word_lr_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->use);
@@ -2753,7 +2761,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (df_word_lr->out_of_date_transfer_functions, 0, bb_index, bi)
     {
-      struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+      class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
       
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->use.obstack)
@@ -2784,7 +2792,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+      class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
       gcc_assert (bb_info);
       bitmap_clear (&bb_info->in);
       bitmap_clear (&bb_info->out);
@@ -2850,7 +2858,7 @@
 df_word_lr_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+  class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
   rtx_insn *insn;
   df_ref def, use;
 
@@ -2917,7 +2925,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+      class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
       bitmap_copy (&bb_info->in, &bb_info->use);
       bitmap_clear (&bb_info->out);
     }
@@ -2941,7 +2949,7 @@
 static bool
 df_word_lr_transfer_function (int bb_index)
 {
-  struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
+  class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb_index);
   bitmap in = &bb_info->in;
   bitmap out = &bb_info->out;
   bitmap use = &bb_info->use;
@@ -2978,7 +2986,7 @@
 static void
 df_word_lr_top_dump (basic_block bb, FILE *file)
 {
-  struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
+  class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -2996,7 +3004,7 @@
 static void
 df_word_lr_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
+  class df_word_lr_bb_info *bb_info = df_word_lr_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -3031,7 +3039,7 @@
   NULL,                            /* Incremental solution verify start.  */
   NULL,                            /* Incremental solution verify end.  */
   NULL,                            /* Dependent problem.  */
-  sizeof (struct df_word_lr_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_word_lr_bb_info),/* Size of entry of block_info array.  */
   TV_DF_WORD_LR,                   /* Timing variable.  */
   false                            /* Reset blocks on dropping out of blocks_to_analyze.  */
 };
@@ -4093,8 +4101,7 @@
 	  if (volatile_insn_p (PATTERN (insn)))
 	    return false;
 	  memrefs_in_across |= find_memory (insn);
-	  note_stores (PATTERN (insn), find_memory_stores,
-		       &mem_sets_in_across);
+	  note_stores (insn, find_memory_stores, &mem_sets_in_across);
 	  /* This is used just to find sets of the stack pointer.  */
 	  memrefs_in_across |= mem_sets_in_across;
 	  trapping_insns_in_across |= may_trap_p (PATTERN (insn));
@@ -4173,7 +4180,7 @@
 	    {
 	      int mem_ref_flags = 0;
 	      int mem_set_flags = 0;
-	      note_stores (PATTERN (insn), find_memory_stores, &mem_set_flags);
+	      note_stores (insn, find_memory_stores, &mem_set_flags);
 	      mem_ref_flags = find_memory (insn);
 	      /* Catch sets of the stack pointer.  */
 	      mem_ref_flags |= mem_set_flags;
@@ -4347,7 +4354,7 @@
 df_md_free_bb_info (basic_block bb ATTRIBUTE_UNUSED,
                     void *vbb_info)
 {
-  struct df_md_bb_info *bb_info = (struct df_md_bb_info *) vbb_info;
+  class df_md_bb_info *bb_info = (class df_md_bb_info *) vbb_info;
   if (bb_info)
     {
       bitmap_clear (&bb_info->kill);
@@ -4382,7 +4389,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+      class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
       /* When bitmaps are already initialized, just clear them.  */
       if (bb_info->init.obstack)
         {
@@ -4451,7 +4458,7 @@
 }
 
 static void
-df_md_bb_local_compute_process_def (struct df_md_bb_info *bb_info,
+df_md_bb_local_compute_process_def (class df_md_bb_info *bb_info,
                                     df_ref def,
                                     int top_flag)
 {
@@ -4492,7 +4499,7 @@
 df_md_bb_local_compute (unsigned int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+  class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
   rtx_insn *insn;
 
   /* Artificials are only hard regs.  */
@@ -4533,7 +4540,7 @@
       df_md_bb_local_compute (bb_index);
     }
 
-  bitmap_clear (&seen_in_insn);
+  bitmap_release (&seen_in_insn);
 
   frontiers = XNEWVEC (bitmap_head, last_basic_block_for_fn (cfun));
   FOR_ALL_BB_FN (bb, cfun)
@@ -4570,7 +4577,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+      class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
       gcc_assert (bb_info);
       bitmap_clear (&bb_info->in);
       bitmap_clear (&bb_info->out);
@@ -4581,7 +4588,7 @@
 df_md_transfer_function (int bb_index)
 {
   basic_block bb = BASIC_BLOCK_FOR_FN (cfun, bb_index);
-  struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+  class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
   bitmap in = &bb_info->in;
   bitmap out = &bb_info->out;
   bitmap gen = &bb_info->gen;
@@ -4609,7 +4616,7 @@
 
   EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
     {
-      struct df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
+      class df_md_bb_info *bb_info = df_md_get_bb_info (bb_index);
 
       bitmap_copy (&bb_info->in, &bb_info->init);
       df_md_transfer_function (bb_index);
@@ -4619,7 +4626,7 @@
 static void
 df_md_confluence_0 (basic_block bb)
 {
-  struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+  class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
   bitmap_copy (&bb_info->in, &bb_info->init);
 }
 
@@ -4635,8 +4642,13 @@
     return false;
 
   if (e->flags & EDGE_EH)
-    return bitmap_ior_and_compl_into (op1, op2,
-				      regs_invalidated_by_call_regset);
+    {
+      /* Conservatively treat partially-clobbered registers as surviving
+	 across the edge; they might or might not, depending on what mode
+	 they have.  */
+      bitmap_view<HARD_REG_SET> eh_kills (eh_edge_abi.full_reg_clobbers ());
+      return bitmap_ior_and_compl_into (op1, op2, eh_kills);
+    }
   else
     return bitmap_ior_into (op1, op2);
 }
@@ -4649,6 +4661,7 @@
   struct df_md_problem_data *problem_data
     = (struct df_md_problem_data *) df_md->problem_data;
 
+  bitmap_release (&df_md_scratch);
   bitmap_obstack_release (&problem_data->md_bitmaps);
   free (problem_data);
   df_md->problem_data = NULL;
@@ -4665,7 +4678,7 @@
 static void
 df_md_top_dump (basic_block bb, FILE *file)
 {
-  struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+  class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -4684,7 +4697,7 @@
 static void
 df_md_bottom_dump (basic_block bb, FILE *file)
 {
-  struct df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
+  class df_md_bb_info *bb_info = df_md_get_bb_info (bb->index);
   if (!bb_info)
     return;
 
@@ -4716,7 +4729,7 @@
   NULL,			      /* Incremental solution verify start.  */
   NULL,			      /* Incremental solution verify end.  */
   NULL,                       /* Dependent problem.  */
-  sizeof (struct df_md_bb_info),/* Size of entry of block_info array.  */
+  sizeof (class df_md_bb_info),/* Size of entry of block_info array.  */
   TV_DF_MD,                   /* Timing variable.  */
   false                       /* Reset blocks on dropping out of blocks_to_analyze.  */
 };