CbC/CbC_gcc: gcc/df-problems.c comparison

comparison gcc/df-problems.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* 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)
 and Kenneth Zadeck (zadeck@naturalbridge.com).
 #include "cfganal.h"
 #include "dce.h"
 #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
 addresses in the dumps.  */
 #define REG_DEAD_DEBUGGING 0
 by the regnum are used to represent that there is a killing def
 for the register.  The confluence and transfer functions use
 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
+The kill and sparse_kill and the dense_invalidated_by_eh and
-sparse_invalidated_by_call both play this game.  */
+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.  */
+public:
-bitmap_head sparse_invalidated_by_call;
+/* The set of defs to regs invalidated by EH edges.  */
-/* The set of defs to regs invalidate by call for rd.  */
+bitmap_head sparse_invalidated_by_eh;
-bitmap_head dense_invalidated_by_call;
+bitmap_head dense_invalidated_by_eh;
 /* An obstack for the bitmaps we need for this problem.  */
 bitmap_obstack rd_bitmaps;
 };
 static void
 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);
 bitmap_clear (&bb_info->sparse_kill);
 bitmap_clear (&bb_info->gen);
 static void
 df_rd_alloc (bitmap all_blocks)
 {
 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;
+problem_data = (class df_rd_problem_data *) df_rd->problem_data;
-bitmap_clear (&problem_data->sparse_invalidated_by_call);
+bitmap_clear (&problem_data->sparse_invalidated_by_eh);
-bitmap_clear (&problem_data->dense_invalidated_by_call);
+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);
 }
 df_grow_bb_info (df_rd);
 /* Because of the clustering of all use sites for the same pseudo,
 we have to process all of the blocks before doing the analysis.  */
 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)
 	{
 	  bitmap_clear (&bb_info->kill);
 more complicated than just simulating, because we must produce the
 gen and kill sets and hence deal with the two possible representations
 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)
 {
 for (; def; def = DF_REF_NEXT_LOC (def))
 {
 static void
 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);
 bitmap_clear (&seen_in_insn);
 static void
 df_rd_local_compute (bitmap all_blocks)
 {
 unsigned int bb_index;
 bitmap_iterator bi;
-unsigned int regno;
+class df_rd_problem_data *problem_data
-struct df_rd_problem_data *problem_data
+= (class df_rd_problem_data *) df_rd->problem_data;
-= (struct df_rd_problem_data *) df_rd->problem_data;
+bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
-bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
+bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
-bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
 bitmap_initialize (&seen_in_block, &df_bitmap_obstack);
 bitmap_initialize (&seen_in_insn, &df_bitmap_obstack);
 df_maybe_reorganize_def_refs (DF_REF_ORDER_BY_REG);
 EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi)
 {
 df_rd_bb_local_compute (bb_index);
 }
-/* Set up the knockout bit vectors to be applied across EH_EDGES.  */
+/* 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)
+Conservatively treat partially-clobbered registers as surviving
-{
+across the EH edge, i.e. assume that definitions before the edge
-if (! HARD_REGISTER_NUM_P (regno)
+is taken *might* reach uses after it has been taken.  */
-	  || !(df->changeable_flags & DF_NO_HARD_REGS))
+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);
 	  else
 	    bitmap_set_range (dense_invalidated,
 			      DF_DEFS_BEGIN (regno),
 			      DF_DEFS_COUNT (regno));
 	}
