Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 1 | //===- BitstreamReader.cpp - BitstreamReader implementation ---------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
| 10 | #include "llvm/Bitcode/BitstreamReader.h" |
| 11 | |
| 12 | using namespace llvm; |
| 13 | |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | // BitstreamCursor implementation |
| 16 | //===----------------------------------------------------------------------===// |
| 17 | |
| 18 | void BitstreamCursor::operator=(const BitstreamCursor &RHS) { |
| 19 | freeState(); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 20 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 21 | BitStream = RHS.BitStream; |
| 22 | NextChar = RHS.NextChar; |
| 23 | CurWord = RHS.CurWord; |
| 24 | BitsInCurWord = RHS.BitsInCurWord; |
| 25 | CurCodeSize = RHS.CurCodeSize; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 26 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 27 | // Copy abbreviations, and bump ref counts. |
| 28 | CurAbbrevs = RHS.CurAbbrevs; |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 29 | for (size_t i = 0, e = CurAbbrevs.size(); i != e; ++i) |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 30 | CurAbbrevs[i]->addRef(); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 31 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 32 | // Copy block scope and bump ref counts. |
| 33 | BlockScope = RHS.BlockScope; |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 34 | for (size_t S = 0, e = BlockScope.size(); S != e; ++S) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 35 | std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs; |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 36 | for (size_t i = 0, e = Abbrevs.size(); i != e; ++i) |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 37 | Abbrevs[i]->addRef(); |
| 38 | } |
| 39 | } |
| 40 | |
| 41 | void BitstreamCursor::freeState() { |
| 42 | // Free all the Abbrevs. |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 43 | for (size_t i = 0, e = CurAbbrevs.size(); i != e; ++i) |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 44 | CurAbbrevs[i]->dropRef(); |
| 45 | CurAbbrevs.clear(); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 46 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 47 | // Free all the Abbrevs in the block scope. |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 48 | for (size_t S = 0, e = BlockScope.size(); S != e; ++S) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 49 | std::vector<BitCodeAbbrev*> &Abbrevs = BlockScope[S].PrevAbbrevs; |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 50 | for (size_t i = 0, e = Abbrevs.size(); i != e; ++i) |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 51 | Abbrevs[i]->dropRef(); |
| 52 | } |
| 53 | BlockScope.clear(); |
| 54 | } |
| 55 | |
| 56 | /// EnterSubBlock - Having read the ENTER_SUBBLOCK abbrevid, enter |
| 57 | /// the block, and return true if the block has an error. |
| 58 | bool BitstreamCursor::EnterSubBlock(unsigned BlockID, unsigned *NumWordsP) { |
| 59 | // Save the current block's state on BlockScope. |
| 60 | BlockScope.push_back(Block(CurCodeSize)); |
| 61 | BlockScope.back().PrevAbbrevs.swap(CurAbbrevs); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 62 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 63 | // Add the abbrevs specific to this block to the CurAbbrevs list. |
| 64 | if (const BitstreamReader::BlockInfo *Info = |
| 65 | BitStream->getBlockInfo(BlockID)) { |
Jakub Staszak | c61e83e | 2013-02-19 09:48:30 +0000 | [diff] [blame] | 66 | for (size_t i = 0, e = Info->Abbrevs.size(); i != e; ++i) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 67 | CurAbbrevs.push_back(Info->Abbrevs[i]); |
| 68 | CurAbbrevs.back()->addRef(); |
| 69 | } |
| 70 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 71 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 72 | // Get the codesize of this block. |
| 73 | CurCodeSize = ReadVBR(bitc::CodeLenWidth); |
Chris Lattner | fd0543d | 2013-01-21 18:04:19 +0000 | [diff] [blame] | 74 | SkipToFourByteBoundary(); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 75 | unsigned NumWords = Read(bitc::BlockSizeWidth); |
| 76 | if (NumWordsP) *NumWordsP = NumWords; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 77 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 78 | // Validate that this block is sane. |
| 79 | if (CurCodeSize == 0 || AtEndOfStream()) |
| 80 | return true; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 81 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 82 | return false; |
| 83 | } |
| 84 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 85 | void BitstreamCursor::readAbbreviatedLiteral(const BitCodeAbbrevOp &Op, |
| 86 | SmallVectorImpl<uint64_t> &Vals) { |
| 87 | assert(Op.isLiteral() && "Not a literal"); |
| 88 | // If the abbrev specifies the literal value to use, use it. |
| 89 | Vals.push_back(Op.getLiteralValue()); |
| 90 | } |
| 91 | |
| 92 | void BitstreamCursor::readAbbreviatedField(const BitCodeAbbrevOp &Op, |
| 93 | SmallVectorImpl<uint64_t> &Vals) { |
| 94 | assert(!Op.isLiteral() && "Use ReadAbbreviatedLiteral for literals!"); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 95 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 96 | // Decode the value as we are commanded. |
| 97 | switch (Op.getEncoding()) { |
| 98 | case BitCodeAbbrevOp::Array: |
| 99 | case BitCodeAbbrevOp::Blob: |
| 100 | assert(0 && "Should not reach here"); |
| 101 | case BitCodeAbbrevOp::Fixed: |
| 102 | Vals.push_back(Read((unsigned)Op.getEncodingData())); |
| 103 | break; |
| 104 | case BitCodeAbbrevOp::VBR: |
| 105 | Vals.push_back(ReadVBR64((unsigned)Op.getEncodingData())); |
| 106 | break; |
| 107 | case BitCodeAbbrevOp::Char6: |
| 108 | Vals.push_back(BitCodeAbbrevOp::DecodeChar6(Read(6))); |
| 109 | break; |
| 110 | } |
| 111 | } |
| 112 | |
| 113 | void BitstreamCursor::skipAbbreviatedField(const BitCodeAbbrevOp &Op) { |
| 114 | assert(!Op.isLiteral() && "Use ReadAbbreviatedLiteral for literals!"); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 115 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 116 | // Decode the value as we are commanded. |
| 117 | switch (Op.getEncoding()) { |
| 118 | case BitCodeAbbrevOp::Array: |
| 119 | case BitCodeAbbrevOp::Blob: |
| 120 | assert(0 && "Should not reach here"); |
| 121 | case BitCodeAbbrevOp::Fixed: |
| 122 | (void)Read((unsigned)Op.getEncodingData()); |
| 123 | break; |
| 124 | case BitCodeAbbrevOp::VBR: |
| 125 | (void)ReadVBR64((unsigned)Op.getEncodingData()); |
| 126 | break; |
| 127 | case BitCodeAbbrevOp::Char6: |
| 128 | (void)Read(6); |
| 129 | break; |
| 130 | } |
| 131 | } |
| 132 | |
| 133 | |
| 134 | |
| 135 | /// skipRecord - Read the current record and discard it. |
| 136 | void BitstreamCursor::skipRecord(unsigned AbbrevID) { |
| 137 | // Skip unabbreviated records by reading past their entries. |
| 138 | if (AbbrevID == bitc::UNABBREV_RECORD) { |
| 139 | unsigned Code = ReadVBR(6); |
| 140 | (void)Code; |
| 141 | unsigned NumElts = ReadVBR(6); |
| 142 | for (unsigned i = 0; i != NumElts; ++i) |
| 143 | (void)ReadVBR64(6); |
| 144 | return; |
| 145 | } |
| 146 | |
| 147 | const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 148 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 149 | for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { |
| 150 | const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); |
| 151 | if (Op.isLiteral()) |
| 152 | continue; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 153 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 154 | if (Op.getEncoding() != BitCodeAbbrevOp::Array && |
| 155 | Op.getEncoding() != BitCodeAbbrevOp::Blob) { |
| 156 | skipAbbreviatedField(Op); |
| 157 | continue; |
| 158 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 159 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 160 | if (Op.getEncoding() == BitCodeAbbrevOp::Array) { |
| 161 | // Array case. Read the number of elements as a vbr6. |
| 162 | unsigned NumElts = ReadVBR(6); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 163 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 164 | // Get the element encoding. |
| 165 | assert(i+2 == e && "array op not second to last?"); |
| 166 | const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 167 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 168 | // Read all the elements. |
| 169 | for (; NumElts; --NumElts) |
| 170 | skipAbbreviatedField(EltEnc); |
| 171 | continue; |
| 172 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 173 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 174 | assert(Op.getEncoding() == BitCodeAbbrevOp::Blob); |
| 175 | // Blob case. Read the number of bytes as a vbr6. |
| 176 | unsigned NumElts = ReadVBR(6); |
Chris Lattner | fd0543d | 2013-01-21 18:04:19 +0000 | [diff] [blame] | 177 | SkipToFourByteBoundary(); // 32-bit alignment |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 178 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 179 | // Figure out where the end of this blob will be including tail padding. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 180 | size_t NewEnd = GetCurrentBitNo()+((NumElts+3)&~3)*8; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 181 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 182 | // If this would read off the end of the bitcode file, just set the |
| 183 | // record to empty and return. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 184 | if (!canSkipToPos(NewEnd/8)) { |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 185 | NextChar = BitStream->getBitcodeBytes().getExtent(); |
| 186 | break; |
| 187 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 188 | |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 189 | // Skip over the blob. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 190 | JumpToBit(NewEnd); |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 191 | } |
| 192 | } |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 193 | |
Chris Lattner | 194ef24 | 2013-01-20 01:06:48 +0000 | [diff] [blame] | 194 | unsigned BitstreamCursor::readRecord(unsigned AbbrevID, |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 195 | SmallVectorImpl<uint64_t> &Vals, |
Chris Lattner | 194ef24 | 2013-01-20 01:06:48 +0000 | [diff] [blame] | 196 | StringRef *Blob) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 197 | if (AbbrevID == bitc::UNABBREV_RECORD) { |
| 198 | unsigned Code = ReadVBR(6); |
| 199 | unsigned NumElts = ReadVBR(6); |
| 200 | for (unsigned i = 0; i != NumElts; ++i) |
| 201 | Vals.push_back(ReadVBR64(6)); |
| 202 | return Code; |
| 203 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 204 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 205 | const BitCodeAbbrev *Abbv = getAbbrev(AbbrevID); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 206 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 207 | for (unsigned i = 0, e = Abbv->getNumOperandInfos(); i != e; ++i) { |
| 208 | const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i); |
| 209 | if (Op.isLiteral()) { |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 210 | readAbbreviatedLiteral(Op, Vals); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 211 | continue; |
| 212 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 213 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 214 | if (Op.getEncoding() != BitCodeAbbrevOp::Array && |
| 215 | Op.getEncoding() != BitCodeAbbrevOp::Blob) { |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 216 | readAbbreviatedField(Op, Vals); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 217 | continue; |
| 218 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 219 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 220 | if (Op.getEncoding() == BitCodeAbbrevOp::Array) { |
| 221 | // Array case. Read the number of elements as a vbr6. |
| 222 | unsigned NumElts = ReadVBR(6); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 223 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 224 | // Get the element encoding. |
| 225 | assert(i+2 == e && "array op not second to last?"); |
| 226 | const BitCodeAbbrevOp &EltEnc = Abbv->getOperandInfo(++i); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 227 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 228 | // Read all the elements. |
| 229 | for (; NumElts; --NumElts) |
Chris Lattner | f9147c4 | 2013-01-20 00:00:00 +0000 | [diff] [blame] | 230 | readAbbreviatedField(EltEnc, Vals); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 231 | continue; |
| 232 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 233 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 234 | assert(Op.getEncoding() == BitCodeAbbrevOp::Blob); |
| 235 | // Blob case. Read the number of bytes as a vbr6. |
| 236 | unsigned NumElts = ReadVBR(6); |
Chris Lattner | fd0543d | 2013-01-21 18:04:19 +0000 | [diff] [blame] | 237 | SkipToFourByteBoundary(); // 32-bit alignment |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 238 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 239 | // Figure out where the end of this blob will be including tail padding. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 240 | size_t CurBitPos = GetCurrentBitNo(); |
| 241 | size_t NewEnd = CurBitPos+((NumElts+3)&~3)*8; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 242 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 243 | // If this would read off the end of the bitcode file, just set the |
| 244 | // record to empty and return. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 245 | if (!canSkipToPos(NewEnd/8)) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 246 | Vals.append(NumElts, 0); |
| 247 | NextChar = BitStream->getBitcodeBytes().getExtent(); |
| 248 | break; |
| 249 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 250 | |
Chris Lattner | 69582cf | 2013-01-21 18:24:49 +0000 | [diff] [blame] | 251 | // Otherwise, inform the streamer that we need these bytes in memory. |
| 252 | const char *Ptr = (const char*) |
| 253 | BitStream->getBitcodeBytes().getPointer(CurBitPos/8, NumElts); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 254 | |
Chris Lattner | 69582cf | 2013-01-21 18:24:49 +0000 | [diff] [blame] | 255 | // If we can return a reference to the data, do so to avoid copying it. |
Chris Lattner | 194ef24 | 2013-01-20 01:06:48 +0000 | [diff] [blame] | 256 | if (Blob) { |
Chris Lattner | 69582cf | 2013-01-21 18:24:49 +0000 | [diff] [blame] | 257 | *Blob = StringRef(Ptr, NumElts); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 258 | } else { |
Chris Lattner | 69582cf | 2013-01-21 18:24:49 +0000 | [diff] [blame] | 259 | // Otherwise, unpack into Vals with zero extension. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 260 | for (; NumElts; --NumElts) |
Chris Lattner | 69582cf | 2013-01-21 18:24:49 +0000 | [diff] [blame] | 261 | Vals.push_back((unsigned char)*Ptr++); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 262 | } |
| 263 | // Skip over tail padding. |
Chris Lattner | 47543a8 | 2013-01-21 18:18:25 +0000 | [diff] [blame] | 264 | JumpToBit(NewEnd); |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 265 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 266 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 267 | unsigned Code = (unsigned)Vals[0]; |
| 268 | Vals.erase(Vals.begin()); |
| 269 | return Code; |
| 270 | } |
| 271 | |
| 272 | |
| 273 | void BitstreamCursor::ReadAbbrevRecord() { |
| 274 | BitCodeAbbrev *Abbv = new BitCodeAbbrev(); |
| 275 | unsigned NumOpInfo = ReadVBR(5); |
| 276 | for (unsigned i = 0; i != NumOpInfo; ++i) { |
| 277 | bool IsLiteral = Read(1) ? true : false; |
| 278 | if (IsLiteral) { |
| 279 | Abbv->Add(BitCodeAbbrevOp(ReadVBR64(8))); |
| 280 | continue; |
| 281 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 282 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 283 | BitCodeAbbrevOp::Encoding E = (BitCodeAbbrevOp::Encoding)Read(3); |
Chris Lattner | b24f5b7 | 2013-02-09 07:07:29 +0000 | [diff] [blame] | 284 | if (BitCodeAbbrevOp::hasEncodingData(E)) { |
| 285 | unsigned Data = ReadVBR64(5); |
| 286 | |
| 287 | // As a special case, handle fixed(0) (i.e., a fixed field with zero bits) |
| 288 | // and vbr(0) as a literal zero. This is decoded the same way, and avoids |
| 289 | // a slow path in Read() to have to handle reading zero bits. |
| 290 | if ((E == BitCodeAbbrevOp::Fixed || E == BitCodeAbbrevOp::VBR) && |
| 291 | Data == 0) { |
| 292 | Abbv->Add(BitCodeAbbrevOp(0)); |
| 293 | continue; |
| 294 | } |
| 295 | |
| 296 | Abbv->Add(BitCodeAbbrevOp(E, Data)); |
| 297 | } else |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 298 | Abbv->Add(BitCodeAbbrevOp(E)); |
| 299 | } |
| 300 | CurAbbrevs.push_back(Abbv); |
| 301 | } |
| 302 | |
| 303 | bool BitstreamCursor::ReadBlockInfoBlock() { |
| 304 | // If this is the second stream to get to the block info block, skip it. |
| 305 | if (BitStream->hasBlockInfoRecords()) |
| 306 | return SkipBlock(); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 307 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 308 | if (EnterSubBlock(bitc::BLOCKINFO_BLOCK_ID)) return true; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 309 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 310 | SmallVector<uint64_t, 64> Record; |
| 311 | BitstreamReader::BlockInfo *CurBlockInfo = 0; |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 312 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 313 | // Read all the records for this module. |
| 314 | while (1) { |
Chris Lattner | 5a4251c | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 315 | BitstreamEntry Entry = advanceSkippingSubblocks(AF_DontAutoprocessAbbrevs); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 316 | |
Chris Lattner | 5a4251c | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 317 | switch (Entry.Kind) { |
| 318 | case llvm::BitstreamEntry::SubBlock: // Handled for us already. |
| 319 | case llvm::BitstreamEntry::Error: |
| 320 | return true; |
| 321 | case llvm::BitstreamEntry::EndBlock: |
| 322 | return false; |
| 323 | case llvm::BitstreamEntry::Record: |
| 324 | // The interesting case. |
| 325 | break; |
| 326 | } |
| 327 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 328 | // Read abbrev records, associate them with CurBID. |
Chris Lattner | 5a4251c | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 329 | if (Entry.ID == bitc::DEFINE_ABBREV) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 330 | if (!CurBlockInfo) return true; |
| 331 | ReadAbbrevRecord(); |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 332 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 333 | // ReadAbbrevRecord installs the abbrev in CurAbbrevs. Move it to the |
| 334 | // appropriate BlockInfo. |
| 335 | BitCodeAbbrev *Abbv = CurAbbrevs.back(); |
| 336 | CurAbbrevs.pop_back(); |
| 337 | CurBlockInfo->Abbrevs.push_back(Abbv); |
| 338 | continue; |
| 339 | } |
Joe Abbey | acb6194 | 2013-02-06 22:14:06 +0000 | [diff] [blame] | 340 | |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 341 | // Read a record. |
| 342 | Record.clear(); |
Chris Lattner | 5a4251c | 2013-01-20 02:13:19 +0000 | [diff] [blame] | 343 | switch (readRecord(Entry.ID, Record)) { |
Chris Lattner | 312c7d9 | 2013-01-19 18:19:39 +0000 | [diff] [blame] | 344 | default: break; // Default behavior, ignore unknown content. |
| 345 | case bitc::BLOCKINFO_CODE_SETBID: |
| 346 | if (Record.size() < 1) return true; |
| 347 | CurBlockInfo = &BitStream->getOrCreateBlockInfo((unsigned)Record[0]); |
| 348 | break; |
| 349 | case bitc::BLOCKINFO_CODE_BLOCKNAME: { |
| 350 | if (!CurBlockInfo) return true; |
| 351 | if (BitStream->isIgnoringBlockInfoNames()) break; // Ignore name. |
| 352 | std::string Name; |
| 353 | for (unsigned i = 0, e = Record.size(); i != e; ++i) |
| 354 | Name += (char)Record[i]; |
| 355 | CurBlockInfo->Name = Name; |
| 356 | break; |
| 357 | } |
| 358 | case bitc::BLOCKINFO_CODE_SETRECORDNAME: { |
| 359 | if (!CurBlockInfo) return true; |
| 360 | if (BitStream->isIgnoringBlockInfoNames()) break; // Ignore name. |
| 361 | std::string Name; |
| 362 | for (unsigned i = 1, e = Record.size(); i != e; ++i) |
| 363 | Name += (char)Record[i]; |
| 364 | CurBlockInfo->RecordNames.push_back(std::make_pair((unsigned)Record[0], |
| 365 | Name)); |
| 366 | break; |
| 367 | } |
| 368 | } |
| 369 | } |
| 370 | } |
| 371 | |