Remove Scalar::Cast

[tromey]

Summary

It was noted on the list that this method is unused. So, this patch
removes it.

Fix Scalar::Promote for most integer types

This fixes promotion of most integer types (128- and 256-bit types are
handled in a subsequent patch) to floating-point types. Previously
promotion was done bitwise, where value preservation is correct.

Fix Scalar::Promote for 128- and 256-bit integer types

This patch fixes the behavior of Scalar::Promote when trying to
perform a binary operation involving a 128- or 256-bit integer type
and a floating-point type. Now, the integer is cast to the floating
point type for the operation.

[clayborg]

Very nice. Thanks for doing this. Someone a while back had converted Scalar to use APInt and APFloat and never got around to all of these details.

[davide]

@tromey thanks! do you need somebody to commit this for you?

[tromey]

In D44907#1051931, @davide wrote:

@tromey thanks! do you need somebody to commit this for you?

Yes. I do not have commit access.

[davide]

OK, I'll commit it for you later today.

include/lldb/Core/Scalar.h

public:
   enum Type {
     e_void = 0,
     e_sint,
     e_uint,
     e_slong,
     e_ulong,
     e_slonglong,
     e_ulonglong,
-    e_float,
-    e_double,
-    e_long_double,
-    e_uint128,
     e_sint128,
+    e_uint128,
+    e_sint256,
     e_uint256,
-    e_sint256
+    e_float,
+    e_double,
+    e_long_double
   };
 
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
   Scalar();
   Scalar(int v) : m_type(e_sint), m_float((float)0) {
     m_integer = llvm::APInt(sizeof(int) * 8, v, true);
public:
   void GetValue(Stream *s, bool show_type) const;
 
   bool IsValid() const {
     return (m_type >= e_sint) && (m_type <= e_long_double);
   }
 
   bool Promote(Scalar::Type type);
 
-  bool Cast(Scalar::Type type);
-
   bool MakeSigned();
 
   bool MakeUnsigned();
 
   static const char *GetValueTypeAsCString(Scalar::Type value_type);
 
   static Scalar::Type
   GetValueTypeForSignedIntegerWithByteSize(size_t byte_size);

source/Core/Scalar.cpp

case e_sint:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_uint:
     switch (type) {
     case e_void:
case e_uint:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_slong:
     switch (type) {
     case e_void:
case e_slong:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_ulong:
     switch (type) {
     case e_void:
case e_ulong:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_slonglong:
     switch (type) {
     case e_void:
case e_slonglong:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_ulonglong:
     switch (type) {
     case e_void:
case e_ulonglong:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_sint128:
     switch (type) {
     case e_void:
case e_sint128:
 
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_uint128:
     switch (type) {
     case e_void:
case e_uint128:
       break;
     case e_sint256:
     case e_uint256:
       m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_sint256:
     switch (type) {
     case e_void:
case e_sint256:
       success = true;
       break;
     case e_uint256:
       m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
       success = true;
       break;
 
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, true, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_uint256:
     switch (type) {
     case e_void:
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
       break;
     case e_uint256:
       success = true;
       break;
     case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEsingle());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
+      m_float = llvm::APFloat(llvm::APFloat::IEEEdouble());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
 
     case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
+      m_float = llvm::APFloat(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                              llvm::APFloat::x87DoubleExtended());
+      m_float.convertFromAPInt(m_integer, false, llvm::APFloat::rmNearestTiesToEven);
       success = true;
       break;
     }
     break;
 
   case e_float:
     switch (type) {
     case e_void:
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
       break;
     case e_float:
       success = true;
       break;
     case e_double:
-      m_float = llvm::APFloat((float_t)m_float.convertToFloat());
+      m_float = llvm::APFloat((double_t)m_float.convertToFloat());
       success = true;
       break;
 
-    case e_long_double:
-      if (m_ieee_quad)
-        m_float =
-            llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                                m_float.bitcastToAPInt());
+    case e_long_double: {
+      bool ignore;
+      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                      llvm::APFloat::x87DoubleExtended(),
+                      llvm::APFloat::rmNearestTiesToEven,
+                      &ignore);
       success = true;
       break;
     }
+    }
     break;
 
   case e_double:
     switch (type) {
     case e_void:
     case e_sint:
     case e_uint:
     case e_slong:
     case e_ulong:
     case e_slonglong:
     case e_ulonglong:
     case e_sint128:
     case e_uint128:
     case e_sint256:
     case e_uint256:
     case e_float:
       break;
     case e_double:
       success = true;
       break;
-    case e_long_double:
-      if (m_ieee_quad)
-        m_float =
-            llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                                m_float.bitcastToAPInt());
+    case e_long_double: {
+      bool ignore;
+      m_float.convert(m_ieee_quad ? llvm::APFloat::IEEEquad() :
+                      llvm::APFloat::x87DoubleExtended(),
+                      llvm::APFloat::rmNearestTiesToEven,
+                      &ignore);
       success = true;
       break;
     }
+    }
     break;
 
   case e_long_double:
     switch (type) {
     case e_void:
     case e_sint:
     case e_uint:
     case e_slong:
if (byte_size == sizeof(float_t))
     return e_float;
   if (byte_size == sizeof(double_t))
     return e_double;
   if (byte_size == sizeof(long_double_t))
     return e_long_double;
   return e_void;
 }
 
-bool Scalar::Cast(Scalar::Type type) {
-  bool success = false;
-  switch (m_type) {
-  case e_void:
-    break;
-
-  case e_sint:
-  case e_uint:
-  case e_slong:
-  case e_ulong:
-  case e_slonglong:
-  case e_ulonglong:
-  case e_sint128:
-  case e_uint128:
-  case e_sint256:
-  case e_uint256:
-    switch (type) {
-    case e_void:
-      break;
-    case e_sint:
-      m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
-      success = true;
-      break;
-
-    case e_uint:
-      m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
-      success = true;
-      break;
-
-    case e_slong:
-      m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulong:
-      m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_slonglong:
-      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_uint128:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_uint256:
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(m_integer.bitsToFloat());
-      success = true;
-      break;
-
-    case e_double:
-      m_float = llvm::APFloat(m_integer.bitsToDouble());
-      success = true;
-      break;
-
-    case e_long_double:
-      if (m_ieee_quad)
-        m_float = llvm::APFloat(llvm::APFloat::IEEEquad(), m_integer);
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(), m_integer);
-      success = true;
-      break;
-    }
-    break;
-
-  case e_float:
-    switch (type) {
-    case e_void:
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_float.bitcastToAPInt();
-      success = true;
-      break;
-    case e_float:
-      m_float = llvm::APFloat(m_float.convertToFloat());
-      success = true;
-      break;
-    case e_double:
-      m_float = llvm::APFloat(m_float.convertToFloat());
-      success = true;
-      break;
-    case e_long_double:
-      if (m_ieee_quad)
-        m_float =
-            llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                                m_float.bitcastToAPInt());
-      success = true;
-      break;
-    }
-    break;
-
-  case e_double:
-    switch (type) {
-    case e_void:
-      break;
-    case e_sint:
-    case e_uint:
-    case e_slong:
-    case e_ulong:
-    case e_slonglong:
-    case e_ulonglong:
-    case e_sint128:
-    case e_uint128:
-    case e_sint256:
-    case e_uint256:
-      m_integer = m_float.bitcastToAPInt();
-      success = true;
-      break;
-    case e_float:
-      m_float = llvm::APFloat(m_float.convertToDouble());
-      success = true;
-      break;
-    case e_double:
-      m_float = llvm::APFloat(m_float.convertToDouble());
-      success = true;
-      break;
-    case e_long_double:
-      if (m_ieee_quad)
-        m_float =
-            llvm::APFloat(llvm::APFloat::IEEEquad(), m_float.bitcastToAPInt());
-      else
-        m_float = llvm::APFloat(llvm::APFloat::x87DoubleExtended(),
-                                m_float.bitcastToAPInt());
-      success = true;
-      break;
-    }
-    break;
-
-  case e_long_double:
-    switch (type) {
-    case e_void:
-      break;
-    case e_sint:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.sextOrTrunc(sizeof(sint_t) * 8);
-      success = true;
-      break;
-
-    case e_uint:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.zextOrTrunc(sizeof(sint_t) * 8);
-      success = true;
-      break;
-
-    case e_slong:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulong:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
-      success = true;
-      break;
-
-    case e_slonglong:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_ulonglong:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
-      success = true;
-      break;
-
-    case e_sint128:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_uint128:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
-      success = true;
-      break;
-
-    case e_sint256:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_uint256:
-      m_integer = m_float.bitcastToAPInt();
-      m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
-      success = true;
-      break;
-
-    case e_float:
-      m_float = llvm::APFloat(m_float.convertToFloat());
-      success = true;
-      break;
-    case e_double:
-      m_float = llvm::APFloat(m_float.convertToFloat());
-      success = true;
-      break;
-    case e_long_double:
-      success = true;
-      break;
-    }
-    break;
-  }
-
-  if (success)
-    m_type = type;
-  return success;
-}
-
 bool Scalar::MakeSigned() {
   bool success = false;
 
   switch (m_type) {
   case e_void:
     break;
   case e_sint:
     success = true;
float Scalar::Float(float fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return m_integer.bitsToFloat();
+    return llvm::APIntOps::RoundAPIntToFloat(m_integer);
   case e_float:
     return m_float.convertToFloat();
   case e_double:
     return (float_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return ldbl_val.bitsToFloat();
   }
double Scalar::Double(double fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return m_integer.bitsToDouble();
+    return llvm::APIntOps::RoundAPIntToDouble(m_integer);
   case e_float:
     return (double_t)m_float.convertToFloat();
   case e_double:
     return m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return ldbl_val.bitsToFloat();
   }
long double Scalar::LongDouble(long double fail_value) const {
   case e_slong:
   case e_ulong:
   case e_slonglong:
   case e_ulonglong:
   case e_sint128:
   case e_uint128:
   case e_sint256:
   case e_uint256:
-    return (long_double_t)m_integer.bitsToDouble();
+    return (long_double_t)llvm::APIntOps::RoundAPIntToDouble(m_integer);
   case e_float:
     return (long_double_t)m_float.convertToFloat();
   case e_double:
     return (long_double_t)m_float.convertToDouble();
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     return (long_double_t)ldbl_val.bitsToDouble();
   }

unittests/Core/ScalarTest.cpp

TEST(ScalarTest, CastOperations) {
   ASSERT_EQ((signed short)a, a_scalar.SShort());
   ASSERT_EQ((unsigned short)a, a_scalar.UShort());
   ASSERT_EQ((signed int)a, a_scalar.SInt());
   ASSERT_EQ((unsigned int)a, a_scalar.UInt());
   ASSERT_EQ((signed long)a, a_scalar.SLong());
   ASSERT_EQ((unsigned long)a, a_scalar.ULong());
   ASSERT_EQ((signed long long)a, a_scalar.SLongLong());
   ASSERT_EQ((unsigned long long)a, a_scalar.ULongLong());
+
+  int a2 = 23;
+  Scalar a2_scalar(a2);
+  ASSERT_EQ((float)a2, a2_scalar.Float());
+  ASSERT_EQ((double)a2, a2_scalar.Double());
+  ASSERT_EQ((long double)a2, a2_scalar.LongDouble());
 }
 
 TEST(ScalarTest, ExtractBitfield) {
   uint32_t len = sizeof(long long) * 8;
 
   long long a1 = 0xf1f2f3f4f5f6f7f8LL;
   long long b1 = 0xff1f2f3f4f5f6f7fLL;
   Scalar s_scalar(a1);
TEST(ScalarTest, GetValue) {
   EXPECT_EQ("1234567890123", ScalarGetValue<signed long long>(1234567890123LL));
   EXPECT_EQ("-1234567890123",
             ScalarGetValue<signed long long>(-1234567890123LL));
   EXPECT_EQ("1234567890123",
             ScalarGetValue<unsigned long long>(1234567890123ULL));
   EXPECT_EQ(std::to_string(std::numeric_limits<unsigned long long>::max()),
             ScalarGetValue(std::numeric_limits<unsigned long long>::max()));
 }
+
+TEST(ScalarTest, Promotion) {
+  static Scalar::Type int_types[] = {
+    Scalar::e_sint,
+    Scalar::e_uint,
+    Scalar::e_slong,
+    Scalar::e_ulong,
+    Scalar::e_slonglong,
+    Scalar::e_ulonglong,
+    Scalar::e_sint128,
+    Scalar::e_uint128,
+    Scalar::e_sint256,
+    Scalar::e_uint256,
+    Scalar::e_void                        // sentinel
+  };
+
+  static Scalar::Type float_types[] = {
+    Scalar::e_float,
+    Scalar::e_double,
+    Scalar::e_long_double,
+    Scalar::e_void                        // sentinel
+  };
+
+  for (int i = 0; int_types[i] != Scalar::e_void; ++i) {
+    for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
+      Scalar lhs(2);
+      EXPECT_TRUE(lhs.Promote(int_types[i])) << "int promotion #" << i;
+      Scalar rhs(0.5f);
+      EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
+      Scalar x(2.5f);
+      EXPECT_TRUE(x.Promote(float_types[j]));
+      EXPECT_EQ(lhs + rhs, x);
+    }
+  }
+
+  for (int i = 0; float_types[i] != Scalar::e_void; ++i) {
+    for (int j = 0; float_types[j] != Scalar::e_void; ++j) {
+      Scalar lhs(2);
+      EXPECT_TRUE(lhs.Promote(float_types[i])) << "float promotion #" << i;
+      Scalar rhs(0.5f);
+      EXPECT_TRUE(rhs.Promote(float_types[j])) << "float promotion #" << j;
+      Scalar x(2.5f);
+      EXPECT_TRUE(x.Promote(float_types[j]));
+      EXPECT_EQ(lhs + rhs, x);
+    }
+  }
+}