-}
+bitmap_release (&seen_in_block);
-bitmap_clear (&seen_in_block);
+bitmap_release (&seen_in_insn);
-bitmap_clear (&seen_in_insn);
 }
 /* Initialize the solution bit vectors for problem.  */
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 if (e->flags & EDGE_FAKE)
 return false;
 if (e->flags & EDGE_EH)
 {
-struct df_rd_problem_data *problem_data
+class df_rd_problem_data *problem_data
-	= (struct df_rd_problem_data *) df_rd->problem_data;
+	= (class df_rd_problem_data *) df_rd->problem_data;
-bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_call;
+bitmap sparse_invalidated = &problem_data->sparse_invalidated_by_eh;
-bitmap dense_invalidated = &problem_data->dense_invalidated_by_call;
+bitmap dense_invalidated = &problem_data->dense_invalidated_by_eh;
 bitmap_iterator bi;
 unsigned int regno;
 auto_bitmap tmp (&df_bitmap_obstack);
 bitmap_and_compl (tmp, op2, dense_invalidated);
 /* Transfer function.  */
 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;
 bitmap out = &bb_info->out;
 bitmap gen = &bb_info->gen;
 if (bitmap_empty_p (sparse_kill))
 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);
 EXECUTE_IF_SET_IN_BITMAP (sparse_kill, 0, regno, bi)
 	{
 {
 /* Create a mask of DEFs for all registers live at the end of this
 	 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;
 bitmap_iterator bi;
 /* Free all storage associated with the problem.  */
 static void
 df_rd_free (void)
 {
-struct df_rd_problem_data *problem_data
+class df_rd_problem_data *problem_data
-= (struct df_rd_problem_data *) df_rd->problem_data;
+= (class df_rd_problem_data *) df_rd->problem_data;
 if (problem_data)
 {
 bitmap_obstack_release (&problem_data->rd_bitmaps);
 /* Debugging info.  */
 static void
 df_rd_start_dump (FILE *file)
 {
-struct df_rd_problem_data *problem_data
+class df_rd_problem_data *problem_data
-= (struct df_rd_problem_data *) df_rd->problem_data;
+= (class df_rd_problem_data *) df_rd->problem_data;
 unsigned int m = DF_REG_SIZE (df);
 unsigned int regno;
 if (!df_rd->block_info)
 return;
 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++)
 if (DF_DEFS_COUNT (regno))
 fprintf (file, "%d[%d,%d] ", regno,
 /* Debugging info at top of bb.  */
 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;
 df_rd_dump_defs_set (&bb_info->in, ";; rd  in  ", file);
 df_rd_dump_defs_set (&bb_info->gen, ";; rd  gen ", file);
 /* Debugging info at bottom of bb.  */
 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;
 df_rd_dump_defs_set (&bb_info->out, ";; rd  out ", file);
 }
 NULL,                       /* Debugging start insn.  */
 NULL,                       /* Debugging end insn.  */
 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.  */
 };
 static void
 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);
 bitmap_clear (&bb_info->def);
 bitmap_clear (&bb_info->in);
 bitmap_obstack_initialize (&problem_data->lr_bitmaps);
 }
 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)
 	{
 	  bitmap_clear (&bb_info->def);
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 static void
 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;
 /* Process the registers set in an exception handler.  */
 FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
 {
 if (bb_index == EXIT_BLOCK)
 	{
 	  /* 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
 	df_lr_bb_local_compute (bb_index);
 }
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 {
 bitmap op1 = &df_lr_get_bb_info (e->src->index)->out;
 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);
 changed |= bitmap_ior_into (op1, &df->hardware_regs_used);
 return changed;
 /* Transfer function.  */
 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;
 bitmap def = &bb_info->def;
 /* Debugging info at top of bb.  */
 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;
 fprintf (file, ";; lr  in  \t");
 /* Debugging info at bottom of bb.  */
 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;
 fprintf (file, ";; lr  out \t");
 NULL,                       /* Debugging start insn.  */
 NULL,                       /* Debugging end insn.  */
 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.  */
 };
 bitmap_initialize (&saved_use, &bitmap_default_obstack);
 bitmap_initialize (&all_blocks, &bitmap_default_obstack);
 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)
 	{
 	  /* Make a copy of the transfer functions and then compute
 static void
 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);
 bitmap_clear (&bb_info->kill);
 bitmap_clear (&bb_info->in);
 df_grow_bb_info (df_live);
 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)
 	{
 	  bitmap_clear (&bb_info->kill);
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 static void
 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;
 FOR_BB_INSNS (bb, insn)
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
-struct df_lr_bb_info *bb_lr_info = df_lr_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.  */
 bitmap_and (&bb_info->out, &bb_info->gen, &bb_lr_info->out);
 bitmap_clear (&bb_info->in);
 /* Transfer function for the forwards may-initialized problem.  */
 static bool
 df_live_transfer_function (int 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);
-struct df_lr_bb_info *bb_lr_info = df_lr_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;
 bitmap kill = &bb_info->kill;
 bitmap_iterator bi;
 unsigned int bb_index;
 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);
+	  class 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_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.  */
 	  bitmap_and_into (&bb_live_info->in, &bb_lr_info->in);
 	  bitmap_and_into (&bb_live_info->out, &bb_lr_info->out);
 if (df_live->block_info)
 {
 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;
 }
 BITMAP_FREE (df_live->out_of_date_transfer_functions);
 /* Debugging info at top of bb.  */
 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)
 return;
 /* Debugging info at bottom of bb.  */
 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)
 return;
 NULL,                         /* Debugging start insn.  */
 NULL,                         /* Debugging end insn.  */
 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.  */
 };
 df_grow_insn_info ();
 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)
 	{
 	  /* Make a copy of the transfer functions and then compute
 static void
 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);
 bitmap_clear (&bb_info->kill);
 bitmap_clear (&bb_info->in);
 df_grow_bb_info (df_mir);
 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)
 	{
 	  bitmap_clear (&bb_info->kill);
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 bitmap_clear (&bb_info->in);
 bitmap_set_range (&bb_info->in, 0, DF_REG_SIZE (df));
 static void
 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;
 /* Ignoring artificial defs is intentional: these often pretend that some
 registers carry incoming arguments (when they are FUNCTION_ARG_REGNO) even
 blocks, assume all registers are uninitialized.  */
 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);
 }
 /* Transfer function for the forwards must-initialized problem.  */
 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;
 bitmap kill = &bb_info->kill;
 /* Debugging info at top of bb.  */
 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;
 fprintf (file, ";; mir   in  \t");
 /* Debugging info at bottom of bb.  */
 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;
 fprintf (file, ";; mir   out \t");
 NULL,                         /* Debugging start insn.  */
 NULL,                         /* Debugging end insn.  */
 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.  */
 };
 static void
 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;
 bitmap_initialize (&cpy, &bitmap_default_obstack);
 bitmap_copy (&cpy, &bb_info->in);
 static void
 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);
 bitmap_clear (&bb_info->def);
 bitmap_clear (&bb_info->in);
 bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, ENTRY_BLOCK);
 bitmap_set_bit (df_word_lr->out_of_date_transfer_functions, EXIT_BLOCK);
 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)
 	{
 	  bitmap_clear (&bb_info->def);
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 static void
 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;
 /* Ensure that artificial refs don't contain references to pseudos.  */
 FOR_EACH_ARTIFICIAL_DEF (def, bb_index)
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 /* Transfer function.  */
 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;
 bitmap def = &bb_info->def;
 /* Debugging info at top of bb.  */
 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;
 fprintf (file, ";; blr  in  \t");
 df_print_word_regset (file, &bb_info->in);
 /* Debugging info at bottom of bb.  */
 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;
 fprintf (file, ";; blr  out \t");
 df_print_word_regset (file, &bb_info->out);
 NULL,                            /* Debugging start insn.  */
 NULL,                            /* Debugging end insn.  */
 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.  */
 };
 if (NONDEBUG_INSN_P (insn))
 	{
 	  if (volatile_insn_p (PATTERN (insn)))
 	    return false;
 	  memrefs_in_across |= find_memory (insn);
-	  note_stores (PATTERN (insn), find_memory_stores,
+	  note_stores (insn, find_memory_stores, &mem_sets_in_across);
-		       &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));
 	}
 next = PREV_INSN (insn);
 	     dealt with elsewhere.  */
 	  if (other_branch_live != NULL || memrefs_in_across != 0)
 	    {
 	      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;
 	      if ((mem_ref_flags | mem_set_flags) & MEMREF_VOLATILE)
 static void
 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);
 bitmap_clear (&bb_info->gen);
 bitmap_clear (&bb_info->init);
 }
 bitmap_initialize (&df_md_scratch, &problem_data->md_bitmaps);
 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)
 {
 bitmap_clear (&bb_info->init);
 bitmap_clear (&bb_info->gen);
 }
 }
 }
 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)
 {
 bitmap_clear (&seen_in_insn);
 static void
 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.  */
 if (!(df->changeable_flags & DF_NO_HARD_REGS))
 df_md_bb_local_compute_process_def (bb_info,
 EXECUTE_IF_SET_IN_BITMAP (all_blocks, 0, bb_index, bi1)
 {
 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)
 bitmap_initialize (&frontiers[bb->index], &bitmap_default_obstack);
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 static bool
 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;
 bitmap kill = &bb_info->kill;
 unsigned int bb_index;
 bitmap_iterator bi;
 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);
 }
 }
 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);
 }
 /* In of target gets or of out of source.  */
 if (e->flags & EDGE_FAKE)
 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);
 }
 /* Free all storage associated with the problem.  */
 df_md_free (void)
 {
 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;
 df_md->block_info_size = 0;
 /* Debugging info at top of bb.  */
 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;
 fprintf (file, ";; md  in  \t");
 df_print_regset (file, &bb_info->in);
 /* Debugging info at bottom of bb.  */
 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;
 fprintf (file, ";; md  out \t");
 df_print_regset (file, &bb_info->out);
 NULL,                       /* Debugging start insn.  */
 NULL,                       /* Debugging end insn.  */
 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.  */
 };
 /* Create a new MD instance and add it to the existing instance

Mercurial > hg > CbC > CbC_gcc

comparison gcc/df-problems.c @ 145:1830386684a0