80e18b93c5
On i386, regular C level symbols are given an underscore prefix in the symbols on the object file level. However, the exported names from DLLs usually don't have this leading underscore. When specified in a def file like "symbol == dllname", the "dllname" is the name of the exported symbol from the DLL, which will be linked against from an object file symbol named "_symbol" (on i386). The mechanism where one symbol is redirected to another one in an import library is implemented with weak aliases. In that case, we need to have the object file symbol level name for the target of the import, as we make one object file symbol point at another one. Therefore, we added an underscore to the ImportName field. (This mechanism, with weak aliases, only works as long as the target also is exported as is, in that form - this issue is dealt with in a later commit.) For clarity, for potentially handling the import renaming in other ways, store the ImportName field unprefixed, containing the actual name to import from the DLL. When creating the aliases, add the prefix as needed. This requires passing an extra AddUnderscores parameter to the writeImportLibrary function; this is a temporary measure, until alias creation is reworked in a later commit. This doesn't preserve the corner case of checking !isDecorated() before adding the prefix. This corner case isn't tested by any of our existing tests, and only would trigger for fastcall/vectorcall/MS C++ functions - while these kinds of renames primarily are used in mingw-w64-crt import libraries (which primarily handle cdecl and stdcall functions).
752 lines
24 KiB
C++
752 lines
24 KiB
C++
//===- COFFImportFile.cpp - COFF short import file implementation ---------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the writeImportLibrary function.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Object/COFFImportFile.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Object/Archive.h"
|
|
#include "llvm/Object/ArchiveWriter.h"
|
|
#include "llvm/Object/COFF.h"
|
|
#include "llvm/Support/Allocator.h"
|
|
#include "llvm/Support/Endian.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/Path.h"
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
using namespace llvm::COFF;
|
|
using namespace llvm::object;
|
|
using namespace llvm;
|
|
|
|
namespace llvm {
|
|
namespace object {
|
|
|
|
StringRef COFFImportFile::getFileFormatName() const {
|
|
switch (getMachine()) {
|
|
case COFF::IMAGE_FILE_MACHINE_I386:
|
|
return "COFF-import-file-i386";
|
|
case COFF::IMAGE_FILE_MACHINE_AMD64:
|
|
return "COFF-import-file-x86-64";
|
|
case COFF::IMAGE_FILE_MACHINE_ARMNT:
|
|
return "COFF-import-file-ARM";
|
|
case COFF::IMAGE_FILE_MACHINE_ARM64:
|
|
return "COFF-import-file-ARM64";
|
|
case COFF::IMAGE_FILE_MACHINE_ARM64EC:
|
|
return "COFF-import-file-ARM64EC";
|
|
case COFF::IMAGE_FILE_MACHINE_ARM64X:
|
|
return "COFF-import-file-ARM64X";
|
|
default:
|
|
return "COFF-import-file-<unknown arch>";
|
|
}
|
|
}
|
|
|
|
StringRef COFFImportFile::getExportName() const {
|
|
const coff_import_header *hdr = getCOFFImportHeader();
|
|
StringRef name = Data.getBuffer().substr(sizeof(*hdr)).split('\0').first;
|
|
|
|
auto ltrim1 = [](StringRef s, StringRef chars) {
|
|
return !s.empty() && chars.contains(s[0]) ? s.substr(1) : s;
|
|
};
|
|
|
|
switch (hdr->getNameType()) {
|
|
case IMPORT_ORDINAL:
|
|
name = "";
|
|
break;
|
|
case IMPORT_NAME_NOPREFIX:
|
|
name = ltrim1(name, "?@_");
|
|
break;
|
|
case IMPORT_NAME_UNDECORATE:
|
|
name = ltrim1(name, "?@_");
|
|
name = name.substr(0, name.find('@'));
|
|
break;
|
|
case IMPORT_NAME_EXPORTAS: {
|
|
// Skip DLL name
|
|
name = Data.getBuffer().substr(sizeof(*hdr) + name.size() + 1);
|
|
name = name.split('\0').second.split('\0').first;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
Error COFFImportFile::printSymbolName(raw_ostream &OS, DataRefImpl Symb) const {
|
|
switch (Symb.p) {
|
|
case ImpSymbol:
|
|
OS << "__imp_";
|
|
break;
|
|
case ECAuxSymbol:
|
|
OS << "__imp_aux_";
|
|
break;
|
|
}
|
|
const char *Name = Data.getBufferStart() + sizeof(coff_import_header);
|
|
if (Symb.p != ECThunkSymbol && COFF::isArm64EC(getMachine())) {
|
|
if (std::optional<std::string> DemangledName =
|
|
getArm64ECDemangledFunctionName(Name)) {
|
|
OS << StringRef(*DemangledName);
|
|
return Error::success();
|
|
}
|
|
}
|
|
OS << StringRef(Name);
|
|
return Error::success();
|
|
}
|
|
|
|
static uint16_t getImgRelRelocation(MachineTypes Machine) {
|
|
switch (Machine) {
|
|
default:
|
|
llvm_unreachable("unsupported machine");
|
|
case IMAGE_FILE_MACHINE_AMD64:
|
|
return IMAGE_REL_AMD64_ADDR32NB;
|
|
case IMAGE_FILE_MACHINE_ARMNT:
|
|
return IMAGE_REL_ARM_ADDR32NB;
|
|
case IMAGE_FILE_MACHINE_ARM64:
|
|
case IMAGE_FILE_MACHINE_ARM64EC:
|
|
case IMAGE_FILE_MACHINE_ARM64X:
|
|
return IMAGE_REL_ARM64_ADDR32NB;
|
|
case IMAGE_FILE_MACHINE_I386:
|
|
return IMAGE_REL_I386_DIR32NB;
|
|
}
|
|
}
|
|
|
|
template <class T> static void append(std::vector<uint8_t> &B, const T &Data) {
|
|
size_t S = B.size();
|
|
B.resize(S + sizeof(T));
|
|
memcpy(&B[S], &Data, sizeof(T));
|
|
}
|
|
|
|
static void writeStringTable(std::vector<uint8_t> &B,
|
|
ArrayRef<const std::string_view> Strings) {
|
|
// The COFF string table consists of a 4-byte value which is the size of the
|
|
// table, including the length field itself. This value is followed by the
|
|
// string content itself, which is an array of null-terminated C-style
|
|
// strings. The termination is important as they are referenced to by offset
|
|
// by the symbol entity in the file format.
|
|
|
|
size_t Pos = B.size();
|
|
size_t Offset = B.size();
|
|
|
|
// Skip over the length field, we will fill it in later as we will have
|
|
// computed the length while emitting the string content itself.
|
|
Pos += sizeof(uint32_t);
|
|
|
|
for (const auto &S : Strings) {
|
|
B.resize(Pos + S.length() + 1);
|
|
std::copy(S.begin(), S.end(), std::next(B.begin(), Pos));
|
|
B[Pos + S.length()] = 0;
|
|
Pos += S.length() + 1;
|
|
}
|
|
|
|
// Backfill the length of the table now that it has been computed.
|
|
support::ulittle32_t Length(B.size() - Offset);
|
|
support::endian::write32le(&B[Offset], Length);
|
|
}
|
|
|
|
static ImportNameType getNameType(StringRef Sym, StringRef ExtName,
|
|
MachineTypes Machine, bool MinGW) {
|
|
// A decorated stdcall function in MSVC is exported with the
|
|
// type IMPORT_NAME, and the exported function name includes the
|
|
// the leading underscore. In MinGW on the other hand, a decorated
|
|
// stdcall function still omits the underscore (IMPORT_NAME_NOPREFIX).
|
|
// See the comment in isDecorated in COFFModuleDefinition.cpp for more
|
|
// details.
|
|
if (ExtName.starts_with("_") && ExtName.contains('@') && !MinGW)
|
|
return IMPORT_NAME;
|
|
if (Sym != ExtName)
|
|
return IMPORT_NAME_UNDECORATE;
|
|
if (Machine == IMAGE_FILE_MACHINE_I386 && Sym.starts_with("_"))
|
|
return IMPORT_NAME_NOPREFIX;
|
|
return IMPORT_NAME;
|
|
}
|
|
|
|
static Expected<std::string> replace(StringRef S, StringRef From,
|
|
StringRef To) {
|
|
size_t Pos = S.find(From);
|
|
|
|
// From and To may be mangled, but substrings in S may not.
|
|
if (Pos == StringRef::npos && From.starts_with("_") && To.starts_with("_")) {
|
|
From = From.substr(1);
|
|
To = To.substr(1);
|
|
Pos = S.find(From);
|
|
}
|
|
|
|
if (Pos == StringRef::npos) {
|
|
return make_error<StringError>(
|
|
StringRef(Twine(S + ": replacing '" + From +
|
|
"' with '" + To + "' failed").str()), object_error::parse_failed);
|
|
}
|
|
|
|
return (Twine(S.substr(0, Pos)) + To + S.substr(Pos + From.size())).str();
|
|
}
|
|
|
|
namespace {
|
|
// This class constructs various small object files necessary to support linking
|
|
// symbols imported from a DLL. The contents are pretty strictly defined and
|
|
// nearly entirely static. The details of the structures files are defined in
|
|
// WINNT.h and the PE/COFF specification.
|
|
class ObjectFactory {
|
|
using u16 = support::ulittle16_t;
|
|
using u32 = support::ulittle32_t;
|
|
MachineTypes NativeMachine;
|
|
BumpPtrAllocator Alloc;
|
|
StringRef ImportName;
|
|
StringRef Library;
|
|
std::string ImportDescriptorSymbolName;
|
|
std::string NullThunkSymbolName;
|
|
|
|
public:
|
|
ObjectFactory(StringRef S, MachineTypes M)
|
|
: NativeMachine(M), ImportName(S), Library(llvm::sys::path::stem(S)),
|
|
ImportDescriptorSymbolName((ImportDescriptorPrefix + Library).str()),
|
|
NullThunkSymbolName(
|
|
(NullThunkDataPrefix + Library + NullThunkDataSuffix).str()) {}
|
|
|
|
// Creates an Import Descriptor. This is a small object file which contains a
|
|
// reference to the terminators and contains the library name (entry) for the
|
|
// import name table. It will force the linker to construct the necessary
|
|
// structure to import symbols from the DLL.
|
|
NewArchiveMember createImportDescriptor(std::vector<uint8_t> &Buffer);
|
|
|
|
// Creates a NULL import descriptor. This is a small object file whcih
|
|
// contains a NULL import descriptor. It is used to terminate the imports
|
|
// from a specific DLL.
|
|
NewArchiveMember createNullImportDescriptor(std::vector<uint8_t> &Buffer);
|
|
|
|
// Create a NULL Thunk Entry. This is a small object file which contains a
|
|
// NULL Import Address Table entry and a NULL Import Lookup Table Entry. It
|
|
// is used to terminate the IAT and ILT.
|
|
NewArchiveMember createNullThunk(std::vector<uint8_t> &Buffer);
|
|
|
|
// Create a short import file which is described in PE/COFF spec 7. Import
|
|
// Library Format.
|
|
NewArchiveMember createShortImport(StringRef Sym, uint16_t Ordinal,
|
|
ImportType Type, ImportNameType NameType,
|
|
StringRef ExportName,
|
|
MachineTypes Machine);
|
|
|
|
// Create a weak external file which is described in PE/COFF Aux Format 3.
|
|
NewArchiveMember createWeakExternal(StringRef Sym, StringRef Weak, bool Imp,
|
|
MachineTypes Machine);
|
|
|
|
bool is64Bit() const { return COFF::is64Bit(NativeMachine); }
|
|
};
|
|
} // namespace
|
|
|
|
NewArchiveMember
|
|
ObjectFactory::createImportDescriptor(std::vector<uint8_t> &Buffer) {
|
|
const uint32_t NumberOfSections = 2;
|
|
const uint32_t NumberOfSymbols = 7;
|
|
const uint32_t NumberOfRelocations = 3;
|
|
|
|
// COFF Header
|
|
coff_file_header Header{
|
|
u16(NativeMachine),
|
|
u16(NumberOfSections),
|
|
u32(0),
|
|
u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
|
|
// .idata$2
|
|
sizeof(coff_import_directory_table_entry) +
|
|
NumberOfRelocations * sizeof(coff_relocation) +
|
|
// .idata$4
|
|
(ImportName.size() + 1)),
|
|
u32(NumberOfSymbols),
|
|
u16(0),
|
|
u16(is64Bit() ? C_Invalid : IMAGE_FILE_32BIT_MACHINE),
|
|
};
|
|
append(Buffer, Header);
|
|
|
|
// Section Header Table
|
|
const coff_section SectionTable[NumberOfSections] = {
|
|
{{'.', 'i', 'd', 'a', 't', 'a', '$', '2'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(sizeof(coff_import_directory_table_entry)),
|
|
u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section)),
|
|
u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
|
|
sizeof(coff_import_directory_table_entry)),
|
|
u32(0),
|
|
u16(NumberOfRelocations),
|
|
u16(0),
|
|
u32(IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
|
|
{{'.', 'i', 'd', 'a', 't', 'a', '$', '6'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(ImportName.size() + 1),
|
|
u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
|
|
sizeof(coff_import_directory_table_entry) +
|
|
NumberOfRelocations * sizeof(coff_relocation)),
|
|
u32(0),
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
u32(IMAGE_SCN_ALIGN_2BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
|
|
};
|
|
append(Buffer, SectionTable);
|
|
|
|
// .idata$2
|
|
const coff_import_directory_table_entry ImportDescriptor{
|
|
u32(0), u32(0), u32(0), u32(0), u32(0),
|
|
};
|
|
append(Buffer, ImportDescriptor);
|
|
|
|
const coff_relocation RelocationTable[NumberOfRelocations] = {
|
|
{u32(offsetof(coff_import_directory_table_entry, NameRVA)), u32(2),
|
|
u16(getImgRelRelocation(NativeMachine))},
|
|
{u32(offsetof(coff_import_directory_table_entry, ImportLookupTableRVA)),
|
|
u32(3), u16(getImgRelRelocation(NativeMachine))},
|
|
{u32(offsetof(coff_import_directory_table_entry, ImportAddressTableRVA)),
|
|
u32(4), u16(getImgRelRelocation(NativeMachine))},
|
|
};
|
|
append(Buffer, RelocationTable);
|
|
|
|
// .idata$6
|
|
auto S = Buffer.size();
|
|
Buffer.resize(S + ImportName.size() + 1);
|
|
memcpy(&Buffer[S], ImportName.data(), ImportName.size());
|
|
Buffer[S + ImportName.size()] = '\0';
|
|
|
|
// Symbol Table
|
|
coff_symbol16 SymbolTable[NumberOfSymbols] = {
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(1),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
{{{'.', 'i', 'd', 'a', 't', 'a', '$', '2'}},
|
|
u32(0),
|
|
u16(1),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_SECTION,
|
|
0},
|
|
{{{'.', 'i', 'd', 'a', 't', 'a', '$', '6'}},
|
|
u32(0),
|
|
u16(2),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_STATIC,
|
|
0},
|
|
{{{'.', 'i', 'd', 'a', 't', 'a', '$', '4'}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_SECTION,
|
|
0},
|
|
{{{'.', 'i', 'd', 'a', 't', 'a', '$', '5'}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_SECTION,
|
|
0},
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
};
|
|
// TODO: Name.Offset.Offset here and in the all similar places below
|
|
// suggests a names refactoring. Maybe StringTableOffset.Value?
|
|
SymbolTable[0].Name.Offset.Offset =
|
|
sizeof(uint32_t);
|
|
SymbolTable[5].Name.Offset.Offset =
|
|
sizeof(uint32_t) + ImportDescriptorSymbolName.length() + 1;
|
|
SymbolTable[6].Name.Offset.Offset =
|
|
sizeof(uint32_t) + ImportDescriptorSymbolName.length() + 1 +
|
|
NullImportDescriptorSymbolName.length() + 1;
|
|
append(Buffer, SymbolTable);
|
|
|
|
// String Table
|
|
writeStringTable(Buffer,
|
|
{ImportDescriptorSymbolName, NullImportDescriptorSymbolName,
|
|
NullThunkSymbolName});
|
|
|
|
StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
|
|
return {MemoryBufferRef(F, ImportName)};
|
|
}
|
|
|
|
NewArchiveMember
|
|
ObjectFactory::createNullImportDescriptor(std::vector<uint8_t> &Buffer) {
|
|
const uint32_t NumberOfSections = 1;
|
|
const uint32_t NumberOfSymbols = 1;
|
|
|
|
// COFF Header
|
|
coff_file_header Header{
|
|
u16(NativeMachine),
|
|
u16(NumberOfSections),
|
|
u32(0),
|
|
u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
|
|
// .idata$3
|
|
sizeof(coff_import_directory_table_entry)),
|
|
u32(NumberOfSymbols),
|
|
u16(0),
|
|
u16(is64Bit() ? C_Invalid : IMAGE_FILE_32BIT_MACHINE),
|
|
};
|
|
append(Buffer, Header);
|
|
|
|
// Section Header Table
|
|
const coff_section SectionTable[NumberOfSections] = {
|
|
{{'.', 'i', 'd', 'a', 't', 'a', '$', '3'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(sizeof(coff_import_directory_table_entry)),
|
|
u32(sizeof(coff_file_header) +
|
|
(NumberOfSections * sizeof(coff_section))),
|
|
u32(0),
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
u32(IMAGE_SCN_ALIGN_4BYTES | IMAGE_SCN_CNT_INITIALIZED_DATA |
|
|
IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE)},
|
|
};
|
|
append(Buffer, SectionTable);
|
|
|
|
// .idata$3
|
|
const coff_import_directory_table_entry ImportDescriptor{
|
|
u32(0), u32(0), u32(0), u32(0), u32(0),
|
|
};
|
|
append(Buffer, ImportDescriptor);
|
|
|
|
// Symbol Table
|
|
coff_symbol16 SymbolTable[NumberOfSymbols] = {
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(1),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
};
|
|
SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
|
|
append(Buffer, SymbolTable);
|
|
|
|
// String Table
|
|
writeStringTable(Buffer, {NullImportDescriptorSymbolName});
|
|
|
|
StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
|
|
return {MemoryBufferRef(F, ImportName)};
|
|
}
|
|
|
|
NewArchiveMember ObjectFactory::createNullThunk(std::vector<uint8_t> &Buffer) {
|
|
const uint32_t NumberOfSections = 2;
|
|
const uint32_t NumberOfSymbols = 1;
|
|
uint32_t VASize = is64Bit() ? 8 : 4;
|
|
|
|
// COFF Header
|
|
coff_file_header Header{
|
|
u16(NativeMachine),
|
|
u16(NumberOfSections),
|
|
u32(0),
|
|
u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section)) +
|
|
// .idata$5
|
|
VASize +
|
|
// .idata$4
|
|
VASize),
|
|
u32(NumberOfSymbols),
|
|
u16(0),
|
|
u16(is64Bit() ? C_Invalid : IMAGE_FILE_32BIT_MACHINE),
|
|
};
|
|
append(Buffer, Header);
|
|
|
|
// Section Header Table
|
|
const coff_section SectionTable[NumberOfSections] = {
|
|
{{'.', 'i', 'd', 'a', 't', 'a', '$', '5'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(VASize),
|
|
u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section)),
|
|
u32(0),
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
u32((is64Bit() ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES) |
|
|
IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
|
|
IMAGE_SCN_MEM_WRITE)},
|
|
{{'.', 'i', 'd', 'a', 't', 'a', '$', '4'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(VASize),
|
|
u32(sizeof(coff_file_header) + NumberOfSections * sizeof(coff_section) +
|
|
VASize),
|
|
u32(0),
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
u32((is64Bit() ? IMAGE_SCN_ALIGN_8BYTES : IMAGE_SCN_ALIGN_4BYTES) |
|
|
IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ |
|
|
IMAGE_SCN_MEM_WRITE)},
|
|
};
|
|
append(Buffer, SectionTable);
|
|
|
|
// .idata$5, ILT
|
|
append(Buffer, u32(0));
|
|
if (is64Bit())
|
|
append(Buffer, u32(0));
|
|
|
|
// .idata$4, IAT
|
|
append(Buffer, u32(0));
|
|
if (is64Bit())
|
|
append(Buffer, u32(0));
|
|
|
|
// Symbol Table
|
|
coff_symbol16 SymbolTable[NumberOfSymbols] = {
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(1),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
};
|
|
SymbolTable[0].Name.Offset.Offset = sizeof(uint32_t);
|
|
append(Buffer, SymbolTable);
|
|
|
|
// String Table
|
|
writeStringTable(Buffer, {NullThunkSymbolName});
|
|
|
|
StringRef F{reinterpret_cast<const char *>(Buffer.data()), Buffer.size()};
|
|
return {MemoryBufferRef{F, ImportName}};
|
|
}
|
|
|
|
NewArchiveMember
|
|
ObjectFactory::createShortImport(StringRef Sym, uint16_t Ordinal,
|
|
ImportType ImportType, ImportNameType NameType,
|
|
StringRef ExportName, MachineTypes Machine) {
|
|
size_t ImpSize = ImportName.size() + Sym.size() + 2; // +2 for NULs
|
|
if (!ExportName.empty())
|
|
ImpSize += ExportName.size() + 1;
|
|
size_t Size = sizeof(coff_import_header) + ImpSize;
|
|
char *Buf = Alloc.Allocate<char>(Size);
|
|
memset(Buf, 0, Size);
|
|
char *P = Buf;
|
|
|
|
// Write short import library.
|
|
auto *Imp = reinterpret_cast<coff_import_header *>(P);
|
|
P += sizeof(*Imp);
|
|
Imp->Sig2 = 0xFFFF;
|
|
Imp->Machine = Machine;
|
|
Imp->SizeOfData = ImpSize;
|
|
if (Ordinal > 0)
|
|
Imp->OrdinalHint = Ordinal;
|
|
Imp->TypeInfo = (NameType << 2) | ImportType;
|
|
|
|
// Write symbol name and DLL name.
|
|
memcpy(P, Sym.data(), Sym.size());
|
|
P += Sym.size() + 1;
|
|
memcpy(P, ImportName.data(), ImportName.size());
|
|
if (!ExportName.empty()) {
|
|
P += ImportName.size() + 1;
|
|
memcpy(P, ExportName.data(), ExportName.size());
|
|
}
|
|
|
|
return {MemoryBufferRef(StringRef(Buf, Size), ImportName)};
|
|
}
|
|
|
|
NewArchiveMember ObjectFactory::createWeakExternal(StringRef Sym,
|
|
StringRef Weak, bool Imp,
|
|
MachineTypes Machine) {
|
|
std::vector<uint8_t> Buffer;
|
|
const uint32_t NumberOfSections = 1;
|
|
const uint32_t NumberOfSymbols = 5;
|
|
|
|
// COFF Header
|
|
coff_file_header Header{
|
|
u16(Machine),
|
|
u16(NumberOfSections),
|
|
u32(0),
|
|
u32(sizeof(Header) + (NumberOfSections * sizeof(coff_section))),
|
|
u32(NumberOfSymbols),
|
|
u16(0),
|
|
u16(0),
|
|
};
|
|
append(Buffer, Header);
|
|
|
|
// Section Header Table
|
|
const coff_section SectionTable[NumberOfSections] = {
|
|
{{'.', 'd', 'r', 'e', 'c', 't', 'v', 'e'},
|
|
u32(0),
|
|
u32(0),
|
|
u32(0),
|
|
u32(0),
|
|
u32(0),
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
u32(IMAGE_SCN_LNK_INFO | IMAGE_SCN_LNK_REMOVE)}};
|
|
append(Buffer, SectionTable);
|
|
|
|
// Symbol Table
|
|
coff_symbol16 SymbolTable[NumberOfSymbols] = {
|
|
{{{'@', 'c', 'o', 'm', 'p', '.', 'i', 'd'}},
|
|
u32(0),
|
|
u16(0xFFFF),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_STATIC,
|
|
0},
|
|
{{{'@', 'f', 'e', 'a', 't', '.', '0', '0'}},
|
|
u32(0),
|
|
u16(0xFFFF),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_STATIC,
|
|
0},
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_EXTERNAL,
|
|
0},
|
|
{{{0, 0, 0, 0, 0, 0, 0, 0}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_WEAK_EXTERNAL,
|
|
1},
|
|
{{{2, 0, 0, 0, IMAGE_WEAK_EXTERN_SEARCH_ALIAS, 0, 0, 0}},
|
|
u32(0),
|
|
u16(0),
|
|
u16(0),
|
|
IMAGE_SYM_CLASS_NULL,
|
|
0},
|
|
};
|
|
SymbolTable[2].Name.Offset.Offset = sizeof(uint32_t);
|
|
|
|
//__imp_ String Table
|
|
StringRef Prefix = Imp ? "__imp_" : "";
|
|
SymbolTable[3].Name.Offset.Offset =
|
|
sizeof(uint32_t) + Sym.size() + Prefix.size() + 1;
|
|
append(Buffer, SymbolTable);
|
|
writeStringTable(Buffer, {(Prefix + Sym).str(),
|
|
(Prefix + Weak).str()});
|
|
|
|
// Copied here so we can still use writeStringTable
|
|
char *Buf = Alloc.Allocate<char>(Buffer.size());
|
|
memcpy(Buf, Buffer.data(), Buffer.size());
|
|
return {MemoryBufferRef(StringRef(Buf, Buffer.size()), ImportName)};
|
|
}
|
|
|
|
Error writeImportLibrary(StringRef ImportName, StringRef Path,
|
|
ArrayRef<COFFShortExport> Exports,
|
|
MachineTypes Machine, bool MinGW,
|
|
ArrayRef<COFFShortExport> NativeExports,
|
|
bool AddUnderscores) {
|
|
|
|
MachineTypes NativeMachine = Machine;
|
|
if (isArm64EC(Machine)) {
|
|
NativeMachine = IMAGE_FILE_MACHINE_ARM64;
|
|
Machine = IMAGE_FILE_MACHINE_ARM64EC;
|
|
}
|
|
|
|
std::vector<NewArchiveMember> Members;
|
|
ObjectFactory OF(llvm::sys::path::filename(ImportName), NativeMachine);
|
|
|
|
std::vector<uint8_t> ImportDescriptor;
|
|
Members.push_back(OF.createImportDescriptor(ImportDescriptor));
|
|
|
|
std::vector<uint8_t> NullImportDescriptor;
|
|
Members.push_back(OF.createNullImportDescriptor(NullImportDescriptor));
|
|
|
|
std::vector<uint8_t> NullThunk;
|
|
Members.push_back(OF.createNullThunk(NullThunk));
|
|
|
|
auto addExports = [&](ArrayRef<COFFShortExport> Exp,
|
|
MachineTypes M) -> Error {
|
|
for (const COFFShortExport &E : Exp) {
|
|
if (E.Private)
|
|
continue;
|
|
|
|
ImportType ImportType = IMPORT_CODE;
|
|
if (E.Data)
|
|
ImportType = IMPORT_DATA;
|
|
if (E.Constant)
|
|
ImportType = IMPORT_CONST;
|
|
|
|
StringRef SymbolName = E.SymbolName.empty() ? E.Name : E.SymbolName;
|
|
std::string Name;
|
|
|
|
if (E.ExtName.empty()) {
|
|
Name = std::string(SymbolName);
|
|
} else {
|
|
Expected<std::string> ReplacedName =
|
|
replace(SymbolName, E.Name, E.ExtName);
|
|
if (!ReplacedName)
|
|
return ReplacedName.takeError();
|
|
Name.swap(*ReplacedName);
|
|
}
|
|
|
|
if (!E.ImportName.empty() && Name != E.ImportName) {
|
|
StringRef Prefix = "";
|
|
if (Machine == IMAGE_FILE_MACHINE_I386 && AddUnderscores)
|
|
Prefix = "_";
|
|
|
|
if (ImportType == IMPORT_CODE)
|
|
Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(),
|
|
Name, false, M));
|
|
Members.push_back(OF.createWeakExternal((Prefix + E.ImportName).str(),
|
|
Name, true, M));
|
|
continue;
|
|
}
|
|
|
|
ImportNameType NameType;
|
|
std::string ExportName;
|
|
if (E.Noname) {
|
|
NameType = IMPORT_ORDINAL;
|
|
} else if (!E.ExportAs.empty()) {
|
|
NameType = IMPORT_NAME_EXPORTAS;
|
|
ExportName = E.ExportAs;
|
|
} else {
|
|
NameType = getNameType(SymbolName, E.Name, M, MinGW);
|
|
}
|
|
|
|
// On ARM64EC, use EXPORTAS to import demangled name for mangled symbols.
|
|
if (ImportType == IMPORT_CODE && isArm64EC(M)) {
|
|
if (std::optional<std::string> MangledName =
|
|
getArm64ECMangledFunctionName(Name)) {
|
|
if (!E.Noname && ExportName.empty()) {
|
|
NameType = IMPORT_NAME_EXPORTAS;
|
|
ExportName.swap(Name);
|
|
}
|
|
Name = std::move(*MangledName);
|
|
} else if (!E.Noname && ExportName.empty()) {
|
|
NameType = IMPORT_NAME_EXPORTAS;
|
|
ExportName = std::move(*getArm64ECDemangledFunctionName(Name));
|
|
}
|
|
}
|
|
|
|
Members.push_back(OF.createShortImport(Name, E.Ordinal, ImportType,
|
|
NameType, ExportName, M));
|
|
}
|
|
return Error::success();
|
|
};
|
|
|
|
if (Error e = addExports(Exports, Machine))
|
|
return e;
|
|
if (Error e = addExports(NativeExports, NativeMachine))
|
|
return e;
|
|
|
|
return writeArchive(Path, Members, SymtabWritingMode::NormalSymtab,
|
|
object::Archive::K_COFF,
|
|
/*Deterministic*/ true, /*Thin*/ false,
|
|
/*OldArchiveBuf*/ nullptr, isArm64EC(Machine));
|
|
}
|
|
|
|
} // namespace object
|
|
} // namespace llvm
|