Avoid assertion failure when serialising constant integer values.

We used a loop to get the individual bytes of a constant value and
serialise them.

This would crash if we ask for 8-bits from the value, but there are
fewer than 8 bits to fetch. E.g. for a i1, you can never fetch a whole
byte's worth of bits.

This change ensures we fetch the right number of bits (i.e. fewer than 8
if there are fewer than 8 left).

Author: vext01

llvm/lib/YkIR/YkIRWriter.cpp

@@ -768,10 +768,26 @@ class YkIRWriter {
 
   void serialiseConstantInt(ConstantInt *CI) {
     OutStreamer.emitSizeT(typeIndex(CI->getType()));
-    OutStreamer.emitSizeT(CI->getBitWidth() / 8);
-    for (size_t I = 0; I < CI->getBitWidth(); I += 8) {
-      uint64_t Byte = CI->getValue().extractBitsAsZExtValue(8, I);
+    unsigned BitWidth = CI->getBitWidth();
+
+    // Figure out how many bytes it'd take to store that many bits.
+    unsigned ByteWidth = BitWidth / 8;
+    if (BitWidth % 8 != 0) {
+      ByteWidth++;
+    }
+    OutStreamer.emitSizeT(ByteWidth);
+
+    unsigned BitsRemain = BitWidth;
+    while (BitsRemain > 0) {
+      // We have to be careful not to ask extractBitsAsZExtValue() for more
+      // bits than there are left, or an internal assertion will fail.
+      unsigned NumBitsThisIter = std::min({BitsRemain, unsigned(8)});
+      uint64_t Byte = CI->getValue().extractBitsAsZExtValue(
+          NumBitsThisIter, BitWidth - BitsRemain);
+      // This could be optimised by writing larger chunks thank a byte, but
+      // beware endianess!
       OutStreamer.emitInt8(Byte);
+      BitsRemain -= NumBitsThisIter;
     }
   }