6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-04-29 15:37:46 +00:00
Code Issues Projects Releases Wiki Activity

switch llvm-bcanalyzer onto the new cursor APIs, allowing deletion of

Browse Source 
the old ReadRecord methods.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@172952 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2013-01-20 02:50:32 +00:00
parent 52878db465
commit 4156ca76e3
2 changed files with 67 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
include/llvm/Bitcode/BitstreamReader.h
View File

@ -158,6 +158,7 @@ struct BitstreamEntry {
BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E; BitstreamEntry E; E.Kind = Record; E.ID = AbbrevID; return E;
} }
}; };
/// BitstreamCursor - This represents a position within a bitcode file. There /// BitstreamCursor - This represents a position within a bitcode file. There
/// may be multiple independent cursors reading within one bitstream, each /// may be multiple independent cursors reading within one bitstream, each
@ -516,22 +517,6 @@ public:
unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals, unsigned readRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
StringRef *Blob = 0); StringRef *Blob = 0);
unsigned ReadRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
const char **BlobStart = 0, unsigned *BlobLen = 0) {
if (!BlobStart)
return readRecord(AbbrevID, Vals);
StringRef S;
unsigned X = readRecord(AbbrevID, Vals, &S);
*BlobStart = S.data();
*BlobLen = S.size();
return X;
}
unsigned ReadRecord(unsigned AbbrevID, SmallVectorImpl<uint64_t> &Vals,
const char *&BlobStart, unsigned &BlobLen) {
return ReadRecord(AbbrevID, Vals, &BlobStart, &BlobLen);
}
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Abbrev Processing // Abbrev Processing
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//

128
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
View File

