Fix for llvm-dis/llvm-bcanalyzer overflows

[tejohnson]

Summary

These tools failed for a very large bitcode file produced by LTO due to
64-bit values being assigned to 32-bit types. For the BitstreamReader.h
fix, the value initially fit into the 32-bit unsigned, but there was an
overflow when multiplying by 32 furter below to compute the bit offset.

No test case in the patch as this requires a huge bitcode file.

[pcc]

LGTM

llvm/trunk/include/llvm/Bitcode/BitstreamReader.h

public:
 
   /// Having read the ENTER_SUBBLOCK abbrevid and a BlockID, skip over the body
   /// of this block. If the block record is malformed, return true.
   bool SkipBlock() {
     // Read and ignore the codelen value.  Since we are skipping this block, we
     // don't care what code widths are used inside of it.
     ReadVBR(bitc::CodeLenWidth);
     SkipToFourByteBoundary();
-    unsigned NumFourBytes = Read(bitc::BlockSizeWidth);
+    size_t NumFourBytes = Read(bitc::BlockSizeWidth);
 
     // Check that the block wasn't partially defined, and that the offset isn't
     // bogus.
     size_t SkipTo = GetCurrentBitNo() + NumFourBytes*4*8;
     if (AtEndOfStream() || !canSkipToPos(SkipTo/8))
       return true;
 
     JumpToBit(SkipTo);

llvm/trunk/tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp

if (Entry.ID == bitc::DEFINE_ABBREV) {
       continue;
     }
     
     Record.clear();
 
     ++BlockStats.NumRecords;
 
     StringRef Blob;
-    unsigned CurrentRecordPos = Stream.GetCurrentBitNo();
+    uint64_t CurrentRecordPos = Stream.GetCurrentBitNo();
     unsigned Code = Stream.readRecord(Entry.ID, Record, &Blob);
 
     // 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;