On Tue, Jan 09, 2007 at 09:42:40AM -0800, H. J. Lu wrote: > On Tue, Jan 09, 2007 at 06:18:19AM -0800, H. J. Lu wrote: > > On Tue, Jan 09, 2007 at 02:01:53PM +0000, Andrew Haley wrote: > > > H. J. Lu writes: > > > > On Tue, Jan 09, 2007 at 01:51:00PM +0000, Andrew Haley wrote: > > > > > H. J. Lu writes: > > > > > > On Tue, Jan 09, 2007 at 01:38:00PM +0000, Andrew Haley wrote: > > > > > > > H. J. Lu writes: > > > > > > > > I am enclosing a patch to implement a new linker swicth, > > > > > > > > --dynamic-list-data. It is -Bsymbolic for function symbols > > > only. > > > > > > > > I tried it with C, C++, Java and Fortran on Linux/ia32, > > > Linux/x86-64 > > > > > > > > and Linux/ia64. There are only a few regressions. The > > > function calls > > > > > > > > within the new resulting DSOs will bind locally. It speeds up > > > > > > > > the enclosed C++ testcase by > > > > > > > > > > > > > > > > 1. 23% on ia64. > > > > > > > > 2. 6% on ia32. > > > > > > > > 3. 3% on x86-64. > > > > > > > > > > > > > > > > Should we consider such optimization? > > > > > > > > > > > > > > That's a terrible name for the option. What does it mean? > > > > > > > > > > > > It is an extension of the current command line options: > > > > > > > > > > > > --dynamic-list-cpp-typeinfo Use C++ typeinfo dynamic list > > > > > > --dynamic-list FILE Read dynamic list > > > > > > > > > > But you said it was like -Bsymbolic for function symbols only. What > > > > > is the connection between C++ typeinfo and that? (Hint: Java doesn't > > > > > use C++ typeinfo, but -Bsymbolic for function symbols only would be > > > > > very useful.) > > > > > > > > --dynamic-list is a generic linker feature. Users have to provide a > > > > list of symbols, which will be bound dynamically and everything else > > > > is bound locally. --dynamic-list-cpp-typeinfo includes a prefined > > > > list for C++ typeinfo. --dynamic-list-data puts data symbols on > > > > the dynamic list. > > > > > > OK, so in the case of --dynamic-list-data, there is no user-supplied > > > list. Instead, there's (conceptually) an automatically-generated > > > list, which contains every symbol that doesn't point to a function. > > > Can't you just call the new option -Bsymbolic-functions? At least > > > then people like me might have an outside chance of remembering it. > > > > Here is the updated patch to use -Bsymbolic-functions instead. > > > > I just realized that --dynamic-list-data is -Bsymbolic for function > symbols only when you build shared libraries. We can use > --dynamic-list-data on executables to make global data symbols > dynamic so that dlopened shared libraries can reference them. We can > make -Bsymbolic-functions an alias of --dynamic-list-data. But > we still need --dynamic-list-data since -Bsymbolic doesn't apply to > executables.
Here is the updated patch with testcases and document change. H.J. ---- bfd/ 2007-01-09 H.J. Lu <[EMAIL PROTECTED]> PR ld/3831 * elf-bfd.h (bfd_elf_link_mark_dynamic_symbol): Add an argument, Elf_Internal_Sym *. * elflink.c (bfd_elf_link_mark_dynamic_symbol): Mark a data symbol dynamic if info->dynamic_data is TRUE. (bfd_elf_record_link_assignment): Updated call to bfd_elf_record_link_assignment. (_bfd_elf_merge_symbol): Likewise. Always call bfd_elf_link_mark_dynamic_symbol. include/ 2007-01-09 H.J. Lu <[EMAIL PROTECTED]> PR ld/3831 * bfdlink.h (bfd_link_info): Rename dynamic to dynamic_list. Add dynamic and dynamic_data. ld/ 2007-01-05 H.J. Lu <[EMAIL PROTECTED]> PR ld/3831 * NEWS: Mention -Bsymbolic-functions and --dynamic-list-data. * ld.texinfo: Document -Bsymbolic-functions and --dynamic-list-data. * ldlang.c (lang_process): Change link_info.dynamic to link_info.dynamic_list. (lang_append_dynamic_list): Likewise. * ldmain.c (main): Likewise. Initialize link_info.dynamic and link_info.dynamic_data to FALSE. * lexsup.c (option_values): Add OPTION_DYNAMIC_LIST_DATA. (ld_options): Add entries for -Bsymbolic-functions and --dynamic-list-data. Make -Bsymbolic-functions an alias of --dynamic-list-data. (parse_args): Change link_info.dynamic to link_info.dynamic_list. Set link_info.dynamic_data to TRUE for --dynamic-list-data. Set link_info.dynamic to TRUE for --dynamuc-list*. ld/testsuite/ 2007-01-09 H.J. Lu <[EMAIL PROTECTED]> * ld-elf/shared.exp: Add tests for --dynamic-list-data. --- binutils/bfd/elf-bfd.h.data 2007-01-09 09:00:51.000000000 -0800 +++ binutils/bfd/elf-bfd.h 2007-01-09 09:00:51.000000000 -0800 @@ -1858,7 +1858,8 @@ extern int bfd_elf_link_record_local_dyn (struct bfd_link_info *, bfd *, long); extern void bfd_elf_link_mark_dynamic_symbol - (struct bfd_link_info *, struct elf_link_hash_entry *); + (struct bfd_link_info *, struct elf_link_hash_entry *, + Elf_Internal_Sym *); extern bfd_boolean _bfd_elf_close_and_cleanup (bfd *); --- binutils/bfd/elflink.c.data 2007-01-09 09:00:51.000000000 -0800 +++ binutils/bfd/elflink.c 2007-01-09 09:59:22.000000000 -0800 @@ -454,14 +454,22 @@ bfd_elf_link_record_dynamic_symbol (stru void bfd_elf_link_mark_dynamic_symbol (struct bfd_link_info *info, - struct elf_link_hash_entry *h) + struct elf_link_hash_entry *h, + Elf_Internal_Sym *sym) { - struct bfd_elf_dynamic_list *d = info->dynamic; + struct bfd_elf_dynamic_list *d = info->dynamic_list; - if (d == NULL || info->relocatable) + /* It may be called more than once on the same H. */ + if(h->dynamic || info->relocatable) return; - if ((*d->match) (&d->head, NULL, h->root.root.string)) + if ((info->dynamic_data + && (h->type == STT_OBJECT + || (sym != NULL + && ELF_ST_TYPE (sym->st_info) == STT_OBJECT))) + || (d != NULL + && h->root.type == bfd_link_hash_new + && (*d->match) (&d->head, NULL, h->root.root.string))) h->dynamic = 1; } @@ -499,7 +507,7 @@ bfd_elf_record_link_assignment (bfd *out if (h->root.type == bfd_link_hash_new) { - bfd_elf_link_mark_dynamic_symbol (info, h); + bfd_elf_link_mark_dynamic_symbol (info, h, NULL); h->non_elf = 0; } @@ -906,13 +914,17 @@ _bfd_elf_merge_symbol (bfd *abfd, || h->root.type == bfd_link_hash_warning) h = (struct elf_link_hash_entry *) h->root.u.i.link; + /* We have to check it for every instance since the first few may be + refereences and not all compilers emit symbol type for undefined + symbols. */ + bfd_elf_link_mark_dynamic_symbol (info, h, sym); + /* If we just created the symbol, mark it as being an ELF symbol. Other than that, there is nothing to do--there is no merge issue with a newly defined symbol--so we just return. */ if (h->root.type == bfd_link_hash_new) { - bfd_elf_link_mark_dynamic_symbol (info, h); h->non_elf = 0; return TRUE; } --- binutils/include/bfdlink.h.data 2006-10-30 15:25:51.000000000 -0800 +++ binutils/include/bfdlink.h 2007-01-09 09:58:52.000000000 -0800 @@ -340,6 +340,13 @@ struct bfd_link_info caching ELF symbol buffer. */ unsigned int reduce_memory_overheads: 1; + /* TRUE if all data symbols should be dynamic. */ + unsigned int dynamic_data: 1; + + /* TRUE if some symbols have to be dynamic, controlled by + --dynamic-list command line options. */ + unsigned int dynamic: 1; + /* What to do with unresolved symbols in an object file. When producing executables the default is GENERATE_ERROR. When producing shared libraries the default is IGNORE. The @@ -440,7 +447,7 @@ struct bfd_link_info bfd_vma relro_start, relro_end; /* List of symbols should be dynamic. */ - struct bfd_elf_dynamic_list *dynamic; + struct bfd_elf_dynamic_list *dynamic_list; }; /* This structures holds a set of callback functions. These are --- binutils/ld/NEWS.data 2006-09-20 04:35:09.000000000 -0700 +++ binutils/ld/NEWS 2007-01-09 11:18:06.000000000 -0800 @@ -1,4 +1,7 @@ -*- text -*- +* ELF: Add -Bsymbolic-functions and --dynamic-list-data, builtin list + for --dynamic-list, which put global data symbols on the dynamic list. + * Add support for x86_64 PE+ target. * Add support for Score target. --- binutils/ld/ld.texinfo.data 2006-12-05 11:28:02.000000000 -0800 +++ binutils/ld/ld.texinfo 2007-01-09 11:14:06.000000000 -0800 @@ -1130,6 +1130,14 @@ for a program linked against a shared li within the shared library. This option is only meaningful on ELF platforms which support shared libraries. [EMAIL PROTECTED] -Bsymbolic-functions [EMAIL PROTECTED] -Bsymbolic-functions +When creating a shared library, bind references to global function +symbols to the definition within the shared library, if any. [EMAIL PROTECTED] is an alias for @option{--dynamic-list-data}. +This option is only meaningful on ELF platforms which support shared +libraries. + @kindex [EMAIL PROTECTED] @item [EMAIL PROTECTED] Specify the name of a dynamic list file to the linker. This is @@ -1143,6 +1151,10 @@ which support shared libraries. The format of the dynamic list is the same as the version node without scope and node name. See @ref{VERSION} for more information. [EMAIL PROTECTED] --dynamic-list-data [EMAIL PROTECTED] --dynamic-list-data +Include all global data symbols to the dynamic list. + @kindex --dynamic-list-cpp-typeinfo @item --dynamic-list-cpp-typeinfo Provide the builtin dynamic list for C++ runtime type identification. --- binutils/ld/ldlang.c.data 2007-01-09 09:00:51.000000000 -0800 +++ binutils/ld/ldlang.c 2007-01-09 09:00:51.000000000 -0800 @@ -5732,8 +5732,8 @@ void lang_process (void) { /* Finalize dynamic list. */ - if (link_info.dynamic) - lang_finalize_version_expr_head (&link_info.dynamic->head); + if (link_info.dynamic_list) + lang_finalize_version_expr_head (&link_info.dynamic_list->head); current_target = default_target; @@ -7047,13 +7047,13 @@ lang_add_unique (const char *name) void lang_append_dynamic_list (struct bfd_elf_version_expr *dynamic) { - if (link_info.dynamic) + if (link_info.dynamic_list) { struct bfd_elf_version_expr *tail; for (tail = dynamic; tail->next != NULL; tail = tail->next) ; - tail->next = link_info.dynamic->head.list; - link_info.dynamic->head.list = dynamic; + tail->next = link_info.dynamic_list->head.list; + link_info.dynamic_list->head.list = dynamic; } else { @@ -7062,7 +7062,7 @@ lang_append_dynamic_list (struct bfd_elf d = xcalloc (1, sizeof *d); d->head.list = dynamic; d->match = lang_vers_match; - link_info.dynamic = d; + link_info.dynamic_list = d; } } --- binutils/ld/ldmain.c.data 2006-10-30 15:25:51.000000000 -0800 +++ binutils/ld/ldmain.c 2007-01-09 10:00:33.000000000 -0800 @@ -318,7 +318,9 @@ main (int argc, char **argv) link_info.warn_shared_textrel = FALSE; link_info.gc_sections = FALSE; link_info.print_gc_sections = FALSE; - link_info.dynamic = NULL; + link_info.dynamic = FALSE; + link_info.dynamic_list = NULL; + link_info.dynamic_data = FALSE; link_info.reduce_memory_overheads = FALSE; config.maxpagesize = 0; --- binutils/ld/lexsup.c.data 2006-10-30 15:25:51.000000000 -0800 +++ binutils/ld/lexsup.c 2007-01-09 10:00:23.000000000 -0800 @@ -109,6 +109,7 @@ enum option_values OPTION_VERSION_EXPORTS_SECTION, OPTION_DYNAMIC_LIST, OPTION_DYNAMIC_LIST_CPP_TYPEINFO, + OPTION_DYNAMIC_LIST_DATA, OPTION_WARN_COMMON, OPTION_WARN_CONSTRUCTORS, OPTION_WARN_FATAL, @@ -503,6 +504,10 @@ static const struct ld_option ld_options OPTION_VERSION_EXPORTS_SECTION }, '\0', N_("SYMBOL"), N_("Take export symbols list from .exports, using\n" "\t\t\t\tSYMBOL as the version."), TWO_DASHES }, + { {"Bsymbolic-functions", no_argument, NULL, OPTION_DYNAMIC_LIST_DATA}, + '\0', NULL, N_("Bind global function references locally"), ONE_DASH }, + { {"dynamic-list-data", no_argument, NULL, OPTION_DYNAMIC_LIST_DATA}, + '\0', NULL, N_("Add data symbols to dynamic list"), TWO_DASHES }, { {"dynamic-list-cpp-typeinfo", no_argument, NULL, OPTION_DYNAMIC_LIST_CPP_TYPEINFO}, '\0', NULL, N_("Use C++ typeinfo dynamic list"), TWO_DASHES }, { {"dynamic-list", required_argument, NULL, OPTION_DYNAMIC_LIST}, @@ -1244,8 +1249,13 @@ parse_args (unsigned argc, char **argv) .exports sections. */ command_line.version_exports_section = optarg; break; + case OPTION_DYNAMIC_LIST_DATA: + link_info.dynamic_data = TRUE; + link_info.dynamic = TRUE; + break; case OPTION_DYNAMIC_LIST_CPP_TYPEINFO: lang_append_dynamic_list_cpp_typeinfo (); + link_info.dynamic = TRUE; break; case OPTION_DYNAMIC_LIST: /* This option indicates a small script that only specifies @@ -1260,6 +1270,7 @@ parse_args (unsigned argc, char **argv) parser_input = input_dynamic_list; yyparse (); } + link_info.dynamic = TRUE; break; case OPTION_WARN_COMMON: config.warn_common = TRUE; --- binutils/ld/testsuite/ld-elf/shared.exp.data 2006-10-18 09:23:24.000000000 -0700 +++ binutils/ld/testsuite/ld-elf/shared.exp 2007-01-09 10:46:32.000000000 -0800 @@ -72,15 +72,27 @@ set build_tests { {"Build libdl2a.so with --dynamic-list=dl2.list" "-shared -Wl,--dynamic-list=dl2.list" "-fPIC" {dl2.c dl2xxx.c} {} "libdl2a.so"} + {"Build libdl2a.so with --dynamic-list-data" + "-shared -Wl,--dynamic-list-data" "-fPIC" + {dl2.c dl2xxx.c} {} "libdl2a.so"} {"Build libdl2b.so with --dynamic-list=dl2.list and dl2xxx.list" "-shared -Wl,--dynamic-list=dl2.list,--dynamic-list=dl2xxx.list" "-fPIC" {dl2.c dl2xxx.c} {} "libdl2b.so"} + {"Build libdl2b.so with --dynamic-list-data and dl2xxx.list" + "-shared -Wl,--dynamic-list-data,--dynamic-list=dl2xxx.list" "-fPIC" + {dl2.c dl2xxx.c} {} "libdl2b.so"} {"Build libdl4a.so with --dynamic-list=dl4.list" "-shared -Wl,--dynamic-list=dl4.list" "-fPIC" {dl4.c dl4xxx.c} {} "libdl4a.so"} + {"Build libdl4a.so with --dynamic-list-data" + "-shared -Wl,--dynamic-list-data" "-fPIC" + {dl4.c dl4xxx.c} {} "libdl4a.so"} {"Build libdl4b.so with --dynamic-list=dl4.list and dl4xxx.list" "-shared -Wl,--dynamic-list=dl4.list,--dynamic-list=dl4xxx.list" "-fPIC" {dl4.c dl4xxx.c} {} "libdl4b.so"} + {"Build libdl4b.so with --dynamic-list-data and dl4xxx.list" + "-shared -Wl,--dynamic-list-data,--dynamic-list=dl4xxx.list" "-fPIC" + {dl4.c dl4xxx.c} {} "libdl4b.so"} } set run_tests { @@ -120,9 +132,12 @@ set run_tests { {"Run hidden libbar.so with versioned libfoo.so" "tmpdir/libbarhfoov.so tmpdir/libfoov.so" "" {main.c} "hidden" "hidden.out"} - {"Run with dlopen on libdl1.so" + {"Run dl1 with --dynamic-list=dl1.list and dlopen on libdl1.so" "--dynamic-list=dl1.list -ldl" "" {dl1main.c} "dl1" "dl1.out"} + {"Run dl1 with --dynamic-list-data and dlopen on libdl1.so" + "--dynamic-list-data -ldl" "" + {dl1main.c} "dl1" "dl1.out"} {"Run with libdl2a.so" "tmpdir/libdl2a.so" "" {dl2main.c} "dl2a" "dl2a.out"}