From a0ed9ed3a53378d084a019bcdc6e36e7f9bb2201 Mon Sep 17 00:00:00 2001 From: Daniel Paoliello Date: Mon, 8 Apr 2024 15:24:35 -0700 Subject: [PATCH] Removed unused options (thin, deterministic, symbol table) and always use settings that the Rust compiler needs --- Cargo.toml | 2 +- Readme.md | 6 +++- src/archive_writer.rs | 68 +++++++++---------------------------------- tests/common.rs | 11 ++----- 4 files changed, 22 insertions(+), 65 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 966bf34..1e9fc2c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "ar_archive_writer" -version = "0.1.5" +version = "0.2.0" edition = "2021" license = "Apache-2.0 WITH LLVM-exception" description = "A writer for object file ar archives" diff --git a/Readme.md b/Readme.md index cee3ffe..f5201f9 100644 --- a/Readme.md +++ b/Readme.md @@ -1,6 +1,10 @@ # A writer for object file ar archives -This is based on commit [8ef3e895a](https://github.com/llvm/llvm-project/tree/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2) (15.0.0-rc3) of LLVM's archive writer. +This is a Rust port of LLVM's archive writer (`ArchiveWriter.cpp`): +* Based on commit [8ef3e895a](https://github.com/llvm/llvm-project/tree/3d3ef9d073e1e27ea57480b371b7f5a9f5642ed2) (15.0.0-rc3). +* With the following options removed: + * Deterministic: always enabled. + * Symbol tables: always enabled. ## License diff --git a/src/archive_writer.rs b/src/archive_writer.rs index d8cda2e..07d54f2 100644 --- a/src/archive_writer.rs +++ b/src/archive_writer.rs @@ -217,10 +217,7 @@ fn compute_string_table(names: &[u8]) -> MemberData<'_> { } } -fn now(deterministic: bool) -> u64 { - if !deterministic { - todo!("non deterministic mode is not yet supported"); // FIXME - } +const fn now() -> u64 { 0 } @@ -293,7 +290,6 @@ fn compute_symbol_table_size_and_pad( fn write_symbol_table_header( w: &mut W, kind: ArchiveKind, - deterministic: bool, size: u64, prev_member_offset: u64, ) -> io::Result<()> { @@ -304,29 +300,18 @@ fn write_symbol_table_header( "__.SYMDEF" }; let pos = w.stream_position()?; - print_bsd_member_header(w, pos, name, now(deterministic), 0, 0, 0, size) + print_bsd_member_header(w, pos, name, now(), 0, 0, 0, size) } else if is_aix_big_archive(kind) { - print_big_archive_member_header( - w, - "", - now(deterministic), - 0, - 0, - 0, - size, - prev_member_offset, - 0, - ) + print_big_archive_member_header(w, "", now(), 0, 0, 0, size, prev_member_offset, 0) } else { let name = if is_64bit_kind(kind) { "/SYM64" } else { "" }; - print_gnu_small_member_header(w, name.to_string(), now(deterministic), 0, 0, 0, size) + print_gnu_small_member_header(w, name.to_string(), now(), 0, 0, 0, size) } } fn write_symbol_table( w: &mut W, kind: ArchiveKind, - deterministic: bool, members: &[MemberData<'_>], string_table: &[u8], prev_member_offset: u64, @@ -341,7 +326,7 @@ fn write_symbol_table( let offset_size = if is_64bit_kind(kind) { 8 } else { 4 }; let (size, pad) = compute_symbol_table_size_and_pad(kind, num_syms, offset_size, string_table); - write_symbol_table_header(w, kind, deterministic, size, prev_member_offset)?; + write_symbol_table_header(w, kind, size, prev_member_offset)?; let mut pos = if is_aix_big_archive(kind) { u64::try_from(std::mem::size_of::()).unwrap() @@ -427,8 +412,6 @@ fn compute_member_data<'a, S: Write + Seek>( sym_names: &mut Cursor>, kind: ArchiveKind, thin: bool, - deterministic: bool, - need_symbols: bool, new_members: &'a [NewArchiveMember<'a>], ) -> io::Result>> { const PADDING_DATA: &[u8; 8] = &[b'\n'; 8]; @@ -490,7 +473,7 @@ fn compute_member_data<'a, S: Write + Seek>( // See also the functions that handle the lookup: // in lldb: ObjectContainerBSDArchive::Archive::FindObject() // in llvm/tools/dsymutil: BinaryHolder::GetArchiveMemberBuffers(). - let unique_timestamps = deterministic && is_darwin(kind); + let unique_timestamps = is_darwin(kind); let mut filename_count = HashMap::new(); if unique_timestamps { for m in new_members { @@ -569,11 +552,7 @@ fn compute_member_data<'a, S: Write + Seek>( )?; } - let symbols = if need_symbols { - write_symbols(data, m.get_symbols, sym_names, &mut has_object)? - } else { - vec![] - }; + let symbols = write_symbols(data, m.get_symbols, sym_names, &mut has_object)?; pos += u64::try_from(header.len() + data.len() + padding.len()).unwrap(); ret.push(MemberData { @@ -597,9 +576,7 @@ fn compute_member_data<'a, S: Write + Seek>( pub fn write_archive_to_stream( w: &mut W, new_members: &[NewArchiveMember<'_>], - write_symtab: bool, mut kind: ArchiveKind, - deterministic: bool, thin: bool, ) -> io::Result<()> { assert!( @@ -610,15 +587,7 @@ pub fn write_archive_to_stream( let mut sym_names = Cursor::new(Vec::new()); let mut string_table = Cursor::new(Vec::new()); - let mut data = compute_member_data( - &mut string_table, - &mut sym_names, - kind, - thin, - deterministic, - write_symtab, - new_members, - )?; + let mut data = compute_member_data(&mut string_table, &mut sym_names, kind, thin, new_members)?; let sym_names = sym_names.into_inner(); @@ -646,13 +615,13 @@ pub fn write_archive_to_stream( // The symbol table is put at the end of the big archive file. The symbol // table is at the start of the archive file for other archive formats. - if write_symtab && !is_aix_big_archive(kind) { + if !is_aix_big_archive(kind) { // We assume 32-bit offsets to see if 32-bit symbols are possible or not. let (symtab_size, _pad) = compute_symbol_table_size_and_pad(kind, num_syms, 4, &sym_names); last_member_header_offset += { // FIXME avoid allocating memory here let mut tmp = Cursor::new(vec![]); - write_symbol_table_header(&mut tmp, kind, deterministic, symtab_size, 0).unwrap(); + write_symbol_table_header(&mut tmp, kind, symtab_size, 0).unwrap(); u64::try_from(tmp.into_inner().len()).unwrap() } + symtab_size; @@ -687,9 +656,7 @@ pub fn write_archive_to_stream( } if !is_aix_big_archive(kind) { - if write_symtab { - write_symbol_table(w, kind, deterministic, &data, &sym_names, 0)?; - } + write_symbol_table(w, kind, &data, &sym_names, 0)?; for m in data { w.write_all(&m.header)?; @@ -723,7 +690,7 @@ pub fn write_archive_to_stream( let member_table_size = u64::try_from(20 + 20 * member_offsets.len() + member_table_name_str_tbl_size).unwrap(); - let global_symbol_offset = if write_symtab && num_syms > 0 { + let global_symbol_offset = if num_syms > 0 { last_member_end_offset + align_to( u64::try_from(std::mem::size_of::()).unwrap() @@ -817,15 +784,8 @@ pub fn write_archive_to_stream( w.write_all(&[0])?; } - if write_symtab && num_syms > 0 { - write_symbol_table( - w, - kind, - deterministic, - &data, - &sym_names, - last_member_end_offset, - )?; + if num_syms > 0 { + write_symbol_table(w, kind, &data, &sym_names, last_member_end_offset)?; } } } diff --git a/tests/common.rs b/tests/common.rs index c095fd5..03e680d 100644 --- a/tests/common.rs +++ b/tests/common.rs @@ -97,15 +97,8 @@ pub fn create_archive_with_ar_archive_writer<'a>( }) .collect::>(); let mut output_bytes = Cursor::new(Vec::new()); - ar_archive_writer::write_archive_to_stream( - &mut output_bytes, - &members, - true, - archive_kind, - true, - false, - ) - .unwrap(); + ar_archive_writer::write_archive_to_stream(&mut output_bytes, &members, archive_kind, false) + .unwrap(); let output_archive_bytes = output_bytes.into_inner(); let ar_archive_writer_file_path = tmpdir.join("output_ar_archive_writer.a");