Fix infinite recursion in MCAsmStreamer::EmitValueImpl

[alexandru.guduleasa]

Summary

If a target can only emit 8-bits data, it will loop in EmitValueImpl since it will try to split a 32-bits data in 1 chunk of 32-bits.
Since we know that "Size" is not supported on the target, we limit the value of "EmissionSize" to the greatest power of 2, smaller than "Size".

[• rafael]

Can this be tested?

EmissionSize can now go out of the loop.

The comment just before the code you changed needs to be updated.

[alexandru.guduleasa]

I've updated the comment just above the changes.
Also, I've computed the EmissionSize based on the min of (Size - 1) and Remaining.
This is closer to the original implementation.
If Size is a number that is not a power of 2 (e.g. 7), this should result in a 4+2+1 split in normal cases.
If the target does not support 4, instead of looping we will split as 2+2+2+1; the 2 values may be split as 1+1 if required.

Unfortunately, this can't be tested since I don't think there is a target in the official repository that can't emit 4 bytes.

[• rafael]

LGTM

[alexandru.guduleasa]

Thank you for the review!
Can someone help me commit this?

[• rafael]

r259399.

lib/MC/MCAsmStreamer.cpp

void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
   }
 
   if (!Directive) {
     int64_t IntValue;
     if (!Value->evaluateAsAbsolute(IntValue))
       report_fatal_error("Don't know how to emit this value.");
 
     // We couldn't handle the requested integer size so we fallback by breaking
-    // the request down into several, smaller, integers.  Since sizes greater
-    // than eight are invalid and size equivalent to eight should have been
-    // handled earlier, we use four bytes as our largest piece of granularity.
+    // the request down into several, smaller, integers.
+    // Since sizes greater or equal to "Size" are invalid, we use the greatest
+    // power of 2 that is less than "Size" as our largest piece of granularity.
     bool IsLittleEndian = MAI->isLittleEndian();
     for (unsigned Emitted = 0; Emitted != Size;) {
       unsigned Remaining = Size - Emitted;
       // The size of our partial emission must be a power of two less than
-      // eight.
-      unsigned EmissionSize = PowerOf2Floor(Remaining);
-      if (EmissionSize > 4)
-        EmissionSize = 4;
+      // Size.
+      unsigned EmissionSize = PowerOf2Floor(std::min(Remaining, Size - 1));
       // Calculate the byte offset of our partial emission taking into account
       // the endianness of the target.
       unsigned ByteOffset =
           IsLittleEndian ? Emitted : (Remaining - EmissionSize);
       uint64_t ValueToEmit = IntValue >> (ByteOffset * 8);
       // We truncate our partial emission to fit within the bounds of the
       // emission domain.  This produces nicer output and silences potential
       // truncation warnings when round tripping through another assembler.