From patchwork Tue Oct 1 17:33:45 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Terekhov, Mikhail via Gdb-patches" X-Patchwork-Id: 34766 Received: (qmail 87591 invoked by alias); 1 Oct 2019 17:33:55 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 87583 invoked by uid 89); 1 Oct 2019 17:33:54 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-21.7 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_PASS, T_FILL_THIS_FORM_SHORT autolearn=ham version=3.3.1 spammy= X-HELO: mail-yb1-f202.google.com Received: from mail-yb1-f202.google.com (HELO mail-yb1-f202.google.com) (209.85.219.202) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 01 Oct 2019 17:33:50 +0000 Received: by mail-yb1-f202.google.com with SMTP id s19so13863975ybg.21 for ; Tue, 01 Oct 2019 10:33:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=sSPfBqXN2JdpU18COdAhSTG7znxzBky8kexIIOWgVDc=; b=U8n9n3gw2P11i0vR41sige8mh1n8ZbWU1jREtPvASdKGGmC2Xb3Q+Zfz95SpVv1JlM jqlgwlBT2LYGO4N7sNUMMobLwCU0lLFKbIFhmS8uKjgtKssH2PVoii+x+Cklz4YaNhxh FqFEnHKEkqWZZbzvsrkpNHD6qF8mR7aGYeBaZBvp7usFQA+TZX8zR8ImqK5FCVfgstl0 7icQjFPPdgCM1gpHRBLy2PCD0dt/GAuB6uJBC31/47Qdaf3bPjfRaxjNZQqdkFN/opFC XkxeJp2/0PEibiiiV69OfCHXcYDXn57A46WpU+z10+oQcq2uj1OfGEPPMBa+k+pCwByB 5bVA== Date: Tue, 1 Oct 2019 12:33:45 -0500 In-Reply-To: Message-Id: <20191001173345.48753-1-cbiesinger@google.com> Mime-Version: 1.0 References: Subject: [PATCH] Change some arguments to gdb::string_view instead of name+len X-Patchwork-Original-From: "Christian Biesinger via gdb-patches" From: "Terekhov, Mikhail via Gdb-patches" Reply-To: Christian Biesinger To: gdb-patches@sourceware.org Cc: Christian Biesinger X-IsSubscribed: yes [Let me try this again, this time after I commit the changes. Fixes tromey's comment about accessing [length] on a string view] Just some code cleanup. This change has a few benefits: - Shorter argument list in the functions - If the caller needs to calculate the string, they no longer need to explicitly call strlen - It is easy to pass std::string to this (done in one place currently) This also updates a couple of places that were passing 0/1 to a bool parameter. gdb/ChangeLog: 2019-09-29 Christian Biesinger * coffread.c (record_minimal_symbol): Update. (process_coff_symbol): Update. * dbxread.c (read_dbx_symtab): Update. * dwarf2read.c (add_partial_symbol): Update. (fixup_go_packaging): Update. (load_partial_dies): Update. (new_symbol): Update. * elfread.c (record_minimal_symbol): Update. * mdebugread.c (parse_partial_symbols): Update. (handle_psymbol_enumerators): Update. (new_symbol): Update. * minsyms.c (minimal_symbol_reader::record_full): Change signature to use gdb::string_view instead of name+len. * minsyms.h (class minimal_symbol_reader) : Likewise. * psympriv.h (add_psymbol_to_list): Likewise. * psymtab.c (add_psymbol_to_bcache): Likewise. (add_psymbol_to_list): Likewise. * stabsread.c (define_symbol): Update. * symtab.c (symbol_set_names): Change signature to use gdb::string_view. * symtab.h (SYMBOL_SET_NAMES): Likewise. (symbol_set_names): Likewise. * xcoffread.c (scan_xcoff_symtab): Update. --- gdb/coffread.c | 5 ++- gdb/dbxread.c | 24 +++++++-------- gdb/dwarf2read.c | 29 +++++++++--------- gdb/elfread.c | 4 +-- gdb/mdebugread.c | 80 ++++++++++++++++++++++++++---------------------- gdb/minsyms.c | 20 ++++++------ gdb/minsyms.h | 10 +++--- gdb/psympriv.h | 16 +++++----- gdb/psymtab.c | 8 ++--- gdb/stabsread.c | 5 +-- gdb/symtab.c | 28 +++++++++-------- gdb/symtab.h | 7 +++-- gdb/xcoffread.c | 42 +++++++++++++++---------- 13 files changed, 145 insertions(+), 133 deletions(-) diff --git a/gdb/coffread.c b/gdb/coffread.c index c44b69069e..52b9c57b9c 100644 --- a/gdb/coffread.c +++ b/gdb/coffread.c @@ -462,8 +462,7 @@ record_minimal_symbol (minimal_symbol_reader &reader, return NULL; } - return reader.record_full (cs->c_name, strlen (cs->c_name), true, address, - type, section); + return reader.record_full (cs->c_name, true, address, type, section); } /* coff_symfile_init () @@ -1569,7 +1568,7 @@ process_coff_symbol (struct coff_symbol *cs, name = EXTERNAL_NAME (name, objfile->obfd); SYMBOL_SET_LANGUAGE (sym, get_current_subfile ()->language, &objfile->objfile_obstack); - SYMBOL_SET_NAMES (sym, name, strlen (name), 1, objfile); + SYMBOL_SET_NAMES (sym, name, true, objfile); /* default assumptions */ SYMBOL_VALUE (sym) = cs->c_value; diff --git a/gdb/dbxread.c b/gdb/dbxread.c index 564c5d3a41..16727ef108 100644 --- a/gdb/dbxread.c +++ b/gdb/dbxread.c @@ -1464,7 +1464,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) if (gdbarch_static_transform_name_p (gdbarch)) gdbarch_static_transform_name (gdbarch, namestring); - add_psymbol_to_list (sym_name, sym_len, true, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true, VAR_DOMAIN, LOC_STATIC, data_sect_index, psymbol_placement::STATIC, @@ -1474,7 +1474,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) case 'G': /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ - add_psymbol_to_list (sym_name, sym_len, true, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true, VAR_DOMAIN, LOC_STATIC, data_sect_index, psymbol_placement::GLOBAL, @@ -1492,15 +1492,15 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list (sym_name, sym_len, true, - STRUCT_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), + true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ - add_psymbol_to_list (sym_name, sym_len, true, - VAR_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); p += 1; @@ -1511,8 +1511,8 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) case 't': if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list (sym_name, sym_len, true, - VAR_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); } @@ -1572,7 +1572,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) ; /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (p, q - p, true, + add_psymbol_to_list (gdb::string_view (p, q - p), true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -1590,7 +1590,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (sym_name, sym_len, true, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -1645,7 +1645,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) pst->set_text_low (nlist.n_value); textlow_not_set = 0; } - add_psymbol_to_list (sym_name, sym_len, true, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::STATIC, @@ -1704,7 +1704,7 @@ read_dbx_symtab (minimal_symbol_reader &reader, struct objfile *objfile) pst->set_text_low (nlist.n_value); textlow_not_set = 0; } - add_psymbol_to_list (sym_name, sym_len, true, + add_psymbol_to_list (gdb::string_view (sym_name, sym_len), true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::GLOBAL, diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 1052501c35..ff0fc7a06a 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -8922,7 +8922,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) of the global scope. But in Ada, we want to be able to access nested procedures globally. So all Ada subprograms are stored in the global scope. */ - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), @@ -8932,7 +8932,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) } else { - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), @@ -8944,7 +8944,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) set_objfile_main_name (objfile, actual_name, cu->language); break; case DW_TAG_constant: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, -1, (pdi->is_external ? psymbol_placement::GLOBAL @@ -8980,7 +8980,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) table building. */ if (pdi->d.locdesc || pdi->has_type) - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, SECT_OFF_TEXT (objfile), @@ -8999,7 +8999,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) return; } - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_STATIC, SECT_OFF_TEXT (objfile), @@ -9011,7 +9011,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) case DW_TAG_typedef: case DW_TAG_base_type: case DW_TAG_subrange_type: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, @@ -9019,7 +9019,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) break; case DW_TAG_imported_declaration: case DW_TAG_namespace: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::GLOBAL, @@ -9030,7 +9030,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) available without any name. If so, we skip the module as it doesn't bring any value. */ if (actual_name != nullptr) - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, MODULE_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::GLOBAL, @@ -9054,7 +9054,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) /* NOTE: carlton/2003-10-07: See comment in new_symbol about static vs. global. */ - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, STRUCT_DOMAIN, LOC_TYPEDEF, -1, cu->language == language_cplus @@ -9064,7 +9064,7 @@ add_partial_symbol (struct partial_die_info *pdi, struct dwarf2_cu *cu) break; case DW_TAG_enumerator: - add_psymbol_to_list (actual_name, strlen (actual_name), + add_psymbol_to_list (actual_name, built_actual_name != NULL, VAR_DOMAIN, LOC_CONST, -1, cu->language == language_cplus @@ -9888,8 +9888,7 @@ fixup_go_packaging (struct dwarf2_cu *cu) sym = allocate_symbol (objfile); SYMBOL_SET_LANGUAGE (sym, language_go, &objfile->objfile_obstack); - SYMBOL_SET_NAMES (sym, saved_package_name, - strlen (saved_package_name), 0, objfile); + SYMBOL_SET_NAMES (sym, saved_package_name, false, objfile); /* This is not VAR_DOMAIN because we want a way to ensure a lookup of, e.g., "main" finds the "main" module and not C's main(). */ SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; @@ -18533,7 +18532,7 @@ load_partial_dies (const struct die_reader_specs *reader, || pdi.tag == DW_TAG_subrange_type)) { if (building_psymtab && pdi.name != NULL) - add_psymbol_to_list (pdi.name, strlen (pdi.name), false, + add_psymbol_to_list (pdi.name, false, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, cu->language, objfile); @@ -18567,7 +18566,7 @@ load_partial_dies (const struct die_reader_specs *reader, if (pdi.name == NULL) complaint (_("malformed enumerator DIE ignored")); else if (building_psymtab) - add_psymbol_to_list (pdi.name, strlen (pdi.name), false, + add_psymbol_to_list (pdi.name, false, VAR_DOMAIN, LOC_CONST, -1, cu->language == language_cplus ? psymbol_placement::GLOBAL @@ -21551,7 +21550,7 @@ new_symbol (struct die_info *die, struct type *type, struct dwarf2_cu *cu, /* Cache this symbol's name and the name's demangled form (if any). */ SYMBOL_SET_LANGUAGE (sym, cu->language, &objfile->objfile_obstack); linkagename = dwarf2_physname (name, die, cu); - SYMBOL_SET_NAMES (sym, linkagename, strlen (linkagename), 0, objfile); + SYMBOL_SET_NAMES (sym, linkagename, false, objfile); /* Fortran does not have mangling standard and the mangling does differ between gfortran, iFort etc. */ diff --git a/gdb/elfread.c b/gdb/elfread.c index a3d17e54a2..04b36d3dba 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -203,8 +203,8 @@ record_minimal_symbol (minimal_symbol_reader &reader, || ms_type == mst_text_gnu_ifunc) address = gdbarch_addr_bits_remove (gdbarch, address); - return reader.record_full (name, name_len, copy_name, address, - ms_type, + return reader.record_full (gdb::string_view (name, name_len), copy_name, + address, ms_type, gdb_bfd_section_index (objfile->obfd, bfd_section)); } diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c index 0956fbdb67..5921251f65 100644 --- a/gdb/mdebugread.c +++ b/gdb/mdebugread.c @@ -3048,8 +3048,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, namestring = gdbarch_static_transform_name (gdbarch, namestring); - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::STATIC, sh.value, @@ -3059,8 +3060,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::GLOBAL, sh.value, @@ -3078,21 +3080,20 @@ parse_partial_symbols (minimal_symbol_reader &reader, || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list (namestring, p - namestring, true, - STRUCT_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + add_psymbol_to_list + (gdb::string_view (namestring, p - namestring), + true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, psymtab_language, + objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, - p - namestring, true, - VAR_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, - objfile); + add_psymbol_to_list + (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, + psymtab_language, objfile); p += 1; } } @@ -3101,11 +3102,12 @@ parse_partial_symbols (minimal_symbol_reader &reader, if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list (namestring, p - namestring, - true, VAR_DOMAIN, LOC_TYPEDEF, - -1, - psymbol_placement::STATIC, - 0, psymtab_language, objfile); + add_psymbol_to_list + (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, + psymbol_placement::STATIC, 0, psymtab_language, + objfile); } check_enum: /* If this is an enumerated type, we need to add @@ -3166,9 +3168,10 @@ parse_partial_symbols (minimal_symbol_reader &reader, /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (p, q - p, true, - VAR_DOMAIN, LOC_CONST, - -1, + add_psymbol_to_list (gdb::string_view (p, + q - p), + true, VAR_DOMAIN, + LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -3185,8 +3188,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_CONST, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); continue; @@ -3198,8 +3202,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::STATIC, sh.value, @@ -3217,8 +3222,9 @@ parse_partial_symbols (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (copy.c_str ()); } - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::GLOBAL, sh.value, @@ -3452,13 +3458,13 @@ parse_partial_symbols (minimal_symbol_reader &reader, symbol table, and the MAIN__ symbol via the minimal symbol table. */ if (sh.st == stProc) - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, LOC_BLOCK, section, psymbol_placement::GLOBAL, sh.value, psymtab_language, objfile); else - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, LOC_BLOCK, section, psymbol_placement::STATIC, @@ -3525,7 +3531,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, && sh.iss != 0 && sh.index != cur_sdx + 2) { - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -3565,7 +3571,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, continue; } /* Use this gdb symbol. */ - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, theclass, section, psymbol_placement::STATIC, sh.value, psymtab_language, objfile); @@ -3644,7 +3650,7 @@ parse_partial_symbols (minimal_symbol_reader &reader, break; } char *sym_name = debug_info->ssext + psh->iss; - add_psymbol_to_list (sym_name, strlen (sym_name), true, + add_psymbol_to_list (sym_name, true, VAR_DOMAIN, theclass, section, psymbol_placement::GLOBAL, @@ -3807,7 +3813,7 @@ handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (name, strlen (name), true, + add_psymbol_to_list (name, true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -4758,7 +4764,7 @@ new_symbol (const char *name) SYMBOL_SET_LANGUAGE (s, psymtab_language, &mdebugread_objfile->objfile_obstack); - SYMBOL_SET_NAMES (s, name, strlen (name), 1, mdebugread_objfile); + SYMBOL_SET_NAMES (s, name, true, mdebugread_objfile); return s; } diff --git a/gdb/minsyms.c b/gdb/minsyms.c index 83f5d89577..379877dc26 100644 --- a/gdb/minsyms.c +++ b/gdb/minsyms.c @@ -1063,7 +1063,7 @@ mst_str (minimal_symbol_type t) /* See minsyms.h. */ struct minimal_symbol * -minimal_symbol_reader::record_full (const char *name, int name_len, +minimal_symbol_reader::record_full (gdb::string_view name, bool copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section) @@ -1077,24 +1077,22 @@ minimal_symbol_reader::record_full (const char *name, int name_len, lookup_minimal_symbol_by_pc would have no way of getting the right one. */ if (ms_type == mst_file_text && name[0] == 'g' - && (strcmp (name, GCC_COMPILED_FLAG_SYMBOL) == 0 - || strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)) + && (name == GCC_COMPILED_FLAG_SYMBOL + || name == GCC2_COMPILED_FLAG_SYMBOL)) return (NULL); /* It's safe to strip the leading char here once, since the name is also stored stripped in the minimal symbol table. */ if (name[0] == get_symbol_leading_char (m_objfile->obfd)) - { - ++name; - --name_len; - } + name = name.substr (1); - if (ms_type == mst_file_text && startswith (name, "__gnu_compiled")) + if (ms_type == mst_file_text && startswith (name.data (), "__gnu_compiled")) return (NULL); if (symtab_create_debug >= 2) - printf_unfiltered ("Recording minsym: %-21s %18s %4d %s\n", - mst_str (ms_type), hex_string (address), section, name); + printf_unfiltered ("Recording minsym: %-21s %18s %4d %.*s\n", + mst_str (ms_type), hex_string (address), section, + (int) name.size (), name.data ()); if (m_msym_bunch_index == BUNCH_SIZE) { @@ -1106,7 +1104,7 @@ minimal_symbol_reader::record_full (const char *name, int name_len, msymbol = &m_msym_bunch->contents[m_msym_bunch_index]; symbol_set_language (msymbol, language_auto, &m_objfile->per_bfd->storage_obstack); - symbol_set_names (msymbol, name, name_len, copy_name, m_objfile->per_bfd); + symbol_set_names (msymbol, name, copy_name, m_objfile->per_bfd); SET_MSYMBOL_VALUE_ADDRESS (msymbol, address); MSYMBOL_SECTION (msymbol) = section; diff --git a/gdb/minsyms.h b/gdb/minsyms.h index ce4b83d544..f62a2b9914 100644 --- a/gdb/minsyms.h +++ b/gdb/minsyms.h @@ -88,7 +88,6 @@ class minimal_symbol_reader Arguments are: NAME - the symbol's name - NAME_LEN - the length of the name COPY_NAME - if true, the minsym code must make a copy of NAME. If false, then NAME must be NUL-terminated, and must have a lifetime that is at least as long as OBJFILE's lifetime. @@ -97,15 +96,14 @@ class minimal_symbol_reader SECTION - the symbol's section */ - struct minimal_symbol *record_full (const char *name, - int name_len, + struct minimal_symbol *record_full (gdb::string_view name, bool copy_name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section); /* Like record_full, but: - - uses strlen to compute NAME_LEN, + - computes the length of NAME - passes COPY_NAME = true, - and passes a default SECTION, depending on the type @@ -115,7 +113,7 @@ class minimal_symbol_reader enum minimal_symbol_type ms_type); /* Like record_full, but: - - uses strlen to compute NAME_LEN, + - computes the length of NAME - passes COPY_NAME = true. This variant does not return the new symbol. */ @@ -124,7 +122,7 @@ class minimal_symbol_reader enum minimal_symbol_type ms_type, int section) { - record_full (name, strlen (name), true, address, ms_type, section); + record_full (name, true, address, ms_type, section); } private: diff --git a/gdb/psympriv.h b/gdb/psympriv.h index 3e89742d8d..9404c46837 100644 --- a/gdb/psympriv.h +++ b/gdb/psympriv.h @@ -22,6 +22,7 @@ #include "psymtab.h" #include "objfiles.h" +#include "gdbsupport/gdb_string_view.h" /* A partial_symbol records the name, domain, and address class of symbols whose types we have not parsed yet. For functions, it also @@ -304,14 +305,13 @@ enum class psymbol_placement LANGUAGE is the language from which the symbol originates. This will influence, amongst other things, how the symbol name is demangled. */ -extern void add_psymbol_to_list (const char *name, int namelength, - bool copy_name, domain_enum domain, - enum address_class theclass, - short section, - psymbol_placement where, - CORE_ADDR coreaddr, - enum language language, - struct objfile *objfile); +extern void add_psymbol_to_list (gdb::string_view, + bool, domain_enum, + enum address_class, + short /* section */, + enum psymbol_placement, + CORE_ADDR, + enum language, struct objfile *); /* Initialize storage for partial symbols. If partial symbol storage has already been initialized, this does nothing. TOTAL_SYMBOLS is diff --git a/gdb/psymtab.c b/gdb/psymtab.c index 31b6d59777..b30d29e6ef 100644 --- a/gdb/psymtab.c +++ b/gdb/psymtab.c @@ -1568,7 +1568,7 @@ psymbol_compare (const void *addr1, const void *addr2, int length) different domain (or address) is possible and correct. */ static struct partial_symbol * -add_psymbol_to_bcache (const char *name, int namelength, bool copy_name, +add_psymbol_to_bcache (gdb::string_view name, bool copy_name, domain_enum domain, enum address_class theclass, short section, @@ -1585,7 +1585,7 @@ add_psymbol_to_bcache (const char *name, int namelength, bool copy_name, psymbol.aclass = theclass; symbol_set_language (&psymbol.ginfo, language, objfile->partial_symtabs->obstack ()); - symbol_set_names (&psymbol.ginfo, name, namelength, copy_name, + symbol_set_names (&psymbol.ginfo, name, copy_name, objfile->per_bfd); /* Stash the partial symbol away in the cache. */ @@ -1608,7 +1608,7 @@ append_psymbol_to_list (std::vector *list, /* See psympriv.h. */ void -add_psymbol_to_list (const char *name, int namelength, bool copy_name, +add_psymbol_to_list (gdb::string_view name, bool copy_name, domain_enum domain, enum address_class theclass, short section, @@ -1621,7 +1621,7 @@ add_psymbol_to_list (const char *name, int namelength, bool copy_name, int added; /* Stash the partial symbol away in the cache. */ - psym = add_psymbol_to_bcache (name, namelength, copy_name, domain, theclass, + psym = add_psymbol_to_bcache (name, copy_name, domain, theclass, section, coreaddr, language, objfile, &added); /* Do not duplicate global partial symbols. */ diff --git a/gdb/stabsread.c b/gdb/stabsread.c index 48c88ded55..d8cb4a5264 100644 --- a/gdb/stabsread.c +++ b/gdb/stabsread.c @@ -751,11 +751,12 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type, if (!new_name.empty ()) { SYMBOL_SET_NAMES (sym, - new_name.c_str (), new_name.length (), + new_name, 1, objfile); } else - SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile); + SYMBOL_SET_NAMES (sym, gdb::string_view (string, p - string), true, + objfile); if (SYMBOL_LANGUAGE (sym) == language_cplus) cp_scan_for_anonymous_namespaces (get_buildsym_compunit (), sym, diff --git a/gdb/symtab.c b/gdb/symtab.c index 6ea9fc6971..25f714a0f4 100644 --- a/gdb/symtab.c +++ b/gdb/symtab.c @@ -811,7 +811,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol, void symbol_set_names (struct general_symbol_info *gsymbol, - const char *linkage_name, int len, bool copy_name, + gdb::string_view linkage_name, bool copy_name, struct objfile_per_bfd_storage *per_bfd) { struct demangled_name_entry **slot; @@ -824,14 +824,14 @@ symbol_set_names (struct general_symbol_info *gsymbol, /* In Ada, we do the symbol lookups using the mangled name, so we can save some space by not storing the demangled name. */ if (!copy_name) - gsymbol->name = linkage_name; + gsymbol->name = linkage_name.data (); else { char *name = (char *) obstack_alloc (&per_bfd->storage_obstack, - len + 1); + linkage_name.length () + 1); - memcpy (name, linkage_name, len); - name[len] = '\0'; + memcpy (name, linkage_name.data (), linkage_name.length ()); + name[linkage_name.length ()] = '\0'; gsymbol->name = name; } symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack); @@ -842,18 +842,20 @@ symbol_set_names (struct general_symbol_info *gsymbol, if (per_bfd->demangled_names_hash == NULL) create_demangled_names_hash (per_bfd); - if (linkage_name[len] != '\0') + /* Don't use string_view::operator[] because we are accessing beyond + the size of the string_view, which is technically unsupported. */ + if (linkage_name.data ()[linkage_name.length ()] != '\0') { char *alloc_name; - alloc_name = (char *) alloca (len + 1); - memcpy (alloc_name, linkage_name, len); - alloc_name[len] = '\0'; + alloc_name = (char *) alloca (linkage_name.length () + 1); + memcpy (alloc_name, linkage_name.data (), linkage_name.length ()); + alloc_name[linkage_name.length ()] = '\0'; linkage_name_copy = alloc_name; } else - linkage_name_copy = linkage_name; + linkage_name_copy = linkage_name.data (); entry.mangled = linkage_name_copy; slot = ((struct demangled_name_entry **) @@ -881,14 +883,14 @@ symbol_set_names (struct general_symbol_info *gsymbol, It turns out that it is actually important to still save such an entry in the hash table, because storing this name gives us better bcache hit rates for partial symbols. */ - if (!copy_name && linkage_name_copy == linkage_name) + if (!copy_name && linkage_name_copy == linkage_name.data ()) { *slot = ((struct demangled_name_entry *) obstack_alloc (&per_bfd->storage_obstack, offsetof (struct demangled_name_entry, demangled) + demangled_len + 1)); - (*slot)->mangled = linkage_name; + (*slot)->mangled = linkage_name.data (); } else { @@ -901,7 +903,7 @@ symbol_set_names (struct general_symbol_info *gsymbol, = ((struct demangled_name_entry *) obstack_alloc (&per_bfd->storage_obstack, offsetof (struct demangled_name_entry, demangled) - + len + demangled_len + 2)); + + linkage_name.length () + demangled_len + 2)); mangled_ptr = &((*slot)->demangled[demangled_len + 1]); strcpy (mangled_ptr, linkage_name_copy); (*slot)->mangled = mangled_ptr; diff --git a/gdb/symtab.h b/gdb/symtab.h index 1f0fc62a65..1546d83029 100644 --- a/gdb/symtab.h +++ b/gdb/symtab.h @@ -29,6 +29,7 @@ #include "gdbsupport/enum-flags.h" #include "gdbsupport/function-view.h" #include "gdbsupport/gdb_optional.h" +#include "gdbsupport/gdb_string_view.h" #include "gdbsupport/next-iterator.h" #include "completer.h" @@ -493,11 +494,11 @@ extern void symbol_set_language (struct general_symbol_info *symbol, /* Set the linkage and natural names of a symbol, by demangling the linkage name. */ -#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile) \ - symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, \ +#define SYMBOL_SET_NAMES(symbol,linkage_name,copy_name,objfile) \ + symbol_set_names (&(symbol)->ginfo, linkage_name, copy_name, \ (objfile)->per_bfd) extern void symbol_set_names (struct general_symbol_info *symbol, - const char *linkage_name, int len, bool copy_name, + gdb::string_view linkage_name, bool copy_name, struct objfile_per_bfd_storage *per_bfd); /* Now come lots of name accessor macros. Short version as to when to diff --git a/gdb/xcoffread.c b/gdb/xcoffread.c index 2fa2706653..52a700215d 100644 --- a/gdb/xcoffread.c +++ b/gdb/xcoffread.c @@ -2644,8 +2644,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, namestring = gdbarch_static_transform_name (gdbarch, namestring); - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::STATIC, symbol.n_value, @@ -2655,8 +2656,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, case 'G': /* The addresses in these entries are reported to be wrong. See the code that reads 'G's for symtabs. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_STATIC, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_STATIC, SECT_OFF_DATA (objfile), psymbol_placement::GLOBAL, symbol.n_value, @@ -2674,15 +2676,17 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, || (p == namestring + 1 && namestring[0] != ' ')) { - add_psymbol_to_list (namestring, p - namestring, true, - STRUCT_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, STRUCT_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); if (p[2] == 't') { /* Also a typedef with the same name. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); p += 1; @@ -2693,8 +2697,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, case 't': if (p != namestring) /* a name is there, not just :T... */ { - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_TYPEDEF, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_TYPEDEF, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); } @@ -2755,7 +2760,7 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, ; /* Note that the value doesn't matter for enum constants in psymtabs, just in symtabs. */ - add_psymbol_to_list (p, q - p, true, + add_psymbol_to_list (gdb::string_view (p, q - p), true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); @@ -2773,8 +2778,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, case 'c': /* Constant, e.g. from "const" in Pascal. */ - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_CONST, -1, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_CONST, -1, psymbol_placement::STATIC, 0, psymtab_language, objfile); continue; @@ -2790,8 +2796,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, function_outside_compilation_unit_complaint (name); xfree (name); } - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::STATIC, symbol.n_value, @@ -2820,8 +2827,9 @@ scan_xcoff_symtab (minimal_symbol_reader &reader, if (startswith (namestring, "@FIX")) continue; - add_psymbol_to_list (namestring, p - namestring, true, - VAR_DOMAIN, LOC_BLOCK, + add_psymbol_to_list (gdb::string_view (namestring, + p - namestring), + true, VAR_DOMAIN, LOC_BLOCK, SECT_OFF_TEXT (objfile), psymbol_placement::GLOBAL, symbol.n_value,