CbC/CbC_gcc: gcc/passes.c comparison

comparison gcc/passes.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	d34655255c78 1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Top level of GCC compilers (cc1, cc1plus, etc.)
-Copyright (C) 1987-2017 Free Software Foundation, Inc.
+Copyright (C) 1987-2018 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 void
 pass_manager::execute_early_local_passes ()
 {
 execute_pass_list (cfun, pass_build_ssa_passes_1->sub);
-if (flag_check_pointer_bounds)
-execute_pass_list (cfun, pass_chkp_instrumentation_passes_1->sub);
 execute_pass_list (cfun, pass_local_optimization_passes_1->sub);
 }
 unsigned int
 pass_manager::execute_pass_mode_switching ()
 return execute_build_ssa_passes ();
 }
 }; // class pass_build_ssa_passes
-const pass_data pass_data_chkp_instrumentation_passes =
-{
-SIMPLE_IPA_PASS, /* type */
-"chkp_passes", /* name */
-OPTGROUP_NONE, /* optinfo_flags */
-TV_NONE, /* tv_id */
-0, /* properties_required */
-0, /* properties_provided */
-0, /* properties_destroyed */
-0, /* todo_flags_start */
-0, /* todo_flags_finish */
-};
-class pass_chkp_instrumentation_passes : public simple_ipa_opt_pass
-{
-public:
-pass_chkp_instrumentation_passes (gcc::context *ctxt)
-: simple_ipa_opt_pass (pass_data_chkp_instrumentation_passes, ctxt)
-{}
-/* opt_pass methods: */
-virtual bool gate (function *)
-{
-/* Don't bother doing anything if the program has errors.  */
-return (flag_check_pointer_bounds
-	      && !seen_error () && !in_lto_p);
-}
-}; // class pass_chkp_instrumentation_passes
 const pass_data pass_data_local_optimization_passes =
 {
 SIMPLE_IPA_PASS, /* type */
 "opt_local_passes", /* name */
 OPTGROUP_NONE, /* optinfo_flags */
 {
 return new pass_build_ssa_passes (ctxt);
 }
 simple_ipa_opt_pass *
-make_pass_chkp_instrumentation_passes (gcc::context *ctxt)
-{
-return new pass_chkp_instrumentation_passes (ctxt);
-}
-simple_ipa_opt_pass *
 make_pass_local_optimization_passes (gcc::context *ctxt)
 {
 return new pass_local_optimization_passes (ctxt);
 }
 /* Buffer big enough to format a 32-bit UINT_MAX into.  */
 char num[11];
 dump_kind dkind;
 int id;
-int optgroup_flags = OPTGROUP_NONE;
+optgroup_flags_t optgroup_flags = OPTGROUP_NONE;
 gcc::dump_manager *dumps = m_ctxt->get_dumps ();
 /* See below in next_pass_1.  */
 num[0] = '\0';
 if (pass->static_pass_number != -1)
 slot = tab[pass->static_pass_number];
 if (!slot)
 return false;
-cgraph_uid = func ? cgraph_node::get (func)->uid : 0;
+cgraph_uid = func ? cgraph_node::get (func)->get_uid () : 0;
 if (func && DECL_ASSEMBLER_NAME_SET_P (func))
 aname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (func));
 range = slot;
 while (range)
 void
 pass_manager::register_pass (struct register_pass_info *pass_info)
 {
 bool all_instances, success;
-gcc::dump_manager *dumps = m_ctxt->get_dumps ();
 /* The checks below could fail in buggy plugins.  Existing GCC
 passes should never fail these checks, so we mention plugin in
 the messages.  */
 if (!pass_info->pass)
 "pass %qs not found but is referenced by new pass %qs",
 pass_info->reference_pass_name, pass_info->pass->name);
 /* OK, we have successfully inserted the new pass. We need to register
 the dump files for the newly added pass and its duplicates (if any).
-Because the registration of plugin/backend passes happens after the
+While doing so, we also delete the pass_list_node
-command-line options are parsed, the options that specify single
-pass dumping (e.g. -fdump-tree-PASSNAME) cannot be used for new
-passes. Therefore we currently can only enable dumping of
-new passes when the 'dump-all' flags (e.g. -fdump-tree-all)
-are specified. While doing so, we also delete the pass_list_node
 objects created during pass positioning.  */
