Implement ordinal / name-types

Author: simonbuchan

src/archive.rs

@@ -21,14 +21,36 @@ impl ArchiveBuilderBuilder for ArArchiveBuilderBuilder {
         tmpdir: &Path,
         _is_direct_dependency: bool,
     ) -> PathBuf {
-        let mut import_names = Vec::new();
-        for dll_import in dll_imports {
-            import_names.push(dll_import.name.as_str());
-        }
         let lib_path = tmpdir.join(format!("{lib_name}_import.lib"));
+
+        // todo: use the same DllImport type?
+        let import_lib_imports = dll_imports
+            .into_iter()
+            .map(|import| crate::dll_import_lib::Import {
+                symbol_name: import.name.to_string(),
+                ordinal_or_hint: import.ordinal(),
+                name_type: match import.import_name_type {
+                    Some(rustc_session::cstore::PeImportNameType::Ordinal(_)) => {
+                        crate::dll_import_lib::ImportNameType::Ordinal
+                    }
+                    None | Some(rustc_session::cstore::PeImportNameType::Decorated) => {
+                        crate::dll_import_lib::ImportNameType::Name
+                    }
+                    Some(rustc_session::cstore::PeImportNameType::NoPrefix) => {
+                        crate::dll_import_lib::ImportNameType::NameNoPrefix
+                    }
+                    Some(rustc_session::cstore::PeImportNameType::Undecorated) => {
+                        crate::dll_import_lib::ImportNameType::NameUndecorate
+                    }
+                },
+                import_type: crate::dll_import_lib::ImportType::Code,
+            })
+            .collect::<Vec<_>>();
+
+        let import_lib = crate::dll_import_lib::generate(lib_name, &import_lib_imports);
+
         // todo: emit session error instead of expects
-        fs::write(&lib_path, crate::dll_import_lib::generate(lib_name, &import_names))
-            .expect("failed to write import library");
+        fs::write(&lib_path, import_lib).expect("failed to write import library");
 
         lib_path
     }

src/dll_import_lib/coff.rs

@@ -89,25 +89,81 @@ pub(crate) struct ImportObjectHeaderUnaligned {
 /// - have no padding
 unsafe impl object::pod::Pod for ImportObjectHeaderUnaligned {}
 
-pub(crate) fn write_short_import(
-    data: &mut DataWriter,
-    dll_name: &str,
-    name: &&str,
-    ordinal_or_hint: Option<std::primitive::u16>,
-) {
+/// The IMPORT_OBJECT_* constants used to find the exported value in the DLL.
+pub(crate) enum ImportNameType {
+    /// No import name, import by ordinal only.
+    Ordinal,
+    /// Import name == public symbol name.
+    Name,
+    /// Import name == public symbol name skipping leading ?, @, or optionally _.
+    NameNoPrefix,
+    /// Import name == public symbol name skipping leading ?, @, or optionally _ and truncating at first @.
+    NameUndecorate,
+    /// Import name == a name is explicitly provided after the DLL name.
+    NameExportAs { export_name: String },
+}
+
+impl ImportNameType {
+    fn as_u16(&self) -> u16 {
+        match self {
+            ImportNameType::Ordinal => IMPORT_OBJECT_ORDINAL,
+            ImportNameType::Name => IMPORT_OBJECT_NAME,
+            ImportNameType::NameNoPrefix => IMPORT_OBJECT_NAME_NO_PREFIX,
+            ImportNameType::NameUndecorate => IMPORT_OBJECT_NAME_UNDECORATE,
+            ImportNameType::NameExportAs { .. } => IMPORT_OBJECT_NAME_EXPORTAS,
+        }
+    }
+}
+
+/// The IMPORT_OBJECT_* constants that defines how the import is linked, or in the words of the PE
+/// documentation:
+/// > These values are used to determine which section contributions must be generated by the tool
+/// > that uses the library if it must access that data.
+pub(crate) enum ImportType {
+    Code,
+    Data,
+    Const,
+}
+
+impl ImportType {
+    fn as_u16(&self) -> u16 {
+        match self {
+            ImportType::Code => IMPORT_OBJECT_CODE,
+            ImportType::Data => IMPORT_OBJECT_DATA,
+            ImportType::Const => IMPORT_OBJECT_CONST,
+        }
+    }
+}
+
+pub(crate) struct Import {
+    pub(crate) symbol_name: String,
+    pub(crate) name_type: ImportNameType,
+    pub(crate) import_type: ImportType,
+    pub(crate) ordinal_or_hint: Option<std::primitive::u16>,
+}
+
+pub(crate) fn write_short_import(data: &mut DataWriter, dll_name: &str, import: &Import) {
+    let mut size_of_data = import.symbol_name.len() + 1 + dll_name.len() + 1;
+    if let ImportNameType::NameExportAs { export_name } = &import.name_type {
+        size_of_data += export_name.len() + 1;
+    }
+
     data.write_pod(&ImportObjectHeaderUnaligned {
         sig1: u16(IMAGE_FILE_MACHINE_UNKNOWN),
         sig2: u16(IMPORT_OBJECT_HDR_SIG2),
         version: u16(0),
         machine: u16(IMAGE_FILE_MACHINE_AMD64),
         time_date_stamp: u32(0),
-        size_of_data: u32((name.len() + 1 + dll_name.len() + 1) as u32),
-        ordinal_or_hint: u16(ordinal_or_hint.unwrap_or_default()),
-        name_type: u16(IMPORT_OBJECT_CODE << IMPORT_OBJECT_TYPE_SHIFT
-            | IMPORT_OBJECT_NAME << IMPORT_OBJECT_NAME_SHIFT),
+        size_of_data: u32(size_of_data as u32),
+        ordinal_or_hint: u16(import.ordinal_or_hint.unwrap_or_default()),
+        name_type: u16(import.import_type.as_u16() << IMPORT_OBJECT_TYPE_SHIFT
+            | import.name_type.as_u16() << IMPORT_OBJECT_NAME_SHIFT),
     });
-    data.write_c_str(name);
+    data.write_c_str(&import.symbol_name);
     data.write_c_str(dll_name);
+    if let ImportNameType::NameExportAs { export_name } = &import.name_type {
+        data.write_c_str(&export_name);
+    }
 }
 
 pub(crate) fn write_import_descriptor(

src/dll_import_lib/mod.rs

@@ -11,12 +11,13 @@ use object::{Object, ObjectSymbol};
 
 use data::DataWriter;
 
+mod coff;
 mod data;
 mod string_table;
 
-mod coff;
+pub(crate) use coff::{Import, ImportNameType, ImportType};
 
-pub(crate) fn generate(dll_name: &str, import_names: &[&str]) -> Vec<u8> {
+pub(crate) fn generate(dll_name: &str, imports: &[Import]) -> Vec<u8> {
     let mut members = Vec::new();
 
     // foo.dll => foo so we can construct the import descriptor symbol.
@@ -98,9 +99,9 @@ pub(crate) fn generate(dll_name: &str, import_names: &[&str]) -> Vec<u8> {
     }
 
     // short import object members
-    for name in import_names.iter() {
+    for import in imports {
         let mut buf = DataWriter::new();
-        coff::write_short_import(&mut buf, dll_name, name, None);
+        coff::write_short_import(&mut buf, dll_name, &import);
         members.push(ar_archive_writer::NewArchiveMember {
             member_name: dll_name.to_string(),
             buf: Box::new(buf.into_data()),