From 3c074f61ed2bd1d8d48c3851d827a06b80d2608b Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Fri, 4 May 2007 20:33:47 +0000 Subject: [PATCH] add support for array abbreviations. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@36754 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Bitcode/BitCodes.h | 22 +++++-- include/llvm/Bitcode/BitstreamReader.h | 52 +++++++++++----- include/llvm/Bitcode/BitstreamWriter.h | 86 +++++++++++++++----------- 3 files changed, 101 insertions(+), 59 deletions(-) diff --git a/include/llvm/Bitcode/BitCodes.h b/include/llvm/Bitcode/BitCodes.h index 647c28fb398..d9a58749668 100644 --- a/include/llvm/Bitcode/BitCodes.h +++ b/include/llvm/Bitcode/BitCodes.h @@ -84,13 +84,15 @@ class BitCodeAbbrevOp { unsigned Enc : 3; // The encoding to use. public: enum Encoding { - FixedWidth = 1, // A fixed with field, Val specifies number of bits. - VBR = 2 // A VBR field where Val specifies the width of each chunk. + Fixed = 1, // A fixed with 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. }; BitCodeAbbrevOp(uint64_t V) : Val(V), IsLiteral(true) {} - BitCodeAbbrevOp(Encoding E, uint64_t Data) + BitCodeAbbrevOp(Encoding E, uint64_t Data = 0) : Val(Data), IsLiteral(false), Enc(E) {} + bool isLiteral() const { return IsLiteral; } bool isEncoding() const { return !IsLiteral; } @@ -100,11 +102,21 @@ public: // Accessors for encoding info. Encoding getEncoding() const { assert(isEncoding()); return (Encoding)Enc; } - uint64_t getEncodingData() const { assert(isEncoding()); return Val; } + uint64_t getEncodingData() const { + assert(isEncoding() && hasEncodingData()); + return Val; + } bool hasEncodingData() const { return hasEncodingData(getEncoding()); } static bool hasEncodingData(Encoding E) { - return true; + switch (E) { + default: assert(0 && "Unknown encoding"); + case Fixed: + case VBR: + return true; + case Array: + return false; + } } }; diff --git a/include/llvm/Bitcode/BitstreamReader.h b/include/llvm/Bitcode/BitstreamReader.h index eac9ab0b607..2a3e412f78d 100644 --- a/include/llvm/Bitcode/BitstreamReader.h +++ b/include/llvm/Bitcode/BitstreamReader.h @@ -274,6 +274,26 @@ public: // Record Processing //===--------------------------------------------------------------------===// +private: + void ReadAbbreviatedField(const BitCodeAbbrevOp &Op, + SmallVectorImpl &Vals) { + if (Op.isLiteral()) { + // If the abbrev specifies the literal value to use, use it. + Vals.push_back(Op.getLiteralValue()); + } else { + // Decode the value as we are commanded. + switch (Op.getEncoding()) { + default: assert(0 && "Unknown encoding!"); + case BitCodeAbbrevOp::Fixed: + Vals.push_back(Read(Op.getEncodingData())); + break; + case BitCodeAbbrevOp::VBR: + Vals.push_back(ReadVBR64(Op.getEncodingData())); + break; + } + } + } +public: unsigned ReadRecord(unsigned AbbrevID, SmallVectorImpl &Vals) { if (AbbrevID == bitc::UNABBREV_RECORD) { unsigned Code = ReadVBR(6); @@ -289,20 +309,19 @@ public: for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); - if (Op.isLiteral()) { - // If the abbrev specifies the literal value to use, use it. - Vals.push_back(Op.getLiteralValue()); + if (Op.isLiteral() || Op.getEncoding() != BitCodeAbbrevOp::Array) { + ReadAbbreviatedField(Op, Vals); } else { - // Decode the value as we are commanded. - switch (Op.getEncoding()) { - default: assert(0 && "Unknown encoding!"); - case BitCodeAbbrevOp::FixedWidth: - Vals.push_back(Read(Op.getEncodingData())); - break; - case BitCodeAbbrevOp::VBR: - Vals.push_back(ReadVBR64(Op.getEncodingData())); - break; - } + // Array case. Read the number of elements as a vbr6. + unsigned NumElts = ReadVBR(6); + + // Get the element encoding. + assert(i+2 == e && "array op not second to last?"); + const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); + + // Read all the elements. + for (; NumElts; --NumElts) + ReadAbbreviatedField(EltEnc, Vals); } } @@ -326,11 +345,10 @@ public: } BitCodeAbbrevOp::Encoding E = (BitCodeAbbrevOp::Encoding)Read(3); - if (BitCodeAbbrevOp::hasEncodingData(E)) { + if (BitCodeAbbrevOp::hasEncodingData(E)) Abbv->Add(BitCodeAbbrevOp(E, ReadVBR64(5))); - } else { - assert(0 && "unimp"); - } + else + Abbv->Add(BitCodeAbbrevOp(E)); } CurAbbrevs.push_back(Abbv); } diff --git a/include/llvm/Bitcode/BitstreamWriter.h b/include/llvm/Bitcode/BitstreamWriter.h index fcbcbbf0fb4..bcae8e54676 100644 --- a/include/llvm/Bitcode/BitstreamWriter.h +++ b/include/llvm/Bitcode/BitstreamWriter.h @@ -189,6 +189,32 @@ public: // Record Emission //===--------------------------------------------------------------------===// +private: + /// EmitAbbreviatedField - Emit a single scalar field value with the specified + /// encoding. + template + void EmitAbbreviatedField(const BitCodeAbbrevOp &Op, uintty V) { + if (Op.isLiteral()) { + // If the abbrev specifies the literal value to use, don't emit + // anything. + assert(V == Op.getLiteralValue() && + "Invalid abbrev for record!"); + return; + } + + // Encode the value as we are commanded. + switch (Op.getEncoding()) { + default: assert(0 && "Unknown encoding!"); + case BitCodeAbbrevOp::Fixed: + Emit(V, Op.getEncodingData()); + break; + case BitCodeAbbrevOp::VBR: + EmitVBR(V, Op.getEncodingData()); + break; + } + } +public: + /// EmitRecord - Emit the specified record to the stream, using an abbrev if /// we have one to compress the output. void EmitRecord(unsigned Code, SmallVectorImpl &Vals, @@ -207,27 +233,20 @@ public: for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { assert(RecordIdx < Vals.size() && "Invalid abbrev/record"); const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); - uint64_t RecordVal = Vals[RecordIdx]; - - if (Op.isLiteral()) { - // If the abbrev specifies the literal value to use, don't emit - // anything. - assert(RecordVal == Op.getLiteralValue() && - "Invalid abbrev for record!"); + if (Op.isLiteral() || Op.getEncoding() != BitCodeAbbrevOp::Array) { + EmitAbbreviatedField(Op, Vals[RecordIdx]); ++RecordIdx; } else { - // Encode the value as we are commanded. - switch (Op.getEncoding()) { - default: assert(0 && "Unknown encoding!"); - case BitCodeAbbrevOp::FixedWidth: - Emit64(RecordVal, Op.getEncodingData()); - ++RecordIdx; - break; - case BitCodeAbbrevOp::VBR: - EmitVBR64(RecordVal, Op.getEncodingData()); - ++RecordIdx; - break; - } + // Array case. + assert(i+2 == e && "array op not second to last?"); + const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); + + // Emit a vbr6 to indicate the number of elements present. + EmitVBR(Vals.size()-RecordIdx, 6); + + // Emit each field. + for (; RecordIdx != Vals.size(); ++RecordIdx) + EmitAbbreviatedField(EltEnc, Vals[RecordIdx]); } } assert(RecordIdx == Vals.size() && "Not all record operands emitted!"); @@ -260,27 +279,20 @@ public: for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { assert(RecordIdx < Vals.size() && "Invalid abbrev/record"); const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); - unsigned RecordVal = Vals[RecordIdx]; - if (Op.isLiteral()) { - // If the abbrev specifies the literal value to use, don't emit - // anything. - assert(RecordVal == Op.getLiteralValue() && - "Invalid abbrev for record!"); + if (Op.isLiteral() || Op.getEncoding() != BitCodeAbbrevOp::Array) { + EmitAbbreviatedField(Op, Vals[RecordIdx]); ++RecordIdx; } else { - // Encode the value as we are commanded. - switch (Op.getEncoding()) { - default: assert(0 && "Unknown encoding!"); - case BitCodeAbbrevOp::FixedWidth: - Emit(RecordVal, Op.getEncodingData()); - ++RecordIdx; - break; - case BitCodeAbbrevOp::VBR: - EmitVBR(RecordVal, Op.getEncodingData()); - ++RecordIdx; - break; - } + assert(i+2 == e && "array op not second to last?"); + const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); + + // Emit a vbr6 to indicate the number of elements present. + EmitVBR(Vals.size()-RecordIdx, 6); + + // Emit each field. + for (; RecordIdx != Vals.size(); ++RecordIdx) + EmitAbbreviatedField(EltEnc, Vals[RecordIdx]); } } assert(RecordIdx == Vals.size() && "Not all record operands emitted!");