+gcc::dump_manager *dumps = m_ctxt->get_dumps ();
 while (added_pass_nodes)
 {
 struct pass_list_node *next_node = added_pass_nodes->next;
-enum tree_dump_index tdi;
-register_one_dump_file (added_pass_nodes->pass);
+/* Handle -fdump-* and -fopt-info.  */
-if (added_pass_nodes->pass->type == SIMPLE_IPA_PASS
+dumps->register_pass (added_pass_nodes->pass);
-|| added_pass_nodes->pass->type == IPA_PASS)
-tdi = TDI_ipa_all;
-else if (added_pass_nodes->pass->type == GIMPLE_PASS)
-tdi = TDI_tree_all;
-else
-tdi = TDI_rtl_all;
-/* Check if dump-all flag is specified.  */
-if (dumps->get_dump_file_info (tdi)->pstate)
-	{
-	  dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
-->pstate = dumps->get_dump_file_info (tdi)->pstate;
-	  dumps->get_dump_file_info (added_pass_nodes->pass->static_pass_number)
-	    ->pflags = dumps->get_dump_file_info (tdi)->pflags;
-	}
 XDELETE (added_pass_nodes);
 added_pass_nodes = next_node;
 }
 }
 #define POP_INSERT_PASSES() \
 }
 #define NEXT_PASS(PASS, NUM) \
 do { \
-gcc_assert (NULL == PASS ## _ ## NUM); \
+gcc_assert (PASS ## _ ## NUM == NULL); \
 if ((NUM) == 1)                              \
 PASS ## _1 = make_##PASS (m_ctxt);          \
 else                                         \
 {                                          \
 gcc_assert (PASS ## _1);                 \
 keep the array visible to garbage collector to avoid reading collected
 out nodes.  */
 static int nnodes;
 static GTY ((length ("nnodes"))) cgraph_node **order;
+#define uid_hash_t hash_set<int_hash <int, 0, -1> >
 /* Hook called when NODE is removed and therefore should be
-excluded from order vector.  DATA is an array of integers.
+excluded from order vector.  DATA is a hash set with removed nodes.  */
-DATA[0] holds max index it may be accessed by.  For cgraph
-node DATA[node->uid + 1] holds index of this node in order
-vector.  */
 static void
 remove_cgraph_node_from_order (cgraph_node *node, void *data)
 {
-int *order_idx = (int *)data;
+uid_hash_t *removed_nodes = (uid_hash_t *)data;
+removed_nodes->add (node->get_uid ());
-if (node->uid >= order_idx[0])
-return;
-int idx = order_idx[node->uid + 1];
-if (idx >= 0 && idx < nnodes && order[idx] == node)
-order[idx] = NULL;
 }
 /* If we are in IPA mode (i.e., current_function_decl is NULL), call
 function CALLBACK for every function in the call graph.  Otherwise,
 call CALLBACK on the current function.
 if (current_function_decl)
 callback (cfun, data);
 else
 {
 cgraph_node_hook_list *hook;
-int *order_idx;
+uid_hash_t removed_nodes;
 gcc_assert (!order);
 order = ggc_vec_alloc<cgraph_node *> (symtab->cgraph_count);
-order_idx = XALLOCAVEC (int, symtab->cgraph_max_uid + 1);
-memset (order_idx + 1, -1, sizeof (int) * symtab->cgraph_max_uid);
-order_idx[0] = symtab->cgraph_max_uid;
 nnodes = ipa_reverse_postorder (order);
 for (i = nnodes - 1; i >= 0; i--)
-	{
+	order[i]->process = 1;
-	  order[i]->process = 1;
-	  order_idx[order[i]->uid + 1] = i;
-	}
 hook = symtab->add_cgraph_removal_hook (remove_cgraph_node_from_order,
-					      order_idx);
+					      &removed_nodes);
 for (i = nnodes - 1; i >= 0; i--)
 	{
+	  cgraph_node *node = order[i];
 	  /* Function could be inlined and removed as unreachable.  */
-	  if (!order[i])
+	  if (node == NULL || removed_nodes.contains (node->get_uid ()))
 	    continue;
-	  struct cgraph_node *node = order[i];
 	  /* Allow possibly removed nodes to be garbage collected.  */
 	  order[i] = NULL;
 	  node->process = 0;
 	  if (node->has_gimple_body_p ())
 struct cgraph_node **order;
 if ((!flag_generate_lto && !flag_generate_offload) || seen_error ())
 return;
+gcc_assert (!dump_file);
+streamer_dump_file = dump_begin (TDI_lto_stream_out, NULL);
 select_what_to_stream ();
 encoder = lto_symtab_encoder_new (false);
 /* Create the callgraph set in the same order used in
 for (i = order_pos - 1; i >= 0; i--)
 {
 struct cgraph_node *node = order[i];
-if (node->has_gimple_body_p ())
+if (gimple_has_body_p (node->decl))
 	{
 	  /* When streaming out references to statements as part of some IPA
 	     pass summary, the statements need to have uids assigned and the
 	     following does that for all the IPA passes here. Naturally, this
 	     ordering then matches the one IPA-passes get in their stmt_fixup
 lto_set_symtab_encoder_in_partition (encoder, vnode);
 ipa_write_summaries_1 (compute_ltrans_boundary (encoder));
 free (order);
+if (streamer_dump_file)
+{
+dump_end (TDI_lto_stream_out, streamer_dump_file);
+streamer_dump_file = NULL;
+}
 }
 /* Same as execute_pass_list but assume that subpasses of IPA passes
 are local passes. If SET is not NULL, write out optimization summaries of
 only those node in SET. */

Mercurial > hg > CbC > CbC_gcc

comparison gcc/passes.c @ 131:84e7813d76e9