Merge pull request #17 from dpaoliello/parseimp

Add support for creating archives with members from an import library

Author: bjorn3

Cargo.toml

@@ -11,11 +11,11 @@ repository = "https://github.com/rust-lang/ar_archive_writer"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-object = { version = "0.35.0", default-features = false, features = ["std", "read"] }
+object = { version = "0.36.2", default-features = false, features = ["std", "read"] }
 
 [dev-dependencies]
 cargo-binutils = "0.3.6"
-object = { version = "0.35.0", default-features = false, features = ["write", "xcoff"] }
+object = { version = "0.36.2", default-features = false, features = ["write", "xcoff"] }
 pretty_assertions = "1.4.0"
 
 [lints.rust]

src/coff_import_file.rs

@@ -42,7 +42,10 @@ macro_rules! u32 {
 }
 
 // Derived from COFFImportFile::printSymbolName and COFFImportFile::symbol_end.
-fn get_short_import_symbol(buf: &[u8], f: &mut dyn FnMut(&[u8]) -> Result<()>) -> Result<bool> {
+pub(crate) fn get_short_import_symbol(
+    buf: &[u8],
+    f: &mut dyn FnMut(&[u8]) -> Result<()>,
+) -> Result<bool> {
     let mut offset = 0;
     let header = ImportObjectHeader::parse(buf, &mut offset).map_err(Error::other)?;
     let data = header.parse_data(buf, &mut offset).map_err(Error::other)?;

src/object_reader.rs

@@ -7,14 +7,13 @@
 
 use std::{io, mem::offset_of};
 
-use object::{xcoff, Object, ObjectSymbol};
+use object::{pe::ImportObjectHeader, xcoff, Object, ObjectSymbol};
+
+use crate::coff_import_file;
 
 fn is_archive_symbol(sym: &object::read::Symbol<'_, '_>) -> bool {
     // FIXME Use a better equivalent of LLVM's SymbolRef::SF_FormatSpecific
-    if sym.kind() == object::SymbolKind::Null
-        || sym.kind() == object::SymbolKind::File
-        || sym.kind() == object::SymbolKind::Section
-    {
+    if sym.kind() == object::SymbolKind::File || sym.kind() == object::SymbolKind::Section {
         return false;
     }
     if !sym.is_global() {
@@ -42,7 +41,15 @@ pub fn get_native_object_symbols(
             }
             Ok(true)
         }
-        Err(_) => Ok(false),
+        Err(_) => {
+            let mut offset = 0;
+            // Try to handle this as a COFF import library.
+            if ImportObjectHeader::parse(buf, &mut offset).is_ok() {
+                coff_import_file::get_short_import_symbol(buf, f).or(Ok(false))
+            } else {
+                Ok(false)
+            }
+        }
     }
 }
 

tests/common.rs

@@ -107,10 +107,10 @@ fn run_llvm_ar(
 
 /// Creates an archive with the given objects using `llvm-ar`.
 /// The generated archive is written to disk as `output_llvm_ar.a`.
-pub fn create_archive_with_llvm_ar<'a>(
+pub fn create_archive_with_llvm_ar<'name, 'data>(
     tmpdir: &Path,
     archive_kind: ArchiveKind,
-    input_objects: impl IntoIterator<Item = (&'static str, &'a [u8])>,
+    input_objects: impl IntoIterator<Item = (&'name str, &'data [u8])>,
     thin: bool,
     is_ec: bool,
 ) -> Vec<u8> {
@@ -140,10 +140,10 @@ pub fn create_archive_with_llvm_ar<'a>(
 
 /// Creates an archive with the given objects using `ar_archive_writer`.
 /// The generated archive is written to disk as `output_ar_archive_writer.a`.
-pub fn create_archive_with_ar_archive_writer<'a>(
+pub fn create_archive_with_ar_archive_writer<'name, 'data>(
     tmpdir: &Path,
     archive_kind: ArchiveKind,
-    input_objects: impl IntoIterator<Item = (&'static str, &'a [u8])>,
+    input_objects: impl IntoIterator<Item = (&'name str, &'data [u8])>,
     thin: bool,
     is_ec: bool,
 ) -> Vec<u8> {

tests/import_library.rs

@@ -1,10 +1,12 @@
 use std::fs;
 use std::io::Cursor;
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use ar_archive_writer::{COFFShortExport, MachineTypes};
+use ar_archive_writer::{ArchiveKind, COFFShortExport, MachineTypes};
+use common::{create_archive_with_ar_archive_writer, create_archive_with_llvm_ar};
+use object::read::archive::ArchiveFile;
+use object::{Architecture, SubArchitecture};
 use pretty_assertions::assert_eq;
 
 mod common;
@@ -215,3 +217,67 @@ fn compare_to_dlltool() {
         );
     }
 }
+
+/// Creates an import library and then wraps that in an archive.
+#[test]
+fn wrap_in_archive() {
+    for (architecture, subarch, machine_type) in [
+        (Architecture::I386, None, MachineTypes::I386),
+        (Architecture::X86_64, None, MachineTypes::AMD64),
+        (Architecture::Arm, None, MachineTypes::ARMNT),
+        (Architecture::Aarch64, None, MachineTypes::ARM64),
+        (
+            Architecture::Aarch64,
+            Some(SubArchitecture::Arm64EC),
+            MachineTypes::ARM64EC,
+        ),
+    ] {
+        let temp_dir = common::create_tmp_dir("import_library_wrap_in_archive");
+
+        let mut import_lib_bytes = Cursor::new(Vec::new());
+        ar_archive_writer::write_import_library(
+            &mut import_lib_bytes,
+            &temp_dir.join("MyLibrary.dll").to_string_lossy().to_string(),
+            &get_members(machine_type),
+            machine_type,
+            false,
+        )
+        .unwrap();
+        let import_lib_bytes = import_lib_bytes.into_inner();
+
+        let is_ec = subarch == Some(SubArchitecture::Arm64EC);
+        let llvm_ar_archive = create_archive_with_llvm_ar(
+            &temp_dir,
+            ArchiveKind::Coff,
+            [("MyLibrary.dll.lib", import_lib_bytes.as_slice())],
+            false,
+            is_ec,
+        );
+        // When a archive is passed into lib.exe, it is opened and the individual members are included
+        // in the new output library. Also, for whatever reason, the members are reversed.
+        let archive = ArchiveFile::parse(import_lib_bytes.as_slice()).unwrap();
+        let mut members = archive
+            .members()
+            .map(|m| {
+                let member = m.unwrap();
+                (
+                    String::from_utf8(member.name().to_vec()).unwrap(),
+                    member.data(import_lib_bytes.as_slice()).unwrap(),
+                )
+            })
+            .collect::<Vec<_>>();
+        members.reverse();
+        let ar_archive_writer_archive = create_archive_with_ar_archive_writer(
+            &temp_dir,
+            ArchiveKind::Coff,
+            members.iter().map(|(name, data)| (name.as_str(), *data)),
+            false,
+            is_ec,
+        );
+
+        assert_eq!(
+            llvm_ar_archive, ar_archive_writer_archive,
+            "Archives differ for architecture: {architecture:?}, subarch: {subarch:?}, machine type: {machine_type:?}",
+        );
+    }
+}

tests/round_trip.rs

@@ -49,12 +49,6 @@ fn round_trip_and_diff(
         let output_archive =
             read::archive::ArchiveFile::parse(output_archive_bytes.as_slice()).unwrap();
         let mut members = output_archive.members();
-        if is_ec && archive_kind == ArchiveKind::Coff {
-            // FIXME: Skip the EC Symbol Table, since `object` doesn't correctly
-            // handle it as a special member.
-            // Fix in object: https://github.com/gimli-rs/object/pull/669
-            members.next().unwrap().unwrap();
-        }
         let output_member = members.next().unwrap().unwrap();
         if archive_kind != ArchiveKind::Coff {
             assert_eq!(output_member.name(), b"input.o");