aboutsummaryrefslogtreecommitdiff
path: root/lib/Bytecode
diff options
context:
space:
mode:
Diffstat (limited to 'lib/Bytecode')
-rw-r--r--lib/Bytecode/Archive/Archive.cpp157
-rw-r--r--lib/Bytecode/Archive/ArchiveInternals.h75
-rw-r--r--lib/Bytecode/Archive/ArchiveReader.cpp540
-rw-r--r--lib/Bytecode/Archive/ArchiveWriter.cpp466
-rw-r--r--lib/Bytecode/Archive/Makefile17
-rw-r--r--lib/Bytecode/Makefile14
-rw-r--r--lib/Bytecode/Reader/Analyzer.cpp733
-rw-r--r--lib/Bytecode/Reader/Makefile13
-rw-r--r--lib/Bytecode/Reader/Reader.cpp2343
-rw-r--r--lib/Bytecode/Reader/Reader.h535
-rw-r--r--lib/Bytecode/Reader/ReaderWrappers.cpp420
-rw-r--r--lib/Bytecode/Writer/Makefile12
-rw-r--r--lib/Bytecode/Writer/SlotCalculator.cpp862
-rw-r--r--lib/Bytecode/Writer/SlotCalculator.h182
-rw-r--r--lib/Bytecode/Writer/SlotTable.h191
-rw-r--r--lib/Bytecode/Writer/Writer.cpp1175
-rw-r--r--lib/Bytecode/Writer/WriterInternals.h140
17 files changed, 7875 insertions, 0 deletions
diff --git a/lib/Bytecode/Archive/Archive.cpp b/lib/Bytecode/Archive/Archive.cpp
new file mode 100644
index 0000000000..c2a80ebbc7
--- /dev/null
+++ b/lib/Bytecode/Archive/Archive.cpp
@@ -0,0 +1,157 @@
+//===-- Archive.cpp - Generic LLVM archive functions ------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the implementation of the Archive and ArchiveMember
+// classes that is common to both reading and writing archives..
+//
+//===----------------------------------------------------------------------===//
+
+#include "ArchiveInternals.h"
+#include "llvm/ModuleProvider.h"
+#include "llvm/System/Process.h"
+
+using namespace llvm;
+
+// getMemberSize - compute the actual physical size of the file member as seen
+// on disk. This isn't the size of member's payload. Use getSize() for that.
+unsigned
+ArchiveMember::getMemberSize() const {
+ // Basically its the file size plus the header size
+ unsigned result = info.fileSize + sizeof(ArchiveMemberHeader);
+
+ // If it has a long filename, include the name length
+ if (hasLongFilename())
+ result += path.toString().length() + 1;
+
+ // If its now odd lengthed, include the padding byte
+ if (result % 2 != 0 )
+ result++;
+
+ return result;
+}
+
+// This default constructor is only use by the ilist when it creates its
+// sentry node. We give it specific static values to make it stand out a bit.
+ArchiveMember::ArchiveMember()
+ : next(0), prev(0), parent(0), path("<invalid>"), flags(0), data(0)
+{
+ info.user = sys::Process::GetCurrentUserId();
+ info.group = sys::Process::GetCurrentGroupId();
+ info.mode = 0777;
+ info.fileSize = 0;
+ info.modTime = sys::TimeValue::now();
+}
+
+// This is the constructor that the Archive class uses when it is building or
+// reading an archive. It just defaults a few things and ensures the parent is
+// set for the iplist. The Archive class fills in the ArchiveMember's data.
+// This is required because correctly setting the data may depend on other
+// things in the Archive.
+ArchiveMember::ArchiveMember(Archive* PAR)
+ : next(0), prev(0), parent(PAR), path(), flags(0), data(0)
+{
+}
+
+// This method allows an ArchiveMember to be replaced with the data for a
+// different file, presumably as an update to the member. It also makes sure
+// the flags are reset correctly.
+void ArchiveMember::replaceWith(const sys::Path& newFile) {
+ assert(newFile.exists() && "Can't replace with a non-existent file");
+ data = 0;
+ path = newFile;
+
+ // SVR4 symbol tables have an empty name
+ if (path.toString() == ARFILE_SVR4_SYMTAB_NAME)
+ flags |= SVR4SymbolTableFlag;
+ else
+ flags &= ~SVR4SymbolTableFlag;
+
+ // BSD4.4 symbol tables have a special name
+ if (path.toString() == ARFILE_BSD4_SYMTAB_NAME)
+ flags |= BSD4SymbolTableFlag;
+ else
+ flags &= ~BSD4SymbolTableFlag;
+
+ // LLVM symbol tables have a very specific name
+ if (path.toString() == ARFILE_LLVM_SYMTAB_NAME)
+ flags |= LLVMSymbolTableFlag;
+ else
+ flags &= ~LLVMSymbolTableFlag;
+
+ // String table name
+ if (path.toString() == ARFILE_STRTAB_NAME)
+ flags |= StringTableFlag;
+ else
+ flags &= ~StringTableFlag;
+
+ // If it has a slash then it has a path
+ bool hasSlash = path.toString().find('/') != std::string::npos;
+ if (hasSlash)
+ flags |= HasPathFlag;
+ else
+ flags &= ~HasPathFlag;
+
+ // If it has a slash or its over 15 chars then its a long filename format
+ if (hasSlash || path.toString().length() > 15)
+ flags |= HasLongFilenameFlag;
+ else
+ flags &= ~HasLongFilenameFlag;
+
+ // Get the signature and status info
+ std::string magic;
+ const char* signature = (const char*) data;
+ if (!signature) {
+ path.getMagicNumber(magic,4);
+ signature = magic.c_str();
+ path.getStatusInfo(info);
+ }
+
+ // Determine what kind of file it is
+ switch (sys::IdentifyFileType(signature,4)) {
+ case sys::BytecodeFileType:
+ flags |= BytecodeFlag;
+ break;
+ case sys::CompressedBytecodeFileType:
+ flags |= CompressedBytecodeFlag;
+ flags &= ~CompressedFlag;
+ break;
+ default:
+ flags &= ~(BytecodeFlag|CompressedBytecodeFlag);
+ break;
+ }
+}
+
+// Archive constructor - this is the only constructor that gets used for the
+// Archive class. Everything else (default,copy) is deprecated. This just
+// initializes and maps the file into memory, if requested.
+Archive::Archive(const sys::Path& filename, bool map )
+ : archPath(filename), members(), mapfile(0), base(0), symTab(), strtab(),
+ symTabSize(0), firstFileOffset(0), modules(), foreignST(0)
+{
+ if (map) {
+ mapfile = new sys::MappedFile(filename);
+ base = (char*) mapfile->map();
+ }
+}
+
+// Archive destructor - just clean up memory
+Archive::~Archive() {
+ // Shutdown the file mapping
+ if (mapfile) {
+ mapfile->close();
+ delete mapfile;
+ }
+ // Delete any ModuleProviders and ArchiveMember's we've allocated as a result
+ // of symbol table searches.
+ for (ModuleMap::iterator I=modules.begin(), E=modules.end(); I != E; ++I ) {
+ delete I->second.first;
+ delete I->second.second;
+ }
+}
+
diff --git a/lib/Bytecode/Archive/ArchiveInternals.h b/lib/Bytecode/Archive/ArchiveInternals.h
new file mode 100644
index 0000000000..86d2827009
--- /dev/null
+++ b/lib/Bytecode/Archive/ArchiveInternals.h
@@ -0,0 +1,75 @@
+//===-- lib/Bytecode/ArchiveInternals.h -------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Internal implementation header for LLVM Archive files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIB_BYTECODE_ARCHIVEINTERNALS_H
+#define LIB_BYTECODE_ARCHIVEINTERNALS_H
+
+#include "llvm/Bytecode/Archive.h"
+#include "llvm/System/TimeValue.h"
+#include "llvm/ADT/StringExtras.h"
+
+#define ARFILE_MAGIC "!<arch>\n" ///< magic string
+#define ARFILE_MAGIC_LEN (sizeof(ARFILE_MAGIC)-1) ///< length of magic string
+#define ARFILE_SVR4_SYMTAB_NAME "/ " ///< SVR4 symtab entry name
+#define ARFILE_LLVM_SYMTAB_NAME "#_LLVM_SYM_TAB_#" ///< LLVM symtab entry name
+#define ARFILE_BSD4_SYMTAB_NAME "__.SYMDEF SORTED" ///< BSD4 symtab entry name
+#define ARFILE_STRTAB_NAME "// " ///< Name of string table
+#define ARFILE_PAD "\n" ///< inter-file align padding
+#define ARFILE_MEMBER_MAGIC "`\n" ///< fmag field magic #
+
+namespace llvm {
+
+ /// The ArchiveMemberHeader structure is used internally for bytecode
+ /// archives.
+ /// The header precedes each file member in the archive. This structure is
+ /// defined using character arrays for direct and correct interpretation
+ /// regardless of the endianess of the machine that produced it.
+ /// @brief Archive File Member Header
+ class ArchiveMemberHeader {
+ /// @name Data
+ /// @{
+ public:
+ char name[16]; ///< Name of the file member.
+ char date[12]; ///< File date, decimal seconds since Epoch
+ char uid[6]; ///< user id in ASCII decimal
+ char gid[6]; ///< group id in ASCII decimal
+ char mode[8]; ///< file mode in ASCII octal
+ char size[10]; ///< file size in ASCII decimal
+ char fmag[2]; ///< Always contains ARFILE_MAGIC_TERMINATOR
+
+ /// @}
+ /// @name Methods
+ /// @{
+ public:
+ void init() {
+ memset(name,' ',16);
+ memset(date,' ',12);
+ memset(uid,' ',6);
+ memset(gid,' ',6);
+ memset(mode,' ',8);
+ memset(size,' ',10);
+ fmag[0] = '`';
+ fmag[1] = '\n';
+ }
+
+ bool checkSignature() {
+ return 0 == memcmp(fmag, ARFILE_MEMBER_MAGIC,2);
+ }
+
+ };
+
+}
+
+#endif
+
+// vim: sw=2 ai
diff --git a/lib/Bytecode/Archive/ArchiveReader.cpp b/lib/Bytecode/Archive/ArchiveReader.cpp
new file mode 100644
index 0000000000..ff8c9bcb03
--- /dev/null
+++ b/lib/Bytecode/Archive/ArchiveReader.cpp
@@ -0,0 +1,540 @@
+//===-- ArchiveReader.cpp - Read LLVM archive files -------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Builds up standard unix archive files (.a) containing LLVM bytecode.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ArchiveInternals.h"
+#include "llvm/Bytecode/Reader.h"
+
+using namespace llvm;
+
+/// Read a variable-bit-rate encoded unsigned integer
+inline unsigned readInteger(const char*&At, const char*End) {
+ unsigned Shift = 0;
+ unsigned Result = 0;
+
+ do {
+ if (At == End)
+ throw std::string("Ran out of data reading vbr_uint!");
+ 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.
+void
+Archive::parseSymbolTable(const void* data, unsigned size) {
+ const char* At = (const char*) data;
+ const char* End = At + size;
+ while (At < End) {
+ unsigned offset = readInteger(At, End);
+ unsigned length = readInteger(At, End);
+ if (At + length > End)
+ throw std::string("malformed symbol table");
+ // 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;
+}
+
+// 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) {
+ assert(At + sizeof(ArchiveMemberHeader) < End && "Not enough data");
+
+ // Cast archive member header
+ ArchiveMemberHeader* Hdr = (ArchiveMemberHeader*)At;
+ At += sizeof(ArchiveMemberHeader);
+
+ // Instantiate the ArchiveMember to be filled
+ ArchiveMember* member = new ArchiveMember(this);
+
+ // Extract the size and determine if the file is
+ // compressed or not (negative length).
+ int flags = 0;
+ int MemberSize = atoi(Hdr->size);
+ if (MemberSize < 0) {
+ flags |= ArchiveMember::CompressedFlag;
+ MemberSize = -MemberSize;
+ }
+
+ // Check the size of the member for sanity
+ if (At + MemberSize > End)
+ throw std::string("invalid member length in archive file");
+
+ // Check the member signature
+ if (!Hdr->checkSignature())
+ throw std::string("invalid file member signature");
+
+ // 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 bytecode.
+ // 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]);
+ pathname.assign(At, len);
+ At += len;
+ MemberSize -= len;
+ flags |= ArchiveMember::HasLongFilenameFlag;
+ } else
+ throw std::string("invalid long filename");
+ } 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 {
+ throw std::string("invalid string table name");
+ }
+ } 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 {
+ throw std::string("invalid SVR4 symbol table name");
+ }
+ } 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)
+ throw std::string("missing name termiantor in string table");
+ } else {
+ throw std::string("name index beyond string table");
+ }
+ }
+ 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:
+ char* slash = (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 bytecode file
+ switch (sys::IdentifyFileType(At, 4)) {
+ case sys::BytecodeFileType:
+ flags |= ArchiveMember::BytecodeFlag;
+ break;
+ case sys::CompressedBytecodeFileType:
+ flags |= ArchiveMember::CompressedBytecodeFlag;
+ flags &= ~ArchiveMember::CompressedFlag;
+ break;
+ default:
+ flags &= ~(ArchiveMember::BytecodeFlag|
+ ArchiveMember::CompressedBytecodeFlag);
+ break;
+ }
+
+ // Fill in fields of the ArchiveMember
+ member->next = 0;
+ member->prev = 0;
+ 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;
+}
+
+void
+Archive::checkSignature() {
+ // Check the magic string at file's header
+ if (mapfile->size() < 8 || memcmp(base, ARFILE_MAGIC, 8))
+ throw std::string("invalid signature for an archive file");
+}
+
+// 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.
+void
+Archive::loadArchive() {
+
+ // Set up parsing
+ members.clear();
+ symTab.clear();
+ const char *At = base;
+ const char *End = base + mapfile->size();
+
+ checkSignature();
+ 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);
+
+ // 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)
+ throw std::string("invalid archive: multiple symbol tables");
+ parseSymbolTable(mbr->getData(), mbr->getSize());
+ 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++;
+ }
+ }
+}
+
+// Open and completely load the archive file.
+Archive*
+Archive::OpenAndLoad(const sys::Path& file, std::string* ErrorMessage) {
+ try {
+ std::auto_ptr<Archive> result ( new Archive(file, true));
+ result->loadArchive();
+ return result.release();
+ } catch (const std::string& msg) {
+ if (ErrorMessage) {
+ *ErrorMessage = msg;
+ }
+ return 0;
+ }
+}
+
+// Get all the bytecode 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->isBytecode() || I->isCompressedBytecode()) {
+ std::string FullMemberName = archPath.toString() +
+ "(" + I->getPath().toString() + ")";
+ Module* M = ParseBytecodeBuffer((const unsigned char*)I->getData(),
+ I->getSize(), FullMemberName, ErrMessage);
+ if (!M)
+ return true;
+
+ Modules.push_back(M);
+ }
+ }
+ return false;
+}
+
+// Load just the symbol table from the archive file
+void
+Archive::loadSymbolTable() {
+
+ // Set up parsing
+ members.clear();
+ symTab.clear();
+ const char *At = base;
+ const char *End = base + mapfile->size();
+
+ // Make sure we're dealing with an archive
+ checkSignature();
+
+ At += 8; // Skip signature
+
+ // Parse the first file member header
+ const char* FirstFile = At;
+ ArchiveMember* mbr = parseMemberHeader(At, End);
+
+ 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);
+ }
+
+ 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);
+ }
+
+ // See if its the symbol table
+ if (mbr->isLLVMSymbolTable()) {
+ parseSymbolTable(mbr->getData(), mbr->getSize());
+ At += mbr->getSize();
+ if ((intptr_t(At) & 1) == 1)
+ At++;
+ 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;
+}
+
+// Open the archive and load just the symbol tables
+Archive*
+Archive::OpenAndLoadSymbols(const sys::Path& file, std::string* ErrorMessage) {
+ try {
+ std::auto_ptr<Archive> result ( new Archive(file, true) );
+ result->loadSymbolTable();
+ return result.release();
+ } catch (const std::string& msg) {
+ if (ErrorMessage) {
+ *ErrorMessage = msg;
+ }
+ return 0;
+ }
+}
+
+// Look up one symbol in the symbol table and return a ModuleProvider for the
+// module that defines that symbol.
+ModuleProvider*
+Archive::findModuleDefiningSymbol(const std::string& symbol) {
+ 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, base + mapfile->size());
+
+ // Now, load the bytecode module to get the ModuleProvider
+ std::string FullMemberName = archPath.toString() + "(" +
+ mbr->getPath().toString() + ")";
+ ModuleProvider* mp = getBytecodeBufferModuleProvider(
+ (const unsigned char*) mbr->getData(), mbr->getSize(),
+ FullMemberName, 0);
+
+ modules.insert(std::make_pair(fileOffset, std::make_pair(mp, mbr)));
+
+ return mp;
+}
+
+// Look up multiple symbols in the symbol table and return a set of
+// ModuleProviders that define those symbols.
+void
+Archive::findModulesDefiningSymbols(std::set<std::string>& symbols,
+ std::set<ModuleProvider*>& result)
+{
+ assert(mapfile && base && "Can't findModulesDefiningSymbols on new archive");
+ 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 = ((const char*)base) + firstFileOffset;
+ const char* End = ((const char*)base) + mapfile->size();
+
+ 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);
+
+ // If it contains symbols
+ if (mbr->isBytecode() || mbr->isCompressedBytecode()) {
+ // Get the symbols
+ std::vector<std::string> symbols;
+ std::string FullMemberName = archPath.toString() + "(" +
+ mbr->getPath().toString() + ")";
+ ModuleProvider* MP = GetBytecodeSymbols((const unsigned char*)At,
+ mbr->getSize(), FullMemberName, symbols);
+
+ if (MP) {
+ // 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 ModuleProvider and the ArchiveMember into the table of
+ // modules.
+ modules.insert(std::make_pair(offset, std::make_pair(MP, mbr)));
+ } else {
+ throw std::string("Can't parse bytecode member: ") +
+ mbr->getPath().toString();
+ }
+ }
+
+ // 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.
+
+ for (std::set<std::string>::iterator I=symbols.begin(),
+ E=symbols.end(); I != E;) {
+ // See if this symbol exists
+ ModuleProvider* mp = findModuleDefiningSymbol(*I);
+ if (mp) {
+ // The symbol exists, insert the ModuleProvider into our result,
+ // duplicates wil be ignored
+ result.insert(mp);
+
+ // Remove the symbol now that its been resolved, being careful to
+ // post-increment the iterator.
+ symbols.erase(I++);
+ } else {
+ ++I;
+ }
+ }
+}
+
+bool Archive::isBytecodeArchive() {
+ // 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.size())
+ loadSymbolTable();
+
+ // 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 bytecode archive
+ loadArchive();
+
+ std::vector<Module *> Modules;
+ std::string ErrorMessage;
+
+ // Scan the archive, trying to load a bytecode member. We only load one to
+ // see if this works.
+ for (iterator I = begin(), E = end(); I != E; ++I) {
+ if (!I->isBytecode() && !I->isCompressedBytecode())
+ continue;
+
+ std::string FullMemberName =
+ archPath.toString() + "(" + I->getPath().toString() + ")";
+ Module* M = ParseBytecodeBuffer((const unsigned char*)I->getData(),
+ I->getSize(), FullMemberName);
+ if (!M)
+ return false; // Couldn't parse bytecode, not a bytecode archive.
+ delete M;
+ return true;
+ }
+
+ return false;
+}
diff --git a/lib/Bytecode/Archive/ArchiveWriter.cpp b/lib/Bytecode/Archive/ArchiveWriter.cpp
new file mode 100644
index 0000000000..3517dc7453
--- /dev/null
+++ b/lib/Bytecode/Archive/ArchiveWriter.cpp
@@ -0,0 +1,466 @@
+//===-- ArchiveWriter.cpp - Write LLVM archive files ----------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Builds up an LLVM archive file (.a) containing LLVM bytecode.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ArchiveInternals.h"
+#include "llvm/Bytecode/Reader.h"
+#include "llvm/Support/Compressor.h"
+#include "llvm/System/Signals.h"
+#include "llvm/System/Process.h"
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+
+using namespace llvm;
+
+// Write an integer using variable bit rate encoding. This saves a few bytes
+// per entry in the symbol table.
+inline void writeInteger(unsigned num, std::ofstream& ARFile) {
+ while (1) {
+ if (num < 0x80) { // done?
+ ARFile << (unsigned char)num;
+ return;
+ }
+
+ // Nope, we are bigger than a character, output the next 7 bits and set the
+ // high bit to say that there is more coming...
+ ARFile << (unsigned char)(0x80 | ((unsigned char)num & 0x7F));
+ num >>= 7; // Shift out 7 bits now...
+ }
+}
+
+// Compute how many bytes are taken by a given VBR encoded value. This is needed
+// to pre-compute the size of the symbol table.
+inline unsigned numVbrBytes(unsigned num) {
+
+ // Note that the following nested ifs are somewhat equivalent to a binary
+ // search. We split it in half by comparing against 2^14 first. This allows
+ // most reasonable values to be done in 2 comparisons instead of 1 for
+ // small ones and four for large ones. We expect this to access file offsets
+ // in the 2^10 to 2^24 range and symbol lengths in the 2^0 to 2^8 range,
+ // so this approach is reasonable.
+ if (num < 1<<14)
+ if (num < 1<<7)
+ return 1;
+ else
+ return 2;
+ if (num < 1<<21)
+ return 3;
+
+ if (num < 1<<28)
+ return 4;
+ return 5; // anything >= 2^28 takes 5 bytes
+}
+
+// Create an empty archive.
+Archive*
+Archive::CreateEmpty(const sys::Path& FilePath ) {
+ Archive* result = new Archive(FilePath,false);
+ return result;
+}
+
+// Fill the ArchiveMemberHeader with the information from a member. If
+// TruncateNames is true, names are flattened to 15 chars or less. The sz field
+// is provided here instead of coming from the mbr because the member might be
+// stored compressed and the compressed size is not the ArchiveMember's size.
+// Furthermore compressed files have negative size fields to identify them as
+// compressed.
+bool
+Archive::fillHeader(const ArchiveMember &mbr, ArchiveMemberHeader& hdr,
+ int sz, bool TruncateNames) const {
+
+ // Set the permissions mode, uid and gid
+ hdr.init();
+ char buffer[32];
+ sprintf(buffer, "%-8o", mbr.getMode());
+ memcpy(hdr.mode,buffer,8);
+ sprintf(buffer, "%-6u", mbr.getUser());
+ memcpy(hdr.uid,buffer,6);
+ sprintf(buffer, "%-6u", mbr.getGroup());
+ memcpy(hdr.gid,buffer,6);
+
+ // Set the last modification date
+ uint64_t secondsSinceEpoch = mbr.getModTime().toEpochTime();
+ sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch));
+ memcpy(hdr.date,buffer,12);
+
+ // Get rid of trailing blanks in the name
+ std::string mbrPath = mbr.getPath().toString();
+ size_t mbrLen = mbrPath.length();
+ while (mbrLen > 0 && mbrPath[mbrLen-1] == ' ') {
+ mbrPath.erase(mbrLen-1,1);
+ mbrLen--;
+ }
+
+ // Set the name field in one of its various flavors.
+ bool writeLongName = false;
+ if (mbr.isStringTable()) {
+ memcpy(hdr.name,ARFILE_STRTAB_NAME,16);
+ } else if (mbr.isSVR4SymbolTable()) {
+ memcpy(hdr.name,ARFILE_SVR4_SYMTAB_NAME,16);
+ } else if (mbr.isBSD4SymbolTable()) {
+ memcpy(hdr.name,ARFILE_BSD4_SYMTAB_NAME,16);
+ } else if (mbr.isLLVMSymbolTable()) {
+ memcpy(hdr.name,ARFILE_LLVM_SYMTAB_NAME,16);
+ } else if (TruncateNames) {
+ const char* nm = mbrPath.c_str();
+ unsigned len = mbrPath.length();
+ size_t slashpos = mbrPath.rfind('/');
+ if (slashpos != std::string::npos) {
+ nm += slashpos + 1;
+ len -= slashpos +1;
+ }
+ if (len > 15)
+ len = 15;
+ memcpy(hdr.name,nm,len);
+ hdr.name[len] = '/';
+ } else if (mbrPath.length() < 16 && mbrPath.find('/') == std::string::npos) {
+ memcpy(hdr.name,mbrPath.c_str(),mbrPath.length());
+ hdr.name[mbrPath.length()] = '/';
+ } else {
+ std::string nm = "#1/";
+ nm += utostr(mbrPath.length());
+ memcpy(hdr.name,nm.data(),nm.length());
+ if (sz < 0)
+ sz -= mbrPath.length();
+ else
+ sz += mbrPath.length();
+ writeLongName = true;
+ }
+
+ // Set the size field
+ if (sz < 0) {
+ buffer[0] = '-';
+ sprintf(&buffer[1],"%-9u",(unsigned)-sz);
+ } else {
+ sprintf(buffer, "%-10u", (unsigned)sz);
+ }
+ memcpy(hdr.size,buffer,10);
+
+ return writeLongName;
+}
+
+// Insert a file into the archive before some other member. This also takes care
+// of extracting the necessary flags and information from the file.
+void
+Archive::addFileBefore(const sys::Path& filePath, iterator where) {
+ assert(filePath.exists() && "Can't add a non-existent file");
+
+ ArchiveMember* mbr = new ArchiveMember(this);
+
+ mbr->data = 0;
+ mbr->path = filePath;
+ mbr->path.getStatusInfo(mbr->info);
+
+ unsigned flags = 0;
+ bool hasSlash = filePath.toString().find('/') != std::string::npos;
+ if (hasSlash)
+ flags |= ArchiveMember::HasPathFlag;
+ if (hasSlash || filePath.toString().length() > 15)
+ flags |= ArchiveMember::HasLongFilenameFlag;
+ std::string magic;
+ mbr->path.getMagicNumber(magic,4);
+ switch (sys::IdentifyFileType(magic.c_str(),4)) {
+ case sys::BytecodeFileType:
+ flags |= ArchiveMember::BytecodeFlag;
+ break;
+ case sys::CompressedBytecodeFileType:
+ flags |= ArchiveMember::CompressedBytecodeFlag;
+ break;
+ default:
+ break;
+ }
+ mbr->flags = flags;
+ members.insert(where,mbr);
+}
+
+// Write one member out to the file.
+void
+Archive::writeMember(
+ const ArchiveMember& member,
+ std::ofstream& ARFile,
+ bool CreateSymbolTable,
+ bool TruncateNames,
+ bool ShouldCompress
+) {
+
+ unsigned filepos = ARFile.tellp();
+ filepos -= 8;
+
+ // Get the data and its size either from the
+ // member's in-memory data or directly from the file.
+ size_t fSize = member.getSize();
+ const char* data = (const char*)member.getData();
+ sys::MappedFile* mFile = 0;
+ if (!data) {
+ mFile = new sys::MappedFile(member.getPath());
+ data = (const char*) mFile->map();
+ fSize = mFile->size();
+ }
+
+ // Now that we have the data in memory, update the
+ // symbol table if its a bytecode file.
+ if (CreateSymbolTable &&
+ (member.isBytecode() || member.isCompressedBytecode())) {
+ std::vector<std::string> symbols;
+ std::string FullMemberName = archPath.toString() + "(" +
+ member.getPath().toString()
+ + ")";
+ ModuleProvider* MP = GetBytecodeSymbols(
+ (const unsigned char*)data,fSize,FullMemberName, symbols);
+
+ // If the bytecode parsed successfully
+ if ( MP ) {
+ for (std::vector<std::string>::iterator SI = symbols.begin(),
+ SE = symbols.end(); SI != SE; ++SI) {
+
+ std::pair<SymTabType::iterator,bool> Res =
+ symTab.insert(std::make_pair(*SI,filepos));
+
+ if (Res.second) {
+ symTabSize += SI->length() +
+ numVbrBytes(SI->length()) +
+ numVbrBytes(filepos);
+ }
+ }
+ // We don't need this module any more.
+ delete MP;
+ } else {
+ throw std::string("Can't parse bytecode member: ") +
+ member.getPath().toString();
+ }
+ }
+
+ // Determine if we actually should compress this member
+ bool willCompress =
+ (ShouldCompress &&
+ !member.isCompressed() &&
+ !member.isCompressedBytecode() &&
+ !member.isLLVMSymbolTable() &&
+ !member.isSVR4SymbolTable() &&
+ !member.isBSD4SymbolTable());
+
+ // Perform the compression. Note that if the file is uncompressed bytecode
+ // then we turn the file into compressed bytecode rather than treating it as
+ // compressed data. This is necessary since it allows us to determine that the
+ // file contains bytecode instead of looking like a regular compressed data
+ // member. A compressed bytecode file has its content compressed but has a
+ // magic number of "llvc". This acounts for the +/-4 arithmetic in the code
+ // below.
+ int hdrSize;
+ if (willCompress) {
+ char* output = 0;
+ if (member.isBytecode()) {
+ data +=4;
+ fSize -= 4;
+ }
+ fSize = Compressor::compressToNewBuffer(data,fSize,output);
+ data = output;
+ if (member.isBytecode())
+ hdrSize = -fSize-4;
+ else
+ hdrSize = -fSize;
+ } else {
+ hdrSize = fSize;
+ }
+
+ // Compute the fields of the header
+ ArchiveMemberHeader Hdr;
+ bool writeLongName = fillHeader(member,Hdr,hdrSize,TruncateNames);
+
+ // Write header to archive file
+ ARFile.write((char*)&Hdr, sizeof(Hdr));
+
+ // Write the long filename if its long
+ if (writeLongName) {
+ ARFile.write(member.getPath().toString().data(),
+ member.getPath().toString().length());
+ }
+
+ // Make sure we write the compressed bytecode magic number if we should.
+ if (willCompress && member.isBytecode())
+ ARFile.write("llvc",4);
+
+ // Write the (possibly compressed) member's content to the file.
+ ARFile.write(data,fSize);
+
+ // Make sure the member is an even length
+ if ((ARFile.tellp() & 1) == 1)
+ ARFile << ARFILE_PAD;
+
+ // Free the compressed data, if necessary
+ if (willCompress) {
+ free((void*)data);
+ }
+
+ // Close the mapped file if it was opened
+ if (mFile != 0) {
+ mFile->close();
+ delete mFile;
+ }
+}
+
+// Write out the LLVM symbol table as an archive member to the file.
+void
+Archive::writeSymbolTable(std::ofstream& ARFile) {
+
+ // Construct the symbol table's header
+ ArchiveMemberHeader Hdr;
+ Hdr.init();
+ memcpy(Hdr.name,ARFILE_LLVM_SYMTAB_NAME,16);
+ uint64_t secondsSinceEpoch = sys::TimeValue::now().toEpochTime();
+ char buffer[32];
+ sprintf(buffer, "%-8o", 0644);
+ memcpy(Hdr.mode,buffer,8);
+ sprintf(buffer, "%-6u", sys::Process::GetCurrentUserId());
+ memcpy(Hdr.uid,buffer,6);
+ sprintf(buffer, "%-6u", sys::Process::GetCurrentGroupId());
+ memcpy(Hdr.gid,buffer,6);
+ sprintf(buffer,"%-12u", unsigned(secondsSinceEpoch));
+ memcpy(Hdr.date,buffer,12);
+ sprintf(buffer,"%-10u",symTabSize);
+ memcpy(Hdr.size,buffer,10);
+
+ // Write the header
+ ARFile.write((char*)&Hdr, sizeof(Hdr));
+
+ // Save the starting position of the symbol tables data content.
+ unsigned startpos = ARFile.tellp();
+
+ // Write out the symbols sequentially
+ for ( Archive::SymTabType::iterator I = symTab.begin(), E = symTab.end();
+ I != E; ++I)
+ {
+ // Write out the file index
+ writeInteger(I->second, ARFile);
+ // Write out the length of the symbol
+ writeInteger(I->first.length(), ARFile);
+ // Write out the symbol
+ ARFile.write(I->first.data(), I->first.length());
+ }
+
+ // Now that we're done with the symbol table, get the ending file position
+ unsigned endpos = ARFile.tellp();
+
+ // Make sure that the amount we wrote is what we pre-computed. This is
+ // critical for file integrity purposes.
+ assert(endpos - startpos == symTabSize && "Invalid symTabSize computation");
+
+ // Make sure the symbol table is even sized
+ if (symTabSize % 2 != 0 )
+ ARFile << ARFILE_PAD;
+}
+
+// Write the entire archive to the file specified when the archive was created.
+// This writes to a temporary file first. Options are for creating a symbol
+// table, flattening the file names (no directories, 15 chars max) and
+// compressing each archive member.
+void
+Archive::writeToDisk(bool CreateSymbolTable, bool TruncateNames, bool Compress){
+
+ // Make sure they haven't opened up the file, not loaded it,
+ // but are now trying to write it which would wipe out the file.
+ assert(!(members.empty() && mapfile->size() > 8) &&
+ "Can't write an archive not opened for writing");
+
+ // Create a temporary file to store the archive in
+ sys::Path TmpArchive = archPath;
+ TmpArchive.createTemporaryFileOnDisk();
+
+ // Make sure the temporary gets removed if we crash
+ sys::RemoveFileOnSignal(TmpArchive);
+
+ // Ensure we can remove the temporary even in the face of an exception
+ try {
+ // Create archive file for output.
+ std::ios::openmode io_mode = std::ios::out | std::ios::trunc |
+ std::ios::binary;
+ std::ofstream ArchiveFile(TmpArchive.c_str(), io_mode);
+
+ // Check for errors opening or creating archive file.
+ if ( !ArchiveFile.is_open() || ArchiveFile.bad() ) {
+ throw std::string("Error opening archive file: ") + archPath.toString();
+ }
+
+ // If we're creating a symbol table, reset it now
+ if (CreateSymbolTable) {
+ symTabSize = 0;
+ symTab.clear();
+ }
+
+ // Write magic string to archive.
+ ArchiveFile << ARFILE_MAGIC;
+
+ // Loop over all member files, and write them out. Note that this also
+ // builds the symbol table, symTab.
+ for ( MembersList::iterator I = begin(), E = end(); I != E; ++I) {
+ writeMember(*I,ArchiveFile,CreateSymbolTable,TruncateNames,Compress);
+ }
+
+ // Close archive file.
+ ArchiveFile.close();
+
+ // Write the symbol table
+ if (CreateSymbolTable) {
+ // At this point we have written a file that is a legal archive but it
+ // doesn't have a symbol table in it. To aid in faster reading and to
+ // ensure compatibility with other archivers we need to put the symbol
+ // table first in the file. Unfortunately, this means mapping the file
+ // we just wrote back in and copying it to the destination file.
+
+ // Map in the archive we just wrote.
+ sys::MappedFile arch(TmpArchive);
+ const char* base = (const char*) arch.map();
+
+ // Open the final file to write and check it.
+ std::ofstream FinalFile(archPath.c_str(), io_mode);
+ if ( !FinalFile.is_open() || FinalFile.bad() ) {
+ throw std::string("Error opening archive file: ") + archPath.toString();
+ }
+
+ // Write the file magic number
+ FinalFile << ARFILE_MAGIC;
+
+ // If there is a foreign symbol table, put it into the file now. Most
+ // ar(1) implementations require the symbol table to be first but llvm-ar
+ // can deal with it being after a foreign symbol table. This ensures
+ // compatibility with other ar(1) implementations as well as allowing the
+ // archive to store both native .o and LLVM .bc files, both indexed.
+ if (foreignST) {
+ writeMember(*foreignST, FinalFile, false, false, false);
+ }
+
+ // Put out the LLVM symbol table now.
+ writeSymbolTable(FinalFile);
+
+ // Copy the temporary file contents being sure to skip the file's magic
+ // number.
+ FinalFile.write(base + sizeof(ARFILE_MAGIC)-1,
+ arch.size()-sizeof(ARFILE_MAGIC)+1);
+
+ // Close up shop
+ FinalFile.close();
+ arch.close();
+ TmpArchive.eraseFromDisk();
+
+ } else {
+ // We don't have to insert the symbol table, so just renaming the temp
+ // file to the correct name will suffice.
+ TmpArchive.renamePathOnDisk(archPath);
+ }
+ } catch (...) {
+ // Make sure we clean up.
+ if (TmpArchive.exists())
+ TmpArchive.eraseFromDisk();
+ throw;
+ }
+}
diff --git a/lib/Bytecode/Archive/Makefile b/lib/Bytecode/Archive/Makefile
new file mode 100644
index 0000000000..e8cc803c78
--- /dev/null
+++ b/lib/Bytecode/Archive/Makefile
@@ -0,0 +1,17 @@
+##===- lib/Bytecode/Archive/Makefile -----------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by Reid Spencer and is distributed under the
+# University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../../..
+LIBRARYNAME = LLVMArchive
+
+# We only want an archive so only those modules actually used by a tool are
+# included.
+BUILD_ARCHIVE = 1
+
+include $(LEVEL)/Makefile.common
diff --git a/lib/Bytecode/Makefile b/lib/Bytecode/Makefile
new file mode 100644
index 0000000000..b31a245292
--- /dev/null
+++ b/lib/Bytecode/Makefile
@@ -0,0 +1,14 @@
+##===- lib/Bytecode/Makefile -------------------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by the LLVM research group and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LEVEL = ../..
+PARALLEL_DIRS = Reader Writer Archive
+
+include $(LEVEL)/Makefile.common
+
diff --git a/lib/Bytecode/Reader/Analyzer.cpp b/lib/Bytecode/Reader/Analyzer.cpp
new file mode 100644
index 0000000000..4990761673
--- /dev/null
+++ b/lib/Bytecode/Reader/Analyzer.cpp
@@ -0,0 +1,733 @@
+//===-- Analyzer.cpp - Analysis and Dumping of Bytecode 000000---*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the AnalyzerHandler class and PrintBytecodeAnalysis
+// function which together comprise the basic functionality of the llmv-abcd
+// tool. The AnalyzerHandler collects information about the bytecode file into
+// the BytecodeAnalysis structure. The PrintBytecodeAnalysis function prints
+// out the content of that structure.
+// @see include/llvm/Bytecode/Analysis.h
+//
+//===----------------------------------------------------------------------===//
+
+#include "Reader.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Module.h"
+#include "llvm/Analysis/Verifier.h"
+#include "llvm/Bytecode/BytecodeHandler.h"
+#include "llvm/Assembly/Writer.h"
+#include <iomanip>
+#include <sstream>
+
+using namespace llvm;
+
+namespace {
+
+/// @brief Bytecode reading handler for analyzing bytecode.
+class AnalyzerHandler : public BytecodeHandler {
+ BytecodeAnalysis& bca; ///< The structure in which data is recorded
+ std::ostream* os; ///< A convenience for osing data.
+ /// @brief Keeps track of current function
+ BytecodeAnalysis::BytecodeFunctionInfo* currFunc;
+ Module* M; ///< Keeps track of current module
+
+/// @name Constructor
+/// @{
+public:
+ /// The only way to construct an AnalyzerHandler. All that is needed is a
+ /// reference to the BytecodeAnalysis structure where the output will be
+ /// placed.
+ AnalyzerHandler(BytecodeAnalysis& TheBca, std::ostream* output)
+ : bca(TheBca)
+ , os(output)
+ , currFunc(0)
+ { }
+
+/// @}
+/// @name BytecodeHandler Implementations
+/// @{
+public:
+ virtual void handleError(const std::string& str ) {
+ if (os)
+ *os << "ERROR: " << str << "\n";
+ }
+
+ virtual void handleStart( Module* Mod, unsigned theSize ) {
+ M = Mod;
+ if (os)
+ *os << "Bytecode {\n";
+ bca.byteSize = theSize;
+ bca.ModuleId.clear();
+ bca.numBlocks = 0;
+ bca.numTypes = 0;
+ bca.numValues = 0;
+ bca.numFunctions = 0;
+ bca.numConstants = 0;
+ bca.numGlobalVars = 0;
+ bca.numInstructions = 0;
+ bca.numBasicBlocks = 0;
+ bca.numOperands = 0;
+ bca.numCmpctnTables = 0;
+ bca.numSymTab = 0;
+ bca.numLibraries = 0;
+ bca.libSize = 0;
+ bca.maxTypeSlot = 0;
+ bca.maxValueSlot = 0;
+ bca.numAlignment = 0;
+ bca.fileDensity = 0.0;
+ bca.globalsDensity = 0.0;
+ bca.functionDensity = 0.0;
+ bca.instructionSize = 0;
+ bca.longInstructions = 0;
+ bca.vbrCount32 = 0;
+ bca.vbrCount64 = 0;
+ bca.vbrCompBytes = 0;
+ bca.vbrExpdBytes = 0;
+ bca.FunctionInfo.clear();
+ bca.BlockSizes[BytecodeFormat::Reserved_DoNotUse] = 0;
+ bca.BlockSizes[BytecodeFormat::ModuleBlockID] = theSize;
+ bca.BlockSizes[BytecodeFormat::FunctionBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::ConstantPoolBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::SymbolTableBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::ModuleGlobalInfoBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::GlobalTypePlaneBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::InstructionListBlockID] = 0;
+ bca.BlockSizes[BytecodeFormat::CompactionTableBlockID] = 0;
+ }
+
+ virtual void handleFinish() {
+ if (os)
+ *os << "} End Bytecode\n";
+
+ bca.fileDensity = double(bca.byteSize) / double( bca.numTypes + bca.numValues );
+ double globalSize = 0.0;
+ globalSize += double(bca.BlockSizes[BytecodeFormat::ConstantPoolBlockID]);
+ globalSize += double(bca.BlockSizes[BytecodeFormat::ModuleGlobalInfoBlockID]);
+ globalSize += double(bca.BlockSizes[BytecodeFormat::GlobalTypePlaneBlockID]);
+ bca.globalsDensity = globalSize / double( bca.numTypes + bca.numConstants +
+ bca.numGlobalVars );
+ bca.functionDensity = double(bca.BlockSizes[BytecodeFormat::FunctionBlockID]) /
+ double(bca.numFunctions);
+
+ if ( bca.progressiveVerify ) {
+ try {
+ verifyModule(*M, ThrowExceptionAction);
+ } catch ( std::string& msg ) {
+ bca.VerifyInfo += "Verify@Finish: " + msg + "\n";
+ }
+ }
+ }
+
+ virtual void handleModuleBegin(const std::string& id) {
+ if (os)
+ *os << " Module " << id << " {\n";
+ bca.ModuleId = id;
+ }
+
+ virtual void handleModuleEnd(const std::string& id) {
+ if (os)
+ *os << " } End Module " << id << "\n";
+ if ( bca.progressiveVerify ) {
+ try {
+ verifyModule(*M, ThrowExceptionAction);
+ } catch ( std::string& msg ) {
+ bca.VerifyInfo += "Verify@EndModule: " + msg + "\n";
+ }
+ }
+ }
+
+ virtual void handleVersionInfo(
+ unsigned char RevisionNum, ///< Byte code revision number
+ Module::Endianness Endianness, ///< Endianness indicator
+ Module::PointerSize PointerSize ///< PointerSize indicator
+ ) {
+ if (os)
+ *os << " RevisionNum: " << int(RevisionNum)
+ << " Endianness: " << Endianness
+ << " PointerSize: " << PointerSize << "\n";
+ bca.version = RevisionNum;
+ }
+
+ virtual void handleModuleGlobalsBegin() {
+ if (os)
+ *os << " BLOCK: ModuleGlobalInfo {\n";
+ }
+
+ virtual void handleGlobalVariable(
+ const Type* ElemType,
+ bool isConstant,
+ GlobalValue::LinkageTypes Linkage,
+ unsigned SlotNum,
+ unsigned initSlot
+ ) {
+ if (os) {
+ *os << " GV: "
+ << ( initSlot == 0 ? "Uni" : "I" ) << "nitialized, "
+ << ( isConstant? "Constant, " : "Variable, ")
+ << " Linkage=" << Linkage << " Type=";
+ WriteTypeSymbolic(*os, ElemType, M);
+ *os << " Slot=" << SlotNum << " InitSlot=" << initSlot
+ << "\n";
+ }
+
+ bca.numGlobalVars++;
+ bca.numValues++;
+ if (SlotNum > bca.maxValueSlot)
+ bca.maxValueSlot = SlotNum;
+ if (initSlot > bca.maxValueSlot)
+ bca.maxValueSlot = initSlot;
+
+ }
+
+ virtual void handleTypeList(unsigned numEntries) {
+ bca.maxTypeSlot = numEntries - 1;
+ }
+
+ virtual void handleType( const Type* Ty ) {
+ bca.numTypes++;
+ if (os) {
+ *os << " Type: ";
+ WriteTypeSymbolic(*os,Ty,M);
+ *os << "\n";
+ }
+ }
+
+ virtual void handleFunctionDeclaration(
+ Function* Func ///< The function
+ ) {
+ bca.numFunctions++;
+ bca.numValues++;
+ if (os) {
+ *os << " Function Decl: ";
+ WriteTypeSymbolic(*os,Func->getType(),M);
+ *os << "\n";
+ }
+ }
+
+ virtual void handleGlobalInitializer(GlobalVariable* GV, Constant* CV) {
+ if (os) {
+ *os << " Initializer: GV=";
+ GV->print(*os);
+ *os << " CV=";
+ CV->print(*os);
+ *os << "\n";
+ }
+ }
+
+ virtual void handleDependentLibrary(const std::string& libName) {
+ bca.numLibraries++;
+ bca.libSize += libName.size() + (libName.size() < 128 ? 1 : 2);
+ if (os)
+ *os << " Library: '" << libName << "'\n";
+ }
+
+ virtual void handleModuleGlobalsEnd() {
+ if (os)
+ *os << " } END BLOCK: ModuleGlobalInfo\n";
+ if ( bca.progressiveVerify ) {
+ try {
+ verifyModule(*M, ThrowExceptionAction);
+ } catch ( std::string& msg ) {
+ bca.VerifyInfo += "Verify@EndModuleGlobalInfo: " + msg + "\n";
+ }
+ }
+ }
+
+ virtual void handleCompactionTableBegin() {
+ if (os)
+ *os << " BLOCK: CompactionTable {\n";
+ bca.numCmpctnTables++;
+ }
+
+ virtual void handleCompactionTablePlane( unsigned Ty, unsigned NumEntries) {
+ if (os)
+ *os << " Plane: Ty=" << Ty << " Size=" << NumEntries << "\n";
+ }
+
+ virtual void handleCompactionTableType( unsigned i, unsigned TypSlot,
+ const Type* Ty ) {
+ if (os) {
+ *os << " Type: " << i << " Slot:" << TypSlot << " is ";
+ WriteTypeSymbolic(*os,Ty,M);
+ *os << "\n";
+ }
+ }
+
+ virtual void handleCompactionTableValue(unsigned i, unsigned TypSlot,
+ unsigned ValSlot) {
+ if (os)
+ *os << " Value: " << i << " TypSlot: " << TypSlot
+ << " ValSlot:" << ValSlot << "\n";
+ if (ValSlot > bca.maxValueSlot)
+ bca.maxValueSlot = ValSlot;
+ }
+
+ virtual void handleCompactionTableEnd() {
+ if (os)
+ *os << " } END BLOCK: CompactionTable\n";
+ }
+
+ virtual void handleSymbolTableBegin(Function* CF, SymbolTable* ST) {
+ bca.numSymTab++;
+ if (os)
+ *os << " BLOCK: SymbolTable {\n";
+ }
+
+ virtual void handleSymbolTablePlane(unsigned Ty, unsigned NumEntries,
+ const Type* Typ) {
+ if (os) {
+ *os << " Plane: Ty=" << Ty << " Size=" << NumEntries << " Type: ";
+ WriteTypeSymbolic(*os,Typ,M);
+ *os << "\n";
+ }
+ }
+
+ virtual void handleSymbolTableType(unsigned i, unsigned TypSlot,
+ const std::string& name ) {
+ if (os)
+ *os << " Type " << i << " Slot=" << TypSlot
+ << " Name: " << name << "\n";
+ }
+
+ virtual void handleSymbolTableValue(unsigned i, unsigned ValSlot,
+ const std::string& name ) {
+ if (os)
+ *os << " Value " << i << " Slot=" << ValSlot
+ << " Name: " << name << "\n";
+ if (ValSlot > bca.maxValueSlot)
+ bca.maxValueSlot = ValSlot;
+ }
+
+ virtual void handleSymbolTableEnd() {
+ if (os)
+ *os << " } END BLOCK: SymbolTable\n";
+ }
+
+ virtual void handleFunctionBegin(Function* Func, unsigned Size) {
+ if (os) {
+ *os << " BLOCK: Function {\n"
+ << " Linkage: " << Func->getLinkage() << "\n"
+ << " Type: ";
+ WriteTypeSymbolic(*os,Func->getType(),M);
+ *os << "\n";
+ }
+
+ currFunc = &bca.FunctionInfo[Func];
+ std::ostringstream tmp;
+ WriteTypeSymbolic(tmp,Func->getType(),M);
+ currFunc->description = tmp.str();
+ currFunc->name = Func->getName();
+ currFunc->byteSize = Size;
+ currFunc->numInstructions = 0;
+ currFunc->numBasicBlocks = 0;
+ currFunc->numPhis = 0;
+ currFunc->numOperands = 0;
+ currFunc->density = 0.0;
+ currFunc->instructionSize = 0;
+ currFunc->longInstructions = 0;
+ currFunc->vbrCount32 = 0;
+ currFunc->vbrCount64 = 0;
+ currFunc->vbrCompBytes = 0;
+ currFunc->vbrExpdBytes = 0;
+
+ }
+
+ virtual void handleFunctionEnd( Function* Func) {
+ if (os)
+ *os << " } END BLOCK: Function\n";
+ currFunc->density = double(currFunc->byteSize) /
+ double(currFunc->numInstructions);
+
+ if ( bca.progressiveVerify ) {
+ try {
+ verifyModule(*M, ThrowExceptionAction);
+ } catch ( std::string& msg ) {
+ bca.VerifyInfo += "Verify@EndFunction: " + msg + "\n";
+ }
+ }
+ }
+
+ virtual void handleBasicBlockBegin( unsigned blocknum) {
+ if (os)
+ *os << " BLOCK: BasicBlock #" << blocknum << "{\n";
+ bca.numBasicBlocks++;
+ bca.numValues++;
+ if ( currFunc ) currFunc->numBasicBlocks++;
+ }
+
+ virtual bool handleInstruction( unsigned Opcode, const Type* iType,
+ std::vector<unsigned>& Operands, unsigned Size){
+ if (os) {
+ *os << " INST: OpCode="
+ << Instruction::getOpcodeName(Opcode) << " Type=\"";
+ WriteTypeSymbolic(*os,iType,M);
+ *os << "\"";
+ for ( unsigned i = 0; i < Operands.size(); ++i )
+ *os << " Op(" << i << ")=Slot(" << Operands[i] << ")";
+ *os << "\n";
+ }
+
+ bca.numInstructions++;
+ bca.numValues++;
+ bca.instructionSize += Size;
+ if (Size > 4 ) bca.longInstructions++;
+ bca.numOperands += Operands.size();
+ for (unsigned i = 0; i < Operands.size(); ++i )
+ if (Operands[i] > bca.maxValueSlot)
+ bca.maxValueSlot = Operands[i];
+ if ( currFunc ) {
+ currFunc->numInstructions++;
+ currFunc->instructionSize += Size;
+ if (Size > 4 ) currFunc->longInstructions++;
+ if ( Opcode == Instruction::PHI ) currFunc->numPhis++;
+ }
+ return Instruction::isTerminator(Opcode);
+ }
+
+ virtual void handleBasicBlockEnd(unsigned blocknum) {
+ if (os)
+ *os << " } END BLOCK: BasicBlock #" << blocknum << "{\n";
+ }
+
+ virtual void handleGlobalConstantsBegin() {
+ if (os)
+ *os << " BLOCK: GlobalConstants {\n";
+ }
+
+ virtual void handleConstantExpression( unsigned Opcode,
+ std::vector<Constant*> ArgVec, Constant* C ) {
+ if (os) {
+ *os << " EXPR: " << Instruction::getOpcodeName(Opcode) << "\n";
+ for ( unsigned i = 0; i < ArgVec.size(); ++i ) {
+ *os << " Arg#" << i << " "; ArgVec[i]->print(*os);
+ *os << "\n";
+ }
+ *os << " Value=";
+ C->print(*os);
+ *os << "\n";
+ }
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantValue( Constant * c ) {
+ if (os) {
+ *os << " VALUE: ";
+ c->print(*os);
+ *os << "\n";
+ }
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantArray( const ArrayType* AT,
+ std::vector<Constant*>& Elements,
+ unsigned TypeSlot,
+ Constant* ArrayVal ) {
+ if (os) {
+ *os << " ARRAY: ";
+ WriteTypeSymbolic(*os,AT,M);
+ *os << " TypeSlot=" << TypeSlot << "\n";
+ for ( unsigned i = 0; i < Elements.size(); ++i ) {
+ *os << " #" << i;
+ Elements[i]->print(*os);
+ *os << "\n";
+ }
+ *os << " Value=";
+ ArrayVal->print(*os);
+ *os << "\n";
+ }
+
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantStruct(
+ const StructType* ST,
+ std::vector<Constant*>& Elements,
+ Constant* StructVal)
+ {
+ if (os) {
+ *os << " STRUC: ";
+ WriteTypeSymbolic(*os,ST,M);
+ *os << "\n";
+ for ( unsigned i = 0; i < Elements.size(); ++i ) {
+ *os << " #" << i << " "; Elements[i]->print(*os);
+ *os << "\n";
+ }
+ *os << " Value=";
+ StructVal->print(*os);
+ *os << "\n";
+ }
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantPacked(
+ const PackedType* PT,
+ std::vector<Constant*>& Elements,
+ unsigned TypeSlot,
+ Constant* PackedVal)
+ {
+ if (os) {
+ *os << " PACKD: ";
+ WriteTypeSymbolic(*os,PT,M);
+ *os << " TypeSlot=" << TypeSlot << "\n";
+ for ( unsigned i = 0; i < Elements.size(); ++i ) {
+ *os << " #" << i;
+ Elements[i]->print(*os);
+ *os << "\n";
+ }
+ *os << " Value=";
+ PackedVal->print(*os);
+ *os << "\n";
+ }
+
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantPointer( const PointerType* PT,
+ unsigned Slot, GlobalValue* GV ) {
+ if (os) {
+ *os << " PNTR: ";
+ WriteTypeSymbolic(*os,PT,M);
+ *os << " Slot=" << Slot << " GlobalValue=";
+ GV->print(*os);
+ *os << "\n";
+ }
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleConstantString( const ConstantArray* CA ) {
+ if (os) {
+ *os << " STRNG: ";
+ CA->print(*os);
+ *os << "\n";
+ }
+ bca.numConstants++;
+ bca.numValues++;
+ }
+
+ virtual void handleGlobalConstantsEnd() {
+ if (os)
+ *os << " } END BLOCK: GlobalConstants\n";
+
+ if ( bca.progressiveVerify ) {
+ try {
+ verifyModule(*M, ThrowExceptionAction);
+ } catch ( std::string& msg ) {
+ bca.VerifyInfo += "Verify@EndGlobalConstants: " + msg + "\n";
+ }
+ }
+ }
+
+ virtual void handleAlignment(unsigned numBytes) {
+ bca.numAlignment += numBytes;
+ }
+
+ virtual void handleBlock(
+ unsigned BType, const unsigned char* StartPtr, unsigned Size) {
+ bca.numBlocks++;
+ assert(BType >= BytecodeFormat::ModuleBlockID);
+ assert(BType < BytecodeFormat::NumberOfBlockIDs);
+ bca.BlockSizes[
+ llvm::BytecodeFormat::CompressedBytecodeBlockIdentifiers(BType)] += Size;
+
+ if (bca.version < 3) // Check for long block headers versions
+ bca.BlockSizes[llvm::BytecodeFormat::Reserved_DoNotUse] += 8;
+ else
+ bca.BlockSizes[llvm::BytecodeFormat::Reserved_DoNotUse] += 4;
+ }
+
+ virtual void handleVBR32(unsigned Size ) {
+ bca.vbrCount32++;
+ bca.vbrCompBytes += Size;
+ bca.vbrExpdBytes += sizeof(uint32_t);
+ if (currFunc) {
+ currFunc->vbrCount32++;
+ currFunc->vbrCompBytes += Size;
+ currFunc->vbrExpdBytes += sizeof(uint32_t);
+ }
+ }
+
+ virtual void handleVBR64(unsigned Size ) {
+ bca.vbrCount64++;
+ bca.vbrCompBytes += Size;
+ bca.vbrExpdBytes += sizeof(uint64_t);
+ if ( currFunc ) {
+ currFunc->vbrCount64++;
+ currFunc->vbrCompBytes += Size;
+ currFunc->vbrExpdBytes += sizeof(uint64_t);
+ }
+ }
+};
+
+
+/// @brief Utility for printing a titled unsigned value with
+/// an aligned colon.
+inline static void print(std::ostream& Out, const char*title,
+ unsigned val, bool nl = true ) {
+ Out << std::setw(30) << std::right << title
+ << std::setw(0) << ": "
+ << std::setw(9) << val << "\n";
+}
+
+/// @brief Utility for printing a titled double value with an
+/// aligned colon
+inline static void print(std::ostream&Out, const char*title,
+ double val ) {
+ Out << std::setw(30) << std::right << title
+ << std::setw(0) << ": "
+ << std::setw(9) << std::setprecision(6) << val << "\n" ;
+}
+
+/// @brief Utility for printing a titled double value with a
+/// percentage and aligned colon.
+inline static void print(std::ostream&Out, const char*title,
+ double top, double bot ) {
+ Out << std::setw(30) << std::right << title
+ << std::setw(0) << ": "
+ << std::setw(9) << std::setprecision(6) << top
+ << " (" << std::left << std::setw(0) << std::setprecision(4)
+ << (top/bot)*100.0 << "%)\n";
+}
+
+/// @brief Utility for printing a titled string value with
+/// an aligned colon.
+inline static void print(std::ostream&Out, const char*title,
+ std::string val, bool nl = true) {
+ Out << std::setw(30) << std::right << title
+ << std::setw(0) << ": "
+ << std::left << val << (nl ? "\n" : "");
+}
+
+}
+
+namespace llvm {
+
+/// This function prints the contents of rhe BytecodeAnalysis structure in
+/// a human legible form.
+/// @brief Print BytecodeAnalysis structure to an ostream
+void PrintBytecodeAnalysis(BytecodeAnalysis& bca, std::ostream& Out )
+{
+ Out << "\nSummary Analysis Of " << bca.ModuleId << ": \n\n";
+ print(Out, "Bytecode Analysis Of Module", bca.ModuleId);
+ print(Out, "Bytecode Version Number", bca.version);
+ print(Out, "File Size", bca.byteSize);
+ print(Out, "Module Bytes",
+ double(bca.BlockSizes[BytecodeFormat::ModuleBlockID]),
+ double(bca.byteSize));
+ print(Out, "Function Bytes",
+ double(bca.BlockSizes[BytecodeFormat::FunctionBlockID]),
+ double(bca.byteSize));
+ print(Out, "Global Types Bytes",
+ double(bca.BlockSizes[BytecodeFormat::GlobalTypePlaneBlockID]),
+ double(bca.byteSize));
+ print(Out, "Constant Pool Bytes",
+ double(bca.BlockSizes[BytecodeFormat::ConstantPoolBlockID]),
+ double(bca.byteSize));
+ print(Out, "Module Globals Bytes",
+ double(bca.BlockSizes[BytecodeFormat::ModuleGlobalInfoBlockID]),
+ double(bca.byteSize));
+ print(Out, "Instruction List Bytes",
+ double(bca.BlockSizes[BytecodeFormat::InstructionListBlockID]),
+ double(bca.byteSize));
+ print(Out, "Compaction Table Bytes",
+ double(bca.BlockSizes[BytecodeFormat::CompactionTableBlockID]),
+ double(bca.byteSize));
+ print(Out, "Symbol Table Bytes",
+ double(bca.BlockSizes[BytecodeFormat::SymbolTableBlockID]),
+ double(bca.byteSize));
+ print(Out, "Alignment Bytes",
+ double(bca.numAlignment), double(bca.byteSize));
+ print(Out, "Block Header Bytes",
+ double(bca.BlockSizes[BytecodeFormat::Reserved_DoNotUse]),
+ double(bca.byteSize));
+ print(Out, "Dependent Libraries Bytes", double(bca.libSize),
+ double(bca.byteSize));
+ print(Out, "Number Of Bytecode Blocks", bca.numBlocks);
+ print(Out, "Number Of Functions", bca.numFunctions);
+ print(Out, "Number Of Types", bca.numTypes);
+ print(Out, "Number Of Constants", bca.numConstants);
+ print(Out, "Number Of Global Variables", bca.numGlobalVars);
+ print(Out, "Number Of Values", bca.numValues);
+ print(Out, "Number Of Basic Blocks", bca.numBasicBlocks);
+ print(Out, "Number Of Instructions", bca.numInstructions);
+ print(Out, "Number Of Long Instructions", bca.longInstructions);
+ print(Out, "Number Of Operands", bca.numOperands);
+ print(Out, "Number Of Compaction Tables", bca.numCmpctnTables);
+ print(Out, "Number Of Symbol Tables", bca.numSymTab);
+ print(Out, "Number Of Dependent Libs", bca.numLibraries);
+ print(Out, "Total Instruction Size", bca.instructionSize);
+ print(Out, "Average Instruction Size",
+ double(bca.instructionSize)/double(bca.numInstructions));
+
+ print(Out, "Maximum Type Slot Number", bca.maxTypeSlot);
+ print(Out, "Maximum Value Slot Number", bca.maxValueSlot);
+ print(Out, "Bytes Per Value ", bca.fileDensity);
+ print(Out, "Bytes Per Global", bca.globalsDensity);
+ print(Out, "Bytes Per Function", bca.functionDensity);
+ print(Out, "# of VBR 32-bit Integers", bca.vbrCount32);
+ print(Out, "# of VBR 64-bit Integers", bca.vbrCount64);
+ print(Out, "# of VBR Compressed Bytes", bca.vbrCompBytes);
+ print(Out, "# of VBR Expanded Bytes", bca.vbrExpdBytes);
+ print(Out, "Bytes Saved With VBR",
+ double(bca.vbrExpdBytes)-double(bca.vbrCompBytes),
+ double(bca.vbrExpdBytes));
+
+ if (bca.detailedResults) {
+ Out << "\nDetailed Analysis Of " << bca.ModuleId << " Functions:\n";
+
+ std::map<const Function*,BytecodeAnalysis::BytecodeFunctionInfo>::iterator I =
+ bca.FunctionInfo.begin();
+ std::map<const Function*,BytecodeAnalysis::BytecodeFunctionInfo>::iterator E =
+ bca.FunctionInfo.end();
+
+ while ( I != E ) {
+ Out << std::left << std::setw(0) << "\n";
+ if (I->second.numBasicBlocks == 0) Out << "External ";
+ Out << "Function: " << I->second.name << "\n";
+ print(Out, "Type:", I->second.description);
+ print(Out, "Byte Size", I->second.byteSize);
+ if (I->second.numBasicBlocks) {
+ print(Out, "Basic Blocks", I->second.numBasicBlocks);
+ print(Out, "Instructions", I->second.numInstructions);
+ print(Out, "Long Instructions", I->second.longInstructions);
+ print(Out, "Operands", I->second.numOperands);
+ print(Out, "Instruction Size", I->second.instructionSize);
+ print(Out, "Average Instruction Size",
+ double(I->second.instructionSize) / I->second.numInstructions);
+ print(Out, "Bytes Per Instruction", I->second.density);
+ print(Out, "# of VBR 32-bit Integers", I->second.vbrCount32);
+ print(Out, "# of VBR 64-bit Integers", I->second.vbrCount64);
+ print(Out, "# of VBR Compressed Bytes", I->second.vbrCompBytes);
+ print(Out, "# of VBR Expanded Bytes", I->second.vbrExpdBytes);
+ print(Out, "Bytes Saved With VBR",
+ double(I->second.vbrExpdBytes) - I->second.vbrCompBytes),
+ double(I->second.vbrExpdBytes);
+ }
+ ++I;
+ }
+ }
+
+ if ( bca.progressiveVerify )
+ Out << bca.VerifyInfo;
+}
+
+BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
+ std::ostream* output)
+{
+ return new AnalyzerHandler(bca,output);
+}
+
+}
+
diff --git a/lib/Bytecode/Reader/Makefile b/lib/Bytecode/Reader/Makefile
new file mode 100644
index 0000000000..cdfa11b1f1
--- /dev/null
+++ b/lib/Bytecode/Reader/Makefile
@@ -0,0 +1,13 @@
+##===- lib/Bytecode/Reader/Makefile ------------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by the LLVM research group and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../..
+LIBRARYNAME = LLVMBCReader
+
+include $(LEVEL)/Makefile.common
+
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
new file mode 100644
index 0000000000..daf7577cf0
--- /dev/null
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -0,0 +1,2343 @@
+//===- Reader.cpp - Code to read bytecode files ---------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This library implements the functionality defined in llvm/Bytecode/Reader.h
+//
+// Note that this library should be as fast as possible, reentrant, and
+// threadsafe!!
+//
+// TODO: Allow passing in an option to ignore the symbol table
+//
+//===----------------------------------------------------------------------===//
+
+#include "Reader.h"
+#include "llvm/Bytecode/BytecodeHandler.h"
+#include "llvm/BasicBlock.h"
+#include "llvm/CallingConv.h"
+#include "llvm/Constants.h"
+#include "llvm/Instructions.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Bytecode/Format.h"
+#include "llvm/Config/alloca.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/Compressor.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include <sstream>
+#include <algorithm>
+using namespace llvm;
+
+namespace {
+ /// @brief A class for maintaining the slot number definition
+ /// as a placeholder for the actual definition for forward constants defs.
+ class ConstantPlaceHolder : public ConstantExpr {
+ ConstantPlaceHolder(); // DO NOT IMPLEMENT
+ void operator=(const ConstantPlaceHolder &); // DO NOT IMPLEMENT
+ public:
+ Use Op;
+ ConstantPlaceHolder(const Type *Ty)
+ : ConstantExpr(Ty, Instruction::UserOp1, &Op, 1),
+ Op(UndefValue::get(Type::IntTy), this) {
+ }
+ };
+}
+
+// Provide some details on error
+inline void BytecodeReader::error(std::string err) {
+ err += " (Vers=" ;
+ err += itostr(RevisionNum) ;
+ err += ", Pos=" ;
+ err += itostr(At-MemStart);
+ err += ")";
+ throw err;
+}
+
+//===----------------------------------------------------------------------===//
+// Bytecode Reading Methods
+//===----------------------------------------------------------------------===//
+
+/// Determine if the current block being read contains any more data.
+inline bool BytecodeReader::moreInBlock() {
+ return At < BlockEnd;
+}
+
+/// Throw an error if we've read past the end of the current block
+inline void BytecodeReader::checkPastBlockEnd(const char * block_name) {
+ if (At > BlockEnd)
+ error(std::string("Attempt to read past the end of ") + block_name +
+ " block.");
+}
+
+/// Align the buffer position to a 32 bit boundary
+inline void BytecodeReader::align32() {
+ if (hasAlignment) {
+ BufPtr Save = At;
+ At = (const unsigned char *)((unsigned long)(At+3) & (~3UL));
+ if (At > Save)
+ if (Handler) Handler->handleAlignment(At - Save);
+ if (At > BlockEnd)
+ error("Ran out of data while aligning!");
+ }
+}
+
+/// Read a whole unsigned integer
+inline unsigned BytecodeReader::read_uint() {
+ if (At+4 > BlockEnd)
+ error("Ran out of data reading uint!");
+ At += 4;
+ return At[-4] | (At[-3] << 8) | (At[-2] << 16) | (At[-1] << 24);
+}
+
+/// Read a variable-bit-rate encoded unsigned integer
+inline unsigned BytecodeReader::read_vbr_uint() {
+ unsigned Shift = 0;
+ unsigned Result = 0;
+ BufPtr Save = At;
+
+ do {
+ if (At == BlockEnd)
+ error("Ran out of data reading vbr_uint!");
+ Result |= (unsigned)((*At++) & 0x7F) << Shift;
+ Shift += 7;
+ } while (At[-1] & 0x80);
+ if (Handler) Handler->handleVBR32(At-Save);
+ return Result;
+}
+
+/// Read a variable-bit-rate encoded unsigned 64-bit integer.
+inline uint64_t BytecodeReader::read_vbr_uint64() {
+ unsigned Shift = 0;
+ uint64_t Result = 0;
+ BufPtr Save = At;
+
+ do {
+ if (At == BlockEnd)
+ error("Ran out of data reading vbr_uint64!");
+ Result |= (uint64_t)((*At++) & 0x7F) << Shift;
+ Shift += 7;
+ } while (At[-1] & 0x80);
+ if (Handler) Handler->handleVBR64(At-Save);
+ return Result;
+}
+
+/// Read a variable-bit-rate encoded signed 64-bit integer.
+inline int64_t BytecodeReader::read_vbr_int64() {
+ uint64_t R = read_vbr_uint64();
+ if (R & 1) {
+ if (R != 1)
+ return -(int64_t)(R >> 1);
+ else // There is no such thing as -0 with integers. "-0" really means
+ // 0x8000000000000000.
+ return 1LL << 63;
+ } else
+ return (int64_t)(R >> 1);
+}
+
+/// Read a pascal-style string (length followed by text)
+inline std::string BytecodeReader::read_str() {
+ unsigned Size = read_vbr_uint();
+ const unsigned char *OldAt = At;
+ At += Size;
+ if (At > BlockEnd) // Size invalid?
+ error("Ran out of data reading a string!");
+ return std::string((char*)OldAt, Size);
+}
+
+/// Read an arbitrary block of data
+inline void BytecodeReader::read_data(void *Ptr, void *End) {
+ unsigned char *Start = (unsigned char *)Ptr;
+ unsigned Amount = (unsigned char *)End - Start;
+ if (At+Amount > BlockEnd)
+ error("Ran out of data!");
+ std::copy(At, At+Amount, Start);
+ At += Amount;
+}
+
+/// Read a float value in little-endian order
+inline void BytecodeReader::read_float(float& FloatVal) {
+ /// FIXME: This isn't optimal, it has size problems on some platforms
+ /// where FP is not IEEE.
+ FloatVal = BitsToFloat(At[0] | (At[1] << 8) | (At[2] << 16) | (At[3] << 24));
+ At+=sizeof(uint32_t);
+}
+
+/// Read a double value in little-endian order
+inline void BytecodeReader::read_double(double& DoubleVal) {
+ /// FIXME: This isn't optimal, it has size problems on some platforms
+ /// where FP is not IEEE.
+ DoubleVal = BitsToDouble((uint64_t(At[0]) << 0) | (uint64_t(At[1]) << 8) |
+ (uint64_t(At[2]) << 16) | (uint64_t(At[3]) << 24) |
+ (uint64_t(At[4]) << 32) | (uint64_t(At[5]) << 40) |
+ (uint64_t(At[6]) << 48) | (uint64_t(At[7]) << 56));
+ At+=sizeof(uint64_t);
+}
+
+/// Read a block header and obtain its type and size
+inline void BytecodeReader::read_block(unsigned &Type, unsigned &Size) {
+ if ( hasLongBlockHeaders ) {
+ Type = read_uint();
+ Size = read_uint();
+ switch (Type) {
+ case BytecodeFormat::Reserved_DoNotUse :
+ error("Reserved_DoNotUse used as Module Type?");
+ Type = BytecodeFormat::ModuleBlockID; break;
+ case BytecodeFormat::Module:
+ Type = BytecodeFormat::ModuleBlockID; break;
+ case BytecodeFormat::Function:
+ Type = BytecodeFormat::FunctionBlockID; break;
+ case BytecodeFormat::ConstantPool:
+ Type = BytecodeFormat::ConstantPoolBlockID; break;
+ case BytecodeFormat::SymbolTable:
+ Type = BytecodeFormat::SymbolTableBlockID; break;
+ case BytecodeFormat::ModuleGlobalInfo:
+ Type = BytecodeFormat::ModuleGlobalInfoBlockID; break;
+ case BytecodeFormat::GlobalTypePlane:
+ Type = BytecodeFormat::GlobalTypePlaneBlockID; break;
+ case BytecodeFormat::InstructionList:
+ Type = BytecodeFormat::InstructionListBlockID; break;
+ case BytecodeFormat::CompactionTable:
+ Type = BytecodeFormat::CompactionTableBlockID; break;
+ case BytecodeFormat::BasicBlock:
+ /// This block type isn't used after version 1.1. However, we have to
+ /// still allow the value in case this is an old bc format file.
+ /// We just let its value creep thru.
+ break;
+ default:
+ error("Invalid block id found: " + utostr(Type));
+ break;
+ }
+ } else {
+ Size = read_uint();
+ Type = Size & 0x1F; // mask low order five bits
+ Size >>= 5; // get rid of five low order bits, leaving high 27
+ }
+ BlockStart = At;
+ if (At + Size > BlockEnd)
+ error("Attempt to size a block past end of memory");
+ BlockEnd = At + Size;
+ if (Handler) Handler->handleBlock(Type, BlockStart, Size);
+}
+
+
+/// In LLVM 1.2 and before, Types were derived from Value and so they were
+/// written as part of the type planes along with any other Value. In LLVM
+/// 1.3 this changed so that Type does not derive from Value. Consequently,
+/// the BytecodeReader's containers for Values can't contain Types because
+/// there's no inheritance relationship. This means that the "Type Type"
+/// plane is defunct along with the Type::TypeTyID TypeID. In LLVM 1.3
+/// whenever a bytecode construct must have both types and values together,
+/// the types are always read/written first and then the Values. Furthermore
+/// since Type::TypeTyID no longer exists, its value (12) now corresponds to
+/// Type::LabelTyID. In order to overcome this we must "sanitize" all the
+/// type TypeIDs we encounter. For LLVM 1.3 bytecode files, there's no change.
+/// For LLVM 1.2 and before, this function will decrement the type id by
+/// one to account for the missing Type::TypeTyID enumerator if the value is
+/// larger than 12 (Type::LabelTyID). If the value is exactly 12, then this
+/// function returns true, otherwise false. This helps detect situations
+/// where the pre 1.3 bytecode is indicating that what follows is a type.
+/// @returns true iff type id corresponds to pre 1.3 "type type"
+inline bool BytecodeReader::sanitizeTypeId(unsigned &TypeId) {
+ if (hasTypeDerivedFromValue) { /// do nothing if 1.3 or later
+ if (TypeId == Type::LabelTyID) {
+ TypeId = Type::VoidTyID; // sanitize it
+ return true; // indicate we got TypeTyID in pre 1.3 bytecode
+ } else if (TypeId > Type::LabelTyID)
+ --TypeId; // shift all planes down because type type plane is missing
+ }
+ return false;
+}
+
+/// Reads a vbr uint to read in a type id and does the necessary
+/// conversion on it by calling sanitizeTypeId.
+/// @returns true iff \p TypeId read corresponds to a pre 1.3 "type type"
+/// @see sanitizeTypeId
+inline bool BytecodeReader::read_typeid(unsigned &TypeId) {
+ TypeId = read_vbr_uint();
+ if ( !has32BitTypes )
+ if ( TypeId == 0x00FFFFFF )
+ TypeId = read_vbr_uint();
+ return sanitizeTypeId(TypeId);
+}
+
+//===----------------------------------------------------------------------===//
+// IR Lookup Methods
+//===----------------------------------------------------------------------===//
+
+/// Determine if a type id has an implicit null value
+inline bool BytecodeReader::hasImplicitNull(unsigned TyID) {
+ if (!hasExplicitPrimitiveZeros)
+ return TyID != Type::LabelTyID && TyID != Type::VoidTyID;
+ return TyID >= Type::FirstDerivedTyID;
+}
+
+/// Obtain a type given a typeid and account for things like compaction tables,
+/// function level vs module level, and the offsetting for the primitive types.
+const Type *BytecodeReader::getType(unsigned ID) {
+ if (ID < Type::FirstDerivedTyID)
+ if (const Type *T = Type::getPrimitiveType((Type::TypeID)ID))
+ return T; // Asked for a primitive type...
+
+ // Otherwise, derived types need offset...
+ ID -= Type::FirstDerivedTyID;
+
+ if (!CompactionTypes.empty()) {
+ if (ID >= CompactionTypes.size())
+ error("Type ID out of range for compaction table!");
+ return CompactionTypes[ID].first;
+ }
+
+ // Is it a module-level type?
+ if (ID < ModuleTypes.size())
+ return ModuleTypes[ID].get();
+
+ // Nope, is it a function-level type?
+ ID -= ModuleTypes.size();
+ if (ID < FunctionTypes.size())
+ return FunctionTypes[ID].get();
+
+ error("Illegal type reference!");
+ return Type::VoidTy;
+}
+
+/// Get a sanitized type id. This just makes sure that the \p ID
+/// is both sanitized and not the "type type" of pre-1.3 bytecode.
+/// @see sanitizeTypeId
+inline const Type* BytecodeReader::getSanitizedType(unsigned& ID) {
+ if (sanitizeTypeId(ID))
+ error("Invalid type id encountered");
+ return getType(ID);
+}
+
+/// This method just saves some coding. It uses read_typeid to read
+/// in a sanitized type id, errors that its not the type type, and
+/// then calls getType to return the type value.
+inline const Type* BytecodeReader::readSanitizedType() {
+ unsigned ID;
+ if (read_typeid(ID))
+ error("Invalid type id encountered");
+ return getType(ID);
+}
+
+/// Get the slot number associated with a type accounting for primitive
+/// types, compaction tables, and function level vs module level.
+unsigned BytecodeReader::getTypeSlot(const Type *Ty) {
+ if (Ty->isPrimitiveType())
+ return Ty->getTypeID();
+
+ // Scan the compaction table for the type if needed.
+ if (!CompactionTypes.empty()) {
+ for (unsigned i = 0, e = CompactionTypes.size(); i != e; ++i)
+ if (CompactionTypes[i].first == Ty)
+ return Type::FirstDerivedTyID + i;
+
+ error("Couldn't find type specified in compaction table!");
+ }
+
+ // Check the function level types first...
+ TypeListTy::iterator I = std::find(FunctionTypes.begin(),
+ FunctionTypes.end(), Ty);
+
+ if (I != FunctionTypes.end())
+ return Type::FirstDerivedTyID + ModuleTypes.size() +
+ (&*I - &FunctionTypes[0]);
+
+ // If we don't have our cache yet, build it now.
+ if (ModuleTypeIDCache.empty()) {
+ unsigned N = 0;
+ ModuleTypeIDCache.reserve(ModuleTypes.size());
+ for (TypeListTy::iterator I = ModuleTypes.begin(), E = ModuleTypes.end();
+ I != E; ++I, ++N)
+ ModuleTypeIDCache.push_back(std::make_pair(*I, N));
+
+ std::sort(ModuleTypeIDCache.begin(), ModuleTypeIDCache.end());
+ }
+
+ // Binary search the cache for the entry.
+ std::vector<std::pair<const Type*, unsigned> >::iterator IT =
+ std::lower_bound(ModuleTypeIDCache.begin(), ModuleTypeIDCache.end(),
+ std::make_pair(Ty, 0U));
+ if (IT == ModuleTypeIDCache.end() || IT->first != Ty)
+ error("Didn't find type in ModuleTypes.");
+
+ return Type::FirstDerivedTyID + IT->second;
+}
+
+/// This is just like getType, but when a compaction table is in use, it is
+/// ignored. It also ignores function level types.
+/// @see getType
+const Type *BytecodeReader::getGlobalTableType(unsigned Slot) {
+ if (Slot < Type::FirstDerivedTyID) {
+ const Type *Ty = Type::getPrimitiveType((Type::TypeID)Slot);
+ if (!Ty)
+ error("Not a primitive type ID?");
+ return Ty;
+ }
+ Slot -= Type::FirstDerivedTyID;
+ if (Slot >= ModuleTypes.size())
+ error("Illegal compaction table type reference!");
+ return ModuleTypes[Slot];
+}
+
+/// This is just like getTypeSlot, but when a compaction table is in use, it
+/// is ignored. It also ignores function level types.
+unsigned BytecodeReader::getGlobalTableTypeSlot(const Type *Ty) {
+ if (Ty->isPrimitiveType())
+ return Ty->getTypeID();
+
+ // If we don't have our cache yet, build it now.
+ if (ModuleTypeIDCache.empty()) {
+ unsigned N = 0;
+ ModuleTypeIDCache.reserve(ModuleTypes.size());
+ for (TypeListTy::iterator I = ModuleTypes.begin(), E = ModuleTypes.end();
+ I != E; ++I, ++N)
+ ModuleTypeIDCache.push_back(std::make_pair(*I, N));
+
+ std::sort(ModuleTypeIDCache.begin(), ModuleTypeIDCache.end());
+ }
+
+ // Binary search the cache for the entry.
+ std::vector<std::pair<const Type*, unsigned> >::iterator IT =
+ std::lower_bound(ModuleTypeIDCache.begin(), ModuleTypeIDCache.end(),
+ std::make_pair(Ty, 0U));
+ if (IT == ModuleTypeIDCache.end() || IT->first != Ty)
+ error("Didn't find type in ModuleTypes.");
+
+ return Type::FirstDerivedTyID + IT->second;
+}
+
+/// Retrieve a value of a given type and slot number, possibly creating
+/// it if it doesn't already exist.
+Value * BytecodeReader::getValue(unsigned type, unsigned oNum, bool Create) {
+ assert(type != Type::LabelTyID && "getValue() cannot get blocks!");
+ unsigned Num = oNum;
+
+ // If there is a compaction table active, it defines the low-level numbers.
+ // If not, the module values define the low-level numbers.
+ if (CompactionValues.size() > type && !CompactionValues[type].empty()) {
+ if (Num < CompactionValues[type].size())
+ return CompactionValues[type][Num];
+ Num -= CompactionValues[type].size();
+ } else {
+ // By default, the global type id is the type id passed in
+ unsigned GlobalTyID = type;
+
+ // If the type plane was compactified, figure out the global type ID by
+ // adding the derived type ids and the distance.
+ if (!CompactionTypes.empty() && type >= Type::FirstDerivedTyID)
+ GlobalTyID = CompactionTypes[type-Type::FirstDerivedTyID].second;
+
+ if (hasImplicitNull(GlobalTyID)) {
+ const Type *Ty = getType(type);
+ if (!isa<OpaqueType>(Ty)) {
+ if (Num == 0)
+ return Constant::getNullValue(Ty);
+ --Num;
+ }
+ }
+
+ if (GlobalTyID < ModuleValues.size() && ModuleValues[GlobalTyID]) {
+ if (Num < ModuleValues[GlobalTyID]->size())
+ return ModuleValues[GlobalTyID]->getOperand(Num);
+ Num -= ModuleValues[GlobalTyID]->size();
+ }
+ }
+
+ if (FunctionValues.size() > type &&
+ FunctionValues[type] &&
+ Num < FunctionValues[type]->size())
+ return FunctionValues[type]->getOperand(Num);
+
+ if (!Create) return 0; // Do not create a placeholder?
+
+ // Did we already create a place holder?
+ std::pair<unsigned,unsigned> KeyValue(type, oNum);
+ ForwardReferenceMap::iterator I = ForwardReferences.lower_bound(KeyValue);
+ if (I != ForwardReferences.end() && I->first == KeyValue)
+ return I->second; // We have already created this placeholder
+
+ // If the type exists (it should)
+ if (const Type* Ty = getType(type)) {
+ // Create the place holder
+ Value *Val = new Argument(Ty);
+ ForwardReferences.insert(I, std::make_pair(KeyValue, Val));
+ return Val;
+ }
+ throw "Can't create placeholder for value of type slot #" + utostr(type);
+}
+
+/// This is just like getValue, but when a compaction table is in use, it
+/// is ignored. Also, no forward references or other fancy features are
+/// supported.
+Value* BytecodeReader::getGlobalTableValue(unsigned TyID, unsigned SlotNo) {
+ if (SlotNo == 0)
+ return Constant::getNullValue(getType(TyID));
+
+ if (!CompactionTypes.empty() && TyID >= Type::FirstDerivedTyID) {
+ TyID -= Type::FirstDerivedTyID;
+ if (TyID >= CompactionTypes.size())
+ error("Type ID out of range for compaction table!");
+ TyID = CompactionTypes[TyID].second;
+ }
+
+ --SlotNo;
+
+ if (TyID >= ModuleValues.size() || ModuleValues[TyID] == 0 ||
+ SlotNo >= ModuleValues[TyID]->size()) {
+ if (TyID >= ModuleValues.size() || ModuleValues[TyID] == 0)
+ error("Corrupt compaction table entry!"
+ + utostr(TyID) + ", " + utostr(SlotNo) + ": "
+ + utostr(ModuleValues.size()));
+ else
+ error("Corrupt compaction table entry!"
+ + utostr(TyID) + ", " + utostr(SlotNo) + ": "
+ + utostr(ModuleValues.size()) + ", "
+ + utohexstr(reinterpret_cast<uint64_t>(((void*)ModuleValues[TyID])))
+ + ", "
+ + utostr(ModuleValues[TyID]->size()));
+ }
+ return ModuleValues[TyID]->getOperand(SlotNo);
+}
+
+/// Just like getValue, except that it returns a null pointer
+/// only on error. It always returns a constant (meaning that if the value is
+/// defined, but is not a constant, that is an error). If the specified
+/// constant hasn't been parsed yet, a placeholder is defined and used.
+/// Later, after the real value is parsed, the placeholder is eliminated.
+Constant* BytecodeReader::getConstantValue(unsigned TypeSlot, unsigned Slot) {
+ if (Value *V = getValue(TypeSlot, Slot, false))
+ if (Constant *C = dyn_cast<Constant>(V))
+ return C; // If we already have the value parsed, just return it
+ else
+ error("Value for slot " + utostr(Slot) +
+ " is expected to be a constant!");
+
+ std::pair<unsigned, unsigned> Key(TypeSlot, Slot);
+ ConstantRefsType::iterator I = ConstantFwdRefs.lower_bound(Key);
+
+ if (I != ConstantFwdRefs.end() && I->first == Key) {
+ return I->second;
+ } else {
+ // Create a placeholder for the constant reference and
+ // keep track of the fact that we have a forward ref to recycle it
+ Constant *C = new ConstantPlaceHolder(getType(TypeSlot));
+
+ // Keep track of the fact that we have a forward ref to recycle it
+ ConstantFwdRefs.insert(I, std::make_pair(Key, C));
+ return C;
+ }
+}
+
+//===----------------------------------------------------------------------===//
+// IR Construction Methods
+//===----------------------------------------------------------------------===//
+
+/// As values are created, they are inserted into the appropriate place
+/// with this method. The ValueTable argument must be one of ModuleValues
+/// or FunctionValues data members of this class.
+unsigned BytecodeReader::insertValue(Value *Val, unsigned type,
+ ValueTable &ValueTab) {
+ assert((!isa<Constant>(Val) || !cast<Constant>(Val)->isNullValue()) ||
+ !hasImplicitNull(type) &&
+ "Cannot read null values from bytecode!");
+
+ if (ValueTab.size() <= type)
+ ValueTab.resize(type+1);
+
+ if (!ValueTab[type]) ValueTab[type] = new ValueList();
+
+ ValueTab[type]->push_back(Val);
+
+ bool HasOffset = hasImplicitNull(type) && !isa<OpaqueType>(Val->getType());
+ return ValueTab[type]->size()-1 + HasOffset;
+}
+
+/// Insert the arguments of a function as new values in the reader.
+void BytecodeReader::insertArguments(Function* F) {
+ const FunctionType *FT = F->getFunctionType();
+ Function::arg_iterator AI = F->arg_begin();
+ for (FunctionType::param_iterator It = FT->param_begin();
+ It != FT->param_end(); ++It, ++AI)
+ insertValue(AI, getTypeSlot(AI->getType()), FunctionValues);
+}
+
+//===----------------------------------------------------------------------===//
+// Bytecode Parsing Methods
+//===----------------------------------------------------------------------===//
+
+/// This method parses a single instruction. The instruction is
+/// inserted at the end of the \p BB provided. The arguments of
+/// the instruction are provided in the \p Oprnds vector.
+void BytecodeReader::ParseInstruction(std::vector<unsigned> &Oprnds,
+ BasicBlock* BB) {
+ BufPtr SaveAt = At;
+
+ // Clear instruction data
+ Oprnds.clear();
+ unsigned iType = 0;
+ unsigned Opcode = 0;
+ unsigned Op = read_uint();
+
+ // bits Instruction format: Common to all formats
+ // --------------------------
+ // 01-00: Opcode type, fixed to 1.
+ // 07-02: Opcode
+ Opcode = (Op >> 2) & 63;
+ Oprnds.resize((Op >> 0) & 03);
+
+ // Extract the operands
+ switch (Oprnds.size()) {
+ case 1:
+ // bits Instruction format:
+ // --------------------------
+ // 19-08: Resulting type plane
+ // 31-20: Operand #1 (if set to (2^12-1), then zero operands)
+ //
+ iType = (Op >> 8) & 4095;
+ Oprnds[0] = (Op >> 20) & 4095;
+ if (Oprnds[0] == 4095) // Handle special encoding for 0 operands...
+ Oprnds.resize(0);
+ break;
+ case 2:
+ // bits Instruction format:
+ // --------------------------
+ // 15-08: Resulting type plane
+ // 23-16: Operand #1
+ // 31-24: Operand #2
+ //
+ iType = (Op >> 8) & 255;
+ Oprnds[0] = (Op >> 16) & 255;
+ Oprnds[1] = (Op >> 24) & 255;
+ break;
+ case 3:
+ // bits Instruction format:
+ // --------------------------
+ // 13-08: Resulting type plane
+ // 19-14: Operand #1
+ // 25-20: Operand #2
+ // 31-26: Operand #3
+ //
+ iType = (Op >> 8) & 63;
+ Oprnds[0] = (Op >> 14) & 63;
+ Oprnds[1] = (Op >> 20) & 63;
+ Oprnds[2] = (Op >> 26) & 63;
+ break;
+ case 0:
+ At -= 4; // Hrm, try this again...
+ Opcode = read_vbr_uint();
+ Opcode >>= 2;
+ iType = read_vbr_uint();
+
+ unsigned NumOprnds = read_vbr_uint();
+ Oprnds.resize(NumOprnds);
+
+ if (NumOprnds == 0)
+ error("Zero-argument instruction found; this is invalid.");
+
+ for (unsigned i = 0; i != NumOprnds; ++i)
+ Oprnds[i] = read_vbr_uint();
+ align32();
+ break;
+ }
+
+ const Type *InstTy = getSanitizedType(iType);
+
+ // We have enough info to inform the handler now.
+ if (Handler) Handler->handleInstruction(Opcode, InstTy, Oprnds, At-SaveAt);
+
+ // Declare the resulting instruction we'll build.
+ Instruction *Result = 0;
+
+ // If this is a bytecode format that did not include the unreachable
+ // instruction, bump up all opcodes numbers to make space.
+ if (hasNoUnreachableInst) {
+ if (Opcode >= Instruction::Unreachable &&
+ Opcode < 62) {
+ ++Opcode;
+ }
+ }
+
+ // Handle binary operators
+ if (Opcode >= Instruction::BinaryOpsBegin &&
+ Opcode < Instruction::BinaryOpsEnd && Oprnds.size() == 2)
+ Result = BinaryOperator::create((Instruction::BinaryOps)Opcode,
+ getValue(iType, Oprnds[0]),
+ getValue(iType, Oprnds[1]));
+
+ switch (Opcode) {
+ default:
+ if (Result == 0)
+ error("Illegal instruction read!");
+ break;
+ case Instruction::VAArg:
+ Result = new VAArgInst(getValue(iType, Oprnds[0]),
+ getSanitizedType(Oprnds[1]));
+ break;
+ case 32: { //VANext_old
+ const Type* ArgTy = getValue(iType, Oprnds[0])->getType();
+ Function* NF = TheModule->getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy,
+ (Type *)0);
+
+ //b = vanext a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //tmp = vaarg foo, t
+ //b = load foo
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vanext.fix");
+ BB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, getValue(iType, Oprnds[0]));
+ BB->getInstList().push_back(bar);
+ BB->getInstList().push_back(new StoreInst(bar, foo));
+ Instruction* tmp = new VAArgInst(foo, getSanitizedType(Oprnds[1]));
+ BB->getInstList().push_back(tmp);
+ Result = new LoadInst(foo);
+ break;
+ }
+ case 33: { //VAArg_old
+ const Type* ArgTy = getValue(iType, Oprnds[0])->getType();
+ Function* NF = TheModule->getOrInsertFunction("llvm.va_copy", ArgTy, ArgTy,
+ (Type *)0);
+
+ //b = vaarg a, t ->
+ //foo = alloca 1 of t
+ //bar = vacopy a
+ //store bar -> foo
+ //b = vaarg foo, t
+ AllocaInst* foo = new AllocaInst(ArgTy, 0, "vaarg.fix");
+ BB->getInstList().push_back(foo);
+ CallInst* bar = new CallInst(NF, getValue(iType, Oprnds[0]));
+ BB->getInstList().push_back(bar);
+ BB->getInstList().push_back(new StoreInst(bar, foo));
+ Result = new VAArgInst(foo, getSanitizedType(Oprnds[1]));
+ break;
+ }
+ case Instruction::Cast:
+ Result = new CastInst(getValue(iType, Oprnds[0]),
+ getSanitizedType(Oprnds[1]));
+ break;
+ case Instruction::Select:
+ Result = new SelectInst(getValue(Type::BoolTyID, Oprnds[0]),
+ getValue(iType, Oprnds[1]),
+ getValue(iType, Oprnds[2]));
+ break;
+ case Instruction::PHI: {
+ if (Oprnds.size() == 0 || (Oprnds.size() & 1))
+ error("Invalid phi node encountered!");
+
+ PHINode *PN = new PHINode(InstTy);
+ PN->reserveOperandSpace(Oprnds.size());
+ for (unsigned i = 0, e = Oprnds.size(); i != e; i += 2)
+ PN->addIncoming(getValue(iType, Oprnds[i]), getBasicBlock(Oprnds[i+1]));
+ Result = PN;
+ break;
+ }
+
+ case Instruction::Shl:
+ case Instruction::Shr:
+ Result = new ShiftInst((Instruction::OtherOps)Opcode,
+ getValue(iType, Oprnds[0]),
+ getValue(Type::UByteTyID, Oprnds[1]));
+ break;
+ case Instruction::Ret:
+ if (Oprnds.size() == 0)
+ Result = new ReturnInst();
+ else if (Oprnds.size() == 1)
+ Result = new ReturnInst(getValue(iType, Oprnds[0]));
+ else
+ error("Unrecognized instruction!");
+ break;
+
+ case Instruction::Br:
+ if (Oprnds.size() == 1)
+ Result = new BranchInst(getBasicBlock(Oprnds[0]));
+ else if (Oprnds.size() == 3)
+ Result = new BranchInst(getBasicBlock(Oprnds[0]),
+ getBasicBlock(Oprnds[1]), getValue(Type::BoolTyID , Oprnds[2]));
+ else
+ error("Invalid number of operands for a 'br' instruction!");
+ break;
+ case Instruction::Switch: {
+ if (Oprnds.size() & 1)
+ error("Switch statement with odd number of arguments!");
+
+ SwitchInst *I = new SwitchInst(getValue(iType, Oprnds[0]),
+ getBasicBlock(Oprnds[1]),
+ Oprnds.size()/2-1);
+ for (unsigned i = 2, e = Oprnds.size(); i != e; i += 2)
+ I->addCase(cast<ConstantInt>(getValue(iType, Oprnds[i])),
+ getBasicBlock(Oprnds[i+1]));
+ Result = I;
+ break;
+ }
+
+ case 58: // Call with extra operand for calling conv
+ case 59: // tail call, Fast CC
+ case 60: // normal call, Fast CC
+ case 61: // tail call, C Calling Conv
+ case Instruction::Call: { // Normal Call, C Calling Convention
+ if (Oprnds.size() == 0)
+ error("Invalid call instruction encountered!");
+
+ Value *F = getValue(iType, Oprnds[0]);
+
+ unsigned CallingConv = CallingConv::C;
+ bool isTailCall = false;
+
+ if (Opcode == 61 || Opcode == 59)
+ isTailCall = true;
+
+ // Check to make sure we have a pointer to function type
+ const PointerType *PTy = dyn_cast<PointerType>(F->getType());
+ if (PTy == 0) error("Call to non function pointer value!");
+ const FunctionType *FTy = dyn_cast<FunctionType>(PTy->getElementType());
+ if (FTy == 0) error("Call to non function pointer value!");
+
+ std::vector<Value *> Params;
+ if (!FTy->isVarArg()) {
+ FunctionType::param_iterator It = FTy->param_begin();
+
+ if (Opcode == 58) {
+ isTailCall = Oprnds.back() & 1;
+ CallingConv = Oprnds.back() >> 1;
+ Oprnds.pop_back();
+ } else if (Opcode == 59 || Opcode == 60)
+ CallingConv = CallingConv::Fast;
+
+ for (unsigned i = 1, e = Oprnds.size(); i != e; ++i) {
+ if (It == FTy->param_end())
+ error("Invalid call instruction!");
+ Params.push_back(getValue(getTypeSlot(*It++), Oprnds[i]));
+ }
+ if (It != FTy->param_end())
+ error("Invalid call instruction!");
+ } else {
+ Oprnds.erase(Oprnds.begin(), Oprnds.begin()+1);
+
+ unsigned FirstVariableOperand;
+ if (Oprnds.size() < FTy->getNumParams())
+ error("Call instruction missing operands!");
+
+ // Read all of the fixed arguments
+ for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
+ Params.push_back(getValue(getTypeSlot(FTy->getParamType(i)),Oprnds[i]));
+
+ FirstVariableOperand = FTy->getNumParams();
+
+ if ((Oprnds.size()-FirstVariableOperand) & 1)
+ error("Invalid call instruction!"); // Must be pairs of type/value
+
+ for (unsigned i = FirstVariableOperand, e = Oprnds.size();
+ i != e; i += 2)
+ Params.push_back(getValue(Oprnds[i], Oprnds[i+1]));
+ }
+
+ Result = new CallInst(F, Params);
+ if (isTailCall) cast<CallInst>(Result)->setTailCall();
+ if (CallingConv) cast<CallInst>(Result)->setCallingConv(CallingConv);
+ break;
+ }
+ case 56: // Invoke with encoded CC
+ case 57: // Invoke Fast CC
+ case Instruction::Invoke: { // Invoke C CC
+ if (Oprnds.size() < 3)
+ error("Invalid invoke instruction!");
+ Value *F = getValue(iType, Oprnds[0]);
+
+ // Check to make sure we have a pointer to function type
+ const PointerType *PTy = dyn_cast<PointerType>(F->getType());
+ if (PTy == 0)
+ error("Invoke to non function pointer value!");
+ const FunctionType *FTy = dyn_cast<FunctionType>(PTy->getElementType());
+ if (FTy == 0)
+ error("Invoke to non function pointer value!");
+
+ std::vector<Value *> Params;
+ BasicBlock *Normal, *Except;
+ unsigned CallingConv = CallingConv::C;
+
+ if (Opcode == 57)
+ CallingConv = CallingConv::Fast;
+ else if (Opcode == 56) {
+ CallingConv = Oprnds.back();
+ Oprnds.pop_back();
+ }
+
+ if (!FTy->isVarArg()) {
+ Normal = getBasicBlock(Oprnds[1]);
+ Except = getBasicBlock(Oprnds[2]);
+
+ FunctionType::param_iterator It = FTy->param_begin();
+ for (unsigned i = 3, e = Oprnds.size(); i != e; ++i) {
+ if (It == FTy->param_end())
+ error("Invalid invoke instruction!");
+ Params.push_back(getValue(getTypeSlot(*It++), Oprnds[i]));
+ }
+ if (It != FTy->param_end())
+ error("Invalid invoke instruction!");
+ } else {
+ Oprnds.erase(Oprnds.begin(), Oprnds.begin()+1);
+
+ Normal = getBasicBlock(Oprnds[0]);
+ Except = getBasicBlock(Oprnds[1]);
+
+ unsigned FirstVariableArgument = FTy->getNumParams()+2;
+ for (unsigned i = 2; i != FirstVariableArgument; ++i)
+ Params.push_back(getValue(getTypeSlot(FTy->getParamType(i-2)),
+ Oprnds[i]));
+
+ if (Oprnds.size()-FirstVariableArgument & 1) // Must be type/value pairs
+ error("Invalid invoke instruction!");
+
+ for (unsigned i = FirstVariableArgument; i < Oprnds.size(); i += 2)
+ Params.push_back(getValue(Oprnds[i], Oprnds[i+1]));
+ }
+
+ Result = new InvokeInst(F, Normal, Except, Params);
+ if (CallingConv) cast<InvokeInst>(Result)->setCallingConv(CallingConv);
+ break;
+ }
+ case Instruction::Malloc:
+ if (Oprnds.size() > 2)
+ error("Invalid malloc instruction!");
+ if (!isa<PointerType>(InstTy))
+ error("Invalid malloc instruction!");
+
+ Result = new MallocInst(cast<PointerType>(InstTy)->getElementType(),
+ Oprnds.size() ? getValue(Type::UIntTyID,
+ Oprnds[0]) : 0);
+ break;
+
+ case Instruction::Alloca:
+ if (Oprnds.size() > 2)
+ error("Invalid alloca instruction!");
+ if (!isa<PointerType>(InstTy))
+ error("Invalid alloca instruction!");
+
+ Result = new AllocaInst(cast<PointerType>(InstTy)->getElementType(),
+ Oprnds.size() ? getValue(Type::UIntTyID,
+ Oprnds[0]) :0);
+ break;
+ case Instruction::Free:
+ if (!isa<PointerType>(InstTy))
+ error("Invalid free instruction!");
+ Result = new FreeInst(getValue(iType, Oprnds[0]));
+ break;
+ case Instruction::GetElementPtr: {
+ if (Oprnds.size() == 0 || !isa<PointerType>(InstTy))
+ error("Invalid getelementptr instruction!");
+
+ std::vector<Value*> Idx;
+
+ const Type *NextTy = InstTy;
+ for (unsigned i = 1, e = Oprnds.size(); i != e; ++i) {
+ const CompositeType *TopTy = dyn_cast_or_null<CompositeType>(NextTy);
+ if (!TopTy)
+ error("Invalid getelementptr instruction!");
+
+ unsigned ValIdx = Oprnds[i];
+ unsigned IdxTy = 0;
+ if (!hasRestrictedGEPTypes) {
+ // Struct indices are always uints, sequential type indices can be any
+ // of the 32 or 64-bit integer types. The actual choice of type is
+ // encoded in the low two bits of the slot number.
+ if (isa<StructType>(TopTy))
+ IdxTy = Type::UIntTyID;
+ else {
+ switch (ValIdx & 3) {
+ default:
+ case 0: IdxTy = Type::UIntTyID; break;
+ case 1: IdxTy = Type::IntTyID; break;
+ case 2: IdxTy = Type::ULongTyID; break;
+ case 3: IdxTy = Type::LongTyID; break;
+ }
+ ValIdx >>= 2;
+ }
+ } else {
+ IdxTy = isa<StructType>(TopTy) ? Type::UByteTyID : Type::LongTyID;
+ }
+
+ Idx.push_back(getValue(IdxTy, ValIdx));
+
+ // Convert ubyte struct indices into uint struct indices.
+ if (isa<StructType>(TopTy) && hasRestrictedGEPTypes)
+ if (ConstantUInt *C = dyn_cast<ConstantUInt>(Idx.back()))
+ Idx[Idx.size()-1] = ConstantExpr::getCast(C, Type::UIntTy);
+
+ NextTy = GetElementPtrInst::getIndexedType(InstTy, Idx, true);
+ }
+
+ Result = new GetElementPtrInst(getValue(iType, Oprnds[0]), Idx);
+ break;
+ }
+
+ case 62: // volatile load
+ case Instruction::Load:
+ if (Oprnds.size() != 1 || !isa<PointerType>(InstTy))
+ error("Invalid load instruction!");
+ Result = new LoadInst(getValue(iType, Oprnds[0]), "", Opcode == 62);
+ break;
+
+ case 63: // volatile store
+ case Instruction::Store: {
+ if (!isa<PointerType>(InstTy) || Oprnds.size() != 2)
+ error("Invalid store instruction!");
+
+ Value *Ptr = getValue(iType, Oprnds[1]);
+ const Type *ValTy = cast<PointerType>(Ptr->getType())->getElementType();
+ Result = new StoreInst(getValue(getTypeSlot(ValTy), Oprnds[0]), Ptr,
+ Opcode == 63);
+ break;
+ }
+ case Instruction::Unwind:
+ if (Oprnds.size() != 0) error("Invalid unwind instruction!");
+ Result = new UnwindInst();
+ break;
+ case Instruction::Unreachable:
+ if (Oprnds.size() != 0) error("Invalid unreachable instruction!");
+ Result = new UnreachableInst();
+ break;
+ } // end switch(Opcode)
+
+ unsigned TypeSlot;
+ if (Result->getType() == InstTy)
+ TypeSlot = iType;
+ else
+ TypeSlot = getTypeSlot(Result->getType());
+
+ insertValue(Result, TypeSlot, FunctionValues);
+ BB->getInstList().push_back(Result);
+}
+
+/// Get a particular numbered basic block, which might be a forward reference.
+/// This works together with ParseBasicBlock to handle these forward references
+/// in a clean manner. This function is used when constructing phi, br, switch,
+/// and other instructions that reference basic blocks. Blocks are numbered
+/// sequentially as they appear in the function.
+BasicBlock *BytecodeReader::getBasicBlock(unsigned ID) {
+ // Make sure there is room in the table...
+ if (ParsedBasicBlocks.size() <= ID) ParsedBasicBlocks.resize(ID+1);
+
+ // First check to see if this is a backwards reference, i.e., ParseBasicBlock
+ // has already created this block, or if the forward reference has already
+ // been created.
+ if (ParsedBasicBlocks[ID])
+ return ParsedBasicBlocks[ID];
+
+ // Otherwise, the basic block has not yet been created. Do so and add it to
+ // the ParsedBasicBlocks list.
+ return ParsedBasicBlocks[ID] = new BasicBlock();
+}
+
+/// In LLVM 1.0 bytecode files, we used to output one basicblock at a time.
+/// This method reads in one of the basicblock packets. This method is not used
+/// for bytecode files after LLVM 1.0
+/// @returns The basic block constructed.
+BasicBlock *BytecodeReader::ParseBasicBlock(unsigned BlockNo) {
+ if (Handler) Handler->handleBasicBlockBegin(BlockNo);
+
+ BasicBlock *BB = 0;
+
+ if (ParsedBasicBlocks.size() == BlockNo)
+ ParsedBasicBlocks.push_back(BB = new BasicBlock());
+ else if (ParsedBasicBlocks[BlockNo] == 0)
+ BB = ParsedBasicBlocks[BlockNo] = new BasicBlock();
+ else
+ BB = ParsedBasicBlocks[BlockNo];
+
+ std::vector<unsigned> Operands;
+ while (moreInBlock())
+ ParseInstruction(Operands, BB);
+
+ if (Handler) Handler->handleBasicBlockEnd(BlockNo);
+ return BB;
+}
+
+/// Parse all of the BasicBlock's & Instruction's in the body of a function.
+/// In post 1.0 bytecode files, we no longer emit basic block individually,
+/// in order to avoid per-basic-block overhead.
+/// @returns Rhe number of basic blocks encountered.
+unsigned BytecodeReader::ParseInstructionList(Function* F) {
+ unsigned BlockNo = 0;
+ std::vector<unsigned> Args;
+
+ while (moreInBlock()) {
+ if (Handler) Handler->handleBasicBlockBegin(BlockNo);
+ BasicBlock *BB;
+ if (ParsedBasicBlocks.size() == BlockNo)
+ ParsedBasicBlocks.push_back(BB = new BasicBlock());
+ else if (ParsedBasicBlocks[BlockNo] == 0)
+ BB = ParsedBasicBlocks[BlockNo] = new BasicBlock();
+ else
+ BB = ParsedBasicBlocks[BlockNo];
+ ++BlockNo;
+ F->getBasicBlockList().push_back(BB);
+
+ // Read instructions into this basic block until we get to a terminator
+ while (moreInBlock() && !BB->getTerminator())
+ ParseInstruction(Args, BB);
+
+ if (!BB->getTerminator())
+ error("Non-terminated basic block found!");
+
+ if (Handler) Handler->handleBasicBlockEnd(BlockNo-1);
+ }
+
+ return BlockNo;
+}
+
+/// Parse a symbol table. This works for both module level and function
+/// level symbol tables. For function level symbol tables, the CurrentFunction
+/// parameter must be non-zero and the ST parameter must correspond to
+/// CurrentFunction's symbol table. For Module level symbol tables, the
+/// CurrentFunction argument must be zero.
+void BytecodeReader::ParseSymbolTable(Function *CurrentFunction,
+ SymbolTable *ST) {
+ if (Handler) Handler->handleSymbolTableBegin(CurrentFunction,ST);
+
+ // Allow efficient basic block lookup by number.
+ std::vector<BasicBlock*> BBMap;
+ if (CurrentFunction)
+ for (Function::iterator I = CurrentFunction->begin(),
+ E = CurrentFunction->end(); I != E; ++I)
+ BBMap.push_back(I);
+
+ /// In LLVM 1.3 we write types separately from values so
+ /// The types are always first in the symbol table. This is
+ /// because Type no longer derives from Value.
+ if (!hasTypeDerivedFromValue) {
+ // Symtab block header: [num entries]
+ unsigned NumEntries = read_vbr_uint();
+ for (unsigned i = 0; i < NumEntries; ++i) {
+ // Symtab entry: [def slot #][name]
+ unsigned slot = read_vbr_uint();
+ std::string Name = read_str();
+ const Type* T = getType(slot);
+ ST->insert(Name, T);
+ }
+ }
+
+ while (moreInBlock()) {
+ // Symtab block header: [num entries][type id number]
+ unsigned NumEntries = read_vbr_uint();
+ unsigned Typ = 0;
+ bool isTypeType = read_typeid(Typ);
+ const Type *Ty = getType(Typ);
+
+ for (unsigned i = 0; i != NumEntries; ++i) {
+ // Symtab entry: [def slot #][name]
+ unsigned slot = read_vbr_uint();
+ std::string Name = read_str();
+
+ // if we're reading a pre 1.3 bytecode file and the type plane
+ // is the "type type", handle it here
+ if (isTypeType) {
+ const Type* T = getType(slot);
+ if (T == 0)
+ error("Failed type look-up for name '" + Name + "'");
+ ST->insert(Name, T);
+ continue; // code below must be short circuited
+ } else {
+ Value *V = 0;
+ if (Typ == Type::LabelTyID) {
+ if (slot < BBMap.size())
+ V = BBMap[slot];
+ } else {
+ V = getValue(Typ, slot, false); // Find mapping...
+ }
+ if (V == 0)
+ error("Failed value look-up for name '" + Name + "'");
+ V->setName(Name);
+ }
+ }
+ }
+ checkPastBlockEnd("Symbol Table");
+ if (Handler) Handler->handleSymbolTableEnd();
+}
+
+/// Read in the types portion of a compaction table.
+void BytecodeReader::ParseCompactionTypes(unsigned NumEntries) {
+ for (unsigned i = 0; i != NumEntries; ++i) {
+ unsigned TypeSlot = 0;
+ if (read_typeid(TypeSlot))
+ error("Invalid type in compaction table: type type");
+ const Type *Typ = getGlobalTableType(TypeSlot);
+ CompactionTypes.push_back(std::make_pair(Typ, TypeSlot));
+ if (Handler) Handler->handleCompactionTableType(i, TypeSlot, Typ);
+ }
+}
+
+/// Parse a compaction table.
+void BytecodeReader::ParseCompactionTable() {
+
+ // Notify handler that we're beginning a compaction table.
+ if (Handler) Handler->handleCompactionTableBegin();
+
+ // In LLVM 1.3 Type no longer derives from Value. So,
+ // we always write them first in the compaction table
+ // because they can't occupy a "type plane" where the
+ // Values reside.
+ if (! hasTypeDerivedFromValue) {
+ unsigned NumEntries = read_vbr_uint();
+ ParseCompactionTypes(NumEntries);
+ }
+
+ // Compaction tables live in separate blocks so we have to loop
+ // until we've read the whole thing.
+ while (moreInBlock()) {
+ // Read the number of Value* entries in the compaction table
+ unsigned NumEntries = read_vbr_uint();
+ unsigned Ty = 0;
+ unsigned isTypeType = false;
+
+ // Decode the type from value read in. Most compaction table
+ // planes will have one or two entries in them. If that's the
+ // case then the length is encoded in the bottom two bits and
+ // the higher bits encode the type. This saves another VBR value.
+ if ((NumEntries & 3) == 3) {
+ // In this case, both low-order bits are set (value 3). This
+ // is a signal that the typeid follows.
+ NumEntries >>= 2;
+ isTypeType = read_typeid(Ty);
+ } else {
+ // In this case, the low-order bits specify the number of entries
+ // and the high order bits specify the type.
+ Ty = NumEntries >> 2;
+ isTypeType = sanitizeTypeId(Ty);
+ NumEntries &= 3;
+ }
+
+ // if we're reading a pre 1.3 bytecode file and the type plane
+ // is the "type type", handle it here
+ if (isTypeType) {
+ ParseCompactionTypes(NumEntries);
+ } else {
+ // Make sure we have enough room for the plane.
+ if (Ty >= CompactionValues.size())
+ CompactionValues.resize(Ty+1);
+
+ // Make sure the plane is empty or we have some kind of error.
+ if (!CompactionValues[Ty].empty())
+ error("Compaction table plane contains multiple entries!");
+
+ // Notify handler about the plane.
+ if (Handler) Handler->handleCompactionTablePlane(Ty, NumEntries);
+
+ // Push the implicit zero.
+ CompactionValues[Ty].push_back(Constant::getNullValue(getType(Ty)));
+
+ // Read in each of the entries, put them in the compaction table
+ // and notify the handler that we have a new compaction table value.
+ for (unsigned i = 0; i != NumEntries; ++i) {
+ unsigned ValSlot = read_vbr_uint();
+ Value *V = getGlobalTableValue(Ty, ValSlot);
+ CompactionValues[Ty].push_back(V);
+ if (Handler) Handler->handleCompactionTableValue(i, Ty, ValSlot);
+ }
+ }
+ }
+ // Notify handler that the compaction table is done.
+ if (Handler) Handler->handleCompactionTableEnd();
+}
+
+// Parse a single type. The typeid is read in first. If its a primitive type
+// then nothing else needs to be read, we know how to instantiate it. If its
+// a derived type, then additional data is read to fill out the type
+// definition.
+const Type *BytecodeReader::ParseType() {
+ unsigned PrimType = 0;
+ if (read_typeid(PrimType))
+ error("Invalid type (type type) in type constants!");
+
+ const Type *Result = 0;
+ if ((Result = Type::getPrimitiveType((Type::TypeID)PrimType)))
+ return Result;
+
+ switch (PrimType) {
+ case Type::FunctionTyID: {
+ const Type *RetType = readSanitizedType();
+
+ unsigned NumParams = read_vbr_uint();
+
+ std::vector<const Type*> Params;
+ while (NumParams--)
+ Params.push_back(readSanitizedType());
+
+ bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
+ if (isVarArg) Params.pop_back();
+
+ Result = FunctionType::get(RetType, Params, isVarArg);
+ break;
+ }
+ case Type::ArrayTyID: {
+ const Type *ElementType = readSanitizedType();
+ unsigned NumElements = read_vbr_uint();
+ Result = ArrayType::get(ElementType, NumElements);
+ break;
+ }
+ case Type::PackedTyID: {
+ const Type *ElementType = readSanitizedType();
+ unsigned NumElements = read_vbr_uint();
+ Result = PackedType::get(ElementType, NumElements);
+ break;
+ }
+ case Type::StructTyID: {
+ std::vector<const Type*> Elements;
+ unsigned Typ = 0;
+ if (read_typeid(Typ))
+ error("Invalid element type (type type) for structure!");
+
+ while (Typ) { // List is terminated by void/0 typeid
+ Elements.push_back(getType(Typ));
+ if (read_typeid(Typ))
+ error("Invalid element type (type type) for structure!");
+ }
+
+ Result = StructType::get(Elements);
+ break;
+ }
+ case Type::PointerTyID: {
+ Result = PointerType::get(readSanitizedType());
+ break;
+ }
+
+ case Type::OpaqueTyID: {
+ Result = OpaqueType::get();
+ break;
+ }
+
+ default:
+ error("Don't know how to deserialize primitive type " + utostr(PrimType));
+ break;
+ }
+ if (Handler) Handler->handleType(Result);
+ return Result;
+}
+
+// ParseTypes - We have to use this weird code to handle recursive
+// types. We know that recursive types will only reference the current slab of
+// values in the type plane, but they can forward reference types before they
+// have been read. For example, Type #0 might be '{ Ty#1 }' and Type #1 might
+// be 'Ty#0*'. When reading Type #0, type number one doesn't exist. To fix
+// this ugly problem, we pessimistically insert an opaque type for each type we
+// are about to read. This means that forward references will resolve to
+// something and when we reread the type later, we can replace the opaque type
+// with a new resolved concrete type.
+//
+void BytecodeReader::ParseTypes(TypeListTy &Tab, unsigned NumEntries){
+ assert(Tab.size() == 0 && "should not have read type constants in before!");
+
+ // Insert a bunch of opaque types to be resolved later...
+ Tab.reserve(NumEntries);
+ for (unsigned i = 0; i != NumEntries; ++i)
+ Tab.push_back(OpaqueType::get());
+
+ if (Handler)
+ Handler->handleTypeList(NumEntries);
+
+ // If we are about to resolve types, make sure the type cache is clear.
+ if (NumEntries)
+ ModuleTypeIDCache.clear();
+
+ // Loop through reading all of the types. Forward types will make use of the
+ // opaque types just inserted.
+ //
+ for (unsigned i = 0; i != NumEntries; ++i) {
+ const Type* NewTy = ParseType();
+ const Type* OldTy = Tab[i].get();
+ if (NewTy == 0)
+ error("Couldn't parse type!");
+
+ // Don't directly push the new type on the Tab. Instead we want to replace
+ // the opaque type we previously inserted with the new concrete value. This
+ // approach helps with forward references to types. The refinement from the
+ // abstract (opaque) type to the new type causes all uses of the abstract
+ // type to use the concrete type (NewTy). This will also cause the opaque
+ // type to be deleted.
+ cast<DerivedType>(const_cast<Type*>(OldTy))->refineAbstractTypeTo(NewTy);
+
+ // This should have replaced the old opaque type with the new type in the
+ // value table... or with a preexisting type that was already in the system.
+ // Let's just make sure it did.
+ assert(Tab[i] != OldTy && "refineAbstractType didn't work!");
+ }
+}
+
+/// Parse a single constant value
+Constant *BytecodeReader::ParseConstantValue(unsigned TypeID) {
+ // We must check for a ConstantExpr before switching by type because
+ // a ConstantExpr can be of any type, and has no explicit value.
+ //
+ // 0 if not expr; numArgs if is expr
+ unsigned isExprNumArgs = read_vbr_uint();
+
+ if (isExprNumArgs) {
+ // 'undef' is encoded with 'exprnumargs' == 1.
+ if (!hasNoUndefValue)
+ if (--isExprNumArgs == 0)
+ return UndefValue::get(getType(TypeID));
+
+ // FIXME: Encoding of constant exprs could be much more compact!
+ std::vector<Constant*> ArgVec;
+ ArgVec.reserve(isExprNumArgs);
+ unsigned Opcode = read_vbr_uint();
+
+ // Bytecode files before LLVM 1.4 need have a missing terminator inst.
+ if (hasNoUnreachableInst) Opcode++;
+
+ // Read the slot number and types of each of the arguments
+ for (unsigned i = 0; i != isExprNumArgs; ++i) {
+ unsigned ArgValSlot = read_vbr_uint();
+ unsigned ArgTypeSlot = 0;
+ if (read_typeid(ArgTypeSlot))
+ error("Invalid argument type (type type) for constant value");
+
+ // Get the arg value from its slot if it exists, otherwise a placeholder
+ ArgVec.push_back(getConstantValue(ArgTypeSlot, ArgValSlot));
+ }
+
+ // Construct a ConstantExpr of the appropriate kind
+ if (isExprNumArgs == 1) { // All one-operand expressions
+ if (Opcode != Instruction::Cast)
+ error("Only cast instruction has one argument for ConstantExpr");
+
+ Constant* Result = ConstantExpr::getCast(ArgVec[0], getType(TypeID));
+ if (Handler) Handler->handleConstantExpression(Opcode, ArgVec, Result);
+ return Result;
+ } else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
+ std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
+
+ if (hasRestrictedGEPTypes) {
+ const Type *BaseTy = ArgVec[0]->getType();
+ generic_gep_type_iterator<std::vector<Constant*>::iterator>
+ GTI = gep_type_begin(BaseTy, IdxList.begin(), IdxList.end()),
+ E = gep_type_end(BaseTy, IdxList.begin(), IdxList.end());
+ for (unsigned i = 0; GTI != E; ++GTI, ++i)
+ if (isa<StructType>(*GTI)) {
+ if (IdxList[i]->getType() != Type::UByteTy)
+ error("Invalid index for getelementptr!");
+ IdxList[i] = ConstantExpr::getCast(IdxList[i], Type::UIntTy);
+ }
+ }
+
+ Constant* Result = ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
+ if (Handler) Handler->handleConstantExpression(Opcode, ArgVec, Result);
+ return Result;
+ } else if (Opcode == Instruction::Select) {
+ if (ArgVec.size() != 3)
+ error("Select instruction must have three arguments.");
+ Constant* Result = ConstantExpr::getSelect(ArgVec[0], ArgVec[1],
+ ArgVec[2]);
+ if (Handler) Handler->handleConstantExpression(Opcode, ArgVec, Result);
+ return Result;
+ } else { // All other 2-operand expressions
+ Constant* Result = ConstantExpr::get(Opcode, ArgVec[0], ArgVec[1]);
+ if (Handler) Handler->handleConstantExpression(Opcode, ArgVec, Result);
+ return Result;
+ }
+ }
+
+ // Ok, not an ConstantExpr. We now know how to read the given type...
+ const Type *Ty = getType(TypeID);
+ switch (Ty->getTypeID()) {
+ case Type::BoolTyID: {
+ unsigned Val = read_vbr_uint();
+ if (Val != 0 && Val != 1)
+ error("Invalid boolean value read.");
+ Constant* Result = ConstantBool::get(Val == 1);
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::UByteTyID: // Unsigned integer types...
+ case Type::UShortTyID:
+ case Type::UIntTyID: {
+ unsigned Val = read_vbr_uint();
+ if (!ConstantUInt::isValueValidForType(Ty, Val))
+ error("Invalid unsigned byte/short/int read.");
+ Constant* Result = ConstantUInt::get(Ty, Val);
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::ULongTyID: {
+ Constant* Result = ConstantUInt::get(Ty, read_vbr_uint64());
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::SByteTyID: // Signed integer types...
+ case Type::ShortTyID:
+ case Type::IntTyID: {
+ case Type::LongTyID:
+ int64_t Val = read_vbr_int64();
+ if (!ConstantSInt::isValueValidForType(Ty, Val))
+ error("Invalid signed byte/short/int/long read.");
+ Constant* Result = ConstantSInt::get(Ty, Val);
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::FloatTyID: {
+ float Val;
+ read_float(Val);
+ Constant* Result = ConstantFP::get(Ty, Val);
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::DoubleTyID: {
+ double Val;
+ read_double(Val);
+ Constant* Result = ConstantFP::get(Ty, Val);
+ if (Handler) Handler->handleConstantValue(Result);
+ return Result;
+ }
+
+ case Type::ArrayTyID: {
+ const ArrayType *AT = cast<ArrayType>(Ty);
+ unsigned NumElements = AT->getNumElements();
+ unsigned TypeSlot = getTypeSlot(AT->getElementType());
+ std::vector<Constant*> Elements;
+ Elements.reserve(NumElements);
+ while (NumElements--) // Read all of the elements of the constant.
+ Elements.push_back(getConstantValue(TypeSlot,
+ read_vbr_uint()));
+ Constant* Result = ConstantArray::get(AT, Elements);
+ if (Handler) Handler->handleConstantArray(AT, Elements, TypeSlot, Result);
+ return Result;
+ }
+
+ case Type::StructTyID: {
+ const StructType *ST = cast<StructType>(Ty);
+
+ std::vector<Constant *> Elements;
+ Elements.reserve(ST->getNumElements());
+ for (unsigned i = 0; i != ST->getNumElements(); ++i)
+ Elements.push_back(getConstantValue(ST->getElementType(i),
+ read_vbr_uint()));
+
+ Constant* Result = ConstantStruct::get(ST, Elements);
+ if (Handler) Handler->handleConstantStruct(ST, Elements, Result);
+ return Result;
+ }
+
+ case Type::PackedTyID: {
+ const PackedType *PT = cast<PackedType>(Ty);
+ unsigned NumElements = PT->getNumElements();
+ unsigned TypeSlot = getTypeSlot(PT->getElementType());
+ std::vector<Constant*> Elements;
+ Elements.reserve(NumElements);
+ while (NumElements--) // Read all of the elements of the constant.
+ Elements.push_back(getConstantValue(TypeSlot,
+ read_vbr_uint()));
+ Constant* Result = ConstantPacked::get(PT, Elements);
+ if (Handler) Handler->handleConstantPacked(PT, Elements, TypeSlot, Result);
+ return Result;
+ }
+
+ case Type::PointerTyID: { // ConstantPointerRef value (backwards compat).
+ const PointerType *PT = cast<PointerType>(Ty);
+ unsigned Slot = read_vbr_uint();
+
+ // Check to see if we have already read this global variable...
+ Value *Val = getValue(TypeID, Slot, false);
+ if (Val) {
+ GlobalValue *GV = dyn_cast<GlobalValue>(Val);
+ if (!GV) error("GlobalValue not in ValueTable!");
+ if (Handler) Handler->handleConstantPointer(PT, Slot, GV);
+ return GV;
+ } else {
+ error("Forward references are not allowed here.");
+ }
+ }
+
+ default:
+ error("Don't know how to deserialize constant value of type '" +
+ Ty->getDescription());
+ break;
+ }
+ return 0;
+}
+
+/// Resolve references for constants. This function resolves the forward
+/// referenced constants in the ConstantFwdRefs map. It uses the
+/// replaceAllUsesWith method of Value class to substitute the placeholder
+/// instance with the actual instance.
+void BytecodeReader::ResolveReferencesToConstant(Constant *NewV, unsigned Typ,
+ unsigned Slot) {
+ ConstantRefsType::iterator I =
+ ConstantFwdRefs.find(std::make_pair(Typ, Slot));
+ if (I == ConstantFwdRefs.end()) return; // Never forward referenced?
+
+ Value *PH = I->second; // Get the placeholder...
+ PH->replaceAllUsesWith(NewV);
+ delete PH; // Delete the old placeholder
+ ConstantFwdRefs.erase(I); // Remove the map entry for it
+}
+
+/// Parse the constant strings section.
+void BytecodeReader::ParseStringConstants(unsigned NumEntries, ValueTable &Tab){
+ for (; NumEntries; --NumEntries) {
+ unsigned Typ = 0;
+ if (read_typeid(Typ))
+ error("Invalid type (type type) for string constant");
+ const Type *Ty = getType(Typ);
+ if (!isa<ArrayType>(Ty))
+ error("String constant data invalid!");
+
+ const ArrayType *ATy = cast<ArrayType>(Ty);
+ if (ATy->getElementType() != Type::SByteTy &&
+ ATy->getElementType() != Type::UByteTy)
+ error("String constant data invalid!");
+
+ // Read character data. The type tells us how long the string is.
+ char *Data = reinterpret_cast<char *>(alloca(ATy->getNumElements()));
+ read_data(Data, Data+ATy->getNumElements());
+
+ std::vector<Constant*> Elements(ATy->getNumElements());
+ if (ATy->getElementType() == Type::SByteTy)
+ for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
+ Elements[i] = ConstantSInt::get(Type::SByteTy, (signed char)Data[i]);
+ else
+ for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i)
+ Elements[i] = ConstantUInt::get(Type::UByteTy, (unsigned char)Data[i]);
+
+ // Create the constant, inserting it as needed.
+ Constant *C = ConstantArray::get(ATy, Elements);
+ unsigned Slot = insertValue(C, Typ, Tab);
+ ResolveReferencesToConstant(C, Typ, Slot);
+ if (Handler) Handler->handleConstantString(cast<ConstantArray>(C));
+ }
+}
+
+/// Parse the constant pool.
+void BytecodeReader::ParseConstantPool(ValueTable &Tab,
+ TypeListTy &TypeTab,
+ bool isFunction) {
+ if (Handler) Handler->handleGlobalConstantsBegin();
+
+ /// In LLVM 1.3 Type does not derive from Value so the types
+ /// do not occupy a plane. Consequently, we read the types
+ /// first in the constant pool.
+ if (isFunction && !hasTypeDerivedFromValue) {
+ unsigned NumEntries = read_vbr_uint();
+ ParseTypes(TypeTab, NumEntries);
+ }
+
+ while (moreInBlock()) {
+ unsigned NumEntries = read_vbr_uint();
+ unsigned Typ = 0;
+ bool isTypeType = read_typeid(Typ);
+
+ /// In LLVM 1.2 and before, Types were written to the
+ /// bytecode file in the "Type Type" plane (#12).
+ /// In 1.3 plane 12 is now the label plane. Handle this here.
+ if (isTypeType) {
+ ParseTypes(TypeTab, NumEntries);
+ } else if (Typ == Type::VoidTyID) {
+ /// Use of Type::VoidTyID is a misnomer. It actually means
+ /// that the following plane is constant strings
+ assert(&Tab == &ModuleValues && "Cannot read strings in functions!");
+ ParseStringConstants(NumEntries, Tab);
+ } else {
+ for (unsigned i = 0; i < NumEntries; ++i) {
+ Constant *C = ParseConstantValue(Typ);
+ assert(C && "ParseConstantValue returned NULL!");
+ unsigned Slot = insertValue(C, Typ, Tab);
+
+ // If we are reading a function constant table, make sure that we adjust
+ // the slot number to be the real global constant number.
+ //
+ if (&Tab != &ModuleValues && Typ < ModuleValues.size() &&
+ ModuleValues[Typ])
+ Slot += ModuleValues[Typ]->size();
+ ResolveReferencesToConstant(C, Typ, Slot);
+ }
+ }
+ }
+
+ // After we have finished parsing the constant pool, we had better not have
+ // any dangling references left.
+ if (!ConstantFwdRefs.empty()) {
+ ConstantRefsType::const_iterator I = ConstantFwdRefs.begin();
+ Constant* missingConst = I->second;
+ error(utostr(ConstantFwdRefs.size()) +
+ " unresolved constant reference exist. First one is '" +
+ missingConst->getName() + "' of type '" +
+ missingConst->getType()->getDescription() + "'.");
+ }
+
+ checkPastBlockEnd("Constant Pool");
+ if (Handler) Handler->handleGlobalConstantsEnd();
+}
+
+/// Parse the contents of a function. Note that this function can be
+/// called lazily by materializeFunction
+/// @see materializeFunction
+void BytecodeReader::ParseFunctionBody(Function* F) {
+
+ unsigned FuncSize = BlockEnd - At;
+ GlobalValue::LinkageTypes Linkage = GlobalValue::ExternalLinkage;
+
+ unsigned LinkageType = read_vbr_uint();
+ switch (LinkageType) {
+ case 0: Linkage = GlobalValue::ExternalLinkage; break;
+ case 1: Linkage = GlobalValue::WeakLinkage; break;
+ case 2: Linkage = GlobalValue::AppendingLinkage; break;
+ case 3: Linkage = GlobalValue::InternalLinkage; break;
+ case 4: Linkage = GlobalValue::LinkOnceLinkage; break;
+ default:
+ error("Invalid linkage type for Function.");
+ Linkage = GlobalValue::InternalLinkage;
+ break;
+ }
+
+ F->setLinkage(Linkage);
+ if (Handler) Handler->handleFunctionBegin(F,FuncSize);
+
+ // Keep track of how many basic blocks we have read in...
+ unsigned BlockNum = 0;
+ bool InsertedArguments = false;
+
+ BufPtr MyEnd = BlockEnd;
+ while (At < MyEnd) {
+ unsigned Type, Size;
+ BufPtr OldAt = At;
+ read_block(Type, Size);
+
+ switch (Type) {
+ case BytecodeFormat::ConstantPoolBlockID:
+ if (!InsertedArguments) {
+ // Insert arguments into the value table before we parse the first basic
+ // block in the function, but after we potentially read in the
+ // compaction table.
+ insertArguments(F);
+ InsertedArguments = true;
+ }
+
+ ParseConstantPool(FunctionValues, FunctionTypes, true);
+ break;
+
+ case BytecodeFormat::CompactionTableBlockID:
+ ParseCompactionTable();
+ break;
+
+ case BytecodeFormat::BasicBlock: {
+ if (!InsertedArguments) {
+ // Insert arguments into the value table before we parse the first basic
+ // block in the function, but after we potentially read in the
+ // compaction table.
+ insertArguments(F);
+ InsertedArguments = true;
+ }
+
+ BasicBlock *BB = ParseBasicBlock(BlockNum++);
+ F->getBasicBlockList().push_back(BB);
+ break;
+ }
+
+ case BytecodeFormat::InstructionListBlockID: {
+ // Insert arguments into the value table before we parse the instruction
+ // list for the function, but after we potentially read in the compaction
+ // table.
+ if (!InsertedArguments) {
+ insertArguments(F);
+ InsertedArguments = true;
+ }
+
+ if (BlockNum)
+ error("Already parsed basic blocks!");
+ BlockNum = ParseInstructionList(F);
+ break;
+ }
+
+ case BytecodeFormat::SymbolTableBlockID:
+ ParseSymbolTable(F, &F->getSymbolTable());
+ break;
+
+ default:
+ At += Size;
+ if (OldAt > At)
+ error("Wrapped around reading bytecode.");
+ break;
+ }
+ BlockEnd = MyEnd;
+
+ // Malformed bc file if read past end of block.
+ align32();
+ }
+
+ // Make sure there were no references to non-existant basic blocks.
+ if (BlockNum != ParsedBasicBlocks.size())
+ error("Illegal basic block operand reference");
+
+ ParsedBasicBlocks.clear();
+
+ // Resolve forward references. Replace any uses of a forward reference value
+ // with the real value.
+ while (!ForwardReferences.empty()) {
+ std::map<std::pair<unsigned,unsigned>, Value*>::iterator
+ I = ForwardReferences.begin();
+ Value *V = getValue(I->first.first, I->first.second, false);
+ Value *PlaceHolder = I->second;
+ PlaceHolder->replaceAllUsesWith(V);
+ ForwardReferences.erase(I);
+ delete PlaceHolder;
+ }
+
+ // Clear out function-level types...
+ FunctionTypes.clear();
+ CompactionTypes.clear();
+ CompactionValues.clear();
+ freeTable(FunctionValues);
+
+ if (Handler) Handler->handleFunctionEnd(F);
+}
+
+/// This function parses LLVM functions lazily. It obtains the type of the
+/// function and records where the body of the function is in the bytecode
+/// buffer. The caller can then use the ParseNextFunction and
+/// ParseAllFunctionBodies to get handler events for the functions.
+void BytecodeReader::ParseFunctionLazily() {
+ if (FunctionSignatureList.empty())
+ error("FunctionSignatureList empty!");
+
+ Function *Func = FunctionSignatureList.back();
+ FunctionSignatureList.pop_back();
+
+ // Save the information for future reading of the function
+ LazyFunctionLoadMap[Func] = LazyFunctionInfo(BlockStart, BlockEnd);
+
+ // This function has a body but it's not loaded so it appears `External'.
+ // Mark it as a `Ghost' instead to notify the users that it has a body.
+ Func->setLinkage(GlobalValue::GhostLinkage);
+
+ // Pretend we've `parsed' this function
+ At = BlockEnd;
+}
+
+/// The ParserFunction method lazily parses one function. Use this method to
+/// casue the parser to parse a specific function in the module. Note that
+/// this will remove the function from what is to be included by
+/// ParseAllFunctionBodies.
+/// @see ParseAllFunctionBodies
+/// @see ParseBytecode
+void BytecodeReader::ParseFunction(Function* Func) {
+ // Find {start, end} pointers and slot in the map. If not there, we're done.
+ LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(Func);
+
+ // Make sure we found it
+ if (Fi == LazyFunctionLoadMap.end()) {
+ error("Unrecognized function of type " + Func->getType()->getDescription());
+ return;
+ }
+
+ BlockStart = At = Fi->second.Buf;
+ BlockEnd = Fi->second.EndBuf;
+ assert(Fi->first == Func && "Found wrong function?");
+
+ LazyFunctionLoadMap.erase(Fi);
+
+ this->ParseFunctionBody(Func);
+}
+
+/// The ParseAllFunctionBodies method parses through all the previously
+/// unparsed functions in the bytecode file. If you want to completely parse
+/// a bytecode file, this method should be called after Parsebytecode because
+/// Parsebytecode only records the locations in the bytecode file of where
+/// the function definitions are located. This function uses that information
+/// to materialize the functions.
+/// @see ParseBytecode
+void BytecodeReader::ParseAllFunctionBodies() {
+ LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.begin();
+ LazyFunctionMap::iterator Fe = LazyFunctionLoadMap.end();
+
+ while (Fi != Fe) {
+ Function* Func = Fi->first;
+ BlockStart = At = Fi->second.Buf;
+ BlockEnd = Fi->second.EndBuf;
+ ParseFunctionBody(Func);
+ ++Fi;
+ }
+ LazyFunctionLoadMap.clear();
+}
+
+/// Parse the global type list
+void BytecodeReader::ParseGlobalTypes() {
+ // Read the number of types
+ unsigned NumEntries = read_vbr_uint();
+
+ // Ignore the type plane identifier for types if the bc file is pre 1.3
+ if (hasTypeDerivedFromValue)
+ read_vbr_uint();
+
+ ParseTypes(ModuleTypes, NumEntries);
+}
+
+/// Parse the Global info (types, global vars, constants)
+void BytecodeReader::ParseModuleGlobalInfo() {
+
+ if (Handler) Handler->handleModuleGlobalsBegin();
+
+ // Read global variables...
+ unsigned VarType = read_vbr_uint();
+ while (VarType != Type::VoidTyID) { // List is terminated by Void
+ // VarType Fields: bit0 = isConstant, bit1 = hasInitializer, bit2,3,4 =
+ // Linkage, bit4+ = slot#
+ unsigned SlotNo = VarType >> 5;
+ if (sanitizeTypeId(SlotNo))
+ error("Invalid type (type type) for global var!");
+ unsigned LinkageID = (VarType >> 2) & 7;
+ bool isConstant = VarType & 1;
+ bool hasInitializer = VarType & 2;
+ GlobalValue::LinkageTypes Linkage;
+
+ switch (LinkageID) {
+ case 0: Linkage = GlobalValue::ExternalLinkage; break;
+ case 1: Linkage = GlobalValue::WeakLinkage; break;
+ case 2: Linkage = GlobalValue::AppendingLinkage; break;
+ case 3: Linkage = GlobalValue::InternalLinkage; break;
+ case 4: Linkage = GlobalValue::LinkOnceLinkage; break;
+ default:
+ error("Unknown linkage type: " + utostr(LinkageID));
+ Linkage = GlobalValue::InternalLinkage;
+ break;
+ }
+
+ const Type *Ty = getType(SlotNo);
+ if (!Ty) {
+ error("Global has no type! SlotNo=" + utostr(SlotNo));
+ }
+
+ if (!isa<PointerType>(Ty)) {
+ error("Global not a pointer type! Ty= " + Ty->getDescription());
+ }
+
+ const Type *ElTy = cast<PointerType>(Ty)->getElementType();
+
+ // Create the global variable...
+ GlobalVariable *GV = new GlobalVariable(ElTy, isConstant, Linkage,
+ 0, "", TheModule);
+ insertValue(GV, SlotNo, ModuleValues);
+
+ unsigned initSlot = 0;
+ if (hasInitializer) {
+ initSlot = read_vbr_uint();
+ GlobalInits.push_back(std::make_pair(GV, initSlot));
+ }
+
+ // Notify handler about the global value.
+ if (Handler)
+ Handler->handleGlobalVariable(ElTy, isConstant, Linkage, SlotNo,initSlot);
+
+ // Get next item
+ VarType = read_vbr_uint();
+ }
+
+ // Read the function objects for all of the functions that are coming
+ unsigned FnSignature = read_vbr_uint();
+
+ if (hasNoFlagsForFunctions)
+ FnSignature = (FnSignature << 5) + 1;
+
+ // List is terminated by VoidTy.
+ while ((FnSignature >> 5) != Type::VoidTyID) {
+ const Type *Ty = getType(FnSignature >> 5);
+ if (!isa<PointerType>(Ty) ||
+ !isa<FunctionType>(cast<PointerType>(Ty)->getElementType())) {
+ error("Function not a pointer to function type! Ty = " +
+ Ty->getDescription());
+ }
+
+ // We create functions by passing the underlying FunctionType to create...
+ const FunctionType* FTy =
+ cast<FunctionType>(cast<PointerType>(Ty)->getElementType());
+
+
+ // Insert the place holder.
+ Function* Func = new Function(FTy, GlobalValue::ExternalLinkage,
+ "", TheModule);
+ insertValue(Func, FnSignature >> 5, ModuleValues);
+
+ // Flags are not used yet.
+ unsigned Flags = FnSignature & 31;
+
+ // Save this for later so we know type of lazily instantiated functions.
+ // Note that known-external functions do not have FunctionInfo blocks, so we
+ // do not add them to the FunctionSignatureList.
+ if ((Flags & (1 << 4)) == 0)
+ FunctionSignatureList.push_back(Func);
+
+ // Look at the low bits. If there is a calling conv here, apply it,
+ // read it as a vbr.
+ Flags &= 15;
+ if (Flags)
+ Func->setCallingConv(Flags-1);
+ else
+ Func->setCallingConv(read_vbr_uint());
+
+ if (Handler) Handler->handleFunctionDeclaration(Func);
+
+ // Get the next function signature.
+ FnSignature = read_vbr_uint();
+ if (hasNoFlagsForFunctions)
+ FnSignature = (FnSignature << 5) + 1;
+ }
+
+ // Now that the function signature list is set up, reverse it so that we can
+ // remove elements efficiently from the back of the vector.
+ std::reverse(FunctionSignatureList.begin(), FunctionSignatureList.end());
+
+ // If this bytecode format has dependent library information in it ..
+ if (!hasNoDependentLibraries) {
+ // Read in the number of dependent library items that follow
+ unsigned num_dep_libs = read_vbr_uint();
+ std::string dep_lib;
+ while( num_dep_libs-- ) {
+ dep_lib = read_str();
+ TheModule->addLibrary(dep_lib);
+ if (Handler)
+ Handler->handleDependentLibrary(dep_lib);
+ }
+
+
+ // Read target triple and place into the module
+ std::string triple = read_str();
+ TheModule->setTargetTriple(triple);
+ if (Handler)
+ Handler->handleTargetTriple(triple);
+ }
+
+ if (hasInconsistentModuleGlobalInfo)
+ align32();
+
+ // This is for future proofing... in the future extra fields may be added that
+ // we don't understand, so we transparently ignore them.
+ //
+ At = BlockEnd;
+
+ if (Handler) Handler->handleModuleGlobalsEnd();
+}
+
+/// Parse the version information and decode it by setting flags on the
+/// Reader that enable backward compatibility of the reader.
+void BytecodeReader::ParseVersionInfo() {
+ unsigned Version = read_vbr_uint();
+
+ // Unpack version number: low four bits are for flags, top bits = version
+ Module::Endianness Endianness;
+ Module::PointerSize PointerSize;
+ Endianness = (Version & 1) ? Module::BigEndian : Module::LittleEndian;
+ PointerSize = (Version & 2) ? Module::Pointer64 : Module::Pointer32;
+
+ bool hasNoEndianness = Version & 4;
+ bool hasNoPointerSize = Version & 8;
+
+ RevisionNum = Version >> 4;
+
+ // Default values for the current bytecode version
+ hasInconsistentModuleGlobalInfo = false;
+ hasExplicitPrimitiveZeros = false;
+ hasRestrictedGEPTypes = false;
+ hasTypeDerivedFromValue = false;
+ hasLongBlockHeaders = false;
+ has32BitTypes = false;
+ hasNoDependentLibraries = false;
+ hasAlignment = false;
+ hasNoUndefValue = false;
+ hasNoFlagsForFunctions = false;
+ hasNoUnreachableInst = false;
+
+ switch (RevisionNum) {
+ case 0: // LLVM 1.0, 1.1 (Released)
+ // Base LLVM 1.0 bytecode format.
+ hasInconsistentModuleGlobalInfo = true;
+ hasExplicitPrimitiveZeros = true;
+
+ // FALL THROUGH
+
+ case 1: // LLVM 1.2 (Released)
+ // LLVM 1.2 added explicit support for emitting strings efficiently.
+
+ // Also, it fixed the problem where the size of the ModuleGlobalInfo block
+ // included the size for the alignment at the end, where the rest of the
+ // blocks did not.
+
+ // LLVM 1.2 and before required that GEP indices be ubyte constants for
+ // structures and longs for sequential types.
+ hasRestrictedGEPTypes = true;
+
+ // LLVM 1.2 and before had the Type class derive from Value class. This
+ // changed in release 1.3 and consequently LLVM 1.3 bytecode files are
+ // written differently because Types can no longer be part of the
+ // type planes for Values.
+ hasTypeDerivedFromValue = true;
+
+ // FALL THROUGH
+
+ case 2: // 1.2.5 (Not Released)
+
+ // LLVM 1.2 and earlier had two-word block headers. This is a bit wasteful,
+ // especially for small files where the 8 bytes per block is a large
+ // fraction of the total block size. In LLVM 1.3, the block type and length
+ // are compressed into a single 32-bit unsigned integer. 27 bits for length,
+ // 5 bits for block type.
+ hasLongBlockHeaders = true;
+
+ // LLVM 1.2 and earlier wrote type slot numbers as vbr_uint32. In LLVM 1.3
+ // this has been reduced to vbr_uint24. It shouldn't make much difference
+ // since we haven't run into a module with > 24 million types, but for
+ // safety the 24-bit restriction has been enforced in 1.3 to free some bits
+ // in various places and to ensure consistency.
+ has32BitTypes = true;
+
+ // LLVM 1.2 and earlier did not provide a target triple nor a list of
+ // libraries on which the bytecode is dependent. LLVM 1.3 provides these
+ // features, for use in future versions of LLVM.
+ hasNoDependentLibraries = true;
+
+ // FALL THROUGH
+
+ case 3: // LLVM 1.3 (Released)
+ // LLVM 1.3 and earlier caused alignment bytes to be written on some block
+ // boundaries and at the end of some strings. In extreme cases (e.g. lots
+ // of GEP references to a constant array), this can increase the file size
+ // by 30% or more. In version 1.4 alignment is done away with completely.
+ hasAlignment = true;
+
+ // FALL THROUGH
+
+ case 4: // 1.3.1 (Not Released)
+ // In version 4, we did not support the 'undef' constant.
+ hasNoUndefValue = true;
+
+ // In version 4 and above, we did not include space for flags for functions
+ // in the module info block.
+ hasNoFlagsForFunctions = true;
+
+ // In version 4 and above, we did not include the 'unreachable' instruction
+ // in the opcode numbering in the bytecode file.
+ hasNoUnreachableInst = true;
+ break;
+
+ // FALL THROUGH
+
+ case 5: // 1.4 (Released)
+ break;
+
+ default:
+ error("Unknown bytecode version number: " + itostr(RevisionNum));
+ }
+
+ if (hasNoEndianness) Endianness = Module::AnyEndianness;
+ if (hasNoPointerSize) PointerSize = Module::AnyPointerSize;
+
+ TheModule->setEndianness(Endianness);
+ TheModule->setPointerSize(PointerSize);
+
+ if (Handler) Handler->handleVersionInfo(RevisionNum, Endianness, PointerSize);
+}
+
+/// Parse a whole module.
+void BytecodeReader::ParseModule() {
+ unsigned Type, Size;
+
+ FunctionSignatureList.clear(); // Just in case...
+
+ // Read into instance variables...
+ ParseVersionInfo();
+ align32();
+
+ bool SeenModuleGlobalInfo = false;
+ bool SeenGlobalTypePlane = false;
+ BufPtr MyEnd = BlockEnd;
+ while (At < MyEnd) {
+ BufPtr OldAt = At;
+ read_block(Type, Size);
+
+ switch (Type) {
+
+ case BytecodeFormat::GlobalTypePlaneBlockID:
+ if (SeenGlobalTypePlane)
+ error("Two GlobalTypePlane Blocks Encountered!");
+
+ if (Size > 0)
+ ParseGlobalTypes();
+ SeenGlobalTypePlane = true;
+ break;
+
+ case BytecodeFormat::ModuleGlobalInfoBlockID:
+ if (SeenModuleGlobalInfo)
+ error("Two ModuleGlobalInfo Blocks Encountered!");
+ ParseModuleGlobalInfo();
+ SeenModuleGlobalInfo = true;
+ break;
+
+ case BytecodeFormat::ConstantPoolBlockID:
+ ParseConstantPool(ModuleValues, ModuleTypes,false);
+ break;
+
+ case BytecodeFormat::FunctionBlockID:
+ ParseFunctionLazily();
+ break;
+
+ case BytecodeFormat::SymbolTableBlockID:
+ ParseSymbolTable(0, &TheModule->getSymbolTable());
+ break;
+
+ default:
+ At += Size;
+ if (OldAt > At) {
+ error("Unexpected Block of Type #" + utostr(Type) + " encountered!");
+ }
+ break;
+ }
+ BlockEnd = MyEnd;
+ align32();
+ }
+
+ // After the module constant pool has been read, we can safely initialize
+ // global variables...
+ while (!GlobalInits.empty()) {
+ GlobalVariable *GV = GlobalInits.back().first;
+ unsigned Slot = GlobalInits.back().second;
+ GlobalInits.pop_back();
+
+ // Look up the initializer value...
+ // FIXME: Preserve this type ID!
+
+ const llvm::PointerType* GVType = GV->getType();
+ unsigned TypeSlot = getTypeSlot(GVType->getElementType());
+ if (Constant *CV = getConstantValue(TypeSlot, Slot)) {
+ if (GV->hasInitializer())
+ error("Global *already* has an initializer?!");
+ if (Handler) Handler->handleGlobalInitializer(GV,CV);
+ GV->setInitializer(CV);
+ } else
+ error("Cannot find initializer value.");
+ }
+
+ if (!ConstantFwdRefs.empty())
+ error("Use of undefined constants in a module");
+
+ /// Make sure we pulled them all out. If we didn't then there's a declaration
+ /// but a missing body. That's not allowed.
+ if (!FunctionSignatureList.empty())
+ error("Function declared, but bytecode stream ended before definition");
+}
+
+/// This function completely parses a bytecode buffer given by the \p Buf
+/// and \p Length parameters.
+void BytecodeReader::ParseBytecode(BufPtr Buf, unsigned Length,
+ const std::string &ModuleID) {
+
+ try {
+ RevisionNum = 0;
+ At = MemStart = BlockStart = Buf;
+ MemEnd = BlockEnd = Buf + Length;
+
+ // Create the module
+ TheModule = new Module(ModuleID);
+
+ if (Handler) Handler->handleStart(TheModule, Length);
+
+ // Read the four bytes of the signature.
+ unsigned Sig = read_uint();
+
+ // If this is a compressed file
+ if (Sig == ('l' | ('l' << 8) | ('v' << 16) | ('c' << 24))) {
+
+ // Invoke the decompression of the bytecode. Note that we have to skip the
+ // file's magic number which is not part of the compressed block. Hence,
+ // the Buf+4 and Length-4. The result goes into decompressedBlock, a data
+ // member for retention until BytecodeReader is destructed.
+ unsigned decompressedLength = Compressor::decompressToNewBuffer(
+ (char*)Buf+4,Length-4,decompressedBlock);
+
+ // We must adjust the buffer pointers used by the bytecode reader to point
+ // into the new decompressed block. After decompression, the
+ // decompressedBlock will point to a contiguous memory area that has
+ // the decompressed data.
+ At = MemStart = BlockStart = Buf = (BufPtr) decompressedBlock;
+ MemEnd = BlockEnd = Buf + decompressedLength;
+
+ // else if this isn't a regular (uncompressed) bytecode file, then its
+ // and error, generate that now.
+ } else if (Sig != ('l' | ('l' << 8) | ('v' << 16) | ('m' << 24))) {
+ error("Invalid bytecode signature: " + utohexstr(Sig));
+ }
+
+ // Tell the handler we're starting a module
+ if (Handler) Handler->handleModuleBegin(ModuleID);
+
+ // Get the module block and size and verify. This is handled specially
+ // because the module block/size is always written in long format. Other
+ // blocks are written in short format so the read_block method is used.
+ unsigned Type, Size;
+ Type = read_uint();
+ Size = read_uint();
+ if (Type != BytecodeFormat::ModuleBlockID) {
+ error("Expected Module Block! Type:" + utostr(Type) + ", Size:"
+ + utostr(Size));
+ }
+
+ // It looks like the darwin ranlib program is broken, and adds trailing
+ // garbage to the end of some bytecode files. This hack allows the bc
+ // reader to ignore trailing garbage on bytecode files.
+ if (At + Size < MemEnd)
+ MemEnd = BlockEnd = At+Size;
+
+ if (At + Size != MemEnd)
+ error("Invalid Top Level Block Length! Type:" + utostr(Type)
+ + ", Size:" + utostr(Size));
+
+ // Parse the module contents
+ this->ParseModule();
+
+ // Check for missing functions
+ if (hasFunctions())
+ error("Function expected, but bytecode stream ended!");
+
+ // Tell the handler we're done with the module
+ if (Handler)
+ Handler->handleModuleEnd(ModuleID);
+
+ // Tell the handler we're finished the parse
+ if (Handler) Handler->handleFinish();
+
+ } catch (std::string& errstr) {
+ if (Handler) Handler->handleError(errstr);
+ freeState();
+ delete TheModule;
+ TheModule = 0;
+ if (decompressedBlock != 0 ) {
+ ::free(decompressedBlock);
+ decompressedBlock = 0;
+ }
+ throw;
+ } catch (...) {
+ std::string msg("Unknown Exception Occurred");
+ if (Handler) Handler->handleError(msg);
+ freeState();
+ delete TheModule;
+ TheModule = 0;
+ if (decompressedBlock != 0) {
+ ::free(decompressedBlock);
+ decompressedBlock = 0;
+ }
+ throw msg;
+ }
+}
+
+//===----------------------------------------------------------------------===//
+//=== Default Implementations of Handler Methods
+//===----------------------------------------------------------------------===//
+
+BytecodeHandler::~BytecodeHandler() {}
+
diff --git a/lib/Bytecode/Reader/Reader.h b/lib/Bytecode/Reader/Reader.h
new file mode 100644
index 0000000000..df0ddca747
--- /dev/null
+++ b/lib/Bytecode/Reader/Reader.h
@@ -0,0 +1,535 @@
+//===-- Reader.h - Interface To Bytecode Reading ----------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under the
+// University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header file defines the interface to the Bytecode Reader which is
+// responsible for correctly interpreting bytecode files (backwards compatible)
+// and materializing a module from the bytecode read.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BYTECODE_PARSER_H
+#define BYTECODE_PARSER_H
+
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/GlobalValue.h"
+#include "llvm/Function.h"
+#include "llvm/ModuleProvider.h"
+#include "llvm/Bytecode/Analyzer.h"
+#include <utility>
+#include <map>
+
+namespace llvm {
+
+class BytecodeHandler; ///< Forward declare the handler interface
+
+/// This class defines the interface for parsing a buffer of bytecode. The
+/// parser itself takes no action except to call the various functions of
+/// the handler interface. The parser's sole responsibility is the correct
+/// interpretation of the bytecode buffer. The handler is responsible for
+/// instantiating and keeping track of all values. As a convenience, the parser
+/// is responsible for materializing types and will pass them through the
+/// handler interface as necessary.
+/// @see BytecodeHandler
+/// @brief Bytecode Reader interface
+class BytecodeReader : public ModuleProvider {
+
+/// @name Constructors
+/// @{
+public:
+ /// @brief Default constructor. By default, no handler is used.
+ BytecodeReader(BytecodeHandler* h = 0) {
+ decompressedBlock = 0;
+ Handler = h;
+ }
+
+ ~BytecodeReader() {
+ freeState();
+ if (decompressedBlock) {
+ ::free(decompressedBlock);
+ decompressedBlock = 0;
+ }
+ }
+
+/// @}
+/// @name Types
+/// @{
+public:
+
+ /// @brief A convenience type for the buffer pointer
+ typedef const unsigned char* BufPtr;
+
+ /// @brief The type used for a vector of potentially abstract types
+ typedef std::vector<PATypeHolder> TypeListTy;
+
+ /// This type provides a vector of Value* via the User class for
+ /// storage of Values that have been constructed when reading the
+ /// bytecode. Because of forward referencing, constant replacement
+ /// can occur so we ensure that our list of Value* is updated
+ /// properly through those transitions. This ensures that the
+ /// correct Value* is in our list when it comes time to associate
+ /// constants with global variables at the end of reading the
+ /// globals section.
+ /// @brief A list of values as a User of those Values.
+ class ValueList : public User {
+ std::vector<Use> Uses;
+ public:
+ ValueList() : User(Type::VoidTy, Value::ArgumentVal, 0, 0) {}
+
+ // vector compatibility methods
+ unsigned size() const { return getNumOperands(); }
+ void push_back(Value *V) {
+ Uses.push_back(Use(V, this));
+ OperandList = &Uses[0];
+ ++NumOperands;
+ }
+ Value *back() const { return Uses.back(); }
+ void pop_back() { Uses.pop_back(); --NumOperands; }
+ bool empty() const { return NumOperands == 0; }
+ virtual void print(std::ostream& os) const {
+ for (unsigned i = 0; i < size(); ++i) {
+ os << i << " ";
+ getOperand(i)->print(os);
+ os << "\n";
+ }
+ }
+ };
+
+ /// @brief A 2 dimensional table of values
+ typedef std::vector<ValueList*> ValueTable;
+
+ /// This map is needed so that forward references to constants can be looked
+ /// up by Type and slot number when resolving those references.
+ /// @brief A mapping of a Type/slot pair to a Constant*.
+ typedef std::map<std::pair<unsigned,unsigned>, Constant*> ConstantRefsType;
+
+ /// For lazy read-in of functions, we need to save the location in the
+ /// data stream where the function is located. This structure provides that
+ /// information. Lazy read-in is used mostly by the JIT which only wants to
+ /// resolve functions as it needs them.
+ /// @brief Keeps pointers to function contents for later use.
+ struct LazyFunctionInfo {
+ const unsigned char *Buf, *EndBuf;
+ LazyFunctionInfo(const unsigned char *B = 0, const unsigned char *EB = 0)
+ : Buf(B), EndBuf(EB) {}
+ };
+
+ /// @brief A mapping of functions to their LazyFunctionInfo for lazy reading.
+ typedef std::map<Function*, LazyFunctionInfo> LazyFunctionMap;
+
+ /// @brief A list of global variables and the slot number that initializes
+ /// them.
+ typedef std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitsList;
+
+ /// This type maps a typeslot/valueslot pair to the corresponding Value*.
+ /// It is used for dealing with forward references as values are read in.
+ /// @brief A map for dealing with forward references of values.
+ typedef std::map<std::pair<unsigned,unsigned>,Value*> ForwardReferenceMap;
+
+/// @}
+/// @name Methods
+/// @{
+public:
+ /// @brief Main interface to parsing a bytecode buffer.
+ void ParseBytecode(
+ const unsigned char *Buf, ///< Beginning of the bytecode buffer
+ unsigned Length, ///< Length of the bytecode buffer
+ const std::string &ModuleID ///< An identifier for the module constructed.
+ );
+
+ /// @brief Parse all function bodies
+ void ParseAllFunctionBodies();
+
+ /// @brief Parse the next function of specific type
+ void ParseFunction(Function* Func) ;
+
+ /// This method is abstract in the parent ModuleProvider class. Its
+ /// implementation is identical to the ParseFunction method.
+ /// @see ParseFunction
+ /// @brief Make a specific function materialize.
+ virtual void materializeFunction(Function *F) {
+ LazyFunctionMap::iterator Fi = LazyFunctionLoadMap.find(F);
+ if (Fi == LazyFunctionLoadMap.end()) return;
+ ParseFunction(F);
+ }
+
+ /// This method is abstract in the parent ModuleProvider class. Its
+ /// implementation is identical to ParseAllFunctionBodies.
+ /// @see ParseAllFunctionBodies
+ /// @brief Make the whole module materialize
+ virtual Module* materializeModule() {
+ ParseAllFunctionBodies();
+ return TheModule;
+ }
+
+ /// This method is provided by the parent ModuleProvde class and overriden
+ /// here. It simply releases the module from its provided and frees up our
+ /// state.
+ /// @brief Release our hold on the generated module
+ Module* releaseModule() {
+ // Since we're losing control of this Module, we must hand it back complete
+ Module *M = ModuleProvider::releaseModule();
+ freeState();
+ return M;
+ }
+
+/// @}
+/// @name Parsing Units For Subclasses
+/// @{
+protected:
+ /// @brief Parse whole module scope
+ void ParseModule();
+
+ /// @brief Parse the version information block
+ void ParseVersionInfo();
+
+ /// @brief Parse the ModuleGlobalInfo block
+ void ParseModuleGlobalInfo();
+
+ /// @brief Parse a symbol table
+ void ParseSymbolTable( Function* Func, SymbolTable *ST);
+
+ /// @brief Parse functions lazily.
+ void ParseFunctionLazily();
+
+ /// @brief Parse a function body
+ void ParseFunctionBody(Function* Func);
+
+ /// @brief Parse the type list portion of a compaction table
+ void ParseCompactionTypes(unsigned NumEntries);
+
+ /// @brief Parse a compaction table
+ void ParseCompactionTable();
+
+ /// @brief Parse global types
+ void ParseGlobalTypes();
+
+ /// @brief Parse a basic block (for LLVM 1.0 basic block blocks)
+ BasicBlock* ParseBasicBlock(unsigned BlockNo);
+
+ /// @brief parse an instruction list (for post LLVM 1.0 instruction lists
+ /// with blocks differentiated by terminating instructions.
+ unsigned ParseInstructionList(
+ Function* F ///< The function into which BBs will be inserted
+ );
+
+ /// @brief Parse a single instruction.
+ void ParseInstruction(
+ std::vector<unsigned>& Args, ///< The arguments to be filled in
+ BasicBlock* BB ///< The BB the instruction goes in
+ );
+
+ /// @brief Parse the whole constant pool
+ void ParseConstantPool(ValueTable& Values, TypeListTy& Types,
+ bool isFunction);
+
+ /// @brief Parse a single constant value
+ Constant* ParseConstantValue(unsigned TypeID);
+
+ /// @brief Parse a block of types constants
+ void ParseTypes(TypeListTy &Tab, unsigned NumEntries);
+
+ /// @brief Parse a single type constant
+ const Type *ParseType();
+
+ /// @brief Parse a string constants block
+ void ParseStringConstants(unsigned NumEntries, ValueTable &Tab);
+
+/// @}
+/// @name Data
+/// @{
+private:
+ char* decompressedBlock; ///< Result of decompression
+ BufPtr MemStart; ///< Start of the memory buffer
+ BufPtr MemEnd; ///< End of the memory buffer
+ BufPtr BlockStart; ///< Start of current block being parsed
+ BufPtr BlockEnd; ///< End of current block being parsed
+ BufPtr At; ///< Where we're currently parsing at
+
+ /// Information about the module, extracted from the bytecode revision number.
+ ///
+ unsigned char RevisionNum; // The rev # itself
+
+ /// Flags to distinguish LLVM 1.0 & 1.1 bytecode formats (revision #0)
+
+ /// Revision #0 had an explicit alignment of data only for the
+ /// ModuleGlobalInfo block. This was fixed to be like all other blocks in 1.2
+ bool hasInconsistentModuleGlobalInfo;
+
+ /// Revision #0 also explicitly encoded zero values for primitive types like
+ /// int/sbyte/etc.
+ bool hasExplicitPrimitiveZeros;
+
+ // Flags to control features specific the LLVM 1.2 and before (revision #1)
+
+ /// LLVM 1.2 and earlier required that getelementptr structure indices were
+ /// ubyte constants and that sequential type indices were longs.
+ bool hasRestrictedGEPTypes;
+
+ /// LLVM 1.2 and earlier had class Type deriving from Value and the Type
+ /// objects were located in the "Type Type" plane of various lists in read
+ /// by the bytecode reader. In LLVM 1.3 this is no longer the case. Types are
+ /// completely distinct from Values. Consequently, Types are written in fixed
+ /// locations in LLVM 1.3. This flag indicates that the older Type derived
+ /// from Value style of bytecode file is being read.
+ bool hasTypeDerivedFromValue;
+
+ /// LLVM 1.2 and earlier encoded block headers as two uint (8 bytes), one for
+ /// the size and one for the type. This is a bit wasteful, especially for
+ /// small files where the 8 bytes per block is a large fraction of the total
+ /// block size. In LLVM 1.3, the block type and length are encoded into a
+ /// single uint32 by restricting the number of block types (limit 31) and the
+ /// maximum size of a block (limit 2^27-1=134,217,727). Note that the module
+ /// block still uses the 8-byte format so the maximum size of a file can be
+ /// 2^32-1 bytes long.
+ bool hasLongBlockHeaders;
+
+ /// LLVM 1.2 and earlier wrote type slot numbers as vbr_uint32. In LLVM 1.3
+ /// this has been reduced to vbr_uint24. It shouldn't make much difference
+ /// since we haven't run into a module with > 24 million types, but for safety
+ /// the 24-bit restriction has been enforced in 1.3 to free some bits in
+ /// various places and to ensure consistency. In particular, global vars are
+ /// restricted to 24-bits.
+ bool has32BitTypes;
+
+ /// LLVM 1.2 and earlier did not provide a target triple nor a list of
+ /// libraries on which the bytecode is dependent. LLVM 1.3 provides these
+ /// features, for use in future versions of LLVM.
+ bool hasNoDependentLibraries;
+
+ /// LLVM 1.3 and earlier caused blocks and other fields to start on 32-bit
+ /// aligned boundaries. This can lead to as much as 30% bytecode size overhead
+ /// in various corner cases (lots of long instructions). In LLVM 1.4,
+ /// alignment of bytecode fields was done away with completely.
+ bool hasAlignment;
+
+ // In version 4 and earlier, the bytecode format did not support the 'undef'
+ // constant.
+ bool hasNoUndefValue;
+
+ // In version 4 and earlier, the bytecode format did not save space for flags
+ // in the global info block for functions.
+ bool hasNoFlagsForFunctions;
+
+ // In version 4 and earlier, there was no opcode space reserved for the
+ // unreachable instruction.
+ bool hasNoUnreachableInst;
+
+ /// CompactionTypes - If a compaction table is active in the current function,
+ /// this is the mapping that it contains. We keep track of what resolved type
+ /// it is as well as what global type entry it is.
+ std::vector<std::pair<const Type*, unsigned> > CompactionTypes;
+
+ /// @brief If a compaction table is active in the current function,
+ /// this is the mapping that it contains.
+ std::vector<std::vector<Value*> > CompactionValues;
+
+ /// @brief This vector is used to deal with forward references to types in
+ /// a module.
+ TypeListTy ModuleTypes;
+
+ /// @brief This is an inverse mapping of ModuleTypes from the type to an
+ /// index. Because refining types causes the index of this map to be
+ /// invalidated, any time we refine a type, we clear this cache and recompute
+ /// it next time we need it. These entries are ordered by the pointer value.
+ std::vector<std::pair<const Type*, unsigned> > ModuleTypeIDCache;
+
+ /// @brief This vector is used to deal with forward references to types in
+ /// a function.
+ TypeListTy FunctionTypes;
+
+ /// When the ModuleGlobalInfo section is read, we create a Function object
+ /// for each function in the module. When the function is loaded, after the
+ /// module global info is read, this Function is populated. Until then, the
+ /// functions in this vector just hold the function signature.
+ std::vector<Function*> FunctionSignatureList;
+
+ /// @brief This is the table of values belonging to the current function
+ ValueTable FunctionValues;
+
+ /// @brief This is the table of values belonging to the module (global)
+ ValueTable ModuleValues;
+
+ /// @brief This keeps track of function level forward references.
+ ForwardReferenceMap ForwardReferences;
+
+ /// @brief The basic blocks we've parsed, while parsing a function.
+ std::vector<BasicBlock*> ParsedBasicBlocks;
+
+ /// This maintains a mapping between <Type, Slot #>'s and forward references
+ /// to constants. Such values may be referenced before they are defined, and
+ /// if so, the temporary object that they represent is held here. @brief
+ /// Temporary place for forward references to constants.
+ ConstantRefsType ConstantFwdRefs;
+
+ /// Constant values are read in after global variables. Because of this, we
+ /// must defer setting the initializers on global variables until after module
+ /// level constants have been read. In the mean time, this list keeps track
+ /// of what we must do.
+ GlobalInitsList GlobalInits;
+
+ // For lazy reading-in of functions, we need to save away several pieces of
+ // information about each function: its begin and end pointer in the buffer
+ // and its FunctionSlot.
+ LazyFunctionMap LazyFunctionLoadMap;
+
+ /// This stores the parser's handler which is used for handling tasks other
+ /// just than reading bytecode into the IR. If this is non-null, calls on
+ /// the (polymorphic) BytecodeHandler interface (see llvm/Bytecode/Handler.h)
+ /// will be made to report the logical structure of the bytecode file. What
+ /// the handler does with the events it receives is completely orthogonal to
+ /// the business of parsing the bytecode and building the IR. This is used,
+ /// for example, by the llvm-abcd tool for analysis of byte code.
+ /// @brief Handler for parsing events.
+ BytecodeHandler* Handler;
+
+/// @}
+/// @name Implementation Details
+/// @{
+private:
+ /// @brief Determines if this module has a function or not.
+ bool hasFunctions() { return ! FunctionSignatureList.empty(); }
+
+ /// @brief Determines if the type id has an implicit null value.
+ bool hasImplicitNull(unsigned TyID );
+
+ /// @brief Converts a type slot number to its Type*
+ const Type *getType(unsigned ID);
+
+ /// @brief Converts a pre-sanitized type slot number to its Type* and
+ /// sanitizes the type id.
+ inline const Type* getSanitizedType(unsigned& ID );
+
+ /// @brief Read in and get a sanitized type id
+ inline const Type* readSanitizedType();
+
+ /// @brief Converts a Type* to its type slot number
+ unsigned getTypeSlot(const Type *Ty);
+
+ /// @brief Converts a normal type slot number to a compacted type slot num.
+ unsigned getCompactionTypeSlot(unsigned type);
+
+ /// @brief Gets the global type corresponding to the TypeId
+ const Type *getGlobalTableType(unsigned TypeId);
+
+ /// This is just like getTypeSlot, but when a compaction table is in use,
+ /// it is ignored.
+ unsigned getGlobalTableTypeSlot(const Type *Ty);
+
+ /// @brief Get a value from its typeid and slot number
+ Value* getValue(unsigned TypeID, unsigned num, bool Create = true);
+
+ /// @brief Get a value from its type and slot number, ignoring compaction
+ /// tables.
+ Value *getGlobalTableValue(unsigned TyID, unsigned SlotNo);
+
+ /// @brief Get a basic block for current function
+ BasicBlock *getBasicBlock(unsigned ID);
+
+ /// @brief Get a constant value from its typeid and value slot.
+ Constant* getConstantValue(unsigned typeSlot, unsigned valSlot);
+
+ /// @brief Convenience function for getting a constant value when
+ /// the Type has already been resolved.
+ Constant* getConstantValue(const Type *Ty, unsigned valSlot) {
+ return getConstantValue(getTypeSlot(Ty), valSlot);
+ }
+
+ /// @brief Insert a newly created value
+ unsigned insertValue(Value *V, unsigned Type, ValueTable &Table);
+
+ /// @brief Insert the arguments of a function.
+ void insertArguments(Function* F );
+
+ /// @brief Resolve all references to the placeholder (if any) for the
+ /// given constant.
+ void ResolveReferencesToConstant(Constant *C, unsigned Typ, unsigned Slot);
+
+ /// @brief Release our memory.
+ void freeState() {
+ freeTable(FunctionValues);
+ freeTable(ModuleValues);
+ }
+
+ /// @brief Free a table, making sure to free the ValueList in the table.
+ void freeTable(ValueTable &Tab) {
+ while (!Tab.empty()) {
+ delete Tab.back();
+ Tab.pop_back();
+ }
+ }
+
+ inline void error(std::string errmsg);
+
+ BytecodeReader(const BytecodeReader &); // DO NOT IMPLEMENT
+ void operator=(const BytecodeReader &); // DO NOT IMPLEMENT
+
+/// @}
+/// @name Reader Primitives
+/// @{
+private:
+
+ /// @brief Is there more to parse in the current block?
+ inline bool moreInBlock();
+
+ /// @brief Have we read past the end of the block
+ inline void checkPastBlockEnd(const char * block_name);
+
+ /// @brief Align to 32 bits
+ inline void align32();
+
+ /// @brief Read an unsigned integer as 32-bits
+ inline unsigned read_uint();
+
+ /// @brief Read an unsigned integer with variable bit rate encoding
+ inline unsigned read_vbr_uint();
+
+ /// @brief Read an unsigned integer of no more than 24-bits with variable
+ /// bit rate encoding.
+ inline unsigned read_vbr_uint24();
+
+ /// @brief Read an unsigned 64-bit integer with variable bit rate encoding.
+ inline uint64_t read_vbr_uint64();
+
+ /// @brief Read a signed 64-bit integer with variable bit rate encoding.
+ inline int64_t read_vbr_int64();
+
+ /// @brief Read a string
+ inline std::string read_str();
+
+ /// @brief Read a float value
+ inline void read_float(float& FloatVal);
+
+ /// @brief Read a double value
+ inline void read_double(double& DoubleVal);
+
+ /// @brief Read an arbitrary data chunk of fixed length
+ inline void read_data(void *Ptr, void *End);
+
+ /// @brief Read a bytecode block header
+ inline void read_block(unsigned &Type, unsigned &Size);
+
+ /// @brief Read a type identifier and sanitize it.
+ inline bool read_typeid(unsigned &TypeId);
+
+ /// @brief Recalculate type ID for pre 1.3 bytecode files.
+ inline bool sanitizeTypeId(unsigned &TypeId );
+/// @}
+};
+
+/// @brief A function for creating a BytecodeAnalzer as a handler
+/// for the Bytecode reader.
+BytecodeHandler* createBytecodeAnalyzerHandler(BytecodeAnalysis& bca,
+ std::ostream* output );
+
+
+} // End llvm namespace
+
+// vim: sw=2
+#endif
diff --git a/lib/Bytecode/Reader/ReaderWrappers.cpp b/lib/Bytecode/Reader/ReaderWrappers.cpp
new file mode 100644
index 0000000000..1ee27185ad
--- /dev/null
+++ b/lib/Bytecode/Reader/ReaderWrappers.cpp
@@ -0,0 +1,420 @@
+//===- ReaderWrappers.cpp - Parse bytecode from file or buffer -----------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements loading and parsing a bytecode file and parsing a
+// bytecode module from a given buffer.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Bytecode/Analyzer.h"
+#include "llvm/Bytecode/Reader.h"
+#include "Reader.h"
+#include "llvm/Module.h"
+#include "llvm/Instructions.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/System/MappedFile.h"
+#include <cerrno>
+#include <iostream>
+using namespace llvm;
+
+//===----------------------------------------------------------------------===//
+// BytecodeFileReader - Read from an mmap'able file descriptor.
+//
+
+namespace {
+ /// BytecodeFileReader - parses a bytecode file from a file
+ ///
+ class BytecodeFileReader : public BytecodeReader {
+ private:
+ sys::MappedFile mapFile;
+
+ BytecodeFileReader(const BytecodeFileReader&); // Do not implement
+ void operator=(const BytecodeFileReader &BFR); // Do not implement
+
+ public:
+ BytecodeFileReader(const std::string &Filename, llvm::BytecodeHandler* H=0);
+ };
+}
+
+BytecodeFileReader::BytecodeFileReader(const std::string &Filename,
+ llvm::BytecodeHandler* H )
+ : BytecodeReader(H)
+ , mapFile( sys::Path(Filename))
+{
+ mapFile.map();
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(mapFile.base());
+ ParseBytecode(buffer, mapFile.size(), Filename);
+}
+
+//===----------------------------------------------------------------------===//
+// BytecodeBufferReader - Read from a memory buffer
+//
+
+namespace {
+ /// BytecodeBufferReader - parses a bytecode file from a buffer
+ ///
+ class BytecodeBufferReader : public BytecodeReader {
+ private:
+ const unsigned char *Buffer;
+ bool MustDelete;
+
+ BytecodeBufferReader(const BytecodeBufferReader&); // Do not implement
+ void operator=(const BytecodeBufferReader &BFR); // Do not implement
+
+ public:
+ BytecodeBufferReader(const unsigned char *Buf, unsigned Length,
+ const std::string &ModuleID,
+ llvm::BytecodeHandler* Handler = 0);
+ ~BytecodeBufferReader();
+
+ };
+}
+
+BytecodeBufferReader::BytecodeBufferReader(const unsigned char *Buf,
+ unsigned Length,
+ const std::string &ModuleID,
+ llvm::BytecodeHandler* H )
+ : BytecodeReader(H)
+{
+ // If not aligned, allocate a new buffer to hold the bytecode...
+ const unsigned char *ParseBegin = 0;
+ if (reinterpret_cast<uint64_t>(Buf) & 3) {
+ Buffer = new unsigned char[Length+4];
+ unsigned Offset = 4 - ((intptr_t)Buffer & 3); // Make sure it's aligned
+ ParseBegin = Buffer + Offset;
+ memcpy((unsigned char*)ParseBegin, Buf, Length); // Copy it over
+ MustDelete = true;
+ } else {
+ // If we don't need to copy it over, just use the caller's copy
+ ParseBegin = Buffer = Buf;
+ MustDelete = false;
+ }
+ try {
+ ParseBytecode(ParseBegin, Length, ModuleID);
+ } catch (...) {
+ if (MustDelete) delete [] Buffer;
+ throw;
+ }
+}
+
+BytecodeBufferReader::~BytecodeBufferReader() {
+ if (MustDelete) delete [] Buffer;
+}
+
+//===----------------------------------------------------------------------===//
+// BytecodeStdinReader - Read bytecode from Standard Input
+//
+
+namespace {
+ /// BytecodeStdinReader - parses a bytecode file from stdin
+ ///
+ class BytecodeStdinReader : public BytecodeReader {
+ private:
+ std::vector<unsigned char> FileData;
+ unsigned char *FileBuf;
+
+ BytecodeStdinReader(const BytecodeStdinReader&); // Do not implement
+ void operator=(const BytecodeStdinReader &BFR); // Do not implement
+
+ public:
+ BytecodeStdinReader( llvm::BytecodeHandler* H = 0 );
+ };
+}
+
+BytecodeStdinReader::BytecodeStdinReader( BytecodeHandler* H )
+ : BytecodeReader(H)
+{
+ char Buffer[4096*4];
+
+ // Read in all of the data from stdin, we cannot mmap stdin...
+ while (std::cin.good()) {
+ std::cin.read(Buffer, 4096*4);
+ int BlockSize = std::cin.gcount();
+ if (0 >= BlockSize)
+ break;
+ FileData.insert(FileData.end(), Buffer, Buffer+BlockSize);
+ }
+
+ if (FileData.empty())
+ throw std::string("Standard Input empty!");
+
+ FileBuf = &FileData[0];
+ ParseBytecode(FileBuf, FileData.size(), "<stdin>");
+}
+
+//===----------------------------------------------------------------------===//
+// Varargs transmogrification code...
+//
+
+// CheckVarargs - This is used to automatically translate old-style varargs to
+// new style varargs for backwards compatibility.
+static ModuleProvider* CheckVarargs(ModuleProvider* MP) {
+ Module* M = MP->getModule();
+
+ // check to see if va_start takes arguements...
+ Function* F = M->getNamedFunction("llvm.va_start");
+ if(F == 0) return MP; //No varargs use, just return.
+
+ if (F->getFunctionType()->getNumParams() == 1)
+ return MP; // Modern varargs processing, just return.
+
+ // If we get to this point, we know that we have an old-style module.
+ // Materialize the whole thing to perform the rewriting.
+ MP->materializeModule();
+
+ if(Function* F = M->getNamedFunction("llvm.va_start")) {
+ assert(F->arg_size() == 0 && "Obsolete va_start takes 0 argument!");
+
+ //foo = va_start()
+ // ->
+ //bar = alloca typeof(foo)
+ //va_start(bar)
+ //foo = load bar
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = M->getOrInsertFunction("llvm.va_start",
+ RetTy, ArgTyPtr, (Type *)0);
+
+ for(Value::use_iterator I = F->use_begin(), E = F->use_end(); I != E;)
+ if (CallInst* CI = dyn_cast<CallInst>(*I++)) {
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vastart.fix.1", CI);
+ new CallInst(NF, bar, "", CI);
+ Value* foo = new LoadInst(bar, "vastart.fix.2", CI);
+ CI->replaceAllUsesWith(foo);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ F->setName("");
+ }
+
+ if(Function* F = M->getNamedFunction("llvm.va_end")) {
+ assert(F->arg_size() == 1 && "Obsolete va_end takes 1 argument!");
+ //vaend foo
+ // ->
+ //bar = alloca 1 of typeof(foo)
+ //vaend bar
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getParamType(0);
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = M->getOrInsertFunction("llvm.va_end",
+ RetTy, ArgTyPtr, (Type *)0);
+
+ for(Value::use_iterator I = F->use_begin(), E = F->use_end(); I != E;)
+ if (CallInst* CI = dyn_cast<CallInst>(*I++)) {
+ AllocaInst* bar = new AllocaInst(ArgTy, 0, "vaend.fix.1", CI);
+ new StoreInst(CI->getOperand(1), bar, CI);
+ new CallInst(NF, bar, "", CI);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ F->setName("");
+ }
+
+ if(Function* F = M->getNamedFunction("llvm.va_copy")) {
+ assert(F->arg_size() == 1 && "Obsolete va_copy takes 1 argument!");
+ //foo = vacopy(bar)
+ // ->
+ //a = alloca 1 of typeof(foo)
+ //b = alloca 1 of typeof(foo)
+ //store bar -> b
+ //vacopy(a, b)
+ //foo = load a
+
+ const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
+ const Type* ArgTy = F->getFunctionType()->getReturnType();
+ const Type* ArgTyPtr = PointerType::get(ArgTy);
+ Function* NF = M->getOrInsertFunction("llvm.va_copy",
+ RetTy, ArgTyPtr, ArgTyPtr, (Type *)0);
+
+ for(Value::use_iterator I = F->use_begin(), E = F->use_end(); I != E;)
+ if (CallInst* CI = dyn_cast<CallInst>(*I++)) {
+ AllocaInst* a = new AllocaInst(ArgTy, 0, "vacopy.fix.1", CI);
+ AllocaInst* b = new AllocaInst(ArgTy, 0, "vacopy.fix.2", CI);
+ new StoreInst(CI->getOperand(1), b, CI);
+ new CallInst(NF, a, b, "", CI);
+ Value* foo = new LoadInst(a, "vacopy.fix.3", CI);
+ CI->replaceAllUsesWith(foo);
+ CI->getParent()->getInstList().erase(CI);
+ }
+ F->setName("");
+ }
+ return MP;
+}
+
+//===----------------------------------------------------------------------===//
+// Wrapper functions
+//===----------------------------------------------------------------------===//
+
+/// getBytecodeBufferModuleProvider - lazy function-at-a-time loading from a
+/// buffer
+ModuleProvider*
+llvm::getBytecodeBufferModuleProvider(const unsigned char *Buffer,
+ unsigned Length,
+ const std::string &ModuleID,
+ BytecodeHandler* H ) {
+ return CheckVarargs(
+ new BytecodeBufferReader(Buffer, Length, ModuleID, H));
+}
+
+/// ParseBytecodeBuffer - Parse a given bytecode buffer
+///
+Module *llvm::ParseBytecodeBuffer(const unsigned char *Buffer, unsigned Length,
+ const std::string &ModuleID,
+ std::string *ErrorStr){
+ try {
+ std::auto_ptr<ModuleProvider>
+ AMP(getBytecodeBufferModuleProvider(Buffer, Length, ModuleID));
+ return AMP->releaseModule();
+ } catch (std::string &err) {
+ if (ErrorStr) *ErrorStr = err;
+ return 0;
+ }
+}
+
+/// getBytecodeModuleProvider - lazy function-at-a-time loading from a file
+///
+ModuleProvider *llvm::getBytecodeModuleProvider(const std::string &Filename,
+ BytecodeHandler* H) {
+ if (Filename != std::string("-")) // Read from a file...
+ return CheckVarargs(new BytecodeFileReader(Filename,H));
+ else // Read from stdin
+ return CheckVarargs(new BytecodeStdinReader(H));
+}
+
+/// ParseBytecodeFile - Parse the given bytecode file
+///
+Module *llvm::ParseBytecodeFile(const std::string &Filename,
+ std::string *ErrorStr) {
+ try {
+ std::auto_ptr<ModuleProvider> AMP(getBytecodeModuleProvider(Filename));
+ return AMP->releaseModule();
+ } catch (std::string &err) {
+ if (ErrorStr) *ErrorStr = err;
+ return 0;
+ }
+}
+
+// AnalyzeBytecodeFile - analyze one file
+Module* llvm::AnalyzeBytecodeFile(
+ const std::string &Filename, ///< File to analyze
+ BytecodeAnalysis& bca, ///< Statistical output
+ std::string *ErrorStr, ///< Error output
+ std::ostream* output ///< Dump output
+)
+{
+ try {
+ BytecodeHandler* analyzerHandler =createBytecodeAnalyzerHandler(bca,output);
+ std::auto_ptr<ModuleProvider> AMP(
+ getBytecodeModuleProvider(Filename,analyzerHandler));
+ return AMP->releaseModule();
+ } catch (std::string &err) {
+ if (ErrorStr) *ErrorStr = err;
+ return 0;
+ }
+}
+
+// AnalyzeBytecodeBuffer - analyze a buffer
+Module* llvm::AnalyzeBytecodeBuffer(
+ const unsigned char* Buffer, ///< Pointer to start of bytecode buffer
+ unsigned Length, ///< Size of the bytecode buffer
+ const std::string& ModuleID, ///< Identifier for the module
+ BytecodeAnalysis& bca, ///< The results of the analysis
+ std::string* ErrorStr, ///< Errors, if any.
+ std::ostream* output ///< Dump output, if any
+)
+{
+ try {
+ BytecodeHandler* hdlr = createBytecodeAnalyzerHandler(bca, output);
+ std::auto_ptr<ModuleProvider>
+ AMP(getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, hdlr));
+ return AMP->releaseModule();
+ } catch (std::string &err) {
+ if (ErrorStr) *ErrorStr = err;
+ return 0;
+ }
+}
+
+bool llvm::GetBytecodeDependentLibraries(const std::string &fname,
+ Module::LibraryListType& deplibs) {
+ try {
+ std::auto_ptr<ModuleProvider> AMP( getBytecodeModuleProvider(fname));
+ Module* M = AMP->releaseModule();
+
+ deplibs = M->getLibraries();
+ delete M;
+ return true;
+ } catch (...) {
+ deplibs.clear();
+ return false;
+ }
+}
+
+static void getSymbols(Module*M, std::vector<std::string>& symbols) {
+ // Loop over global variables
+ for (Module::global_iterator GI = M->global_begin(), GE=M->global_end(); GI != GE; ++GI)
+ if (!GI->isExternal() && !GI->hasInternalLinkage())
+ if (!GI->getName().empty())
+ symbols.push_back(GI->getName());
+
+ // Loop over functions.
+ for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
+ if (!FI->isExternal() && !FI->hasInternalLinkage())
+ if (!FI->getName().empty())
+ symbols.push_back(FI->getName());
+}
+
+// Get just the externally visible defined symbols from the bytecode
+bool llvm::GetBytecodeSymbols(const sys::Path& fName,
+ std::vector<std::string>& symbols) {
+ try {
+ std::auto_ptr<ModuleProvider> AMP(
+ getBytecodeModuleProvider(fName.toString()));
+
+ // Get the module from the provider
+ Module* M = AMP->materializeModule();
+
+ // Get the symbols
+ getSymbols(M, symbols);
+
+ // Done with the module
+ return true;
+
+ } catch (...) {
+ return false;
+ }
+}
+
+ModuleProvider*
+llvm::GetBytecodeSymbols(const unsigned char*Buffer, unsigned Length,
+ const std::string& ModuleID,
+ std::vector<std::string>& symbols) {
+
+ ModuleProvider* MP = 0;
+ try {
+ // Get the module provider
+ MP = getBytecodeBufferModuleProvider(Buffer, Length, ModuleID);
+
+ // Get the module from the provider
+ Module* M = MP->materializeModule();
+
+ // Get the symbols
+ getSymbols(M, symbols);
+
+ // Done with the module. Note that ModuleProvider will delete the
+ // Module when it is deleted. Also note that its the caller's responsibility
+ // to delete the ModuleProvider.
+ return MP;
+
+ } catch (...) {
+ // We delete only the ModuleProvider here because its destructor will
+ // also delete the Module (we used materializeModule not releaseModule).
+ delete MP;
+ }
+ return 0;
+}
diff --git a/lib/Bytecode/Writer/Makefile b/lib/Bytecode/Writer/Makefile
new file mode 100644
index 0000000000..e1bf0da87d
--- /dev/null
+++ b/lib/Bytecode/Writer/Makefile
@@ -0,0 +1,12 @@
+##===- lib/Bytecode/Writer/Makefile ------------------------*- Makefile -*-===##
+#
+# The LLVM Compiler Infrastructure
+#
+# This file was developed by the LLVM research group and is distributed under
+# the University of Illinois Open Source License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../..
+LIBRARYNAME = LLVMBCWriter
+
+include $(LEVEL)/Makefile.common
diff --git a/lib/Bytecode/Writer/SlotCalculator.cpp b/lib/Bytecode/Writer/SlotCalculator.cpp
new file mode 100644
index 0000000000..c6aba09fe5
--- /dev/null
+++ b/lib/Bytecode/Writer/SlotCalculator.cpp
@@ -0,0 +1,862 @@
+//===-- SlotCalculator.cpp - Calculate what slots values land in ----------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a useful analysis step to figure out what numbered slots
+// values in a program will land in (keeping track of per plane information).
+//
+// This is used when writing a file to disk, either in bytecode or assembly.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SlotCalculator.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Type.h"
+#include "llvm/Analysis/ConstantsScanner.h"
+#include "llvm/ADT/PostOrderIterator.h"
+#include "llvm/ADT/STLExtras.h"
+#include <algorithm>
+#include <functional>
+
+using namespace llvm;
+
+#if 0
+#include <iostream>
+#define SC_DEBUG(X) std::cerr << X
+#else
+#define SC_DEBUG(X)
+#endif
+
+SlotCalculator::SlotCalculator(const Module *M ) {
+ ModuleContainsAllFunctionConstants = false;
+ ModuleTypeLevel = 0;
+ TheModule = M;
+
+ // Preload table... Make sure that all of the primitive types are in the table
+ // and that their Primitive ID is equal to their slot #
+ //
+ SC_DEBUG("Inserting primitive types:\n");
+ for (unsigned i = 0; i < Type::FirstDerivedTyID; ++i) {
+ assert(Type::getPrimitiveType((Type::TypeID)i));
+ insertType(Type::getPrimitiveType((Type::TypeID)i), true);
+ }
+
+ if (M == 0) return; // Empty table...
+ processModule();
+}
+
+SlotCalculator::SlotCalculator(const Function *M ) {
+ ModuleContainsAllFunctionConstants = false;
+ TheModule = M ? M->getParent() : 0;
+
+ // Preload table... Make sure that all of the primitive types are in the table
+ // and that their Primitive ID is equal to their slot #
+ //
+ SC_DEBUG("Inserting primitive types:\n");
+ for (unsigned i = 0; i < Type::FirstDerivedTyID; ++i) {
+ assert(Type::getPrimitiveType((Type::TypeID)i));
+ insertType(Type::getPrimitiveType((Type::TypeID)i), true);
+ }
+
+ if (TheModule == 0) return; // Empty table...
+
+ processModule(); // Process module level stuff
+ incorporateFunction(M); // Start out in incorporated state
+}
+
+unsigned SlotCalculator::getGlobalSlot(const Value *V) const {
+ assert(!CompactionTable.empty() &&
+ "This method can only be used when compaction is enabled!");
+ std::map<const Value*, unsigned>::const_iterator I = NodeMap.find(V);
+ assert(I != NodeMap.end() && "Didn't find global slot entry!");
+ return I->second;
+}
+
+unsigned SlotCalculator::getGlobalSlot(const Type* T) const {
+ std::map<const Type*, unsigned>::const_iterator I = TypeMap.find(T);
+ assert(I != TypeMap.end() && "Didn't find global slot entry!");
+ return I->second;
+}
+
+SlotCalculator::TypePlane &SlotCalculator::getPlane(unsigned Plane) {
+ if (CompactionTable.empty()) { // No compaction table active?
+ // fall out
+ } else if (!CompactionTable[Plane].empty()) { // Compaction table active.
+ assert(Plane < CompactionTable.size());
+ return CompactionTable[Plane];
+ } else {
+ // Final case: compaction table active, but this plane is not
+ // compactified. If the type plane is compactified, unmap back to the
+ // global type plane corresponding to "Plane".
+ if (!CompactionTypes.empty()) {
+ const Type *Ty = CompactionTypes[Plane];
+ TypeMapType::iterator It = TypeMap.find(Ty);
+ assert(It != TypeMap.end() && "Type not in global constant map?");
+ Plane = It->second;
+ }
+ }
+
+ // Okay we are just returning an entry out of the main Table. Make sure the
+ // plane exists and return it.
+ if (Plane >= Table.size())
+ Table.resize(Plane+1);
+ return Table[Plane];
+}
+
+// processModule - Process all of the module level function declarations and
+// types that are available.
+//
+void SlotCalculator::processModule() {
+ SC_DEBUG("begin processModule!\n");
+
+ // Add all of the global variables to the value table...
+ //
+ for (Module::const_global_iterator I = TheModule->global_begin(),
+ E = TheModule->global_end(); I != E; ++I)
+ getOrCreateSlot(I);
+
+ // Scavenge the types out of the functions, then add the functions themselves
+ // to the value table...
+ //
+ for (Module::const_iterator I = TheModule->begin(), E = TheModule->end();
+ I != E; ++I)
+ getOrCreateSlot(I);
+
+ // Add all of the module level constants used as initializers
+ //
+ for (Module::const_global_iterator I = TheModule->global_begin(),
+ E = TheModule->global_end(); I != E; ++I)
+ if (I->hasInitializer())
+ getOrCreateSlot(I->getInitializer());
+
+ // Now that all global constants have been added, rearrange constant planes
+ // that contain constant strings so that the strings occur at the start of the
+ // plane, not somewhere in the middle.
+ //
+ for (unsigned plane = 0, e = Table.size(); plane != e; ++plane) {
+ if (const ArrayType *AT = dyn_cast<ArrayType>(Types[plane]))
+ if (AT->getElementType() == Type::SByteTy ||
+ AT->getElementType() == Type::UByteTy) {
+ TypePlane &Plane = Table[plane];
+ unsigned FirstNonStringID = 0;
+ for (unsigned i = 0, e = Plane.size(); i != e; ++i)
+ if (isa<ConstantAggregateZero>(Plane[i]) ||
+ (isa<ConstantArray>(Plane[i]) &&
+ cast<ConstantArray>(Plane[i])->isString())) {
+ // Check to see if we have to shuffle this string around. If not,
+ // don't do anything.
+ if (i != FirstNonStringID) {
+ // Swap the plane entries....
+ std::swap(Plane[i], Plane[FirstNonStringID]);
+
+ // Keep the NodeMap up to date.
+ NodeMap[Plane[i]] = i;
+ NodeMap[Plane[FirstNonStringID]] = FirstNonStringID;
+ }
+ ++FirstNonStringID;
+ }
+ }
+ }
+
+ // Scan all of the functions for their constants, which allows us to emit
+ // more compact modules. This is optional, and is just used to compactify
+ // the constants used by different functions together.
+ //
+ // This functionality tends to produce smaller bytecode files. This should
+ // not be used in the future by clients that want to, for example, build and
+ // emit functions on the fly. For now, however, it is unconditionally
+ // enabled.
+ ModuleContainsAllFunctionConstants = true;
+
+ SC_DEBUG("Inserting function constants:\n");
+ for (Module::const_iterator F = TheModule->begin(), E = TheModule->end();
+ F != E; ++F) {
+ for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I){
+ for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
+ if (isa<Constant>(I->getOperand(op)) &&
+ !isa<GlobalValue>(I->getOperand(op)))
+ getOrCreateSlot(I->getOperand(op));
+ getOrCreateSlot(I->getType());
+ }
+ processSymbolTableConstants(&F->getSymbolTable());
+ }
+
+ // Insert constants that are named at module level into the slot pool so that
+ // the module symbol table can refer to them...
+ SC_DEBUG("Inserting SymbolTable values:\n");
+ processSymbolTable(&TheModule->getSymbolTable());
+
+ // Now that we have collected together all of the information relevant to the
+ // module, compactify the type table if it is particularly big and outputting
+ // a bytecode file. The basic problem we run into is that some programs have
+ // a large number of types, which causes the type field to overflow its size,
+ // which causes instructions to explode in size (particularly call
+ // instructions). To avoid this behavior, we "sort" the type table so that
+ // all non-value types are pushed to the end of the type table, giving nice
+ // low numbers to the types that can be used by instructions, thus reducing
+ // the amount of explodage we suffer.
+ if (Types.size() >= 64) {
+ unsigned FirstNonValueTypeID = 0;
+ for (unsigned i = 0, e = Types.size(); i != e; ++i)
+ if (Types[i]->isFirstClassType() || Types[i]->isPrimitiveType()) {
+ // Check to see if we have to shuffle this type around. If not, don't
+ // do anything.
+ if (i != FirstNonValueTypeID) {
+ // Swap the type ID's.
+ std::swap(Types[i], Types[FirstNonValueTypeID]);
+
+ // Keep the TypeMap up to date.
+ TypeMap[Types[i]] = i;
+ TypeMap[Types[FirstNonValueTypeID]] = FirstNonValueTypeID;
+
+ // When we move a type, make sure to move its value plane as needed.
+ if (Table.size() > FirstNonValueTypeID) {
+ if (Table.size() <= i) Table.resize(i+1);
+ std::swap(Table[i], Table[FirstNonValueTypeID]);
+ }
+ }
+ ++FirstNonValueTypeID;
+ }
+ }
+
+ SC_DEBUG("end processModule!\n");
+}
+
+// processSymbolTable - Insert all of the values in the specified symbol table
+// into the values table...
+//
+void SlotCalculator::processSymbolTable(const SymbolTable *ST) {
+ // Do the types first.
+ for (SymbolTable::type_const_iterator TI = ST->type_begin(),
+ TE = ST->type_end(); TI != TE; ++TI )
+ getOrCreateSlot(TI->second);
+
+ // Now do the values.
+ for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
+ PE = ST->plane_end(); PI != PE; ++PI)
+ for (SymbolTable::value_const_iterator VI = PI->second.begin(),
+ VE = PI->second.end(); VI != VE; ++VI)
+ getOrCreateSlot(VI->second);
+}
+
+void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
+ // Do the types first
+ for (SymbolTable::type_const_iterator TI = ST->type_begin(),
+ TE = ST->type_end(); TI != TE; ++TI )
+ getOrCreateSlot(TI->second);
+
+ // Now do the constant values in all planes
+ for (SymbolTable::plane_const_iterator PI = ST->plane_begin(),
+ PE = ST->plane_end(); PI != PE; ++PI)
+ for (SymbolTable::value_const_iterator VI = PI->second.begin(),
+ VE = PI->second.end(); VI != VE; ++VI)
+ if (isa<Constant>(VI->second) &&
+ !isa<GlobalValue>(VI->second))
+ getOrCreateSlot(VI->second);
+}
+
+
+void SlotCalculator::incorporateFunction(const Function *F) {
+ assert((ModuleLevel.size() == 0 ||
+ ModuleTypeLevel == 0) && "Module already incorporated!");
+
+ SC_DEBUG("begin processFunction!\n");
+
+ // If we emitted all of the function constants, build a compaction table.
+ if ( ModuleContainsAllFunctionConstants)
+ buildCompactionTable(F);
+
+ // Update the ModuleLevel entries to be accurate.
+ ModuleLevel.resize(getNumPlanes());
+ for (unsigned i = 0, e = getNumPlanes(); i != e; ++i)
+ ModuleLevel[i] = getPlane(i).size();
+ ModuleTypeLevel = Types.size();
+
+ // Iterate over function arguments, adding them to the value table...
+ for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
+ getOrCreateSlot(I);
+
+ if ( !ModuleContainsAllFunctionConstants ) {
+ // Iterate over all of the instructions in the function, looking for
+ // constant values that are referenced. Add these to the value pools
+ // before any nonconstant values. This will be turned into the constant
+ // pool for the bytecode writer.
+ //
+
+ // Emit all of the constants that are being used by the instructions in
+ // the function...
+ constant_iterator CI = constant_begin(F);
+ constant_iterator CE = constant_end(F);
+ while ( CI != CE ) {
+ this->getOrCreateSlot(*CI);
+ ++CI;
+ }
+
+ // If there is a symbol table, it is possible that the user has names for
+ // constants that are not being used. In this case, we will have problems
+ // if we don't emit the constants now, because otherwise we will get
+ // symbol table references to constants not in the output. Scan for these
+ // constants now.
+ //
+ processSymbolTableConstants(&F->getSymbolTable());
+ }
+
+ SC_DEBUG("Inserting Instructions:\n");
+
+ // Add all of the instructions to the type planes...
+ for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
+ getOrCreateSlot(BB);
+ for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) {
+ getOrCreateSlot(I);
+ }
+ }
+
+ // If we are building a compaction table, prune out planes that do not benefit
+ // from being compactified.
+ if (!CompactionTable.empty())
+ pruneCompactionTable();
+
+ SC_DEBUG("end processFunction!\n");
+}
+
+void SlotCalculator::purgeFunction() {
+ assert((ModuleLevel.size() != 0 ||
+ ModuleTypeLevel != 0) && "Module not incorporated!");
+ unsigned NumModuleTypes = ModuleLevel.size();
+
+ SC_DEBUG("begin purgeFunction!\n");
+
+ // First, free the compaction map if used.
+ CompactionNodeMap.clear();
+ CompactionTypeMap.clear();
+
+ // Next, remove values from existing type planes
+ for (unsigned i = 0; i != NumModuleTypes; ++i) {
+ // Size of plane before function came
+ unsigned ModuleLev = getModuleLevel(i);
+ assert(int(ModuleLev) >= 0 && "BAD!");
+
+ TypePlane &Plane = getPlane(i);
+
+ assert(ModuleLev <= Plane.size() && "module levels higher than elements?");
+ while (Plane.size() != ModuleLev) {
+ assert(!isa<GlobalValue>(Plane.back()) &&
+ "Functions cannot define globals!");
+ NodeMap.erase(Plane.back()); // Erase from nodemap
+ Plane.pop_back(); // Shrink plane
+ }
+ }
+
+ // We don't need this state anymore, free it up.
+ ModuleLevel.clear();
+ ModuleTypeLevel = 0;
+
+ // Finally, remove any type planes defined by the function...
+ CompactionTypes.clear();
+ if (!CompactionTable.empty()) {
+ CompactionTable.clear();
+ } else {
+ while (Table.size() > NumModuleTypes) {
+ TypePlane &Plane = Table.back();
+ SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size "
+ << Plane.size() << "\n");
+ while (Plane.size()) {
+ assert(!isa<GlobalValue>(Plane.back()) &&
+ "Functions cannot define globals!");
+ NodeMap.erase(Plane.back()); // Erase from nodemap
+ Plane.pop_back(); // Shrink plane
+ }
+
+ Table.pop_back(); // Nuke the plane, we don't like it.
+ }
+ }
+
+ SC_DEBUG("end purgeFunction!\n");
+}
+
+static inline bool hasNullValue(const Type *Ty) {
+ return Ty != Type::LabelTy && Ty != Type::VoidTy && !isa<OpaqueType>(Ty);
+}
+
+/// getOrCreateCompactionTableSlot - This method is used to build up the initial
+/// approximation of the compaction table.
+unsigned SlotCalculator::getOrCreateCompactionTableSlot(const Value *V) {
+ std::map<const Value*, unsigned>::iterator I =
+ CompactionNodeMap.lower_bound(V);
+ if (I != CompactionNodeMap.end() && I->first == V)
+ return I->second; // Already exists?
+
+ // Make sure the type is in the table.
+ unsigned Ty;
+ if (!CompactionTypes.empty())
+ Ty = getOrCreateCompactionTableSlot(V->getType());
+ else // If the type plane was decompactified, use the global plane ID
+ Ty = getSlot(V->getType());
+ if (CompactionTable.size() <= Ty)
+ CompactionTable.resize(Ty+1);
+
+ TypePlane &TyPlane = CompactionTable[Ty];
+
+ // Make sure to insert the null entry if the thing we are inserting is not a
+ // null constant.
+ if (TyPlane.empty() && hasNullValue(V->getType())) {
+ Value *ZeroInitializer = Constant::getNullValue(V->getType());
+ if (V != ZeroInitializer) {
+ TyPlane.push_back(ZeroInitializer);
+ CompactionNodeMap[ZeroInitializer] = 0;
+ }
+ }
+
+ unsigned SlotNo = TyPlane.size();
+ TyPlane.push_back(V);
+ CompactionNodeMap.insert(std::make_pair(V, SlotNo));
+ return SlotNo;
+}
+
+/// getOrCreateCompactionTableSlot - This method is used to build up the initial
+/// approximation of the compaction table.
+unsigned SlotCalculator::getOrCreateCompactionTableSlot(const Type *T) {
+ std::map<const Type*, unsigned>::iterator I =
+ CompactionTypeMap.lower_bound(T);
+ if (I != CompactionTypeMap.end() && I->first == T)
+ return I->second; // Already exists?
+
+ unsigned SlotNo = CompactionTypes.size();
+ SC_DEBUG("Inserting Compaction Type #" << SlotNo << ": " << T << "\n");
+ CompactionTypes.push_back(T);
+ CompactionTypeMap.insert(std::make_pair(T, SlotNo));
+ return SlotNo;
+}
+
+/// buildCompactionTable - Since all of the function constants and types are
+/// stored in the module-level constant table, we don't need to emit a function
+/// constant table. Also due to this, the indices for various constants and
+/// types might be very large in large programs. In order to avoid blowing up
+/// the size of instructions in the bytecode encoding, we build a compaction
+/// table, which defines a mapping from function-local identifiers to global
+/// identifiers.
+void SlotCalculator::buildCompactionTable(const Function *F) {
+ assert(CompactionNodeMap.empty() && "Compaction table already built!");
+ assert(CompactionTypeMap.empty() && "Compaction types already built!");
+ // First step, insert the primitive types.
+ CompactionTable.resize(Type::LastPrimitiveTyID+1);
+ for (unsigned i = 0; i <= Type::LastPrimitiveTyID; ++i) {
+ const Type *PrimTy = Type::getPrimitiveType((Type::TypeID)i);
+ CompactionTypes.push_back(PrimTy);
+ CompactionTypeMap[PrimTy] = i;
+ }
+
+ // Next, include any types used by function arguments.
+ for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
+ I != E; ++I)
+ getOrCreateCompactionTableSlot(I->getType());
+
+ // Next, find all of the types and values that are referred to by the
+ // instructions in the function.
+ for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
+ getOrCreateCompactionTableSlot(I->getType());
+ for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
+ if (isa<Constant>(I->getOperand(op)))
+ getOrCreateCompactionTableSlot(I->getOperand(op));
+ }
+
+ // Do the types in the symbol table
+ const SymbolTable &ST = F->getSymbolTable();
+ for (SymbolTable::type_const_iterator TI = ST.type_begin(),
+ TE = ST.type_end(); TI != TE; ++TI)
+ getOrCreateCompactionTableSlot(TI->second);
+
+ // Now do the constants and global values
+ for (SymbolTable::plane_const_iterator PI = ST.plane_begin(),
+ PE = ST.plane_end(); PI != PE; ++PI)
+ for (SymbolTable::value_const_iterator VI = PI->second.begin(),
+ VE = PI->second.end(); VI != VE; ++VI)
+ if (isa<Constant>(VI->second) && !isa<GlobalValue>(VI->second))
+ getOrCreateCompactionTableSlot(VI->second);
+
+ // Now that we have all of the values in the table, and know what types are
+ // referenced, make sure that there is at least the zero initializer in any
+ // used type plane. Since the type was used, we will be emitting instructions
+ // to the plane even if there are no constants in it.
+ CompactionTable.resize(CompactionTypes.size());
+ for (unsigned i = 0, e = CompactionTable.size(); i != e; ++i)
+ if (CompactionTable[i].empty() && (i != Type::VoidTyID) &&
+ i != Type::LabelTyID) {
+ const Type *Ty = CompactionTypes[i];
+ SC_DEBUG("Getting Null Value #" << i << " for Type " << Ty << "\n");
+ assert(Ty->getTypeID() != Type::VoidTyID);
+ assert(Ty->getTypeID() != Type::LabelTyID);
+ getOrCreateCompactionTableSlot(Constant::getNullValue(Ty));
+ }
+
+ // Okay, now at this point, we have a legal compaction table. Since we want
+ // to emit the smallest possible binaries, do not compactify the type plane if
+ // it will not save us anything. Because we have not yet incorporated the
+ // function body itself yet, we don't know whether or not it's a good idea to
+ // compactify other planes. We will defer this decision until later.
+ TypeList &GlobalTypes = Types;
+
+ // All of the values types will be scrunched to the start of the types plane
+ // of the global table. Figure out just how many there are.
+ assert(!GlobalTypes.empty() && "No global types???");
+ unsigned NumFCTypes = GlobalTypes.size()-1;
+ while (!GlobalTypes[NumFCTypes]->isFirstClassType())
+ --NumFCTypes;
+
+ // If there are fewer that 64 types, no instructions will be exploded due to
+ // the size of the type operands. Thus there is no need to compactify types.
+ // Also, if the compaction table contains most of the entries in the global
+ // table, there really is no reason to compactify either.
+ if (NumFCTypes < 64) {
+ // Decompactifying types is tricky, because we have to move type planes all
+ // over the place. At least we don't need to worry about updating the
+ // CompactionNodeMap for non-types though.
+ std::vector<TypePlane> TmpCompactionTable;
+ std::swap(CompactionTable, TmpCompactionTable);
+ TypeList TmpTypes;
+ std::swap(TmpTypes, CompactionTypes);
+
+ // Move each plane back over to the uncompactified plane
+ while (!TmpTypes.empty()) {
+ const Type *Ty = TmpTypes.back();
+ TmpTypes.pop_back();
+ CompactionTypeMap.erase(Ty); // Decompactify type!
+
+ // Find the global slot number for this type.
+ int TySlot = getSlot(Ty);
+ assert(TySlot != -1 && "Type doesn't exist in global table?");
+
+ // Now we know where to put the compaction table plane.
+ if (CompactionTable.size() <= unsigned(TySlot))
+ CompactionTable.resize(TySlot+1);
+ // Move the plane back into the compaction table.
+ std::swap(CompactionTable[TySlot], TmpCompactionTable[TmpTypes.size()]);
+
+ // And remove the empty plane we just moved in.
+ TmpCompactionTable.pop_back();
+ }
+ }
+}
+
+
+/// pruneCompactionTable - Once the entire function being processed has been
+/// incorporated into the current compaction table, look over the compaction
+/// table and check to see if there are any values whose compaction will not
+/// save us any space in the bytecode file. If compactifying these values
+/// serves no purpose, then we might as well not even emit the compactification
+/// information to the bytecode file, saving a bit more space.
+///
+/// Note that the type plane has already been compactified if possible.
+///
+void SlotCalculator::pruneCompactionTable() {
+ TypeList &TyPlane = CompactionTypes;
+ for (unsigned ctp = 0, e = CompactionTable.size(); ctp != e; ++ctp)
+ if (!CompactionTable[ctp].empty()) {
+ TypePlane &CPlane = CompactionTable[ctp];
+ unsigned GlobalSlot = ctp;
+ if (!TyPlane.empty())
+ GlobalSlot = getGlobalSlot(TyPlane[ctp]);
+
+ if (GlobalSlot >= Table.size())
+ Table.resize(GlobalSlot+1);
+ TypePlane &GPlane = Table[GlobalSlot];
+
+ unsigned ModLevel = getModuleLevel(ctp);
+ unsigned NumFunctionObjs = CPlane.size()-ModLevel;
+
+ // If the maximum index required if all entries in this plane were merged
+ // into the global plane is less than 64, go ahead and eliminate the
+ // plane.
+ bool PrunePlane = GPlane.size() + NumFunctionObjs < 64;
+
+ // If there are no function-local values defined, and the maximum
+ // referenced global entry is less than 64, we don't need to compactify.
+ if (!PrunePlane && NumFunctionObjs == 0) {
+ unsigned MaxIdx = 0;
+ for (unsigned i = 0; i != ModLevel; ++i) {
+ unsigned Idx = NodeMap[CPlane[i]];
+ if (Idx > MaxIdx) MaxIdx = Idx;
+ }
+ PrunePlane = MaxIdx < 64;
+ }
+
+ // Ok, finally, if we decided to prune this plane out of the compaction
+ // table, do so now.
+ if (PrunePlane) {
+ TypePlane OldPlane;
+ std::swap(OldPlane, CPlane);
+
+ // Loop over the function local objects, relocating them to the global
+ // table plane.
+ for (unsigned i = ModLevel, e = OldPlane.size(); i != e; ++i) {
+ const Value *V = OldPlane[i];
+ CompactionNodeMap.erase(V);
+ assert(NodeMap.count(V) == 0 && "Value already in table??");
+ getOrCreateSlot(V);
+ }
+
+ // For compactified global values, just remove them from the compaction
+ // node map.
+ for (unsigned i = 0; i != ModLevel; ++i)
+ CompactionNodeMap.erase(OldPlane[i]);
+
+ // Update the new modulelevel for this plane.
+ assert(ctp < ModuleLevel.size() && "Cannot set modulelevel!");
+ ModuleLevel[ctp] = GPlane.size()-NumFunctionObjs;
+ assert((int)ModuleLevel[ctp] >= 0 && "Bad computation!");
+ }
+ }
+}
+
+/// Determine if the compaction table is actually empty. Because the
+/// compaction table always includes the primitive type planes, we
+/// can't just check getCompactionTable().size() because it will never
+/// be zero. Furthermore, the ModuleLevel factors into whether a given
+/// plane is empty or not. This function does the necessary computation
+/// to determine if its actually empty.
+bool SlotCalculator::CompactionTableIsEmpty() const {
+ // Check a degenerate case, just in case.
+ if (CompactionTable.size() == 0) return true;
+
+ // Check each plane
+ for (unsigned i = 0, e = CompactionTable.size(); i < e; ++i) {
+ // If the plane is not empty
+ if (!CompactionTable[i].empty()) {
+ // If the module level is non-zero then at least the
+ // first element of the plane is valid and therefore not empty.
+ unsigned End = getModuleLevel(i);
+ if (End != 0)
+ return false;
+ }
+ }
+ // All the compaction table planes are empty so the table is
+ // considered empty too.
+ return true;
+}
+
+int SlotCalculator::getSlot(const Value *V) const {
+ // If there is a CompactionTable active...
+ if (!CompactionNodeMap.empty()) {
+ std::map<const Value*, unsigned>::const_iterator I =
+ CompactionNodeMap.find(V);
+ if (I != CompactionNodeMap.end())
+ return (int)I->second;
+ // Otherwise, if it's not in the compaction table, it must be in a
+ // non-compactified plane.
+ }
+
+ std::map<const Value*, unsigned>::const_iterator I = NodeMap.find(V);
+ if (I != NodeMap.end())
+ return (int)I->second;
+
+ return -1;
+}
+
+int SlotCalculator::getSlot(const Type*T) const {
+ // If there is a CompactionTable active...
+ if (!CompactionTypeMap.empty()) {
+ std::map<const Type*, unsigned>::const_iterator I =
+ CompactionTypeMap.find(T);
+ if (I != CompactionTypeMap.end())
+ return (int)I->second;
+ // Otherwise, if it's not in the compaction table, it must be in a
+ // non-compactified plane.
+ }
+
+ std::map<const Type*, unsigned>::const_iterator I = TypeMap.find(T);
+ if (I != TypeMap.end())
+ return (int)I->second;
+
+ return -1;
+}
+
+int SlotCalculator::getOrCreateSlot(const Value *V) {
+ if (V->getType() == Type::VoidTy) return -1;
+
+ int SlotNo = getSlot(V); // Check to see if it's already in!
+ if (SlotNo != -1) return SlotNo;
+
+ if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
+ assert(GV->getParent() != 0 && "Global not embedded into a module!");
+
+ if (!isa<GlobalValue>(V)) // Initializers for globals are handled explicitly
+ if (const Constant *C = dyn_cast<Constant>(V)) {
+ assert(CompactionNodeMap.empty() &&
+ "All needed constants should be in the compaction map already!");
+
+ // Do not index the characters that make up constant strings. We emit
+ // constant strings as special entities that don't require their
+ // individual characters to be emitted.
+ if (!isa<ConstantArray>(C) || !cast<ConstantArray>(C)->isString()) {
+ // This makes sure that if a constant has uses (for example an array of
+ // const ints), that they are inserted also.
+ //
+ for (User::const_op_iterator I = C->op_begin(), E = C->op_end();
+ I != E; ++I)
+ getOrCreateSlot(*I);
+ } else {
+ assert(ModuleLevel.empty() &&
+ "How can a constant string be directly accessed in a function?");
+ // Otherwise, if we are emitting a bytecode file and this IS a string,
+ // remember it.
+ if (!C->isNullValue())
+ ConstantStrings.push_back(cast<ConstantArray>(C));
+ }
+ }
+
+ return insertValue(V);
+}
+
+int SlotCalculator::getOrCreateSlot(const Type* T) {
+ int SlotNo = getSlot(T); // Check to see if it's already in!
+ if (SlotNo != -1) return SlotNo;
+ return insertType(T);
+}
+
+int SlotCalculator::insertValue(const Value *D, bool dontIgnore) {
+ assert(D && "Can't insert a null value!");
+ assert(getSlot(D) == -1 && "Value is already in the table!");
+
+ // If we are building a compaction map, and if this plane is being compacted,
+ // insert the value into the compaction map, not into the global map.
+ if (!CompactionNodeMap.empty()) {
+ if (D->getType() == Type::VoidTy) return -1; // Do not insert void values
+ assert(!isa<Constant>(D) &&
+ "Types, constants, and globals should be in global table!");
+
+ int Plane = getSlot(D->getType());
+ assert(Plane != -1 && CompactionTable.size() > (unsigned)Plane &&
+ "Didn't find value type!");
+ if (!CompactionTable[Plane].empty())
+ return getOrCreateCompactionTableSlot(D);
+ }
+
+ // If this node does not contribute to a plane, or if the node has a
+ // name and we don't want names, then ignore the silly node... Note that types
+ // do need slot numbers so that we can keep track of where other values land.
+ //
+ if (!dontIgnore) // Don't ignore nonignorables!
+ if (D->getType() == Type::VoidTy ) { // Ignore void type nodes
+ SC_DEBUG("ignored value " << *D << "\n");
+ return -1; // We do need types unconditionally though
+ }
+
+ // Okay, everything is happy, actually insert the silly value now...
+ return doInsertValue(D);
+}
+
+int SlotCalculator::insertType(const Type *Ty, bool dontIgnore) {
+ assert(Ty && "Can't insert a null type!");
+ assert(getSlot(Ty) == -1 && "Type is already in the table!");
+
+ // If we are building a compaction map, and if this plane is being compacted,
+ // insert the value into the compaction map, not into the global map.
+ if (!CompactionTypeMap.empty()) {
+ getOrCreateCompactionTableSlot(Ty);
+ }
+
+ // Insert the current type before any subtypes. This is important because
+ // recursive types elements are inserted in a bottom up order. Changing
+ // this here can break things. For example:
+ //
+ // global { \2 * } { { \2 }* null }
+ //
+ int ResultSlot = doInsertType(Ty);
+ SC_DEBUG(" Inserted type: " << Ty->getDescription() << " slot=" <<
+ ResultSlot << "\n");
+
+ // Loop over any contained types in the definition... in post
+ // order.
+ for (po_iterator<const Type*> I = po_begin(Ty), E = po_end(Ty);
+ I != E; ++I) {
+ if (*I != Ty) {
+ const Type *SubTy = *I;
+ // If we haven't seen this sub type before, add it to our type table!
+ if (getSlot(SubTy) == -1) {
+ SC_DEBUG(" Inserting subtype: " << SubTy->getDescription() << "\n");
+ doInsertType(SubTy);
+ SC_DEBUG(" Inserted subtype: " << SubTy->getDescription() << "\n");
+ }
+ }
+ }
+ return ResultSlot;
+}
+
+// doInsertValue - This is a small helper function to be called only
+// be insertValue.
+//
+int SlotCalculator::doInsertValue(const Value *D) {
+ const Type *Typ = D->getType();
+ unsigned Ty;
+
+ // Used for debugging DefSlot=-1 assertion...
+ //if (Typ == Type::TypeTy)
+ // cerr << "Inserting type '" << cast<Type>(D)->getDescription() << "'!\n";
+
+ if (Typ->isDerivedType()) {
+ int ValSlot;
+ if (CompactionTable.empty())
+ ValSlot = getSlot(Typ);
+ else
+ ValSlot = getGlobalSlot(Typ);
+ if (ValSlot == -1) { // Have we already entered this type?
+ // Nope, this is the first we have seen the type, process it.
+ ValSlot = insertType(Typ, true);
+ assert(ValSlot != -1 && "ProcessType returned -1 for a type?");
+ }
+ Ty = (unsigned)ValSlot;
+ } else {
+ Ty = Typ->getTypeID();
+ }
+
+ if (Table.size() <= Ty) // Make sure we have the type plane allocated...
+ Table.resize(Ty+1, TypePlane());
+
+ // If this is the first value to get inserted into the type plane, make sure
+ // to insert the implicit null value...
+ if (Table[Ty].empty() && hasNullValue(Typ)) {
+ Value *ZeroInitializer = Constant::getNullValue(Typ);
+
+ // If we are pushing zeroinit, it will be handled below.
+ if (D != ZeroInitializer) {
+ Table[Ty].push_back(ZeroInitializer);
+ NodeMap[ZeroInitializer] = 0;
+ }
+ }
+
+ // Insert node into table and NodeMap...
+ unsigned DestSlot = NodeMap[D] = Table[Ty].size();
+ Table[Ty].push_back(D);
+
+ SC_DEBUG(" Inserting value [" << Ty << "] = " << D << " slot=" <<
+ DestSlot << " [");
+ // G = Global, C = Constant, T = Type, F = Function, o = other
+ SC_DEBUG((isa<GlobalVariable>(D) ? "G" : (isa<Constant>(D) ? "C" :
+ (isa<Function>(D) ? "F" : "o"))));
+ SC_DEBUG("]\n");
+ return (int)DestSlot;
+}
+
+// doInsertType - This is a small helper function to be called only
+// be insertType.
+//
+int SlotCalculator::doInsertType(const Type *Ty) {
+
+ // Insert node into table and NodeMap...
+ unsigned DestSlot = TypeMap[Ty] = Types.size();
+ Types.push_back(Ty);
+
+ SC_DEBUG(" Inserting type [" << DestSlot << "] = " << Ty << "\n" );
+ return (int)DestSlot;
+}
+
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
new file mode 100644
index 0000000000..63927ca814
--- /dev/null
+++ b/lib/Bytecode/Writer/SlotCalculator.h
@@ -0,0 +1,182 @@
+//===-- Analysis/SlotCalculator.h - Calculate value slots -------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class calculates the slots that values will land in. This is useful for
+// when writing bytecode or assembly out, because you have to know these things.
+//
+// Specifically, this class calculates the "type plane numbering" that you see
+// for a function if you strip out all of the symbols in it. For assembly
+// writing, this is used when a symbol does not have a name. For bytecode
+// writing, this is always used, and the symbol table is added on later.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
+#define LLVM_ANALYSIS_SLOTCALCULATOR_H
+
+#include <vector>
+#include <map>
+
+namespace llvm {
+
+class Value;
+class Type;
+class Module;
+class Function;
+class SymbolTable;
+class ConstantArray;
+
+class SlotCalculator {
+ const Module *TheModule;
+
+ typedef std::vector<const Type*> TypeList;
+ typedef std::vector<const Value*> TypePlane;
+ std::vector<TypePlane> Table;
+ TypeList Types;
+ typedef std::map<const Value*, unsigned> NodeMapType;
+ NodeMapType NodeMap;
+
+ typedef std::map<const Type*, unsigned> TypeMapType;
+ TypeMapType TypeMap;
+
+ /// ConstantStrings - If we are indexing for a bytecode file, this keeps track
+ /// of all of the constants strings that need to be emitted.
+ std::vector<const ConstantArray*> ConstantStrings;
+
+ /// ModuleLevel - Used to keep track of which values belong to the module,
+ /// and which values belong to the currently incorporated function.
+ ///
+ std::vector<unsigned> ModuleLevel;
+ unsigned ModuleTypeLevel;
+
+ /// ModuleContainsAllFunctionConstants - This flag is set to true if all
+ /// function constants are incorporated into the module constant table. This
+ /// is only possible if building information for a bytecode file.
+ bool ModuleContainsAllFunctionConstants;
+
+ /// CompactionTable/NodeMap - When function compaction has been performed,
+ /// these entries provide a compacted view of the namespace needed to emit
+ /// instructions in a function body. The 'getSlot()' method automatically
+ /// returns these entries if applicable, or the global entries if not.
+ std::vector<TypePlane> CompactionTable;
+ TypeList CompactionTypes;
+ typedef std::map<const Value*, unsigned> CompactionNodeMapType;
+ CompactionNodeMapType CompactionNodeMap;
+ typedef std::map<const Type*, unsigned> CompactionTypeMapType;
+ CompactionTypeMapType CompactionTypeMap;
+
+ SlotCalculator(const SlotCalculator &); // DO NOT IMPLEMENT
+ void operator=(const SlotCalculator &); // DO NOT IMPLEMENT
+public:
+ SlotCalculator(const Module *M );
+ // Start out in incorp state
+ SlotCalculator(const Function *F );
+
+ /// getSlot - Return the slot number of the specified value in it's type
+ /// plane. This returns < 0 on error!
+ ///
+ int getSlot(const Value *V) const;
+ int getSlot(const Type* T) const;
+
+ /// getGlobalSlot - Return a slot number from the global table. This can only
+ /// be used when a compaction table is active.
+ unsigned getGlobalSlot(const Value *V) const;
+ unsigned getGlobalSlot(const Type *V) const;
+
+ inline unsigned getNumPlanes() const {
+ if (CompactionTable.empty())
+ return Table.size();
+ else
+ return CompactionTable.size();
+ }
+
+ inline unsigned getNumTypes() const {
+ if (CompactionTypes.empty())
+ return Types.size();
+ else
+ return CompactionTypes.size();
+ }
+
+ inline unsigned getModuleLevel(unsigned Plane) const {
+ return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0;
+ }
+
+ /// Returns the number of types in the type list that are at module level
+ inline unsigned getModuleTypeLevel() const {
+ return ModuleTypeLevel;
+ }
+
+ TypePlane &getPlane(unsigned Plane);
+ TypeList& getTypes() {
+ if (!CompactionTypes.empty())
+ return CompactionTypes;
+ return Types;
+ }
+
+ /// incorporateFunction/purgeFunction - If you'd like to deal with a function,
+ /// use these two methods to get its data into the SlotCalculator!
+ ///
+ void incorporateFunction(const Function *F);
+ void purgeFunction();
+
+ /// string_iterator/string_begin/end - Access the list of module-level
+ /// constant strings that have been incorporated. This is only applicable to
+ /// bytecode files.
+ typedef std::vector<const ConstantArray*>::const_iterator string_iterator;
+ string_iterator string_begin() const { return ConstantStrings.begin(); }
+ string_iterator string_end() const { return ConstantStrings.end(); }
+
+ const std::vector<TypePlane> &getCompactionTable() const {
+ return CompactionTable;
+ }
+
+ const TypeList& getCompactionTypes() const { return CompactionTypes; }
+
+ /// @brief Determine if the compaction table (not types) is empty
+ bool CompactionTableIsEmpty() const;
+
+private:
+ // getOrCreateSlot - Values can be crammed into here at will... if
+ // they haven't been inserted already, they get inserted, otherwise
+ // they are ignored.
+ //
+ int getOrCreateSlot(const Value *D);
+ int getOrCreateSlot(const Type* T);
+
+ // insertValue - Insert a value into the value table... Return the
+ // slot that it occupies, or -1 if the declaration is to be ignored
+ // because of the IgnoreNamedNodes flag.
+ //
+ int insertValue(const Value *D, bool dontIgnore = false);
+ int insertType(const Type* T, bool dontIgnore = false );
+
+ // doInsertValue - Small helper function to be called only be insertVal.
+ int doInsertValue(const Value *D);
+ int doInsertType(const Type*T);
+
+ // processModule - Process all of the module level function declarations and
+ // types that are available.
+ //
+ void processModule();
+
+ // processSymbolTable - Insert all of the values in the specified symbol table
+ // into the values table...
+ //
+ void processSymbolTable(const SymbolTable *ST);
+ void processSymbolTableConstants(const SymbolTable *ST);
+
+ void buildCompactionTable(const Function *F);
+ unsigned getOrCreateCompactionTableSlot(const Value *V);
+ unsigned getOrCreateCompactionTableSlot(const Type *V);
+ void pruneCompactionTable();
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/lib/Bytecode/Writer/SlotTable.h b/lib/Bytecode/Writer/SlotTable.h
new file mode 100644
index 0000000000..78d9ea2710
--- /dev/null
+++ b/lib/Bytecode/Writer/SlotTable.h
@@ -0,0 +1,191 @@
+//===-- Internal/SlotTable.h - Type/Value Slot Holder -----------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares the SlotTable class for type plane numbering.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_INTERNAL_SLOTTABLE_H
+#define LLVM_INTERNAL_SLOTTABLE_H
+
+#include <vector>
+#include <map>
+
+namespace llvm {
+
+// Forward declarations
+class Value;
+class Type;
+class Module;
+class Function;
+class SymbolTable;
+class ConstantArray;
+
+/// This class is the common abstract data type for both the SlotMachine and
+/// the SlotCalculator. It provides the two-way mapping between Values and
+/// Slots as well as the two-way mapping between Types and Slots. For Values,
+/// the slot number can be extracted by simply using the getSlot()
+/// method and passing in the Value. For Types, it is the same.
+/// @brief Abstract data type for slot numbers.
+class SlotTable
+{
+/// @name Types
+/// @{
+public:
+
+ /// This type is used throughout the code to make it clear that
+ /// an unsigned value refers to a Slot number and not something else.
+ /// @brief Type slot number identification type.
+ typedef unsigned SlotNum;
+
+ /// This type is used throughout the code to make it clear that an
+ /// unsigned value refers to a type plane number and not something else.
+ /// @brief The type of a plane number (corresponds to Type::TypeID).
+ typedef unsigned PlaneNum;
+
+ /// @brief Some constants used as flags instead of actual slot numbers
+ enum Constants {
+ MAX_SLOT = 4294967294U,
+ BAD_SLOT = 4294967295U
+ };
+
+ /// @brief A single plane of Values. Intended index is slot number.
+ typedef std::vector<const Value*> ValuePlane;
+
+ /// @brief A table of Values. Intended index is Type::TypeID.
+ typedef std::vector<ValuePlane> ValueTable;
+
+ /// @brief A map of values to slot numbers.
+ typedef std::map<const Value*,SlotNum> ValueMap;
+
+ /// @brief A single plane of Types. Intended index is slot number.
+ typedef std::vector<const Type*> TypePlane;
+
+ /// @brief A map of types to slot numbers.
+ typedef std::map<const Type*,SlotNum> TypeMap;
+
+/// @}
+/// @name Constructors
+/// @{
+public:
+ /// This constructor initializes all the containers in the SlotTable
+ /// to empty and then inserts all the primitive types into the type plane
+ /// by default. This is done as a convenience since most uses of the
+ /// SlotTable will need the primitive types. If you don't need them, pass
+ /// in true.
+ /// @brief Default Constructor
+ explicit SlotTable(
+ bool dont_insert_primitives = false ///< Control insertion of primitives.
+ );
+
+/// @}
+/// @name Accessors
+/// @{
+public:
+ /// @brief Get the number of planes of values.
+ size_t value_size() const { return vTable.size(); }
+
+ /// @brief Determine if a specific type plane in the value table exists
+ bool plane_exists(PlaneNum plane) const {
+ return vTable.size() > plane;
+ }
+
+ /// @brief Determine if a specific type plane in the value table is empty
+ bool plane_empty(PlaneNum plane) const {
+ return (plane_exists(plane) ? vTable[plane].empty() : true);
+ }
+
+ /// @brief Get the number of entries in a specific plane of the value table
+ size_t plane_size(PlaneNum plane) const {
+ return (plane_exists(plane) ? vTable[plane].size() : 0 );
+ }
+
+ /// @returns true if the slot table is completely empty.
+ /// @brief Determine if the SlotTable is empty.
+ bool empty() const;
+
+ /// @returns the slot number or BAD_SLOT if Val is not in table.
+ /// @brief Get a slot number for a Value.
+ SlotNum getSlot(const Value* Val) const;
+
+ /// @returns the slot number or BAD_SLOT if Type is not in the table.
+ /// @brief Get a slot number for a Type.
+ SlotNum getSlot(const Type* Typ) const;
+
+ /// @returns true iff the Value is in the table.
+ /// @brief Determine if a Value has a slot number.
+ bool hasSlot(const Value* Val) { return getSlot(Val) != BAD_SLOT; }
+
+ /// @returns true iff the Type is in the table.
+ /// @brief Determine if a Type has a slot number.
+ bool hasSlot(const Type* Typ) { return getSlot(Typ) != BAD_SLOT; }
+
+/// @}
+/// @name Mutators
+/// @{
+public:
+ /// @brief Completely clear the SlotTable;
+ void clear();
+
+ /// @brief Resize the table to incorporate at least \p new_size planes
+ void resize( size_t new_size );
+
+ /// @returns the slot number of the newly inserted value in its plane
+ /// @brief Add a Value to the SlotTable
+ SlotNum insert(const Value* Val, PlaneNum plane );
+
+ /// @returns the slot number of the newly inserted type
+ /// @brief Add a Type to the SlotTable
+ SlotNum insert( const Type* Typ );
+
+ /// @returns the slot number that \p Val had when it was in the table
+ /// @brief Remove a Value from the SlotTable
+ SlotNum remove( const Value* Val, PlaneNum plane );
+
+ /// @returns the slot number that \p Typ had when it was in the table
+ /// @brief Remove a Type from the SlotTable
+ SlotNum remove( const Type* Typ );
+
+/// @}
+/// @name Implementation Details
+/// @{
+private:
+ /// Insert the primitive types into the type plane. This is called
+ /// by the constructor to initialize the type plane.
+ void insertPrimitives();
+
+/// @}
+/// @name Data
+/// @{
+private:
+ /// A two dimensional table of Values indexed by type and slot number. This
+ /// allows for efficient lookup of a Value by its type and slot number.
+ ValueTable vTable;
+
+ /// A map of Values to unsigned integer. This allows for efficient lookup of
+ /// A Value's slot number in its type plane.
+ ValueMap vMap;
+
+ /// A one dimensional vector of Types indexed by slot number. Types are
+ /// handled separately because they are not Values.
+ TypePlane tPlane;
+
+ /// A map of Types to unsigned integer. This allows for efficient lookup of
+ /// a Type's slot number in the type plane.
+ TypeMap tMap;
+
+/// @}
+
+};
+
+} // End llvm namespace
+
+// vim: sw=2
+
+#endif
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
new file mode 100644
index 0000000000..b1f2634296
--- /dev/null
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -0,0 +1,1175 @@
+//===-- Writer.cpp - Library for writing LLVM bytecode files --------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This library implements the functionality defined in llvm/Bytecode/Writer.h
+//
+// Note that this file uses an unusual technique of outputting all the bytecode
+// to a vector of unsigned char, then copies the vector to an ostream. The
+// reason for this is that we must do "seeking" in the stream to do back-
+// patching, and some very important ostreams that we want to support (like
+// pipes) do not support seeking. :( :( :(
+//
+//===----------------------------------------------------------------------===//
+
+#include "WriterInternals.h"
+#include "llvm/Bytecode/WriteBytecodePass.h"
+#include "llvm/CallingConv.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/SymbolTable.h"
+#include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/Compressor.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Statistic.h"
+#include <cstring>
+#include <algorithm>
+using namespace llvm;
+
+/// This value needs to be incremented every time the bytecode format changes
+/// so that the reader can distinguish which format of the bytecode file has
+/// been written.
+/// @brief The bytecode version number
+const unsigned BCVersionNum = 5;
+
+static RegisterPass<WriteBytecodePass> X("emitbytecode", "Bytecode Writer");
+
+static Statistic<>
+BytesWritten("bytecodewriter", "Number of bytecode bytes written");
+
+//===----------------------------------------------------------------------===//
+//=== Output Primitives ===//
+//===----------------------------------------------------------------------===//
+
+// output - If a position is specified, it must be in the valid portion of the
+// string... note that this should be inlined always so only the relevant IF
+// body should be included.
+inline void BytecodeWriter::output(unsigned i, int pos) {
+ if (pos == -1) { // Be endian clean, little endian is our friend
+ Out.push_back((unsigned char)i);
+ Out.push_back((unsigned char)(i >> 8));
+ Out.push_back((unsigned char)(i >> 16));
+ Out.push_back((unsigned char)(i >> 24));
+ } else {
+ Out[pos ] = (unsigned char)i;
+ Out[pos+1] = (unsigned char)(i >> 8);
+ Out[pos+2] = (unsigned char)(i >> 16);
+ Out[pos+3] = (unsigned char)(i >> 24);
+ }
+}
+
+inline void BytecodeWriter::output(int i) {
+ output((unsigned)i);
+}
+
+/// output_vbr - Output an unsigned value, by using the least number of bytes
+/// possible. This is useful because many of our "infinite" values are really
+/// very small most of the time; but can be large a few times.
+/// Data format used: If you read a byte with the high bit set, use the low
+/// seven bits as data and then read another byte.
+inline void BytecodeWriter::output_vbr(uint64_t i) {
+ while (1) {
+ if (i < 0x80) { // done?
+ Out.push_back((unsigned char)i); // We know the high bit is clear...
+ return;
+ }
+
+ // Nope, we are bigger than a character, output the next 7 bits and set the
+ // high bit to say that there is more coming...
+ Out.push_back(0x80 | ((unsigned char)i & 0x7F));
+ i >>= 7; // Shift out 7 bits now...
+ }
+}
+
+inline void BytecodeWriter::output_vbr(unsigned i) {
+ while (1) {
+ if (i < 0x80) { // done?
+ Out.push_back((unsigned char)i); // We know the high bit is clear...
+ return;
+ }
+
+ // Nope, we are bigger than a character, output the next 7 bits and set the
+ // high bit to say that there is more coming...
+ Out.push_back(0x80 | ((unsigned char)i & 0x7F));
+ i >>= 7; // Shift out 7 bits now...
+ }
+}
+
+inline void BytecodeWriter::output_typeid(unsigned i) {
+ if (i <= 0x00FFFFFF)
+ this->output_vbr(i);
+ else {
+ this->output_vbr(0x00FFFFFF);
+ this->output_vbr(i);
+ }
+}
+
+inline void BytecodeWriter::output_vbr(int64_t i) {
+ if (i < 0)
+ output_vbr(((uint64_t)(-i) << 1) | 1); // Set low order sign bit...
+ else
+ output_vbr((uint64_t)i << 1); // Low order bit is clear.
+}
+
+
+inline void BytecodeWriter::output_vbr(int i) {
+ if (i < 0)
+ output_vbr(((unsigned)(-i) << 1) | 1); // Set low order sign bit...
+ else
+ output_vbr((unsigned)i << 1); // Low order bit is clear.
+}
+
+inline void BytecodeWriter::output(const std::string &s) {
+ unsigned Len = s.length();
+ output_vbr(Len ); // Strings may have an arbitrary length...
+ Out.insert(Out.end(), s.begin(), s.end());
+}
+
+inline void BytecodeWriter::output_data(const void *Ptr, const void *End) {
+ Out.insert(Out.end(), (const unsigned char*)Ptr, (const unsigned char*)End);
+}
+
+inline void BytecodeWriter::output_float(float& FloatVal) {
+ /// FIXME: This isn't optimal, it has size problems on some platforms
+ /// where FP is not IEEE.
+ uint32_t i = FloatToBits(FloatVal);
+ Out.push_back( static_cast<unsigned char>( (i & 0xFF )));
+ Out.push_back( static_cast<unsigned char>( (i >> 8) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 16) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 24) & 0xFF));
+}
+
+inline void BytecodeWriter::output_double(double& DoubleVal) {
+ /// FIXME: This isn't optimal, it has size problems on some platforms
+ /// where FP is not IEEE.
+ uint64_t i = DoubleToBits(DoubleVal);
+ Out.push_back( static_cast<unsigned char>( (i & 0xFF )));
+ Out.push_back( static_cast<unsigned char>( (i >> 8) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 16) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 24) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 32) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 40) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 48) & 0xFF));
+ Out.push_back( static_cast<unsigned char>( (i >> 56) & 0xFF));
+}
+
+inline BytecodeBlock::BytecodeBlock(unsigned ID, BytecodeWriter& w,
+ bool elideIfEmpty, bool hasLongFormat )
+ : Id(ID), Writer(w), ElideIfEmpty(elideIfEmpty), HasLongFormat(hasLongFormat){
+
+ if (HasLongFormat) {
+ w.output(ID);
+ w.output(0U); // For length in long format
+ } else {
+ w.output(0U); /// Place holder for ID and length for this block
+ }
+ Loc = w.size();
+}
+
+inline BytecodeBlock::~BytecodeBlock() { // Do backpatch when block goes out
+ // of scope...
+ if (Loc == Writer.size() && ElideIfEmpty) {
+ // If the block is empty, and we are allowed to, do not emit the block at
+ // all!
+ Writer.resize(Writer.size()-(HasLongFormat?8:4));
+ return;
+ }
+
+ if (HasLongFormat)
+ Writer.output(unsigned(Writer.size()-Loc), int(Loc-4));
+ else
+ Writer.output(unsigned(Writer.size()-Loc) << 5 | (Id & 0x1F), int(Loc-4));
+}
+
+//===----------------------------------------------------------------------===//
+//=== Constant Output ===//
+//===----------------------------------------------------------------------===//
+
+void BytecodeWriter::outputType(const Type *T) {
+ output_vbr((unsigned)T->getTypeID());
+
+ // That's all there is to handling primitive types...
+ if (T->isPrimitiveType()) {
+ return; // We might do this if we alias a prim type: %x = type int
+ }
+
+ switch (T->getTypeID()) { // Handle derived types now.
+ case Type::FunctionTyID: {
+ const FunctionType *MT = cast<FunctionType>(T);
+ int Slot = Table.getSlot(MT->getReturnType());
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+
+ // Output the number of arguments to function (+1 if varargs):
+ output_vbr((unsigned)MT->getNumParams()+MT->isVarArg());
+
+ // Output all of the arguments...
+ FunctionType::param_iterator I = MT->param_begin();
+ for (; I != MT->param_end(); ++I) {
+ Slot = Table.getSlot(*I);
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+ }
+
+ // Terminate list with VoidTy if we are a varargs function...
+ if (MT->isVarArg())
+ output_typeid((unsigned)Type::VoidTyID);
+ break;
+ }
+
+ case Type::ArrayTyID: {
+ const ArrayType *AT = cast<ArrayType>(T);
+ int Slot = Table.getSlot(AT->getElementType());
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+ output_vbr(AT->getNumElements());
+ break;
+ }
+
+ case Type::PackedTyID: {
+ const PackedType *PT = cast<PackedType>(T);
+ int Slot = Table.getSlot(PT->getElementType());
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+ output_vbr(PT->getNumElements());
+ break;
+ }
+
+
+ case Type::StructTyID: {
+ const StructType *ST = cast<StructType>(T);
+
+ // Output all of the element types...
+ for (StructType::element_iterator I = ST->element_begin(),
+ E = ST->element_end(); I != E; ++I) {
+ int Slot = Table.getSlot(*I);
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+ }
+
+ // Terminate list with VoidTy
+ output_typeid((unsigned)Type::VoidTyID);
+ break;
+ }
+
+ case Type::PointerTyID: {
+ const PointerType *PT = cast<PointerType>(T);
+ int Slot = Table.getSlot(PT->getElementType());
+ assert(Slot != -1 && "Type used but not available!!");
+ output_typeid((unsigned)Slot);
+ break;
+ }
+
+ case Type::OpaqueTyID:
+ // No need to emit anything, just the count of opaque types is enough.
+ break;
+
+ default:
+ std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
+ << " Type '" << T->getDescription() << "'\n";
+ break;
+ }
+}
+
+void BytecodeWriter::outputConstant(const Constant *CPV) {
+ assert((CPV->getType()->isPrimitiveType() || !CPV->isNullValue()) &&
+ "Shouldn't output null constants!");
+
+ // We must check for a ConstantExpr before switching by type because
+ // a ConstantExpr can be of any type, and has no explicit value.
+ //
+ if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
+ // FIXME: Encoding of constant exprs could be much more compact!
+ assert(CE->getNumOperands() > 0 && "ConstantExpr with 0 operands");
+ assert(CE->getNumOperands() != 1 || CE->getOpcode() == Instruction::Cast);
+ output_vbr(1+CE->getNumOperands()); // flags as an expr
+ output_vbr(CE->getOpcode()); // flags as an expr
+
+ for (User::const_op_iterator OI = CE->op_begin(); OI != CE->op_end(); ++OI){
+ int Slot = Table.getSlot(*OI);
+ assert(Slot != -1 && "Unknown constant used in ConstantExpr!!");
+ output_vbr((unsigned)Slot);
+ Slot = Table.getSlot((*OI)->getType());
+ output_typeid((unsigned)Slot);
+ }
+ return;
+ } else if (isa<UndefValue>(CPV)) {
+ output_vbr(1U); // 1 -> UndefValue constant.
+ return;
+ } else {
+ output_vbr(0U); // flag as not a ConstantExpr
+ }
+
+ switch (CPV->getType()->getTypeID()) {
+ case Type::BoolTyID: // Boolean Types
+ if (cast<ConstantBool>(CPV)->getValue())
+ output_vbr(1U);
+ else
+ output_vbr(0U);
+ break;
+
+ case Type::UByteTyID: // Unsigned integer types...
+ case Type::UShortTyID:
+ case Type::UIntTyID:
+ case Type::ULongTyID:
+ output_vbr(cast<ConstantUInt>(CPV)->getValue());
+ break;
+
+ case Type::SByteTyID: // Signed integer types...
+ case Type::ShortTyID:
+ case Type::IntTyID:
+ case Type::LongTyID:
+ output_vbr(cast<ConstantSInt>(CPV)->getValue());
+ break;
+
+ case Type::ArrayTyID: {
+ const ConstantArray *CPA = cast<ConstantArray>(CPV);
+ assert(!CPA->isString() && "Constant strings should be handled specially!");
+
+ for (unsigned i = 0, e = CPA->getNumOperands(); i != e; ++i) {
+ int Slot = Table.getSlot(CPA->getOperand(i));
+ assert(Slot != -1 && "Constant used but not available!!");
+ output_vbr((unsigned)Slot);
+ }
+ break;
+ }
+
+ case Type::PackedTyID: {
+ const ConstantPacked *CP = cast<ConstantPacked>(CPV);
+
+ for (unsigned i = 0, e = CP->getNumOperands(); i != e; ++i) {
+ int Slot = Table.getSlot(CP->getOperand(i));
+ assert(Slot != -1 && "Constant used but not available!!");
+ output_vbr((unsigned)Slot);
+ }
+ break;
+ }
+
+ case Type::StructTyID: {
+ const ConstantStruct *CPS = cast<ConstantStruct>(CPV);
+
+ for (unsigned i = 0, e = CPS->getNumOperands(); i != e; ++i) {
+ int Slot = Table.getSlot(CPS->getOperand(i));
+ assert(Slot != -1 && "Constant used but not available!!");
+ output_vbr((unsigned)Slot);
+ }
+ break;
+ }
+
+ case Type::PointerTyID:
+ assert(0 && "No non-null, non-constant-expr constants allowed!");
+ abort();
+
+ case Type::FloatTyID: { // Floating point types...
+ float Tmp = (float)cast<ConstantFP>(CPV)->getValue();
+ output_float(Tmp);
+ break;
+ }
+ case Type::DoubleTyID: {
+ double Tmp = cast<ConstantFP>(CPV)->getValue();
+ output_double(Tmp);
+ break;
+ }
+
+ case Type::VoidTyID:
+ case Type::LabelTyID:
+ default:
+ std::cerr << __FILE__ << ":" << __LINE__ << ": Don't know how to serialize"
+ << " type '" << *CPV->getType() << "'\n";
+ break;
+ }
+ return;
+}
+
+void BytecodeWriter::outputConstantStrings() {
+ SlotCalculator::string_iterator I = Table.string_begin();
+ SlotCalculator::string_iterator E = Table.string_end();
+ if (I == E) return; // No strings to emit
+
+ // If we have != 0 strings to emit, output them now. Strings are emitted into
+ // the 'void' type plane.
+ output_vbr(unsigned(E-I));
+ output_typeid(Type::VoidTyID);
+
+ // Emit all of the strings.
+ for (I = Table.string_begin(); I != E; ++I) {
+ const ConstantArray *Str = *I;
+ int Slot = Table.getSlot(Str->getType());
+ assert(Slot != -1 && "Constant string of unknown type?");
+ output_typeid((unsigned)Slot);
+
+ // Now that we emitted the type (which indicates the size of the string),
+ // emit all of the characters.
+ std::string Val = Str->getAsString();
+ output_data(Val.c_str(), Val.c_str()+Val.size());
+ }
+}
+
+//===----------------------------------------------------------------------===//
+//=== Instruction Output ===//
+//===----------------------------------------------------------------------===//
+typedef unsigned char uchar;
+
+// outputInstructionFormat0 - Output those weird instructions that have a large
+// number of operands or have large operands themselves.
+//
+// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
+//
+void BytecodeWriter::outputInstructionFormat0(const Instruction *I,
+ unsigned Opcode,
+ const SlotCalculator &Table,
+ unsigned Type) {
+ // Opcode must have top two bits clear...
+ output_vbr(Opcode << 2); // Instruction Opcode ID
+ output_typeid(Type); // Result type
+
+ unsigned NumArgs = I->getNumOperands();
+ output_vbr(NumArgs + (isa<CastInst>(I) ||
+ isa<VAArgInst>(I) || Opcode == 56 || Opcode == 58));
+
+ if (!isa<GetElementPtrInst>(&I)) {
+ for (unsigned i = 0; i < NumArgs; ++i) {
+ int Slot = Table.getSlot(I->getOperand(i));
+ assert(Slot >= 0 && "No slot number for value!?!?");
+ output_vbr((unsigned)Slot);
+ }
+
+ if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
+ int Slot = Table.getSlot(I->getType());
+ assert(Slot != -1 && "Cast return type unknown?");
+ output_typeid((unsigned)Slot);
+ } else if (Opcode == 56) { // Invoke escape sequence
+ output_vbr(cast<InvokeInst>(I)->getCallingConv());
+ } else if (Opcode == 58) { // Call escape sequence
+ output_vbr((cast<CallInst>(I)->getCallingConv() << 1) |
+ unsigned(cast<CallInst>(I)->isTailCall()));
+ }
+ } else {
+ int Slot = Table.getSlot(I->getOperand(0));
+ assert(Slot >= 0 && "No slot number for value!?!?");
+ output_vbr(unsigned(Slot));
+
+ // We need to encode the type of sequential type indices into their slot #
+ unsigned Idx = 1;
+ for (gep_type_iterator TI = gep_type_begin(I), E = gep_type_end(I);
+ Idx != NumArgs; ++TI, ++Idx) {
+ Slot = Table.getSlot(I->getOperand(Idx));
+ assert(Slot >= 0 && "No slot number for value!?!?");
+
+ if (isa<SequentialType>(*TI)) {
+ unsigned IdxId;
+ switch (I->getOperand(Idx)->getType()->getTypeID()) {
+ default: assert(0 && "Unknown index type!");
+ case Type::UIntTyID: IdxId = 0; break;
+ case Type::IntTyID: IdxId = 1; break;
+ case Type::ULongTyID: IdxId = 2; break;
+ case Type::LongTyID: IdxId = 3; break;
+ }
+ Slot = (Slot << 2) | IdxId;
+ }
+ output_vbr(unsigned(Slot));
+ }
+ }
+}
+
+
+// outputInstrVarArgsCall - Output the absurdly annoying varargs function calls.
+// This are more annoying than most because the signature of the call does not
+// tell us anything about the types of the arguments in the varargs portion.
+// Because of this, we encode (as type 0) all of the argument types explicitly
+// before the argument value. This really sucks, but you shouldn't be using
+// varargs functions in your code! *death to printf*!
+//
+// Format: [opcode] [type] [numargs] [arg0] [arg1] ... [arg<numargs-1>]
+//
+void BytecodeWriter::outputInstrVarArgsCall(const Instruction *I,
+ unsigned Opcode,
+ const SlotCalculator &Table,
+ unsigned Type) {
+ assert(isa<CallInst>(I) || isa<InvokeInst>(I));
+ // Opcode must have top two bits clear...
+ output_vbr(Opcode << 2); // Instruction Opcode ID
+ output_typeid(Type); // Result type (varargs type)
+
+ const PointerType *PTy = cast<PointerType>(I->getOperand(0)->getType());
+ const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
+ unsigned NumParams = FTy->getNumParams();
+
+ unsigned NumFixedOperands;
+ if (isa<CallInst>(I)) {
+ // Output an operand for the callee and each fixed argument, then two for
+ // each variable argument.
+ NumFixedOperands = 1+NumParams;
+ } else {
+ assert(isa<InvokeInst>(I) && "Not call or invoke??");
+ // Output an operand for the callee and destinations, then two for each
+ // variable argument.
+ NumFixedOperands = 3+NumParams;
+ }
+ output_vbr(2 * I->getNumOperands()-NumFixedOperands);
+
+ // The type for the function has already been emitted in the type field of the
+ // instruction. Just emit the slot # now.
+ for (unsigned i = 0; i != NumFixedOperands; ++i) {
+ int Slot = Table.getSlot(I->getOperand(i));
+ assert(Slot >= 0 && "No slot number for value!?!?");
+ output_vbr((unsigned)Slot);
+ }
+
+ for (unsigned i = NumFixedOperands, e = I->getNumOperands(); i != e; ++i) {
+ // Output Arg Type ID
+ int Slot = Table.getSlot(I->getOperand(i)->getType());
+ assert(Slot >= 0 && "No slot number for value!?!?");
+ output_typeid((unsigned)Slot);
+
+ // Output arg ID itself
+ Slot = Table.getSlot(I->getOperand(i));
+ assert(Slot >= 0 && "No slot number for value!?!?");
+ output_vbr((unsigned)Slot);
+ }
+}
+
+
+// outputInstructionFormat1 - Output one operand instructions, knowing that no
+// operand index is >= 2^12.
+//
+inline void BytecodeWriter::outputInstructionFormat1(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) {
+ // bits Instruction format:
+ // --------------------------
+ // 01-00: Opcode type, fixed to 1.
+ // 07-02: Opcode
+ // 19-08: Resulting type plane
+ // 31-20: Operand #1 (if set to (2^12-1), then zero operands)
+ //
+ output(1 | (Opcode << 2) | (Type << 8) | (Slots[0] << 20));
+}
+
+
+// outputInstructionFormat2 - Output two operand instructions, knowing that no
+// operand index is >= 2^8.
+//
+inline void BytecodeWriter::outputInstructionFormat2(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) {
+ // bits Instruction format:
+ // --------------------------
+ // 01-00: Opcode type, fixed to 2.
+ // 07-02: Opcode
+ // 15-08: Resulting type plane
+ // 23-16: Operand #1
+ // 31-24: Operand #2
+ //
+ output(2 | (Opcode << 2) | (Type << 8) | (Slots[0] << 16) | (Slots[1] << 24));
+}
+
+
+// outputInstructionFormat3 - Output three operand instructions, knowing that no
+// operand index is >= 2^6.
+//
+inline void BytecodeWriter::outputInstructionFormat3(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) {
+ // bits Instruction format:
+ // --------------------------
+ // 01-00: Opcode type, fixed to 3.
+ // 07-02: Opcode
+ // 13-08: Resulting type plane
+ // 19-14: Operand #1
+ // 25-20: Operand #2
+ // 31-26: Operand #3
+ //
+ output(3 | (Opcode << 2) | (Type << 8) |
+ (Slots[0] << 14) | (Slots[1] << 20) | (Slots[2] << 26));
+}
+
+void BytecodeWriter::outputInstruction(const Instruction &I) {
+ assert(I.getOpcode() < 56 && "Opcode too big???");
+ unsigned Opcode = I.getOpcode();
+ unsigned NumOperands = I.getNumOperands();
+
+ // Encode 'tail call' as 61, 'volatile load' as 62, and 'volatile store' as
+ // 63.
+ if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
+ if (CI->getCallingConv() == CallingConv::C) {
+ if (CI->isTailCall())
+ Opcode = 61; // CCC + Tail Call
+ else
+ ; // Opcode = Instruction::Call
+ } else if (CI->getCallingConv() == CallingConv::Fast) {
+ if (CI->isTailCall())
+ Opcode = 59; // FastCC + TailCall
+ else
+ Opcode = 60; // FastCC + Not Tail Call
+ } else {
+ Opcode = 58; // Call escape sequence.
+ }
+ } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
+ if (II->getCallingConv() == CallingConv::Fast)
+ Opcode = 57; // FastCC invoke.
+ else if (II->getCallingConv() != CallingConv::C)
+ Opcode = 56; // Invoke escape sequence.
+
+ } else if (isa<LoadInst>(I) && cast<LoadInst>(I).isVolatile()) {
+ Opcode = 62;
+ } else if (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) {
+ Opcode = 63;
+ }
+
+ // Figure out which type to encode with the instruction. Typically we want
+ // the type of the first parameter, as opposed to the type of the instruction
+ // (for example, with setcc, we always know it returns bool, but the type of
+ // the first param is actually interesting). But if we have no arguments
+ // we take the type of the instruction itself.
+ //
+ const Type *Ty;
+ switch (I.getOpcode()) {
+ case Instruction::Select:
+ case Instruction::Malloc:
+ case Instruction::Alloca:
+ Ty = I.getType(); // These ALWAYS want to encode the return type
+ break;
+ case Instruction::Store:
+ Ty = I.getOperand(1)->getType(); // Encode the pointer type...
+ assert(isa<PointerType>(Ty) && "Store to nonpointer type!?!?");
+ break;
+ default: // Otherwise use the default behavior...
+ Ty = NumOperands ? I.getOperand(0)->getType() : I.getType();
+ break;
+ }
+
+ unsigned Type;
+ int Slot = Table.getSlot(Ty);
+ assert(Slot != -1 && "Type not available!!?!");
+ Type = (unsigned)Slot;
+
+ // Varargs calls and invokes are encoded entirely different from any other
+ // instructions.
+ if (const CallInst *CI = dyn_cast<CallInst>(&I)){
+ const PointerType *Ty =cast<PointerType>(CI->getCalledValue()->getType());
+ if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
+ outputInstrVarArgsCall(CI, Opcode, Table, Type);
+ return;
+ }
+ } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
+ const PointerType *Ty =cast<PointerType>(II->getCalledValue()->getType());
+ if (cast<FunctionType>(Ty->getElementType())->isVarArg()) {
+ outputInstrVarArgsCall(II, Opcode, Table, Type);
+ return;
+ }
+ }
+
+ if (NumOperands <= 3) {
+ // Make sure that we take the type number into consideration. We don't want
+ // to overflow the field size for the instruction format we select.
+ //
+ unsigned MaxOpSlot = Type;
+ unsigned Slots[3]; Slots[0] = (1 << 12)-1; // Marker to signify 0 operands
+
+ for (unsigned i = 0; i != NumOperands; ++i) {
+ int slot = Table.getSlot(I.getOperand(i));
+ assert(slot != -1 && "Broken bytecode!");
+ if (unsigned(slot) > MaxOpSlot) MaxOpSlot = unsigned(slot);
+ Slots[i] = unsigned(slot);
+ }
+
+ // Handle the special cases for various instructions...
+ if (isa<CastInst>(I) || isa<VAArgInst>(I)) {
+ // Cast has to encode the destination type as the second argument in the
+ // packet, or else we won't know what type to cast to!
+ Slots[1] = Table.getSlot(I.getType());
+ assert(Slots[1] != ~0U && "Cast return type unknown?");
+ if (Slots[1] > MaxOpSlot) MaxOpSlot = Slots[1];
+ NumOperands++;
+ } else if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I)) {
+ // We need to encode the type of sequential type indices into their slot #
+ unsigned Idx = 1;
+ for (gep_type_iterator I = gep_type_begin(GEP), E = gep_type_end(GEP);
+ I != E; ++I, ++Idx)
+ if (isa<SequentialType>(*I)) {
+ unsigned IdxId;
+ switch (GEP->getOperand(Idx)->getType()->getTypeID()) {
+ default: assert(0 && "Unknown index type!");
+ case Type::UIntTyID: IdxId = 0; break;
+ case Type::IntTyID: IdxId = 1; break;
+ case Type::ULongTyID: IdxId = 2; break;
+ case Type::LongTyID: IdxId = 3; break;
+ }
+ Slots[Idx] = (Slots[Idx] << 2) | IdxId;
+ if (Slots[Idx] > MaxOpSlot) MaxOpSlot = Slots[Idx];
+ }
+ } else if (Opcode == 58) {
+ // If this is the escape sequence for call, emit the tailcall/cc info.
+ const CallInst &CI = cast<CallInst>(I);
+ ++NumOperands;
+ if (NumOperands < 3) {
+ Slots[NumOperands-1] = (CI.getCallingConv() << 1)|unsigned(CI.isTailCall());
+ if (Slots[NumOperands-1] > MaxOpSlot)
+ MaxOpSlot = Slots[NumOperands-1];
+ }
+ } else if (Opcode == 56) {
+ // Invoke escape seq has at least 4 operands to encode.
+ ++NumOperands;
+ }
+
+ // Decide which instruction encoding to use. This is determined primarily
+ // by the number of operands, and secondarily by whether or not the max
+ // operand will fit into the instruction encoding. More operands == fewer
+ // bits per operand.
+ //
+ switch (NumOperands) {
+ case 0:
+ case 1:
+ if (MaxOpSlot < (1 << 12)-1) { // -1 because we use 4095 to indicate 0 ops
+ outputInstructionFormat1(&I, Opcode, Slots, Type);
+ return;
+ }
+ break;
+
+ case 2:
+ if (MaxOpSlot < (1 << 8)) {
+ outputInstructionFormat2(&I, Opcode, Slots, Type);
+ return;
+ }
+ break;
+
+ case 3:
+ if (MaxOpSlot < (1 << 6)) {
+ outputInstructionFormat3(&I, Opcode, Slots, Type);
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ // If we weren't handled before here, we either have a large number of
+ // operands or a large operand index that we are referring to.
+ outputInstructionFormat0(&I, Opcode, Table, Type);
+}
+
+//===----------------------------------------------------------------------===//
+//=== Block Output ===//
+//===----------------------------------------------------------------------===//
+
+BytecodeWriter::BytecodeWriter(std::vector<unsigned char> &o, const Module *M)
+ : Out(o), Table(M) {
+
+ // Emit the signature...
+ static const unsigned char *Sig = (const unsigned char*)"llvm";
+ output_data(Sig, Sig+4);
+
+ // Emit the top level CLASS block.
+ BytecodeBlock ModuleBlock(BytecodeFormat::ModuleBlockID, *this, false, true);
+
+ bool isBigEndian = M->getEndianness() == Module::BigEndian;
+ bool hasLongPointers = M->getPointerSize() == Module::Pointer64;
+ bool hasNoEndianness = M->getEndianness() == Module::AnyEndianness;
+ bool hasNoPointerSize = M->getPointerSize() == Module::AnyPointerSize;
+
+ // Output the version identifier and other information.
+ unsigned Version = (BCVersionNum << 4) |
+ (unsigned)isBigEndian | (hasLongPointers << 1) |
+ (hasNoEndianness << 2) |
+ (hasNoPointerSize << 3);
+ output_vbr(Version);
+
+ // The Global type plane comes first
+ {
+ BytecodeBlock CPool(BytecodeFormat::GlobalTypePlaneBlockID, *this );
+ outputTypes(Type::FirstDerivedTyID);
+ }
+
+ // The ModuleInfoBlock follows directly after the type information
+ outputModuleInfoBlock(M);
+
+ // Output module level constants, used for global variable initializers
+ outputConstants(false);
+
+ // Do the whole module now! Process each function at a time...
+ for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
+ outputFunction(I);
+
+ // If needed, output the symbol table for the module...
+ outputSymbolTable(M->getSymbolTable());
+}
+
+void BytecodeWriter::outputTypes(unsigned TypeNum) {
+ // Write the type plane for types first because earlier planes (e.g. for a
+ // primitive type like float) may have constants constructed using types
+ // coming later (e.g., via getelementptr from a pointer type). The type
+ // plane is needed before types can be fwd or bkwd referenced.
+ const std::vector<const Type*>& Types = Table.getTypes();
+ assert(!Types.empty() && "No types at all?");
+ assert(TypeNum <= Types.size() && "Invalid TypeNo index");
+
+ unsigned NumEntries = Types.size() - TypeNum;
+
+ // Output type header: [num entries]
+ output_vbr(NumEntries);
+
+ for (unsigned i = TypeNum; i < TypeNum+NumEntries; ++i)
+ outputType(Types[i]);
+}
+
+// Helper function for outputConstants().
+// Writes out all the constants in the plane Plane starting at entry StartNo.
+//
+void BytecodeWriter::outputConstantsInPlane(const std::vector<const Value*>
+ &Plane, unsigned StartNo) {
+ unsigned ValNo = StartNo;
+
+ // Scan through and ignore function arguments, global values, and constant
+ // strings.
+ for (; ValNo < Plane.size() &&
+ (isa<Argument>(Plane[ValNo]) || isa<GlobalValue>(Plane[ValNo]) ||
+ (isa<ConstantArray>(Plane[ValNo]) &&
+ cast<ConstantArray>(Plane[ValNo])->isString())); ValNo++)
+ /*empty*/;
+
+ unsigned NC = ValNo; // Number of constants
+ for (; NC < Plane.size() && (isa<Constant>(Plane[NC])); NC++)
+ /*empty*/;
+ NC -= ValNo; // Convert from index into count
+ if (NC == 0) return; // Skip empty type planes...
+
+ // FIXME: Most slabs only have 1 or 2 entries! We should encode this much
+ // more compactly.
+
+ // Output type header: [num entries][type id number]
+ //
+ output_vbr(NC);
+
+ // Output the Type ID Number...
+ int Slot = Table.getSlot(Plane.front()->getType());
+ assert (Slot != -1 && "Type in constant pool but not in function!!");
+ output_typeid((unsigned)Slot);
+
+ for (unsigned i = ValNo; i < ValNo+NC; ++i) {
+ const Value *V = Plane[i];
+ if (const Constant *C = dyn_cast<Constant>(V)) {
+ outputConstant(C);
+ }
+ }
+}
+
+static inline bool hasNullValue(const Type *Ty) {
+ return Ty != Type::LabelTy && Ty != Type::VoidTy && !isa<OpaqueType>(Ty);
+}
+
+void BytecodeWriter::outputConstants(bool isFunction) {
+ BytecodeBlock CPool(BytecodeFormat::ConstantPoolBlockID, *this,
+ true /* Elide block if empty */);
+
+ unsigned NumPlanes = Table.getNumPlanes();
+
+ if (isFunction)
+ // Output the type plane before any constants!
+ outputTypes(Table.getModuleTypeLevel());
+ else
+ // Output module-level string constants before any other constants.
+ outputConstantStrings();
+
+ for (unsigned pno = 0; pno != NumPlanes; pno++) {
+ const std::vector<const Value*> &Plane = Table.getPlane(pno);
+ if (!Plane.empty()) { // Skip empty type planes...
+ unsigned ValNo = 0;
+ if (isFunction) // Don't re-emit module constants
+ ValNo += Table.getModuleLevel(pno);
+
+ if (hasNullValue(Plane[0]->getType())) {
+ // Skip zero initializer
+ if (ValNo == 0)
+ ValNo = 1;
+ }
+
+ // Write out constants in the plane
+ outputConstantsInPlane(Plane, ValNo);
+ }
+ }
+}
+
+static unsigned getEncodedLinkage(const GlobalValue *GV) {
+ switch (GV->getLinkage()) {
+ default: assert(0 && "Invalid linkage!");
+ case GlobalValue::ExternalLinkage: return 0;
+ case GlobalValue::WeakLinkage: return 1;
+ case GlobalValue::AppendingLinkage: return 2;
+ case GlobalValue::InternalLinkage: return 3;
+ case GlobalValue::LinkOnceLinkage: return 4;
+ }
+}
+
+void BytecodeWriter::outputModuleInfoBlock(const Module *M) {
+ BytecodeBlock ModuleInfoBlock(BytecodeFormat::ModuleGlobalInfoBlockID, *this);
+
+ // Output the types for the global variables in the module...
+ for (Module::const_global_iterator I = M->global_begin(),
+ End = M->global_end(); I != End;++I) {
+ int Slot = Table.getSlot(I->getType());
+ assert(Slot != -1 && "Module global vars is broken!");
+
+ // Fields: bit0 = isConstant, bit1 = hasInitializer, bit2-4=Linkage,
+ // bit5+ = Slot # for type
+ unsigned oSlot = ((unsigned)Slot << 5) | (getEncodedLinkage(I) << 2) |
+ (I->hasInitializer() << 1) | (unsigned)I->isConstant();
+ output_vbr(oSlot);
+
+ // If we have an initializer, output it now.
+ if (I->hasInitializer()) {
+ Slot = Table.getSlot((Value*)I->getInitializer());
+ assert(Slot != -1 && "No slot for global var initializer!");
+ output_vbr((unsigned)Slot);
+ }
+ }
+ output_typeid((unsigned)Table.getSlot(Type::VoidTy));
+
+ // Output the types of the functions in this module.
+ for (Module::const_iterator I = M->begin(), End = M->end(); I != End; ++I) {
+ int Slot = Table.getSlot(I->getType());
+ assert(Slot != -1 && "Module slot calculator is broken!");
+ assert(Slot >= Type::FirstDerivedTyID && "Derived type not in range!");
+ assert(((Slot << 5) >> 5) == Slot && "Slot # too big!");
+ unsigned ID = (Slot << 5);
+
+ if (I->getCallingConv() < 15)
+ ID += I->getCallingConv()+1;
+
+ if (I->isExternal()) // If external, we don't have an FunctionInfo block.
+ ID |= 1 << 4;
+ output_vbr(ID);
+
+ if (I->getCallingConv() >= 15)
+ output_vbr(I->getCallingConv());
+ }
+ output_vbr((unsigned)Table.getSlot(Type::VoidTy) << 5);
+
+ // Emit the list of dependent libraries for the Module.
+ Module::lib_iterator LI = M->lib_begin();
+ Module::lib_iterator LE = M->lib_end();
+ output_vbr(unsigned(LE - LI)); // Emit the number of dependent libraries.
+ for (; LI != LE; ++LI)
+ output(*LI);
+
+ // Output the target triple from the module
+ output(M->getTargetTriple());
+}
+
+void BytecodeWriter::outputInstructions(const Function *F) {
+ BytecodeBlock ILBlock(BytecodeFormat::InstructionListBlockID, *this);
+ for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
+ for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I)
+ outputInstruction(*I);
+}
+
+void BytecodeWriter::outputFunction(const Function *F) {
+ // If this is an external function, there is nothing else to emit!
+ if (F->isExternal()) return;
+
+ BytecodeBlock FunctionBlock(BytecodeFormat::FunctionBlockID, *this);
+ output_vbr(getEncodedLinkage(F));
+
+ // Get slot information about the function...
+ Table.incorporateFunction(F);
+
+ if (Table.getCompactionTable().empty()) {
+ // Output information about the constants in the function if the compaction
+ // table is not being used.
+ outputConstants(true);
+ } else {
+ // Otherwise, emit the compaction table.
+ outputCompactionTable();
+ }
+
+ // Output all of the instructions in the body of the function
+ outputInstructions(F);
+
+ // If needed, output the symbol table for the function...
+ outputSymbolTable(F->getSymbolTable());
+
+ Table.purgeFunction();
+}
+
+void BytecodeWriter::outputCompactionTablePlane(unsigned PlaneNo,
+ const std::vector<const Value*> &Plane,
+ unsigned StartNo) {
+ unsigned End = Table.getModuleLevel(PlaneNo);
+ if (Plane.empty() || StartNo == End || End == 0) return; // Nothing to emit
+ assert(StartNo < End && "Cannot emit negative range!");
+ assert(StartNo < Plane.size() && End <= Plane.size());
+
+ // Do not emit the null initializer!
+ ++StartNo;
+
+ // Figure out which encoding to use. By far the most common case we have is
+ // to emit 0-2 entries in a compaction table plane.
+ switch (End-StartNo) {
+ case 0: // Avoid emitting two vbr's if possible.
+ case 1:
+ case 2:
+ output_vbr((PlaneNo << 2) | End-StartNo);
+ break;
+ default:
+ // Output the number of things.
+ output_vbr((unsigned(End-StartNo) << 2) | 3);
+ output_typeid(PlaneNo); // Emit the type plane this is
+ break;
+ }
+
+ for (unsigned i = StartNo; i != End; ++i)
+ output_vbr(Table.getGlobalSlot(Plane[i]));
+}
+
+void BytecodeWriter::outputCompactionTypes(unsigned StartNo) {
+ // Get the compaction type table from the slot calculator
+ const std::vector<const Type*> &CTypes = Table.getCompactionTypes();
+
+ // The compaction types may have been uncompactified back to the
+ // global types. If so, we just write an empty table
+ if (CTypes.size() == 0 ) {
+ output_vbr(0U);
+ return;
+ }
+
+ assert(CTypes.size() >= StartNo && "Invalid compaction types start index");
+
+ // Determine how many types to write
+ unsigned NumTypes = CTypes.size() - StartNo;
+
+ // Output the number of types.
+ output_vbr(NumTypes);
+
+ for (unsigned i = StartNo; i < StartNo+NumTypes; ++i)
+ output_typeid(Table.getGlobalSlot(CTypes[i]));
+}
+
+void BytecodeWriter::outputCompactionTable() {
+ // Avoid writing the compaction table at all if there is no content.
+ if (Table.getCompactionTypes().size() >= Type::FirstDerivedTyID ||
+ (!Table.CompactionTableIsEmpty())) {
+ BytecodeBlock CTB(BytecodeFormat::CompactionTableBlockID, *this,
+ true/*ElideIfEmpty*/);
+ const std::vector<std::vector<const Value*> > &CT =
+ Table.getCompactionTable();
+
+ // First things first, emit the type compaction table if there is one.
+ outputCompactionTypes(Type::FirstDerivedTyID);
+
+ for (unsigned i = 0, e = CT.size(); i != e; ++i)
+ outputCompactionTablePlane(i, CT[i], 0);
+ }
+}
+
+void BytecodeWriter::outputSymbolTable(const SymbolTable &MST) {
+ // Do not output the Bytecode block for an empty symbol table, it just wastes
+ // space!
+ if (MST.isEmpty()) return;
+
+ BytecodeBlock SymTabBlock(BytecodeFormat::SymbolTableBlockID, *this,
+ true/*ElideIfEmpty*/);
+
+ // Write the number of types
+ output_vbr(MST.num_types());
+
+ // Write each of the types
+ for (SymbolTable::type_const_iterator TI = MST.type_begin(),
+ TE = MST.type_end(); TI != TE; ++TI ) {
+ // Symtab entry:[def slot #][name]
+ output_typeid((unsigned)Table.getSlot(TI->second));
+ output(TI->first);
+ }
+
+ // Now do each of the type planes in order.
+ for (SymbolTable::plane_const_iterator PI = MST.plane_begin(),
+ PE = MST.plane_end(); PI != PE; ++PI) {
+ SymbolTable::value_const_iterator I = MST.value_begin(PI->first);
+ SymbolTable::value_const_iterator End = MST.value_end(PI->first);
+ int Slot;
+
+ if (I == End) continue; // Don't mess with an absent type...
+
+ // Write the number of values in this plane
+ output_vbr((unsigned)PI->second.size());
+
+ // Write the slot number of the type for this plane
+ Slot = Table.getSlot(PI->first);
+ assert(Slot != -1 && "Type in symtab, but not in table!");
+ output_typeid((unsigned)Slot);
+
+ // Write each of the values in this plane
+ for (; I != End; ++I) {
+ // Symtab entry: [def slot #][name]
+ Slot = Table.getSlot(I->second);
+ assert(Slot != -1 && "Value in symtab but has no slot number!!");
+ output_vbr((unsigned)Slot);
+ output(I->first);
+ }
+ }
+}
+
+void llvm::WriteBytecodeToFile(const Module *M, std::ostream &Out,
+ bool compress ) {
+ assert(M && "You can't write a null module!!");
+
+ // Create a vector of unsigned char for the bytecode output. We
+ // reserve 256KBytes of space in the vector so that we avoid doing
+ // lots of little allocations. 256KBytes is sufficient for a large
+ // proportion of the bytecode files we will encounter. Larger files
+ // will be automatically doubled in size as needed (std::vector
+ // behavior).
+ std::vector<unsigned char> Buffer;
+ Buffer.reserve(256 * 1024);
+
+ // The BytecodeWriter populates Buffer for us.
+ BytecodeWriter BCW(Buffer, M);
+
+ // Keep track of how much we've written
+ BytesWritten += Buffer.size();
+
+ // Determine start and end points of the Buffer
+ const unsigned char *FirstByte = &Buffer.front();
+
+ // If we're supposed to compress this mess ...
+ if (compress) {
+
+ // We signal compression by using an alternate magic number for the
+ // file. The compressed bytecode file's magic number is "llvc" instead
+ // of "llvm".
+ char compressed_magic[4];
+ compressed_magic[0] = 'l';
+ compressed_magic[1] = 'l';
+ compressed_magic[2] = 'v';
+ compressed_magic[3] = 'c';
+
+ Out.write(compressed_magic,4);
+
+ // Compress everything after the magic number (which we altered)
+ uint64_t zipSize = Compressor::compressToStream(
+ (char*)(FirstByte+4), // Skip the magic number
+ Buffer.size()-4, // Skip the magic number
+ Out // Where to write compressed data
+ );
+
+ } else {
+
+ // We're not compressing, so just write the entire block.
+ Out.write((char*)FirstByte, Buffer.size());
+ }
+
+ // make sure it hits disk now
+ Out.flush();
+}
+
diff --git a/lib/Bytecode/Writer/WriterInternals.h b/lib/Bytecode/Writer/WriterInternals.h
new file mode 100644
index 0000000000..46ad5c6710
--- /dev/null
+++ b/lib/Bytecode/Writer/WriterInternals.h
@@ -0,0 +1,140 @@
+//===- WriterInternals.h - Data structures shared by the Writer -*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header defines the interface used between components of the bytecode
+// writer.
+//
+// Note that the performance of this library is not terribly important, because
+// it shouldn't be used by JIT type applications... so it is not a huge focus
+// at least. :)
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
+#define LLVM_LIB_BYTECODE_WRITER_WRITERINTERNALS_H
+
+#include "SlotCalculator.h"
+#include "llvm/Bytecode/Writer.h"
+#include "llvm/Bytecode/Format.h"
+#include "llvm/Instruction.h"
+#include "llvm/Support/DataTypes.h"
+#include <string>
+#include <vector>
+
+namespace llvm {
+
+class BytecodeWriter {
+ std::vector<unsigned char> &Out;
+ SlotCalculator Table;
+public:
+ BytecodeWriter(std::vector<unsigned char> &o, const Module *M);
+
+private:
+ void outputConstants(bool isFunction);
+ void outputConstantStrings();
+ void outputFunction(const Function *F);
+ void outputCompactionTable();
+ void outputCompactionTypes(unsigned StartNo);
+ void outputCompactionTablePlane(unsigned PlaneNo,
+ const std::vector<const Value*> &TypePlane,
+ unsigned StartNo);
+ void outputInstructions(const Function *F);
+ void outputInstruction(const Instruction &I);
+ void outputInstructionFormat0(const Instruction *I, unsigned Opcode,
+ const SlotCalculator &Table,
+ unsigned Type);
+ void outputInstrVarArgsCall(const Instruction *I,
+ unsigned Opcode,
+ const SlotCalculator &Table,
+ unsigned Type) ;
+ inline void outputInstructionFormat1(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) ;
+ inline void outputInstructionFormat2(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) ;
+ inline void outputInstructionFormat3(const Instruction *I,
+ unsigned Opcode,
+ unsigned *Slots,
+ unsigned Type) ;
+
+ void outputModuleInfoBlock(const Module *C);
+ void outputSymbolTable(const SymbolTable &ST);
+ void outputTypes(unsigned StartNo);
+ void outputConstantsInPlane(const std::vector<const Value*> &Plane,
+ unsigned StartNo);
+ void outputConstant(const Constant *CPV);
+ void outputType(const Type *T);
+
+ /// @brief Unsigned integer output primitive
+ inline void output(unsigned i, int pos = -1);
+
+ /// @brief Signed integer output primitive
+ inline void output(int i);
+
+ /// @brief 64-bit variable bit rate output primitive.
+ inline void output_vbr(uint64_t i);
+
+ /// @brief 32-bit variable bit rate output primitive.
+ inline void output_vbr(unsigned i);
+
+ /// @brief Signed 64-bit variable bit rate output primitive.
+ inline void output_vbr(int64_t i);
+
+ /// @brief Signed 32-bit variable bit rate output primitive.
+ inline void output_vbr(int i);
+
+ inline void output(const std::string &s );
+
+ inline void output_data(const void *Ptr, const void *End);
+
+ inline void output_float(float& FloatVal);
+ inline void output_double(double& DoubleVal);
+
+ inline void output_typeid(unsigned i);
+
+ inline size_t size() const { return Out.size(); }
+ inline void resize(size_t S) { Out.resize(S); }
+ friend class BytecodeBlock;
+};
+
+/// BytecodeBlock - Little helper class is used by the bytecode writer to help
+/// do backpatching of bytecode block sizes really easily. It backpatches when
+/// it goes out of scope.
+///
+class BytecodeBlock {
+ unsigned Id;
+ unsigned Loc;
+ BytecodeWriter& Writer;
+
+ /// ElideIfEmpty - If this is true and the bytecode block ends up being empty,
+ /// the block can remove itself from the output stream entirely.
+ bool ElideIfEmpty;
+
+ /// If this is true then the block is written with a long format header using
+ /// a uint (32-bits) for both the block id and size. Otherwise, it uses the
+ /// short format which is a single uint with 27 bits for size and 5 bits for
+ /// the block id. Both formats are used in a bc file with version 1.3.
+ /// Previously only the long format was used.
+ bool HasLongFormat;
+
+ BytecodeBlock(const BytecodeBlock &); // do not implement
+ void operator=(const BytecodeBlock &); // do not implement
+public:
+ inline BytecodeBlock(unsigned ID, BytecodeWriter& w,
+ bool elideIfEmpty = false, bool hasLongFormat = false);
+
+ inline ~BytecodeBlock();
+};
+
+} // End llvm namespace
+
+#endif
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-09-07 20:16:22 +0000