1 //===-- Type.h --------------------------------------------------*- 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 #ifndef liblldb_Type_h_ 11 #define liblldb_Type_h_ 12 13 #include "lldb/lldb-private.h" 14 #include "lldb/Core/ClangForward.h" 15 #include "lldb/Core/ConstString.h" 16 #include "lldb/Core/UserID.h" 17 #include "lldb/Symbol/ClangASTType.h" 18 #include "lldb/Symbol/Declaration.h" 19 20 #include <set> 21 22 namespace lldb_private { 23 24 class SymbolFileType : 25 public std::enable_shared_from_this<SymbolFileType>, 26 public UserID 27 { 28 public: 29 SymbolFileType (SymbolFile &symbol_file, lldb::user_id_t uid) : 30 UserID (uid), 31 m_symbol_file (symbol_file) 32 { 33 } 34 35 ~SymbolFileType () 36 { 37 } 38 39 Type * 40 operator->() 41 { 42 return GetType (); 43 } 44 45 Type * 46 GetType (); 47 48 protected: 49 SymbolFile &m_symbol_file; 50 lldb::TypeSP m_type_sp; 51 }; 52 53 class Type : 54 public std::enable_shared_from_this<Type>, 55 public UserID 56 { 57 public: 58 typedef enum EncodingDataTypeTag 59 { 60 eEncodingInvalid, 61 eEncodingIsUID, ///< This type is the type whose UID is m_encoding_uid 62 eEncodingIsConstUID, ///< This type is the type whose UID is m_encoding_uid with the const qualifier added 63 eEncodingIsRestrictUID, ///< This type is the type whose UID is m_encoding_uid with the restrict qualifier added 64 eEncodingIsVolatileUID, ///< This type is the type whose UID is m_encoding_uid with the volatile qualifier added 65 eEncodingIsTypedefUID, ///< This type is pointer to a type whose UID is m_encoding_uid 66 eEncodingIsPointerUID, ///< This type is pointer to a type whose UID is m_encoding_uid 67 eEncodingIsLValueReferenceUID, ///< This type is L value reference to a type whose UID is m_encoding_uid 68 eEncodingIsRValueReferenceUID, ///< This type is R value reference to a type whose UID is m_encoding_uid 69 eEncodingIsSyntheticUID 70 } EncodingDataType; 71 72 typedef enum ResolveStateTag 73 { 74 eResolveStateUnresolved = 0, 75 eResolveStateForward = 1, 76 eResolveStateLayout = 2, 77 eResolveStateFull = 3 78 } ResolveState; 79 80 Type (lldb::user_id_t uid, 81 SymbolFile* symbol_file, 82 const ConstString &name, 83 uint64_t byte_size, 84 SymbolContextScope *context, 85 lldb::user_id_t encoding_uid, 86 EncodingDataType encoding_uid_type, 87 const Declaration& decl, 88 const ClangASTType &clang_qual_type, 89 ResolveState clang_type_resolve_state); 90 91 // This makes an invalid type. Used for functions that return a Type when they 92 // get an error. 93 Type(); 94 95 Type (const Type &rhs); 96 97 const Type& 98 operator= (const Type& rhs); 99 100 void 101 Dump(Stream *s, bool show_context); 102 103 void 104 DumpTypeName(Stream *s); 105 106 107 void 108 GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name); 109 110 SymbolFile * 111 GetSymbolFile() 112 { 113 return m_symbol_file; 114 } 115 const SymbolFile * 116 GetSymbolFile() const 117 { 118 return m_symbol_file; 119 } 120 121 TypeList* 122 GetTypeList(); 123 124 const ConstString& 125 GetName(); 126 127 uint64_t 128 GetByteSize(); 129 130 uint32_t 131 GetNumChildren (bool omit_empty_base_classes); 132 133 bool 134 IsAggregateType (); 135 136 bool 137 IsValidType () 138 { 139 return m_encoding_uid_type != eEncodingInvalid; 140 } 141 142 bool 143 IsTypedef () 144 { 145 return m_encoding_uid_type == eEncodingIsTypedefUID; 146 } 147 148 lldb::TypeSP 149 GetTypedefType(); 150 151 const ConstString & 152 GetName () const 153 { 154 return m_name; 155 } 156 157 ConstString 158 GetQualifiedName (); 159 160 void 161 DumpValue(ExecutionContext *exe_ctx, 162 Stream *s, 163 const DataExtractor &data, 164 uint32_t data_offset, 165 bool show_type, 166 bool show_summary, 167 bool verbose, 168 lldb::Format format = lldb::eFormatDefault); 169 170 bool 171 DumpValueInMemory(ExecutionContext *exe_ctx, 172 Stream *s, 173 lldb::addr_t address, 174 AddressType address_type, 175 bool show_types, 176 bool show_summary, 177 bool verbose); 178 179 bool 180 ReadFromMemory (ExecutionContext *exe_ctx, 181 lldb::addr_t address, 182 AddressType address_type, 183 DataExtractor &data); 184 185 bool 186 WriteToMemory (ExecutionContext *exe_ctx, 187 lldb::addr_t address, 188 AddressType address_type, 189 DataExtractor &data); 190 191 bool 192 GetIsDeclaration() const; 193 194 void 195 SetIsDeclaration(bool b); 196 197 bool 198 GetIsExternal() const; 199 200 void 201 SetIsExternal(bool b); 202 203 lldb::Format 204 GetFormat (); 205 206 lldb::Encoding 207 GetEncoding (uint64_t &count); 208 209 SymbolContextScope * 210 GetSymbolContextScope() 211 { 212 return m_context; 213 } 214 const SymbolContextScope * 215 GetSymbolContextScope() const 216 { 217 return m_context; 218 } 219 void 220 SetSymbolContextScope(SymbolContextScope *context) 221 { 222 m_context = context; 223 } 224 225 const lldb_private::Declaration & 226 GetDeclaration () const; 227 228 // Get the clang type, and resolve definitions for any 229 // class/struct/union/enum types completely. 230 ClangASTType 231 GetClangFullType (); 232 233 // Get the clang type, and resolve definitions enough so that the type could 234 // have layout performed. This allows ptrs and refs to class/struct/union/enum 235 // types remain forward declarations. 236 ClangASTType 237 GetClangLayoutType (); 238 239 // Get the clang type and leave class/struct/union/enum types as forward 240 // declarations if they haven't already been fully defined. 241 ClangASTType 242 GetClangForwardType (); 243 244 ClangASTContext & 245 GetClangASTContext (); 246 247 static int 248 Compare(const Type &a, const Type &b); 249 250 // From a fully qualified typename, split the type into the type basename 251 // and the remaining type scope (namespaces/classes). 252 static bool 253 GetTypeScopeAndBasename (const char* &name_cstr, 254 std::string &scope, 255 std::string &basename, 256 lldb::TypeClass &type_class); 257 void 258 SetEncodingType (Type *encoding_type) 259 { 260 m_encoding_type = encoding_type; 261 } 262 263 uint32_t 264 GetEncodingMask (); 265 266 ClangASTType 267 CreateClangTypedefType (Type *typedef_type, Type *base_type); 268 269 bool 270 IsRealObjCClass(); 271 272 bool 273 IsCompleteObjCClass() 274 { 275 return m_flags.is_complete_objc_class; 276 } 277 278 void 279 SetIsCompleteObjCClass(bool is_complete_objc_class) 280 { 281 m_flags.is_complete_objc_class = is_complete_objc_class; 282 } 283 284 protected: 285 ConstString m_name; 286 SymbolFile *m_symbol_file; 287 SymbolContextScope *m_context; // The symbol context in which this type is defined 288 Type *m_encoding_type; 289 lldb::user_id_t m_encoding_uid; 290 EncodingDataType m_encoding_uid_type; 291 uint64_t m_byte_size; 292 Declaration m_decl; 293 ClangASTType m_clang_type; 294 295 struct Flags { 296 ResolveState clang_type_resolve_state : 2; 297 bool is_complete_objc_class : 1; 298 } m_flags; 299 300 Type * 301 GetEncodingType (); 302 303 bool 304 ResolveClangType (ResolveState clang_type_resolve_state); 305 }; 306 307 308 /// 309 /// Sometimes you can find the name of the type corresponding to an object, but we don't have debug 310 /// information for it. If that is the case, you can return one of these objects, and then if it 311 /// has a full type, you can use that, but if not at least you can print the name for informational 312 /// purposes. 313 /// 314 315 class TypeAndOrName 316 { 317 public: 318 TypeAndOrName (); 319 TypeAndOrName (lldb::TypeSP &type_sp); 320 TypeAndOrName (const char *type_str); 321 TypeAndOrName (const TypeAndOrName &rhs); 322 TypeAndOrName (ConstString &type_const_string); 323 324 TypeAndOrName & 325 operator= (const TypeAndOrName &rhs); 326 327 bool 328 operator==(const TypeAndOrName &other) const; 329 330 bool 331 operator!=(const TypeAndOrName &other) const; 332 333 ConstString GetName () const; 334 335 lldb::TypeSP 336 GetTypeSP () const 337 { 338 return m_type_sp; 339 } 340 341 void 342 SetName (const ConstString &type_name); 343 344 void 345 SetName (const char *type_name_cstr); 346 347 void 348 SetTypeSP (lldb::TypeSP type_sp); 349 350 bool 351 IsEmpty (); 352 353 bool 354 HasName (); 355 356 bool 357 HasTypeSP (); 358 359 void 360 Clear (); 361 362 operator 363 bool () 364 { 365 return !IsEmpty(); 366 } 367 368 private: 369 lldb::TypeSP m_type_sp; 370 ConstString m_type_name; 371 }; 372 373 // the two classes here are used by the public API as a backend to 374 // the SBType and SBTypeList classes 375 376 class TypeImpl 377 { 378 public: 379 380 TypeImpl() : 381 m_clang_ast_type(), 382 m_type_sp() 383 { 384 } 385 386 TypeImpl(const TypeImpl& rhs) : 387 m_clang_ast_type(rhs.m_clang_ast_type), 388 m_type_sp(rhs.m_type_sp) 389 { 390 } 391 392 TypeImpl(const lldb_private::ClangASTType& type); 393 394 TypeImpl(const lldb::TypeSP& type); 395 396 TypeImpl& 397 operator = (const TypeImpl& rhs); 398 399 bool 400 operator == (const TypeImpl& rhs) 401 { 402 return m_clang_ast_type == rhs.m_clang_ast_type && m_type_sp.get() == rhs.m_type_sp.get(); 403 } 404 405 bool 406 operator != (const TypeImpl& rhs) 407 { 408 return m_clang_ast_type != rhs.m_clang_ast_type || m_type_sp.get() != rhs.m_type_sp.get(); 409 } 410 411 bool 412 IsValid() 413 { 414 return m_type_sp.get() != NULL || m_clang_ast_type.IsValid(); 415 } 416 417 const lldb_private::ClangASTType & 418 GetClangASTType() const 419 { 420 return m_clang_ast_type; 421 } 422 423 clang::ASTContext* 424 GetASTContext(); 425 426 lldb::clang_type_t 427 GetOpaqueQualType(); 428 429 lldb::TypeSP 430 GetTypeSP () 431 { 432 return m_type_sp; 433 } 434 435 ConstString 436 GetName (); 437 438 bool 439 GetDescription (lldb_private::Stream &strm, 440 lldb::DescriptionLevel description_level); 441 442 void 443 SetType (const lldb::TypeSP &type_sp); 444 445 private: 446 ClangASTType m_clang_ast_type; 447 lldb::TypeSP m_type_sp; 448 }; 449 450 class TypeListImpl 451 { 452 public: 453 TypeListImpl() : 454 m_content() 455 { 456 } 457 458 void 459 Append (const lldb::TypeImplSP& type) 460 { 461 m_content.push_back(type); 462 } 463 464 class AppendVisitor 465 { 466 public: 467 AppendVisitor(TypeListImpl &type_list) : 468 m_type_list(type_list) 469 { 470 } 471 472 void 473 operator() (const lldb::TypeImplSP& type) 474 { 475 m_type_list.Append(type); 476 } 477 478 private: 479 TypeListImpl &m_type_list; 480 }; 481 482 void 483 Append (const lldb_private::TypeList &type_list); 484 485 lldb::TypeImplSP 486 GetTypeAtIndex(size_t idx) 487 { 488 lldb::TypeImplSP type_sp; 489 if (idx < GetSize()) 490 type_sp = m_content[idx]; 491 return type_sp; 492 } 493 494 size_t 495 GetSize() 496 { 497 return m_content.size(); 498 } 499 500 private: 501 std::vector<lldb::TypeImplSP> m_content; 502 }; 503 504 class TypeMemberImpl 505 { 506 public: 507 TypeMemberImpl () : 508 m_type_impl_sp (), 509 m_bit_offset (0), 510 m_name (), 511 m_bitfield_bit_size (0), 512 m_is_bitfield (false) 513 514 { 515 } 516 517 TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp, 518 uint64_t bit_offset, 519 const ConstString &name, 520 uint32_t bitfield_bit_size = 0, 521 bool is_bitfield = false) : 522 m_type_impl_sp (type_impl_sp), 523 m_bit_offset (bit_offset), 524 m_name (name), 525 m_bitfield_bit_size (bitfield_bit_size), 526 m_is_bitfield (is_bitfield) 527 { 528 } 529 530 TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp, 531 uint64_t bit_offset): 532 m_type_impl_sp (type_impl_sp), 533 m_bit_offset (bit_offset), 534 m_name (), 535 m_bitfield_bit_size (0), 536 m_is_bitfield (false) 537 { 538 if (m_type_impl_sp) 539 m_name = m_type_impl_sp->GetName(); 540 } 541 542 const lldb::TypeImplSP & 543 GetTypeImpl () 544 { 545 return m_type_impl_sp; 546 } 547 548 const ConstString & 549 GetName () const 550 { 551 return m_name; 552 } 553 554 uint64_t 555 GetBitOffset () const 556 { 557 return m_bit_offset; 558 } 559 560 uint32_t 561 GetBitfieldBitSize () const 562 { 563 return m_bitfield_bit_size; 564 } 565 566 void 567 SetBitfieldBitSize (uint32_t bitfield_bit_size) 568 { 569 m_bitfield_bit_size = bitfield_bit_size; 570 } 571 572 bool 573 GetIsBitfield () const 574 { 575 return m_is_bitfield; 576 } 577 578 void 579 SetIsBitfield (bool is_bitfield) 580 { 581 m_is_bitfield = is_bitfield; 582 } 583 584 protected: 585 lldb::TypeImplSP m_type_impl_sp; 586 uint64_t m_bit_offset; 587 ConstString m_name; 588 uint32_t m_bitfield_bit_size; // Bit size for bitfield members only 589 bool m_is_bitfield; 590 }; 591 592 593 } // namespace lldb_private 594 595 #endif // liblldb_Type_h_ 596 597
