contrib/llvm/tools/lldb/source/Core/Scalar.cpp

   1 //===-- Scalar.cpp ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Scalar.h"
  11
  12 #include <math.h>
  13 #include <inttypes.h>
  14
  15 #include "lldb/Interpreter/Args.h"
  16 #include "lldb/Core/Error.h"
  17 #include "lldb/Core/Stream.h"
  18 #include "lldb/Core/DataExtractor.h"
  19 #include "lldb/Host/Endian.h"
  20
  21 #include "Plugins/Process/Utility/InstructionUtils.h"
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 //----------------------------------------------------------------------
  27 // Promote to max type currently follows the ANSI C rule for type
  28 // promotion in expressions.
  29 //----------------------------------------------------------------------
  30 static Scalar::Type
  31 PromoteToMaxType
  32 (
  33     const Scalar& lhs,                  // The const left hand side object
  34     const Scalar& rhs,                  // The const right hand side object
  35     Scalar& temp_value,             // A modifiable temp value than can be used to hold either the promoted lhs or rhs object
  36     const Scalar* &promoted_lhs_ptr,    // Pointer to the resulting possibly promoted value of lhs (at most one of lhs/rhs will get promoted)
  37     const Scalar* &promoted_rhs_ptr // Pointer to the resulting possibly promoted value of rhs (at most one of lhs/rhs will get promoted)
  38 )
  39 {
  40     Scalar result;
  41     // Initialize the promoted values for both the right and left hand side values
  42     // to be the objects themselves. If no promotion is needed (both right and left
  43     // have the same type), then the temp_value will not get used.
  44     promoted_lhs_ptr = &lhs;
  45     promoted_rhs_ptr = &rhs;
  46     // Extract the types of both the right and left hand side values
  47     Scalar::Type lhs_type = lhs.GetType();
  48     Scalar::Type rhs_type = rhs.GetType();
  49
  50     if (lhs_type > rhs_type)
  51     {
  52         // Right hand side need to be promoted
  53         temp_value = rhs;                   // Copy right hand side into the temp value
  54         if (temp_value.Promote(lhs_type))   // Promote it
  55             promoted_rhs_ptr = &temp_value; // Update the pointer for the promoted right hand side
  56     }
  57     else if (lhs_type < rhs_type)
  58     {
  59         // Left hand side need to be promoted
  60         temp_value = lhs;                   // Copy left hand side value into the temp value
  61         if (temp_value.Promote(rhs_type))   // Promote it
  62             promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
  63     }
  64
  65     // Make sure our type promotion worked as exptected
  66     if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
  67         return promoted_lhs_ptr->GetType(); // Return the resulting max type
  68
  69     // Return the void type (zero) if we fail to promote either of the values.
  70     return Scalar::e_void;
  71 }
  72
  73
  74 //----------------------------------------------------------------------
  75 // Scalar constructor
  76 //----------------------------------------------------------------------
  77 Scalar::Scalar() :
  78     m_type(e_void),
  79     m_data()
  80 {
  81 }
  82
  83 //----------------------------------------------------------------------
  84 // Scalar copy constructor
  85 //----------------------------------------------------------------------
  86 Scalar::Scalar(const Scalar& rhs) :
  87     m_type(rhs.m_type),
  88     m_data(rhs.m_data)  // TODO: verify that for C++ this will correctly copy the union??
  89 {
  90 }
  91
  92 //Scalar::Scalar(const RegisterValue& reg) :
  93 //  m_type(e_void),
  94 //  m_data()
  95 //{
  96 //  switch (reg.info.encoding)
  97 //  {
  98 //  case eEncodingUint:     // unsigned integer
  99 //      switch (reg.info.byte_size)
 100 //      {
 101 //      case 1: m_type = e_uint; m_data.uint = reg.value.uint8; break;
 102 //      case 2: m_type = e_uint; m_data.uint = reg.value.uint16; break;
 103 //      case 4: m_type = e_uint; m_data.uint = reg.value.uint32; break;
 104 //      case 8: m_type = e_ulonglong; m_data.ulonglong = reg.value.uint64; break;
 105 //      break;
 106 //      }
 107 //      break;
 108 //
 109 //  case eEncodingSint:     // signed integer
 110 //      switch (reg.info.byte_size)
 111 //      {
 112 //      case 1: m_type = e_sint; m_data.sint = reg.value.sint8; break;
 113 //      case 2: m_type = e_sint; m_data.sint = reg.value.sint16; break;
 114 //      case 4: m_type = e_sint; m_data.sint = reg.value.sint32; break;
 115 //      case 8: m_type = e_slonglong; m_data.slonglong = reg.value.sint64; break;
 116 //      break;
 117 //      }
 118 //      break;
 119 //
 120 //  case eEncodingIEEE754:  // float
 121 //      switch (reg.info.byte_size)
 122 //      {
 123 //      case 4: m_type = e_float; m_data.flt = reg.value.float32; break;
 124 //      case 8: m_type = e_double; m_data.dbl = reg.value.float64; break;
 125 //      break;
 126 //      }
 127 //      break;
 128 //    case eEncodingVector: // vector registers
 129 //      break;
 130 //  }
 131 //}
 132
 133 bool
 134 Scalar::GetData (DataExtractor &data, size_t limit_byte_size) const
 135 {
 136     size_t byte_size = GetByteSize();
 137     if (byte_size > 0)
 138     {
 139         if (limit_byte_size < byte_size)
 140         {
 141             if (lldb::endian::InlHostByteOrder() == eByteOrderLittle)
 142             {
 143                 // On little endian systems if we want fewer bytes from the
 144                 // current type we just specify fewer bytes since the LSByte
 145                 // is first...
 146                 data.SetData((uint8_t*)&m_data, limit_byte_size, lldb::endian::InlHostByteOrder());
 147             }
 148             else if (lldb::endian::InlHostByteOrder() == eByteOrderBig)
 149             {
 150                 // On big endian systems if we want fewer bytes from the
 151                 // current type have to advance our initial byte pointer and
 152                 // trim down the number of bytes since the MSByte is first
 153                 data.SetData(((uint8_t*)&m_data) + byte_size - limit_byte_size, limit_byte_size, lldb::endian::InlHostByteOrder());
 154             }
 155         }
 156         else
 157         {
 158             // We want all of the data
 159             data.SetData((uint8_t*)&m_data, byte_size, lldb::endian::InlHostByteOrder());
 160         }
 161         return true;
 162     }
 163     data.Clear();
 164     return false;
 165 }
 166
 167 size_t
 168 Scalar::GetByteSize() const
 169 {
 170     switch (m_type)
 171     {
 172     case e_void:
 173         break;
 174     case e_sint:        return sizeof(m_data.sint);
 175     case e_uint:        return sizeof(m_data.uint);
 176     case e_slong:       return sizeof(m_data.slong);
 177     case e_ulong:       return sizeof(m_data.ulong);
 178     case e_slonglong:   return sizeof(m_data.slonglong);
 179     case e_ulonglong:   return sizeof(m_data.ulonglong);
 180     case e_float:       return sizeof(m_data.flt);
 181     case e_double:      return sizeof(m_data.dbl);
 182     case e_long_double: return sizeof(m_data.ldbl);
 183     }
 184     return 0;
 185 }
 186
 187 bool
 188 Scalar::IsZero() const
 189 {
 190     switch (m_type)
 191     {
 192     case e_void:
 193         break;
 194     case e_sint:        return m_data.sint == 0;
 195     case e_uint:        return m_data.uint == 0;
 196     case e_slong:       return m_data.slong == 0;
 197     case e_ulong:       return m_data.ulong == 0;
 198     case e_slonglong:   return m_data.slonglong == 0;
 199     case e_ulonglong:   return m_data.ulonglong == 0;
 200     case e_float:       return m_data.flt == 0.0f;
 201     case e_double:      return m_data.dbl == 0.0;
 202     case e_long_double: return m_data.ldbl == 0.0;
 203     }
 204     return false;
 205 }
 206
 207 void
 208 Scalar::GetValue (Stream *s, bool show_type) const
 209 {
 210     if (show_type)
 211         s->Printf("(%s) ", GetTypeAsCString());
 212
 213     switch (m_type)
 214     {
 215     case e_void:
 216         break;
 217     case e_sint:        s->Printf("%i", m_data.sint);               break;
 218     case e_uint:        s->Printf("0x%8.8x", m_data.uint);          break;
 219     case e_slong:       s->Printf("%li", m_data.slong);             break;
 220     case e_ulong:       s->Printf("0x%8.8lx", m_data.ulong);        break;
 221     case e_slonglong:   s->Printf("%lli", m_data.slonglong);        break;
 222     case e_ulonglong:   s->Printf("0x%16.16llx", m_data.ulonglong); break;
 223     case e_float:       s->Printf("%f", m_data.flt);                break;
 224     case e_double:      s->Printf("%g", m_data.dbl);                break;
 225     case e_long_double: s->Printf("%Lg", m_data.ldbl);              break;
 226     }
 227 }
 228
 229 const char *
 230 Scalar::GetTypeAsCString() const
 231 {
 232     switch (m_type)
 233     {
 234     case e_void:        return "void";
 235     case e_sint:        return "int";
 236     case e_uint:        return "unsigned int";
 237     case e_slong:       return "long";
 238     case e_ulong:       return "unsigned long";
 239     case e_slonglong:   return "long long";
 240     case e_ulonglong:   return "unsigned long long";
 241     case e_float:       return "float";
 242     case e_double:      return "double";
 243     case e_long_double: return "long double";
 244     }
 245     return "<invalid Scalar type>";
 246 }
 247
 248
 249
 250 //----------------------------------------------------------------------
 251 // Scalar copy constructor
 252 //----------------------------------------------------------------------
 253 Scalar&
 254 Scalar::operator=(const Scalar& rhs)
 255 {
 256     if (this != &rhs)
 257     {
 258         m_type = rhs.m_type;
 259         ::memcpy (&m_data, &rhs.m_data, sizeof(m_data));
 260     }
 261     return *this;
 262 }
 263
 264 Scalar&
 265 Scalar::operator= (const int v)
 266 {
 267     m_type = e_sint;
 268     m_data.sint = v;
 269     return *this;
 270 }
 271
 272
 273 Scalar&
 274 Scalar::operator= (unsigned int v)
 275 {
 276     m_type = e_uint;
 277     m_data.uint = v;
 278     return *this;
 279 }
 280
 281 Scalar&
 282 Scalar::operator= (long v)
 283 {
 284     m_type = e_slong;
 285     m_data.slong = v;
 286     return *this;
 287 }
 288
 289 Scalar&
 290 Scalar::operator= (unsigned long v)
 291 {
 292     m_type = e_ulong;
 293     m_data.ulong = v;
 294     return *this;
 295 }
 296
 297 Scalar&
 298 Scalar::operator= (long long v)
 299 {
 300     m_type = e_slonglong;
 301     m_data.slonglong = v;
 302     return *this;
 303 }
 304
 305 Scalar&
 306 Scalar::operator= (unsigned long long v)
 307 {
 308     m_type = e_ulonglong;
 309     m_data.ulonglong = v;
 310     return *this;
 311 }
 312
 313 Scalar&
 314 Scalar::operator= (float v)
 315 {
 316     m_type = e_float;
 317     m_data.flt = v;
 318     return *this;
 319 }
 320
 321 Scalar&
 322 Scalar::operator= (double v)
 323 {
 324     m_type = e_double;
 325     m_data.dbl = v;
 326     return *this;
 327 }
 328
 329 Scalar&
 330 Scalar::operator= (long double v)
 331 {
 332     m_type = e_long_double;
 333     m_data.ldbl = v;
 334     return *this;
 335 }
 336
 337 //----------------------------------------------------------------------
 338 // Destructor
 339 //----------------------------------------------------------------------
 340 Scalar::~Scalar()
 341 {
 342 }
 343
 344 bool
 345 Scalar::Promote(Scalar::Type type)
 346 {
 347     bool success = false;
 348     switch (m_type)
 349     {
 350     case e_void:
 351         break;
 352
 353     case e_sint:
 354         switch (type)
 355         {
 356         case e_void:        break;
 357         case e_sint:        success = true; break;
 358         case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
 359         case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
 360         case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
 361         case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
 362         case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
 363         case e_float:       m_data.flt          = m_data.sint;      success = true; break;
 364         case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
 365         case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
 366         }
 367         break;
 368
 369     case e_uint:
 370         switch (type)
 371         {
 372         case e_void:
 373         case e_sint:        break;
 374         case e_uint:        success = true; break;
 375         case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
 376         case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
 377         case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
 378         case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
 379         case e_float:       m_data.flt          = m_data.uint;      success = true; break;
 380         case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
 381         case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
 382         }
 383         break;
 384
 385     case e_slong:
 386         switch (type)
 387         {
 388         case e_void:
 389         case e_sint:
 390         case e_uint:        break;
 391         case e_slong:       success = true; break;
 392         case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
 393         case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
 394         case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
 395         case e_float:       m_data.flt          = m_data.slong;     success = true; break;
 396         case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
 397         case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
 398         }
 399         break;
 400
 401     case e_ulong:
 402         switch (type)
 403         {
 404         case e_void:
 405         case e_sint:
 406         case e_uint:
 407         case e_slong:       break;
 408         case e_ulong:       success = true; break;
 409         case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
 410         case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
 411         case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
 412         case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
 413         case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
 414         }
 415         break;
 416
 417     case e_slonglong:
 418         switch (type)
 419         {
 420         case e_void:
 421         case e_sint:
 422         case e_uint:
 423         case e_slong:
 424         case e_ulong:       break;
 425         case e_slonglong:   success = true; break;
 426         case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
 427         case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
 428         case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
 429         case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
 430         }
 431         break;
 432
 433     case e_ulonglong:
 434         switch (type)
 435         {
 436         case e_void:
 437         case e_sint:
 438         case e_uint:
 439         case e_slong:
 440         case e_ulong:
 441         case e_slonglong:   break;
 442         case e_ulonglong:   success = true; break;
 443         case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
 444         case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
 445         case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
 446         }
 447         break;
 448
 449     case e_float:
 450         switch (type)
 451         {
 452         case e_void:
 453         case e_sint:
 454         case e_uint:
 455         case e_slong:
 456         case e_ulong:
 457         case e_slonglong:
 458         case e_ulonglong:   break;
 459         case e_float:       success = true; break;
 460         case e_double:      m_data.dbl          = m_data.flt;           success = true; break;
 461         case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
 462         }
 463         break;
 464
 465     case e_double:
 466         switch (type)
 467         {
 468         case e_void:
 469         case e_sint:
 470         case e_uint:
 471         case e_slong:
 472         case e_ulong:
 473         case e_slonglong:
 474         case e_ulonglong:
 475         case e_float:       break;
 476         case e_double:      success = true; break;
 477         case e_long_double: m_data.ldbl         = m_data.dbl;       success = true; break;
 478         }
 479         break;
 480
 481     case e_long_double:
 482         switch (type)
 483         {
 484         case e_void:
 485         case e_sint:
 486         case e_uint:
 487         case e_slong:
 488         case e_ulong:
 489         case e_slonglong:
 490         case e_ulonglong:
 491         case e_float:
 492         case e_double:      break;
 493         case e_long_double: success = true; break;
 494         }
 495         break;
 496     }
 497
 498     if (success)
 499         m_type = type;
 500     return success;
 501 }
 502
 503 const char *
 504 Scalar::GetValueTypeAsCString (Scalar::Type type)
 505 {
 506     switch (type)
 507     {
 508     case e_void:        return "void";
 509     case e_sint:        return "int";
 510     case e_uint:        return "unsigned int";
 511     case e_slong:       return "long";
 512     case e_ulong:       return "unsigned long";
 513     case e_slonglong:   return "long long";
 514     case e_ulonglong:   return "unsigned long long";
 515     case e_float:       return "float";
 516     case e_double:      return "double";
 517     case e_long_double: return "long double";
 518     }
 519     return "???";
 520 }
 521
 522
 523 Scalar::Type
 524 Scalar::GetValueTypeForSignedIntegerWithByteSize (size_t byte_size)
 525 {
 526     if (byte_size <= sizeof(sint_t))
 527         return e_sint;
 528     if (byte_size <= sizeof(slong_t))
 529         return e_slong;
 530     if (byte_size <= sizeof(slonglong_t))
 531         return e_slonglong;
 532     return e_void;
 533 }
 534
 535 Scalar::Type
 536 Scalar::GetValueTypeForUnsignedIntegerWithByteSize (size_t byte_size)
 537 {
 538     if (byte_size <= sizeof(uint_t))
 539         return e_uint;
 540     if (byte_size <= sizeof(ulong_t))
 541         return e_ulong;
 542     if (byte_size <= sizeof(ulonglong_t))
 543         return e_ulonglong;
 544     return e_void;
 545 }
 546
 547 Scalar::Type
 548 Scalar::GetValueTypeForFloatWithByteSize (size_t byte_size)
 549 {
 550     if (byte_size == sizeof(float_t))
 551         return e_float;
 552     if (byte_size == sizeof(double_t))
 553         return e_double;
 554     if (byte_size == sizeof(long_double_t))
 555         return e_long_double;
 556     return e_void;
 557 }
 558
 559 bool
 560 Scalar::Cast(Scalar::Type type)
 561 {
 562     bool success = false;
 563     switch (m_type)
 564     {
 565     case e_void:
 566         break;
 567
 568     case e_sint:
 569         switch (type)
 570         {
 571         case e_void:        break;
 572         case e_sint:        success = true; break;
 573         case e_uint:        m_data.uint         = m_data.sint;      success = true; break;
 574         case e_slong:       m_data.slong        = m_data.sint;      success = true; break;
 575         case e_ulong:       m_data.ulong        = m_data.sint;      success = true; break;
 576         case e_slonglong:   m_data.slonglong    = m_data.sint;      success = true; break;
 577         case e_ulonglong:   m_data.ulonglong    = m_data.sint;      success = true; break;
 578         case e_float:       m_data.flt          = m_data.sint;      success = true; break;
 579         case e_double:      m_data.dbl          = m_data.sint;      success = true; break;
 580         case e_long_double: m_data.ldbl         = m_data.sint;      success = true; break;
 581         }
 582         break;
 583
 584     case e_uint:
 585         switch (type)
 586         {
 587         case e_void:
 588         case e_sint:        m_data.sint         = m_data.uint;      success = true; break;
 589         case e_uint:        success = true; break;
 590         case e_slong:       m_data.slong        = m_data.uint;      success = true; break;
 591         case e_ulong:       m_data.ulong        = m_data.uint;      success = true; break;
 592         case e_slonglong:   m_data.slonglong    = m_data.uint;      success = true; break;
 593         case e_ulonglong:   m_data.ulonglong    = m_data.uint;      success = true; break;
 594         case e_float:       m_data.flt          = m_data.uint;      success = true; break;
 595         case e_double:      m_data.dbl          = m_data.uint;      success = true; break;
 596         case e_long_double: m_data.ldbl         = m_data.uint;      success = true; break;
 597         }
 598         break;
 599
 600     case e_slong:
 601         switch (type)
 602         {
 603         case e_void:
 604         case e_sint:        m_data.sint         = (sint_t)m_data.slong;     success = true; break;
 605         case e_uint:        m_data.uint         = (uint_t)m_data.slong;     success = true; break;
 606         case e_slong:       success = true; break;
 607         case e_ulong:       m_data.ulong        = m_data.slong;     success = true; break;
 608         case e_slonglong:   m_data.slonglong    = m_data.slong;     success = true; break;
 609         case e_ulonglong:   m_data.ulonglong    = m_data.slong;     success = true; break;
 610         case e_float:       m_data.flt          = m_data.slong;     success = true; break;
 611         case e_double:      m_data.dbl          = m_data.slong;     success = true; break;
 612         case e_long_double: m_data.ldbl         = m_data.slong;     success = true; break;
 613         }
 614         break;
 615
 616     case e_ulong:
 617         switch (type)
 618         {
 619         case e_void:
 620         case e_sint:        m_data.sint         = (sint_t)m_data.ulong;     success = true; break;
 621         case e_uint:        m_data.uint         = (uint_t)m_data.ulong;     success = true; break;
 622         case e_slong:       m_data.slong        = m_data.ulong;     success = true; break;
 623         case e_ulong:       success = true; break;
 624         case e_slonglong:   m_data.slonglong    = m_data.ulong;     success = true; break;
 625         case e_ulonglong:   m_data.ulonglong    = m_data.ulong;     success = true; break;
 626         case e_float:       m_data.flt          = m_data.ulong;     success = true; break;
 627         case e_double:      m_data.dbl          = m_data.ulong;     success = true; break;
 628         case e_long_double: m_data.ldbl         = m_data.ulong;     success = true; break;
 629         }
 630         break;
 631
 632     case e_slonglong:
 633         switch (type)
 634         {
 635         case e_void:
 636         case e_sint:        m_data.sint         = (sint_t)m_data.slonglong;     success = true; break;
 637         case e_uint:        m_data.uint         = (uint_t)m_data.slonglong;     success = true; break;
 638         case e_slong:       m_data.slong        = m_data.slonglong;     success = true; break;
 639         case e_ulong:       m_data.ulong        = m_data.slonglong;     success = true; break;
 640         case e_slonglong:   success = true; break;
 641         case e_ulonglong:   m_data.ulonglong    = m_data.slonglong;     success = true; break;
 642         case e_float:       m_data.flt          = m_data.slonglong;     success = true; break;
 643         case e_double:      m_data.dbl          = m_data.slonglong;     success = true; break;
 644         case e_long_double: m_data.ldbl         = m_data.slonglong;     success = true; break;
 645         }
 646         break;
 647
 648     case e_ulonglong:
 649         switch (type)
 650         {
 651         case e_void:
 652         case e_sint:        m_data.sint         = (sint_t)m_data.ulonglong;     success = true; break;
 653         case e_uint:        m_data.uint         = (uint_t)m_data.ulonglong;     success = true; break;
 654         case e_slong:       m_data.slong        = m_data.ulonglong;     success = true; break;
 655         case e_ulong:       m_data.ulong        = m_data.ulonglong;     success = true; break;
 656         case e_slonglong:   m_data.slonglong    = m_data.ulonglong;     success = true; break;
 657         case e_ulonglong:   success = true; break;
 658         case e_float:       m_data.flt          = m_data.ulonglong;     success = true; break;
 659         case e_double:      m_data.dbl          = m_data.ulonglong;     success = true; break;
 660         case e_long_double: m_data.ldbl         = m_data.ulonglong;     success = true; break;
 661         }
 662         break;
 663
 664     case e_float:
 665         switch (type)
 666         {
 667         case e_void:
 668         case e_sint:        m_data.sint         = (sint_t)m_data.flt;       success = true; break;
 669         case e_uint:        m_data.uint         = (uint_t)m_data.flt;       success = true; break;
 670         case e_slong:       m_data.slong        = (slong_t)m_data.flt;      success = true; break;
 671         case e_ulong:       m_data.ulong        = (ulong_t)m_data.flt;      success = true; break;
 672         case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.flt;  success = true; break;
 673         case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.flt;  success = true; break;
 674         case e_float:       success = true; break;
 675         case e_double:      m_data.dbl          = m_data.flt;               success = true; break;
 676         case e_long_double: m_data.ldbl         = m_data.flt;               success = true; break;
 677         }
 678         break;
 679
 680     case e_double:
 681         switch (type)
 682         {
 683         case e_void:
 684         case e_sint:        m_data.sint         = (sint_t)m_data.dbl;       success = true; break;
 685         case e_uint:        m_data.uint         = (uint_t)m_data.dbl;       success = true; break;
 686         case e_slong:       m_data.slong        = (slong_t)m_data.dbl;      success = true; break;
 687         case e_ulong:       m_data.ulong        = (ulong_t)m_data.dbl;      success = true; break;
 688         case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.dbl;  success = true; break;
 689         case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.dbl;  success = true; break;
 690         case e_float:       m_data.flt          = (float_t)m_data.dbl;      success = true; break;
 691         case e_double:      success = true; break;
 692         case e_long_double: m_data.ldbl         = m_data.dbl;               success = true; break;
 693         }
 694         break;
 695
 696     case e_long_double:
 697         switch (type)
 698         {
 699         case e_void:
 700         case e_sint:        m_data.sint         = (sint_t)m_data.ldbl;      success = true; break;
 701         case e_uint:        m_data.uint         = (uint_t)m_data.ldbl;      success = true; break;
 702         case e_slong:       m_data.slong        = (slong_t)m_data.ldbl;     success = true; break;
 703         case e_ulong:       m_data.ulong        = (ulong_t)m_data.ldbl;     success = true; break;
 704         case e_slonglong:   m_data.slonglong    = (slonglong_t)m_data.ldbl; success = true; break;
 705         case e_ulonglong:   m_data.ulonglong    = (ulonglong_t)m_data.ldbl; success = true; break;
 706         case e_float:       m_data.flt          = (float_t)m_data.ldbl;     success = true; break;
 707         case e_double:      m_data.dbl          = (double_t)m_data.ldbl;    success = true; break;
 708         case e_long_double: success = true; break;
 709         }
 710         break;
 711     }
 712
 713     if (success)
 714         m_type = type;
 715     return success;
 716 }
 717
 718 bool
 719 Scalar::MakeSigned ()
 720 {
 721     bool success = false;
 722
 723     switch (m_type)
 724     {
 725     case e_void:                                break;
 726     case e_sint:                                success = true; break;
 727     case e_uint:        m_type = e_sint;        success = true; break;
 728     case e_slong:                               success = true; break;
 729     case e_ulong:       m_type = e_slong;       success = true; break;
 730     case e_slonglong:                           success = true; break;
 731     case e_ulonglong:   m_type = e_slonglong;   success = true; break;
 732     case e_float:                               success = true; break;
 733     case e_double:                              success = true; break;
 734     case e_long_double:                         success = true; break;
 735     }
 736
 737     return success;
 738 }
 739
 740 int
 741 Scalar::SInt(int fail_value) const
 742 {
 743     switch (m_type)
 744     {
 745     case e_void:        break;
 746     case e_sint:        return m_data.sint;
 747     case e_uint:        return (int)m_data.uint;
 748     case e_slong:       return (int)m_data.slong;
 749     case e_ulong:       return (int)m_data.ulong;
 750     case e_slonglong:   return (int)m_data.slonglong;
 751     case e_ulonglong:   return (int)m_data.ulonglong;
 752     case e_float:       return (int)m_data.flt;
 753     case e_double:      return (int)m_data.dbl;
 754     case e_long_double: return (int)m_data.ldbl;
 755     }
 756     return fail_value;
 757 }
 758
 759 unsigned int
 760 Scalar::UInt(unsigned int fail_value) const
 761 {
 762     switch (m_type)
 763     {
 764     case e_void:        break;
 765     case e_sint:        return (unsigned int)m_data.sint;
 766     case e_uint:        return (unsigned int)m_data.uint;
 767     case e_slong:       return (unsigned int)m_data.slong;
 768     case e_ulong:       return (unsigned int)m_data.ulong;
 769     case e_slonglong:   return (unsigned int)m_data.slonglong;
 770     case e_ulonglong:   return (unsigned int)m_data.ulonglong;
 771     case e_float:       return (unsigned int)m_data.flt;
 772     case e_double:      return (unsigned int)m_data.dbl;
 773     case e_long_double: return (unsigned int)m_data.ldbl;
 774     }
 775     return fail_value;
 776 }
 777
 778
 779 long
 780 Scalar::SLong(long fail_value) const
 781 {
 782     switch (m_type)
 783     {
 784     case e_void:        break;
 785     case e_sint:        return (long)m_data.sint;
 786     case e_uint:        return (long)m_data.uint;
 787     case e_slong:       return (long)m_data.slong;
 788     case e_ulong:       return (long)m_data.ulong;
 789     case e_slonglong:   return (long)m_data.slonglong;
 790     case e_ulonglong:   return (long)m_data.ulonglong;
 791     case e_float:       return (long)m_data.flt;
 792     case e_double:      return (long)m_data.dbl;
 793     case e_long_double: return (long)m_data.ldbl;
 794     }
 795     return fail_value;
 796 }
 797
 798
 799
 800 unsigned long
 801 Scalar::ULong(unsigned long fail_value) const
 802 {
 803     switch (m_type)
 804     {
 805     case e_void:        break;
 806     case e_sint:        return (unsigned long)m_data.sint;
 807     case e_uint:        return (unsigned long)m_data.uint;
 808     case e_slong:       return (unsigned long)m_data.slong;
 809     case e_ulong:       return (unsigned long)m_data.ulong;
 810     case e_slonglong:   return (unsigned long)m_data.slonglong;
 811     case e_ulonglong:   return (unsigned long)m_data.ulonglong;
 812     case e_float:       return (unsigned long)m_data.flt;
 813     case e_double:      return (unsigned long)m_data.dbl;
 814     case e_long_double: return (unsigned long)m_data.ldbl;
 815     }
 816     return fail_value;
 817 }
 818
 819 uint64_t
 820 Scalar::GetRawBits64(uint64_t fail_value) const
 821 {
 822     switch (m_type)
 823     {
 824     case e_void:
 825         break;
 826
 827     case e_sint:
 828     case e_uint:
 829         return m_data.uint;
 830
 831     case e_slong:
 832     case e_ulong:
 833         return m_data.ulong;
 834
 835     case e_slonglong:
 836     case e_ulonglong:
 837         return m_data.ulonglong;
 838
 839     case e_float:
 840         if (sizeof(m_data.flt) == sizeof(m_data.uint))
 841             return m_data.uint;
 842         else if (sizeof(m_data.flt) == sizeof(m_data.ulong))
 843             return m_data.ulong;
 844         else if (sizeof(m_data.flt) == sizeof(m_data.ulonglong))
 845             return m_data.ulonglong;
 846         break;
 847
 848     case e_double:
 849         if (sizeof(m_data.dbl) == sizeof(m_data.uint))
 850             return m_data.uint;
 851         else if (sizeof(m_data.dbl) == sizeof(m_data.ulong))
 852             return m_data.ulong;
 853         else if (sizeof(m_data.dbl) == sizeof(m_data.ulonglong))
 854             return m_data.ulonglong;
 855         break;
 856
 857     case e_long_double:
 858         if (sizeof(m_data.ldbl) == sizeof(m_data.uint))
 859             return m_data.uint;
 860         else if (sizeof(m_data.ldbl) == sizeof(m_data.ulong))
 861             return m_data.ulong;
 862         else if (sizeof(m_data.ldbl) == sizeof(m_data.ulonglong))
 863             return m_data.ulonglong;
 864         break;
 865     }
 866     return fail_value;
 867 }
 868
 869
 870
 871 long long
 872 Scalar::SLongLong(long long fail_value) const
 873 {
 874     switch (m_type)
 875     {
 876     case e_void:        break;
 877     case e_sint:        return (long long)m_data.sint;
 878     case e_uint:        return (long long)m_data.uint;
 879     case e_slong:       return (long long)m_data.slong;
 880     case e_ulong:       return (long long)m_data.ulong;
 881     case e_slonglong:   return (long long)m_data.slonglong;
 882     case e_ulonglong:   return (long long)m_data.ulonglong;
 883     case e_float:       return (long long)m_data.flt;
 884     case e_double:      return (long long)m_data.dbl;
 885     case e_long_double: return (long long)m_data.ldbl;
 886     }
 887     return fail_value;
 888 }
 889
 890
 891 unsigned long long
 892 Scalar::ULongLong(unsigned long long fail_value) const
 893 {
 894     switch (m_type)
 895     {
 896     case e_void:        break;
 897     case e_sint:        return (unsigned long long)m_data.sint;
 898     case e_uint:        return (unsigned long long)m_data.uint;
 899     case e_slong:       return (unsigned long long)m_data.slong;
 900     case e_ulong:       return (unsigned long long)m_data.ulong;
 901     case e_slonglong:   return (unsigned long long)m_data.slonglong;
 902     case e_ulonglong:   return (unsigned long long)m_data.ulonglong;
 903     case e_float:       return (unsigned long long)m_data.flt;
 904     case e_double:      return (unsigned long long)m_data.dbl;
 905     case e_long_double: return (unsigned long long)m_data.ldbl;
 906     }
 907     return fail_value;
 908 }
 909
 910
 911 float
 912 Scalar::Float(float fail_value) const
 913 {
 914     switch (m_type)
 915     {
 916     case e_void:        break;
 917     case e_sint:        return (float)m_data.sint;
 918     case e_uint:        return (float)m_data.uint;
 919     case e_slong:       return (float)m_data.slong;
 920     case e_ulong:       return (float)m_data.ulong;
 921     case e_slonglong:   return (float)m_data.slonglong;
 922     case e_ulonglong:   return (float)m_data.ulonglong;
 923     case e_float:       return (float)m_data.flt;
 924     case e_double:      return (float)m_data.dbl;
 925     case e_long_double: return (float)m_data.ldbl;
 926     }
 927     return fail_value;
 928 }
 929
 930
 931 double
 932 Scalar::Double(double fail_value) const
 933 {
 934     switch (m_type)
 935     {
 936     case e_void:        break;
 937     case e_sint:        return (double)m_data.sint;
 938     case e_uint:        return (double)m_data.uint;
 939     case e_slong:       return (double)m_data.slong;
 940     case e_ulong:       return (double)m_data.ulong;
 941     case e_slonglong:   return (double)m_data.slonglong;
 942     case e_ulonglong:   return (double)m_data.ulonglong;
 943     case e_float:       return (double)m_data.flt;
 944     case e_double:      return (double)m_data.dbl;
 945     case e_long_double: return (double)m_data.ldbl;
 946     }
 947     return fail_value;
 948 }
 949
 950
 951 long double
 952 Scalar::LongDouble(long double fail_value) const
 953 {
 954     switch (m_type)
 955     {
 956     case e_void:        break;
 957     case e_sint:        return (long double)m_data.sint;
 958     case e_uint:        return (long double)m_data.uint;
 959     case e_slong:       return (long double)m_data.slong;
 960     case e_ulong:       return (long double)m_data.ulong;
 961     case e_slonglong:   return (long double)m_data.slonglong;
 962     case e_ulonglong:   return (long double)m_data.ulonglong;
 963     case e_float:       return (long double)m_data.flt;
 964     case e_double:      return (long double)m_data.dbl;
 965     case e_long_double: return (long double)m_data.ldbl;
 966     }
 967     return fail_value;
 968 }
 969
 970
 971 Scalar&
 972 Scalar::operator+= (const Scalar& rhs)
 973 {
 974     Scalar temp_value;
 975     const Scalar* a;
 976     const Scalar* b;
 977     if ((m_type = PromoteToMaxType(*this, rhs, temp_value, a, b)) != Scalar::e_void)
 978     {
 979         switch (m_type)
 980         {
 981         case e_void:        break;
 982         case e_sint:        m_data.sint         = a->m_data.sint        + b->m_data.sint;       break;
 983         case e_uint:        m_data.uint         = a->m_data.uint        + b->m_data.uint;       break;
 984         case e_slong:       m_data.slong        = a->m_data.slong       + b->m_data.slong;      break;
 985         case e_ulong:       m_data.ulong        = a->m_data.ulong       + b->m_data.ulong;      break;
 986         case e_slonglong:   m_data.slonglong    = a->m_data.slonglong   + b->m_data.slonglong;  break;
 987         case e_ulonglong:   m_data.ulonglong    = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
 988         case e_float:       m_data.flt          = a->m_data.flt         + b->m_data.flt;        break;
 989         case e_double:      m_data.dbl          = a->m_data.dbl         + b->m_data.dbl;        break;
 990         case e_long_double: m_data.ldbl         = a->m_data.ldbl        + b->m_data.ldbl;       break;
 991         }
 992     }
 993     return *this;
 994 }
 995
 996 Scalar&
 997 Scalar::operator<<= (const Scalar& rhs)
 998 {
 999     switch (m_type)
1000     {
1001     case e_void:
1002     case e_float:
1003     case e_double:
1004     case e_long_double:
1005         m_type = e_void;
1006         break;
1007
1008     case e_sint:
1009         switch (rhs.m_type)
1010         {
1011         case e_void:
1012         case e_float:
1013         case e_double:
1014         case e_long_double:
1015             m_type = e_void;
1016             break;
1017         case e_sint:            m_data.sint <<= rhs.m_data.sint;        break;
1018         case e_uint:            m_data.sint <<= rhs.m_data.uint;        break;
1019         case e_slong:           m_data.sint <<= rhs.m_data.slong;       break;
1020         case e_ulong:           m_data.sint <<= rhs.m_data.ulong;       break;
1021         case e_slonglong:       m_data.sint <<= rhs.m_data.slonglong;   break;
1022         case e_ulonglong:       m_data.sint <<= rhs.m_data.ulonglong;   break;
1023         }
1024         break;
1025
1026     case e_uint:
1027         switch (rhs.m_type)
1028         {
1029         case e_void:
1030         case e_float:
1031         case e_double:
1032         case e_long_double:
1033             m_type = e_void;
1034             break;
1035         case e_sint:            m_data.uint <<= rhs.m_data.sint;        break;
1036         case e_uint:            m_data.uint <<= rhs.m_data.uint;        break;
1037         case e_slong:           m_data.uint <<= rhs.m_data.slong;       break;
1038         case e_ulong:           m_data.uint <<= rhs.m_data.ulong;       break;
1039         case e_slonglong:       m_data.uint <<= rhs.m_data.slonglong;   break;
1040         case e_ulonglong:       m_data.uint <<= rhs.m_data.ulonglong;   break;
1041         }
1042         break;
1043
1044     case e_slong:
1045         switch (rhs.m_type)
1046         {
1047         case e_void:
1048         case e_float:
1049         case e_double:
1050         case e_long_double:
1051             m_type = e_void;
1052             break;
1053         case e_sint:            m_data.slong <<= rhs.m_data.sint;       break;
1054         case e_uint:            m_data.slong <<= rhs.m_data.uint;       break;
1055         case e_slong:           m_data.slong <<= rhs.m_data.slong;      break;
1056         case e_ulong:           m_data.slong <<= rhs.m_data.ulong;      break;
1057         case e_slonglong:       m_data.slong <<= rhs.m_data.slonglong;  break;
1058         case e_ulonglong:       m_data.slong <<= rhs.m_data.ulonglong;  break;
1059         }
1060         break;
1061
1062     case e_ulong:
1063         switch (rhs.m_type)
1064         {
1065         case e_void:
1066         case e_float:
1067         case e_double:
1068         case e_long_double:
1069             m_type = e_void;
1070             break;
1071         case e_sint:            m_data.ulong <<= rhs.m_data.sint;       break;
1072         case e_uint:            m_data.ulong <<= rhs.m_data.uint;       break;
1073         case e_slong:           m_data.ulong <<= rhs.m_data.slong;      break;
1074         case e_ulong:           m_data.ulong <<= rhs.m_data.ulong;      break;
1075         case e_slonglong:       m_data.ulong <<= rhs.m_data.slonglong;  break;
1076         case e_ulonglong:       m_data.ulong <<= rhs.m_data.ulonglong;  break;
1077         }
1078         break;
1079     case e_slonglong:
1080         switch (rhs.m_type)
1081         {
1082         case e_void:
1083         case e_float:
1084         case e_double:
1085         case e_long_double:
1086             m_type = e_void;
1087             break;
1088         case e_sint:            m_data.slonglong <<= rhs.m_data.sint;       break;
1089         case e_uint:            m_data.slonglong <<= rhs.m_data.uint;       break;
1090         case e_slong:           m_data.slonglong <<= rhs.m_data.slong;      break;
1091         case e_ulong:           m_data.slonglong <<= rhs.m_data.ulong;      break;
1092         case e_slonglong:       m_data.slonglong <<= rhs.m_data.slonglong;  break;
1093         case e_ulonglong:       m_data.slonglong <<= rhs.m_data.ulonglong;  break;
1094         }
1095         break;
1096
1097     case e_ulonglong:
1098         switch (rhs.m_type)
1099         {
1100         case e_void:
1101         case e_float:
1102         case e_double:
1103         case e_long_double:
1104             m_type = e_void;
1105             break;
1106         case e_sint:            m_data.ulonglong <<= rhs.m_data.sint;       break;
1107         case e_uint:            m_data.ulonglong <<= rhs.m_data.uint;       break;
1108         case e_slong:           m_data.ulonglong <<= rhs.m_data.slong;      break;
1109         case e_ulong:           m_data.ulonglong <<= rhs.m_data.ulong;      break;
1110         case e_slonglong:       m_data.ulonglong <<= rhs.m_data.slonglong;  break;
1111         case e_ulonglong:       m_data.ulonglong <<= rhs.m_data.ulonglong;  break;
1112         }
1113         break;
1114     }
1115     return *this;
1116 }
1117
1118 bool
1119 Scalar::ShiftRightLogical(const Scalar& rhs)
1120 {
1121     switch (m_type)
1122     {
1123     case e_void:
1124     case e_float:
1125     case e_double:
1126     case e_long_double:
1127         m_type = e_void;
1128         break;
1129
1130     case e_sint:
1131     case e_uint:
1132         switch (rhs.m_type)
1133         {
1134         case e_void:
1135         case e_float:
1136         case e_double:
1137         case e_long_double:
1138             m_type = e_void;
1139             break;
1140         case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
1141         case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
1142         case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
1143         case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
1144         case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
1145         case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
1146         }
1147         break;
1148
1149     case e_slong:
1150     case e_ulong:
1151         switch (rhs.m_type)
1152         {
1153         case e_void:
1154         case e_float:
1155         case e_double:
1156         case e_long_double:
1157             m_type = e_void;
1158             break;
1159         case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
1160         case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
1161         case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
1162         case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
1163         case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
1164         case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
1165         }
1166         break;
1167
1168     case e_slonglong:
1169     case e_ulonglong:
1170         switch (rhs.m_type)
1171         {
1172         case e_void:
1173         case e_float:
1174         case e_double:
1175         case e_long_double:
1176             m_type = e_void;
1177             break;
1178         case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
1179         case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
1180         case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
1181         case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
1182         case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
1183         case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
1184         }
1185         break;
1186     }
1187     return m_type != e_void;
1188 }
1189
1190
1191 Scalar&
1192 Scalar::operator>>= (const Scalar& rhs)
1193 {
1194     switch (m_type)
1195     {
1196     case e_void:
1197     case e_float:
1198     case e_double:
1199     case e_long_double:
1200         m_type = e_void;
1201         break;
1202
1203     case e_sint:
1204         switch (rhs.m_type)
1205         {
1206         case e_void:
1207         case e_float:
1208         case e_double:
1209         case e_long_double:
1210             m_type = e_void;
1211             break;
1212         case e_sint:            m_data.sint >>= rhs.m_data.sint;        break;
1213         case e_uint:            m_data.sint >>= rhs.m_data.uint;        break;
1214         case e_slong:           m_data.sint >>= rhs.m_data.slong;       break;
1215         case e_ulong:           m_data.sint >>= rhs.m_data.ulong;       break;
1216         case e_slonglong:       m_data.sint >>= rhs.m_data.slonglong;   break;
1217         case e_ulonglong:       m_data.sint >>= rhs.m_data.ulonglong;   break;
1218         }
1219         break;
1220
1221     case e_uint:
1222         switch (rhs.m_type)
1223         {
1224         case e_void:
1225         case e_float:
1226         case e_double:
1227         case e_long_double:
1228             m_type = e_void;
1229             break;
1230         case e_sint:            m_data.uint >>= rhs.m_data.sint;        break;
1231         case e_uint:            m_data.uint >>= rhs.m_data.uint;        break;
1232         case e_slong:           m_data.uint >>= rhs.m_data.slong;       break;
1233         case e_ulong:           m_data.uint >>= rhs.m_data.ulong;       break;
1234         case e_slonglong:       m_data.uint >>= rhs.m_data.slonglong;   break;
1235         case e_ulonglong:       m_data.uint >>= rhs.m_data.ulonglong;   break;
1236         }
1237         break;
1238
1239     case e_slong:
1240         switch (rhs.m_type)
1241         {
1242         case e_void:
1243         case e_float:
1244         case e_double:
1245         case e_long_double:
1246             m_type = e_void;
1247             break;
1248         case e_sint:            m_data.slong >>= rhs.m_data.sint;       break;
1249         case e_uint:            m_data.slong >>= rhs.m_data.uint;       break;
1250         case e_slong:           m_data.slong >>= rhs.m_data.slong;      break;
1251         case e_ulong:           m_data.slong >>= rhs.m_data.ulong;      break;
1252         case e_slonglong:       m_data.slong >>= rhs.m_data.slonglong;  break;
1253         case e_ulonglong:       m_data.slong >>= rhs.m_data.ulonglong;  break;
1254         }
1255         break;
1256
1257     case e_ulong:
1258         switch (rhs.m_type)
1259         {
1260         case e_void:
1261         case e_float:
1262         case e_double:
1263         case e_long_double:
1264             m_type = e_void;
1265             break;
1266         case e_sint:            m_data.ulong >>= rhs.m_data.sint;       break;
1267         case e_uint:            m_data.ulong >>= rhs.m_data.uint;       break;
1268         case e_slong:           m_data.ulong >>= rhs.m_data.slong;      break;
1269         case e_ulong:           m_data.ulong >>= rhs.m_data.ulong;      break;
1270         case e_slonglong:       m_data.ulong >>= rhs.m_data.slonglong;  break;
1271         case e_ulonglong:       m_data.ulong >>= rhs.m_data.ulonglong;  break;
1272         }
1273         break;
1274     case e_slonglong:
1275         switch (rhs.m_type)
1276         {
1277         case e_void:
1278         case e_float:
1279         case e_double:
1280         case e_long_double:
1281             m_type = e_void;
1282             break;
1283         case e_sint:            m_data.slonglong >>= rhs.m_data.sint;       break;
1284         case e_uint:            m_data.slonglong >>= rhs.m_data.uint;       break;
1285         case e_slong:           m_data.slonglong >>= rhs.m_data.slong;      break;
1286         case e_ulong:           m_data.slonglong >>= rhs.m_data.ulong;      break;
1287         case e_slonglong:       m_data.slonglong >>= rhs.m_data.slonglong;  break;
1288         case e_ulonglong:       m_data.slonglong >>= rhs.m_data.ulonglong;  break;
1289         }
1290         break;
1291
1292     case e_ulonglong:
1293         switch (rhs.m_type)
1294         {
1295         case e_void:
1296         case e_float:
1297         case e_double:
1298         case e_long_double:
1299             m_type = e_void;
1300             break;
1301         case e_sint:            m_data.ulonglong >>= rhs.m_data.sint;       break;
1302         case e_uint:            m_data.ulonglong >>= rhs.m_data.uint;       break;
1303         case e_slong:           m_data.ulonglong >>= rhs.m_data.slong;      break;
1304         case e_ulong:           m_data.ulonglong >>= rhs.m_data.ulong;      break;
1305         case e_slonglong:       m_data.ulonglong >>= rhs.m_data.slonglong;  break;
1306         case e_ulonglong:       m_data.ulonglong >>= rhs.m_data.ulonglong;  break;
1307         }
1308         break;
1309     }
1310     return *this;
1311 }
1312
1313
1314 Scalar&
1315 Scalar::operator&= (const Scalar& rhs)
1316 {
1317     switch (m_type)
1318     {
1319     case e_void:
1320     case e_float:
1321     case e_double:
1322     case e_long_double:
1323         m_type = e_void;
1324         break;
1325
1326     case e_sint:
1327         switch (rhs.m_type)
1328         {
1329         case e_void:
1330         case e_float:
1331         case e_double:
1332         case e_long_double:
1333             m_type = e_void;
1334             break;
1335         case e_sint:            m_data.sint &= rhs.m_data.sint;         break;
1336         case e_uint:            m_data.sint &= rhs.m_data.uint;         break;
1337         case e_slong:           m_data.sint &= rhs.m_data.slong;        break;
1338         case e_ulong:           m_data.sint &= rhs.m_data.ulong;        break;
1339         case e_slonglong:       m_data.sint &= rhs.m_data.slonglong;    break;
1340         case e_ulonglong:       m_data.sint &= rhs.m_data.ulonglong;    break;
1341         }
1342         break;
1343
1344     case e_uint:
1345         switch (rhs.m_type)
1346         {
1347         case e_void:
1348         case e_float:
1349         case e_double:
1350         case e_long_double:
1351             m_type = e_void;
1352             break;
1353         case e_sint:            m_data.uint &= rhs.m_data.sint;         break;
1354         case e_uint:            m_data.uint &= rhs.m_data.uint;         break;
1355         case e_slong:           m_data.uint &= rhs.m_data.slong;        break;
1356         case e_ulong:           m_data.uint &= rhs.m_data.ulong;        break;
1357         case e_slonglong:       m_data.uint &= rhs.m_data.slonglong;    break;
1358         case e_ulonglong:       m_data.uint &= rhs.m_data.ulonglong;    break;
1359         }
1360         break;
1361
1362     case e_slong:
1363         switch (rhs.m_type)
1364         {
1365         case e_void:
1366         case e_float:
1367         case e_double:
1368         case e_long_double:
1369             m_type = e_void;
1370             break;
1371         case e_sint:            m_data.slong &= rhs.m_data.sint;        break;
1372         case e_uint:            m_data.slong &= rhs.m_data.uint;        break;
1373         case e_slong:           m_data.slong &= rhs.m_data.slong;       break;
1374         case e_ulong:           m_data.slong &= rhs.m_data.ulong;       break;
1375         case e_slonglong:       m_data.slong &= rhs.m_data.slonglong;   break;
1376         case e_ulonglong:       m_data.slong &= rhs.m_data.ulonglong;   break;
1377         }
1378         break;
1379
1380     case e_ulong:
1381         switch (rhs.m_type)
1382         {
1383         case e_void:
1384         case e_float:
1385         case e_double:
1386         case e_long_double:
1387             m_type = e_void;
1388             break;
1389         case e_sint:            m_data.ulong &= rhs.m_data.sint;        break;
1390         case e_uint:            m_data.ulong &= rhs.m_data.uint;        break;
1391         case e_slong:           m_data.ulong &= rhs.m_data.slong;       break;
1392         case e_ulong:           m_data.ulong &= rhs.m_data.ulong;       break;
1393         case e_slonglong:       m_data.ulong &= rhs.m_data.slonglong;   break;
1394         case e_ulonglong:       m_data.ulong &= rhs.m_data.ulonglong;   break;
1395         }
1396         break;
1397     case e_slonglong:
1398         switch (rhs.m_type)
1399         {
1400         case e_void:
1401         case e_float:
1402         case e_double:
1403         case e_long_double:
1404             m_type = e_void;
1405             break;
1406         case e_sint:            m_data.slonglong &= rhs.m_data.sint;        break;
1407         case e_uint:            m_data.slonglong &= rhs.m_data.uint;        break;
1408         case e_slong:           m_data.slonglong &= rhs.m_data.slong;       break;
1409         case e_ulong:           m_data.slonglong &= rhs.m_data.ulong;       break;
1410         case e_slonglong:       m_data.slonglong &= rhs.m_data.slonglong;   break;
1411         case e_ulonglong:       m_data.slonglong &= rhs.m_data.ulonglong;   break;
1412         }
1413         break;
1414
1415     case e_ulonglong:
1416         switch (rhs.m_type)
1417         {
1418         case e_void:
1419         case e_float:
1420         case e_double:
1421         case e_long_double:
1422             m_type = e_void;
1423             break;
1424         case e_sint:            m_data.ulonglong &= rhs.m_data.sint;        break;
1425         case e_uint:            m_data.ulonglong &= rhs.m_data.uint;        break;
1426         case e_slong:           m_data.ulonglong &= rhs.m_data.slong;       break;
1427         case e_ulong:           m_data.ulonglong &= rhs.m_data.ulong;       break;
1428         case e_slonglong:       m_data.ulonglong &= rhs.m_data.slonglong;   break;
1429         case e_ulonglong:       m_data.ulonglong &= rhs.m_data.ulonglong;   break;
1430         }
1431         break;
1432     }
1433     return *this;
1434 }
1435
1436
1437
1438 bool
1439 Scalar::AbsoluteValue()
1440 {
1441     switch (m_type)
1442     {
1443     case e_void:
1444         break;
1445
1446     case e_sint:
1447         if (m_data.sint < 0)
1448             m_data.sint = -m_data.sint;
1449         return true;
1450
1451     case e_slong:
1452         if (m_data.slong < 0)
1453             m_data.slong = -m_data.slong;
1454         return true;
1455
1456     case e_slonglong:
1457         if (m_data.slonglong < 0)
1458             m_data.slonglong = -m_data.slonglong;
1459         return true;
1460
1461     case e_uint:
1462     case e_ulong:
1463     case e_ulonglong:   return true;
1464     case e_float:       m_data.flt = fabsf(m_data.flt);     return true;
1465     case e_double:      m_data.dbl = fabs(m_data.dbl);      return true;
1466     case e_long_double: m_data.ldbl = fabsl(m_data.ldbl);   return true;
1467     }
1468     return false;
1469 }
1470
1471
1472 bool
1473 Scalar::UnaryNegate()
1474 {
1475     switch (m_type)
1476     {
1477     case e_void:        break;
1478     case e_sint:        m_data.sint = -m_data.sint;             return true;
1479     case e_uint:        m_data.uint = -m_data.uint;             return true;
1480     case e_slong:       m_data.slong = -m_data.slong;           return true;
1481     case e_ulong:       m_data.ulong = -m_data.ulong;           return true;
1482     case e_slonglong:   m_data.slonglong = -m_data.slonglong;   return true;
1483     case e_ulonglong:   m_data.ulonglong = -m_data.ulonglong;   return true;
1484     case e_float:       m_data.flt = -m_data.flt;               return true;
1485     case e_double:      m_data.dbl = -m_data.dbl;               return true;
1486     case e_long_double: m_data.ldbl = -m_data.ldbl;             return true;
1487     }
1488     return false;
1489 }
1490
1491 bool
1492 Scalar::OnesComplement()
1493 {
1494     switch (m_type)
1495     {
1496     case e_sint:        m_data.sint = ~m_data.sint; return true;
1497     case e_uint:        m_data.uint = ~m_data.uint; return true;
1498     case e_slong:       m_data.slong = ~m_data.slong; return true;
1499     case e_ulong:       m_data.ulong = ~m_data.ulong; return true;
1500     case e_slonglong:   m_data.slonglong = ~m_data.slonglong; return true;
1501     case e_ulonglong:   m_data.ulonglong = ~m_data.ulonglong; return true;
1502
1503     case e_void:
1504     case e_float:
1505     case e_double:
1506     case e_long_double:
1507         break;
1508     }
1509     return false;
1510 }
1511
1512
1513 const Scalar
1514 lldb_private::operator+ (const Scalar& lhs, const Scalar& rhs)
1515 {
1516     Scalar result;
1517     Scalar temp_value;
1518     const Scalar* a;
1519     const Scalar* b;
1520     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1521     {
1522         switch (result.m_type)
1523         {
1524         case Scalar::e_void:            break;
1525         case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        + b->m_data.sint;       break;
1526         case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        + b->m_data.uint;       break;
1527         case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       + b->m_data.slong;      break;
1528         case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       + b->m_data.ulong;      break;
1529         case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   + b->m_data.slonglong;  break;
1530         case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   + b->m_data.ulonglong;  break;
1531         case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         + b->m_data.flt;        break;
1532         case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         + b->m_data.dbl;        break;
1533         case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        + b->m_data.ldbl;       break;
1534         }
1535     }
1536     return result;
1537 }
1538
1539
1540 const Scalar
1541 lldb_private::operator- (const Scalar& lhs, const Scalar& rhs)
1542 {
1543     Scalar result;
1544     Scalar temp_value;
1545     const Scalar* a;
1546     const Scalar* b;
1547     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1548     {
1549         switch (result.m_type)
1550         {
1551         case Scalar::e_void:            break;
1552         case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        - b->m_data.sint;       break;
1553         case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        - b->m_data.uint;       break;
1554         case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       - b->m_data.slong;      break;
1555         case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       - b->m_data.ulong;      break;
1556         case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   - b->m_data.slonglong;  break;
1557         case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   - b->m_data.ulonglong;  break;
1558         case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         - b->m_data.flt;        break;
1559         case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         - b->m_data.dbl;        break;
1560         case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        - b->m_data.ldbl;       break;
1561         }
1562     }
1563     return result;
1564 }
1565
1566 const Scalar
1567 lldb_private::operator/ (const Scalar& lhs, const Scalar& rhs)
1568 {
1569     Scalar result;
1570     Scalar temp_value;
1571     const Scalar* a;
1572     const Scalar* b;
1573     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1574     {
1575         switch (result.m_type)
1576         {
1577         case Scalar::e_void:            break;
1578
1579         case Scalar::e_sint:            if (b->m_data.sint != 0)        { result.m_data.sint = a->m_data.sint/ b->m_data.sint; return result; } break;
1580         case Scalar::e_uint:            if (b->m_data.uint != 0)        { result.m_data.uint = a->m_data.uint / b->m_data.uint; return result; } break;
1581         case Scalar::e_slong:           if (b->m_data.slong != 0)       { result.m_data.slong = a->m_data.slong / b->m_data.slong; return result; } break;
1582         case Scalar::e_ulong:           if (b->m_data.ulong != 0)       { result.m_data.ulong = a->m_data.ulong / b->m_data.ulong; return result; } break;
1583         case Scalar::e_slonglong:       if (b->m_data.slonglong != 0)   { result.m_data.slonglong = a->m_data.slonglong / b->m_data.slonglong; return result; } break;
1584         case Scalar::e_ulonglong:       if (b->m_data.ulonglong != 0)   { result.m_data.ulonglong = a->m_data.ulonglong / b->m_data.ulonglong; return result; } break;
1585         case Scalar::e_float:           if (b->m_data.flt != 0.0f)      { result.m_data.flt = a->m_data.flt / b->m_data.flt; return result; } break;
1586         case Scalar::e_double:      if (b->m_data.dbl != 0.0)       { result.m_data.dbl = a->m_data.dbl / b->m_data.dbl; return result; } break;
1587         case Scalar::e_long_double: if (b->m_data.ldbl != 0.0)      { result.m_data.ldbl = a->m_data.ldbl / b->m_data.ldbl; return result; } break;
1588         }
1589     }
1590     // For division only, the only way it should make it here is if a promotion failed,
1591     // or if we are trying to do a divide by zero.
1592     result.m_type = Scalar::e_void;
1593     return result;
1594 }
1595
1596 const Scalar
1597 lldb_private::operator* (const Scalar& lhs, const Scalar& rhs)
1598 {
1599     Scalar result;
1600     Scalar temp_value;
1601     const Scalar* a;
1602     const Scalar* b;
1603     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1604     {
1605         switch (result.m_type)
1606         {
1607         case Scalar::e_void:            break;
1608         case Scalar::e_sint:            result.m_data.sint      = a->m_data.sint        * b->m_data.sint;       break;
1609         case Scalar::e_uint:            result.m_data.uint      = a->m_data.uint        * b->m_data.uint;       break;
1610         case Scalar::e_slong:           result.m_data.slong     = a->m_data.slong       * b->m_data.slong;      break;
1611         case Scalar::e_ulong:           result.m_data.ulong     = a->m_data.ulong       * b->m_data.ulong;      break;
1612         case Scalar::e_slonglong:       result.m_data.slonglong = a->m_data.slonglong   * b->m_data.slonglong;  break;
1613         case Scalar::e_ulonglong:       result.m_data.ulonglong = a->m_data.ulonglong   * b->m_data.ulonglong;  break;
1614         case Scalar::e_float:           result.m_data.flt       = a->m_data.flt         * b->m_data.flt;        break;
1615         case Scalar::e_double:      result.m_data.dbl       = a->m_data.dbl         * b->m_data.dbl;        break;
1616         case Scalar::e_long_double: result.m_data.ldbl      = a->m_data.ldbl        * b->m_data.ldbl;       break;
1617         }
1618     }
1619     return result;
1620 }
1621
1622 const Scalar
1623 lldb_private::operator& (const Scalar& lhs, const Scalar& rhs)
1624 {
1625     Scalar result;
1626     Scalar temp_value;
1627     const Scalar* a;
1628     const Scalar* b;
1629     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1630     {
1631         switch (result.m_type)
1632         {
1633         case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        & b->m_data.sint;       break;
1634         case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        & b->m_data.uint;       break;
1635         case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       & b->m_data.slong;      break;
1636         case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       & b->m_data.ulong;      break;
1637         case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   & b->m_data.slonglong;  break;
1638         case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   & b->m_data.ulonglong;  break;
1639
1640         case Scalar::e_void:
1641         case Scalar::e_float:
1642         case Scalar::e_double:
1643         case Scalar::e_long_double:
1644             // No bitwise AND on floats, doubles of long doubles
1645             result.m_type = Scalar::e_void;
1646             break;
1647         }
1648     }
1649     return result;
1650 }
1651
1652 const Scalar
1653 lldb_private::operator| (const Scalar& lhs, const Scalar& rhs)
1654 {
1655     Scalar result;
1656     Scalar temp_value;
1657     const Scalar* a;
1658     const Scalar* b;
1659     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1660     {
1661         switch (result.m_type)
1662         {
1663         case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        | b->m_data.sint;       break;
1664         case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        | b->m_data.uint;       break;
1665         case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       | b->m_data.slong;      break;
1666         case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       | b->m_data.ulong;      break;
1667         case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   | b->m_data.slonglong;  break;
1668         case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   | b->m_data.ulonglong;  break;
1669
1670         case Scalar::e_void:
1671         case Scalar::e_float:
1672         case Scalar::e_double:
1673         case Scalar::e_long_double:
1674             // No bitwise AND on floats, doubles of long doubles
1675             result.m_type = Scalar::e_void;
1676             break;
1677         }
1678     }
1679     return result;
1680 }
1681
1682 const Scalar
1683 lldb_private::operator% (const Scalar& lhs, const Scalar& rhs)
1684 {
1685     Scalar result;
1686     Scalar temp_value;
1687     const Scalar* a;
1688     const Scalar* b;
1689     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1690     {
1691         switch (result.m_type)
1692         {
1693         default:                    break;
1694         case Scalar::e_sint:        if (b->m_data.sint != 0)        {   result.m_data.sint      = a->m_data.sint        % b->m_data.sint;       return result;  }   break;
1695         case Scalar::e_uint:        if (b->m_data.uint != 0)        {   result.m_data.uint      = a->m_data.uint        % b->m_data.uint;       return result;  }   break;
1696         case Scalar::e_slong:       if (b->m_data.slong != 0)       {   result.m_data.slong     = a->m_data.slong       % b->m_data.slong;      return result;  }   break;
1697         case Scalar::e_ulong:       if (b->m_data.ulong != 0)       {   result.m_data.ulong     = a->m_data.ulong       % b->m_data.ulong;      return result;  }   break;
1698         case Scalar::e_slonglong:   if (b->m_data.slonglong != 0)   {   result.m_data.slonglong = a->m_data.slonglong   % b->m_data.slonglong;  return result;  }   break;
1699         case Scalar::e_ulonglong:   if (b->m_data.ulonglong != 0)   {   result.m_data.ulonglong = a->m_data.ulonglong   % b->m_data.ulonglong;  return result;  }   break;
1700         }
1701     }
1702     result.m_type = Scalar::e_void;
1703     return result;
1704 }
1705
1706 const Scalar
1707 lldb_private::operator^ (const Scalar& lhs, const Scalar& rhs)
1708 {
1709     Scalar result;
1710     Scalar temp_value;
1711     const Scalar* a;
1712     const Scalar* b;
1713     if ((result.m_type = PromoteToMaxType(lhs, rhs, temp_value, a, b)) != Scalar::e_void)
1714     {
1715         switch (result.m_type)
1716         {
1717         case Scalar::e_sint:        result.m_data.sint      = a->m_data.sint        ^ b->m_data.sint;       break;
1718         case Scalar::e_uint:        result.m_data.uint      = a->m_data.uint        ^ b->m_data.uint;       break;
1719         case Scalar::e_slong:       result.m_data.slong     = a->m_data.slong       ^ b->m_data.slong;      break;
1720         case Scalar::e_ulong:       result.m_data.ulong     = a->m_data.ulong       ^ b->m_data.ulong;      break;
1721         case Scalar::e_slonglong:   result.m_data.slonglong = a->m_data.slonglong   ^ b->m_data.slonglong;  break;
1722         case Scalar::e_ulonglong:   result.m_data.ulonglong = a->m_data.ulonglong   ^ b->m_data.ulonglong;  break;
1723
1724         case Scalar::e_void:
1725         case Scalar::e_float:
1726         case Scalar::e_double:
1727         case Scalar::e_long_double:
1728             // No bitwise AND on floats, doubles of long doubles
1729             result.m_type = Scalar::e_void;
1730             break;
1731         }
1732     }
1733     return result;
1734 }
1735
1736 const Scalar
1737 lldb_private::operator<< (const Scalar& lhs, const Scalar &rhs)
1738 {
1739     Scalar result = lhs;
1740     result <<= rhs;
1741     return result;
1742 }
1743
1744 const Scalar
1745 lldb_private::operator>> (const Scalar& lhs, const Scalar &rhs)
1746 {
1747     Scalar result = lhs;
1748     result >>= rhs;
1749     return result;
1750 }
1751
1752 // Return the raw unsigned integer without any casting or conversion
1753 unsigned int
1754 Scalar::RawUInt () const
1755 {
1756     return m_data.uint;
1757 }
1758
1759 // Return the raw unsigned long without any casting or conversion
1760 unsigned long
1761 Scalar::RawULong () const
1762 {
1763     return m_data.ulong;
1764 }
1765
1766 // Return the raw unsigned long long without any casting or conversion
1767 unsigned long long
1768 Scalar::RawULongLong () const
1769 {
1770     return m_data.ulonglong;
1771 }
1772
1773
1774 Error
1775 Scalar::SetValueFromCString (const char *value_str, Encoding encoding, size_t byte_size)
1776 {
1777     Error error;
1778     if (value_str == NULL || value_str[0] == '\0')
1779     {
1780         error.SetErrorString ("Invalid c-string value string.");
1781         return error;
1782     }
1783     bool success = false;
1784     switch (encoding)
1785     {
1786     case eEncodingInvalid:
1787         error.SetErrorString ("Invalid encoding.");
1788         break;
1789
1790     case eEncodingUint:
1791         if (byte_size <= sizeof (unsigned long long))
1792         {
1793             uint64_t uval64 = Args::StringToUInt64(value_str, UINT64_MAX, 0, &success);
1794             if (!success)
1795                 error.SetErrorStringWithFormat ("'%s' is not a valid unsigned integer string value", value_str);
1796             else if (!UIntValueIsValidForSize (uval64, byte_size))
1797                 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte unsigned integer value", uval64, byte_size);
1798             else
1799             {
1800                 m_type = Scalar::GetValueTypeForUnsignedIntegerWithByteSize (byte_size);
1801                 switch (m_type)
1802                 {
1803                 case e_uint:        m_data.uint = (uint_t)uval64;           break;
1804                 case e_ulong:       m_data.ulong = (ulong_t)uval64;         break;
1805                 case e_ulonglong:   m_data.ulonglong = (ulonglong_t)uval64; break;
1806                 default:
1807                     error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1808                     break;
1809                 }
1810             }
1811         }
1812         else
1813         {
1814             error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1815             return error;
1816         }
1817         break;
1818
1819     case eEncodingSint:
1820         if (byte_size <= sizeof (long long))
1821         {
1822             uint64_t sval64 = Args::StringToSInt64(value_str, INT64_MAX, 0, &success);
1823             if (!success)
1824                 error.SetErrorStringWithFormat ("'%s' is not a valid signed integer string value", value_str);
1825             else if (!SIntValueIsValidForSize (sval64, byte_size))
1826                 error.SetErrorStringWithFormat ("value 0x%" PRIx64 " is too large to fit in a %zu byte signed integer value", sval64, byte_size);
1827             else
1828             {
1829                 m_type = Scalar::GetValueTypeForSignedIntegerWithByteSize (byte_size);
1830                 switch (m_type)
1831                 {
1832                 case e_sint:        m_data.sint = (sint_t)sval64;           break;
1833                 case e_slong:       m_data.slong = (slong_t)sval64;         break;
1834                 case e_slonglong:   m_data.slonglong = (slonglong_t)sval64; break;
1835                 default:
1836                     error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1837                     break;
1838                 }
1839             }
1840         }
1841         else
1842         {
1843             error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1844             return error;
1845         }
1846         break;
1847
1848     case eEncodingIEEE754:
1849         if (byte_size == sizeof (float))
1850         {
1851             if (::sscanf (value_str, "%f", &m_data.flt) == 1)
1852                 m_type = e_float;
1853             else
1854                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1855         }
1856         else if (byte_size == sizeof (double))
1857         {
1858             if (::sscanf (value_str, "%lf", &m_data.dbl) == 1)
1859                 m_type = e_double;
1860             else
1861                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1862         }
1863         else if (byte_size == sizeof (long double))
1864         {
1865             if (::sscanf (value_str, "%Lf", &m_data.ldbl) == 1)
1866                 m_type = e_long_double;
1867             else
1868                 error.SetErrorStringWithFormat ("'%s' is not a valid float string value", value_str);
1869         }
1870         else
1871         {
1872             error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
1873             return error;
1874         }
1875         break;
1876
1877     case eEncodingVector:
1878         error.SetErrorString ("vector encoding unsupported.");
1879         break;
1880     }
1881     if (error.Fail())
1882         m_type = e_void;
1883
1884     return error;
1885 }
1886
1887 Error
1888 Scalar::SetValueFromData (DataExtractor &data, lldb::Encoding encoding, size_t byte_size)
1889 {
1890     Error error;
1891
1892     switch (encoding)
1893     {
1894     case lldb::eEncodingInvalid:
1895         error.SetErrorString ("invalid encoding");
1896         break;
1897     case lldb::eEncodingVector:
1898         error.SetErrorString ("vector encoding unsupported");
1899         break;
1900     case lldb::eEncodingUint:
1901         {
1902             lldb::offset_t offset;
1903
1904             switch (byte_size)
1905             {
1906             case 1: operator=((uint8_t)data.GetU8(&offset)); break;
1907             case 2: operator=((uint16_t)data.GetU16(&offset)); break;
1908             case 4: operator=((uint32_t)data.GetU32(&offset)); break;
1909             case 8: operator=((uint64_t)data.GetU64(&offset)); break;
1910             default:
1911                 error.SetErrorStringWithFormat ("unsupported unsigned integer byte size: %zu", byte_size);
1912                 break;
1913             }
1914         }
1915         break;
1916     case lldb::eEncodingSint:
1917         {
1918             lldb::offset_t offset;
1919
1920             switch (byte_size)
1921             {
1922             case 1: operator=((int8_t)data.GetU8(&offset)); break;
1923             case 2: operator=((int16_t)data.GetU16(&offset)); break;
1924             case 4: operator=((int32_t)data.GetU32(&offset)); break;
1925             case 8: operator=((int64_t)data.GetU64(&offset)); break;
1926             default:
1927                 error.SetErrorStringWithFormat ("unsupported signed integer byte size: %zu", byte_size);
1928                 break;
1929             }
1930         }
1931         break;
1932     case lldb::eEncodingIEEE754:
1933         {
1934             lldb::offset_t offset;
1935
1936             if (byte_size == sizeof (float))
1937                 operator=((float)data.GetFloat(&offset));
1938             else if (byte_size == sizeof (double))
1939                 operator=((double)data.GetDouble(&offset));
1940             else if (byte_size == sizeof (long double))
1941                 operator=((long double)data.GetLongDouble(&offset));
1942             else
1943                 error.SetErrorStringWithFormat ("unsupported float byte size: %zu", byte_size);
1944         }
1945         break;
1946     }
1947
1948     return error;
1949 }
1950
1951 bool
1952 Scalar::SignExtend (uint32_t sign_bit_pos)
1953 {
1954     const uint32_t max_bit_pos = GetByteSize() * 8;
1955
1956     if (sign_bit_pos < max_bit_pos)
1957     {
1958         switch (m_type)
1959         {
1960         case Scalar::e_void:
1961         case Scalar::e_float:
1962         case Scalar::e_double:
1963         case Scalar::e_long_double:
1964             return false;
1965
1966         case Scalar::e_sint:
1967         case Scalar::e_uint:
1968             if (max_bit_pos == sign_bit_pos)
1969                 return true;
1970             else if (sign_bit_pos < (max_bit_pos-1))
1971             {
1972                 unsigned int sign_bit = 1u << sign_bit_pos;
1973                 if (m_data.uint & sign_bit)
1974                 {
1975                     const unsigned int mask = ~(sign_bit) + 1u;
1976                     m_data.uint |= mask;
1977                 }
1978                 return true;
1979             }
1980             break;
1981
1982         case Scalar::e_slong:
1983         case Scalar::e_ulong:
1984             if (max_bit_pos == sign_bit_pos)
1985                 return true;
1986             else if (sign_bit_pos < (max_bit_pos-1))
1987             {
1988                 unsigned long sign_bit = 1ul << sign_bit_pos;
1989                 if (m_data.ulong & sign_bit)
1990                 {
1991                     const unsigned long mask = ~(sign_bit) + 1ul;
1992                     m_data.ulong |= mask;
1993                 }
1994                 return true;
1995             }
1996             break;
1997
1998         case Scalar::e_slonglong:
1999         case Scalar::e_ulonglong:
2000             if (max_bit_pos == sign_bit_pos)
2001                 return true;
2002             else if (sign_bit_pos < (max_bit_pos-1))
2003             {
2004                 unsigned long long sign_bit = 1ull << sign_bit_pos;
2005                 if (m_data.ulonglong & sign_bit)
2006                 {
2007                     const unsigned long long mask = ~(sign_bit) + 1ull;
2008                     m_data.ulonglong |= mask;
2009                 }
2010                 return true;
2011             }
2012             break;
2013         }
2014     }
2015     return false;
2016 }
2017
2018 size_t
2019 Scalar::GetAsMemoryData (void *dst,
2020                          size_t dst_len,
2021                          lldb::ByteOrder dst_byte_order,
2022                          Error &error) const
2023 {
2024     // Get a data extractor that points to the native scalar data
2025     DataExtractor data;
2026     if (!GetData(data))
2027     {
2028         error.SetErrorString ("invalid scalar value");
2029         return 0;
2030     }
2031
2032     const size_t src_len = data.GetByteSize();
2033
2034     // Prepare a memory buffer that contains some or all of the register value
2035     const size_t bytes_copied = data.CopyByteOrderedData (0,                  // src offset
2036                                                             src_len,            // src length
2037                                                             dst,                // dst buffer
2038                                                             dst_len,            // dst length
2039                                                             dst_byte_order);    // dst byte order
2040     if (bytes_copied == 0)
2041         error.SetErrorString ("failed to copy data");
2042
2043     return bytes_copied;
2044 }
2045
2046 bool
2047 Scalar::ExtractBitfield (uint32_t bit_size,
2048                          uint32_t bit_offset)
2049 {
2050     if (bit_size == 0)
2051         return true;
2052
2053     uint32_t msbit = bit_offset + bit_size - 1;
2054     uint32_t lsbit = bit_offset;
2055     switch (m_type)
2056     {
2057         case Scalar::e_void:
2058             break;
2059
2060         case e_float:
2061             if (sizeof(m_data.flt) == sizeof(sint_t))
2062                 m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
2063             else if (sizeof(m_data.flt) == sizeof(ulong_t))
2064                 m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
2065             else if (sizeof(m_data.flt) == sizeof(ulonglong_t))
2066                 m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
2067             else
2068                 return false;
2069             return true;
2070
2071         case e_double:
2072             if (sizeof(m_data.dbl) == sizeof(sint_t))
2073                 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2074             else if (sizeof(m_data.dbl) == sizeof(ulong_t))
2075                 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2076             else if (sizeof(m_data.dbl) == sizeof(ulonglong_t))
2077                 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2078             else
2079                 return false;
2080             return true;
2081
2082         case e_long_double:
2083             if (sizeof(m_data.ldbl) == sizeof(sint_t))
2084                 m_data.sint = SignedBits (m_data.sint, msbit, lsbit);
2085             else if (sizeof(m_data.ldbl) == sizeof(ulong_t))
2086                 m_data.slong = SignedBits (m_data.slong, msbit, lsbit);
2087             else if (sizeof(m_data.ldbl) == sizeof(ulonglong_t))
2088                 m_data.slonglong = SignedBits (m_data.slonglong, msbit, lsbit);
2089             else
2090                 return false;
2091             return true;
2092
2093         case Scalar::e_sint:
2094             m_data.sint = (sint_t)SignedBits (m_data.sint, msbit, lsbit);
2095             return true;
2096
2097         case Scalar::e_uint:
2098             m_data.uint = (uint_t)UnsignedBits (m_data.uint, msbit, lsbit);
2099             return true;
2100
2101         case Scalar::e_slong:
2102             m_data.slong = (slong_t)SignedBits (m_data.slong, msbit, lsbit);
2103             return true;
2104
2105         case Scalar::e_ulong:
2106             m_data.ulong = (ulong_t)UnsignedBits (m_data.ulong, msbit, lsbit);
2107             return true;
2108
2109         case Scalar::e_slonglong:
2110             m_data.slonglong = (slonglong_t)SignedBits (m_data.slonglong, msbit, lsbit);
2111             return true;
2112
2113         case Scalar::e_ulonglong:
2114             m_data.ulonglong = (ulonglong_t)UnsignedBits (m_data.ulonglong, msbit, lsbit);
2115             return true;
2116     }
2117     return false;
2118 }
2119
2120
2121
2122
2123
2124 bool
2125 lldb_private::operator== (const Scalar& lhs, const Scalar& rhs)
2126 {
2127     // If either entry is void then we can just compare the types
2128     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2129         return lhs.m_type == rhs.m_type;
2130
2131     Scalar temp_value;
2132     const Scalar* a;
2133     const Scalar* b;
2134     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2135     {
2136     case Scalar::e_void:            break;
2137     case Scalar::e_sint:            return a->m_data.sint       == b->m_data.sint;
2138     case Scalar::e_uint:            return a->m_data.uint       == b->m_data.uint;
2139     case Scalar::e_slong:           return a->m_data.slong      == b->m_data.slong;
2140     case Scalar::e_ulong:           return a->m_data.ulong      == b->m_data.ulong;
2141     case Scalar::e_slonglong:       return a->m_data.slonglong  == b->m_data.slonglong;
2142     case Scalar::e_ulonglong:       return a->m_data.ulonglong  == b->m_data.ulonglong;
2143     case Scalar::e_float:           return a->m_data.flt        == b->m_data.flt;
2144     case Scalar::e_double:      return a->m_data.dbl        == b->m_data.dbl;
2145     case Scalar::e_long_double: return a->m_data.ldbl       == b->m_data.ldbl;
2146     }
2147     return false;
2148 }
2149
2150 bool
2151 lldb_private::operator!= (const Scalar& lhs, const Scalar& rhs)
2152 {
2153     // If either entry is void then we can just compare the types
2154     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2155         return lhs.m_type != rhs.m_type;
2156
2157     Scalar temp_value;  // A temp value that might get a copy of either promoted value
2158     const Scalar* a;
2159     const Scalar* b;
2160     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2161     {
2162     case Scalar::e_void:            break;
2163     case Scalar::e_sint:            return a->m_data.sint       != b->m_data.sint;
2164     case Scalar::e_uint:            return a->m_data.uint       != b->m_data.uint;
2165     case Scalar::e_slong:           return a->m_data.slong      != b->m_data.slong;
2166     case Scalar::e_ulong:           return a->m_data.ulong      != b->m_data.ulong;
2167     case Scalar::e_slonglong:       return a->m_data.slonglong  != b->m_data.slonglong;
2168     case Scalar::e_ulonglong:       return a->m_data.ulonglong  != b->m_data.ulonglong;
2169     case Scalar::e_float:           return a->m_data.flt        != b->m_data.flt;
2170     case Scalar::e_double:      return a->m_data.dbl        != b->m_data.dbl;
2171     case Scalar::e_long_double: return a->m_data.ldbl       != b->m_data.ldbl;
2172     }
2173     return true;
2174 }
2175
2176 bool
2177 lldb_private::operator< (const Scalar& lhs, const Scalar& rhs)
2178 {
2179     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2180         return false;
2181
2182     Scalar temp_value;
2183     const Scalar* a;
2184     const Scalar* b;
2185     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2186     {
2187     case Scalar::e_void:            break;
2188     case Scalar::e_sint:            return a->m_data.sint       < b->m_data.sint;
2189     case Scalar::e_uint:            return a->m_data.uint       < b->m_data.uint;
2190     case Scalar::e_slong:           return a->m_data.slong      < b->m_data.slong;
2191     case Scalar::e_ulong:           return a->m_data.ulong      < b->m_data.ulong;
2192     case Scalar::e_slonglong:       return a->m_data.slonglong  < b->m_data.slonglong;
2193     case Scalar::e_ulonglong:       return a->m_data.ulonglong  < b->m_data.ulonglong;
2194     case Scalar::e_float:           return a->m_data.flt        < b->m_data.flt;
2195     case Scalar::e_double:      return a->m_data.dbl        < b->m_data.dbl;
2196     case Scalar::e_long_double: return a->m_data.ldbl       < b->m_data.ldbl;
2197     }
2198     return false;
2199 }
2200
2201 bool
2202 lldb_private::operator<= (const Scalar& lhs, const Scalar& rhs)
2203 {
2204     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2205         return false;
2206
2207     Scalar temp_value;
2208     const Scalar* a;
2209     const Scalar* b;
2210     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2211     {
2212     case Scalar::e_void:            break;
2213     case Scalar::e_sint:            return a->m_data.sint       <= b->m_data.sint;
2214     case Scalar::e_uint:            return a->m_data.uint       <= b->m_data.uint;
2215     case Scalar::e_slong:           return a->m_data.slong      <= b->m_data.slong;
2216     case Scalar::e_ulong:           return a->m_data.ulong      <= b->m_data.ulong;
2217     case Scalar::e_slonglong:       return a->m_data.slonglong  <= b->m_data.slonglong;
2218     case Scalar::e_ulonglong:       return a->m_data.ulonglong  <= b->m_data.ulonglong;
2219     case Scalar::e_float:           return a->m_data.flt        <= b->m_data.flt;
2220     case Scalar::e_double:      return a->m_data.dbl        <= b->m_data.dbl;
2221     case Scalar::e_long_double: return a->m_data.ldbl       <= b->m_data.ldbl;
2222     }
2223     return false;
2224 }
2225
2226
2227 bool
2228 lldb_private::operator> (const Scalar& lhs, const Scalar& rhs)
2229 {
2230     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2231         return false;
2232
2233     Scalar temp_value;
2234     const Scalar* a;
2235     const Scalar* b;
2236     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2237     {
2238     case Scalar::e_void:            break;
2239     case Scalar::e_sint:            return a->m_data.sint       > b->m_data.sint;
2240     case Scalar::e_uint:            return a->m_data.uint       > b->m_data.uint;
2241     case Scalar::e_slong:           return a->m_data.slong      > b->m_data.slong;
2242     case Scalar::e_ulong:           return a->m_data.ulong      > b->m_data.ulong;
2243     case Scalar::e_slonglong:       return a->m_data.slonglong  > b->m_data.slonglong;
2244     case Scalar::e_ulonglong:       return a->m_data.ulonglong  > b->m_data.ulonglong;
2245     case Scalar::e_float:           return a->m_data.flt        > b->m_data.flt;
2246     case Scalar::e_double:      return a->m_data.dbl        > b->m_data.dbl;
2247     case Scalar::e_long_double: return a->m_data.ldbl       > b->m_data.ldbl;
2248     }
2249     return false;
2250 }
2251
2252 bool
2253 lldb_private::operator>= (const Scalar& lhs, const Scalar& rhs)
2254 {
2255     if (lhs.m_type == Scalar::e_void || rhs.m_type == Scalar::e_void)
2256         return false;
2257
2258     Scalar temp_value;
2259     const Scalar* a;
2260     const Scalar* b;
2261     switch (PromoteToMaxType(lhs, rhs, temp_value, a, b))
2262     {
2263     case Scalar::e_void:            break;
2264     case Scalar::e_sint:            return a->m_data.sint       >= b->m_data.sint;
2265     case Scalar::e_uint:            return a->m_data.uint       >= b->m_data.uint;
2266     case Scalar::e_slong:           return a->m_data.slong      >= b->m_data.slong;
2267     case Scalar::e_ulong:           return a->m_data.ulong      >= b->m_data.ulong;
2268     case Scalar::e_slonglong:       return a->m_data.slonglong  >= b->m_data.slonglong;
2269     case Scalar::e_ulonglong:       return a->m_data.ulonglong  >= b->m_data.ulonglong;
2270     case Scalar::e_float:           return a->m_data.flt        >= b->m_data.flt;
2271     case Scalar::e_double:      return a->m_data.dbl        >= b->m_data.dbl;
2272     case Scalar::e_long_double: return a->m_data.ldbl       >= b->m_data.ldbl;
2273     }
2274     return false;
2275 }
2276
2277
2278
2279