From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 15963 invoked by alias); 17 Oct 2013 17:50:00 -0000 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 Received: (qmail 15857 invoked by uid 89); 17 Oct 2013 17:50:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.9 required=5.0 tests=AWL,BAYES_00,KAM_STOCKGEN,RP_MATCHES_RCVD,SPF_HELO_PASS,SPF_PASS autolearn=no version=3.3.2 X-HELO: mx1.redhat.com Received: from mx1.redhat.com (HELO mx1.redhat.com) (209.132.183.28) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 17 Oct 2013 17:49:59 +0000 Received: from int-mx10.intmail.prod.int.phx2.redhat.com (int-mx10.intmail.prod.int.phx2.redhat.com [10.5.11.23]) by mx1.redhat.com (8.14.4/8.14.4) with ESMTP id r9HHnwTn019113 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-SHA bits=256 verify=OK) for ; Thu, 17 Oct 2013 13:49:58 -0400 Received: from barimba.redhat.com (ovpn-113-54.phx2.redhat.com [10.3.113.54]) by int-mx10.intmail.prod.int.phx2.redhat.com (8.14.4/8.14.4) with ESMTP id r9HHnvEn021105; Thu, 17 Oct 2013 13:49:57 -0400 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH v2 1/9] introduce minimal_symbol_upper_bound Date: Thu, 17 Oct 2013 17:50:00 -0000 Message-Id: <1382032193-9115-2-git-send-email-tromey@redhat.com> In-Reply-To: <1382032193-9115-1-git-send-email-tromey@redhat.com> References: <1382032193-9115-1-git-send-email-tromey@redhat.com> X-SW-Source: 2013-10/txt/msg00523.txt.bz2 This introduces minimal_symbol_upper_bound and changes various bits of code to use it. Since this function is intimately tied to the implementation of minimal symbol tables, I believe it belongs in minsyms.c. The new function is extracted from find_pc_partial_function_gnu_ifunc. This isn't a "clean" move because the old function interleaved the caching and the computation; but this doesn't make sense for the new code. * blockframe.c (find_pc_partial_function_gnu_ifunc): Use bound minimal symbols. Move code that knows about minsym table layout... * minsyms.c (minimal_symbol_upper_bound): ... here. New function. * minsyms.h (minimal_symbol_upper_bound): Declare. * objc-lang.c (find_objc_msgsend): Use bound minimal symbols, minimal_symbol_upper_bound. --- gdb/blockframe.c | 54 ++++++++++++------------------------------------------ gdb/minsyms.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ gdb/minsyms.h | 5 +++++ gdb/objc-lang.c | 16 +++++++--------- 4 files changed, 69 insertions(+), 51 deletions(-) diff --git a/gdb/blockframe.c b/gdb/blockframe.c index 2cf54c3..10b7816 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -195,7 +195,7 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name, { struct obj_section *section; struct symbol *f; - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; struct symtab *symtab = NULL; struct objfile *objfile; int i; @@ -217,11 +217,11 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name, && section == cache_pc_function_section) goto return_cached_value; - msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section).minsym; + msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section); ALL_OBJFILES (objfile) { if (objfile->sf) - symtab = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol, + symtab = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol.minsym, mapped_pc, section, 0); if (symtab) break; @@ -233,9 +233,9 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name, "pathological" case mentioned in print_frame_info. */ f = find_pc_sect_function (mapped_pc, section); if (f != NULL - && (msymbol == NULL + && (msymbol.minsym == NULL || (BLOCK_START (SYMBOL_BLOCK_VALUE (f)) - >= SYMBOL_VALUE_ADDRESS (msymbol)))) + >= SYMBOL_VALUE_ADDRESS (msymbol.minsym)))) { cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f)); cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f)); @@ -252,10 +252,10 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name, last function in the text segment. */ if (!section) - msymbol = NULL; + msymbol.minsym = NULL; /* Must be in the minimal symbol table. */ - if (msymbol == NULL) + if (msymbol.minsym == NULL) { /* No available symbol. */ if (name != NULL) @@ -269,42 +269,12 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name, return 0; } - cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol); - cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol); + cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol.minsym); + cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol.minsym); cache_pc_function_section = section; - cache_pc_function_is_gnu_ifunc = MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc; - - /* If the minimal symbol has a size, use it for the cache. - Otherwise use the lesser of the next minimal symbol in the same - section, or the end of the section, as the end of the - function. */ - - if (MSYMBOL_SIZE (msymbol) != 0) - cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol); - else - { - /* Step over other symbols at this same address, and symbols in - other sections, to find the next symbol in this section with - a different address. */ - - for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) - { - if (SYMBOL_VALUE_ADDRESS (msymbol + i) - != SYMBOL_VALUE_ADDRESS (msymbol) - && SYMBOL_SECTION (msymbol + i) - == SYMBOL_SECTION (msymbol)) - break; - } - - if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL - && SYMBOL_VALUE_ADDRESS (msymbol + i) - < obj_section_endaddr (section)) - cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i); - else - /* We got the start address from the last msymbol in the objfile. - So the end address is the end of the section. */ - cache_pc_function_high = obj_section_endaddr (section); - } + cache_pc_function_is_gnu_ifunc = (MSYMBOL_TYPE (msymbol.minsym) + == mst_text_gnu_ifunc); + cache_pc_function_high = minimal_symbol_upper_bound (msymbol); return_cached_value: diff --git a/gdb/minsyms.c b/gdb/minsyms.c index 95dd6cf..97c31c6 100644 --- a/gdb/minsyms.c +++ b/gdb/minsyms.c @@ -1360,3 +1360,48 @@ find_solib_trampoline_target (struct frame_info *frame, CORE_ADDR pc) } return 0; } + +/* See minsyms.h. */ + +CORE_ADDR +minimal_symbol_upper_bound (struct bound_minimal_symbol minsym) +{ + int i; + short section; + struct obj_section *obj_section; + CORE_ADDR result; + struct minimal_symbol *msymbol; + + gdb_assert (minsym.minsym != NULL); + + /* If the minimal symbol has a size, use it. Otherwise use the + lesser of the next minimal symbol in the same section, or the end + of the section, as the end of the function. */ + + if (MSYMBOL_SIZE (minsym.minsym) != 0) + return SYMBOL_VALUE_ADDRESS (minsym.minsym) + MSYMBOL_SIZE (minsym.minsym); + + /* Step over other symbols at this same address, and symbols in + other sections, to find the next symbol in this section with a + different address. */ + + msymbol = minsym.minsym; + section = SYMBOL_SECTION (msymbol); + for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) + { + if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol) + && SYMBOL_SECTION (msymbol + i) == section) + break; + } + + obj_section = SYMBOL_OBJ_SECTION (minsym.objfile, minsym.minsym); + if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL + && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (obj_section)) + result = SYMBOL_VALUE_ADDRESS (msymbol + i); + else + /* We got the start address from the last msymbol in the objfile. + So the end address is the end of the section. */ + result = obj_section_endaddr (obj_section); + + return result; +} diff --git a/gdb/minsyms.h b/gdb/minsyms.h index 95bbdc5..e1562d5 100644 --- a/gdb/minsyms.h +++ b/gdb/minsyms.h @@ -249,4 +249,9 @@ void iterate_over_minimal_symbols (struct objfile *objf, void *), void *user_data); +/* Try to compute the upper bound of MINSYM. The upper bound is the + last address thought to be part of the symbol. */ + +CORE_ADDR minimal_symbol_upper_bound (struct bound_minimal_symbol minsym); + #endif /* MINSYMS_H */ diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c index bcce435..1b3968f 100644 --- a/gdb/objc-lang.c +++ b/gdb/objc-lang.c @@ -1252,25 +1252,23 @@ find_objc_msgsend (void) for (i = 0; i < nmethcalls; i++) { - struct minimal_symbol *func; + struct bound_minimal_symbol func; /* Try both with and without underscore. */ - func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL); - if ((func == NULL) && (methcalls[i].name[0] == '_')) + func = lookup_bound_minimal_symbol (methcalls[i].name); + if ((func.minsym == NULL) && (methcalls[i].name[0] == '_')) { - func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL); + func = lookup_bound_minimal_symbol (methcalls[i].name + 1); } - if (func == NULL) + if (func.minsym == NULL) { methcalls[i].begin = 0; methcalls[i].end = 0; continue; } - methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func); - do { - methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func); - } while (methcalls[i].begin == methcalls[i].end); + methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func.minsym); + methcalls[i].end = minimal_symbol_upper_bound (func); } } -- 1.8.1.4