@ -318,10 +318,10 @@ static bool Error(const std::string &Err) {
} }
/// ParseBlock - Read a block, updating statistics, etc. /// ParseBlock - Read a block, updating statistics, etc.
static bool ParseBlock(BitstreamCursor &Stream, unsigned IndentLevel) { static bool ParseBlock(BitstreamCursor &Stream, unsigned BlockID,
unsigned IndentLevel) {
std::string Indent(IndentLevel*2, ' '); std::string Indent(IndentLevel*2, ' ');
uint64_t BlockBitStart = Stream.GetCurrentBitNo(); uint64_t BlockBitStart = Stream.GetCurrentBitNo();
unsigned BlockID = Stream.ReadSubBlockID();
// Get the statistics for this BlockID. // Get the statistics for this BlockID.
PerBlockIDStats &BlockStats = BlockIDStats[BlockID]; PerBlockIDStats &BlockStats = BlockIDStats[BlockID];
@ -366,12 +366,13 @@ static bool ParseBlock(BitstreamCursor &Stream, unsigned IndentLevel) {
uint64_t RecordStartBit = Stream.GetCurrentBitNo(); uint64_t RecordStartBit = Stream.GetCurrentBitNo();
// Read the code for this record. BitstreamEntry Entry =
unsigned AbbrevID = Stream.ReadCode(); Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
switch (AbbrevID) {
case bitc::END_BLOCK: { switch (Entry.Kind) {
if (Stream.ReadBlockEnd()) case BitstreamEntry::Error:
return Error("Error at end of block"); return Error("malformed bitcode file");
case BitstreamEntry::EndBlock: {
uint64_t BlockBitEnd = Stream.GetCurrentBitNo(); uint64_t BlockBitEnd = Stream.GetCurrentBitNo();
BlockStats.NumBits += BlockBitEnd-BlockBitStart; BlockStats.NumBits += BlockBitEnd-BlockBitStart;
if (Dump) { if (Dump) {
@ -383,80 +384,81 @@ static bool ParseBlock(BitstreamCursor &Stream, unsigned IndentLevel) {
} }
return false; return false;
} }
case bitc::ENTER_SUBBLOCK: {
case BitstreamEntry::SubBlock: {
uint64_t SubBlockBitStart = Stream.GetCurrentBitNo(); uint64_t SubBlockBitStart = Stream.GetCurrentBitNo();
if (ParseBlock(Stream, IndentLevel+1)) if (ParseBlock(Stream, Entry.ID, IndentLevel+1))
return true; return true;
++BlockStats.NumSubBlocks; ++BlockStats.NumSubBlocks;
uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo(); uint64_t SubBlockBitEnd = Stream.GetCurrentBitNo();
// Don't include subblock sizes in the size of this block. // Don't include subblock sizes in the size of this block.
BlockBitStart += SubBlockBitEnd-SubBlockBitStart; BlockBitStart += SubBlockBitEnd-SubBlockBitStart;
continue;
}
case BitstreamEntry::Record:
// The interesting case.
break; break;
} }
case bitc::DEFINE_ABBREV:
if (Entry.ID == bitc::DEFINE_ABBREV) {
Stream.ReadAbbrevRecord(); Stream.ReadAbbrevRecord();
++BlockStats.NumAbbrevs; ++BlockStats.NumAbbrevs;
break; continue;
default: }
Record.clear();
Record.clear();
++BlockStats.NumRecords; ++BlockStats.NumRecords;
if (AbbrevID != bitc::UNABBREV_RECORD)
++BlockStats.NumAbbreviatedRecords;
const char *BlobStart = 0; StringRef Blob;
unsigned BlobLen = 0; unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
unsigned Code = Stream.ReadRecord(AbbrevID, Record, BlobStart, BlobLen);
// Increment the # occurrences of this code.
if (BlockStats.CodeFreq.size() <= Code)
BlockStats.CodeFreq.resize(Code+1);
BlockStats.CodeFreq[Code].NumInstances++;
BlockStats.CodeFreq[Code].TotalBits +=
Stream.GetCurrentBitNo()-RecordStartBit;
if (Entry.ID != bitc::UNABBREV_RECORD) {
BlockStats.CodeFreq[Code].NumAbbrev++;
++BlockStats.NumAbbreviatedRecords;
}
if (Dump) {
// Increment the # occurrences of this code. outs() << Indent << " <";
if (BlockStats.CodeFreq.size() <= Code) if (const char *CodeName =
BlockStats.CodeFreq.resize(Code+1);
BlockStats.CodeFreq[Code].NumInstances++;
BlockStats.CodeFreq[Code].TotalBits +=
Stream.GetCurrentBitNo()-RecordStartBit;
if (AbbrevID != bitc::UNABBREV_RECORD)
BlockStats.CodeFreq[Code].NumAbbrev++;
if (Dump) {
outs() << Indent << " <";
if (const char *CodeName =
GetCodeName(Code, BlockID, *Stream.getBitStreamReader()))
outs() << CodeName;
else
outs() << "UnknownCode" << Code;
if (NonSymbolic &&
GetCodeName(Code, BlockID, *Stream.getBitStreamReader())) GetCodeName(Code, BlockID, *Stream.getBitStreamReader()))
outs() << " codeid=" << Code; outs() << CodeName;
if (AbbrevID != bitc::UNABBREV_RECORD) else
outs() << " abbrevid=" << AbbrevID; outs() << "UnknownCode" << Code;
if (NonSymbolic &&
GetCodeName(Code, BlockID, *Stream.getBitStreamReader()))
outs() << " codeid=" << Code;
if (Entry.ID != bitc::UNABBREV_RECORD)
outs() << " abbrevid=" << Entry.ID;
for (unsigned i = 0, e = Record.size(); i != e; ++i) for (unsigned i = 0, e = Record.size(); i != e; ++i)
outs() << " op" << i << "=" << (int64_t)Record[i]; outs() << " op" << i << "=" << (int64_t)Record[i];
outs() << "/>"; outs() << "/>";
if (BlobStart) { if (Blob.data()) {
outs() << " blob data = "; outs() << " blob data = ";
bool BlobIsPrintable = true; bool BlobIsPrintable = true;
for (unsigned i = 0; i != BlobLen; ++i) for (unsigned i = 0, e = Blob.size(); i != e; ++i)
if (!isprint(BlobStart[i])) { if (!isprint(Blob[i])) {
BlobIsPrintable = false; BlobIsPrintable = false;
break; break;
} }
if (BlobIsPrintable) if (BlobIsPrintable)
outs() << "'" << std::string(BlobStart, BlobStart+BlobLen) <<"'"; outs() << "'" << Blob << "'";
else else
outs() << "unprintable, " << BlobLen << " bytes."; outs() << "unprintable, " << Blob.size() << " bytes.";
}
outs() << "\n";
} }
break; outs() << "\n";
} }
} }
} }
@ -519,7 +521,9 @@ static int AnalyzeBitcode() {
if (Code != bitc::ENTER_SUBBLOCK) if (Code != bitc::ENTER_SUBBLOCK)
return Error("Invalid record at top-level"); return Error("Invalid record at top-level");
if (ParseBlock(Stream, 0)) unsigned BlockID = Stream.ReadSubBlockID();
if (ParseBlock(Stream, BlockID, 0))
return true; return true;
++NumTopBlocks; ++NumTopBlocks;
} }