Avoid unintended integer overflow in bitstream handling

[andrew.w.kaylor]

Summary

This change fixes two cases detected by static analysis where an operation is being performed on a 32-bit integer which may overflow and the result is assigned to a 64-bit integer.

[tahonermann]

Sorry for the very delayed review, @andrew.w.kaylor; I managed not to see this request until now.

The changes look fine to me.

llvm/include/llvm/Bitstream/BitstreamReader.h

public:
   }
 
   bool AtEndOfStream() {
     return BitsInCurWord == 0 && BitcodeBytes.size() <= NextChar;
   }
 
   /// Return the bit # of the bit we are reading.
   uint64_t GetCurrentBitNo() const {
-    return NextChar*CHAR_BIT - BitsInCurWord;
+    return uint64_t(NextChar)*CHAR_BIT - BitsInCurWord;
   }
 
   // Return the byte # of the current bit.
   uint64_t getCurrentByteNo() const { return GetCurrentBitNo() / 8; }
 
   ArrayRef<uint8_t> getBitcodeBytes() const { return BitcodeBytes; }
 
   /// Reset the stream to the specified bit number.

llvm/include/llvm/Bitstream/BitstreamWriter.h

public:
   ///
   /// \p FS is the file stream that \p O flushes to incrementally. If \p FS is
   /// null, \p O does not flush incrementially, but writes to disk at the end.
   ///
   /// \p FlushThreshold is the threshold (unit M) to flush \p O if \p FS is
   /// valid. Flushing only occurs at (sub)block boundaries.
   BitstreamWriter(SmallVectorImpl<char> &O, raw_fd_stream *FS = nullptr,
                   uint32_t FlushThreshold = 512)
-      : Out(O), FS(FS), FlushThreshold(FlushThreshold << 20), CurBit(0),
+      : Out(O), FS(FS), FlushThreshold(uint64_t(FlushThreshold) << 20), CurBit(0),
         CurValue(0), CurCodeSize(2) {}
 
   ~BitstreamWriter() {
     assert(CurBit == 0 && "Unflushed data remaining");
     assert(BlockScope.empty() && CurAbbrevs.empty() && "Block imbalance");
   }
 
   /// Retrieve the current position in the stream, in bits.