aboutsummaryrefslogtreecommitdiff
path: root/gcc
diff options
context:
space:
mode:
Diffstat (limited to 'gcc')
-rw-r--r--gcc/ChangeLog11
-rw-r--r--gcc/common.opt6
-rw-r--r--gcc/flag-types.h8
-rw-r--r--gcc/ipa-visibility.c46
-rw-r--r--gcc/lto/ChangeLog6
-rw-r--r--gcc/lto/lang.opt23
-rw-r--r--gcc/lto/lto-lang.c29
7 files changed, 116 insertions, 13 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index e868795..eae1883 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2015-11-25 Jan Hubicka <jh@suse.cz>
+
+ * ipa-visibility.c (cgraph_externally_visible_p,
+ varpool_node::externally_visible_p): When doing incremental linking,
+ hidden symbols may be still used later.
+ (update_visibility_by_resolution_info): Do not drop weak during
+ incremental link.
+ (function_and_variable_visibility): Fix formating.
+ * flag-types.h (lto_linker_output): Declare.
+ * common.opt 9flag_incremental_link): New flag.
+
2015-11-25 Michael Meissner <meissner@linux.vnet.ibm.com>
* config/rs6000/constraints.md (wb constraint): New constraint for
diff --git a/gcc/common.opt b/gcc/common.opt
index 3eb520e..e1617c4 100644
--- a/gcc/common.opt
+++ b/gcc/common.opt
@@ -46,6 +46,12 @@ int optimize_fast
Variable
bool in_lto_p = false
+; This variable is set to non-0 only by LTO front-end. 1 indicates that
+; the output produced will be used for incrmeental linking (thus weak symbols
+; can still be bound).
+Variable
+int flag_incremental_link = 0
+
; 0 means straightforward implementation of complex divide acceptable.
; 1 means wide ranges of inputs must work for complex divide.
; 2 means C99-like requirements for complex multiply and divide.
diff --git a/gcc/flag-types.h b/gcc/flag-types.h
index 88a760c..b130fc5 100644
--- a/gcc/flag-types.h
+++ b/gcc/flag-types.h
@@ -265,6 +265,14 @@ enum lto_partition_model {
LTO_PARTITION_MAX = 4
};
+/* flag_lto_linker_output initialization values. */
+enum lto_linker_output {
+ LTO_LINKER_OUTPUT_UNKNOWN,
+ LTO_LINKER_OUTPUT_REL,
+ LTO_LINKER_OUTPUT_DYN,
+ LTO_LINKER_OUTPUT_PIE,
+ LTO_LINKER_OUTPUT_EXEC
+};
/* gfortran -finit-real= values. */
diff --git a/gcc/ipa-visibility.c b/gcc/ipa-visibility.c
index d128ca8..41ed4db 100644
--- a/gcc/ipa-visibility.c
+++ b/gcc/ipa-visibility.c
@@ -217,13 +217,13 @@ cgraph_externally_visible_p (struct cgraph_node *node,
This improves code quality and we know we will duplicate them at most twice
(in the case that we are not using plugin and link with object file
implementing same COMDAT) */
- if ((in_lto_p || whole_program)
+ if (((in_lto_p || whole_program) && !flag_incremental_link)
&& DECL_COMDAT (node->decl)
&& comdat_can_be_unshared_p (node))
return false;
/* When doing link time optimizations, hidden symbols become local. */
- if (in_lto_p
+ if ((in_lto_p && !flag_incremental_link)
&& (DECL_VISIBILITY (node->decl) == VISIBILITY_HIDDEN
|| DECL_VISIBILITY (node->decl) == VISIBILITY_INTERNAL)
/* Be sure that node is defined in IR file, not in other object
@@ -293,13 +293,13 @@ varpool_node::externally_visible_p (void)
so this does not enable more optimization, but referring static var
is faster for dynamic linking. Also this match logic hidding vtables
from LTO symbol tables. */
- if ((in_lto_p || flag_whole_program)
+ if (((in_lto_p || flag_whole_program) && !flag_incremental_link)
&& DECL_COMDAT (decl)
&& comdat_can_be_unshared_p (this))
return false;
/* When doing link time optimizations, hidden symbols become local. */
- if (in_lto_p
+ if (in_lto_p && !flag_incremental_link
&& (DECL_VISIBILITY (decl) == VISIBILITY_HIDDEN
|| DECL_VISIBILITY (decl) == VISIBILITY_INTERNAL)
/* Be sure that node is defined in IR file, not in other object
@@ -405,17 +405,36 @@ update_visibility_by_resolution_info (symtab_node * node)
for (symtab_node *next = node->same_comdat_group;
next != node; next = next->same_comdat_group)
{
- next->set_comdat_group (NULL);
- DECL_WEAK (next->decl) = false;
+ /* During incremental linking we need to keep symbol weak for future
+ linking. We can still drop definition if we know non-LTO world
+ prevails. */
+ if (!flag_incremental_link)
+ {
+ DECL_WEAK (next->decl) = false;
+ next->set_comdat_group (NULL);
+ }
if (next->externally_visible
&& !define)
- DECL_EXTERNAL (next->decl) = true;
+ {
+ DECL_EXTERNAL (next->decl) = true;
+ next->set_comdat_group (NULL);
+ }
}
- node->set_comdat_group (NULL);
- DECL_WEAK (node->decl) = false;
+
+ /* During incremental linking we need to keep symbol weak for future
+ linking. We can still drop definition if we know non-LTO world prevails. */
+ if (!flag_incremental_link)
+ {
+ DECL_WEAK (node->decl) = false;
+ node->set_comdat_group (NULL);
+ node->dissolve_same_comdat_group_list ();
+ }
if (!define)
- DECL_EXTERNAL (node->decl) = true;
- node->dissolve_same_comdat_group_list ();
+ {
+ DECL_EXTERNAL (node->decl) = true;
+ node->set_comdat_group (NULL);
+ node->dissolve_same_comdat_group_list ();
+ }
}
/* Decide on visibility of all symbols. */
@@ -639,8 +658,9 @@ function_and_variable_visibility (bool whole_program)
{
gcc_assert (in_lto_p || whole_program || !TREE_PUBLIC (vnode->decl));
vnode->unique_name = ((vnode->resolution == LDPR_PREVAILING_DEF_IRONLY
- || vnode->resolution == LDPR_PREVAILING_DEF_IRONLY_EXP)
- && TREE_PUBLIC (vnode->decl));
+ || vnode->resolution
+ == LDPR_PREVAILING_DEF_IRONLY_EXP)
+ && TREE_PUBLIC (vnode->decl));
if (vnode->same_comdat_group && TREE_PUBLIC (vnode->decl))
{
symtab_node *next = vnode;
diff --git a/gcc/lto/ChangeLog b/gcc/lto/ChangeLog
index 4aae740..1ddacfa 100644
--- a/gcc/lto/ChangeLog
+++ b/gcc/lto/ChangeLog
@@ -1,3 +1,9 @@
+2015-11-25 Jan Hubicka <jh@suse.cz>
+
+ * lto-lang.c (lto_post_options): Process flag_lto_linker_output.
+ * lang.opt (lto_linker_output): New enum.
+ (flinker_output): New flag.
+
2015-11-24 Jan Hubicka <hubicka@ucw.cz>
* lto-symtab.c: Include alias.h
diff --git a/gcc/lto/lang.opt b/gcc/lto/lang.opt
index f7aedc4..c4216b3 100644
--- a/gcc/lto/lang.opt
+++ b/gcc/lto/lang.opt
@@ -24,6 +24,29 @@
Language
LTO
+Enum
+Name(lto_linker_output) Type(enum lto_linker_output) UnknownError(unknown linker output %qs)
+
+EnumValue
+Enum(lto_linker_output) String(unknown) Value(LTO_LINKER_OUTPUT_UNKNOWN)
+
+EnumValue
+Enum(lto_linker_output) String(rel) Value(LTO_LINKER_OUTPUT_REL)
+
+EnumValue
+Enum(lto_linker_output) String(dyn) Value(LTO_LINKER_OUTPUT_DYN)
+
+EnumValue
+Enum(lto_linker_output) String(pie) Value(LTO_LINKER_OUTPUT_PIE)
+
+EnumValue
+Enum(lto_linker_output) String(exec) Value(LTO_LINKER_OUTPUT_EXEC)
+
+flinker-output=
+LTO Report Driver Joined RejectNegative Enum(lto_linker_output) Var(flag_lto_linker_output) Init(LTO_LINKER_OUTPUT_UNKNOWN)
+Set linker output type (used internally during LTO optimization)
+
+
fltrans
LTO Report Var(flag_ltrans)
Run the link-time optimizer in local transformation (LTRANS) mode.
diff --git a/gcc/lto/lto-lang.c b/gcc/lto/lto-lang.c
index 53dd8f6..90bacde 100644
--- a/gcc/lto/lto-lang.c
+++ b/gcc/lto/lto-lang.c
@@ -819,6 +819,35 @@ lto_post_options (const char **pfilename ATTRIBUTE_UNUSED)
if (flag_wpa)
flag_generate_lto = 1;
+ /* Initialize the codegen flags according to the output type. */
+ switch (flag_lto_linker_output)
+ {
+ case LTO_LINKER_OUTPUT_REL: /* .o: incremental link producing LTO IL */
+ flag_whole_program = 0;
+ flag_incremental_link = 1;
+ break;
+
+ case LTO_LINKER_OUTPUT_DYN: /* .so: PID library */
+ /* On some targets, like i386 it makes sense to build PIC library wihout
+ -fpic for performance reasons. So no need to adjust flags. */
+ break;
+
+ case LTO_LINKER_OUTPUT_PIE: /* PIE binary */
+ /* If -fPIC or -fPIE was used at compile time, be sure that
+ flag_pie is 2. */
+ flag_pie = MAX (flag_pie, flag_pic);
+ flag_pic = 0;
+ break;
+
+ case LTO_LINKER_OUTPUT_EXEC: /* Normal executable */
+ flag_pic = 0;
+ flag_pie = 0;
+ break;
+
+ case LTO_LINKER_OUTPUT_UNKNOWN:
+ break;
+ }
+
/* Excess precision other than "fast" requires front-end
support. */
flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
generated by cgit v1.1 at 2025-03-02 22:29:52 +0000