Added more llvm dependencies.
This commit is contained in:
1 parent
bdc83bb95d
commit
c4958b25c4
1063 files changed
+277561
-1
No files matched your search
@@ -0,0 +1,185 @@
|
||||
//===- BitCodes.h - Enum values for the bitcode format ----------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header Bitcode enum values.
|
||||
//
|
||||
// The enum values defined in this file should be considered permanent. If
|
||||
// new features are added, they should have values added at the end of the
|
||||
// respective lists.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITCODES_H
|
||||
#define LLVM_BITCODE_BITCODES_H
|
||||
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/Support/DataTypes.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include <cassert>
|
||||
|
||||
namespace llvm {
|
||||
/// Offsets of the 32-bit fields of bitcode wrapper header.
|
||||
static const unsigned BWH_MagicField = 0 * 4;
|
||||
static const unsigned BWH_VersionField = 1 * 4;
|
||||
static const unsigned BWH_OffsetField = 2 * 4;
|
||||
static const unsigned BWH_SizeField = 3 * 4;
|
||||
static const unsigned BWH_CPUTypeField = 4 * 4;
|
||||
static const unsigned BWH_HeaderSize = 5 * 4;
|
||||
|
||||
namespace bitc {
|
||||
enum StandardWidths {
|
||||
BlockIDWidth = 8, // We use VBR-8 for block IDs.
|
||||
CodeLenWidth = 4, // Codelen are VBR-4.
|
||||
BlockSizeWidth = 32 // BlockSize up to 2^32 32-bit words = 16GB per block.
|
||||
};
|
||||
|
||||
// The standard abbrev namespace always has a way to exit a block, enter a
|
||||
// nested block, define abbrevs, and define an unabbreviated record.
|
||||
enum FixedAbbrevIDs {
|
||||
END_BLOCK = 0, // Must be zero to guarantee termination for broken bitcode.
|
||||
ENTER_SUBBLOCK = 1,
|
||||
|
||||
/// DEFINE_ABBREV - Defines an abbrev for the current block. It consists
|
||||
/// of a vbr5 for # operand infos. Each operand info is emitted with a
|
||||
/// single bit to indicate if it is a literal encoding. If so, the value is
|
||||
/// emitted with a vbr8. If not, the encoding is emitted as 3 bits followed
|
||||
/// by the info value as a vbr5 if needed.
|
||||
DEFINE_ABBREV = 2,
|
||||
|
||||
// UNABBREV_RECORDs are emitted with a vbr6 for the record code, followed by
|
||||
// a vbr6 for the # operands, followed by vbr6's for each operand.
|
||||
UNABBREV_RECORD = 3,
|
||||
|
||||
// This is not a code, this is a marker for the first abbrev assignment.
|
||||
FIRST_APPLICATION_ABBREV = 4
|
||||
};
|
||||
|
||||
/// StandardBlockIDs - All bitcode files can optionally include a BLOCKINFO
|
||||
/// block, which contains metadata about other blocks in the file.
|
||||
enum StandardBlockIDs {
|
||||
/// BLOCKINFO_BLOCK is used to define metadata about blocks, for example,
|
||||
/// standard abbrevs that should be available to all blocks of a specified
|
||||
/// ID.
|
||||
BLOCKINFO_BLOCK_ID = 0,
|
||||
|
||||
// Block IDs 1-7 are reserved for future expansion.
|
||||
FIRST_APPLICATION_BLOCKID = 8
|
||||
};
|
||||
|
||||
/// BlockInfoCodes - The blockinfo block contains metadata about user-defined
|
||||
/// blocks.
|
||||
enum BlockInfoCodes {
|
||||
// DEFINE_ABBREV has magic semantics here, applying to the current SETBID'd
|
||||
// block, instead of the BlockInfo block.
|
||||
|
||||
BLOCKINFO_CODE_SETBID = 1, // SETBID: [blockid#]
|
||||
BLOCKINFO_CODE_BLOCKNAME = 2, // BLOCKNAME: [name]
|
||||
BLOCKINFO_CODE_SETRECORDNAME = 3 // BLOCKINFO_CODE_SETRECORDNAME:
|
||||
// [id, name]
|
||||
};
|
||||
|
||||
} // End bitc namespace
|
||||
|
||||
/// BitCodeAbbrevOp - This describes one or more operands in an abbreviation.
|
||||
/// This is actually a union of two different things:
|
||||
/// 1. It could be a literal integer value ("the operand is always 17").
|
||||
/// 2. It could be an encoding specification ("this operand encoded like so").
|
||||
///
|
||||
class BitCodeAbbrevOp {
|
||||
uint64_t Val; // A literal value or data for an encoding.
|
||||
bool IsLiteral : 1; // Indicate whether this is a literal value or not.
|
||||
unsigned Enc : 3; // The encoding to use.
|
||||
public:
|
||||
enum Encoding {
|
||||
Fixed = 1, // A fixed width field, Val specifies number of bits.
|
||||
VBR = 2, // A VBR field where Val specifies the width of each chunk.
|
||||
Array = 3, // A sequence of fields, next field species elt encoding.
|
||||
Char6 = 4, // A 6-bit fixed field which maps to [a-zA-Z0-9._].
|
||||
Blob = 5 // 32-bit aligned array of 8-bit characters.
|
||||
};
|
||||
|
||||
explicit BitCodeAbbrevOp(uint64_t V) : Val(V), IsLiteral(true) {}
|
||||
explicit BitCodeAbbrevOp(Encoding E, uint64_t Data = 0)
|
||||
: Val(Data), IsLiteral(false), Enc(E) {}
|
||||
|
||||
bool isLiteral() const { return IsLiteral; }
|
||||
bool isEncoding() const { return !IsLiteral; }
|
||||
|
||||
// Accessors for literals.
|
||||
uint64_t getLiteralValue() const { assert(isLiteral()); return Val; }
|
||||
|
||||
// Accessors for encoding info.
|
||||
Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; }
|
||||
uint64_t getEncodingData() const {
|
||||
assert(isEncoding() && hasEncodingData());
|
||||
return Val;
|
||||
}
|
||||
|
||||
bool hasEncodingData() const { return hasEncodingData(getEncoding()); }
|
||||
static bool hasEncodingData(Encoding E) {
|
||||
switch (E) {
|
||||
case Fixed:
|
||||
case VBR:
|
||||
return true;
|
||||
case Array:
|
||||
case Char6:
|
||||
case Blob:
|
||||
return false;
|
||||
}
|
||||
report_fatal_error("Invalid encoding");
|
||||
}
|
||||
|
||||
/// isChar6 - Return true if this character is legal in the Char6 encoding.
|
||||
static bool isChar6(char C) {
|
||||
if (C >= 'a' && C <= 'z') return true;
|
||||
if (C >= 'A' && C <= 'Z') return true;
|
||||
if (C >= '0' && C <= '9') return true;
|
||||
if (C == '.' || C == '_') return true;
|
||||
return false;
|
||||
}
|
||||
static unsigned EncodeChar6(char C) {
|
||||
if (C >= 'a' && C <= 'z') return C-'a';
|
||||
if (C >= 'A' && C <= 'Z') return C-'A'+26;
|
||||
if (C >= '0' && C <= '9') return C-'0'+26+26;
|
||||
if (C == '.') return 62;
|
||||
if (C == '_') return 63;
|
||||
llvm_unreachable("Not a value Char6 character!");
|
||||
}
|
||||
|
||||
static char DecodeChar6(unsigned V) {
|
||||
assert((V & ~63) == 0 && "Not a Char6 encoded character!");
|
||||
return "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._"
|
||||
[V];
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
template <> struct isPodLike<BitCodeAbbrevOp> { static const bool value=true; };
|
||||
|
||||
/// BitCodeAbbrev - This class represents an abbreviation record. An
|
||||
/// abbreviation allows a complex record that has redundancy to be stored in a
|
||||
/// specialized format instead of the fully-general, fully-vbr, format.
|
||||
class BitCodeAbbrev {
|
||||
SmallVector<BitCodeAbbrevOp, 32> OperandList;
|
||||
|
||||
public:
|
||||
unsigned getNumOperandInfos() const {
|
||||
return static_cast<unsigned>(OperandList.size());
|
||||
}
|
||||
const BitCodeAbbrevOp &getOperandInfo(unsigned N) const {
|
||||
return OperandList[N];
|
||||
}
|
||||
|
||||
void Add(const BitCodeAbbrevOp &OpInfo) {
|
||||
OperandList.push_back(OpInfo);
|
||||
}
|
||||
};
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,272 @@
|
||||
//===- llvm/Bitcode/BitcodeReader.h - Bitcode reader ------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header defines interfaces to read LLVM bitcode files/streams.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITCODEREADER_H
|
||||
#define LLVM_BITCODE_BITCODEREADER_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Bitcode/BitCodes.h"
|
||||
#include "llvm/IR/ModuleSummaryIndex.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include "llvm/Support/ErrorOr.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <system_error>
|
||||
#include <vector>
|
||||
namespace llvm {
|
||||
|
||||
class LLVMContext;
|
||||
class Module;
|
||||
|
||||
// These functions are for converting Expected/Error values to
|
||||
// ErrorOr/std::error_code for compatibility with legacy clients. FIXME:
|
||||
// Remove these functions once no longer needed by the C and libLTO APIs.
|
||||
|
||||
std::error_code errorToErrorCodeAndEmitErrors(LLVMContext &Ctx, Error Err);
|
||||
|
||||
template <typename T>
|
||||
ErrorOr<T> expectedToErrorOrAndEmitErrors(LLVMContext &Ctx, Expected<T> Val) {
|
||||
if (!Val)
|
||||
return errorToErrorCodeAndEmitErrors(Ctx, Val.takeError());
|
||||
return std::move(*Val);
|
||||
}
|
||||
|
||||
struct BitcodeFileContents;
|
||||
|
||||
/// Basic information extracted from a bitcode module to be used for LTO.
|
||||
struct BitcodeLTOInfo {
|
||||
bool IsThinLTO;
|
||||
bool HasSummary;
|
||||
};
|
||||
|
||||
/// Represents a module in a bitcode file.
|
||||
class BitcodeModule {
|
||||
// This covers the identification (if present) and module blocks.
|
||||
ArrayRef<uint8_t> Buffer;
|
||||
StringRef ModuleIdentifier;
|
||||
|
||||
// The string table used to interpret this module.
|
||||
StringRef Strtab;
|
||||
|
||||
// The bitstream location of the IDENTIFICATION_BLOCK.
|
||||
uint64_t IdentificationBit;
|
||||
|
||||
// The bitstream location of this module's MODULE_BLOCK.
|
||||
uint64_t ModuleBit;
|
||||
|
||||
BitcodeModule(ArrayRef<uint8_t> Buffer, StringRef ModuleIdentifier,
|
||||
uint64_t IdentificationBit, uint64_t ModuleBit)
|
||||
: Buffer(Buffer), ModuleIdentifier(ModuleIdentifier),
|
||||
IdentificationBit(IdentificationBit), ModuleBit(ModuleBit) {}
|
||||
|
||||
// Calls the ctor.
|
||||
friend Expected<BitcodeFileContents>
|
||||
getBitcodeFileContents(MemoryBufferRef Buffer);
|
||||
|
||||
Expected<std::unique_ptr<Module>> getModuleImpl(LLVMContext &Context,
|
||||
bool MaterializeAll,
|
||||
bool ShouldLazyLoadMetadata,
|
||||
bool IsImporting);
|
||||
|
||||
public:
|
||||
StringRef getBuffer() const {
|
||||
return StringRef((const char *)Buffer.begin(), Buffer.size());
|
||||
}
|
||||
|
||||
StringRef getStrtab() const { return Strtab; }
|
||||
|
||||
StringRef getModuleIdentifier() const { return ModuleIdentifier; }
|
||||
|
||||
/// Read the bitcode module and prepare for lazy deserialization of function
|
||||
/// bodies. If ShouldLazyLoadMetadata is true, lazily load metadata as well.
|
||||
/// If IsImporting is true, this module is being parsed for ThinLTO
|
||||
/// importing into another module.
|
||||
Expected<std::unique_ptr<Module>> getLazyModule(LLVMContext &Context,
|
||||
bool ShouldLazyLoadMetadata,
|
||||
bool IsImporting);
|
||||
|
||||
/// Read the entire bitcode module and return it.
|
||||
Expected<std::unique_ptr<Module>> parseModule(LLVMContext &Context);
|
||||
|
||||
/// Returns information about the module to be used for LTO: whether to
|
||||
/// compile with ThinLTO, and whether it has a summary.
|
||||
Expected<BitcodeLTOInfo> getLTOInfo();
|
||||
|
||||
/// Parse the specified bitcode buffer, returning the module summary index.
|
||||
Expected<std::unique_ptr<ModuleSummaryIndex>> getSummary();
|
||||
|
||||
/// Parse the specified bitcode buffer and merge its module summary index
|
||||
/// into CombinedIndex.
|
||||
Error readSummary(ModuleSummaryIndex &CombinedIndex, StringRef ModulePath,
|
||||
uint64_t ModuleId);
|
||||
};
|
||||
|
||||
struct BitcodeFileContents {
|
||||
std::vector<BitcodeModule> Mods;
|
||||
StringRef Symtab, StrtabForSymtab;
|
||||
};
|
||||
|
||||
/// Returns the contents of a bitcode file. This includes the raw contents of
|
||||
/// the symbol table embedded in the bitcode file. Clients which require a
|
||||
/// symbol table should prefer to use irsymtab::read instead of this function
|
||||
/// because it creates a reader for the irsymtab and handles upgrading bitcode
|
||||
/// files without a symbol table or with an old symbol table.
|
||||
Expected<BitcodeFileContents> getBitcodeFileContents(MemoryBufferRef Buffer);
|
||||
|
||||
/// Returns a list of modules in the specified bitcode buffer.
|
||||
Expected<std::vector<BitcodeModule>>
|
||||
getBitcodeModuleList(MemoryBufferRef Buffer);
|
||||
|
||||
/// Read the header of the specified bitcode buffer and prepare for lazy
|
||||
/// deserialization of function bodies. If ShouldLazyLoadMetadata is true,
|
||||
/// lazily load metadata as well. If IsImporting is true, this module is
|
||||
/// being parsed for ThinLTO importing into another module.
|
||||
Expected<std::unique_ptr<Module>>
|
||||
getLazyBitcodeModule(MemoryBufferRef Buffer, LLVMContext &Context,
|
||||
bool ShouldLazyLoadMetadata = false,
|
||||
bool IsImporting = false);
|
||||
|
||||
/// Like getLazyBitcodeModule, except that the module takes ownership of
|
||||
/// the memory buffer if successful. If successful, this moves Buffer. On
|
||||
/// error, this *does not* move Buffer. If IsImporting is true, this module is
|
||||
/// being parsed for ThinLTO importing into another module.
|
||||
Expected<std::unique_ptr<Module>> getOwningLazyBitcodeModule(
|
||||
std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext &Context,
|
||||
bool ShouldLazyLoadMetadata = false, bool IsImporting = false);
|
||||
|
||||
/// Read the header of the specified bitcode buffer and extract just the
|
||||
/// triple information. If successful, this returns a string. On error, this
|
||||
/// returns "".
|
||||
Expected<std::string> getBitcodeTargetTriple(MemoryBufferRef Buffer);
|
||||
|
||||
/// Return true if \p Buffer contains a bitcode file with ObjC code (category
|
||||
/// or class) in it.
|
||||
Expected<bool> isBitcodeContainingObjCCategory(MemoryBufferRef Buffer);
|
||||
|
||||
/// Read the header of the specified bitcode buffer and extract just the
|
||||
/// producer string information. If successful, this returns a string. On
|
||||
/// error, this returns "".
|
||||
Expected<std::string> getBitcodeProducerString(MemoryBufferRef Buffer);
|
||||
|
||||
/// Read the specified bitcode file, returning the module.
|
||||
Expected<std::unique_ptr<Module>> parseBitcodeFile(MemoryBufferRef Buffer,
|
||||
LLVMContext &Context);
|
||||
|
||||
/// Returns LTO information for the specified bitcode file.
|
||||
Expected<BitcodeLTOInfo> getBitcodeLTOInfo(MemoryBufferRef Buffer);
|
||||
|
||||
/// Parse the specified bitcode buffer, returning the module summary index.
|
||||
Expected<std::unique_ptr<ModuleSummaryIndex>>
|
||||
getModuleSummaryIndex(MemoryBufferRef Buffer);
|
||||
|
||||
/// Parse the specified bitcode buffer and merge the index into CombinedIndex.
|
||||
Error readModuleSummaryIndex(MemoryBufferRef Buffer,
|
||||
ModuleSummaryIndex &CombinedIndex,
|
||||
uint64_t ModuleId);
|
||||
|
||||
/// Parse the module summary index out of an IR file and return the module
|
||||
/// summary index object if found, or an empty summary if not. If Path refers
|
||||
/// to an empty file and IgnoreEmptyThinLTOIndexFile is true, then
|
||||
/// this function will return nullptr.
|
||||
Expected<std::unique_ptr<ModuleSummaryIndex>>
|
||||
getModuleSummaryIndexForFile(StringRef Path,
|
||||
bool IgnoreEmptyThinLTOIndexFile = false);
|
||||
|
||||
/// isBitcodeWrapper - Return true if the given bytes are the magic bytes
|
||||
/// for an LLVM IR bitcode wrapper.
|
||||
inline bool isBitcodeWrapper(const unsigned char *BufPtr,
|
||||
const unsigned char *BufEnd) {
|
||||
// See if you can find the hidden message in the magic bytes :-).
|
||||
// (Hint: it's a little-endian encoding.)
|
||||
return BufPtr != BufEnd &&
|
||||
BufPtr[0] == 0xDE &&
|
||||
BufPtr[1] == 0xC0 &&
|
||||
BufPtr[2] == 0x17 &&
|
||||
BufPtr[3] == 0x0B;
|
||||
}
|
||||
|
||||
/// isRawBitcode - Return true if the given bytes are the magic bytes for
|
||||
/// raw LLVM IR bitcode (without a wrapper).
|
||||
inline bool isRawBitcode(const unsigned char *BufPtr,
|
||||
const unsigned char *BufEnd) {
|
||||
// These bytes sort of have a hidden message, but it's not in
|
||||
// little-endian this time, and it's a little redundant.
|
||||
return BufPtr != BufEnd &&
|
||||
BufPtr[0] == 'B' &&
|
||||
BufPtr[1] == 'C' &&
|
||||
BufPtr[2] == 0xc0 &&
|
||||
BufPtr[3] == 0xde;
|
||||
}
|
||||
|
||||
/// isBitcode - Return true if the given bytes are the magic bytes for
|
||||
/// LLVM IR bitcode, either with or without a wrapper.
|
||||
inline bool isBitcode(const unsigned char *BufPtr,
|
||||
const unsigned char *BufEnd) {
|
||||
return isBitcodeWrapper(BufPtr, BufEnd) ||
|
||||
isRawBitcode(BufPtr, BufEnd);
|
||||
}
|
||||
|
||||
/// SkipBitcodeWrapperHeader - Some systems wrap bc files with a special
|
||||
/// header for padding or other reasons. The format of this header is:
|
||||
///
|
||||
/// struct bc_header {
|
||||
/// uint32_t Magic; // 0x0B17C0DE
|
||||
/// uint32_t Version; // Version, currently always 0.
|
||||
/// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
|
||||
/// uint32_t BitcodeSize; // Size of traditional bitcode file.
|
||||
/// ... potentially other gunk ...
|
||||
/// };
|
||||
///
|
||||
/// This function is called when we find a file with a matching magic number.
|
||||
/// In this case, skip down to the subsection of the file that is actually a
|
||||
/// BC file.
|
||||
/// If 'VerifyBufferSize' is true, check that the buffer is large enough to
|
||||
/// contain the whole bitcode file.
|
||||
inline bool SkipBitcodeWrapperHeader(const unsigned char *&BufPtr,
|
||||
const unsigned char *&BufEnd,
|
||||
bool VerifyBufferSize) {
|
||||
// Must contain the offset and size field!
|
||||
if (unsigned(BufEnd - BufPtr) < BWH_SizeField + 4)
|
||||
return true;
|
||||
|
||||
unsigned Offset = support::endian::read32le(&BufPtr[BWH_OffsetField]);
|
||||
unsigned Size = support::endian::read32le(&BufPtr[BWH_SizeField]);
|
||||
uint64_t BitcodeOffsetEnd = (uint64_t)Offset + (uint64_t)Size;
|
||||
|
||||
// Verify that Offset+Size fits in the file.
|
||||
if (VerifyBufferSize && BitcodeOffsetEnd > uint64_t(BufEnd-BufPtr))
|
||||
return true;
|
||||
BufPtr += Offset;
|
||||
BufEnd = BufPtr+Size;
|
||||
return false;
|
||||
}
|
||||
|
||||
const std::error_category &BitcodeErrorCategory();
|
||||
enum class BitcodeError { CorruptedBitcode = 1 };
|
||||
inline std::error_code make_error_code(BitcodeError E) {
|
||||
return std::error_code(static_cast<int>(E), BitcodeErrorCategory());
|
||||
}
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
namespace std {
|
||||
|
||||
template <> struct is_error_code_enum<llvm::BitcodeError> : std::true_type {};
|
||||
|
||||
} // end namespace std
|
||||
|
||||
#endif // LLVM_BITCODE_BITCODEREADER_H
|
||||
@@ -0,0 +1,157 @@
|
||||
//===- llvm/Bitcode/BitcodeWriter.h - Bitcode writers -----------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header defines interfaces to write LLVM bitcode files/streams.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITCODEWRITER_H
|
||||
#define LLVM_BITCODE_BITCODEWRITER_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/ModuleSummaryIndex.h"
|
||||
#include "llvm/MC/StringTableBuilder.h"
|
||||
#include "llvm/Support/Allocator.h"
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class BitstreamWriter;
|
||||
class Module;
|
||||
class raw_ostream;
|
||||
|
||||
class BitcodeWriter {
|
||||
SmallVectorImpl<char> &Buffer;
|
||||
std::unique_ptr<BitstreamWriter> Stream;
|
||||
|
||||
StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
|
||||
|
||||
// Owns any strings created by the irsymtab writer until we create the
|
||||
// string table.
|
||||
BumpPtrAllocator Alloc;
|
||||
|
||||
bool WroteStrtab = false, WroteSymtab = false;
|
||||
|
||||
void writeBlob(unsigned Block, unsigned Record, StringRef Blob);
|
||||
|
||||
std::vector<Module *> Mods;
|
||||
|
||||
public:
|
||||
/// Create a BitcodeWriter that writes to Buffer.
|
||||
BitcodeWriter(SmallVectorImpl<char> &Buffer);
|
||||
|
||||
~BitcodeWriter();
|
||||
|
||||
/// Attempt to write a symbol table to the bitcode file. This must be called
|
||||
/// at most once after all modules have been written.
|
||||
///
|
||||
/// A reader does not require a symbol table to interpret a bitcode file;
|
||||
/// the symbol table is needed only to improve link-time performance. So
|
||||
/// this function may decide not to write a symbol table. It may so decide
|
||||
/// if, for example, the target is unregistered or the IR is malformed.
|
||||
void writeSymtab();
|
||||
|
||||
/// Write the bitcode file's string table. This must be called exactly once
|
||||
/// after all modules and the optional symbol table have been written.
|
||||
void writeStrtab();
|
||||
|
||||
/// Copy the string table for another module into this bitcode file. This
|
||||
/// should be called after copying the module itself into the bitcode file.
|
||||
void copyStrtab(StringRef Strtab);
|
||||
|
||||
/// Write the specified module to the buffer specified at construction time.
|
||||
///
|
||||
/// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
|
||||
/// Value in \c M. These will be reconstructed exactly when \a M is
|
||||
/// deserialized.
|
||||
///
|
||||
/// If \c Index is supplied, the bitcode will contain the summary index
|
||||
/// (currently for use in ThinLTO optimization).
|
||||
///
|
||||
/// \p GenerateHash enables hashing the Module and including the hash in the
|
||||
/// bitcode (currently for use in ThinLTO incremental build).
|
||||
///
|
||||
/// If \p ModHash is non-null, when GenerateHash is true, the resulting
|
||||
/// hash is written into ModHash. When GenerateHash is false, that value
|
||||
/// is used as the hash instead of computing from the generated bitcode.
|
||||
/// Can be used to produce the same module hash for a minimized bitcode
|
||||
/// used just for the thin link as in the regular full bitcode that will
|
||||
/// be used in the backend.
|
||||
void writeModule(const Module *M, bool ShouldPreserveUseListOrder = false,
|
||||
const ModuleSummaryIndex *Index = nullptr,
|
||||
bool GenerateHash = false, ModuleHash *ModHash = nullptr);
|
||||
|
||||
/// Write the specified thin link bitcode file (i.e., the minimized bitcode
|
||||
/// file) to the buffer specified at construction time. The thin link
|
||||
/// bitcode file is used for thin link, and it only contains the necessary
|
||||
/// information for thin link.
|
||||
///
|
||||
/// ModHash is for use in ThinLTO incremental build, generated while the
|
||||
/// IR bitcode file writing.
|
||||
void writeThinLinkBitcode(const Module *M, const ModuleSummaryIndex &Index,
|
||||
const ModuleHash &ModHash);
|
||||
|
||||
void writeIndex(
|
||||
const ModuleSummaryIndex *Index,
|
||||
const std::map<std::string, GVSummaryMapTy> *ModuleToSummariesForIndex);
|
||||
};
|
||||
|
||||
/// \brief Write the specified module to the specified raw output stream.
|
||||
///
|
||||
/// For streams where it matters, the given stream should be in "binary"
|
||||
/// mode.
|
||||
///
|
||||
/// If \c ShouldPreserveUseListOrder, encode the use-list order for each \a
|
||||
/// Value in \c M. These will be reconstructed exactly when \a M is
|
||||
/// deserialized.
|
||||
///
|
||||
/// If \c Index is supplied, the bitcode will contain the summary index
|
||||
/// (currently for use in ThinLTO optimization).
|
||||
///
|
||||
/// \p GenerateHash enables hashing the Module and including the hash in the
|
||||
/// bitcode (currently for use in ThinLTO incremental build).
|
||||
///
|
||||
/// If \p ModHash is non-null, when GenerateHash is true, the resulting
|
||||
/// hash is written into ModHash. When GenerateHash is false, that value
|
||||
/// is used as the hash instead of computing from the generated bitcode.
|
||||
/// Can be used to produce the same module hash for a minimized bitcode
|
||||
/// used just for the thin link as in the regular full bitcode that will
|
||||
/// be used in the backend.
|
||||
void WriteBitcodeToFile(const Module *M, raw_ostream &Out,
|
||||
bool ShouldPreserveUseListOrder = false,
|
||||
const ModuleSummaryIndex *Index = nullptr,
|
||||
bool GenerateHash = false,
|
||||
ModuleHash *ModHash = nullptr);
|
||||
|
||||
/// Write the specified thin link bitcode file (i.e., the minimized bitcode
|
||||
/// file) to the given raw output stream, where it will be written in a new
|
||||
/// bitcode block. The thin link bitcode file is used for thin link, and it
|
||||
/// only contains the necessary information for thin link.
|
||||
///
|
||||
/// ModHash is for use in ThinLTO incremental build, generated while the IR
|
||||
/// bitcode file writing.
|
||||
void WriteThinLinkBitcodeToFile(const Module *M, raw_ostream &Out,
|
||||
const ModuleSummaryIndex &Index,
|
||||
const ModuleHash &ModHash);
|
||||
|
||||
/// Write the specified module summary index to the given raw output stream,
|
||||
/// where it will be written in a new bitcode block. This is used when
|
||||
/// writing the combined index file for ThinLTO. When writing a subset of the
|
||||
/// index for a distributed backend, provide the \p ModuleToSummariesForIndex
|
||||
/// map.
|
||||
void WriteIndexToFile(const ModuleSummaryIndex &Index, raw_ostream &Out,
|
||||
const std::map<std::string, GVSummaryMapTy>
|
||||
*ModuleToSummariesForIndex = nullptr);
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_BITCODE_BITCODEWRITER_H
|
||||
@@ -0,0 +1,75 @@
|
||||
//===-- BitcodeWriterPass.h - Bitcode writing pass --------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// \file
|
||||
///
|
||||
/// This file provides a bitcode writing pass.
|
||||
///
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITCODEWRITERPASS_H
|
||||
#define LLVM_BITCODE_BITCODEWRITERPASS_H
|
||||
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/PassManager.h"
|
||||
|
||||
namespace llvm {
|
||||
class Module;
|
||||
class ModulePass;
|
||||
class raw_ostream;
|
||||
|
||||
/// \brief Create and return a pass that writes the module to the specified
|
||||
/// ostream. Note that this pass is designed for use with the legacy pass
|
||||
/// manager.
|
||||
///
|
||||
/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
|
||||
/// reproduced when deserialized.
|
||||
///
|
||||
/// If \c EmitSummaryIndex, emit the summary index (currently for use in ThinLTO
|
||||
/// optimization).
|
||||
///
|
||||
/// If \c EmitModuleHash, compute and emit the module hash in the bitcode
|
||||
/// (currently for use in ThinLTO incremental build).
|
||||
ModulePass *createBitcodeWriterPass(raw_ostream &Str,
|
||||
bool ShouldPreserveUseListOrder = false,
|
||||
bool EmitSummaryIndex = false,
|
||||
bool EmitModuleHash = false);
|
||||
|
||||
/// \brief Pass for writing a module of IR out to a bitcode file.
|
||||
///
|
||||
/// Note that this is intended for use with the new pass manager. To construct
|
||||
/// a pass for the legacy pass manager, use the function above.
|
||||
class BitcodeWriterPass : public PassInfoMixin<BitcodeWriterPass> {
|
||||
raw_ostream &OS;
|
||||
bool ShouldPreserveUseListOrder;
|
||||
bool EmitSummaryIndex;
|
||||
bool EmitModuleHash;
|
||||
|
||||
public:
|
||||
/// \brief Construct a bitcode writer pass around a particular output stream.
|
||||
///
|
||||
/// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
|
||||
/// reproduced when deserialized.
|
||||
///
|
||||
/// If \c EmitSummaryIndex, emit the summary index (currently
|
||||
/// for use in ThinLTO optimization).
|
||||
explicit BitcodeWriterPass(raw_ostream &OS,
|
||||
bool ShouldPreserveUseListOrder = false,
|
||||
bool EmitSummaryIndex = false,
|
||||
bool EmitModuleHash = false)
|
||||
: OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
|
||||
EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {}
|
||||
|
||||
/// \brief Run the bitcode writer pass, and output the module to the selected
|
||||
/// output stream.
|
||||
PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,506 @@
|
||||
//===- BitstreamReader.h - Low-level bitstream reader interface -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header defines the BitstreamReader class. This class can be used to
|
||||
// read an arbitrary bitstream, regardless of its contents.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITSTREAMREADER_H
|
||||
#define LLVM_BITCODE_BITSTREAMREADER_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/Bitcode/BitCodes.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
/// This class maintains the abbreviations read from a block info block.
|
||||
class BitstreamBlockInfo {
|
||||
public:
|
||||
/// This contains information emitted to BLOCKINFO_BLOCK blocks. These
|
||||
/// describe abbreviations that all blocks of the specified ID inherit.
|
||||
struct BlockInfo {
|
||||
unsigned BlockID;
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
|
||||
std::string Name;
|
||||
std::vector<std::pair<unsigned, std::string>> RecordNames;
|
||||
};
|
||||
|
||||
private:
|
||||
std::vector<BlockInfo> BlockInfoRecords;
|
||||
|
||||
public:
|
||||
/// If there is block info for the specified ID, return it, otherwise return
|
||||
/// null.
|
||||
const BlockInfo *getBlockInfo(unsigned BlockID) const {
|
||||
// Common case, the most recent entry matches BlockID.
|
||||
if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
|
||||
return &BlockInfoRecords.back();
|
||||
|
||||
for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
|
||||
i != e; ++i)
|
||||
if (BlockInfoRecords[i].BlockID == BlockID)
|
||||
return &BlockInfoRecords[i];
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
|
||||
if (const BlockInfo *BI = getBlockInfo(BlockID))
|
||||
return *const_cast<BlockInfo*>(BI);
|
||||
|
||||
// Otherwise, add a new record.
|
||||
BlockInfoRecords.emplace_back();
|
||||
BlockInfoRecords.back().BlockID = BlockID;
|
||||
return BlockInfoRecords.back();
|
||||
}
|
||||
};
|
||||
|
||||
/// This represents a position within a bitstream. There may be multiple
|
||||
/// independent cursors reading within one bitstream, each maintaining their
|
||||
/// own local state.
|
||||
class SimpleBitstreamCursor {
|
||||
ArrayRef<uint8_t> BitcodeBytes;
|
||||
size_t NextChar = 0;
|
||||
|
||||
public:
|
||||
/// This is the current data we have pulled from the stream but have not
|
||||
/// returned to the client. This is specifically and intentionally defined to
|
||||
/// follow the word size of the host machine for efficiency. We use word_t in
|
||||
/// places that are aware of this to make it perfectly explicit what is going
|
||||
/// on.
|
||||
using word_t = size_t;
|
||||
|
||||
private:
|
||||
word_t CurWord = 0;
|
||||
|
||||
/// This is the number of bits in CurWord that are valid. This is always from
|
||||
/// [0...bits_of(size_t)-1] inclusive.
|
||||
unsigned BitsInCurWord = 0;
|
||||
|
||||
public:
|
||||
static const size_t MaxChunkSize = sizeof(word_t) * 8;
|
||||
|
||||
SimpleBitstreamCursor() = default;
|
||||
explicit SimpleBitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
|
||||
: BitcodeBytes(BitcodeBytes) {}
|
||||
explicit SimpleBitstreamCursor(StringRef BitcodeBytes)
|
||||
: BitcodeBytes(reinterpret_cast<const uint8_t *>(BitcodeBytes.data()),
|
||||
BitcodeBytes.size()) {}
|
||||
explicit SimpleBitstreamCursor(MemoryBufferRef BitcodeBytes)
|
||||
: SimpleBitstreamCursor(BitcodeBytes.getBuffer()) {}
|
||||
|
||||
bool canSkipToPos(size_t pos) const {
|
||||
// pos can be skipped to if it is a valid address or one byte past the end.
|
||||
return pos <= BitcodeBytes.size();
|
||||
}
|
||||
|
||||
bool AtEndOfStream() {
|
||||
return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
|
||||
}
|
||||
|
||||
/// Return the bit # of the bit we are reading.
|
||||
uint64_t GetCurrentBitNo() const {
|
||||
return NextChar*CHAR_BIT - BitsInCurWord;
|
||||
}
|
||||
|
||||
// Return the byte # of the current bit.
|
||||
uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }
|
||||
|
||||
ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
|
||||
|
||||
/// Reset the stream to the specified bit number.
|
||||
void JumpToBit(uint64_t BitNo) {
|
||||
size_t ByteNo = size_t(BitNo/8) & ~(sizeof(word_t)-1);
|
||||
unsigned WordBitNo = unsigned(BitNo & (sizeof(word_t)*8-1));
|
||||
assert(canSkipToPos(ByteNo) && "Invalid location");
|
||||
|
||||
// Move the cursor to the right word.
|
||||
NextChar = ByteNo;
|
||||
BitsInCurWord = 0;
|
||||
|
||||
// Skip over any bits that are already consumed.
|
||||
if (WordBitNo)
|
||||
Read(WordBitNo);
|
||||
}
|
||||
|
||||
/// Get a pointer into the bitstream at the specified byte offset.
|
||||
const uint8_t *getPointerToByte(uint64_t ByteNo, uint64_t NumBytes) {
|
||||
return BitcodeBytes.data() + ByteNo;
|
||||
}
|
||||
|
||||
/// Get a pointer into the bitstream at the specified bit offset.
|
||||
///
|
||||
/// The bit offset must be on a byte boundary.
|
||||
const uint8_t *getPointerToBit(uint64_t BitNo, uint64_t NumBytes) {
|
||||
assert(!(BitNo % 8) && "Expected bit on byte boundary");
|
||||
return getPointerToByte(BitNo / 8, NumBytes);
|
||||
}
|
||||
|
||||
void fillCurWord() {
|
||||
if (NextChar >= BitcodeBytes.size())
|
||||
report_fatal_error("Unexpected end of file");
|
||||
|
||||
// Read the next word from the stream.
|
||||
const uint8_t *NextCharPtr = BitcodeBytes.data() + NextChar;
|
||||
unsigned BytesRead;
|
||||
if (BitcodeBytes.size() >= NextChar + sizeof(word_t)) {
|
||||
BytesRead = sizeof(word_t);
|
||||
CurWord =
|
||||
support::endian::read<word_t, support::little, support::unaligned>(
|
||||
NextCharPtr);
|
||||
} else {
|
||||
// Short read.
|
||||
BytesRead = BitcodeBytes.size() - NextChar;
|
||||
CurWord = 0;
|
||||
for (unsigned B = 0; B != BytesRead; ++B)
|
||||
CurWord |= uint64_t(NextCharPtr[B]) << (B * 8);
|
||||
}
|
||||
NextChar += BytesRead;
|
||||
BitsInCurWord = BytesRead * 8;
|
||||
}
|
||||
|
||||
word_t Read(unsigned NumBits) {
|
||||
static const unsigned BitsInWord = MaxChunkSize;
|
||||
|
||||
assert(NumBits && NumBits <= BitsInWord &&
|
||||
"Cannot return zero or more than BitsInWord bits!");
|
||||
|
||||
static const unsigned Mask = sizeof(word_t) > 4 ? 0x3f : 0x1f;
|
||||
|
||||
// If the field is fully contained by CurWord, return it quickly.
|
||||
if (BitsInCurWord >= NumBits) {
|
||||
word_t R = CurWord & (~word_t(0) >> (BitsInWord - NumBits));
|
||||
|
||||
// Use a mask to avoid undefined behavior.
|
||||
CurWord >>= (NumBits & Mask);
|
||||
|
||||
BitsInCurWord -= NumBits;
|
||||
return R;
|
||||
}
|
||||
|
||||
word_t R = BitsInCurWord ? CurWord : 0;
|
||||
unsigned BitsLeft = NumBits - BitsInCurWord;
|
||||
|
||||
fillCurWord();
|
||||
|
||||
// If we run out of data, abort.
|
||||
if (BitsLeft > BitsInCurWord)
|
||||
report_fatal_error("Unexpected end of file");
|
||||
|
||||
word_t R2 = CurWord & (~word_t(0) >> (BitsInWord - BitsLeft));
|
||||
|
||||
// Use a mask to avoid undefined behavior.
|
||||
CurWord >>= (BitsLeft & Mask);
|
||||
|
||||
BitsInCurWord -= BitsLeft;
|
||||
|
||||
R |= R2 << (NumBits - BitsLeft);
|
||||
|
||||
return R;
|
||||
}
|
||||
|
||||
uint32_t ReadVBR(unsigned NumBits) {
|
||||
uint32_t Piece = Read(NumBits);
|
||||
if ((Piece & (1U << (NumBits-1))) == 0)
|
||||
return Piece;
|
||||
|
||||
uint32_t Result = 0;
|
||||
unsigned NextBit = 0;
|
||||
while (true) {
|
||||
Result |= (Piece & ((1U << (NumBits-1))-1)) << NextBit;
|
||||
|
||||
if ((Piece & (1U << (NumBits-1))) == 0)
|
||||
return Result;
|
||||
|
||||
NextBit += NumBits-1;
|
||||
Piece = Read(NumBits);
|
||||
}
|
||||
}
|
||||
|
||||
// Read a VBR that may have a value up to 64-bits in size. The chunk size of
|
||||
// the VBR must still be <= 32 bits though.
|
||||
uint64_t ReadVBR64(unsigned NumBits) {
|
||||
uint32_t Piece = Read(NumBits);
|
||||
if ((Piece & (1U << (NumBits-1))) == 0)
|
||||
return uint64_t(Piece);
|
||||
|
||||
uint64_t Result = 0;
|
||||
unsigned NextBit = 0;
|
||||
while (true) {
|
||||
Result |= uint64_t(Piece & ((1U << (NumBits-1))-1)) << NextBit;
|
||||
|
||||
if ((Piece & (1U << (NumBits-1))) == 0)
|
||||
return Result;
|
||||
|
||||
NextBit += NumBits-1;
|
||||
Piece = Read(NumBits);
|
||||
}
|
||||
}
|
||||
|
||||
void SkipToFourByteBoundary() {
|
||||
// If word_t is 64-bits and if we've read less than 32 bits, just dump
|
||||
// the bits we have up to the next 32-bit boundary.
|
||||
if (sizeof(word_t) > 4 &&
|
||||
BitsInCurWord >= 32) {
|
||||
CurWord >>= BitsInCurWord-32;
|
||||
BitsInCurWord = 32;
|
||||
return;
|
||||
}
|
||||
|
||||
BitsInCurWord = 0;
|
||||
}
|
||||
|
||||
/// Skip to the end of the file.
|
||||
void skipToEnd() { NextChar = BitcodeBytes.size(); }
|
||||
};
|
||||
|
||||
/// When advancing through a bitstream cursor, each advance can discover a few
|
||||
/// different kinds of entries:
|
||||
struct BitstreamEntry {
|
||||
enum {
|
||||
Error, // Malformed bitcode was found.
|
||||
EndBlock, // We've reached the end of the current block, (or the end of the
|
||||
// file, which is treated like a series of EndBlock records.
|
||||
SubBlock, // This is the start of a new subblock of a specific ID.
|
||||
Record // This is a record with a specific AbbrevID.
|
||||
} Kind;
|
||||
|
||||
unsigned ID;
|
||||
|
||||
static BitstreamEntry getError() {
|
||||
BitstreamEntry E; E.Kind = Error; return E;
|
||||
}
|
||||
|
||||
static BitstreamEntry getEndBlock() {
|
||||
BitstreamEntry E; E.Kind = EndBlock; return E;
|
||||
}
|
||||
|
||||
static BitstreamEntry getSubBlock(unsigned ID) {
|
||||
BitstreamEntry E; E.Kind = SubBlock; E.ID = ID; return E;
|
||||
}
|
||||
|
||||
static BitstreamEntry getRecord(unsigned AbbrevID) {
|
||||
BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
|
||||
}
|
||||
};
|
||||
|
||||
/// This represents a position within a bitcode file, implemented on top of a
|
||||
/// SimpleBitstreamCursor.
|
||||
///
|
||||
/// Unlike iterators, BitstreamCursors are heavy-weight objects that should not
|
||||
/// be passed by value.
|
||||
class BitstreamCursor : SimpleBitstreamCursor {
|
||||
// This is the declared size of code values used for the current block, in
|
||||
// bits.
|
||||
unsigned CurCodeSize = 2;
|
||||
|
||||
/// Abbrevs installed at in this block.
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
|
||||
|
||||
struct Block {
|
||||
unsigned PrevCodeSize;
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
|
||||
|
||||
explicit Block(unsigned PCS) : PrevCodeSize(PCS) {}
|
||||
};
|
||||
|
||||
/// This tracks the codesize of parent blocks.
|
||||
SmallVector<Block, 8> BlockScope;
|
||||
|
||||
BitstreamBlockInfo *BlockInfo = nullptr;
|
||||
|
||||
public:
|
||||
static const size_t MaxChunkSize = sizeof(word_t) * 8;
|
||||
|
||||
BitstreamCursor() = default;
|
||||
explicit BitstreamCursor(ArrayRef<uint8_t> BitcodeBytes)
|
||||
: SimpleBitstreamCursor(BitcodeBytes) {}
|
||||
explicit BitstreamCursor(StringRef BitcodeBytes)
|
||||
: SimpleBitstreamCursor(BitcodeBytes) {}
|
||||
explicit BitstreamCursor(MemoryBufferRef BitcodeBytes)
|
||||
: SimpleBitstreamCursor(BitcodeBytes) {}
|
||||
|
||||
using SimpleBitstreamCursor::canSkipToPos;
|
||||
using SimpleBitstreamCursor::AtEndOfStream;
|
||||
using SimpleBitstreamCursor::getBitcodeBytes;
|
||||
using SimpleBitstreamCursor::GetCurrentBitNo;
|
||||
using SimpleBitstreamCursor::getCurrentByteNo;
|
||||
using SimpleBitstreamCursor::getPointerToByte;
|
||||
using SimpleBitstreamCursor::JumpToBit;
|
||||
using SimpleBitstreamCursor::fillCurWord;
|
||||
using SimpleBitstreamCursor::Read;
|
||||
using SimpleBitstreamCursor::ReadVBR;
|
||||
using SimpleBitstreamCursor::ReadVBR64;
|
||||
|
||||
/// Return the number of bits used to encode an abbrev #.
|
||||
unsigned getAbbrevIDWidth() const { return CurCodeSize; }
|
||||
|
||||
/// Flags that modify the behavior of advance().
|
||||
enum {
|
||||
/// If this flag is used, the advance() method does not automatically pop
|
||||
/// the block scope when the end of a block is reached.
|
||||
AF_DontPopBlockAtEnd = 1,
|
||||
|
||||
/// If this flag is used, abbrev entries are returned just like normal
|
||||
/// records.
|
||||
AF_DontAutoprocessAbbrevs = 2
|
||||
};
|
||||
|
||||
/// Advance the current bitstream, returning the next entry in the stream.
|
||||
BitstreamEntry advance(unsigned Flags = 0) {
|
||||
while (true) {
|
||||
if (AtEndOfStream())
|
||||
return BitstreamEntry::getError();
|
||||
|
||||
unsigned Code = ReadCode();
|
||||
if (Code == bitc::END_BLOCK) {
|
||||
// Pop the end of the block unless Flags tells us not to.
|
||||
if (!(Flags & AF_DontPopBlockAtEnd) && ReadBlockEnd())
|
||||
return BitstreamEntry::getError();
|
||||
return BitstreamEntry::getEndBlock();
|
||||
}
|
||||
|
||||
if (Code == bitc::ENTER_SUBBLOCK)
|
||||
return BitstreamEntry::getSubBlock(ReadSubBlockID());
|
||||
|
||||
if (Code == bitc::DEFINE_ABBREV &&
|
||||
!(Flags & AF_DontAutoprocessAbbrevs)) {
|
||||
// We read and accumulate abbrev's, the client can't do anything with
|
||||
// them anyway.
|
||||
ReadAbbrevRecord();
|
||||
continue;
|
||||
}
|
||||
|
||||
return BitstreamEntry::getRecord(Code);
|
||||
}
|
||||
}
|
||||
|
||||
/// This is a convenience function for clients that don't expect any
|
||||
/// subblocks. This just skips over them automatically.
|
||||
BitstreamEntry advanceSkippingSubblocks(unsigned Flags = 0) {
|
||||
while (true) {
|
||||
// If we found a normal entry, return it.
|
||||
BitstreamEntry Entry = advance(Flags);
|
||||
if (Entry.Kind != BitstreamEntry::SubBlock)
|
||||
return Entry;
|
||||
|
||||
// If we found a sub-block, just skip over it and check the next entry.
|
||||
if (SkipBlock())
|
||||
return BitstreamEntry::getError();
|
||||
}
|
||||
}
|
||||
|
||||
unsigned ReadCode() {
|
||||
return Read(CurCodeSize);
|
||||
}
|
||||
|
||||
// Block header:
|
||||
// [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
|
||||
|
||||
/// Having read the ENTER_SUBBLOCK code, read the BlockID for the block.
|
||||
unsigned ReadSubBlockID() {
|
||||
return ReadVBR(bitc::BlockIDWidth);
|
||||
}
|
||||
|
||||
/// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
|
||||
/// of this block. If the block record is malformed, return true.
|
||||
bool SkipBlock() {
|
||||
// Read and ignore the codelen value. Since we are skipping this block, we
|
||||
// don't care what code widths are used inside of it.
|
||||
ReadVBR(bitc::CodeLenWidth);
|
||||
SkipToFourByteBoundary();
|
||||
unsigned NumFourBytes = Read(bitc::BlockSizeWidth);
|
||||
|
||||
// Check that the block wasn't partially defined, and that the offset isn't
|
||||
// bogus.
|
||||
size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
|
||||
if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
|
||||
return true;
|
||||
|
||||
JumpToBit(SkipTo);
|
||||
return false;
|
||||
}
|
||||
|
||||
/// Having read the ENTER_SUBBLOCK abbrevid, enter the block, and return true
|
||||
/// if the block has an error.
|
||||
bool EnterSubBlock(unsigned BlockID, unsigned *NumWordsP = nullptr);
|
||||
|
||||
bool ReadBlockEnd() {
|
||||
if (BlockScope.empty()) return true;
|
||||
|
||||
// Block tail:
|
||||
// [END_BLOCK, <align4bytes>]
|
||||
SkipToFourByteBoundary();
|
||||
|
||||
popBlockScope();
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
void popBlockScope() {
|
||||
CurCodeSize = BlockScope.back().PrevCodeSize;
|
||||
|
||||
CurAbbrevs = std::move(BlockScope.back().PrevAbbrevs);
|
||||
BlockScope.pop_back();
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Record Processing
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
public:
|
||||
/// Return the abbreviation for the specified AbbrevId.
|
||||
const BitCodeAbbrev *getAbbrev(unsigned AbbrevID) {
|
||||
unsigned AbbrevNo = AbbrevID - bitc::FIRST_APPLICATION_ABBREV;
|
||||
if (AbbrevNo >= CurAbbrevs.size())
|
||||
report_fatal_error("Invalid abbrev number");
|
||||
return CurAbbrevs[AbbrevNo].get();
|
||||
}
|
||||
|
||||
/// Read the current record and discard it, returning the code for the record.
|
||||
unsigned skipRecord(unsigned AbbrevID);
|
||||
|
||||
unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
|
||||
StringRef *Blob = nullptr);
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Abbrev Processing
|
||||
//===--------------------------------------------------------------------===//
|
||||
void ReadAbbrevRecord();
|
||||
|
||||
/// Read and return a block info block from the bitstream. If an error was
|
||||
/// encountered, return None.
|
||||
///
|
||||
/// \param ReadBlockInfoNames Whether to read block/record name information in
|
||||
/// the BlockInfo block. Only llvm-bcanalyzer uses this.
|
||||
Optional<BitstreamBlockInfo>
|
||||
ReadBlockInfoBlock(bool ReadBlockInfoNames = false);
|
||||
|
||||
/// Set the block info to be used by this BitstreamCursor to interpret
|
||||
/// abbreviated records.
|
||||
void setBlockInfo(BitstreamBlockInfo *BI) { BlockInfo = BI; }
|
||||
};
|
||||
|
||||
} // end llvm namespace
|
||||
|
||||
#endif // LLVM_BITCODE_BITSTREAMREADER_H
|
||||
@@ -0,0 +1,550 @@
|
||||
//===- BitstreamWriter.h - Low-level bitstream writer interface -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header defines the BitstreamWriter class. This class can be used to
|
||||
// write an arbitrary bitstream, regardless of its contents.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_BITSTREAMWRITER_H
|
||||
#define LLVM_BITCODE_BITSTREAMWRITER_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/Optional.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Bitcode/BitCodes.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class BitstreamWriter {
|
||||
SmallVectorImpl<char> &Out;
|
||||
|
||||
/// CurBit - Always between 0 and 31 inclusive, specifies the next bit to use.
|
||||
unsigned CurBit;
|
||||
|
||||
/// CurValue - The current value. Only bits < CurBit are valid.
|
||||
uint32_t CurValue;
|
||||
|
||||
/// CurCodeSize - This is the declared size of code values used for the
|
||||
/// current block, in bits.
|
||||
unsigned CurCodeSize;
|
||||
|
||||
/// BlockInfoCurBID - When emitting a BLOCKINFO_BLOCK, this is the currently
|
||||
/// selected BLOCK ID.
|
||||
unsigned BlockInfoCurBID;
|
||||
|
||||
/// CurAbbrevs - Abbrevs installed at in this block.
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> CurAbbrevs;
|
||||
|
||||
struct Block {
|
||||
unsigned PrevCodeSize;
|
||||
size_t StartSizeWord;
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> PrevAbbrevs;
|
||||
Block(unsigned PCS, size_t SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
|
||||
};
|
||||
|
||||
/// BlockScope - This tracks the current blocks that we have entered.
|
||||
std::vector<Block> BlockScope;
|
||||
|
||||
/// BlockInfo - This contains information emitted to BLOCKINFO_BLOCK blocks.
|
||||
/// These describe abbreviations that all blocks of the specified ID inherit.
|
||||
struct BlockInfo {
|
||||
unsigned BlockID;
|
||||
std::vector<std::shared_ptr<BitCodeAbbrev>> Abbrevs;
|
||||
};
|
||||
std::vector<BlockInfo> BlockInfoRecords;
|
||||
|
||||
void WriteByte(unsigned char Value) {
|
||||
Out.push_back(Value);
|
||||
}
|
||||
|
||||
void WriteWord(unsigned Value) {
|
||||
Value = support::endian::byte_swap<uint32_t, support::little>(Value);
|
||||
Out.append(reinterpret_cast<const char *>(&Value),
|
||||
reinterpret_cast<const char *>(&Value + 1));
|
||||
}
|
||||
|
||||
size_t GetBufferOffset() const { return Out.size(); }
|
||||
|
||||
size_t GetWordIndex() const {
|
||||
size_t Offset = GetBufferOffset();
|
||||
assert((Offset & 3) == 0 && "Not 32-bit aligned");
|
||||
return Offset / 4;
|
||||
}
|
||||
|
||||
public:
|
||||
explicit BitstreamWriter(SmallVectorImpl<char> &O)
|
||||
: Out(O), CurBit(0), CurValue(0), CurCodeSize(2) {}
|
||||
|
||||
~BitstreamWriter() {
|
||||
assert(CurBit == 0 && "Unflushed data remaining");
|
||||
assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
|
||||
}
|
||||
|
||||
/// \brief Retrieve the current position in the stream, in bits.
|
||||
uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }
|
||||
|
||||
/// \brief Retrieve the number of bits currently used to encode an abbrev ID.
|
||||
unsigned GetAbbrevIDWidth() const { return CurCodeSize; }
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Basic Primitives for emitting bits to the stream.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
/// Backpatch a 32-bit word in the output at the given bit offset
|
||||
/// with the specified value.
|
||||
void BackpatchWord(uint64_t BitNo, unsigned NewWord) {
|
||||
using namespace llvm::support;
|
||||
unsigned ByteNo = BitNo / 8;
|
||||
assert((!endian::readAtBitAlignment<uint32_t, little, unaligned>(
|
||||
&Out[ByteNo], BitNo & 7)) &&
|
||||
"Expected to be patching over 0-value placeholders");
|
||||
endian::writeAtBitAlignment<uint32_t, little, unaligned>(
|
||||
&Out[ByteNo], NewWord, BitNo & 7);
|
||||
}
|
||||
|
||||
void BackpatchWord64(uint64_t BitNo, uint64_t Val) {
|
||||
BackpatchWord(BitNo, (uint32_t)Val);
|
||||
BackpatchWord(BitNo + 32, (uint32_t)(Val >> 32));
|
||||
}
|
||||
|
||||
void Emit(uint32_t Val, unsigned NumBits) {
|
||||
assert(NumBits && NumBits <= 32 && "Invalid value size!");
|
||||
assert((Val & ~(~0U >> (32-NumBits))) == 0 && "High bits set!");
|
||||
CurValue |= Val << CurBit;
|
||||
if (CurBit + NumBits < 32) {
|
||||
CurBit += NumBits;
|
||||
return;
|
||||
}
|
||||
|
||||
// Add the current word.
|
||||
WriteWord(CurValue);
|
||||
|
||||
if (CurBit)
|
||||
CurValue = Val >> (32-CurBit);
|
||||
else
|
||||
CurValue = 0;
|
||||
CurBit = (CurBit+NumBits) & 31;
|
||||
}
|
||||
|
||||
void FlushToWord() {
|
||||
if (CurBit) {
|
||||
WriteWord(CurValue);
|
||||
CurBit = 0;
|
||||
CurValue = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void EmitVBR(uint32_t Val, unsigned NumBits) {
|
||||
assert(NumBits <= 32 && "Too many bits to emit!");
|
||||
uint32_t Threshold = 1U << (NumBits-1);
|
||||
|
||||
// Emit the bits with VBR encoding, NumBits-1 bits at a time.
|
||||
while (Val >= Threshold) {
|
||||
Emit((Val & ((1 << (NumBits-1))-1)) | (1 << (NumBits-1)), NumBits);
|
||||
Val >>= NumBits-1;
|
||||
}
|
||||
|
||||
Emit(Val, NumBits);
|
||||
}
|
||||
|
||||
void EmitVBR64(uint64_t Val, unsigned NumBits) {
|
||||
assert(NumBits <= 32 && "Too many bits to emit!");
|
||||
if ((uint32_t)Val == Val)
|
||||
return EmitVBR((uint32_t)Val, NumBits);
|
||||
|
||||
uint32_t Threshold = 1U << (NumBits-1);
|
||||
|
||||
// Emit the bits with VBR encoding, NumBits-1 bits at a time.
|
||||
while (Val >= Threshold) {
|
||||
Emit(((uint32_t)Val & ((1 << (NumBits-1))-1)) |
|
||||
(1 << (NumBits-1)), NumBits);
|
||||
Val >>= NumBits-1;
|
||||
}
|
||||
|
||||
Emit((uint32_t)Val, NumBits);
|
||||
}
|
||||
|
||||
/// EmitCode - Emit the specified code.
|
||||
void EmitCode(unsigned Val) {
|
||||
Emit(Val, CurCodeSize);
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Block Manipulation
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
/// getBlockInfo - If there is block info for the specified ID, return it,
|
||||
/// otherwise return null.
|
||||
BlockInfo *getBlockInfo(unsigned BlockID) {
|
||||
// Common case, the most recent entry matches BlockID.
|
||||
if (!BlockInfoRecords.empty() && BlockInfoRecords.back().BlockID == BlockID)
|
||||
return &BlockInfoRecords.back();
|
||||
|
||||
for (unsigned i = 0, e = static_cast<unsigned>(BlockInfoRecords.size());
|
||||
i != e; ++i)
|
||||
if (BlockInfoRecords[i].BlockID == BlockID)
|
||||
return &BlockInfoRecords[i];
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void EnterSubblock(unsigned BlockID, unsigned CodeLen) {
|
||||
// Block header:
|
||||
// [ENTER_SUBBLOCK, blockid, newcodelen, <align4bytes>, blocklen]
|
||||
EmitCode(bitc::ENTER_SUBBLOCK);
|
||||
EmitVBR(BlockID, bitc::BlockIDWidth);
|
||||
EmitVBR(CodeLen, bitc::CodeLenWidth);
|
||||
FlushToWord();
|
||||
|
||||
size_t BlockSizeWordIndex = GetWordIndex();
|
||||
unsigned OldCodeSize = CurCodeSize;
|
||||
|
||||
// Emit a placeholder, which will be replaced when the block is popped.
|
||||
Emit(0, bitc::BlockSizeWidth);
|
||||
|
||||
CurCodeSize = CodeLen;
|
||||
|
||||
// Push the outer block's abbrev set onto the stack, start out with an
|
||||
// empty abbrev set.
|
||||
BlockScope.emplace_back(OldCodeSize, BlockSizeWordIndex);
|
||||
BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
|
||||
|
||||
// If there is a blockinfo for this BlockID, add all the predefined abbrevs
|
||||
// to the abbrev list.
|
||||
if (BlockInfo *Info = getBlockInfo(BlockID)) {
|
||||
CurAbbrevs.insert(CurAbbrevs.end(), Info->Abbrevs.begin(),
|
||||
Info->Abbrevs.end());
|
||||
}
|
||||
}
|
||||
|
||||
void ExitBlock() {
|
||||
assert(!BlockScope.empty() && "Block scope imbalance!");
|
||||
const Block &B = BlockScope.back();
|
||||
|
||||
// Block tail:
|
||||
// [END_BLOCK, <align4bytes>]
|
||||
EmitCode(bitc::END_BLOCK);
|
||||
FlushToWord();
|
||||
|
||||
// Compute the size of the block, in words, not counting the size field.
|
||||
size_t SizeInWords = GetWordIndex() - B.StartSizeWord - 1;
|
||||
uint64_t BitNo = uint64_t(B.StartSizeWord) * 32;
|
||||
|
||||
// Update the block size field in the header of this sub-block.
|
||||
BackpatchWord(BitNo, SizeInWords);
|
||||
|
||||
// Restore the inner block's code size and abbrev table.
|
||||
CurCodeSize = B.PrevCodeSize;
|
||||
CurAbbrevs = std::move(B.PrevAbbrevs);
|
||||
BlockScope.pop_back();
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Record Emission
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
private:
|
||||
/// EmitAbbreviatedLiteral - Emit a literal value according to its abbrev
|
||||
/// record. This is a no-op, since the abbrev specifies the literal to use.
|
||||
template<typename uintty>
|
||||
void EmitAbbreviatedLiteral(const BitCodeAbbrevOp &Op, uintty V) {
|
||||
assert(Op.isLiteral() && "Not a literal");
|
||||
// If the abbrev specifies the literal value to use, don't emit
|
||||
// anything.
|
||||
assert(V == Op.getLiteralValue() &&
|
||||
"Invalid abbrev for record!");
|
||||
}
|
||||
|
||||
/// EmitAbbreviatedField - Emit a single scalar field value with the specified
|
||||
/// encoding.
|
||||
template<typename uintty>
|
||||
void EmitAbbreviatedField(const BitCodeAbbrevOp &Op, uintty V) {
|
||||
assert(!Op.isLiteral() && "Literals should use EmitAbbreviatedLiteral!");
|
||||
|
||||
// Encode the value as we are commanded.
|
||||
switch (Op.getEncoding()) {
|
||||
default: llvm_unreachable("Unknown encoding!");
|
||||
case BitCodeAbbrevOp::Fixed:
|
||||
if (Op.getEncodingData())
|
||||
Emit((unsigned)V, (unsigned)Op.getEncodingData());
|
||||
break;
|
||||
case BitCodeAbbrevOp::VBR:
|
||||
if (Op.getEncodingData())
|
||||
EmitVBR64(V, (unsigned)Op.getEncodingData());
|
||||
break;
|
||||
case BitCodeAbbrevOp::Char6:
|
||||
Emit(BitCodeAbbrevOp::EncodeChar6((char)V), 6);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/// EmitRecordWithAbbrevImpl - This is the core implementation of the record
|
||||
/// emission code. If BlobData is non-null, then it specifies an array of
|
||||
/// data that should be emitted as part of the Blob or Array operand that is
|
||||
/// known to exist at the end of the record. If Code is specified, then
|
||||
/// it is the record code to emit before the Vals, which must not contain
|
||||
/// the code.
|
||||
template <typename uintty>
|
||||
void EmitRecordWithAbbrevImpl(unsigned Abbrev, ArrayRef<uintty> Vals,
|
||||
StringRef Blob, Optional<unsigned> Code) {
|
||||
const char *BlobData = Blob.data();
|
||||
unsigned BlobLen = (unsigned) Blob.size();
|
||||
unsigned AbbrevNo = Abbrev-bitc::FIRST_APPLICATION_ABBREV;
|
||||
assert(AbbrevNo < CurAbbrevs.size() && "Invalid abbrev #!");
|
||||
const BitCodeAbbrev *Abbv = CurAbbrevs[AbbrevNo].get();
|
||||
|
||||
EmitCode(Abbrev);
|
||||
|
||||
unsigned i = 0, e = static_cast<unsigned>(Abbv->getNumOperandInfos());
|
||||
if (Code) {
|
||||
assert(e && "Expected non-empty abbreviation");
|
||||
const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i++);
|
||||
|
||||
if (Op.isLiteral())
|
||||
EmitAbbreviatedLiteral(Op, Code.getValue());
|
||||
else {
|
||||
assert(Op.getEncoding() != BitCodeAbbrevOp::Array &&
|
||||
Op.getEncoding() != BitCodeAbbrevOp::Blob &&
|
||||
"Expected literal or scalar");
|
||||
EmitAbbreviatedField(Op, Code.getValue());
|
||||
}
|
||||
}
|
||||
|
||||
unsigned RecordIdx = 0;
|
||||
for (; i != e; ++i) {
|
||||
const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i);
|
||||
if (Op.isLiteral()) {
|
||||
assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
|
||||
EmitAbbreviatedLiteral(Op, Vals[RecordIdx]);
|
||||
++RecordIdx;
|
||||
} else if (Op.getEncoding() == BitCodeAbbrevOp::Array) {
|
||||
// Array case.
|
||||
assert(i + 2 == e && "array op not second to last?");
|
||||
const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
|
||||
|
||||
// If this record has blob data, emit it, otherwise we must have record
|
||||
// entries to encode this way.
|
||||
if (BlobData) {
|
||||
assert(RecordIdx == Vals.size() &&
|
||||
"Blob data and record entries specified for array!");
|
||||
// Emit a vbr6 to indicate the number of elements present.
|
||||
EmitVBR(static_cast<uint32_t>(BlobLen), 6);
|
||||
|
||||
// Emit each field.
|
||||
for (unsigned i = 0; i != BlobLen; ++i)
|
||||
EmitAbbreviatedField(EltEnc, (unsigned char)BlobData[i]);
|
||||
|
||||
// Know that blob data is consumed for assertion below.
|
||||
BlobData = nullptr;
|
||||
} else {
|
||||
// Emit a vbr6 to indicate the number of elements present.
|
||||
EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
|
||||
|
||||
// Emit each field.
|
||||
for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
|
||||
EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
|
||||
}
|
||||
} else if (Op.getEncoding() == BitCodeAbbrevOp::Blob) {
|
||||
// If this record has blob data, emit it, otherwise we must have record
|
||||
// entries to encode this way.
|
||||
|
||||
if (BlobData) {
|
||||
assert(RecordIdx == Vals.size() &&
|
||||
"Blob data and record entries specified for blob operand!");
|
||||
|
||||
assert(Blob.data() == BlobData && "BlobData got moved");
|
||||
assert(Blob.size() == BlobLen && "BlobLen got changed");
|
||||
emitBlob(Blob);
|
||||
BlobData = nullptr;
|
||||
} else {
|
||||
emitBlob(Vals.slice(RecordIdx));
|
||||
}
|
||||
} else { // Single scalar field.
|
||||
assert(RecordIdx < Vals.size() && "Invalid abbrev/record");
|
||||
EmitAbbreviatedField(Op, Vals[RecordIdx]);
|
||||
++RecordIdx;
|
||||
}
|
||||
}
|
||||
assert(RecordIdx == Vals.size() && "Not all record operands emitted!");
|
||||
assert(BlobData == nullptr &&
|
||||
"Blob data specified for record that doesn't use it!");
|
||||
}
|
||||
|
||||
public:
|
||||
/// Emit a blob, including flushing before and tail-padding.
|
||||
template <class UIntTy>
|
||||
void emitBlob(ArrayRef<UIntTy> Bytes, bool ShouldEmitSize = true) {
|
||||
// Emit a vbr6 to indicate the number of elements present.
|
||||
if (ShouldEmitSize)
|
||||
EmitVBR(static_cast<uint32_t>(Bytes.size()), 6);
|
||||
|
||||
// Flush to a 32-bit alignment boundary.
|
||||
FlushToWord();
|
||||
|
||||
// Emit literal bytes.
|
||||
for (const auto &B : Bytes) {
|
||||
assert(isUInt<8>(B) && "Value too large to emit as byte");
|
||||
WriteByte((unsigned char)B);
|
||||
}
|
||||
|
||||
// Align end to 32-bits.
|
||||
while (GetBufferOffset() & 3)
|
||||
WriteByte(0);
|
||||
}
|
||||
void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) {
|
||||
emitBlob(makeArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),
|
||||
ShouldEmitSize);
|
||||
}
|
||||
|
||||
/// EmitRecord - Emit the specified record to the stream, using an abbrev if
|
||||
/// we have one to compress the output.
|
||||
template <typename Container>
|
||||
void EmitRecord(unsigned Code, const Container &Vals, unsigned Abbrev = 0) {
|
||||
if (!Abbrev) {
|
||||
// If we don't have an abbrev to use, emit this in its fully unabbreviated
|
||||
// form.
|
||||
auto Count = static_cast<uint32_t>(makeArrayRef(Vals).size());
|
||||
EmitCode(bitc::UNABBREV_RECORD);
|
||||
EmitVBR(Code, 6);
|
||||
EmitVBR(Count, 6);
|
||||
for (unsigned i = 0, e = Count; i != e; ++i)
|
||||
EmitVBR64(Vals[i], 6);
|
||||
return;
|
||||
}
|
||||
|
||||
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), Code);
|
||||
}
|
||||
|
||||
/// EmitRecordWithAbbrev - Emit a record with the specified abbreviation.
|
||||
/// Unlike EmitRecord, the code for the record should be included in Vals as
|
||||
/// the first entry.
|
||||
template <typename Container>
|
||||
void EmitRecordWithAbbrev(unsigned Abbrev, const Container &Vals) {
|
||||
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), None);
|
||||
}
|
||||
|
||||
/// EmitRecordWithBlob - Emit the specified record to the stream, using an
|
||||
/// abbrev that includes a blob at the end. The blob data to emit is
|
||||
/// specified by the pointer and length specified at the end. In contrast to
|
||||
/// EmitRecord, this routine expects that the first entry in Vals is the code
|
||||
/// of the record.
|
||||
template <typename Container>
|
||||
void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
|
||||
StringRef Blob) {
|
||||
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Blob, None);
|
||||
}
|
||||
template <typename Container>
|
||||
void EmitRecordWithBlob(unsigned Abbrev, const Container &Vals,
|
||||
const char *BlobData, unsigned BlobLen) {
|
||||
return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals),
|
||||
StringRef(BlobData, BlobLen), None);
|
||||
}
|
||||
|
||||
/// EmitRecordWithArray - Just like EmitRecordWithBlob, works with records
|
||||
/// that end with an array.
|
||||
template <typename Container>
|
||||
void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
|
||||
StringRef Array) {
|
||||
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), Array, None);
|
||||
}
|
||||
template <typename Container>
|
||||
void EmitRecordWithArray(unsigned Abbrev, const Container &Vals,
|
||||
const char *ArrayData, unsigned ArrayLen) {
|
||||
return EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals),
|
||||
StringRef(ArrayData, ArrayLen), None);
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Abbrev Emission
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
private:
|
||||
// Emit the abbreviation as a DEFINE_ABBREV record.
|
||||
void EncodeAbbrev(const BitCodeAbbrev &Abbv) {
|
||||
EmitCode(bitc::DEFINE_ABBREV);
|
||||
EmitVBR(Abbv.getNumOperandInfos(), 5);
|
||||
for (unsigned i = 0, e = static_cast<unsigned>(Abbv.getNumOperandInfos());
|
||||
i != e; ++i) {
|
||||
const BitCodeAbbrevOp &Op = Abbv.getOperandInfo(i);
|
||||
Emit(Op.isLiteral(), 1);
|
||||
if (Op.isLiteral()) {
|
||||
EmitVBR64(Op.getLiteralValue(), 8);
|
||||
} else {
|
||||
Emit(Op.getEncoding(), 3);
|
||||
if (Op.hasEncodingData())
|
||||
EmitVBR64(Op.getEncodingData(), 5);
|
||||
}
|
||||
}
|
||||
}
|
||||
public:
|
||||
|
||||
/// EmitAbbrev - This emits an abbreviation to the stream. Note that this
|
||||
/// method takes ownership of the specified abbrev.
|
||||
unsigned EmitAbbrev(std::shared_ptr<BitCodeAbbrev> Abbv) {
|
||||
// Emit the abbreviation as a record.
|
||||
EncodeAbbrev(*Abbv);
|
||||
CurAbbrevs.push_back(std::move(Abbv));
|
||||
return static_cast<unsigned>(CurAbbrevs.size())-1 +
|
||||
bitc::FIRST_APPLICATION_ABBREV;
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// BlockInfo Block Emission
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
/// EnterBlockInfoBlock - Start emitting the BLOCKINFO_BLOCK.
|
||||
void EnterBlockInfoBlock() {
|
||||
EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, 2);
|
||||
BlockInfoCurBID = ~0U;
|
||||
BlockInfoRecords.clear();
|
||||
}
|
||||
private:
|
||||
/// SwitchToBlockID - If we aren't already talking about the specified block
|
||||
/// ID, emit a BLOCKINFO_CODE_SETBID record.
|
||||
void SwitchToBlockID(unsigned BlockID) {
|
||||
if (BlockInfoCurBID == BlockID) return;
|
||||
SmallVector<unsigned, 2> V;
|
||||
V.push_back(BlockID);
|
||||
EmitRecord(bitc::BLOCKINFO_CODE_SETBID, V);
|
||||
BlockInfoCurBID = BlockID;
|
||||
}
|
||||
|
||||
BlockInfo &getOrCreateBlockInfo(unsigned BlockID) {
|
||||
if (BlockInfo *BI = getBlockInfo(BlockID))
|
||||
return *BI;
|
||||
|
||||
// Otherwise, add a new record.
|
||||
BlockInfoRecords.emplace_back();
|
||||
BlockInfoRecords.back().BlockID = BlockID;
|
||||
return BlockInfoRecords.back();
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/// EmitBlockInfoAbbrev - Emit a DEFINE_ABBREV record for the specified
|
||||
/// BlockID.
|
||||
unsigned EmitBlockInfoAbbrev(unsigned BlockID, std::shared_ptr<BitCodeAbbrev> Abbv) {
|
||||
SwitchToBlockID(BlockID);
|
||||
EncodeAbbrev(*Abbv);
|
||||
|
||||
// Add the abbrev to the specified block record.
|
||||
BlockInfo &Info = getOrCreateBlockInfo(BlockID);
|
||||
Info.Abbrevs.push_back(std::move(Abbv));
|
||||
|
||||
return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,584 @@
|
||||
//===- LLVMBitCodes.h - Enum values for the LLVM bitcode format -*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This header defines Bitcode enum values for LLVM IR bitcode files.
|
||||
//
|
||||
// The enum values defined in this file should be considered permanent. If
|
||||
// new features are added, they should have values added at the end of the
|
||||
// respective lists.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#ifndef LLVM_BITCODE_LLVMBITCODES_H
|
||||
#define LLVM_BITCODE_LLVMBITCODES_H
|
||||
|
||||
#include "llvm/Bitcode/BitCodes.h"
|
||||
|
||||
namespace llvm {
|
||||
namespace bitc {
|
||||
// The only top-level block types are MODULE, IDENTIFICATION, STRTAB and SYMTAB.
|
||||
enum BlockIDs {
|
||||
// Blocks
|
||||
MODULE_BLOCK_ID = FIRST_APPLICATION_BLOCKID,
|
||||
|
||||
// Module sub-block id's.
|
||||
PARAMATTR_BLOCK_ID,
|
||||
PARAMATTR_GROUP_BLOCK_ID,
|
||||
|
||||
CONSTANTS_BLOCK_ID,
|
||||
FUNCTION_BLOCK_ID,
|
||||
|
||||
// Block intended to contains information on the bitcode versioning.
|
||||
// Can be used to provide better error messages when we fail to parse a
|
||||
// bitcode file.
|
||||
IDENTIFICATION_BLOCK_ID,
|
||||
|
||||
VALUE_SYMTAB_BLOCK_ID,
|
||||
METADATA_BLOCK_ID,
|
||||
METADATA_ATTACHMENT_ID,
|
||||
|
||||
TYPE_BLOCK_ID_NEW,
|
||||
|
||||
USELIST_BLOCK_ID,
|
||||
|
||||
MODULE_STRTAB_BLOCK_ID,
|
||||
GLOBALVAL_SUMMARY_BLOCK_ID,
|
||||
|
||||
OPERAND_BUNDLE_TAGS_BLOCK_ID,
|
||||
|
||||
METADATA_KIND_BLOCK_ID,
|
||||
|
||||
STRTAB_BLOCK_ID,
|
||||
|
||||
FULL_LTO_GLOBALVAL_SUMMARY_BLOCK_ID,
|
||||
|
||||
SYMTAB_BLOCK_ID,
|
||||
|
||||
SYNC_SCOPE_NAMES_BLOCK_ID,
|
||||
};
|
||||
|
||||
/// Identification block contains a string that describes the producer details,
|
||||
/// and an epoch that defines the auto-upgrade capability.
|
||||
enum IdentificationCodes {
|
||||
IDENTIFICATION_CODE_STRING = 1, // IDENTIFICATION: [strchr x N]
|
||||
IDENTIFICATION_CODE_EPOCH = 2, // EPOCH: [epoch#]
|
||||
};
|
||||
|
||||
/// The epoch that defines the auto-upgrade compatibility for the bitcode.
|
||||
///
|
||||
/// LLVM guarantees in a major release that a minor release can read bitcode
|
||||
/// generated by previous minor releases. We translate this by making the reader
|
||||
/// accepting only bitcode with the same epoch, except for the X.0 release which
|
||||
/// also accepts N-1.
|
||||
enum { BITCODE_CURRENT_EPOCH = 0 };
|
||||
|
||||
/// MODULE blocks have a number of optional fields and subblocks.
|
||||
enum ModuleCodes {
|
||||
MODULE_CODE_VERSION = 1, // VERSION: [version#]
|
||||
MODULE_CODE_TRIPLE = 2, // TRIPLE: [strchr x N]
|
||||
MODULE_CODE_DATALAYOUT = 3, // DATALAYOUT: [strchr x N]
|
||||
MODULE_CODE_ASM = 4, // ASM: [strchr x N]
|
||||
MODULE_CODE_SECTIONNAME = 5, // SECTIONNAME: [strchr x N]
|
||||
|
||||
// FIXME: Remove DEPLIB in 4.0.
|
||||
MODULE_CODE_DEPLIB = 6, // DEPLIB: [strchr x N]
|
||||
|
||||
// GLOBALVAR: [pointer type, isconst, initid,
|
||||
// linkage, alignment, section, visibility, threadlocal]
|
||||
MODULE_CODE_GLOBALVAR = 7,
|
||||
|
||||
// FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment,
|
||||
// section, visibility, gc, unnamed_addr]
|
||||
MODULE_CODE_FUNCTION = 8,
|
||||
|
||||
// ALIAS: [alias type, aliasee val#, linkage, visibility]
|
||||
MODULE_CODE_ALIAS_OLD = 9,
|
||||
|
||||
MODULE_CODE_GCNAME = 11, // GCNAME: [strchr x N]
|
||||
MODULE_CODE_COMDAT = 12, // COMDAT: [selection_kind, name]
|
||||
|
||||
MODULE_CODE_VSTOFFSET = 13, // VSTOFFSET: [offset]
|
||||
|
||||
// ALIAS: [alias value type, addrspace, aliasee val#, linkage, visibility]
|
||||
MODULE_CODE_ALIAS = 14,
|
||||
|
||||
MODULE_CODE_METADATA_VALUES_UNUSED = 15,
|
||||
|
||||
// SOURCE_FILENAME: [namechar x N]
|
||||
MODULE_CODE_SOURCE_FILENAME = 16,
|
||||
|
||||
// HASH: [5*i32]
|
||||
MODULE_CODE_HASH = 17,
|
||||
|
||||
// IFUNC: [ifunc value type, addrspace, resolver val#, linkage, visibility]
|
||||
MODULE_CODE_IFUNC = 18,
|
||||
};
|
||||
|
||||
/// PARAMATTR blocks have code for defining a parameter attribute set.
|
||||
enum AttributeCodes {
|
||||
// FIXME: Remove `PARAMATTR_CODE_ENTRY_OLD' in 4.0
|
||||
PARAMATTR_CODE_ENTRY_OLD = 1, // ENTRY: [paramidx0, attr0,
|
||||
// paramidx1, attr1...]
|
||||
PARAMATTR_CODE_ENTRY = 2, // ENTRY: [attrgrp0, attrgrp1, ...]
|
||||
PARAMATTR_GRP_CODE_ENTRY = 3 // ENTRY: [grpid, idx, attr0, attr1, ...]
|
||||
};
|
||||
|
||||
/// TYPE blocks have codes for each type primitive they use.
|
||||
enum TypeCodes {
|
||||
TYPE_CODE_NUMENTRY = 1, // NUMENTRY: [numentries]
|
||||
|
||||
// Type Codes
|
||||
TYPE_CODE_VOID = 2, // VOID
|
||||
TYPE_CODE_FLOAT = 3, // FLOAT
|
||||
TYPE_CODE_DOUBLE = 4, // DOUBLE
|
||||
TYPE_CODE_LABEL = 5, // LABEL
|
||||
TYPE_CODE_OPAQUE = 6, // OPAQUE
|
||||
TYPE_CODE_INTEGER = 7, // INTEGER: [width]
|
||||
TYPE_CODE_POINTER = 8, // POINTER: [pointee type]
|
||||
|
||||
TYPE_CODE_FUNCTION_OLD = 9, // FUNCTION: [vararg, attrid, retty,
|
||||
// paramty x N]
|
||||
|
||||
TYPE_CODE_HALF = 10, // HALF
|
||||
|
||||
TYPE_CODE_ARRAY = 11, // ARRAY: [numelts, eltty]
|
||||
TYPE_CODE_VECTOR = 12, // VECTOR: [numelts, eltty]
|
||||
|
||||
// These are not with the other floating point types because they're
|
||||
// a late addition, and putting them in the right place breaks
|
||||
// binary compatibility.
|
||||
TYPE_CODE_X86_FP80 = 13, // X86 LONG DOUBLE
|
||||
TYPE_CODE_FP128 = 14, // LONG DOUBLE (112 bit mantissa)
|
||||
TYPE_CODE_PPC_FP128 = 15, // PPC LONG DOUBLE (2 doubles)
|
||||
|
||||
TYPE_CODE_METADATA = 16, // METADATA
|
||||
|
||||
TYPE_CODE_X86_MMX = 17, // X86 MMX
|
||||
|
||||
TYPE_CODE_STRUCT_ANON = 18, // STRUCT_ANON: [ispacked, eltty x N]
|
||||
TYPE_CODE_STRUCT_NAME = 19, // STRUCT_NAME: [strchr x N]
|
||||
TYPE_CODE_STRUCT_NAMED = 20, // STRUCT_NAMED: [ispacked, eltty x N]
|
||||
|
||||
TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
|
||||
|
||||
TYPE_CODE_TOKEN = 22 // TOKEN
|
||||
};
|
||||
|
||||
enum OperandBundleTagCode {
|
||||
OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N]
|
||||
};
|
||||
|
||||
enum SyncScopeNameCode {
|
||||
SYNC_SCOPE_NAME = 1,
|
||||
};
|
||||
|
||||
// Value symbol table codes.
|
||||
enum ValueSymtabCodes {
|
||||
VST_CODE_ENTRY = 1, // VST_ENTRY: [valueid, namechar x N]
|
||||
VST_CODE_BBENTRY = 2, // VST_BBENTRY: [bbid, namechar x N]
|
||||
VST_CODE_FNENTRY = 3, // VST_FNENTRY: [valueid, offset, namechar x N]
|
||||
// VST_COMBINED_ENTRY: [valueid, refguid]
|
||||
VST_CODE_COMBINED_ENTRY = 5
|
||||
};
|
||||
|
||||
// The module path symbol table only has one code (MST_CODE_ENTRY).
|
||||
enum ModulePathSymtabCodes {
|
||||
MST_CODE_ENTRY = 1, // MST_ENTRY: [modid, namechar x N]
|
||||
MST_CODE_HASH = 2, // MST_HASH: [5*i32]
|
||||
};
|
||||
|
||||
// The summary section uses different codes in the per-module
|
||||
// and combined index cases.
|
||||
enum GlobalValueSummarySymtabCodes {
|
||||
// PERMODULE: [valueid, flags, instcount, numrefs, numrefs x valueid,
|
||||
// n x (valueid)]
|
||||
FS_PERMODULE = 1,
|
||||
// PERMODULE_PROFILE: [valueid, flags, instcount, numrefs,
|
||||
// numrefs x valueid,
|
||||
// n x (valueid, hotness)]
|
||||
FS_PERMODULE_PROFILE = 2,
|
||||
// PERMODULE_GLOBALVAR_INIT_REFS: [valueid, flags, n x valueid]
|
||||
FS_PERMODULE_GLOBALVAR_INIT_REFS = 3,
|
||||
// COMBINED: [valueid, modid, flags, instcount, numrefs, numrefs x valueid,
|
||||
// n x (valueid)]
|
||||
FS_COMBINED = 4,
|
||||
// COMBINED_PROFILE: [valueid, modid, flags, instcount, numrefs,
|
||||
// numrefs x valueid,
|
||||
// n x (valueid, hotness)]
|
||||
FS_COMBINED_PROFILE = 5,
|
||||
// COMBINED_GLOBALVAR_INIT_REFS: [valueid, modid, flags, n x valueid]
|
||||
FS_COMBINED_GLOBALVAR_INIT_REFS = 6,
|
||||
// ALIAS: [valueid, flags, valueid]
|
||||
FS_ALIAS = 7,
|
||||
// COMBINED_ALIAS: [valueid, modid, flags, valueid]
|
||||
FS_COMBINED_ALIAS = 8,
|
||||
// COMBINED_ORIGINAL_NAME: [original_name_hash]
|
||||
FS_COMBINED_ORIGINAL_NAME = 9,
|
||||
// VERSION of the summary, bumped when adding flags for instance.
|
||||
FS_VERSION = 10,
|
||||
// The list of llvm.type.test type identifiers used by the following function
|
||||
// that are used other than by an llvm.assume.
|
||||
// [n x typeid]
|
||||
FS_TYPE_TESTS = 11,
|
||||
// The list of virtual calls made by this function using
|
||||
// llvm.assume(llvm.type.test) intrinsics that do not have all constant
|
||||
// integer arguments.
|
||||
// [n x (typeid, offset)]
|
||||
FS_TYPE_TEST_ASSUME_VCALLS = 12,
|
||||
// The list of virtual calls made by this function using
|
||||
// llvm.type.checked.load intrinsics that do not have all constant integer
|
||||
// arguments.
|
||||
// [n x (typeid, offset)]
|
||||
FS_TYPE_CHECKED_LOAD_VCALLS = 13,
|
||||
// Identifies a virtual call made by this function using an
|
||||
// llvm.assume(llvm.type.test) intrinsic with all constant integer arguments.
|
||||
// [typeid, offset, n x arg]
|
||||
FS_TYPE_TEST_ASSUME_CONST_VCALL = 14,
|
||||
// Identifies a virtual call made by this function using an
|
||||
// llvm.type.checked.load intrinsic with all constant integer arguments.
|
||||
// [typeid, offset, n x arg]
|
||||
FS_TYPE_CHECKED_LOAD_CONST_VCALL = 15,
|
||||
// Assigns a GUID to a value ID. This normally appears only in combined
|
||||
// summaries, but it can also appear in per-module summaries for PGO data.
|
||||
// [valueid, guid]
|
||||
FS_VALUE_GUID = 16,
|
||||
// The list of local functions with CFI jump tables. Function names are
|
||||
// strings in strtab.
|
||||
// [n * name]
|
||||
FS_CFI_FUNCTION_DEFS = 17,
|
||||
// The list of external functions with CFI jump tables. Function names are
|
||||
// strings in strtab.
|
||||
// [n * name]
|
||||
FS_CFI_FUNCTION_DECLS = 18,
|
||||
};
|
||||
|
||||
enum MetadataCodes {
|
||||
METADATA_STRING_OLD = 1, // MDSTRING: [values]
|
||||
METADATA_VALUE = 2, // VALUE: [type num, value num]
|
||||
METADATA_NODE = 3, // NODE: [n x md num]
|
||||
METADATA_NAME = 4, // STRING: [values]
|
||||
METADATA_DISTINCT_NODE = 5, // DISTINCT_NODE: [n x md num]
|
||||
METADATA_KIND = 6, // [n x [id, name]]
|
||||
METADATA_LOCATION = 7, // [distinct, line, col, scope, inlined-at?]
|
||||
METADATA_OLD_NODE = 8, // OLD_NODE: [n x (type num, value num)]
|
||||
METADATA_OLD_FN_NODE = 9, // OLD_FN_NODE: [n x (type num, value num)]
|
||||
METADATA_NAMED_NODE = 10, // NAMED_NODE: [n x mdnodes]
|
||||
METADATA_ATTACHMENT = 11, // [m x [value, [n x [id, mdnode]]]
|
||||
METADATA_GENERIC_DEBUG = 12, // [distinct, tag, vers, header, n x md num]
|
||||
METADATA_SUBRANGE = 13, // [distinct, count, lo]
|
||||
METADATA_ENUMERATOR = 14, // [distinct, value, name]
|
||||
METADATA_BASIC_TYPE = 15, // [distinct, tag, name, size, align, enc]
|
||||
METADATA_FILE = 16, // [distinct, filename, directory, checksumkind, checksum]
|
||||
METADATA_DERIVED_TYPE = 17, // [distinct, ...]
|
||||
METADATA_COMPOSITE_TYPE = 18, // [distinct, ...]
|
||||
METADATA_SUBROUTINE_TYPE = 19, // [distinct, flags, types, cc]
|
||||
METADATA_COMPILE_UNIT = 20, // [distinct, ...]
|
||||
METADATA_SUBPROGRAM = 21, // [distinct, ...]
|
||||
METADATA_LEXICAL_BLOCK = 22, // [distinct, scope, file, line, column]
|
||||
METADATA_LEXICAL_BLOCK_FILE = 23, //[distinct, scope, file, discriminator]
|
||||
METADATA_NAMESPACE = 24, // [distinct, scope, file, name, line, exportSymbols]
|
||||
METADATA_TEMPLATE_TYPE = 25, // [distinct, scope, name, type, ...]
|
||||
METADATA_TEMPLATE_VALUE = 26, // [distinct, scope, name, type, value, ...]
|
||||
METADATA_GLOBAL_VAR = 27, // [distinct, ...]
|
||||
METADATA_LOCAL_VAR = 28, // [distinct, ...]
|
||||
METADATA_EXPRESSION = 29, // [distinct, n x element]
|
||||
METADATA_OBJC_PROPERTY = 30, // [distinct, name, file, line, ...]
|
||||
METADATA_IMPORTED_ENTITY = 31, // [distinct, tag, scope, entity, line, name]
|
||||
METADATA_MODULE = 32, // [distinct, scope, name, ...]
|
||||
METADATA_MACRO = 33, // [distinct, macinfo, line, name, value]
|
||||
METADATA_MACRO_FILE = 34, // [distinct, macinfo, line, file, ...]
|
||||
METADATA_STRINGS = 35, // [count, offset] blob([lengths][chars])
|
||||
METADATA_GLOBAL_DECL_ATTACHMENT = 36, // [valueid, n x [id, mdnode]]
|
||||
METADATA_GLOBAL_VAR_EXPR = 37, // [distinct, var, expr]
|
||||
METADATA_INDEX_OFFSET = 38, // [offset]
|
||||
METADATA_INDEX = 39, // [bitpos]
|
||||
};
|
||||
|
||||
// The constants block (CONSTANTS_BLOCK_ID) describes emission for each
|
||||
// constant and maintains an implicit current type value.
|
||||
enum ConstantsCodes {
|
||||
CST_CODE_SETTYPE = 1, // SETTYPE: [typeid]
|
||||
CST_CODE_NULL = 2, // NULL
|
||||
CST_CODE_UNDEF = 3, // UNDEF
|
||||
CST_CODE_INTEGER = 4, // INTEGER: [intval]
|
||||
CST_CODE_WIDE_INTEGER = 5, // WIDE_INTEGER: [n x intval]
|
||||
CST_CODE_FLOAT = 6, // FLOAT: [fpval]
|
||||
CST_CODE_AGGREGATE = 7, // AGGREGATE: [n x value number]
|
||||
CST_CODE_STRING = 8, // STRING: [values]
|
||||
CST_CODE_CSTRING = 9, // CSTRING: [values]
|
||||
CST_CODE_CE_BINOP = 10, // CE_BINOP: [opcode, opval, opval]
|
||||
CST_CODE_CE_CAST = 11, // CE_CAST: [opcode, opty, opval]
|
||||
CST_CODE_CE_GEP = 12, // CE_GEP: [n x operands]
|
||||
CST_CODE_CE_SELECT = 13, // CE_SELECT: [opval, opval, opval]
|
||||
CST_CODE_CE_EXTRACTELT = 14, // CE_EXTRACTELT: [opty, opval, opval]
|
||||
CST_CODE_CE_INSERTELT = 15, // CE_INSERTELT: [opval, opval, opval]
|
||||
CST_CODE_CE_SHUFFLEVEC = 16, // CE_SHUFFLEVEC: [opval, opval, opval]
|
||||
CST_CODE_CE_CMP = 17, // CE_CMP: [opty, opval, opval, pred]
|
||||
CST_CODE_INLINEASM_OLD = 18, // INLINEASM: [sideeffect|alignstack,
|
||||
// asmstr,conststr]
|
||||
CST_CODE_CE_SHUFVEC_EX = 19, // SHUFVEC_EX: [opty, opval, opval, opval]
|
||||
CST_CODE_CE_INBOUNDS_GEP = 20, // INBOUNDS_GEP: [n x operands]
|
||||
CST_CODE_BLOCKADDRESS = 21, // CST_CODE_BLOCKADDRESS [fnty, fnval, bb#]
|
||||
CST_CODE_DATA = 22, // DATA: [n x elements]
|
||||
CST_CODE_INLINEASM = 23, // INLINEASM: [sideeffect|alignstack|
|
||||
// asmdialect,asmstr,conststr]
|
||||
CST_CODE_CE_GEP_WITH_INRANGE_INDEX = 24, // [opty, flags, n x operands]
|
||||
};
|
||||
|
||||
/// CastOpcodes - These are values used in the bitcode files to encode which
|
||||
/// cast a CST_CODE_CE_CAST or a XXX refers to. The values of these enums
|
||||
/// have no fixed relation to the LLVM IR enum values. Changing these will
|
||||
/// break compatibility with old files.
|
||||
enum CastOpcodes {
|
||||
CAST_TRUNC = 0,
|
||||
CAST_ZEXT = 1,
|
||||
CAST_SEXT = 2,
|
||||
CAST_FPTOUI = 3,
|
||||
CAST_FPTOSI = 4,
|
||||
CAST_UITOFP = 5,
|
||||
CAST_SITOFP = 6,
|
||||
CAST_FPTRUNC = 7,
|
||||
CAST_FPEXT = 8,
|
||||
CAST_PTRTOINT = 9,
|
||||
CAST_INTTOPTR = 10,
|
||||
CAST_BITCAST = 11,
|
||||
CAST_ADDRSPACECAST = 12
|
||||
};
|
||||
|
||||
/// BinaryOpcodes - These are values used in the bitcode files to encode which
|
||||
/// binop a CST_CODE_CE_BINOP or a XXX refers to. The values of these enums
|
||||
/// have no fixed relation to the LLVM IR enum values. Changing these will
|
||||
/// break compatibility with old files.
|
||||
enum BinaryOpcodes {
|
||||
BINOP_ADD = 0,
|
||||
BINOP_SUB = 1,
|
||||
BINOP_MUL = 2,
|
||||
BINOP_UDIV = 3,
|
||||
BINOP_SDIV = 4, // overloaded for FP
|
||||
BINOP_UREM = 5,
|
||||
BINOP_SREM = 6, // overloaded for FP
|
||||
BINOP_SHL = 7,
|
||||
BINOP_LSHR = 8,
|
||||
BINOP_ASHR = 9,
|
||||
BINOP_AND = 10,
|
||||
BINOP_OR = 11,
|
||||
BINOP_XOR = 12
|
||||
};
|
||||
|
||||
/// These are values used in the bitcode files to encode AtomicRMW operations.
|
||||
/// The values of these enums have no fixed relation to the LLVM IR enum
|
||||
/// values. Changing these will break compatibility with old files.
|
||||
enum RMWOperations {
|
||||
RMW_XCHG = 0,
|
||||
RMW_ADD = 1,
|
||||
RMW_SUB = 2,
|
||||
RMW_AND = 3,
|
||||
RMW_NAND = 4,
|
||||
RMW_OR = 5,
|
||||
RMW_XOR = 6,
|
||||
RMW_MAX = 7,
|
||||
RMW_MIN = 8,
|
||||
RMW_UMAX = 9,
|
||||
RMW_UMIN = 10
|
||||
};
|
||||
|
||||
/// OverflowingBinaryOperatorOptionalFlags - Flags for serializing
|
||||
/// OverflowingBinaryOperator's SubclassOptionalData contents.
|
||||
enum OverflowingBinaryOperatorOptionalFlags {
|
||||
OBO_NO_UNSIGNED_WRAP = 0,
|
||||
OBO_NO_SIGNED_WRAP = 1
|
||||
};
|
||||
|
||||
/// PossiblyExactOperatorOptionalFlags - Flags for serializing
|
||||
/// PossiblyExactOperator's SubclassOptionalData contents.
|
||||
enum PossiblyExactOperatorOptionalFlags { PEO_EXACT = 0 };
|
||||
|
||||
/// Encoded AtomicOrdering values.
|
||||
enum AtomicOrderingCodes {
|
||||
ORDERING_NOTATOMIC = 0,
|
||||
ORDERING_UNORDERED = 1,
|
||||
ORDERING_MONOTONIC = 2,
|
||||
ORDERING_ACQUIRE = 3,
|
||||
ORDERING_RELEASE = 4,
|
||||
ORDERING_ACQREL = 5,
|
||||
ORDERING_SEQCST = 6
|
||||
};
|
||||
|
||||
/// Markers and flags for call instruction.
|
||||
enum CallMarkersFlags {
|
||||
CALL_TAIL = 0,
|
||||
CALL_CCONV = 1,
|
||||
CALL_MUSTTAIL = 14,
|
||||
CALL_EXPLICIT_TYPE = 15,
|
||||
CALL_NOTAIL = 16,
|
||||
CALL_FMF = 17 // Call has optional fast-math-flags.
|
||||
};
|
||||
|
||||
// The function body block (FUNCTION_BLOCK_ID) describes function bodies. It
|
||||
// can contain a constant block (CONSTANTS_BLOCK_ID).
|
||||
enum FunctionCodes {
|
||||
FUNC_CODE_DECLAREBLOCKS = 1, // DECLAREBLOCKS: [n]
|
||||
|
||||
FUNC_CODE_INST_BINOP = 2, // BINOP: [opcode, ty, opval, opval]
|
||||
FUNC_CODE_INST_CAST = 3, // CAST: [opcode, ty, opty, opval]
|
||||
FUNC_CODE_INST_GEP_OLD = 4, // GEP: [n x operands]
|
||||
FUNC_CODE_INST_SELECT = 5, // SELECT: [ty, opval, opval, opval]
|
||||
FUNC_CODE_INST_EXTRACTELT = 6, // EXTRACTELT: [opty, opval, opval]
|
||||
FUNC_CODE_INST_INSERTELT = 7, // INSERTELT: [ty, opval, opval, opval]
|
||||
FUNC_CODE_INST_SHUFFLEVEC = 8, // SHUFFLEVEC: [ty, opval, opval, opval]
|
||||
FUNC_CODE_INST_CMP = 9, // CMP: [opty, opval, opval, pred]
|
||||
|
||||
FUNC_CODE_INST_RET = 10, // RET: [opty,opval<both optional>]
|
||||
FUNC_CODE_INST_BR = 11, // BR: [bb#, bb#, cond] or [bb#]
|
||||
FUNC_CODE_INST_SWITCH = 12, // SWITCH: [opty, op0, op1, ...]
|
||||
FUNC_CODE_INST_INVOKE = 13, // INVOKE: [attr, fnty, op0,op1, ...]
|
||||
// 14 is unused.
|
||||
FUNC_CODE_INST_UNREACHABLE = 15, // UNREACHABLE
|
||||
|
||||
FUNC_CODE_INST_PHI = 16, // PHI: [ty, val0,bb0, ...]
|
||||
// 17 is unused.
|
||||
// 18 is unused.
|
||||
FUNC_CODE_INST_ALLOCA = 19, // ALLOCA: [instty, opty, op, align]
|
||||
FUNC_CODE_INST_LOAD = 20, // LOAD: [opty, op, align, vol]
|
||||
// 21 is unused.
|
||||
// 22 is unused.
|
||||
FUNC_CODE_INST_VAARG = 23, // VAARG: [valistty, valist, instty]
|
||||
// This store code encodes the pointer type, rather than the value type
|
||||
// this is so information only available in the pointer type (e.g. address
|
||||
// spaces) is retained.
|
||||
FUNC_CODE_INST_STORE_OLD = 24, // STORE: [ptrty,ptr,val, align, vol]
|
||||
// 25 is unused.
|
||||
FUNC_CODE_INST_EXTRACTVAL = 26, // EXTRACTVAL: [n x operands]
|
||||
FUNC_CODE_INST_INSERTVAL = 27, // INSERTVAL: [n x operands]
|
||||
// fcmp/icmp returning Int1TY or vector of Int1Ty. Same as CMP, exists to
|
||||
// support legacy vicmp/vfcmp instructions.
|
||||
FUNC_CODE_INST_CMP2 = 28, // CMP2: [opty, opval, opval, pred]
|
||||
// new select on i1 or [N x i1]
|
||||
FUNC_CODE_INST_VSELECT = 29, // VSELECT: [ty,opval,opval,predty,pred]
|
||||
FUNC_CODE_INST_INBOUNDS_GEP_OLD = 30, // INBOUNDS_GEP: [n x operands]
|
||||
FUNC_CODE_INST_INDIRECTBR = 31, // INDIRECTBR: [opty, op0, op1, ...]
|
||||
// 32 is unused.
|
||||
FUNC_CODE_DEBUG_LOC_AGAIN = 33, // DEBUG_LOC_AGAIN
|
||||
|
||||
FUNC_CODE_INST_CALL = 34, // CALL: [attr, cc, fnty, fnid, args...]
|
||||
|
||||
FUNC_CODE_DEBUG_LOC = 35, // DEBUG_LOC: [Line,Col,ScopeVal, IAVal]
|
||||
FUNC_CODE_INST_FENCE = 36, // FENCE: [ordering, synchscope]
|
||||
FUNC_CODE_INST_CMPXCHG_OLD = 37, // CMPXCHG: [ptrty,ptr,cmp,new, align, vol,
|
||||
// ordering, synchscope]
|
||||
FUNC_CODE_INST_ATOMICRMW = 38, // ATOMICRMW: [ptrty,ptr,val, operation,
|
||||
// align, vol,
|
||||
// ordering, synchscope]
|
||||
FUNC_CODE_INST_RESUME = 39, // RESUME: [opval]
|
||||
FUNC_CODE_INST_LANDINGPAD_OLD =
|
||||
40, // LANDINGPAD: [ty,val,val,num,id0,val0...]
|
||||
FUNC_CODE_INST_LOADATOMIC = 41, // LOAD: [opty, op, align, vol,
|
||||
// ordering, synchscope]
|
||||
FUNC_CODE_INST_STOREATOMIC_OLD = 42, // STORE: [ptrty,ptr,val, align, vol
|
||||
// ordering, synchscope]
|
||||
FUNC_CODE_INST_GEP = 43, // GEP: [inbounds, n x operands]
|
||||
FUNC_CODE_INST_STORE = 44, // STORE: [ptrty,ptr,valty,val, align, vol]
|
||||
FUNC_CODE_INST_STOREATOMIC = 45, // STORE: [ptrty,ptr,val, align, vol
|
||||
FUNC_CODE_INST_CMPXCHG = 46, // CMPXCHG: [ptrty,ptr,valty,cmp,new, align,
|
||||
// vol,ordering,synchscope]
|
||||
FUNC_CODE_INST_LANDINGPAD = 47, // LANDINGPAD: [ty,val,num,id0,val0...]
|
||||
FUNC_CODE_INST_CLEANUPRET = 48, // CLEANUPRET: [val] or [val,bb#]
|
||||
FUNC_CODE_INST_CATCHRET = 49, // CATCHRET: [val,bb#]
|
||||
FUNC_CODE_INST_CATCHPAD = 50, // CATCHPAD: [bb#,bb#,num,args...]
|
||||
FUNC_CODE_INST_CLEANUPPAD = 51, // CLEANUPPAD: [num,args...]
|
||||
FUNC_CODE_INST_CATCHSWITCH =
|
||||
52, // CATCHSWITCH: [num,args...] or [num,args...,bb]
|
||||
// 53 is unused.
|
||||
// 54 is unused.
|
||||
FUNC_CODE_OPERAND_BUNDLE = 55, // OPERAND_BUNDLE: [tag#, value...]
|
||||
};
|
||||
|
||||
enum UseListCodes {
|
||||
USELIST_CODE_DEFAULT = 1, // DEFAULT: [index..., value-id]
|
||||
USELIST_CODE_BB = 2 // BB: [index..., bb-id]
|
||||
};
|
||||
|
||||
enum AttributeKindCodes {
|
||||
// = 0 is unused
|
||||
ATTR_KIND_ALIGNMENT = 1,
|
||||
ATTR_KIND_ALWAYS_INLINE = 2,
|
||||
ATTR_KIND_BY_VAL = 3,
|
||||
ATTR_KIND_INLINE_HINT = 4,
|
||||
ATTR_KIND_IN_REG = 5,
|
||||
ATTR_KIND_MIN_SIZE = 6,
|
||||
ATTR_KIND_NAKED = 7,
|
||||
ATTR_KIND_NEST = 8,
|
||||
ATTR_KIND_NO_ALIAS = 9,
|
||||
ATTR_KIND_NO_BUILTIN = 10,
|
||||
ATTR_KIND_NO_CAPTURE = 11,
|
||||
ATTR_KIND_NO_DUPLICATE = 12,
|
||||
ATTR_KIND_NO_IMPLICIT_FLOAT = 13,
|
||||
ATTR_KIND_NO_INLINE = 14,
|
||||
ATTR_KIND_NON_LAZY_BIND = 15,
|
||||
ATTR_KIND_NO_RED_ZONE = 16,
|
||||
ATTR_KIND_NO_RETURN = 17,
|
||||
ATTR_KIND_NO_UNWIND = 18,
|
||||
ATTR_KIND_OPTIMIZE_FOR_SIZE = 19,
|
||||
ATTR_KIND_READ_NONE = 20,
|
||||
ATTR_KIND_READ_ONLY = 21,
|
||||
ATTR_KIND_RETURNED = 22,
|
||||
ATTR_KIND_RETURNS_TWICE = 23,
|
||||
ATTR_KIND_S_EXT = 24,
|
||||
ATTR_KIND_STACK_ALIGNMENT = 25,
|
||||
ATTR_KIND_STACK_PROTECT = 26,
|
||||
ATTR_KIND_STACK_PROTECT_REQ = 27,
|
||||
ATTR_KIND_STACK_PROTECT_STRONG = 28,
|
||||
ATTR_KIND_STRUCT_RET = 29,
|
||||
ATTR_KIND_SANITIZE_ADDRESS = 30,
|
||||
ATTR_KIND_SANITIZE_THREAD = 31,
|
||||
ATTR_KIND_SANITIZE_MEMORY = 32,
|
||||
ATTR_KIND_UW_TABLE = 33,
|
||||
ATTR_KIND_Z_EXT = 34,
|
||||
ATTR_KIND_BUILTIN = 35,
|
||||
ATTR_KIND_COLD = 36,
|
||||
ATTR_KIND_OPTIMIZE_NONE = 37,
|
||||
ATTR_KIND_IN_ALLOCA = 38,
|
||||
ATTR_KIND_NON_NULL = 39,
|
||||
ATTR_KIND_JUMP_TABLE = 40,
|
||||
ATTR_KIND_DEREFERENCEABLE = 41,
|
||||
ATTR_KIND_DEREFERENCEABLE_OR_NULL = 42,
|
||||
ATTR_KIND_CONVERGENT = 43,
|
||||
ATTR_KIND_SAFESTACK = 44,
|
||||
ATTR_KIND_ARGMEMONLY = 45,
|
||||
ATTR_KIND_SWIFT_SELF = 46,
|
||||
ATTR_KIND_SWIFT_ERROR = 47,
|
||||
ATTR_KIND_NO_RECURSE = 48,
|
||||
ATTR_KIND_INACCESSIBLEMEM_ONLY = 49,
|
||||
ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY = 50,
|
||||
ATTR_KIND_ALLOC_SIZE = 51,
|
||||
ATTR_KIND_WRITEONLY = 52,
|
||||
ATTR_KIND_SPECULATABLE = 53,
|
||||
ATTR_KIND_STRICT_FP = 54,
|
||||
};
|
||||
|
||||
enum ComdatSelectionKindCodes {
|
||||
COMDAT_SELECTION_KIND_ANY = 1,
|
||||
COMDAT_SELECTION_KIND_EXACT_MATCH = 2,
|
||||
COMDAT_SELECTION_KIND_LARGEST = 3,
|
||||
COMDAT_SELECTION_KIND_NO_DUPLICATES = 4,
|
||||
COMDAT_SELECTION_KIND_SAME_SIZE = 5,
|
||||
};
|
||||
|
||||
enum StrtabCodes {
|
||||
STRTAB_BLOB = 1,
|
||||
};
|
||||
|
||||
enum SymtabCodes {
|
||||
SYMTAB_BLOB = 1,
|
||||
};
|
||||
|
||||
} // End bitc namespace
|
||||
} // End llvm namespace
|
||||
|
||||
#endif
|
||||
Reference in new issue
Block a user