+
+/* Do not re-run on ltrans stage. */
+
+static bool
+gate_whole_program_function_and_variable_visibility (void)
+{
+ return !flag_ltrans;
+}
+
+/* Bring functionss local at LTO time whith -fwhole-program. */
+
+static unsigned int
+whole_program_function_and_variable_visibility (void)
+{
+ struct cgraph_node *node;
+ struct varpool_node *vnode;
+
+ function_and_variable_visibility (flag_whole_program);
+
+ for (node = cgraph_nodes; node; node = node->next)
+ if ((node->local.externally_visible && !DECL_COMDAT (node->decl))
+ && node->local.finalized)
+ cgraph_mark_needed_node (node);
+ for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
+ if (vnode->externally_visible && !DECL_COMDAT (vnode->decl))
+ varpool_mark_needed_node (vnode);
+ if (dump_file)
+ {
+ fprintf (dump_file, "\nNeeded variables:");
+ for (vnode = varpool_nodes_queue; vnode; vnode = vnode->next_needed)
+ if (vnode->needed)
+ fprintf (dump_file, " %s", varpool_node_name (vnode));
+ fprintf (dump_file, "\n\n");
+ }
+ if (optimize)
+ ipa_discover_readonly_nonaddressable_vars ();
+ return 0;
+}
+
+struct ipa_opt_pass_d pass_ipa_whole_program_visibility =
+{
+ {
+ IPA_PASS,
+ "whole-program", /* name */
+ gate_whole_program_function_and_variable_visibility,/* gate */
+ whole_program_function_and_variable_visibility,/* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_CGRAPHOPT, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ TODO_remove_functions | TODO_dump_cgraph
+ | TODO_ggc_collect /* todo_flags_finish */
+ },
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* TODOs */
+ NULL, /* function_transform */
+ NULL, /* variable_transform */
+};
+
+
+/* Simple ipa profile pass propagating frequencies across the callgraph. */
+
+static unsigned int
+ipa_profile (void)
+{
+ struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
+ struct cgraph_edge *e;
+ int order_pos;
+ bool something_changed = false;
+ int i;
+
+ order_pos = ipa_reverse_postorder (order);
+ for (i = order_pos - 1; i >= 0; i--)
+ {
+ if (order[i]->local.local && cgraph_propagate_frequency (order[i]))
+ {
+ for (e = order[i]->callees; e; e = e->next_callee)
+ if (e->callee->local.local && !e->callee->aux)
+ {
+ something_changed = true;
+ e->callee->aux = (void *)1;
+ }
+ }
+ order[i]->aux = NULL;
+ }
+
+ while (something_changed)
+ {
+ something_changed = false;
+ for (i = order_pos - 1; i >= 0; i--)
+ {
+ if (order[i]->aux && cgraph_propagate_frequency (order[i]))
+ {
+ for (e = order[i]->callees; e; e = e->next_callee)
+ if (e->callee->local.local && !e->callee->aux)
+ {
+ something_changed = true;
+ e->callee->aux = (void *)1;
+ }
+ }
+ order[i]->aux = NULL;
+ }
+ }
+ free (order);
+ return 0;
+}
+
+static bool
+gate_ipa_profile (void)
+{
+ return flag_ipa_profile;
+}
+
+struct ipa_opt_pass_d pass_ipa_profile =
+{
+ {
+ IPA_PASS,
+ "profile_estimate", /* name */
+ gate_ipa_profile, /* gate */
+ ipa_profile, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_IPA_PROFILE, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
+ },
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* TODOs */
+ NULL, /* function_transform */
+ NULL /* variable_transform */
+};
+
+/* Generate and emit a static constructor or destructor. WHICH must
+ be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
+ is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
+ initialization priority for this constructor or destructor.
+
+ FINAL specify whether the externally visible name for collect2 should
+ be produced. */
+
+static void
+cgraph_build_static_cdtor_1 (char which, tree body, int priority, bool final)
+{
+ static int counter = 0;
+ char which_buf[16];
+ tree decl, name, resdecl;
+
+ /* The priority is encoded in the constructor or destructor name.
+ collect2 will sort the names and arrange that they are called at
+ program startup. */
+ if (final)
+ sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
+ else
+ /* Proudce sane name but one not recognizable by collect2, just for the
+ case we fail to inline the function. */
+ sprintf (which_buf, "sub_%c_%.5d_%d", which, priority, counter++);
+ name = get_file_function_name (which_buf);
+
+ decl = build_decl (input_location, FUNCTION_DECL, name,
+ build_function_type_list (void_type_node, NULL_TREE));
+ current_function_decl = decl;
+
+ resdecl = build_decl (input_location,
+ RESULT_DECL, NULL_TREE, void_type_node);
+ DECL_ARTIFICIAL (resdecl) = 1;
+ DECL_RESULT (decl) = resdecl;
+ DECL_CONTEXT (resdecl) = decl;
+
+ allocate_struct_function (decl, false);
+
+ TREE_STATIC (decl) = 1;
+ TREE_USED (decl) = 1;
+ DECL_ARTIFICIAL (decl) = 1;
+ DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
+ DECL_SAVED_TREE (decl) = body;
+ if (!targetm.have_ctors_dtors && final)
+ {
+ TREE_PUBLIC (decl) = 1;
+ DECL_PRESERVE_P (decl) = 1;
+ }
+ DECL_UNINLINABLE (decl) = 1;
+
+ DECL_INITIAL (decl) = make_node (BLOCK);
+ TREE_USED (DECL_INITIAL (decl)) = 1;
+
+ DECL_SOURCE_LOCATION (decl) = input_location;
+ cfun->function_end_locus = input_location;
+
+ switch (which)
+ {
+ case 'I':
+ DECL_STATIC_CONSTRUCTOR (decl) = 1;
+ decl_init_priority_insert (decl, priority);
+ break;
+ case 'D':
+ DECL_STATIC_DESTRUCTOR (decl) = 1;
+ decl_fini_priority_insert (decl, priority);
+ break;
+ default:
+ gcc_unreachable ();
+ }
+
+ gimplify_function_tree (decl);
+
+ cgraph_add_new_function (decl, false);
+
+ set_cfun (NULL);
+ current_function_decl = NULL;
+}
+
+/* Generate and emit a static constructor or destructor. WHICH must
+ be one of 'I' (for a constructor) or 'D' (for a destructor). BODY
+ is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the
+ initialization priority for this constructor or destructor. */
+
+void
+cgraph_build_static_cdtor (char which, tree body, int priority)
+{
+ cgraph_build_static_cdtor_1 (which, body, priority, false);
+}
+
+/* A vector of FUNCTION_DECLs declared as static constructors. */
+static VEC(tree, heap) *static_ctors;
+/* A vector of FUNCTION_DECLs declared as static destructors. */
+static VEC(tree, heap) *static_dtors;
+
+/* When target does not have ctors and dtors, we call all constructor
+ and destructor by special initialization/destruction function
+ recognized by collect2.
+
+ When we are going to build this function, collect all constructors and
+ destructors and turn them into normal functions. */
+
+static void
+record_cdtor_fn (struct cgraph_node *node)
+{
+ if (DECL_STATIC_CONSTRUCTOR (node->decl))
+ VEC_safe_push (tree, heap, static_ctors, node->decl);
+ if (DECL_STATIC_DESTRUCTOR (node->decl))
+ VEC_safe_push (tree, heap, static_dtors, node->decl);
+ node = cgraph_get_node (node->decl);
+ DECL_DISREGARD_INLINE_LIMITS (node->decl) = 1;
+}
+
+/* Define global constructors/destructor functions for the CDTORS, of
+ which they are LEN. The CDTORS are sorted by initialization
+ priority. If CTOR_P is true, these are constructors; otherwise,
+ they are destructors. */
+
+static void
+build_cdtor (bool ctor_p, VEC (tree, heap) *cdtors)
+{
+ size_t i,j;
+ size_t len = VEC_length (tree, cdtors);
+
+ i = 0;
+ while (i < len)
+ {
+ tree body;
+ tree fn;
+ priority_type priority;
+
+ priority = 0;
+ body = NULL_TREE;
+ j = i;
+ do
+ {
+ priority_type p;
+ fn = VEC_index (tree, cdtors, j);
+ p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
+ if (j == i)
+ priority = p;
+ else if (p != priority)
+ break;
+ j++;
+ }
+ while (j < len);
+
+ /* When there is only one cdtor and target supports them, do nothing. */
+ if (j == i + 1
+ && targetm.have_ctors_dtors)
+ {
+ i++;
+ continue;
+ }
+ /* Find the next batch of constructors/destructors with the same
+ initialization priority. */
+ for (;i < j; i++)
+ {
+ tree call;
+ fn = VEC_index (tree, cdtors, i);
+ call = build_call_expr (fn, 0);
+ if (ctor_p)
+ DECL_STATIC_CONSTRUCTOR (fn) = 0;
+ else
+ DECL_STATIC_DESTRUCTOR (fn) = 0;
+ /* We do not want to optimize away pure/const calls here.
+ When optimizing, these should be already removed, when not
+ optimizing, we want user to be able to breakpoint in them. */
+ TREE_SIDE_EFFECTS (call) = 1;
+ append_to_statement_list (call, &body);
+ }
+ gcc_assert (body != NULL_TREE);
+ /* Generate a function to call all the function of like
+ priority. */
+ cgraph_build_static_cdtor_1 (ctor_p ? 'I' : 'D', body, priority, true);
+ }
+}
+
+/* Comparison function for qsort. P1 and P2 are actually of type
+ "tree *" and point to static constructors. DECL_INIT_PRIORITY is
+ used to determine the sort order. */
+
+static int
+compare_ctor (const void *p1, const void *p2)
+{
+ tree f1;
+ tree f2;
+ int priority1;
+ int priority2;
+
+ f1 = *(const tree *)p1;
+ f2 = *(const tree *)p2;
+ priority1 = DECL_INIT_PRIORITY (f1);
+ priority2 = DECL_INIT_PRIORITY (f2);
+
+ if (priority1 < priority2)
+ return -1;
+ else if (priority1 > priority2)
+ return 1;
+ else
+ /* Ensure a stable sort. Constructors are executed in backwarding
+ order to make LTO initialize braries first. */
+ return DECL_UID (f2) - DECL_UID (f1);
+}
+
+/* Comparison function for qsort. P1 and P2 are actually of type
+ "tree *" and point to static destructors. DECL_FINI_PRIORITY is
+ used to determine the sort order. */
+
+static int
+compare_dtor (const void *p1, const void *p2)
+{
+ tree f1;
+ tree f2;
+ int priority1;
+ int priority2;
+
+ f1 = *(const tree *)p1;
+ f2 = *(const tree *)p2;
+ priority1 = DECL_FINI_PRIORITY (f1);
+ priority2 = DECL_FINI_PRIORITY (f2);
+
+ if (priority1 < priority2)
+ return -1;
+ else if (priority1 > priority2)
+ return 1;
+ else
+ /* Ensure a stable sort. */
+ return DECL_UID (f1) - DECL_UID (f2);
+}
+
+/* Generate functions to call static constructors and destructors
+ for targets that do not support .ctors/.dtors sections. These
+ functions have magic names which are detected by collect2. */
+
+static void
+build_cdtor_fns (void)
+{
+ if (!VEC_empty (tree, static_ctors))
+ {
+ gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
+ VEC_qsort (tree, static_ctors, compare_ctor);
+ build_cdtor (/*ctor_p=*/true, static_ctors);
+ }
+
+ if (!VEC_empty (tree, static_dtors))
+ {
+ gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
+ VEC_qsort (tree, static_dtors, compare_dtor);
+ build_cdtor (/*ctor_p=*/false, static_dtors);
+ }
+}
+
+/* Look for constructors and destructors and produce function calling them.
+ This is needed for targets not supporting ctors or dtors, but we perform the
+ transformation also at linktime to merge possibly numberous
+ constructors/destructors into single function to improve code locality and
+ reduce size. */
+
+static unsigned int
+ipa_cdtor_merge (void)
+{
+ struct cgraph_node *node;
+ for (node = cgraph_nodes; node; node = node->next)
+ if (node->analyzed
+ && (DECL_STATIC_CONSTRUCTOR (node->decl)
+ || DECL_STATIC_DESTRUCTOR (node->decl)))
+ record_cdtor_fn (node);
+ build_cdtor_fns ();
+ VEC_free (tree, heap, static_ctors);
+ VEC_free (tree, heap, static_dtors);
+ return 0;
+}
+
+/* Perform the pass when we have no ctors/dtors support
+ or at LTO time to merge multiple constructors into single
+ function. */
+
+static bool
+gate_ipa_cdtor_merge (void)
+{
+ return !targetm.have_ctors_dtors || (optimize && in_lto_p);
+}
+
+struct ipa_opt_pass_d pass_ipa_cdtor_merge =
+{
+ {
+ IPA_PASS,
+ "cdtor", /* name */
+ gate_ipa_cdtor_merge, /* gate */
+ ipa_cdtor_merge, /* execute */
+ NULL, /* sub */
+ NULL, /* next */
+ 0, /* static_pass_number */
+ TV_CGRAPHOPT, /* tv_id */
+ 0, /* properties_required */
+ 0, /* properties_provided */
+ 0, /* properties_destroyed */
+ 0, /* todo_flags_start */
+ 0 /* todo_flags_finish */
+ },
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* TODOs */
+ NULL, /* function_transform */
+ NULL /* variable_transform */
+};