You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
16 KiB
451 lines
16 KiB
//===- GNUArchiveReader.cpp -----------------------------------------------===//
|
|
//
|
|
// The MCLinker Project
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
#include "mcld/LD/GNUArchiveReader.h"
|
|
|
|
#include "mcld/InputTree.h"
|
|
#include "mcld/LinkerConfig.h"
|
|
#include "mcld/Module.h"
|
|
#include "mcld/ADT/SizeTraits.h"
|
|
#include "mcld/MC/Attribute.h"
|
|
#include "mcld/MC/Input.h"
|
|
#include "mcld/LD/ELFObjectReader.h"
|
|
#include "mcld/LD/ResolveInfo.h"
|
|
#include "mcld/Support/FileHandle.h"
|
|
#include "mcld/Support/FileSystem.h"
|
|
#include "mcld/Support/MemoryArea.h"
|
|
#include "mcld/Support/MsgHandling.h"
|
|
#include "mcld/Support/Path.h"
|
|
|
|
#include <llvm/ADT/StringRef.h>
|
|
#include <llvm/Support/Host.h>
|
|
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
|
|
namespace mcld {
|
|
|
|
GNUArchiveReader::GNUArchiveReader(Module& pModule,
|
|
ELFObjectReader& pELFObjectReader)
|
|
: m_Module(pModule), m_ELFObjectReader(pELFObjectReader) {
|
|
}
|
|
|
|
GNUArchiveReader::~GNUArchiveReader() {
|
|
}
|
|
|
|
/// isMyFormat
|
|
bool GNUArchiveReader::isMyFormat(Input& pInput, bool& pContinue) const {
|
|
assert(pInput.hasMemArea());
|
|
if (pInput.memArea()->size() < Archive::MAGIC_LEN)
|
|
return false;
|
|
|
|
llvm::StringRef region =
|
|
pInput.memArea()->request(pInput.fileOffset(), Archive::MAGIC_LEN);
|
|
const char* str = region.begin();
|
|
|
|
bool result = false;
|
|
assert(str != NULL);
|
|
pContinue = true;
|
|
if (isArchive(str) || isThinArchive(str))
|
|
result = true;
|
|
|
|
return result;
|
|
}
|
|
|
|
/// isArchive
|
|
bool GNUArchiveReader::isArchive(const char* pStr) const {
|
|
return (memcmp(pStr, Archive::MAGIC, Archive::MAGIC_LEN) == 0);
|
|
}
|
|
|
|
/// isThinArchive
|
|
bool GNUArchiveReader::isThinArchive(const char* pStr) const {
|
|
return (memcmp(pStr, Archive::THIN_MAGIC, Archive::MAGIC_LEN) == 0);
|
|
}
|
|
|
|
/// isThinArchive
|
|
bool GNUArchiveReader::isThinArchive(Input& pInput) const {
|
|
assert(pInput.hasMemArea());
|
|
llvm::StringRef region =
|
|
pInput.memArea()->request(pInput.fileOffset(), Archive::MAGIC_LEN);
|
|
const char* str = region.begin();
|
|
|
|
bool result = false;
|
|
assert(str != NULL);
|
|
if (isThinArchive(str))
|
|
result = true;
|
|
|
|
return result;
|
|
}
|
|
|
|
bool GNUArchiveReader::readArchive(const LinkerConfig& pConfig,
|
|
Archive& pArchive) {
|
|
// bypass the empty archive
|
|
if (Archive::MAGIC_LEN == pArchive.getARFile().memArea()->size())
|
|
return true;
|
|
|
|
if (pArchive.getARFile().attribute()->isWholeArchive())
|
|
return includeAllMembers(pConfig, pArchive);
|
|
|
|
// if this is the first time read this archive, setup symtab and strtab
|
|
if (pArchive.getSymbolTable().empty()) {
|
|
// read the symtab of the archive
|
|
readSymbolTable(pArchive);
|
|
|
|
// read the strtab of the archive
|
|
readStringTable(pArchive);
|
|
|
|
// add root archive to ArchiveMemberMap
|
|
pArchive.addArchiveMember(pArchive.getARFile().name(),
|
|
pArchive.inputs().root(),
|
|
&InputTree::Downward);
|
|
}
|
|
|
|
// include the needed members in the archive and build up the input tree
|
|
bool willSymResolved;
|
|
do {
|
|
willSymResolved = false;
|
|
for (size_t idx = 0; idx < pArchive.numOfSymbols(); ++idx) {
|
|
// bypass if we already decided to include this symbol or not
|
|
if (Archive::Symbol::Unknown != pArchive.getSymbolStatus(idx))
|
|
continue;
|
|
|
|
// bypass if another symbol with the same object file offset is included
|
|
if (pArchive.hasObjectMember(pArchive.getObjFileOffset(idx))) {
|
|
pArchive.setSymbolStatus(idx, Archive::Symbol::Include);
|
|
continue;
|
|
}
|
|
|
|
// check if we should include this defined symbol
|
|
Archive::Symbol::Status status =
|
|
shouldIncludeSymbol(pArchive.getSymbolName(idx));
|
|
if (Archive::Symbol::Unknown != status)
|
|
pArchive.setSymbolStatus(idx, status);
|
|
|
|
if (Archive::Symbol::Include == status) {
|
|
// include the object member from the given offset
|
|
includeMember(pConfig, pArchive, pArchive.getObjFileOffset(idx));
|
|
willSymResolved = true;
|
|
} // end of if
|
|
} // end of for
|
|
} while (willSymResolved);
|
|
|
|
return true;
|
|
}
|
|
|
|
/// readMemberHeader - read the header of a member in a archive file and then
|
|
/// return the corresponding archive member (it may be an input object or
|
|
/// another archive)
|
|
/// @param pArchiveRoot - the archive root that holds the strtab (extended
|
|
/// name table)
|
|
/// @param pArchiveFile - the archive that contains the needed object
|
|
/// @param pFileOffset - file offset of the member header in the archive
|
|
/// @param pNestedOffset - used when we find a nested archive
|
|
/// @param pMemberSize - the file size of this member
|
|
Input* GNUArchiveReader::readMemberHeader(Archive& pArchiveRoot,
|
|
Input& pArchiveFile,
|
|
uint32_t pFileOffset,
|
|
uint32_t& pNestedOffset,
|
|
size_t& pMemberSize) {
|
|
assert(pArchiveFile.hasMemArea());
|
|
|
|
llvm::StringRef header_region = pArchiveFile.memArea()->request(
|
|
(pArchiveFile.fileOffset() + pFileOffset), sizeof(Archive::MemberHeader));
|
|
const Archive::MemberHeader* header =
|
|
reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
|
|
|
|
assert(memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)) ==
|
|
0);
|
|
|
|
pMemberSize = atoi(header->size);
|
|
|
|
// parse the member name and nested offset if any
|
|
std::string member_name;
|
|
llvm::StringRef name_field(header->name, sizeof(header->name));
|
|
if (header->name[0] != '/') {
|
|
// this is an object file in an archive
|
|
size_t pos = name_field.find_first_of('/');
|
|
member_name.assign(name_field.substr(0, pos).str());
|
|
} else {
|
|
// this is an object/archive file in a thin archive
|
|
size_t begin = 1;
|
|
size_t end = name_field.find_first_of(" :");
|
|
uint32_t name_offset = 0;
|
|
// parse the name offset
|
|
name_field.substr(begin, end - begin).getAsInteger(10, name_offset);
|
|
|
|
if (name_field[end] == ':') {
|
|
// there is a nested offset
|
|
begin = end + 1;
|
|
end = name_field.find_first_of(' ', begin);
|
|
name_field.substr(begin, end - begin).getAsInteger(10, pNestedOffset);
|
|
}
|
|
|
|
// get the member name from the extended name table
|
|
assert(pArchiveRoot.hasStrTable());
|
|
begin = name_offset;
|
|
end = pArchiveRoot.getStrTable().find_first_of('\n', begin);
|
|
member_name.assign(
|
|
pArchiveRoot.getStrTable().substr(begin, end - begin - 1));
|
|
}
|
|
|
|
Input* member = NULL;
|
|
bool isThinAR = isThinArchive(pArchiveFile);
|
|
if (!isThinAR) {
|
|
// this is an object file in an archive
|
|
member = pArchiveRoot.getMemberFile(
|
|
pArchiveFile,
|
|
isThinAR,
|
|
member_name,
|
|
pArchiveFile.path(),
|
|
(pFileOffset + sizeof(Archive::MemberHeader)));
|
|
} else {
|
|
// this is a member in a thin archive
|
|
// try to find if this is a archive already in the map first
|
|
Archive::ArchiveMember* ar_member =
|
|
pArchiveRoot.getArchiveMember(member_name);
|
|
if (ar_member != NULL) {
|
|
return ar_member->file;
|
|
}
|
|
|
|
// get nested file path, the nested file's member name is the relative
|
|
// path to the archive containing it.
|
|
sys::fs::Path input_path(pArchiveFile.path().parent_path());
|
|
if (!input_path.empty())
|
|
input_path.append(sys::fs::Path(member_name));
|
|
else
|
|
input_path.assign(member_name);
|
|
|
|
member = pArchiveRoot.getMemberFile(
|
|
pArchiveFile, isThinAR, member_name, input_path);
|
|
}
|
|
|
|
return member;
|
|
}
|
|
|
|
template <size_t SIZE>
|
|
static void readSymbolTableEntries(Archive& pArchive,
|
|
llvm::StringRef pMemRegion) {
|
|
typedef typename SizeTraits<SIZE>::Offset Offset;
|
|
|
|
const Offset* data = reinterpret_cast<const Offset*>(pMemRegion.begin());
|
|
|
|
// read the number of symbols
|
|
Offset number = 0;
|
|
if (llvm::sys::IsLittleEndianHost)
|
|
number = mcld::bswap<SIZE>(*data);
|
|
else
|
|
number = *data;
|
|
|
|
// set up the pointers for file offset and name offset
|
|
++data;
|
|
const char* name = reinterpret_cast<const char*>(data + number);
|
|
|
|
// add the archive symbols
|
|
for (Offset i = 0; i < number; ++i) {
|
|
if (llvm::sys::IsLittleEndianHost)
|
|
pArchive.addSymbol(name, mcld::bswap<SIZE>(*data));
|
|
else
|
|
pArchive.addSymbol(name, *data);
|
|
name += strlen(name) + 1;
|
|
++data;
|
|
}
|
|
}
|
|
|
|
/// readSymbolTable - read the archive symbol map (armap)
|
|
bool GNUArchiveReader::readSymbolTable(Archive& pArchive) {
|
|
assert(pArchive.getARFile().hasMemArea());
|
|
MemoryArea* memory_area = pArchive.getARFile().memArea();
|
|
|
|
llvm::StringRef header_region = memory_area->request(
|
|
(pArchive.getARFile().fileOffset() + Archive::MAGIC_LEN),
|
|
sizeof(Archive::MemberHeader));
|
|
const Archive::MemberHeader* header =
|
|
reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
|
|
assert(memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)) ==
|
|
0);
|
|
|
|
int symtab_size = atoi(header->size);
|
|
pArchive.setSymTabSize(symtab_size);
|
|
|
|
if (!pArchive.getARFile().attribute()->isWholeArchive()) {
|
|
llvm::StringRef symtab_region = memory_area->request(
|
|
(pArchive.getARFile().fileOffset() + Archive::MAGIC_LEN +
|
|
sizeof(Archive::MemberHeader)),
|
|
symtab_size);
|
|
|
|
if (strncmp(header->name,
|
|
Archive::SVR4_SYMTAB_NAME,
|
|
strlen(Archive::SVR4_SYMTAB_NAME)) == 0)
|
|
readSymbolTableEntries<32>(pArchive, symtab_region);
|
|
else if (strncmp(header->name,
|
|
Archive::IRIX6_SYMTAB_NAME,
|
|
strlen(Archive::IRIX6_SYMTAB_NAME)) == 0)
|
|
readSymbolTableEntries<64>(pArchive, symtab_region);
|
|
else
|
|
unreachable(diag::err_unsupported_archive);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// readStringTable - read the strtab for long file name of the archive
|
|
bool GNUArchiveReader::readStringTable(Archive& pArchive) {
|
|
size_t offset = Archive::MAGIC_LEN + sizeof(Archive::MemberHeader) +
|
|
pArchive.getSymTabSize();
|
|
|
|
if ((offset & 1) != 0x0)
|
|
++offset;
|
|
|
|
assert(pArchive.getARFile().hasMemArea());
|
|
MemoryArea* memory_area = pArchive.getARFile().memArea();
|
|
|
|
llvm::StringRef header_region =
|
|
memory_area->request((pArchive.getARFile().fileOffset() + offset),
|
|
sizeof(Archive::MemberHeader));
|
|
const Archive::MemberHeader* header =
|
|
reinterpret_cast<const Archive::MemberHeader*>(header_region.begin());
|
|
|
|
assert(memcmp(header->fmag, Archive::MEMBER_MAGIC, sizeof(header->fmag)) ==
|
|
0);
|
|
|
|
if (memcmp(header->name, Archive::STRTAB_NAME, sizeof(header->name)) == 0) {
|
|
// read the extended name table
|
|
int strtab_size = atoi(header->size);
|
|
llvm::StringRef strtab_region =
|
|
memory_area->request((pArchive.getARFile().fileOffset() + offset +
|
|
sizeof(Archive::MemberHeader)),
|
|
strtab_size);
|
|
const char* strtab = strtab_region.begin();
|
|
pArchive.getStrTable().assign(strtab, strtab_size);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// shouldIncludeStatus - given a sym name from armap and check if including
|
|
/// the corresponding archive member, and then return the decision
|
|
enum Archive::Symbol::Status GNUArchiveReader::shouldIncludeSymbol(
|
|
const llvm::StringRef& pSymName) const {
|
|
// TODO: handle symbol version issue and user defined symbols
|
|
const ResolveInfo* info = m_Module.getNamePool().findInfo(pSymName);
|
|
if (info != NULL) {
|
|
if (!info->isUndef())
|
|
return Archive::Symbol::Exclude;
|
|
if (info->isWeak())
|
|
return Archive::Symbol::Unknown;
|
|
return Archive::Symbol::Include;
|
|
}
|
|
return Archive::Symbol::Unknown;
|
|
}
|
|
|
|
/// includeMember - include the object member in the given file offset, and
|
|
/// return the size of the object
|
|
/// @param pConfig - LinkerConfig
|
|
/// @param pArchiveRoot - the archive root
|
|
/// @param pFileOffset - file offset of the member header in the archive
|
|
size_t GNUArchiveReader::includeMember(const LinkerConfig& pConfig,
|
|
Archive& pArchive,
|
|
uint32_t pFileOffset) {
|
|
Input* cur_archive = &(pArchive.getARFile());
|
|
Input* member = NULL;
|
|
uint32_t file_offset = pFileOffset;
|
|
size_t size = 0;
|
|
do {
|
|
uint32_t nested_offset = 0;
|
|
// use the file offset in current archive to find out the member we
|
|
// want to include
|
|
member = readMemberHeader(
|
|
pArchive, *cur_archive, file_offset, nested_offset, size);
|
|
assert(member != NULL);
|
|
// bypass if we get an archive that is already in the map
|
|
if (Input::Archive == member->type()) {
|
|
cur_archive = member;
|
|
file_offset = nested_offset;
|
|
continue;
|
|
}
|
|
|
|
// insert a node into the subtree of current archive.
|
|
Archive::ArchiveMember* parent =
|
|
pArchive.getArchiveMember(cur_archive->name());
|
|
|
|
assert(parent != NULL);
|
|
pArchive.inputs().insert(parent->lastPos, *(parent->move), *member);
|
|
|
|
// move the iterator to new created node, and also adjust the
|
|
// direction to Afterward for next insertion in this subtree
|
|
parent->move->move(parent->lastPos);
|
|
parent->move = &InputTree::Afterward;
|
|
bool doContinue = false;
|
|
|
|
if (m_ELFObjectReader.isMyFormat(*member, doContinue)) {
|
|
member->setType(Input::Object);
|
|
// Set this object as no export if the archive is in the exclude libs.
|
|
if (pArchive.getARFile().noExport()) {
|
|
member->setNoExport();
|
|
}
|
|
pArchive.addObjectMember(pFileOffset, parent->lastPos);
|
|
m_ELFObjectReader.readHeader(*member);
|
|
m_ELFObjectReader.readSections(*member);
|
|
m_ELFObjectReader.readSymbols(*member);
|
|
m_Module.getObjectList().push_back(member);
|
|
} else if (doContinue && isMyFormat(*member, doContinue)) {
|
|
member->setType(Input::Archive);
|
|
// when adding a new archive node, set the iterator to archive
|
|
// itself, and set the direction to Downward
|
|
pArchive.addArchiveMember(
|
|
member->name(), parent->lastPos, &InputTree::Downward);
|
|
cur_archive = member;
|
|
file_offset = nested_offset;
|
|
} else {
|
|
warning(diag::warn_unrecognized_input_file)
|
|
<< member->path() << pConfig.targets().triple().str();
|
|
}
|
|
} while (Input::Object != member->type());
|
|
return size;
|
|
}
|
|
|
|
/// includeAllMembers - include all object members. This is called if
|
|
/// --whole-archive is the attribute for this archive file.
|
|
bool GNUArchiveReader::includeAllMembers(const LinkerConfig& pConfig,
|
|
Archive& pArchive) {
|
|
// read the symtab of the archive
|
|
readSymbolTable(pArchive);
|
|
|
|
// read the strtab of the archive
|
|
readStringTable(pArchive);
|
|
|
|
// add root archive to ArchiveMemberMap
|
|
pArchive.addArchiveMember(pArchive.getARFile().name(),
|
|
pArchive.inputs().root(),
|
|
&InputTree::Downward);
|
|
|
|
bool isThinAR = isThinArchive(pArchive.getARFile());
|
|
uint32_t begin_offset = pArchive.getARFile().fileOffset() +
|
|
Archive::MAGIC_LEN + sizeof(Archive::MemberHeader) +
|
|
pArchive.getSymTabSize();
|
|
if (pArchive.hasStrTable()) {
|
|
if ((begin_offset & 1) != 0x0)
|
|
++begin_offset;
|
|
begin_offset +=
|
|
sizeof(Archive::MemberHeader) + pArchive.getStrTable().size();
|
|
}
|
|
uint32_t end_offset = pArchive.getARFile().memArea()->size();
|
|
for (uint32_t offset = begin_offset; offset < end_offset;
|
|
offset += sizeof(Archive::MemberHeader)) {
|
|
size_t size = includeMember(pConfig, pArchive, offset);
|
|
|
|
if (!isThinAR) {
|
|
offset += size;
|
|
}
|
|
|
|
if ((offset & 1) != 0x0)
|
|
++offset;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace mcld
|