#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;
unsigned CurBit;
uint32_t CurValue;
unsigned CurCodeSize;
unsigned BlockInfoCurBID;
std::vector<IntrusiveRefCntPtr<BitCodeAbbrev>> CurAbbrevs;
struct Block {
unsigned PrevCodeSize;
size_t StartSizeWord;
std::vector<IntrusiveRefCntPtr<BitCodeAbbrev>> PrevAbbrevs;
Block(unsigned PCS, size_t SSW) : PrevCodeSize(PCS), StartSizeWord(SSW) {}
};
std::vector<Block> BlockScope;
struct BlockInfo {
unsigned BlockID;
std::vector<IntrusiveRefCntPtr<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");
}
uint64_t GetCurrentBitNo() const { return GetBufferOffset() * 8 + CurBit; }
unsigned GetAbbrevIDWidth() const { return CurCodeSize; }
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 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;
}
WriteWord(CurValue);
if (CurBit)
CurValue = Val >> (32-CurBit);
else
CurValue = 0;
CurBit = (CurBit+NumBits) & 31;
}
void Emit64(uint64_t Val, unsigned NumBits) {
if (NumBits <= 32)
Emit((uint32_t)Val, NumBits);
else {
Emit((uint32_t)Val, 32);
Emit((uint32_t)(Val >> 32), NumBits-32);
}
}
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);
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);
while (Val >= Threshold) {
Emit(((uint32_t)Val & ((1 << (NumBits-1))-1)) |
(1 << (NumBits-1)), NumBits);
Val >>= NumBits-1;
}
Emit((uint32_t)Val, NumBits);
}
void EmitCode(unsigned Val) {
Emit(Val, CurCodeSize);
}
BlockInfo *getBlockInfo(unsigned 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) {
EmitCode(bitc::ENTER_SUBBLOCK);
EmitVBR(BlockID, bitc::BlockIDWidth);
EmitVBR(CodeLen, bitc::CodeLenWidth);
FlushToWord();
size_t BlockSizeWordIndex = GetWordIndex();
unsigned OldCodeSize = CurCodeSize;
Emit(0, bitc::BlockSizeWidth);
CurCodeSize = CodeLen;
BlockScope.emplace_back(OldCodeSize, BlockSizeWordIndex);
BlockScope.back().PrevAbbrevs.swap(CurAbbrevs);
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();
EmitCode(bitc::END_BLOCK);
FlushToWord();
size_t SizeInWords = GetWordIndex() - B.StartSizeWord - 1;
uint64_t BitNo = uint64_t(B.StartSizeWord) * 32;
BackpatchWord(BitNo, SizeInWords);
CurCodeSize = B.PrevCodeSize;
CurAbbrevs = std::move(B.PrevAbbrevs);
BlockScope.pop_back();
}
private:
template<typename uintty>
void EmitAbbreviatedLiteral(const BitCodeAbbrevOp &Op, uintty V) {
assert(Op.isLiteral() && "Not a literal");
assert(V == Op.getLiteralValue() &&
"Invalid abbrev for record!");
}
template<typename uintty>
void EmitAbbreviatedField(const BitCodeAbbrevOp &Op, uintty V) {
assert(!Op.isLiteral() && "Literals should use EmitAbbreviatedLiteral!");
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;
}
}
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) {
assert(i + 2 == e && "array op not second to last?");
const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i);
if (BlobData) {
assert(RecordIdx == Vals.size() &&
"Blob data and record entries specified for array!");
EmitVBR(static_cast<uint32_t>(BlobLen), 6);
for (unsigned i = 0; i != BlobLen; ++i)
EmitAbbreviatedField(EltEnc, (unsigned char)BlobData[i]);
BlobData = nullptr;
} else {
EmitVBR(static_cast<uint32_t>(Vals.size()-RecordIdx), 6);
for (unsigned e = Vals.size(); RecordIdx != e; ++RecordIdx)
EmitAbbreviatedField(EltEnc, Vals[RecordIdx]);
}
} else if (Op.getEncoding() == BitCodeAbbrevOp::Blob) {
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 { 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:
template <class UIntTy>
void emitBlob(ArrayRef<UIntTy> Bytes, bool ShouldEmitSize = true) {
if (ShouldEmitSize)
EmitVBR(static_cast<uint32_t>(Bytes.size()), 6);
FlushToWord();
for (const auto &B : Bytes) {
assert(isUInt<8>(B) && "Value too large to emit as byte");
WriteByte((unsigned char)B);
}
while (GetBufferOffset() & 3)
WriteByte(0);
}
void emitBlob(StringRef Bytes, bool ShouldEmitSize = true) {
emitBlob(makeArrayRef((const uint8_t *)Bytes.data(), Bytes.size()),
ShouldEmitSize);
}
template <typename Container>
void EmitRecord(unsigned Code, const Container &Vals, unsigned Abbrev = 0) {
if (!Abbrev) {
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);
}
template <typename Container>
void EmitRecordWithAbbrev(unsigned Abbrev, const Container &Vals) {
EmitRecordWithAbbrevImpl(Abbrev, makeArrayRef(Vals), StringRef(), None);
}
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);
}
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);
}
private:
void EncodeAbbrev(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:
unsigned EmitAbbrev(BitCodeAbbrev *Abbv) {
EncodeAbbrev(Abbv);
CurAbbrevs.push_back(Abbv);
return static_cast<unsigned>(CurAbbrevs.size())-1 +
bitc::FIRST_APPLICATION_ABBREV;
}
void EnterBlockInfoBlock(unsigned CodeWidth) {
EnterSubblock(bitc::BLOCKINFO_BLOCK_ID, CodeWidth);
BlockInfoCurBID = ~0U;
}
private:
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;
BlockInfoRecords.emplace_back();
BlockInfoRecords.back().BlockID = BlockID;
return BlockInfoRecords.back();
}
public:
unsigned EmitBlockInfoAbbrev(unsigned BlockID, BitCodeAbbrev *Abbv) {
SwitchToBlockID(BlockID);
EncodeAbbrev(Abbv);
BlockInfo &Info = getOrCreateBlockInfo(BlockID);
Info.Abbrevs.push_back(Abbv);
return Info.Abbrevs.size()-1+bitc::FIRST_APPLICATION_ABBREV;
}
};
}
#endif