llvm-6502/lib/Archive/ArchiveReader.cpp
Chandler Carruth d04a8d4b33 Use the new script to sort the includes of every file under lib.
Sooooo many of these had incorrect or strange main module includes.
I have manually inspected all of these, and fixed the main module
include to be the nearest plausible thing I could find. If you own or
care about any of these source files, I encourage you to take some time
and check that these edits were sensible. I can't have broken anything
(I strictly added headers, and reordered them, never removed), but they
may not be the headers you'd really like to identify as containing the
API being implemented.

Many forward declarations and missing includes were added to a header
files to allow them to parse cleanly when included first. The main
module rule does in fact have its merits. =]

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@169131 91177308-0d34-0410-b5e6-96231b3b80d8
2012-12-03 16:50:05 +00:00

634 lines
19 KiB
C++

//===-- ArchiveReader.cpp - Read LLVM archive files -------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Builds up standard unix archive files (.a) containing LLVM bitcode.
//
//===----------------------------------------------------------------------===//
#include "llvm/Bitcode/Archive.h"
#include "ArchiveInternals.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/Module.h"
#include "llvm/Support/MemoryBuffer.h"
#include <cstdio>
#include <cstdlib>
#include <memory>
using namespace llvm;
/// Read a variable-bit-rate encoded unsigned integer
static inline unsigned readInteger(const char*&At, const char*End) {
unsigned Shift = 0;
unsigned Result = 0;
do {
if (At == End)
return Result;
Result |= (unsigned)((*At++) & 0x7F) << Shift;
Shift += 7;
} while (At[-1] & 0x80);
return Result;
}
// Completely parse the Archive's symbol table and populate symTab member var.
bool
Archive::parseSymbolTable(const void* data, unsigned size, std::string* error) {
const char* At = (const char*) data;
const char* End = At + size;
while (At < End) {
unsigned offset = readInteger(At, End);
if (At == End) {
if (error)
*error = "Ran out of data reading vbr_uint for symtab offset!";
return false;
}
unsigned length = readInteger(At, End);
if (At == End) {
if (error)
*error = "Ran out of data reading vbr_uint for symtab length!";
return false;
}
if (At + length > End) {
if (error)
*error = "Malformed symbol table: length not consistent with size";
return false;
}
// we don't care if it can't be inserted (duplicate entry)
symTab.insert(std::make_pair(std::string(At, length), offset));
At += length;
}
symTabSize = size;
return true;
}
// This member parses an ArchiveMemberHeader that is presumed to be pointed to
// by At. The At pointer is updated to the byte just after the header, which
// can be variable in size.
ArchiveMember*
Archive::parseMemberHeader(const char*& At, const char* End, std::string* error)
{
if (At + sizeof(ArchiveMemberHeader) >= End) {
if (error)
*error = "Unexpected end of file";
return 0;
}
// Cast archive member header
const ArchiveMemberHeader* Hdr = (const ArchiveMemberHeader*)At;
At += sizeof(ArchiveMemberHeader);
int flags = 0;
int MemberSize = atoi(Hdr->size);
assert(MemberSize >= 0);
// Check the size of the member for sanity
if (At + MemberSize > End) {
if (error)
*error = "invalid member length in archive file";
return 0;
}
// Check the member signature
if (!Hdr->checkSignature()) {
if (error)
*error = "invalid file member signature";
return 0;
}
// Convert and check the member name
// The empty name ( '/' and 15 blanks) is for a foreign (non-LLVM) symbol
// table. The special name "//" and 14 blanks is for a string table, used
// for long file names. This library doesn't generate either of those but
// it will accept them. If the name starts with #1/ and the remainder is
// digits, then those digits specify the length of the name that is
// stored immediately following the header. The special name
// __LLVM_SYM_TAB__ identifies the symbol table for LLVM bitcode.
// Anything else is a regular, short filename that is terminated with
// a '/' and blanks.
std::string pathname;
switch (Hdr->name[0]) {
case '#':
if (Hdr->name[1] == '1' && Hdr->name[2] == '/') {
if (isdigit(Hdr->name[3])) {
unsigned len = atoi(&Hdr->name[3]);
const char *nulp = (const char *)memchr(At, '\0', len);
pathname.assign(At, nulp != 0 ? (uintptr_t)(nulp - At) : len);
At += len;
MemberSize -= len;
flags |= ArchiveMember::HasLongFilenameFlag;
} else {
if (error)
*error = "invalid long filename";
return 0;
}
} else if (Hdr->name[1] == '_' &&
(0 == memcmp(Hdr->name, ARFILE_LLVM_SYMTAB_NAME, 16))) {
// The member is using a long file name (>15 chars) format.
// This format is standard for 4.4BSD and Mac OSX operating
// systems. LLVM uses it similarly. In this format, the
// remainder of the name field (after #1/) specifies the
// length of the file name which occupy the first bytes of
// the member's data. The pathname already has the #1/ stripped.
pathname.assign(ARFILE_LLVM_SYMTAB_NAME);
flags |= ArchiveMember::LLVMSymbolTableFlag;
}
break;
case '/':
if (Hdr->name[1]== '/') {
if (0 == memcmp(Hdr->name, ARFILE_STRTAB_NAME, 16)) {
pathname.assign(ARFILE_STRTAB_NAME);
flags |= ArchiveMember::StringTableFlag;
} else {
if (error)
*error = "invalid string table name";
return 0;
}
} else if (Hdr->name[1] == ' ') {
if (0 == memcmp(Hdr->name, ARFILE_SVR4_SYMTAB_NAME, 16)) {
pathname.assign(ARFILE_SVR4_SYMTAB_NAME);
flags |= ArchiveMember::SVR4SymbolTableFlag;
} else {
if (error)
*error = "invalid SVR4 symbol table name";
return 0;
}
} else if (isdigit(Hdr->name[1])) {
unsigned index = atoi(&Hdr->name[1]);
if (index < strtab.length()) {
const char* namep = strtab.c_str() + index;
const char* endp = strtab.c_str() + strtab.length();
const char* p = namep;
const char* last_p = p;
while (p < endp) {
if (*p == '\n' && *last_p == '/') {
pathname.assign(namep, last_p - namep);
flags |= ArchiveMember::HasLongFilenameFlag;
break;
}
last_p = p;
p++;
}
if (p >= endp) {
if (error)
*error = "missing name termiantor in string table";
return 0;
}
} else {
if (error)
*error = "name index beyond string table";
return 0;
}
}
break;
case '_':
if (Hdr->name[1] == '_' &&
(0 == memcmp(Hdr->name, ARFILE_BSD4_SYMTAB_NAME, 16))) {
pathname.assign(ARFILE_BSD4_SYMTAB_NAME);
flags |= ArchiveMember::BSD4SymbolTableFlag;
break;
}
/* FALL THROUGH */
default:
const char* slash = (const char*) memchr(Hdr->name, '/', 16);
if (slash == 0)
slash = Hdr->name + 16;
pathname.assign(Hdr->name, slash - Hdr->name);
break;
}
// Determine if this is a bitcode file
switch (sys::IdentifyFileType(At, 4)) {
case sys::Bitcode_FileType:
flags |= ArchiveMember::BitcodeFlag;
break;
default:
flags &= ~ArchiveMember::BitcodeFlag;
break;
}
// Instantiate the ArchiveMember to be filled
ArchiveMember* member = new ArchiveMember(this);
// Fill in fields of the ArchiveMember
member->parent = this;
member->path.set(pathname);
member->info.fileSize = MemberSize;
member->info.modTime.fromEpochTime(atoi(Hdr->date));
unsigned int mode;
sscanf(Hdr->mode, "%o", &mode);
member->info.mode = mode;
member->info.user = atoi(Hdr->uid);
member->info.group = atoi(Hdr->gid);
member->flags = flags;
member->data = At;
return member;
}
bool
Archive::checkSignature(std::string* error) {
// Check the magic string at file's header
if (mapfile->getBufferSize() < 8 || memcmp(base, ARFILE_MAGIC, 8)) {
if (error)
*error = "invalid signature for an archive file";
return false;
}
return true;
}
// This function loads the entire archive and fully populates its ilist with
// the members of the archive file. This is typically used in preparation for
// editing the contents of the archive.
bool
Archive::loadArchive(std::string* error) {
// Set up parsing
members.clear();
symTab.clear();
const char *At = base;
const char *End = mapfile->getBufferEnd();
if (!checkSignature(error))
return false;
At += 8; // Skip the magic string.
bool seenSymbolTable = false;
bool foundFirstFile = false;
while (At < End) {
// parse the member header
const char* Save = At;
ArchiveMember* mbr = parseMemberHeader(At, End, error);
if (!mbr)
return false;
// check if this is the foreign symbol table
if (mbr->isSVR4SymbolTable() || mbr->isBSD4SymbolTable()) {
// We just save this but don't do anything special
// with it. It doesn't count as the "first file".
if (foreignST) {
// What? Multiple foreign symbol tables? Just chuck it
// and retain the last one found.
delete foreignST;
}
foreignST = mbr;
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
} else if (mbr->isStringTable()) {
// Simply suck the entire string table into a string
// variable. This will be used to get the names of the
// members that use the "/ddd" format for their names
// (SVR4 style long names).
strtab.assign(At, mbr->getSize());
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
delete mbr;
} else if (mbr->isLLVMSymbolTable()) {
// This is the LLVM symbol table for the archive. If we've seen it
// already, its an error. Otherwise, parse the symbol table and move on.
if (seenSymbolTable) {
if (error)
*error = "invalid archive: multiple symbol tables";
return false;
}
if (!parseSymbolTable(mbr->getData(), mbr->getSize(), error))
return false;
seenSymbolTable = true;
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
delete mbr; // We don't need this member in the list of members.
} else {
// This is just a regular file. If its the first one, save its offset.
// Otherwise just push it on the list and move on to the next file.
if (!foundFirstFile) {
firstFileOffset = Save - base;
foundFirstFile = true;
}
members.push_back(mbr);
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
}
}
return true;
}
// Open and completely load the archive file.
Archive*
Archive::OpenAndLoad(const sys::Path& file, LLVMContext& C,
std::string* ErrorMessage) {
std::auto_ptr<Archive> result ( new Archive(file, C));
if (result->mapToMemory(ErrorMessage))
return 0;
if (!result->loadArchive(ErrorMessage))
return 0;
return result.release();
}
// Get all the bitcode modules from the archive
bool
Archive::getAllModules(std::vector<Module*>& Modules,
std::string* ErrMessage) {
for (iterator I=begin(), E=end(); I != E; ++I) {
if (I->isBitcode()) {
std::string FullMemberName = archPath.str() +
"(" + I->getPath().str() + ")";
MemoryBuffer *Buffer =
MemoryBuffer::getMemBufferCopy(StringRef(I->getData(), I->getSize()),
FullMemberName.c_str());
Module *M = ParseBitcodeFile(Buffer, Context, ErrMessage);
delete Buffer;
if (!M)
return true;
Modules.push_back(M);
}
}
return false;
}
// Load just the symbol table from the archive file
bool
Archive::loadSymbolTable(std::string* ErrorMsg) {
// Set up parsing
members.clear();
symTab.clear();
const char *At = base;
const char *End = mapfile->getBufferEnd();
// Make sure we're dealing with an archive
if (!checkSignature(ErrorMsg))
return false;
At += 8; // Skip signature
// Parse the first file member header
const char* FirstFile = At;
ArchiveMember* mbr = parseMemberHeader(At, End, ErrorMsg);
if (!mbr)
return false;
if (mbr->isSVR4SymbolTable() || mbr->isBSD4SymbolTable()) {
// Skip the foreign symbol table, we don't do anything with it
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
delete mbr;
// Read the next one
FirstFile = At;
mbr = parseMemberHeader(At, End, ErrorMsg);
if (!mbr) {
delete mbr;
return false;
}
}
if (mbr->isStringTable()) {
// Process the string table entry
strtab.assign((const char*)mbr->getData(), mbr->getSize());
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
delete mbr;
// Get the next one
FirstFile = At;
mbr = parseMemberHeader(At, End, ErrorMsg);
if (!mbr) {
delete mbr;
return false;
}
}
// See if its the symbol table
if (mbr->isLLVMSymbolTable()) {
if (!parseSymbolTable(mbr->getData(), mbr->getSize(), ErrorMsg)) {
delete mbr;
return false;
}
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
delete mbr;
// Can't be any more symtab headers so just advance
FirstFile = At;
} else {
// There's no symbol table in the file. We have to rebuild it from scratch
// because the intent of this method is to get the symbol table loaded so
// it can be searched efficiently.
// Add the member to the members list
members.push_back(mbr);
}
firstFileOffset = FirstFile - base;
return true;
}
// Open the archive and load just the symbol tables
Archive* Archive::OpenAndLoadSymbols(const sys::Path& file,
LLVMContext& C,
std::string* ErrorMessage) {
std::auto_ptr<Archive> result ( new Archive(file, C) );
if (result->mapToMemory(ErrorMessage))
return 0;
if (!result->loadSymbolTable(ErrorMessage))
return 0;
return result.release();
}
// Look up one symbol in the symbol table and return the module that defines
// that symbol.
Module*
Archive::findModuleDefiningSymbol(const std::string& symbol,
std::string* ErrMsg) {
SymTabType::iterator SI = symTab.find(symbol);
if (SI == symTab.end())
return 0;
// The symbol table was previously constructed assuming that the members were
// written without the symbol table header. Because VBR encoding is used, the
// values could not be adjusted to account for the offset of the symbol table
// because that could affect the size of the symbol table due to VBR encoding.
// We now have to account for this by adjusting the offset by the size of the
// symbol table and its header.
unsigned fileOffset =
SI->second + // offset in symbol-table-less file
firstFileOffset; // add offset to first "real" file in archive
// See if the module is already loaded
ModuleMap::iterator MI = modules.find(fileOffset);
if (MI != modules.end())
return MI->second.first;
// Module hasn't been loaded yet, we need to load it
const char* modptr = base + fileOffset;
ArchiveMember* mbr = parseMemberHeader(modptr, mapfile->getBufferEnd(),
ErrMsg);
if (!mbr)
return 0;
// Now, load the bitcode module to get the Module.
std::string FullMemberName = archPath.str() + "(" +
mbr->getPath().str() + ")";
MemoryBuffer *Buffer =
MemoryBuffer::getMemBufferCopy(StringRef(mbr->getData(), mbr->getSize()),
FullMemberName.c_str());
Module *m = getLazyBitcodeModule(Buffer, Context, ErrMsg);
if (!m)
return 0;
modules.insert(std::make_pair(fileOffset, std::make_pair(m, mbr)));
return m;
}
// Look up multiple symbols in the symbol table and return a set of
// Modules that define those symbols.
bool
Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
SmallVectorImpl<Module*>& result,
std::string* error) {
if (!mapfile || !base) {
if (error)
*error = "Empty archive invalid for finding modules defining symbols";
return false;
}
if (symTab.empty()) {
// We don't have a symbol table, so we must build it now but lets also
// make sure that we populate the modules table as we do this to ensure
// that we don't load them twice when findModuleDefiningSymbol is called
// below.
// Get a pointer to the first file
const char* At = base + firstFileOffset;
const char* End = mapfile->getBufferEnd();
while ( At < End) {
// Compute the offset to be put in the symbol table
unsigned offset = At - base - firstFileOffset;
// Parse the file's header
ArchiveMember* mbr = parseMemberHeader(At, End, error);
if (!mbr)
return false;
// If it contains symbols
if (mbr->isBitcode()) {
// Get the symbols
std::vector<std::string> symbols;
std::string FullMemberName = archPath.str() + "(" +
mbr->getPath().str() + ")";
Module* M =
GetBitcodeSymbols(At, mbr->getSize(), FullMemberName, Context,
symbols, error);
if (M) {
// Insert the module's symbols into the symbol table
for (std::vector<std::string>::iterator I = symbols.begin(),
E=symbols.end(); I != E; ++I ) {
symTab.insert(std::make_pair(*I, offset));
}
// Insert the Module and the ArchiveMember into the table of
// modules.
modules.insert(std::make_pair(offset, std::make_pair(M, mbr)));
} else {
if (error)
*error = "Can't parse bitcode member: " +
mbr->getPath().str() + ": " + *error;
delete mbr;
return false;
}
}
// Go to the next file location
At += mbr->getSize();
if ((intptr_t(At) & 1) == 1)
At++;
}
}
// At this point we have a valid symbol table (one way or another) so we
// just use it to quickly find the symbols requested.
SmallPtrSet<Module*, 16> Added;
for (std::set<std::string>::iterator I=symbols.begin(),
Next = I,
E=symbols.end(); I != E; I = Next) {
// Increment Next before we invalidate it.
++Next;
// See if this symbol exists
Module* m = findModuleDefiningSymbol(*I,error);
if (!m)
continue;
bool NewMember = Added.insert(m);
if (!NewMember)
continue;
// The symbol exists, insert the Module into our result.
result.push_back(m);
// Remove the symbol now that its been resolved.
symbols.erase(I);
}
return true;
}
bool Archive::isBitcodeArchive() {
// Make sure the symTab has been loaded. In most cases this should have been
// done when the archive was constructed, but still, this is just in case.
if (symTab.empty())
if (!loadSymbolTable(0))
return false;
// Now that we know it's been loaded, return true
// if it has a size
if (symTab.size()) return true;
// We still can't be sure it isn't a bitcode archive
if (!loadArchive(0))
return false;
std::vector<Module *> Modules;
std::string ErrorMessage;
// Scan the archive, trying to load a bitcode member. We only load one to
// see if this works.
for (iterator I = begin(), E = end(); I != E; ++I) {
if (!I->isBitcode())
continue;
std::string FullMemberName =
archPath.str() + "(" + I->getPath().str() + ")";
MemoryBuffer *Buffer =
MemoryBuffer::getMemBufferCopy(StringRef(I->getData(), I->getSize()),
FullMemberName.c_str());
Module *M = ParseBitcodeFile(Buffer, Context);
delete Buffer;
if (!M)
return false; // Couldn't parse bitcode, not a bitcode archive.
delete M;
return true;
}
return false;
}