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