From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3001 invoked by alias); 18 Aug 2011 15:37:18 -0000 Received: (qmail 2265 invoked by uid 22791); 18 Aug 2011 15:37:15 -0000 X-SWARE-Spam-Status: No, hits=-2.4 required=5.0 tests=AWL,BAYES_00,RP_MATCHES_RCVD,TW_BJ X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 18 Aug 2011 15:36:58 +0000 Received: (qmail 22814 invoked from network); 18 Aug 2011 15:36:56 -0000 Received: from unknown (HELO ?192.168.0.101?) (yao@127.0.0.2) by mail.codesourcery.com with ESMTPA; 18 Aug 2011 15:36:56 -0000 Message-ID: <4E4D318E.704@codesourcery.com> Date: Thu, 18 Aug 2011 15:37:00 -0000 From: Yao Qi User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.18) Gecko/20110617 Lightning/1.0b2 Thunderbird/3.1.11 MIME-Version: 1.0 To: "gdb-patches@sourceware.org" Subject: combine bfd_lookup_symbol in solib-*.c Content-Type: multipart/mixed; boundary="------------030003010304080908070407" X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2011-08/txt/msg00356.txt.bz2 This is a multi-part message in MIME format. --------------030003010304080908070407 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Content-length: 1248 >> > +static CORE_ADDR >> > +bfd_lookup_symbol (bfd *abfd, char *symname) > I now notice that we already have copies of this > function in solib-svr4.c, solib-frv.c and solib-pa64.c > could could be combined. Given the precedent, it's okay > to leave that for a follow up. > During the tic6x patches review, Pedro pointed out the duplication of bfd_lookup_symbol cross solib-svr4.c, solib-frv.c and solib-pa64.c. This patch is to remove the duplication. Four instances of bfd_lookup_symbol is not exactly the same, and can be grouped into three 1) solib-svr4.c 2) solib-frv.c and solib-dsbt.c, 3) solib-pa64. In this patch, I split original version into two functions bfd_lookup_symbol_from_symtab and bfd_lookup_symbol_from_dyn_symtab, and move them to solib.c, so that they can be reused easily. A helper function, as a parameter, is introduced to hide the difference on comparing symbol name and checking section flag. There is still minor duplications in this new patch, which is helper function (cmp_name) defined in each solib-{frv,pa64,dsbt}.c respectively. Since I don't want helper_function be visible out of file, so this duplication is acceptable to me. Regression tested x86_64-pc-linux-gnu. OK for mainline? -- Yao (齐尧) --------------030003010304080908070407 Content-Type: text/x-patch; name="0007-combine-bfd_lookup_symbol.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="0007-combine-bfd_lookup_symbol.patch" Content-length: 16436 gdb/ * solib-dsbt.c (bfd_lookup_symbol): Removed. (cmp_name): New. (enable_break2): Update caller. * solib-frv.c (bfd_lookup_symbol): Removed. (cmp_name): New. (enable_break2): Update caller. * solib-pa64.c (bfd_lookup_symbol): Removed. (cmp_name): New. * solib-svr4.c (bfd_lookup_symbol): Removed. (cmp_name_and_sec_flags): New. (enable_break): Update caller. * solib.c (bfd_lookup_symbol_from_symtab): New. (bfd_lookup_symbol_from_dyn_symtab): New. (bfd_lookup_symbol): New. * solib.h: Functions declarations. --- gdb/solib-dsbt.c | 80 +++++----------------------------------------- gdb/solib-frv.c | 82 ++++++----------------------------------------- gdb/solib-pa64.c | 48 +++------------------------ gdb/solib-svr4.c | 91 ++++++----------------------------------------------- gdb/solib.c | 93 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ gdb/solib.h | 12 +++++++ 6 files changed, 140 insertions(+), 266 deletions(-) diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c index 2569395..2922731 100644 --- a/gdb/solib-dsbt.c +++ b/gdb/solib-dsbt.c @@ -508,76 +508,6 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr) return 0; } -/* An expensive way to lookup the value of a single symbol for - bfd's that are only temporary anyway. This is used by the - shared library support to find the address of the debugger - interface structures in the shared library. - - Note that 0 is specifically allowed as an error return (no - such symbol). */ - -static CORE_ADDR -bfd_lookup_symbol (bfd *abfd, char *symname) -{ - long storage_needed; - asymbol *sym; - asymbol **symbol_table; - unsigned int number_of_symbols; - unsigned int i; - struct cleanup *back_to; - CORE_ADDR symaddr = 0; - - storage_needed = bfd_get_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0) - { - /* Bfd symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - if (symaddr) - return symaddr; - - /* Look for the symbol in the dynamic string table too. */ - - storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0) - { - /* Bfd symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - return symaddr; -} - - /* If no open symbol file, attempt to locate and open the main symbol file. @@ -852,6 +782,14 @@ enable_break_failure_warning (void) "and track explicitly loaded dynamic code.")); } +/* Helper function for bfd_lookup_symbol. */ + +static int +cmp_name (asymbol *sym, const char *name) +{ + return (strcmp (sym->name, symname) == 0); +} + /* The dynamic linkers has, as part of its debugger interface, support for arranging for the inferior to hit a breakpoint after mapping in the shared libraries. This function enables that breakpoint. @@ -957,7 +895,7 @@ enable_break2 (void) info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); } - addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr"); + addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr", cmp_name); if (addr == 0) { warning (_("Could not find symbol _dl_debug_addr in dynamic linker")); diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c index e1c16d9..d412b61 100644 --- a/gdb/solib-frv.c +++ b/gdb/solib-frv.c @@ -239,77 +239,6 @@ static void frv_relocate_main_executable (void); static CORE_ADDR main_got (void); static int enable_break2 (void); -/* Lookup the value for a specific symbol. - - An expensive way to lookup the value of a single symbol for - bfd's that are only temporary anyway. This is used by the - shared library support to find the address of the debugger - interface structures in the shared library. - - Note that 0 is specifically allowed as an error return (no - such symbol). */ - -static CORE_ADDR -bfd_lookup_symbol (bfd *abfd, char *symname) -{ - long storage_needed; - asymbol *sym; - asymbol **symbol_table; - unsigned int number_of_symbols; - unsigned int i; - struct cleanup *back_to; - CORE_ADDR symaddr = 0; - - storage_needed = bfd_get_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0) - { - /* Bfd symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - if (symaddr) - return symaddr; - - /* Look for the symbol in the dynamic string table too. */ - - storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0) - { - /* Bfd symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - return symaddr; -} - /* Implement the "open_symbol_file_object" target_so_ops method. */ static int @@ -554,6 +483,14 @@ enable_break_failure_warning (void) "and track explicitly loaded dynamic code.")); } +/* Helper function for bfd_lookup_symbol. */ + +static int +cmp_name (asymbol *sym, const char *name) +{ + return (strcmp (sym->name, name) == 0); +} + /* Arrange for dynamic linker to hit breakpoint. The dynamic linkers has, as part of its debugger interface, support @@ -680,7 +617,8 @@ enable_break2 (void) interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect); } - addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr"); + addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr", cmp_name); + if (addr == 0) { warning (_("Could not find symbol _dl_debug_addr " diff --git a/gdb/solib-pa64.c b/gdb/solib-pa64.c index cd38728..83e179d 100644 --- a/gdb/solib-pa64.c +++ b/gdb/solib-pa64.c @@ -269,51 +269,14 @@ read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p) return 1; } -/* bfd_lookup_symbol -- lookup the value for a specific symbol +/* Helper function for bfd_lookup_symbol_from_symtab. */ - An expensive way to lookup the value of a single symbol for - bfd's that are only temporary anyway. This is used by the - shared library support to find the address of the debugger - interface structures in the shared library. - - Note that 0 is specifically allowed as an error return (no - such symbol). */ - -static CORE_ADDR -bfd_lookup_symbol (bfd *abfd, char *symname) +static int +cmp_name (asymbol *sym, const char *name) { - unsigned int storage_needed; - asymbol *sym; - asymbol **symbol_table; - unsigned int number_of_symbols; - unsigned int i; - struct cleanup *back_to; - CORE_ADDR symaddr = 0; - - storage_needed = bfd_get_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0) - { - /* Bfd symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - return (symaddr); + return (strcmp (sym->name, symname) == 0); } - /* This hook gets called just before the first instruction in the inferior process is executed. @@ -421,7 +384,8 @@ manpage for methods to privately map shared library text.")); routine. */ load_addr = regcache_read_pc (get_current_regcache ()) - tmp_bfd->start_address; - sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break"); + sym_addr = bfd_lookup_symbol_from_symtab (tmp_bfd, "__dld_break", + cmp_name); sym_addr = load_addr + sym_addr + 4; /* Create the shared library breakpoint. */ diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index f643a24..d199af4 100644 --- a/gdb/solib-svr4.c +++ b/gdb/solib-svr4.c @@ -370,86 +370,6 @@ get_svr4_info (void) static int match_main (const char *); -/* Lookup the value for a specific symbol. - - An expensive way to lookup the value of a single symbol for - bfd's that are only temporary anyway. This is used by the - shared library support to find the address of the debugger - notification routine in the shared library. - - The returned symbol may be in a code or data section; functions - will normally be in a code section, but may be in a data section - if this architecture uses function descriptors. - - Note that 0 is specifically allowed as an error return (no - such symbol). */ - -static CORE_ADDR -bfd_lookup_symbol (bfd *abfd, const char *symname) -{ - long storage_needed; - asymbol *sym; - asymbol **symbol_table; - unsigned int number_of_symbols; - unsigned int i; - struct cleanup *back_to; - CORE_ADDR symaddr = 0; - - storage_needed = bfd_get_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - if (strcmp (sym->name, symname) == 0 - && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0) - { - /* BFD symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - if (symaddr) - return symaddr; - - /* On FreeBSD, the dynamic linker is stripped by default. So we'll - have to check the dynamic string table too. */ - - storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); - - if (storage_needed > 0) - { - symbol_table = (asymbol **) xmalloc (storage_needed); - back_to = make_cleanup (xfree, symbol_table); - number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table); - - for (i = 0; i < number_of_symbols; i++) - { - sym = *symbol_table++; - - if (strcmp (sym->name, symname) == 0 - && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0) - { - /* BFD symbols are section relative. */ - symaddr = sym->value + sym->section->vma; - break; - } - } - do_cleanups (back_to); - } - - return symaddr; -} - - /* Read program header TYPE from inferior memory. The header is found by scanning the OS auxillary vector. @@ -1253,6 +1173,14 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ) targ); } +/* Helper function for bfd_lookup_symbol. */ + +static int +cmp_name_and_sec_flags (asymbol *sym, const char *name) +{ + return (strcmp (sym->name, name) == 0 + && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0); +} /* Arrange for dynamic linker to hit breakpoint. Both the SunOS and the SVR4 dynamic linkers have, as part of their @@ -1501,7 +1429,8 @@ enable_break (struct svr4_info *info, int from_tty) /* Now try to set a breakpoint in the dynamic linker. */ for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++) { - sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep); + sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, + cmp_name_and_sec_flags); if (sym_addr != 0) break; } diff --git a/gdb/solib.c b/gdb/solib.c index f843723..9fffa49 100644 --- a/gdb/solib.c +++ b/gdb/solib.c @@ -1336,6 +1336,99 @@ solib_global_lookup (const struct objfile *objfile, return NULL; } +CORE_ADDR +bfd_lookup_symbol_from_symtab (bfd *abfd, const char *symname, + int (*is_right_sym) (asymbol *, const char *)) +{ + long storage_needed = bfd_get_symtab_upper_bound (abfd); + CORE_ADDR symaddr = 0; + + if (storage_needed > 0) + { + unsigned int i; + + asymbol **symbol_table = (asymbol **) xmalloc (storage_needed); + struct cleanup *back_to = make_cleanup (xfree, symbol_table); + unsigned int number_of_symbols = + bfd_canonicalize_symtab (abfd, symbol_table); + + for (i = 0; i < number_of_symbols; i++) + { + asymbol *sym = *symbol_table++; + + if (is_right_sym (sym, symname)) + { + /* BFD symbols are section relative. */ + symaddr = sym->value + sym->section->vma; + break; + } + } + do_cleanups (back_to); + } + + return symaddr; +} + +static CORE_ADDR +bfd_lookup_symbol_from_dyn_symtab (bfd *abfd, const char *symname, + int (*is_right_sym) (asymbol *, + const char *)) +{ + long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd); + CORE_ADDR symaddr = 0; + + if (storage_needed > 0) + { + unsigned int i; + asymbol **symbol_table = (asymbol **) xmalloc (storage_needed); + struct cleanup *back_to = make_cleanup (xfree, symbol_table); + unsigned int number_of_symbols = + bfd_canonicalize_dynamic_symtab (abfd, symbol_table); + + for (i = 0; i < number_of_symbols; i++) + { + asymbol *sym = *symbol_table++; + + if (is_right_sym (sym, symname)) + { + /* BFD symbols are section relative. */ + symaddr = sym->value + sym->section->vma; + break; + } + } + do_cleanups (back_to); + } + return symaddr; +} + +/* Lookup the value for a specific symbol. + + An expensive way to lookup the value of a single symbol for + bfd's that are only temporary anyway. This is used by the + shared library support to find the address of the debugger + notification routine in the shared library. + + The returned symbol may be in a code or data section; functions + will normally be in a code section, but may be in a data section + if this architecture uses function descriptors. + + Note that 0 is specifically allowed as an error return (no + such symbol). */ + +CORE_ADDR +bfd_lookup_symbol (bfd *abfd, const char *symname, + int (*is_right_sym) (asymbol *, const char *)) +{ + CORE_ADDR symaddr = bfd_lookup_symbol_from_symtab (abfd, symname, + is_right_sym); + + /* On FreeBSD, the dynamic linker is stripped by default. So we'll + have to check the dynamic string table too. */ + if (symaddr == 0) + symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, symname, is_right_sym); + + return symaddr; +} extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */ diff --git a/gdb/solib.h b/gdb/solib.h index c473d85..4e788f8 100644 --- a/gdb/solib.h +++ b/gdb/solib.h @@ -78,4 +78,16 @@ extern void set_solib_ops (struct gdbarch *gdbarch, extern int libpthread_name_p (const char *name); +/* Look up symbol from both symbol table and dynamic string table. */ + +extern CORE_ADDR bfd_lookup_symbol (bfd *abfd, const char *symname, + int (*is_right_sym) (asymbol *, + const char *)); + +/* Look up symbol from symbol table. */ + +extern CORE_ADDR bfd_lookup_symbol_from_symtab (bfd *abfd, const char *symname, + int (*is_right_sym) (asymbol *, + const char *)); + #endif /* SOLIB_H */ -- 1.7.0.4 --------------030003010304080908070407--