[lldb][PPC64] Fixed long double variables dump

[luporl]

Summary

LLDB's DumpDataExtractor was not prepared to handle PowerPC's long double type: PPCDoubleDouble.

As it is somewhat special, treating it as other regular float types resulted in getting wrong information about it.
In this particular case, llvm::APFloat::getSizeInBits(PPCDoubleDouble) was returning 0.

This caused the TestSetValues.py test to fail, because lldb would abort on an assertion failure on APInt(), because of the invalid size.

This patch checks if the FloatTypeSemantics is PPCDoubleDouble and, if so, sets the byte size of the variable to 16.

This fixed the issue and the test is passing now.

[labath]

This adds a special case to "long double" logic, which is already a special case compared to "float" and "double" cases. This was written this way (see http://reviews.llvm.org/D8417) because the x86 long double type is special, but if I understand this correctly, for the ppc type, the "default" logic of just using the item_byte_size would be correct.

What if we reverse the conditions here to be something like?

offset_t byte_size = item_byte_size;
if (&semantics == &x87DoubleExtended)
  byte_size = (APFloat::getSizeInBits(semantics)+7)/8;

[luporl]

@labath, the change you suggested really looks better, by reducing the number of special cases.

I tested it on PPC64 and it also fixes the issue, as expected.

I'll update the diff.
Thanks!

[luporl]

Changed implementation to make only x87DoubleExtended a special case.

[labath]

Awesome, thanks.

[luporl]

@labath, can you please commit the changes for me? (I don't have permission to do it)

lldb/trunk/source/Core/DumpDataExtractor.cpp

case eFormatFloat: {
               if (GetAPInt(DE, &offset, item_byte_size, apint)) {
                 llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy),
                                       apint);
                 apfloat.toString(sv, format_precision, format_max_padding);
               }
             } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) {
               const auto &semantics =
                   ast->getFloatTypeSemantics(ast->LongDoubleTy);
-              const auto byte_size =
-                  (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
+
+              offset_t byte_size = item_byte_size;
+              if (&semantics == &llvm::APFloatBase::x87DoubleExtended())
+                byte_size = (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
 
               llvm::APInt apint;
               if (GetAPInt(DE, &offset, byte_size, apint)) {
                 llvm::APFloat apfloat(semantics, apint);
                 apfloat.toString(sv, format_precision, format_max_padding);
               }
             } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) {
               llvm::APInt apint(item_bit_size, DE.GetU16(&offset));