From patchwork Mon Nov 27 17:55:59 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Burgess X-Patchwork-Id: 80835 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id A45903861855 for ; Mon, 27 Nov 2023 17:56:54 +0000 (GMT) X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id D0CF53858C35 for ; Mon, 27 Nov 2023 17:56:13 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org D0CF53858C35 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org D0CF53858C35 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701107775; cv=none; b=Yjqp3TBAxgtTx0ID4NSm68WDKkxQwzJL6p4CUWVvKJqh+Tfh10meH9/qPt+qlDZT6uId9G39qX9ZUBNJ+D71g44PBAHaQFDJbeTYPpgXWGOaj2lPHdBFYKe9nTziaqiMRGrHtBdeM9tUtcAn33mJnivxCv0tSsDS9uODXPeylEQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1701107775; c=relaxed/simple; bh=T3S0fJkJWdzGf+YB2k5tMlVlc9C7Icy/vd0jyRDRCr8=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=sC5ohWa0hHobMQ1t5mYGxZEyD6EP+8edfftHbLrG6eGPLXq00sCpbNN969MiS8kWoic1tHTFFrlERK+F5Y/key4ybfNctKc6yH3hf3c7Kh3RPwHb702FzLh7RZY9koLXX3fqcCw6xG0F0714rMyvoe6z1C1TuxSWHKanuniOSyo= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1701107773; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LS4gD/MR0++A77ZZ1qD66qfQwiU7+rWWYI1kivIpwlw=; b=YMM72TK2emRscrAKbV0sQl3uYZ4Pke3xkazfOdF1zrqPY7cqC5KGGOaj1jAk+sYYm1rWjG BqVsbRsMSib7WlaXq8BBXF4I1rSoFieReoO5qlxLyZFRtF26Yx+9zclitmdikbXvoZDT3G pDdUYDbf06d3oT7aWAAQzzSAPKAxHxs= Received: from mail-lf1-f72.google.com (mail-lf1-f72.google.com [209.85.167.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-500-tzzUjd0-MmKmBmEUk4lUnw-1; Mon, 27 Nov 2023 12:56:12 -0500 X-MC-Unique: tzzUjd0-MmKmBmEUk4lUnw-1 Received: by mail-lf1-f72.google.com with SMTP id 2adb3069b0e04-5091368e043so5321707e87.2 for ; Mon, 27 Nov 2023 09:56:11 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1701107770; x=1701712570; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=LS4gD/MR0++A77ZZ1qD66qfQwiU7+rWWYI1kivIpwlw=; b=eNEK3xUxnxyDmPRdFDomR6EVlFPAh+U6aVMTHUxzofCSDBsLeexn5c9FS0Frj0cP5z laDaF5L19GeExxwzDKnl+e8Ef0Kq+PgRQrv59FBgvtiaVL8d/TArvKNK4gGXBvpRIYl4 PeUO3w4zOBk/zS1VSte1aUHEeM9Dn+G9rNTOmtYK3efRYcUUypcM/+2pZcIps8Eq1NC1 mhi3b108e/HqyvEFsmZ8bn9YrAThmadfHOoxfJn4/mjP/HspRIXIMkKncYOR2uRMTYDZ qSWAlZ6fX6bAAtaFYcObhyPi2NNw0KD0SbkKfa8E7v6aONEwg7rfoqE67OL3tcxZ1CaL KBsg== X-Gm-Message-State: AOJu0YxMkMJc42uQUSeDDKKr3u4aIFqhOdFTZ8jjsAsreiCb1cL4gCer 9dnvM94U8Udtdrm9q3tckrRY+0ZyOBKzOBPv3XcCoIjfTRp7V/ayF/7pYgYQtGNMdEDGKd8wo86 9cBHHHX/iFBbBMiQjnAmkiNxwlRY9KKeicI6oYJzAwKsX2ta5FlXOKkeJY5PEIZ5Ldyljvqd19n isajubFA== X-Received: by 2002:a05:651c:200d:b0:2c9:a1fd:ae35 with SMTP id s13-20020a05651c200d00b002c9a1fdae35mr2644619ljo.16.1701107770300; Mon, 27 Nov 2023 09:56:10 -0800 (PST) X-Google-Smtp-Source: AGHT+IFJ7+C3RgXjr+jI03zuM0e9jvWWFPr3jJ+K9ocO3cql7Zdkksv469EyyU2DK3QHDq6N+pWLKg== X-Received: by 2002:a05:651c:200d:b0:2c9:a1fd:ae35 with SMTP id s13-20020a05651c200d00b002c9a1fdae35mr2644606ljo.16.1701107769924; Mon, 27 Nov 2023 09:56:09 -0800 (PST) Received: from localhost (105.226.159.143.dyn.plus.net. [143.159.226.105]) by smtp.gmail.com with ESMTPSA id i12-20020a05600c354c00b004060f0a0fd5sm14609149wmq.13.2023.11.27.09.56.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 27 Nov 2023 09:56:09 -0800 (PST) From: Andrew Burgess To: gdb-patches@sourceware.org Cc: Andrew Burgess Subject: [PATCH 5/7] gdb: C++-ify mapped_symtab from dwarf2/index-write.c Date: Mon, 27 Nov 2023 17:55:59 +0000 Message-Id: X-Mailer: git-send-email 2.25.4 In-Reply-To: References: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Make static the functions add_index_entry, find_slot, and hash_expand, member functions of the mapped_symtab class. Fold an additional snippet of code from write_gdbindex into mapped_symtab::minimize, this code relates to minimisation, so this seems like a good home for it. Make the n_elements, data, and m_string_obstack member variables of mapped_symtab private. Provide a new obstack() member function to provide access to the obstack when needed, and also add member functions begin(), end(), cbegin(), and cend() so that the mapped_symtab class can be treated like a contained and iterated over. I've also taken this opportunity to split out the logic for whether the hash table (m_data) needs expanding, this is the new function hash_needs_expanding. This will be useful in a later commit. There should be no user visible changes after this commit. --- gdb/dwarf2/index-write.c | 138 ++++++++++++++++++++++++++------------- 1 file changed, 92 insertions(+), 46 deletions(-) diff --git a/gdb/dwarf2/index-write.c b/gdb/dwarf2/index-write.c index 5960bacf8fb..e1c343e8790 100644 --- a/gdb/dwarf2/index-write.c +++ b/gdb/dwarf2/index-write.c @@ -189,86 +189,135 @@ struct mapped_symtab { mapped_symtab () { - data.resize (1024); + m_data.resize (1024); } - /* Minimize each entry in the symbol table, removing duplicates. */ + /* If there are no elements in the symbol table, then reduce the table + size to zero. Otherwise call symtab_index_entry::minimize each entry + in the symbol table. */ + void minimize () { - for (symtab_index_entry &item : data) + if (m_element_count == 0) + m_data.resize (0); + + for (symtab_index_entry &item : m_data) item.minimize (); } - offset_type n_elements = 0; - std::vector data; + /* Add an entry to SYMTAB. NAME is the name of the symbol. CU_INDEX is + the index of the CU in which the symbol appears. IS_STATIC is one if + the symbol is static, otherwise zero (global). */ + + void add_index_entry (const char *name, int is_static, + gdb_index_symbol_kind kind, offset_type cu_index); + + /* Access the obstack. */ + auto_obstack *obstack () + { return &m_string_obstack; } + +private: + + /* Find a slot in SYMTAB for the symbol NAME. Returns a reference to + the slot. + + Function is used only during write_hash_table so no index format + backward compatibility is needed. */ + + symtab_index_entry &find_slot (const char *name); + + /* Expand SYMTAB's hash table. */ + + void hash_expand (); + + /* Return true if the hash table in data needs to grow. */ + + bool hash_needs_expanding () const + { return 4 * m_element_count / 3 >= m_data.size (); } + + /* A vector that is used as a hash table. */ + std::vector m_data; + + /* The number of elements stored in the m_data hash. */ + offset_type m_element_count = 0; /* Temporary storage for names. */ auto_obstack m_string_obstack; -}; -/* Find a slot in SYMTAB for the symbol NAME. Returns a reference to - the slot. +public: + using iterator = decltype (m_data)::iterator; + using const_iterator = decltype (m_data)::const_iterator; - Function is used only during write_hash_table so no index format backward - compatibility is needed. */ + iterator begin () + { return m_data.begin (); } -static symtab_index_entry & -find_slot (struct mapped_symtab *symtab, const char *name) + iterator end () + { return m_data.end (); } + + const_iterator cbegin () + { return m_data.cbegin (); } + + const_iterator cend () + { return m_data.cend (); } +}; + +/* See class definition. */ + +symtab_index_entry & +mapped_symtab::find_slot (const char *name) { offset_type index, step, hash = mapped_index_string_hash (INT_MAX, name); - index = hash & (symtab->data.size () - 1); - step = ((hash * 17) & (symtab->data.size () - 1)) | 1; + index = hash & (m_data.size () - 1); + step = ((hash * 17) & (m_data.size () - 1)) | 1; for (;;) { - if (symtab->data[index].name == NULL - || strcmp (name, symtab->data[index].name) == 0) - return symtab->data[index]; - index = (index + step) & (symtab->data.size () - 1); + if (m_data[index].name == NULL + || strcmp (name, m_data[index].name) == 0) + return m_data[index]; + index = (index + step) & (m_data.size () - 1); } } -/* Expand SYMTAB's hash table. */ +/* See class definition. */ -static void -hash_expand (struct mapped_symtab *symtab) +void +mapped_symtab::hash_expand () { - auto old_entries = std::move (symtab->data); + auto old_entries = std::move (m_data); - symtab->data.clear (); - symtab->data.resize (old_entries.size () * 2); + gdb_assert (m_data.size () == 0); + m_data.resize (old_entries.size () * 2); for (auto &it : old_entries) if (it.name != NULL) { - auto &ref = find_slot (symtab, it.name); + auto &ref = this->find_slot (it.name); ref = std::move (it); } } -/* Add an entry to SYMTAB. NAME is the name of the symbol. - CU_INDEX is the index of the CU in which the symbol appears. - IS_STATIC is one if the symbol is static, otherwise zero (global). */ +/* See class definition. */ -static void -add_index_entry (struct mapped_symtab *symtab, const char *name, - int is_static, gdb_index_symbol_kind kind, - offset_type cu_index) +void +mapped_symtab::add_index_entry (const char *name, int is_static, + gdb_index_symbol_kind kind, + offset_type cu_index) { - symtab_index_entry *slot = &find_slot (symtab, name); + symtab_index_entry *slot = &this->find_slot (name); if (slot->name == NULL) { /* This is a new element in the hash table. */ - ++symtab->n_elements; + ++this->m_element_count; /* We might need to grow the hash table. */ - if (4 * symtab->n_elements / 3 >= symtab->data.size ()) + if (this->hash_needs_expanding ()) { - hash_expand (symtab); + this->hash_expand (); /* This element will have a different slot in the new table. */ - slot = &find_slot (symtab, name); + slot = &this->find_slot (name); /* But it should still be a new element in the hash table. */ gdb_assert (slot->name == nullptr); @@ -389,7 +438,7 @@ write_hash_table (mapped_symtab *symtab, data_buf &output, data_buf &cpool) /* We add all the index vectors to the constant pool first, to ensure alignment is ok. */ - for (symtab_index_entry &entry : symtab->data) + for (symtab_index_entry &entry : *symtab) { if (entry.name == NULL) continue; @@ -418,7 +467,7 @@ write_hash_table (mapped_symtab *symtab, data_buf &output, data_buf &cpool) /* Now write out the hash table. */ std::unordered_map str_table; - for (const auto &entry : symtab->data) + for (const auto &entry : *symtab) { offset_type str_off, vec_off; @@ -1159,7 +1208,7 @@ write_cooked_index (cooked_index *table, const auto it = cu_index_htab.find (entry->per_cu); gdb_assert (it != cu_index_htab.cend ()); - const char *name = entry->full_name (&symtab->m_string_obstack); + const char *name = entry->full_name (symtab->obstack ()); if (entry->per_cu->lang () == language_ada) { @@ -1167,8 +1216,7 @@ write_cooked_index (cooked_index *table, gdb, it has to use the encoded name, with any suffixes stripped. */ std::string encoded = ada_encode (name, false); - name = obstack_strdup (&symtab->m_string_obstack, - encoded.c_str ()); + name = obstack_strdup (symtab->obstack (), encoded.c_str ()); } else if (entry->per_cu->lang () == language_cplus && (entry->flags & IS_LINKAGE) != 0) @@ -1199,8 +1247,8 @@ write_cooked_index (cooked_index *table, else kind = GDB_INDEX_SYMBOL_KIND_TYPE; - add_index_entry (symtab, name, (entry->flags & IS_STATIC) != 0, - kind, it->second); + symtab->add_index_entry (name, (entry->flags & IS_STATIC) != 0, + kind, it->second); } } @@ -1303,8 +1351,6 @@ write_gdbindex (dwarf2_per_bfd *per_bfd, cooked_index *table, symtab.minimize (); data_buf symtab_vec, constant_pool; - if (symtab.n_elements == 0) - symtab.data.resize (0); write_hash_table (&symtab, symtab_vec, constant_pool);