From: Michael Matz <matz@suse.de>
To: binutils@sourceware.org
Subject: [PATCH 5/8] section-select: Remove unused code
Date: Fri, 25 Nov 2022 16:55:36 +0000 (UTC) [thread overview]
Message-ID: <alpine.LSU.2.20.2211251655221.24878@wotan.suse.de> (raw)
In-Reply-To: <cover.1669391757.git.matz@suse.de>
walk_wild_file, hence walk_wild_section and walk_wild_section_handler
aren't called with the prefix tree. Hence initialization of the latter
and all potential special cases for it aren't used anymore. That also
removes the need to handler_data[] and some associated helper functions.
So, remove all of that.
---
ld/ldlang.c | 506 +---------------------------------------------------
ld/ldlang.h | 2 -
2 files changed, 5 insertions(+), 503 deletions(-)
diff --git a/ld/ldlang.c b/ld/ldlang.c
index 57432700a18..3748bf9bec9 100644
--- a/ld/ldlang.c
+++ b/ld/ldlang.c
@@ -444,83 +444,6 @@ walk_wild_section_match (lang_wild_statement_type *ptr,
}
}
-/* Lowest common denominator routine that can handle everything correctly,
- but slowly. */
-
-static void
-walk_wild_section_general (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- asection *s;
- struct wildcard_list *sec;
-
- for (s = file->the_bfd->sections; s != NULL; s = s->next)
- {
- if (s->id < ptr->max_section_id)
- continue;
- //printf ("YYY checking %s:%s\n", s->owner->filename, s->name);
- sec = ptr->section_list;
- if (sec == NULL)
- (*callback) (ptr, sec, s, file, data);
-
- while (sec != NULL)
- {
- bool skip = false;
-
- if (sec->spec.name != NULL)
- {
- const char *sname = bfd_section_name (s);
-
- skip = spec_match (&sec->spec, sname) != 0;
- }
-
- if (!skip)
- walk_wild_consider_section (ptr, file, s, sec, callback, data);
-
- sec = sec->next;
- }
- }
-}
-
-/* Routines to find a single section given its name. If there's more
- than one section with that name, we report that. */
-
-typedef struct
-{
- asection *found_section;
- bool multiple_sections_found;
-} section_iterator_callback_data;
-
-static bool
-section_iterator_callback (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *data)
-{
- section_iterator_callback_data *d = (section_iterator_callback_data *) data;
-
- if (d->found_section != NULL)
- {
- d->multiple_sections_found = true;
- return true;
- }
-
- d->found_section = s;
- return false;
-}
-
-static asection *
-find_section (lang_input_statement_type *file,
- struct wildcard_list *sec,
- bool *multiple_sections_found)
-{
- section_iterator_callback_data cb_data = { NULL, false };
-
- bfd_get_section_by_name_if (file->the_bfd, sec->spec.name,
- section_iterator_callback, &cb_data);
- *multiple_sections_found = cb_data.multiple_sections_found;
- return cb_data.found_section;
-}
-
/* Return the numerical value of the init_priority attribute from
section name NAME. */
@@ -768,221 +691,6 @@ output_section_callback_tree_to_list (lang_wild_statement_type *ptr,
free (tree);
}
-/* Specialized, optimized routines for handling different kinds of
- wildcards */
-
-static void
-walk_wild_section_specs1_wild0 (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- /* We can just do a hash lookup for the section with the right name.
- But if that lookup discovers more than one section with the name
- (should be rare), we fall back to the general algorithm because
- we would otherwise have to sort the sections to make sure they
- get processed in the bfd's order. */
- bool multiple_sections_found;
- struct wildcard_list *sec0 = ptr->handler_data[0];
- asection *s0 = find_section (file, sec0, &multiple_sections_found);
-
- if (multiple_sections_found)
- walk_wild_section_general (ptr, file, callback, data);
- else if (s0)
- walk_wild_consider_section (ptr, file, s0, sec0, callback, data);
-}
-
-static void
-walk_wild_section_specs1_wild1 (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- asection *s;
- struct wildcard_list *wildsec0 = ptr->handler_data[0];
-
- for (s = file->the_bfd->sections; s != NULL; s = s->next)
- {
- const char *sname = bfd_section_name (s);
- bool skip = !match_simple_wild (wildsec0->spec.name, sname);
- //bool skip = !!spec_match (&wildsec0->spec, sname);
-
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec0, callback, data);
- }
-}
-
-static void
-walk_wild_section_specs2_wild1 (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- asection *s;
- struct wildcard_list *sec0 = ptr->handler_data[0];
- struct wildcard_list *wildsec1 = ptr->handler_data[1];
- bool multiple_sections_found;
- asection *s0 = find_section (file, sec0, &multiple_sections_found);
-
- if (multiple_sections_found)
- {
- walk_wild_section_general (ptr, file, callback, data);
- return;
- }
-
- /* Note that if the section was not found, s0 is NULL and
- we'll simply never succeed the s == s0 test below. */
- for (s = file->the_bfd->sections; s != NULL; s = s->next)
- {
- /* Recall that in this code path, a section cannot satisfy more
- than one spec, so if s == s0 then it cannot match
- wildspec1. */
- if (s == s0)
- walk_wild_consider_section (ptr, file, s, sec0, callback, data);
- else
- {
- const char *sname = bfd_section_name (s);
- bool skip = !match_simple_wild (wildsec1->spec.name, sname);
- //bool skip = !!spec_match (&wildsec1->spec, sname);
-
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec1, callback,
- data);
- }
- }
-}
-
-static void
-walk_wild_section_specs3_wild2 (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- asection *s;
- struct wildcard_list *sec0 = ptr->handler_data[0];
- struct wildcard_list *wildsec1 = ptr->handler_data[1];
- struct wildcard_list *wildsec2 = ptr->handler_data[2];
- bool multiple_sections_found;
- asection *s0 = find_section (file, sec0, &multiple_sections_found);
-
- if (multiple_sections_found)
- {
- walk_wild_section_general (ptr, file, callback, data);
- return;
- }
-
- for (s = file->the_bfd->sections; s != NULL; s = s->next)
- {
- if (s == s0)
- walk_wild_consider_section (ptr, file, s, sec0, callback, data);
- else
- {
- const char *sname = bfd_section_name (s);
- bool skip = !match_simple_wild (wildsec1->spec.name, sname);
-
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec1, callback, data);
- else
- {
- skip = !match_simple_wild (wildsec2->spec.name, sname);
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec2, callback,
- data);
- }
- }
- }
-}
-
-static void
-walk_wild_section_specs4_wild2 (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- asection *s;
- struct wildcard_list *sec0 = ptr->handler_data[0];
- struct wildcard_list *sec1 = ptr->handler_data[1];
- struct wildcard_list *wildsec2 = ptr->handler_data[2];
- struct wildcard_list *wildsec3 = ptr->handler_data[3];
- bool multiple_sections_found;
- asection *s0 = find_section (file, sec0, &multiple_sections_found), *s1;
-
- if (multiple_sections_found)
- {
- walk_wild_section_general (ptr, file, callback, data);
- return;
- }
-
- s1 = find_section (file, sec1, &multiple_sections_found);
- if (multiple_sections_found)
- {
- walk_wild_section_general (ptr, file, callback, data);
- return;
- }
-
- for (s = file->the_bfd->sections; s != NULL; s = s->next)
- {
- if (s == s0)
- walk_wild_consider_section (ptr, file, s, sec0, callback, data);
- else
- if (s == s1)
- walk_wild_consider_section (ptr, file, s, sec1, callback, data);
- else
- {
- const char *sname = bfd_section_name (s);
- bool skip = !match_simple_wild (wildsec2->spec.name, sname);
-
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec2, callback,
- data);
- else
- {
- skip = !match_simple_wild (wildsec3->spec.name, sname);
- if (!skip)
- walk_wild_consider_section (ptr, file, s, wildsec3,
- callback, data);
- }
- }
- }
-}
-
-static void
-walk_wild_section (lang_wild_statement_type *ptr,
- lang_input_statement_type *file,
- callback_t callback,
- void *data)
-{
- if (file->flags.just_syms)
- return;
-
- (*ptr->walk_wild_section_handler) (ptr, file, callback, data);
-}
-
-/* Returns TRUE when name1 is a wildcard spec that might match
- something name2 can match. We're conservative: we return FALSE
- only if the prefixes of name1 and name2 are different up to the
- first wildcard character. */
-
-static bool
-wild_spec_can_overlap (const char *name1, const char *name2)
-{
- size_t prefix1_len = strcspn (name1, "?*[");
- size_t prefix2_len = strcspn (name2, "?*[");
- size_t min_prefix_len;
-
- /* Note that if there is no wildcard character, then we treat the
- terminating 0 as part of the prefix. Thus ".text" won't match
- ".text." or ".text.*", for example. */
- if (name1[prefix1_len] == '\0')
- prefix1_len++;
- if (name2[prefix2_len] == '\0')
- prefix2_len++;
-
- min_prefix_len = prefix1_len < prefix2_len ? prefix1_len : prefix2_len;
-
- return memcmp (name1, name2, min_prefix_len) == 0;
-}
-
\f
/* Sections are matched against wildcard statements via a prefix tree.
The prefix tree holds prefixes of all matching patterns (up to the first
@@ -1156,17 +864,8 @@ rstrcspn (const char *s, const char *reject)
static void
analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
{
- int sec_count = 0;
- int wild_name_count = 0;
struct wildcard_list *sec;
- int signature;
- int data_counter;
-
- ptr->walk_wild_section_handler = walk_wild_section_general;
- ptr->handler_data[0] = NULL;
- ptr->handler_data[1] = NULL;
- ptr->handler_data[2] = NULL;
- ptr->handler_data[3] = NULL;
+
ptr->tree = NULL;
ptr->rightmost = &ptr->tree;
@@ -1184,113 +883,6 @@ analyze_walk_wild_section_handler (lang_wild_statement_type *ptr)
}
insert_prefix_tree (ptr);
-
- /* Count how many wildcard_specs there are, and how many of those
- actually use wildcards in the name. Also, bail out if any of the
- wildcard names are NULL. (Can this actually happen?
- walk_wild_section used to test for it.) And bail out if any
- of the wildcards are more complex than a simple string
- ending in a single '*'. */
- for (sec = ptr->section_list; sec != NULL; sec = sec->next)
- {
- ++sec_count;
- if (sec->spec.name == NULL)
- return;
- if (wildcardp (sec->spec.name))
- {
- ++wild_name_count;
- if (!is_simple_wild (sec->spec.name))
- return;
- }
- }
-
- /* The zero-spec case would be easy to optimize but it doesn't
- happen in practice. Likewise, more than 4 specs doesn't
- happen in practice. */
- if (sec_count == 0 || sec_count > 4)
- return;
-
- /* Check that no two specs can match the same section. */
- for (sec = ptr->section_list; sec != NULL; sec = sec->next)
- {
- struct wildcard_list *sec2;
- for (sec2 = sec->next; sec2 != NULL; sec2 = sec2->next)
- {
- if (wild_spec_can_overlap (sec->spec.name, sec2->spec.name))
- return;
- }
- }
-
- signature = (sec_count << 8) + wild_name_count;
- switch (signature)
- {
- case 0x0100:
- ptr->walk_wild_section_handler = walk_wild_section_specs1_wild0;
- break;
- case 0x0101:
- ptr->walk_wild_section_handler = walk_wild_section_specs1_wild1;
- break;
- case 0x0201:
- ptr->walk_wild_section_handler = walk_wild_section_specs2_wild1;
- break;
- case 0x0302:
- ptr->walk_wild_section_handler = walk_wild_section_specs3_wild2;
- break;
- case 0x0402:
- ptr->walk_wild_section_handler = walk_wild_section_specs4_wild2;
- break;
- default:
- return;
- }
-
- /* Now fill the data array with pointers to the specs, first the
- specs with non-wildcard names, then the specs with wildcard
- names. It's OK to process the specs in different order from the
- given order, because we've already determined that no section
- will match more than one spec. */
- data_counter = 0;
- for (sec = ptr->section_list; sec != NULL; sec = sec->next)
- if (!wildcardp (sec->spec.name))
- ptr->handler_data[data_counter++] = sec;
- for (sec = ptr->section_list; sec != NULL; sec = sec->next)
- if (wildcardp (sec->spec.name))
- ptr->handler_data[data_counter++] = sec;
-}
-
-/* Handle a wild statement for a single file F. */
-
-static void
-walk_wild_file (lang_wild_statement_type *s,
- lang_input_statement_type *f,
- callback_t callback,
- void *data)
-{
- if (walk_wild_file_in_exclude_list (s->exclude_name_list, f))
- return;
-
- if (f->the_bfd == NULL
- || !bfd_check_format (f->the_bfd, bfd_archive))
- walk_wild_section (s, f, callback, data);
- else
- {
- bfd *member;
-
- /* This is an archive file. We must map each member of the
- archive separately. */
- member = bfd_openr_next_archived_file (f->the_bfd, NULL);
- while (member != NULL)
- {
- /* When lookup_name is called, it will call the add_symbols
- entry point for the archive. For each element of the
- archive which is included, BFD will call ldlang_add_file,
- which will set the usrdata field of the member to the
- lang_input_statement. */
- if (bfd_usrdata (member) != NULL)
- walk_wild_section (s, bfd_usrdata (member), callback, data);
-
- member = bfd_openr_next_archived_file (f->the_bfd, member);
- }
- }
}
static bool check_resolve = false;
@@ -1422,113 +1014,25 @@ resolve_wilds (void)
check_resolve = true;
}
-static void
-walk_wild_resolve (lang_wild_statement_type *s)
-{
- const char *file_spec = s->filename;
- char *p;
-
- if (file_spec == NULL)
- {
- /* Perform the iteration over all files in the list. */
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- //printf("XXX %s\n", f->filename);
- walk_wild_file (s, f, add_matching_callback, NULL);
- }
- }
- else if ((p = archive_path (file_spec)) != NULL)
- {
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- if (input_statement_is_archive_path (file_spec, p, f))
- walk_wild_file (s, f, add_matching_callback, NULL);
- }
- }
- else if (wildcardp (file_spec))
- {
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- if (fnmatch (file_spec, f->filename, 0) == 0)
- walk_wild_file (s, f, add_matching_callback, NULL);
- }
- }
- else
- {
- lang_input_statement_type *f;
-
- /* Perform the iteration over a single file. */
- f = lookup_name (file_spec);
- if (f)
- walk_wild_file (s, f, add_matching_callback, NULL);
- }
-}
-
/* For each input section that matches wild statement S calls
CALLBACK with DATA. */
static void
walk_wild (lang_wild_statement_type *s, callback_t callback, void *data)
{
- const char *file_spec = s->filename;
- //char *p;
+ lang_statement_union_type *l;
-#if 1
- //if (!s->resolved)
if (s->max_section_id < bfd_get_max_section_id ())
{
- //printf("XXX %s\n", file_spec ? file_spec : "<null>");
- //walk_wild_resolve (s);
+ //printf("XXX %s\n", s->filename ? s->filename : "<null>");
s->resolved = true;
s->max_section_id = bfd_get_max_section_id ();
}
+ for (l = s->matching_sections.head; l; l = l->header.next)
{
- lang_statement_union_type *l;
- for (l = s->matching_sections.head; l; l = l->header.next)
- {
- (*callback) (s, l->input_matcher.pattern, l->input_matcher.section, l->input_matcher.input_stmt, data);
- }
- return;
- }
-#endif
-
-#if 0
- if (file_spec == NULL)
- {
- /* Perform the iteration over all files in the list. */
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- printf("XXX %s\n", f->filename);
- walk_wild_file (s, f, callback, data);
- }
- }
- else if ((p = archive_path (file_spec)) != NULL)
- {
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- if (input_statement_is_archive_path (file_spec, p, f))
- walk_wild_file (s, f, callback, data);
- }
- }
- else if (wildcardp (file_spec))
- {
- LANG_FOR_EACH_INPUT_STATEMENT (f)
- {
- if (fnmatch (file_spec, f->filename, 0) == 0)
- walk_wild_file (s, f, callback, data);
- }
+ (*callback) (s, l->input_matcher.pattern, l->input_matcher.section, l->input_matcher.input_stmt, data);
}
- else
- {
- lang_input_statement_type *f;
-
- /* Perform the iteration over a single file. */
- f = lookup_name (file_spec);
- if (f)
- walk_wild_file (s, f, callback, data);
- }
-#endif
}
/* lang_for_each_statement walks the parse tree and calls the provided
diff --git a/ld/ldlang.h b/ld/ldlang.h
index 8566e022a57..09c43611a22 100644
--- a/ld/ldlang.h
+++ b/ld/ldlang.h
@@ -402,8 +402,6 @@ struct lang_wild_statement_struct
bool resolved;
unsigned int max_section_id;
- walk_wild_section_handler_t walk_wild_section_handler;
- struct wildcard_list *handler_data[4];
lang_section_bst_type *tree, **rightmost;
struct flag_info *section_flag_list;
};
--
2.36.1
next prev parent reply other threads:[~2022-11-25 16:55 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <cover.1669391757.git.matz@suse.de>
2022-11-25 16:44 ` [PATCH 1/8] section-select: Lazily resolve section matches Michael Matz
2022-11-25 16:46 ` [PATCH 2/8] section-select: Deal with sections added late Michael Matz
2022-11-25 16:47 ` [PATCH 3/8] section-select: Implement a prefix-tree Michael Matz
2022-11-25 16:55 ` [PATCH 4/8] section-select: Completely rebuild matches Michael Matz
2022-11-28 1:57 ` Alan Modra
2022-11-28 14:24 ` Michael Matz
2022-11-29 12:22 ` Alan Modra
2022-11-29 13:23 ` Michael Matz
2022-11-25 16:55 ` Michael Matz [this message]
2022-11-25 16:55 ` [PATCH 6/8] section-select: Cleanup Michael Matz
2022-11-25 16:57 ` [PATCH 7/8] section-select: Remove bfd_max_section_id again Michael Matz
2022-11-25 16:58 ` [PATCH 8/8] section-select: Fix exclude-file-3 Michael Matz
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=alpine.LSU.2.20.2211251655221.24878@wotan.suse.de \
--to=matz@suse.de \
--cc=binutils@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).