contrib/llvm/tools/lldb/source/API/SBType.cpp

   1 //===-- SBType.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/API/SBDefines.h"
  11 #include "lldb/API/SBType.h"
  12 #include "lldb/API/SBStream.h"
  13 #include "lldb/Core/ConstString.h"
  14 #include "lldb/Core/Log.h"
  15 #include "lldb/Core/Stream.h"
  16 #include "lldb/Symbol/ClangASTContext.h"
  17 #include "lldb/Symbol/ClangASTType.h"
  18 #include "lldb/Symbol/Type.h"
  19
  20 using namespace lldb;
  21 using namespace lldb_private;
  22 using namespace clang;
  23
  24 SBType::SBType() :
  25     m_opaque_sp()
  26 {
  27 }
  28
  29 SBType::SBType (const ClangASTType &type) :
  30     m_opaque_sp(new TypeImpl(ClangASTType(type.GetASTContext(),
  31                                           type.GetOpaqueQualType())))
  32 {
  33 }
  34
  35 SBType::SBType (const lldb::TypeSP &type_sp) :
  36     m_opaque_sp(new TypeImpl(type_sp))
  37 {
  38 }
  39
  40 SBType::SBType (const lldb::TypeImplSP &type_impl_sp) :
  41     m_opaque_sp(type_impl_sp)
  42 {
  43 }
  44
  45
  46 SBType::SBType (const SBType &rhs) :
  47     m_opaque_sp()
  48 {
  49     if (this != &rhs)
  50     {
  51         m_opaque_sp = rhs.m_opaque_sp;
  52     }
  53 }
  54
  55
  56 //SBType::SBType (TypeImpl* impl) :
  57 //    m_opaque_ap(impl)
  58 //{}
  59 //
  60 bool
  61 SBType::operator == (SBType &rhs)
  62 {
  63     if (IsValid() == false)
  64         return !rhs.IsValid();
  65
  66     if (rhs.IsValid() == false)
  67         return false;
  68
  69     return *m_opaque_sp.get() == *rhs.m_opaque_sp.get();
  70 }
  71
  72 bool
  73 SBType::operator != (SBType &rhs)
  74 {
  75     if (IsValid() == false)
  76         return rhs.IsValid();
  77
  78     if (rhs.IsValid() == false)
  79         return true;
  80
  81     return *m_opaque_sp.get() != *rhs.m_opaque_sp.get();
  82 }
  83
  84 lldb::TypeImplSP
  85 SBType::GetSP ()
  86 {
  87     return m_opaque_sp;
  88 }
  89
  90
  91 void
  92 SBType::SetSP (const lldb::TypeImplSP &type_impl_sp)
  93 {
  94     m_opaque_sp = type_impl_sp;
  95 }
  96
  97 SBType &
  98 SBType::operator = (const SBType &rhs)
  99 {
 100     if (this != &rhs)
 101     {
 102         m_opaque_sp = rhs.m_opaque_sp;
 103     }
 104     return *this;
 105 }
 106
 107 SBType::~SBType ()
 108 {}
 109
 110 TypeImpl &
 111 SBType::ref ()
 112 {
 113     if (m_opaque_sp.get() == NULL)
 114         m_opaque_sp.reset (new TypeImpl());
 115         return *m_opaque_sp;
 116 }
 117
 118 const TypeImpl &
 119 SBType::ref () const
 120 {
 121     // "const SBAddress &addr" should already have checked "addr.IsValid()"
 122     // prior to calling this function. In case you didn't we will assert
 123     // and die to let you know.
 124     assert (m_opaque_sp.get());
 125     return *m_opaque_sp;
 126 }
 127
 128 bool
 129 SBType::IsValid() const
 130 {
 131     if (m_opaque_sp.get() == NULL)
 132         return false;
 133
 134     return m_opaque_sp->IsValid();
 135 }
 136
 137 uint64_t
 138 SBType::GetByteSize()
 139 {
 140     if (!IsValid())
 141         return 0;
 142
 143     return m_opaque_sp->GetClangASTType(false).GetByteSize();
 144
 145 }
 146
 147 bool
 148 SBType::IsPointerType()
 149 {
 150     if (!IsValid())
 151         return false;
 152     return m_opaque_sp->GetClangASTType(true).IsPointerType();
 153 }
 154
 155 bool
 156 SBType::IsReferenceType()
 157 {
 158     if (!IsValid())
 159         return false;
 160     return m_opaque_sp->GetClangASTType(true).IsReferenceType();
 161 }
 162
 163 SBType
 164 SBType::GetPointerType()
 165 {
 166     if (!IsValid())
 167         return SBType();
 168
 169     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointerType())));
 170 }
 171
 172 SBType
 173 SBType::GetPointeeType()
 174 {
 175     if (!IsValid())
 176         return SBType();
 177     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetPointeeType())));
 178 }
 179
 180 SBType
 181 SBType::GetReferenceType()
 182 {
 183     if (!IsValid())
 184         return SBType();
 185     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetReferenceType())));
 186 }
 187
 188 SBType
 189 SBType::GetTypedefedType()
 190 {
 191     if (!IsValid())
 192         return SBType();
 193     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetTypedefedType())));
 194 }
 195
 196 SBType
 197 SBType::GetDereferencedType()
 198 {
 199     if (!IsValid())
 200         return SBType();
 201     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetDereferencedType())));
 202 }
 203
 204 bool
 205 SBType::IsFunctionType ()
 206 {
 207     if (!IsValid())
 208         return false;
 209     return m_opaque_sp->GetClangASTType(true).IsFunctionType();
 210 }
 211
 212 bool
 213 SBType::IsPolymorphicClass ()
 214 {
 215     if (!IsValid())
 216         return false;
 217     return m_opaque_sp->GetClangASTType(true).IsPolymorphicClass();
 218 }
 219
 220
 221
 222 lldb::SBType
 223 SBType::GetFunctionReturnType ()
 224 {
 225     if (IsValid())
 226     {
 227         ClangASTType return_clang_type (m_opaque_sp->GetClangASTType(true).GetFunctionReturnType());
 228         if (return_clang_type.IsValid())
 229             return SBType(return_clang_type);
 230     }
 231     return lldb::SBType();
 232 }
 233
 234 lldb::SBTypeList
 235 SBType::GetFunctionArgumentTypes ()
 236 {
 237     SBTypeList sb_type_list;
 238     if (IsValid())
 239     {
 240         ClangASTType func_type(m_opaque_sp->GetClangASTType(true));
 241         size_t count = func_type.GetNumberOfFunctionArguments();
 242         for (size_t i = 0;
 243              i < count;
 244              i++)
 245         {
 246             sb_type_list.Append(SBType(func_type.GetFunctionArgumentAtIndex(i)));
 247         }
 248     }
 249     return sb_type_list;
 250 }
 251
 252 lldb::SBType
 253 SBType::GetUnqualifiedType()
 254 {
 255     if (!IsValid())
 256         return SBType();
 257     return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetUnqualifiedType())));
 258 }
 259
 260 lldb::SBType
 261 SBType::GetCanonicalType()
 262 {
 263     if (IsValid())
 264         return SBType(TypeImplSP(new TypeImpl(m_opaque_sp->GetCanonicalType())));
 265     return SBType();
 266 }
 267
 268
 269 lldb::BasicType
 270 SBType::GetBasicType()
 271 {
 272     if (IsValid())
 273         return m_opaque_sp->GetClangASTType(false).GetBasicTypeEnumeration ();
 274     return eBasicTypeInvalid;
 275 }
 276
 277 SBType
 278 SBType::GetBasicType(lldb::BasicType basic_type)
 279 {
 280     if (IsValid())
 281         return SBType (ClangASTContext::GetBasicType (m_opaque_sp->GetClangASTContext(false), basic_type));
 282     return SBType();
 283 }
 284
 285 uint32_t
 286 SBType::GetNumberOfDirectBaseClasses ()
 287 {
 288     if (IsValid())
 289         return m_opaque_sp->GetClangASTType(true).GetNumDirectBaseClasses();
 290     return 0;
 291 }
 292
 293 uint32_t
 294 SBType::GetNumberOfVirtualBaseClasses ()
 295 {
 296     if (IsValid())
 297         return m_opaque_sp->GetClangASTType(true).GetNumVirtualBaseClasses();
 298     return 0;
 299 }
 300
 301 uint32_t
 302 SBType::GetNumberOfFields ()
 303 {
 304     if (IsValid())
 305         return m_opaque_sp->GetClangASTType(false).GetNumFields();
 306     return 0;
 307 }
 308
 309 bool
 310 SBType::GetDescription (SBStream &description, lldb::DescriptionLevel description_level)
 311 {
 312     Stream &strm = description.ref();
 313
 314     if (m_opaque_sp)
 315     {
 316         m_opaque_sp->GetDescription (strm, description_level);
 317     }
 318     else
 319         strm.PutCString ("No value");
 320
 321     return true;
 322 }
 323
 324
 325
 326 SBTypeMember
 327 SBType::GetDirectBaseClassAtIndex (uint32_t idx)
 328 {
 329     SBTypeMember sb_type_member;
 330     if (IsValid())
 331     {
 332         ClangASTType this_type (m_opaque_sp->GetClangASTType (true));
 333         if (this_type.IsValid())
 334         {
 335             uint32_t bit_offset = 0;
 336             ClangASTType base_class_type (this_type.GetDirectBaseClassAtIndex(idx, &bit_offset));
 337             if (base_class_type.IsValid())
 338             {
 339                 sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
 340             }
 341         }
 342     }
 343     return sb_type_member;
 344
 345 }
 346
 347 SBTypeMember
 348 SBType::GetVirtualBaseClassAtIndex (uint32_t idx)
 349 {
 350     SBTypeMember sb_type_member;
 351     if (IsValid())
 352     {
 353         ClangASTType this_type (m_opaque_sp->GetClangASTType (true));
 354         if (this_type.IsValid())
 355         {
 356             uint32_t bit_offset = 0;
 357             ClangASTType base_class_type (this_type.GetVirtualBaseClassAtIndex(idx, &bit_offset));
 358             if (base_class_type.IsValid())
 359             {
 360                 sb_type_member.reset (new TypeMemberImpl (TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
 361             }
 362         }
 363     }
 364     return sb_type_member;
 365 }
 366
 367 SBTypeMember
 368 SBType::GetFieldAtIndex (uint32_t idx)
 369 {
 370     SBTypeMember sb_type_member;
 371     if (IsValid())
 372     {
 373         ClangASTType this_type (m_opaque_sp->GetClangASTType (false));
 374         if (this_type.IsValid())
 375         {
 376             uint64_t bit_offset = 0;
 377             uint32_t bitfield_bit_size = 0;
 378             bool is_bitfield = false;
 379             std::string name_sstr;
 380             ClangASTType field_type (this_type.GetFieldAtIndex (idx,
 381                                                                 name_sstr,
 382                                                                 &bit_offset,
 383                                                                 &bitfield_bit_size,
 384                                                                 &is_bitfield));
 385             if (field_type.IsValid())
 386             {
 387                 ConstString name;
 388                 if (!name_sstr.empty())
 389                     name.SetCString(name_sstr.c_str());
 390                 sb_type_member.reset (new TypeMemberImpl (TypeImplSP (new TypeImpl(field_type)),
 391                                                           bit_offset,
 392                                                           name,
 393                                                           bitfield_bit_size,
 394                                                           is_bitfield));
 395             }
 396         }
 397     }
 398     return sb_type_member;
 399 }
 400
 401 bool
 402 SBType::IsTypeComplete()
 403 {
 404     if (!IsValid())
 405         return false;
 406     return m_opaque_sp->GetClangASTType(false).IsCompleteType();
 407 }
 408
 409 const char*
 410 SBType::GetName()
 411 {
 412     if (!IsValid())
 413         return "";
 414     return m_opaque_sp->GetName().GetCString();
 415 }
 416
 417 lldb::TypeClass
 418 SBType::GetTypeClass ()
 419 {
 420     if (IsValid())
 421         return m_opaque_sp->GetClangASTType(false).GetTypeClass();
 422     return lldb::eTypeClassInvalid;
 423 }
 424
 425 uint32_t
 426 SBType::GetNumberOfTemplateArguments ()
 427 {
 428     if (IsValid())
 429         return m_opaque_sp->GetClangASTType(false).GetNumTemplateArguments();
 430     return 0;
 431 }
 432
 433 lldb::SBType
 434 SBType::GetTemplateArgumentType (uint32_t idx)
 435 {
 436     if (IsValid())
 437     {
 438         TemplateArgumentKind kind = eTemplateArgumentKindNull;
 439         ClangASTType template_arg_type = m_opaque_sp->GetClangASTType(false).GetTemplateArgument (idx, kind);
 440         if (template_arg_type.IsValid())
 441             return SBType(template_arg_type);
 442     }
 443     return SBType();
 444 }
 445
 446
 447 lldb::TemplateArgumentKind
 448 SBType::GetTemplateArgumentKind (uint32_t idx)
 449 {
 450     TemplateArgumentKind kind = eTemplateArgumentKindNull;
 451     if (IsValid())
 452         m_opaque_sp->GetClangASTType(false).GetTemplateArgument (idx, kind);
 453     return kind;
 454 }
 455
 456
 457 SBTypeList::SBTypeList() :
 458     m_opaque_ap(new TypeListImpl())
 459 {
 460 }
 461
 462 SBTypeList::SBTypeList(const SBTypeList& rhs) :
 463     m_opaque_ap(new TypeListImpl())
 464 {
 465     for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++)
 466         Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i));
 467 }
 468
 469 bool
 470 SBTypeList::IsValid ()
 471 {
 472     return (m_opaque_ap.get() != NULL);
 473 }
 474
 475 SBTypeList&
 476 SBTypeList::operator = (const SBTypeList& rhs)
 477 {
 478     if (this != &rhs)
 479     {
 480         m_opaque_ap.reset (new TypeListImpl());
 481         for (uint32_t i = 0, rhs_size = const_cast<SBTypeList&>(rhs).GetSize(); i < rhs_size; i++)
 482             Append(const_cast<SBTypeList&>(rhs).GetTypeAtIndex(i));
 483     }
 484     return *this;
 485 }
 486
 487 void
 488 SBTypeList::Append (SBType type)
 489 {
 490     if (type.IsValid())
 491         m_opaque_ap->Append (type.m_opaque_sp);
 492 }
 493
 494 SBType
 495 SBTypeList::GetTypeAtIndex(uint32_t index)
 496 {
 497     if (m_opaque_ap.get())
 498         return SBType(m_opaque_ap->GetTypeAtIndex(index));
 499     return SBType();
 500 }
 501
 502 uint32_t
 503 SBTypeList::GetSize()
 504 {
 505     return m_opaque_ap->GetSize();
 506 }
 507
 508 SBTypeList::~SBTypeList()
 509 {
 510 }
 511
 512 SBTypeMember::SBTypeMember() :
 513     m_opaque_ap()
 514 {
 515 }
 516
 517 SBTypeMember::~SBTypeMember()
 518 {
 519 }
 520
 521 SBTypeMember::SBTypeMember (const SBTypeMember& rhs) :
 522     m_opaque_ap()
 523 {
 524     if (this != &rhs)
 525     {
 526         if (rhs.IsValid())
 527             m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
 528     }
 529 }
 530
 531 lldb::SBTypeMember&
 532 SBTypeMember::operator = (const lldb::SBTypeMember& rhs)
 533 {
 534     if (this != &rhs)
 535     {
 536         if (rhs.IsValid())
 537             m_opaque_ap.reset(new TypeMemberImpl(rhs.ref()));
 538     }
 539     return *this;
 540 }
 541
 542 bool
 543 SBTypeMember::IsValid() const
 544 {
 545     return m_opaque_ap.get();
 546 }
 547
 548 const char *
 549 SBTypeMember::GetName ()
 550 {
 551     if (m_opaque_ap.get())
 552         return m_opaque_ap->GetName().GetCString();
 553     return NULL;
 554 }
 555
 556 SBType
 557 SBTypeMember::GetType ()
 558 {
 559     SBType sb_type;
 560     if (m_opaque_ap.get())
 561     {
 562         sb_type.SetSP (m_opaque_ap->GetTypeImpl());
 563     }
 564     return sb_type;
 565
 566 }
 567
 568 uint64_t
 569 SBTypeMember::GetOffsetInBytes()
 570 {
 571     if (m_opaque_ap.get())
 572         return m_opaque_ap->GetBitOffset() / 8u;
 573     return 0;
 574 }
 575
 576 uint64_t
 577 SBTypeMember::GetOffsetInBits()
 578 {
 579     if (m_opaque_ap.get())
 580         return m_opaque_ap->GetBitOffset();
 581     return 0;
 582 }
 583
 584 bool
 585 SBTypeMember::IsBitfield()
 586 {
 587     if (m_opaque_ap.get())
 588         return m_opaque_ap->GetIsBitfield();
 589     return false;
 590 }
 591
 592 uint32_t
 593 SBTypeMember::GetBitfieldSizeInBits()
 594 {
 595     if (m_opaque_ap.get())
 596         return m_opaque_ap->GetBitfieldBitSize();
 597     return 0;
 598 }
 599
 600
 601 bool
 602 SBTypeMember::GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level)
 603 {
 604     Stream &strm = description.ref();
 605
 606     if (m_opaque_ap.get())
 607     {
 608         const uint32_t bit_offset = m_opaque_ap->GetBitOffset();
 609         const uint32_t byte_offset = bit_offset / 8u;
 610         const uint32_t byte_bit_offset = bit_offset % 8u;
 611         const char *name = m_opaque_ap->GetName().GetCString();
 612         if (byte_bit_offset)
 613             strm.Printf ("+%u + %u bits: (", byte_offset, byte_bit_offset);
 614         else
 615             strm.Printf ("+%u: (", byte_offset);
 616
 617         TypeImplSP type_impl_sp (m_opaque_ap->GetTypeImpl());
 618         if (type_impl_sp)
 619             type_impl_sp->GetDescription(strm, description_level);
 620
 621         strm.Printf (") %s", name);
 622         if (m_opaque_ap->GetIsBitfield())
 623         {
 624             const uint32_t bitfield_bit_size = m_opaque_ap->GetBitfieldBitSize();
 625             strm.Printf (" : %u", bitfield_bit_size);
 626         }
 627     }
 628     else
 629     {
 630         strm.PutCString ("No value");
 631     }
 632     return true;
 633 }
 634
 635
 636 void
 637 SBTypeMember::reset(TypeMemberImpl *type_member_impl)
 638 {
 639     m_opaque_ap.reset(type_member_impl);
 640 }
 641
 642 TypeMemberImpl &
 643 SBTypeMember::ref ()
 644 {
 645     if (m_opaque_ap.get() == NULL)
 646         m_opaque_ap.reset (new TypeMemberImpl());
 647     return *m_opaque_ap.get();
 648 }
 649
 650 const TypeMemberImpl &
 651 SBTypeMember::ref () const
 652 {
 653     return *m_opaque_ap.get();
 654 }