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