run-make-support: add object-based symbol helpers

- `dynamic_symbol_names`
- `text_section_global_dynamic_symbol_names`
- `global_undefined_dynamic_symbol_names`

Also add some missing `#[track_caller]` attributes.

Co-authored-by: binarycat <binarycat@envs.net>

Author: jieyouxu

src/tools/run-make-support/src/symbols.rs

@@ -1,19 +1,84 @@
 use std::path::Path;
 
-use object::{self, Object, ObjectSymbol, SymbolIterator};
+use object::{self, Object, ObjectSymbol, SectionIndex, SymbolIterator};
 
-/// Iterate through the symbols in an object file.
+/// Given an [`object::File`], find the dynamic symbol names via
+/// [`object::Object::dynamic_symbols`]. This does **not** impose any filters on the specific
+/// dynamic symbols, e.g. if they are global or local, if they are defined or not, and in which
+/// section the dynamic symbols reside in.
 ///
-/// Uses a callback because `SymbolIterator` does not own its data.
+/// On Windows, [`object::Object::dynamic_symbols`] will return an empty iterator because the symbol
+/// names are stored in a separate file (which object doesn't know how to read). Use
+/// [`object::Object::exports`] instead of this helper.
+#[track_caller]
+pub fn dynamic_symbol_names<'file>(file: &'file object::File<'file>) -> Vec<&'file str> {
+    file.dynamic_symbols().map(|sym| sym.name().unwrap()).collect()
+}
+
+/// Given an [`object::File`], find the global (externally visible) dynamic symbol names in the
+/// `.text` section via [`object::Object::dynamic_symbols`]. This requires that `.text`'s section
+/// index is known.
+///
+/// On Windows, [`object::Object::dynamic_symbols`] will return an empty iterator because the symbol
+/// names are stored in a separate file (which object doesn't know how to read). Use
+/// [`object::Object::exports`] instead of this helper.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// use object::{self, Object};
+/// use run_make_support::{rfs, dynamic_lib_name};
+///
+/// let dylib_filename = dynamic_lib_name("foo");
+/// let blob = rfs::read(&dylib_filename);
+/// let file = object::File::parse(&*blob)
+///     .unwrap_or_else(|e| panic!("failed to read `{dylib_filename}`: {e}"));
+/// let text_section =
+///     file.section_by_name(".text").expect("couldn't find `.text` section");
+/// let found_symbols = text_section_global_dynamic_symbol_names(&file, text_section.index());
+/// ```
+#[track_caller]
+pub fn text_section_global_dynamic_symbol_names<'file>(
+    file: &'file object::File<'file>,
+    text_section_idx: SectionIndex,
+) -> Vec<&'file str> {
+    file.dynamic_symbols()
+        .filter(|sym| {
+            sym.is_global() && sym.section_index().is_some_and(|idx| idx == text_section_idx)
+        })
+        .map(|sym| sym.name().unwrap())
+        .collect()
+}
+
+/// Given an [`object::File`], find the global (externally visible) undefined dynamic symbol names
+/// in the `.text` section via [`object::Object::dynamic_symbols`].
+///
+/// On Windows, [`object::Object::dynamic_symbols`] will return an empty iterator because the symbol
+/// names are stored in a separate file (which object doesn't know how to read). Use
+/// [`object::Object::exports`] instead of this helper.
+#[track_caller]
+pub fn global_undefined_dynamic_symbol_names<'file>(
+    file: &'file object::File<'file>,
+) -> Vec<&'file str> {
+    file.dynamic_symbols()
+        .filter(|sym| sym.is_global() && sym.is_undefined())
+        .map(|sym| sym.name().unwrap())
+        .collect()
+}
+
+/// Iterate through the symbols in an object file. See [`object::Object::symbols`].
 ///
 /// Panics if `path` is not a valid object file readable by the current user.
+#[track_caller]
 pub fn with_symbol_iter<P, F, R>(path: P, func: F) -> R
 where
     P: AsRef<Path>,
     F: FnOnce(&mut SymbolIterator<'_, '_>) -> R,
 {
-    let raw_bytes = crate::fs::read(path);
-    let f = object::File::parse(raw_bytes.as_slice()).expect("unable to parse file");
+    let path = path.as_ref();
+    let blob = crate::fs::read(path);
+    let f = object::File::parse(&*blob)
+        .unwrap_or_else(|e| panic!("failed to parse `{}`: {e}", path.display()));
     let mut iter = f.symbols();
     func(&mut iter)
 }
@@ -24,6 +89,7 @@ where
 /// `path` contain a substring listed in `substrings`.
 ///
 /// Panics if `path` is not a valid object file readable by the current user.
+#[track_caller]
 pub fn any_symbol_contains(path: impl AsRef<Path>, substrings: &[&str]) -> bool {
     with_symbol_iter(path, |syms| {
         for sym in syms {