1/* 2 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. 3 * Copyright 2011-2013, Rene Gollent, rene@gollent.com. 4 * Distributed under the terms of the MIT License. 5 */ 6 7#include "DebugInfoEntries.h" 8 9#include <new> 10 11#include "AttributeValue.h" 12#include "Dwarf.h" 13#include "SourceLanguageInfo.h" 14 15 16// #pragma mark - DIECompileUnitBase 17 18 19DIECompileUnitBase::DIECompileUnitBase() 20 : 21 fName(NULL), 22 fCompilationDir(NULL), 23 fLowPC(0), 24 fHighPC(0), 25 fStatementListOffset(-1), 26 fMacroInfoOffset(-1), 27 fAddressRangesOffset(-1), 28 fBaseTypesUnit(NULL), 29 fLanguage(0), 30 fIdentifierCase(0), 31 fUseUTF8(true) 32{ 33} 34 35 36DIECompileUnitBase::~DIECompileUnitBase() 37{ 38} 39 40 41status_t 42DIECompileUnitBase::InitAfterAttributes(DebugInfoEntryInitInfo& info) 43{ 44 switch (fLanguage) { 45 case 0: 46 info.languageInfo = &kUnknownLanguageInfo; 47 return B_OK; 48 case DW_LANG_C89: 49 info.languageInfo = &kC89LanguageInfo; 50 return B_OK; 51 case DW_LANG_C: 52 info.languageInfo = &kCLanguageInfo; 53 return B_OK; 54 case DW_LANG_C_plus_plus: 55 info.languageInfo = &kCPlusPlusLanguageInfo; 56 return B_OK; 57 case DW_LANG_C99: 58 info.languageInfo = &kC99LanguageInfo; 59 return B_OK; 60 default: 61 info.languageInfo = &kUnsupportedLanguageInfo; 62 return B_OK; 63 } 64} 65 66 67const char* 68DIECompileUnitBase::Name() const 69{ 70 return fName; 71} 72 73 74status_t 75DIECompileUnitBase::AddChild(DebugInfoEntry* child) 76{ 77 if (child->IsType()) 78 fTypes.Add(child); 79 else 80 fOtherChildren.Add(child); 81 return B_OK; 82} 83 84 85status_t 86DIECompileUnitBase::AddAttribute_name(uint16 attributeName, 87 const AttributeValue& value) 88{ 89 fName = value.string; 90 return B_OK; 91} 92 93 94status_t 95DIECompileUnitBase::AddAttribute_comp_dir(uint16 attributeName, 96 const AttributeValue& value) 97{ 98 fCompilationDir = value.string; 99 return B_OK; 100} 101 102 103status_t 104DIECompileUnitBase::AddAttribute_low_pc(uint16 attributeName, 105 const AttributeValue& value) 106{ 107 fLowPC = value.address; 108 return B_OK; 109} 110 111 112status_t 113DIECompileUnitBase::AddAttribute_high_pc(uint16 attributeName, 114 const AttributeValue& value) 115{ 116 fHighPC = value.address; 117 return B_OK; 118} 119 120 121status_t 122DIECompileUnitBase::AddAttribute_producer(uint16 attributeName, 123 const AttributeValue& value) 124{ 125 // not interesting 126 return B_OK; 127} 128 129 130status_t 131DIECompileUnitBase::AddAttribute_stmt_list(uint16 attributeName, 132 const AttributeValue& value) 133{ 134 fStatementListOffset = value.pointer; 135 return B_OK; 136} 137 138 139status_t 140DIECompileUnitBase::AddAttribute_macro_info(uint16 attributeName, 141 const AttributeValue& value) 142{ 143 fMacroInfoOffset = value.pointer; 144 return B_OK; 145} 146 147 148status_t 149DIECompileUnitBase::AddAttribute_base_types(uint16 attributeName, 150 const AttributeValue& value) 151{ 152 fBaseTypesUnit = dynamic_cast<DIECompileUnitBase*>(value.reference); 153 return fBaseTypesUnit != NULL ? B_OK : B_BAD_DATA; 154} 155 156 157status_t 158DIECompileUnitBase::AddAttribute_language(uint16 attributeName, 159 const AttributeValue& value) 160{ 161 fLanguage = value.constant; 162 return B_OK; 163} 164 165 166status_t 167DIECompileUnitBase::AddAttribute_identifier_case(uint16 attributeName, 168 const AttributeValue& value) 169{ 170 fIdentifierCase = value.constant; 171 return B_OK; 172} 173 174 175status_t 176DIECompileUnitBase::AddAttribute_use_UTF8(uint16 attributeName, 177 const AttributeValue& value) 178{ 179 fUseUTF8 = value.flag; 180 return B_OK; 181} 182 183 184status_t 185DIECompileUnitBase::AddAttribute_ranges(uint16 attributeName, 186 const AttributeValue& value) 187{ 188 fAddressRangesOffset = value.pointer; 189 return B_OK; 190} 191 192 193// #pragma mark - DIEType 194 195 196DIEType::DIEType() 197 : 198 fName(NULL) 199{ 200 fAllocated.SetTo((uint64)0); 201 fAssociated.SetTo((uint64)0); 202} 203 204 205bool 206DIEType::IsType() const 207{ 208 return true; 209} 210 211 212const char* 213DIEType::Name() const 214{ 215 return fName; 216} 217 218 219bool 220DIEType::IsDeclaration() const 221{ 222 return false; 223} 224 225 226const DynamicAttributeValue* 227DIEType::ByteSize() const 228{ 229 return NULL; 230} 231 232 233status_t 234DIEType::AddAttribute_name(uint16 attributeName, 235 const AttributeValue& value) 236{ 237 fName = value.string; 238 return B_OK; 239} 240 241 242status_t 243DIEType::AddAttribute_allocated(uint16 attributeName, 244 const AttributeValue& value) 245{ 246 return SetDynamicAttributeValue(fAllocated, value); 247} 248 249 250status_t 251DIEType::AddAttribute_associated(uint16 attributeName, 252 const AttributeValue& value) 253{ 254 return SetDynamicAttributeValue(fAssociated, value); 255} 256 257 258// #pragma mark - DIEModifiedType 259 260 261DIEModifiedType::DIEModifiedType() 262 : 263 fType(NULL) 264{ 265} 266 267 268status_t 269DIEModifiedType::AddAttribute_type(uint16 attributeName, 270 const AttributeValue& value) 271{ 272 fType = dynamic_cast<DIEType*>(value.reference); 273 return fType != NULL ? B_OK : B_BAD_DATA; 274} 275 276 277// #pragma mark - DIEAddressingType 278 279 280DIEAddressingType::DIEAddressingType() 281 : 282 fAddressClass(0) 283{ 284} 285 286 287status_t 288DIEAddressingType::AddAttribute_address_class(uint16 attributeName, 289 const AttributeValue& value) 290{ 291// TODO: How is the address class handled? 292 fAddressClass = value.constant; 293 return B_OK; 294} 295 296 297// #pragma mark - DIEDeclaredType 298 299 300DIEDeclaredType::DIEDeclaredType() 301 : 302 fDescription(NULL), 303 fAbstractOrigin(NULL), 304 fAccessibility(0), 305 fDeclaration(false) 306{ 307} 308 309 310const char* 311DIEDeclaredType::Description() const 312{ 313 return fDescription; 314} 315 316 317DebugInfoEntry* 318DIEDeclaredType::AbstractOrigin() const 319{ 320 return fAbstractOrigin; 321} 322 323 324bool 325DIEDeclaredType::IsDeclaration() const 326{ 327 return fDeclaration; 328} 329 330 331status_t 332DIEDeclaredType::AddAttribute_accessibility(uint16 attributeName, 333 const AttributeValue& value) 334{ 335 fAccessibility = value.constant; 336 return B_OK; 337} 338 339 340status_t 341DIEDeclaredType::AddAttribute_declaration(uint16 attributeName, 342 const AttributeValue& value) 343{ 344 fDeclaration = value.flag; 345 return B_OK; 346} 347 348 349status_t 350DIEDeclaredType::AddAttribute_description(uint16 attributeName, 351 const AttributeValue& value) 352{ 353 fDescription = value.string; 354 return B_OK; 355} 356 357 358status_t 359DIEDeclaredType::AddAttribute_abstract_origin(uint16 attributeName, 360 const AttributeValue& value) 361{ 362 fAbstractOrigin = value.reference; 363 return B_OK; 364} 365 366 367DeclarationLocation* 368DIEDeclaredType::GetDeclarationLocation() 369{ 370 return &fDeclarationLocation; 371} 372 373 374// #pragma mark - DIEDerivedType 375 376 377DIEDerivedType::DIEDerivedType() 378 : 379 fType(NULL) 380{ 381} 382 383 384status_t 385DIEDerivedType::AddAttribute_type(uint16 attributeName, 386 const AttributeValue& value) 387{ 388 fType = dynamic_cast<DIEType*>(value.reference); 389 return fType != NULL ? B_OK : B_BAD_DATA; 390} 391 392 393 394 395// #pragma mark - DIECompoundType 396 397 398DIECompoundType::DIECompoundType() 399 : 400 fSpecification(NULL) 401{ 402} 403 404 405bool 406DIECompoundType::IsNamespace() const 407{ 408 return true; 409} 410 411 412DebugInfoEntry* 413DIECompoundType::Specification() const 414{ 415 return fSpecification; 416} 417 418 419const DynamicAttributeValue* 420DIECompoundType::ByteSize() const 421{ 422 return &fByteSize; 423} 424 425 426status_t 427DIECompoundType::AddChild(DebugInfoEntry* child) 428{ 429 if (child->Tag() == DW_TAG_member) { 430 // TODO: Not for interfaces! 431 fDataMembers.Add(child); 432 return B_OK; 433 } 434 435 return DIEDeclaredType::AddChild(child); 436} 437 438 439status_t 440DIECompoundType::AddAttribute_byte_size(uint16 attributeName, 441 const AttributeValue& value) 442{ 443 return SetDynamicAttributeValue(fByteSize, value); 444} 445 446 447status_t 448DIECompoundType::AddAttribute_specification(uint16 attributeName, 449 const AttributeValue& value) 450{ 451 fSpecification = dynamic_cast<DIECompoundType*>(value.reference); 452 return fSpecification != NULL ? B_OK : B_BAD_DATA; 453} 454 455 456// #pragma mark - DIEClassBaseType 457 458 459DIEClassBaseType::DIEClassBaseType() 460{ 461} 462 463 464status_t 465DIEClassBaseType::AddChild(DebugInfoEntry* child) 466{ 467 switch (child->Tag()) { 468 case DW_TAG_inheritance: 469 fBaseTypes.Add(child); 470 return B_OK; 471 case DW_TAG_friend: 472 fFriends.Add(child); 473 return B_OK; 474 case DW_TAG_access_declaration: 475 fAccessDeclarations.Add(child); 476 return B_OK; 477 case DW_TAG_subprogram: 478 fMemberFunctions.Add(child); 479 return B_OK; 480 case DW_TAG_template_type_parameter: 481 case DW_TAG_template_value_parameter: 482 fTemplateParameters.Add(child); 483 return B_OK; 484// TODO: Variants! 485 default: 486 { 487 if (child->IsType()) { 488 fInnerTypes.Add(child); 489 return B_OK; 490 } 491 492 return DIECompoundType::AddChild(child); 493 } 494 } 495} 496 497 498// #pragma mark - DIENamedBase 499 500 501DIENamedBase::DIENamedBase() 502 : 503 fName(NULL), 504 fDescription(NULL) 505{ 506} 507 508 509const char* 510DIENamedBase::Name() const 511{ 512 return fName; 513} 514 515 516const char* 517DIENamedBase::Description() const 518{ 519 return fDescription; 520} 521 522 523status_t 524DIENamedBase::AddAttribute_name(uint16 attributeName, 525 const AttributeValue& value) 526{ 527 fName = value.string; 528 return B_OK; 529} 530 531 532status_t 533DIENamedBase::AddAttribute_description(uint16 attributeName, 534 const AttributeValue& value) 535{ 536 fDescription = value.string; 537 return B_OK; 538} 539 540 541// #pragma mark - DIEDeclaredBase 542 543 544DIEDeclaredBase::DIEDeclaredBase() 545{ 546} 547 548 549DeclarationLocation* 550DIEDeclaredBase::GetDeclarationLocation() 551{ 552 return &fDeclarationLocation; 553} 554 555 556// #pragma mark - DIEDeclaredNamedBase 557 558 559DIEDeclaredNamedBase::DIEDeclaredNamedBase() 560 : 561 fName(NULL), 562 fDescription(NULL), 563 fAccessibility(0), 564 fVisibility(0), 565 fDeclaration(false) 566{ 567} 568 569 570const char* 571DIEDeclaredNamedBase::Name() const 572{ 573 return fName; 574} 575 576 577const char* 578DIEDeclaredNamedBase::Description() const 579{ 580 return fDescription; 581} 582 583 584bool 585DIEDeclaredNamedBase::IsDeclaration() const 586{ 587 return fDeclaration; 588} 589 590 591status_t 592DIEDeclaredNamedBase::AddAttribute_name(uint16 attributeName, 593 const AttributeValue& value) 594{ 595 fName = value.string; 596 return B_OK; 597} 598 599 600status_t 601DIEDeclaredNamedBase::AddAttribute_description(uint16 attributeName, 602 const AttributeValue& value) 603{ 604 fDescription = value.string; 605 return B_OK; 606} 607 608 609status_t 610DIEDeclaredNamedBase::AddAttribute_accessibility(uint16 attributeName, 611 const AttributeValue& value) 612{ 613 fAccessibility = value.constant; 614 return B_OK; 615} 616 617 618status_t 619DIEDeclaredNamedBase::AddAttribute_declaration(uint16 attributeName, 620 const AttributeValue& value) 621{ 622 fDeclaration = value.flag; 623 return B_OK; 624} 625 626 627// #pragma mark - DIEArrayIndexType 628 629 630DIEArrayIndexType::DIEArrayIndexType() 631{ 632} 633 634 635const DynamicAttributeValue* 636DIEArrayIndexType::ByteSize() const 637{ 638 return &fByteSize; 639} 640 641 642status_t 643DIEArrayIndexType::AddAttribute_bit_stride(uint16 attributeName, 644 const AttributeValue& value) 645{ 646 return SetDynamicAttributeValue(fBitStride, value); 647} 648 649 650status_t 651DIEArrayIndexType::AddAttribute_byte_size(uint16 attributeName, 652 const AttributeValue& value) 653{ 654 return SetDynamicAttributeValue(fByteSize, value); 655} 656 657 658status_t 659DIEArrayIndexType::AddAttribute_byte_stride(uint16 attributeName, 660 const AttributeValue& value) 661{ 662 return SetDynamicAttributeValue(fByteStride, value); 663} 664 665 666// #pragma mark - DIEArrayType 667 668 669DIEArrayType::DIEArrayType() 670 : 671 fSpecification(NULL), 672 fOrdering(DW_ORD_row_major) 673{ 674} 675 676 677uint16 678DIEArrayType::Tag() const 679{ 680 return DW_TAG_array_type; 681} 682 683 684status_t 685DIEArrayType::InitAfterHierarchy(DebugInfoEntryInitInfo& info) 686{ 687 fOrdering = info.languageInfo->arrayOrdering; 688 return B_OK; 689} 690 691 692DebugInfoEntry* 693DIEArrayType::Specification() const 694{ 695 return fSpecification; 696} 697 698 699const DynamicAttributeValue* 700DIEArrayType::ByteSize() const 701{ 702 return &fByteSize; 703} 704 705 706status_t 707DIEArrayType::AddChild(DebugInfoEntry* child) 708{ 709 // a dimension child must be of subrange or enumeration type 710 uint16 tag = child->Tag(); 711 if (tag == DW_TAG_subrange_type || tag == DW_TAG_enumeration_type) { 712 fDimensions.Add(child); 713 return B_OK; 714 } 715 716 return DIEDerivedType::AddChild(child); 717} 718 719 720status_t 721DIEArrayType::AddAttribute_ordering(uint16 attributeName, 722 const AttributeValue& value) 723{ 724 fOrdering = value.constant; 725 return B_OK; 726} 727 728 729status_t 730DIEArrayType::AddAttribute_bit_stride(uint16 attributeName, 731 const AttributeValue& value) 732{ 733 return SetDynamicAttributeValue(fBitStride, value); 734} 735 736 737status_t 738DIEArrayType::AddAttribute_stride_size(uint16 attributeName, 739 const AttributeValue& value) 740{ 741 return SetDynamicAttributeValue(fBitStride, value); 742} 743 744 745status_t 746DIEArrayType::AddAttribute_byte_size(uint16 attributeName, 747 const AttributeValue& value) 748{ 749 return SetDynamicAttributeValue(fByteSize, value); 750} 751 752 753status_t 754DIEArrayType::AddAttribute_specification(uint16 attributeName, 755 const AttributeValue& value) 756{ 757 fSpecification = dynamic_cast<DIEArrayType*>(value.reference); 758 return fSpecification != NULL ? B_OK : B_BAD_DATA; 759} 760 761 762// #pragma mark - DIEClassType 763 764 765DIEClassType::DIEClassType() 766{ 767} 768 769 770uint16 771DIEClassType::Tag() const 772{ 773 return DW_TAG_class_type; 774} 775 776 777// #pragma mark - DIEEntryPoint 778 779 780DIEEntryPoint::DIEEntryPoint() 781{ 782} 783 784 785uint16 786DIEEntryPoint::Tag() const 787{ 788 return DW_TAG_entry_point; 789} 790 791 792// #pragma mark - DIEEnumerationType 793 794 795DIEEnumerationType::DIEEnumerationType() 796 : 797 fSpecification(NULL) 798{ 799} 800 801 802uint16 803DIEEnumerationType::Tag() const 804{ 805 return DW_TAG_enumeration_type; 806} 807 808 809DebugInfoEntry* 810DIEEnumerationType::Specification() const 811{ 812 return fSpecification; 813} 814 815 816status_t 817DIEEnumerationType::AddChild(DebugInfoEntry* child) 818{ 819 if (child->Tag() == DW_TAG_enumerator) { 820 fEnumerators.Add(child); 821 return B_OK; 822 } 823 824 return DIEDerivedType::AddChild(child); 825} 826 827 828status_t 829DIEEnumerationType::AddAttribute_specification(uint16 attributeName, 830 const AttributeValue& value) 831{ 832 fSpecification = dynamic_cast<DIEEnumerationType*>(value.reference); 833 return fSpecification != NULL ? B_OK : B_BAD_DATA; 834} 835 836 837// #pragma mark - DIEFormalParameter 838 839 840DIEFormalParameter::DIEFormalParameter() 841 : 842 fAbstractOrigin(NULL), 843 fType(NULL), 844 fArtificial(false) 845{ 846} 847 848 849uint16 850DIEFormalParameter::Tag() const 851{ 852 return DW_TAG_formal_parameter; 853} 854 855 856DebugInfoEntry* 857DIEFormalParameter::AbstractOrigin() const 858{ 859 return fAbstractOrigin; 860} 861 862 863LocationDescription* 864DIEFormalParameter::GetLocationDescription() 865{ 866 return &fLocationDescription; 867} 868 869 870status_t 871DIEFormalParameter::AddAttribute_abstract_origin(uint16 attributeName, 872 const AttributeValue& value) 873{ 874 fAbstractOrigin = value.reference; 875 return B_OK; 876} 877 878 879status_t 880DIEFormalParameter::AddAttribute_artificial(uint16 attributeName, 881 const AttributeValue& value) 882{ 883 fArtificial = value.flag; 884 return B_OK; 885} 886 887 888status_t 889DIEFormalParameter::AddAttribute_const_value(uint16 attributeName, 890 const AttributeValue& value) 891{ 892 return SetConstantAttributeValue(fValue, value); 893} 894 895 896status_t 897DIEFormalParameter::AddAttribute_type(uint16 attributeName, 898 const AttributeValue& value) 899{ 900 fType = dynamic_cast<DIEType*>(value.reference); 901 return fType != NULL ? B_OK : B_BAD_DATA; 902} 903 904 905// #pragma mark - DIEImportedDeclaration 906 907 908DIEImportedDeclaration::DIEImportedDeclaration() 909{ 910} 911 912 913uint16 914DIEImportedDeclaration::Tag() const 915{ 916 return DW_TAG_imported_declaration; 917} 918 919 920// #pragma mark - DIELabel 921 922 923DIELabel::DIELabel() 924{ 925} 926 927 928uint16 929DIELabel::Tag() const 930{ 931 return DW_TAG_label; 932} 933 934 935// #pragma mark - DIELexicalBlock 936 937 938DIELexicalBlock::DIELexicalBlock() 939 : 940 fLowPC(0), 941 fHighPC(0), 942 fAddressRangesOffset(-1), 943 fAbstractOrigin(NULL) 944{ 945} 946 947 948uint16 949DIELexicalBlock::Tag() const 950{ 951 return DW_TAG_lexical_block; 952} 953 954 955DebugInfoEntry* 956DIELexicalBlock::AbstractOrigin() const 957{ 958 return fAbstractOrigin; 959} 960 961 962status_t 963DIELexicalBlock::AddChild(DebugInfoEntry* child) 964{ 965 switch (child->Tag()) { 966 case DW_TAG_variable: 967 fVariables.Add(child); 968 return B_OK; 969 case DW_TAG_lexical_block: 970 fBlocks.Add(child); 971 return B_OK; 972 default: 973 return DIENamedBase::AddChild(child); 974 } 975} 976 977 978status_t 979DIELexicalBlock::AddAttribute_low_pc(uint16 attributeName, 980 const AttributeValue& value) 981{ 982 fLowPC = value.address; 983 return B_OK; 984} 985 986 987status_t 988DIELexicalBlock::AddAttribute_high_pc(uint16 attributeName, 989 const AttributeValue& value) 990{ 991 fHighPC = value.address; 992 return B_OK; 993} 994 995 996status_t 997DIELexicalBlock::AddAttribute_ranges(uint16 attributeName, 998 const AttributeValue& value) 999{ 1000 fAddressRangesOffset = value.pointer; 1001 return B_OK; 1002} 1003 1004 1005status_t 1006DIELexicalBlock::AddAttribute_abstract_origin(uint16 attributeName, 1007 const AttributeValue& value) 1008{ 1009 fAbstractOrigin = dynamic_cast<DIELexicalBlock*>(value.reference); 1010 return fAbstractOrigin != NULL ? B_OK : B_BAD_DATA; 1011} 1012 1013 1014// #pragma mark - DIEMember 1015 1016 1017DIEMember::DIEMember() 1018 : 1019 fType(NULL) 1020{ 1021} 1022 1023 1024uint16 1025DIEMember::Tag() const 1026{ 1027 return DW_TAG_member; 1028} 1029 1030 1031status_t 1032DIEMember::AddAttribute_type(uint16 attributeName, 1033 const AttributeValue& value) 1034{ 1035 fType = dynamic_cast<DIEType*>(value.reference); 1036 return fType != NULL ? B_OK : B_BAD_DATA; 1037} 1038 1039 1040status_t 1041DIEMember::AddAttribute_byte_size(uint16 attributeName, 1042 const AttributeValue& value) 1043{ 1044 return SetDynamicAttributeValue(fByteSize, value); 1045} 1046 1047 1048status_t 1049DIEMember::AddAttribute_bit_size(uint16 attributeName, 1050 const AttributeValue& value) 1051{ 1052 return SetDynamicAttributeValue(fBitSize, value); 1053} 1054 1055 1056status_t 1057DIEMember::AddAttribute_data_member_location(uint16 attributeName, 1058 const AttributeValue& value) 1059{ 1060 return SetMemberLocation(fLocation, value); 1061} 1062 1063 1064status_t 1065DIEMember::AddAttribute_bit_offset(uint16 attributeName, 1066 const AttributeValue& value) 1067{ 1068 return SetDynamicAttributeValue(fBitOffset, value); 1069} 1070 1071 1072// #pragma mark - DIEPointerType 1073 1074 1075DIEPointerType::DIEPointerType() 1076 : 1077 fSpecification(NULL) 1078{ 1079} 1080 1081 1082uint16 1083DIEPointerType::Tag() const 1084{ 1085 return DW_TAG_pointer_type; 1086} 1087 1088 1089DebugInfoEntry* 1090DIEPointerType::Specification() const 1091{ 1092 return fSpecification; 1093} 1094 1095 1096status_t 1097DIEPointerType::AddAttribute_specification(uint16 attributeName, 1098 const AttributeValue& value) 1099{ 1100 fSpecification = dynamic_cast<DIEPointerType*>(value.reference); 1101 return fSpecification != NULL ? B_OK : B_BAD_DATA; 1102} 1103 1104 1105// #pragma mark - DIEReferenceType 1106 1107 1108DIEReferenceType::DIEReferenceType() 1109{ 1110} 1111 1112 1113uint16 1114DIEReferenceType::Tag() const 1115{ 1116 return DW_TAG_reference_type; 1117} 1118 1119 1120// #pragma mark - DIECompileUnit 1121 1122 1123DIECompileUnit::DIECompileUnit() 1124{ 1125} 1126 1127 1128uint16 1129DIECompileUnit::Tag() const 1130{ 1131 return DW_TAG_compile_unit; 1132} 1133 1134 1135// #pragma mark - DIEStringType 1136 1137 1138DIEStringType::DIEStringType() 1139{ 1140} 1141 1142 1143uint16 1144DIEStringType::Tag() const 1145{ 1146 return DW_TAG_string_type; 1147} 1148 1149 1150const DynamicAttributeValue* 1151DIEStringType::ByteSize() const 1152{ 1153 return &fByteSize; 1154} 1155 1156 1157status_t 1158DIEStringType::AddAttribute_byte_size(uint16 attributeName, 1159 const AttributeValue& value) 1160{ 1161 return SetDynamicAttributeValue(fByteSize, value); 1162} 1163 1164 1165// #pragma mark - DIEStructureType 1166 1167 1168DIEStructureType::DIEStructureType() 1169{ 1170} 1171 1172 1173uint16 1174DIEStructureType::Tag() const 1175{ 1176 return DW_TAG_structure_type; 1177} 1178 1179 1180// #pragma mark - DIESubroutineType 1181 1182 1183DIESubroutineType::DIESubroutineType() 1184 : 1185 fReturnType(NULL), 1186 fAddressClass(0), 1187 fPrototyped(false) 1188{ 1189} 1190 1191 1192uint16 1193DIESubroutineType::Tag() const 1194{ 1195 return DW_TAG_subroutine_type; 1196} 1197 1198 1199status_t 1200DIESubroutineType::AddChild(DebugInfoEntry* child) 1201{ 1202 switch (child->Tag()) { 1203 case DW_TAG_formal_parameter: 1204 case DW_TAG_unspecified_parameters: 1205 fParameters.Add(child); 1206 return B_OK; 1207 default: 1208 return DIEDeclaredType::AddChild(child); 1209 } 1210} 1211 1212 1213status_t 1214DIESubroutineType::AddAttribute_address_class(uint16 attributeName, 1215 const AttributeValue& value) 1216{ 1217// TODO: How is the address class handled? 1218 fAddressClass = value.constant; 1219 return B_OK; 1220} 1221 1222 1223status_t 1224DIESubroutineType::AddAttribute_prototyped(uint16 attributeName, 1225 const AttributeValue& value) 1226{ 1227 fPrototyped = value.flag; 1228 return B_OK; 1229} 1230 1231 1232status_t 1233DIESubroutineType::AddAttribute_type(uint16 attributeName, 1234 const AttributeValue& value) 1235{ 1236 fReturnType = dynamic_cast<DIEType*>(value.reference); 1237 return fReturnType != NULL ? B_OK : B_BAD_DATA; 1238} 1239 1240 1241// #pragma mark - DIETypedef 1242 1243 1244DIETypedef::DIETypedef() 1245{ 1246} 1247 1248 1249uint16 1250DIETypedef::Tag() const 1251{ 1252 return DW_TAG_typedef; 1253} 1254 1255 1256// #pragma mark - DIEUnionType 1257 1258 1259DIEUnionType::DIEUnionType() 1260{ 1261} 1262 1263 1264uint16 1265DIEUnionType::Tag() const 1266{ 1267 return DW_TAG_union_type; 1268} 1269 1270 1271// #pragma mark - DIEUnspecifiedParameters 1272 1273 1274DIEUnspecifiedParameters::DIEUnspecifiedParameters() 1275{ 1276} 1277 1278 1279uint16 1280DIEUnspecifiedParameters::Tag() const 1281{ 1282 return DW_TAG_unspecified_parameters; 1283} 1284 1285 1286// #pragma mark - DIEVariant 1287 1288 1289DIEVariant::DIEVariant() 1290{ 1291} 1292 1293 1294uint16 1295DIEVariant::Tag() const 1296{ 1297 return DW_TAG_variant; 1298} 1299 1300 1301// #pragma mark - DIECommonBlock 1302 1303 1304DIECommonBlock::DIECommonBlock() 1305{ 1306} 1307 1308 1309uint16 1310DIECommonBlock::Tag() const 1311{ 1312 return DW_TAG_common_block; 1313} 1314 1315 1316LocationDescription* 1317DIECommonBlock::GetLocationDescription() 1318{ 1319 return &fLocationDescription; 1320} 1321 1322 1323// #pragma mark - DIECommonInclusion 1324 1325 1326DIECommonInclusion::DIECommonInclusion() 1327{ 1328} 1329 1330 1331uint16 1332DIECommonInclusion::Tag() const 1333{ 1334 return DW_TAG_common_inclusion; 1335} 1336 1337 1338// #pragma mark - DIEInheritance 1339 1340 1341DIEInheritance::DIEInheritance() 1342 : 1343 fType(NULL) 1344{ 1345} 1346 1347 1348uint16 1349DIEInheritance::Tag() const 1350{ 1351 return DW_TAG_inheritance; 1352} 1353 1354 1355status_t 1356DIEInheritance::AddAttribute_type(uint16 attributeName, 1357 const AttributeValue& value) 1358{ 1359 fType = dynamic_cast<DIEType*>(value.reference); 1360 return fType != NULL ? B_OK : B_BAD_DATA; 1361} 1362 1363 1364status_t 1365DIEInheritance::AddAttribute_data_member_location(uint16 attributeName, 1366 const AttributeValue& value) 1367{ 1368 return SetMemberLocation(fLocation, value); 1369} 1370 1371 1372// #pragma mark - DIEInlinedSubroutine 1373 1374 1375DIEInlinedSubroutine::DIEInlinedSubroutine() 1376{ 1377} 1378 1379 1380uint16 1381DIEInlinedSubroutine::Tag() const 1382{ 1383 return DW_TAG_inlined_subroutine; 1384} 1385 1386 1387// #pragma mark - DIEModule 1388 1389 1390DIEModule::DIEModule() 1391{ 1392} 1393 1394 1395uint16 1396DIEModule::Tag() const 1397{ 1398 return DW_TAG_module; 1399} 1400 1401 1402// #pragma mark - DIEPointerToMemberType 1403 1404 1405DIEPointerToMemberType::DIEPointerToMemberType() 1406 : 1407 fContainingType(NULL), 1408 fAddressClass(0) 1409{ 1410} 1411 1412 1413uint16 1414DIEPointerToMemberType::Tag() const 1415{ 1416 return DW_TAG_ptr_to_member_type; 1417} 1418 1419 1420status_t 1421DIEPointerToMemberType::AddAttribute_address_class(uint16 attributeName, 1422 const AttributeValue& value) 1423{ 1424// TODO: How is the address class handled? 1425 fAddressClass = value.constant; 1426 return B_OK; 1427} 1428 1429 1430status_t 1431DIEPointerToMemberType::AddAttribute_containing_type(uint16 attributeName, 1432 const AttributeValue& value) 1433{ 1434 fContainingType = dynamic_cast<DIECompoundType*>(value.reference); 1435 return fContainingType != NULL ? B_OK : B_BAD_DATA; 1436} 1437 1438 1439status_t 1440DIEPointerToMemberType::AddAttribute_use_location(uint16 attributeName, 1441 const AttributeValue& value) 1442{ 1443 if (value.attributeClass == ATTRIBUTE_CLASS_LOCLISTPTR) { 1444 fUseLocation.SetToLocationList(value.pointer); 1445 return B_OK; 1446 } 1447 1448 if (value.attributeClass == ATTRIBUTE_CLASS_BLOCK) { 1449 fUseLocation.SetToExpression(value.block.data, value.block.length); 1450 return B_OK; 1451 } 1452 1453 return B_BAD_DATA; 1454} 1455 1456 1457// #pragma mark - DIESetType 1458 1459 1460DIESetType::DIESetType() 1461{ 1462} 1463 1464 1465uint16 1466DIESetType::Tag() const 1467{ 1468 return DW_TAG_set_type; 1469} 1470 1471 1472const DynamicAttributeValue* 1473DIESetType::ByteSize() const 1474{ 1475 return &fByteSize; 1476} 1477 1478 1479status_t 1480DIESetType::AddAttribute_byte_size(uint16 attributeName, 1481 const AttributeValue& value) 1482{ 1483 return SetDynamicAttributeValue(fByteSize, value); 1484} 1485 1486 1487// #pragma mark - DIESubrangeType 1488 1489 1490DIESubrangeType::DIESubrangeType() 1491 : 1492 fThreadsScaled(false) 1493{ 1494} 1495 1496 1497uint16 1498DIESubrangeType::Tag() const 1499{ 1500 return DW_TAG_subrange_type; 1501} 1502 1503 1504status_t 1505DIESubrangeType::AddAttribute_count(uint16 attributeName, 1506 const AttributeValue& value) 1507{ 1508 return SetDynamicAttributeValue(fCount, value); 1509} 1510 1511 1512status_t 1513DIESubrangeType::AddAttribute_lower_bound(uint16 attributeName, 1514 const AttributeValue& value) 1515{ 1516 return SetDynamicAttributeValue(fLowerBound, value); 1517} 1518 1519 1520status_t 1521DIESubrangeType::AddAttribute_upper_bound(uint16 attributeName, 1522 const AttributeValue& value) 1523{ 1524 return SetDynamicAttributeValue(fUpperBound, value); 1525} 1526 1527 1528status_t 1529DIESubrangeType::AddAttribute_threads_scaled(uint16 attributeName, 1530 const AttributeValue& value) 1531{ 1532 fThreadsScaled = value.flag; 1533 return B_OK; 1534} 1535 1536 1537// #pragma mark - DIEWithStatement 1538 1539 1540DIEWithStatement::DIEWithStatement() 1541 : 1542 fType(NULL) 1543{ 1544} 1545 1546 1547uint16 1548DIEWithStatement::Tag() const 1549{ 1550 return DW_TAG_with_stmt; 1551} 1552 1553 1554LocationDescription* 1555DIEWithStatement::GetLocationDescription() 1556{ 1557 return &fLocationDescription; 1558} 1559 1560 1561status_t 1562DIEWithStatement::AddAttribute_type(uint16 attributeName, 1563 const AttributeValue& value) 1564{ 1565 fType = dynamic_cast<DIEType*>(value.reference); 1566 return fType != NULL ? B_OK : B_BAD_DATA; 1567} 1568 1569 1570// #pragma mark - DIEAccessDeclaration 1571 1572 1573DIEAccessDeclaration::DIEAccessDeclaration() 1574{ 1575} 1576 1577 1578uint16 1579DIEAccessDeclaration::Tag() const 1580{ 1581 return DW_TAG_access_declaration; 1582} 1583 1584 1585// #pragma mark - DIEBaseType 1586 1587 1588DIEBaseType::DIEBaseType() 1589 : 1590 fEncoding(0), 1591 fEndianity(0) 1592{ 1593} 1594 1595 1596uint16 1597DIEBaseType::Tag() const 1598{ 1599 return DW_TAG_base_type; 1600} 1601 1602 1603const DynamicAttributeValue* 1604DIEBaseType::ByteSize() const 1605{ 1606 return &fByteSize; 1607} 1608 1609 1610status_t 1611DIEBaseType::AddAttribute_encoding(uint16 attributeName, 1612 const AttributeValue& value) 1613{ 1614 fEncoding = value.constant; 1615 return B_OK; 1616} 1617 1618 1619status_t 1620DIEBaseType::AddAttribute_byte_size(uint16 attributeName, 1621 const AttributeValue& value) 1622{ 1623 return SetDynamicAttributeValue(fByteSize, value); 1624} 1625 1626 1627status_t 1628DIEBaseType::AddAttribute_bit_size(uint16 attributeName, 1629 const AttributeValue& value) 1630{ 1631 return SetDynamicAttributeValue(fBitSize, value); 1632} 1633 1634 1635status_t 1636DIEBaseType::AddAttribute_bit_offset(uint16 attributeName, 1637 const AttributeValue& value) 1638{ 1639 return SetDynamicAttributeValue(fBitOffset, value); 1640} 1641 1642 1643status_t 1644DIEBaseType::AddAttribute_endianity(uint16 attributeName, 1645 const AttributeValue& value) 1646{ 1647 fEndianity = value.constant; 1648 return B_OK; 1649} 1650 1651 1652// #pragma mark - DIECatchBlock 1653 1654 1655DIECatchBlock::DIECatchBlock() 1656{ 1657} 1658 1659 1660uint16 1661DIECatchBlock::Tag() const 1662{ 1663 return DW_TAG_catch_block; 1664} 1665 1666 1667// #pragma mark - DIEConstType 1668 1669 1670DIEConstType::DIEConstType() 1671{ 1672} 1673 1674 1675uint16 1676DIEConstType::Tag() const 1677{ 1678 return DW_TAG_const_type; 1679} 1680 1681 1682// #pragma mark - DIEConstant 1683 1684 1685DIEConstant::DIEConstant() 1686 : 1687 fType(NULL) 1688{ 1689} 1690 1691 1692uint16 1693DIEConstant::Tag() const 1694{ 1695 return DW_TAG_constant; 1696} 1697 1698 1699status_t 1700DIEConstant::AddAttribute_const_value(uint16 attributeName, 1701 const AttributeValue& value) 1702{ 1703 return SetConstantAttributeValue(fValue, value); 1704} 1705 1706 1707status_t 1708DIEConstant::AddAttribute_type(uint16 attributeName, 1709 const AttributeValue& value) 1710{ 1711 fType = dynamic_cast<DIEType*>(value.reference); 1712 return fType != NULL ? B_OK : B_BAD_DATA; 1713} 1714 1715 1716// #pragma mark - DIEEnumerator 1717 1718 1719DIEEnumerator::DIEEnumerator() 1720{ 1721} 1722 1723 1724uint16 1725DIEEnumerator::Tag() const 1726{ 1727 return DW_TAG_enumerator; 1728} 1729 1730 1731status_t 1732DIEEnumerator::AddAttribute_const_value(uint16 attributeName, 1733 const AttributeValue& value) 1734{ 1735 return SetConstantAttributeValue(fValue, value); 1736} 1737 1738 1739// #pragma mark - DIEFileType 1740 1741 1742DIEFileType::DIEFileType() 1743{ 1744} 1745 1746 1747uint16 1748DIEFileType::Tag() const 1749{ 1750 return DW_TAG_file_type; 1751} 1752 1753 1754const DynamicAttributeValue* 1755DIEFileType::ByteSize() const 1756{ 1757 return &fByteSize; 1758} 1759 1760 1761status_t 1762DIEFileType::AddAttribute_byte_size(uint16 attributeName, 1763 const AttributeValue& value) 1764{ 1765 return SetDynamicAttributeValue(fByteSize, value); 1766} 1767 1768 1769// #pragma mark - DIEFriend 1770 1771 1772DIEFriend::DIEFriend() 1773{ 1774} 1775 1776 1777uint16 1778DIEFriend::Tag() const 1779{ 1780 return DW_TAG_friend; 1781} 1782 1783 1784// #pragma mark - DIENameList 1785 1786 1787DIENameList::DIENameList() 1788{ 1789} 1790 1791 1792uint16 1793DIENameList::Tag() const 1794{ 1795 return DW_TAG_namelist; 1796} 1797 1798 1799// #pragma mark - DIENameListItem 1800 1801 1802DIENameListItem::DIENameListItem() 1803{ 1804} 1805 1806 1807uint16 1808DIENameListItem::Tag() const 1809{ 1810 return DW_TAG_namelist_item; 1811} 1812 1813 1814// #pragma mark - DIEPackedType 1815 1816 1817DIEPackedType::DIEPackedType() 1818{ 1819} 1820 1821 1822uint16 1823DIEPackedType::Tag() const 1824{ 1825 return DW_TAG_packed_type; 1826} 1827 1828 1829// #pragma mark - DIESubprogram 1830 1831 1832DIESubprogram::DIESubprogram() 1833 : 1834 fLowPC(0), 1835 fHighPC(0), 1836 fAddressRangesOffset(-1), 1837 fSpecification(NULL), 1838 fAbstractOrigin(NULL), 1839 fReturnType(NULL), 1840 fAddressClass(0), 1841 fPrototyped(false), 1842 fInline(DW_INL_not_inlined), 1843 fArtificial(false), 1844 fCallingConvention(DW_CC_normal) 1845{ 1846} 1847 1848 1849DIESubprogram::~DIESubprogram() 1850{ 1851} 1852 1853 1854uint16 1855DIESubprogram::Tag() const 1856{ 1857 return DW_TAG_subprogram; 1858} 1859 1860 1861DebugInfoEntry* 1862DIESubprogram::Specification() const 1863{ 1864 return fSpecification; 1865} 1866 1867 1868 1869DebugInfoEntry* 1870DIESubprogram::AbstractOrigin() const 1871{ 1872 return fAbstractOrigin; 1873} 1874 1875 1876status_t 1877DIESubprogram::AddChild(DebugInfoEntry* child) 1878{ 1879 switch (child->Tag()) { 1880 case DW_TAG_formal_parameter: 1881 case DW_TAG_unspecified_parameters: 1882 fParameters.Add(child); 1883 return B_OK; 1884 case DW_TAG_variable: 1885 fVariables.Add(child); 1886 return B_OK; 1887 case DW_TAG_lexical_block: 1888 fBlocks.Add(child); 1889 return B_OK; 1890 case DW_TAG_template_type_parameter: 1891 fTemplateTypeParameters.Add(child); 1892 return B_OK; 1893 case DW_TAG_template_value_parameter: 1894 fTemplateValueParameters.Add(child); 1895 return B_OK; 1896 default: 1897 return DIEDeclaredNamedBase::AddChild(child); 1898 } 1899} 1900 1901 1902status_t 1903DIESubprogram::AddAttribute_low_pc(uint16 attributeName, 1904 const AttributeValue& value) 1905{ 1906 fLowPC = value.address; 1907 return B_OK; 1908} 1909 1910 1911status_t 1912DIESubprogram::AddAttribute_high_pc(uint16 attributeName, 1913 const AttributeValue& value) 1914{ 1915 fHighPC = value.address; 1916 return B_OK; 1917} 1918 1919 1920status_t 1921DIESubprogram::AddAttribute_ranges(uint16 attributeName, 1922 const AttributeValue& value) 1923{ 1924 fAddressRangesOffset = value.pointer; 1925 return B_OK; 1926} 1927 1928 1929status_t 1930DIESubprogram::AddAttribute_specification(uint16 attributeName, 1931 const AttributeValue& value) 1932{ 1933 fSpecification = dynamic_cast<DIESubprogram*>(value.reference); 1934 return fSpecification != NULL ? B_OK : B_BAD_DATA; 1935} 1936 1937 1938status_t 1939DIESubprogram::AddAttribute_address_class(uint16 attributeName, 1940 const AttributeValue& value) 1941{ 1942// TODO: How is the address class handled? 1943 fAddressClass = value.constant; 1944 return B_OK; 1945} 1946 1947 1948status_t 1949DIESubprogram::AddAttribute_prototyped(uint16 attributeName, 1950 const AttributeValue& value) 1951{ 1952 fPrototyped = value.flag; 1953 return B_OK; 1954} 1955 1956 1957status_t 1958DIESubprogram::AddAttribute_type(uint16 attributeName, 1959 const AttributeValue& value) 1960{ 1961 fReturnType = dynamic_cast<DIEType*>(value.reference); 1962 return fReturnType != NULL ? B_OK : B_BAD_DATA; 1963} 1964 1965 1966status_t 1967DIESubprogram::AddAttribute_inline(uint16 attributeName, 1968 const AttributeValue& value) 1969{ 1970// TODO: How is the address class handled? 1971 fInline = value.constant; 1972 return B_OK; 1973} 1974 1975 1976status_t 1977DIESubprogram::AddAttribute_abstract_origin(uint16 attributeName, 1978 const AttributeValue& value) 1979{ 1980 fAbstractOrigin = dynamic_cast<DIESubprogram*>(value.reference); 1981 return fAbstractOrigin != NULL ? B_OK : B_BAD_DATA; 1982} 1983 1984 1985status_t 1986DIESubprogram::AddAttribute_frame_base(uint16 attributeName, 1987 const AttributeValue& value) 1988{ 1989 if (value.attributeClass == ATTRIBUTE_CLASS_LOCLISTPTR) { 1990 fFrameBase.SetToLocationList(value.pointer); 1991 return B_OK; 1992 } 1993 1994 if (value.attributeClass == ATTRIBUTE_CLASS_BLOCK) { 1995 fFrameBase.SetToExpression(value.block.data, value.block.length); 1996 return B_OK; 1997 } 1998 1999 return B_BAD_DATA; 2000} 2001 2002 2003status_t 2004DIESubprogram::AddAttribute_artificial(uint16 attributeName, 2005 const AttributeValue& value) 2006{ 2007 fArtificial = value.flag; 2008 return B_OK; 2009} 2010 2011 2012status_t 2013DIESubprogram::AddAttribute_calling_convention(uint16 attributeName, 2014 const AttributeValue& value) 2015{ 2016 fCallingConvention = value.constant; 2017 return B_OK; 2018} 2019 2020 2021// #pragma mark - DIETemplateTypeParameter 2022 2023 2024DIETemplateTypeParameter::DIETemplateTypeParameter() 2025 : 2026 fType(NULL) 2027{ 2028} 2029 2030 2031uint16 2032DIETemplateTypeParameter::Tag() const 2033{ 2034 return DW_TAG_template_type_parameter; 2035} 2036 2037 2038status_t 2039DIETemplateTypeParameter::AddAttribute_type(uint16 attributeName, 2040 const AttributeValue& value) 2041{ 2042 fType = dynamic_cast<DIEType*>(value.reference); 2043 return fType != NULL ? B_OK : B_BAD_DATA; 2044} 2045 2046 2047// #pragma mark - DIETemplateValueParameter 2048 2049 2050DIETemplateValueParameter::DIETemplateValueParameter() 2051 : 2052 fType(NULL) 2053{ 2054} 2055 2056 2057uint16 2058DIETemplateValueParameter::Tag() const 2059{ 2060 return DW_TAG_template_value_parameter; 2061} 2062 2063 2064status_t 2065DIETemplateValueParameter::AddAttribute_const_value(uint16 attributeName, 2066 const AttributeValue& value) 2067{ 2068 return SetConstantAttributeValue(fValue, value); 2069} 2070 2071 2072status_t 2073DIETemplateValueParameter::AddAttribute_type(uint16 attributeName, 2074 const AttributeValue& value) 2075{ 2076 fType = dynamic_cast<DIEType*>(value.reference); 2077 return fType != NULL ? B_OK : B_BAD_DATA; 2078} 2079 2080 2081// #pragma mark - DIEThrownType 2082 2083 2084DIEThrownType::DIEThrownType() 2085 : 2086 fType(NULL) 2087{ 2088} 2089 2090 2091uint16 2092DIEThrownType::Tag() const 2093{ 2094 return DW_TAG_thrown_type; 2095} 2096 2097 2098status_t 2099DIEThrownType::AddAttribute_type(uint16 attributeName, 2100 const AttributeValue& value) 2101{ 2102 fType = dynamic_cast<DIEType*>(value.reference); 2103 return fType != NULL ? B_OK : B_BAD_DATA; 2104} 2105 2106 2107// #pragma mark - DIETryBlock 2108 2109 2110DIETryBlock::DIETryBlock() 2111{ 2112} 2113 2114 2115uint16 2116DIETryBlock::Tag() const 2117{ 2118 return DW_TAG_try_block; 2119} 2120 2121 2122// #pragma mark - DIEVariantPart 2123 2124 2125DIEVariantPart::DIEVariantPart() 2126 : 2127 fType(NULL) 2128{ 2129} 2130 2131 2132uint16 2133DIEVariantPart::Tag() const 2134{ 2135 return DW_TAG_variant_part; 2136} 2137 2138 2139status_t 2140DIEVariantPart::AddAttribute_type(uint16 attributeName, 2141 const AttributeValue& value) 2142{ 2143 fType = dynamic_cast<DIEType*>(value.reference); 2144 return fType != NULL ? B_OK : B_BAD_DATA; 2145} 2146 2147 2148// #pragma mark - DIEVariable 2149 2150 2151DIEVariable::DIEVariable() 2152 : 2153 fType(NULL), 2154 fSpecification(NULL), 2155 fAbstractOrigin(NULL), 2156 fStartScope(0) 2157{ 2158} 2159 2160 2161uint16 2162DIEVariable::Tag() const 2163{ 2164 return DW_TAG_variable; 2165} 2166 2167 2168DebugInfoEntry* 2169DIEVariable::Specification() const 2170{ 2171 return fSpecification; 2172} 2173 2174 2175 2176DebugInfoEntry* 2177DIEVariable::AbstractOrigin() const 2178{ 2179 return fAbstractOrigin; 2180} 2181 2182 2183LocationDescription* 2184DIEVariable::GetLocationDescription() 2185{ 2186 return &fLocationDescription; 2187} 2188 2189 2190status_t 2191DIEVariable::AddAttribute_const_value(uint16 attributeName, 2192 const AttributeValue& value) 2193{ 2194 return SetConstantAttributeValue(fValue, value); 2195} 2196 2197 2198status_t 2199DIEVariable::AddAttribute_type(uint16 attributeName, 2200 const AttributeValue& value) 2201{ 2202 fType = dynamic_cast<DIEType*>(value.reference); 2203 return fType != NULL ? B_OK : B_BAD_DATA; 2204} 2205 2206 2207status_t 2208DIEVariable::AddAttribute_specification(uint16 attributeName, 2209 const AttributeValue& value) 2210{ 2211 fSpecification = dynamic_cast<DIEVariable*>(value.reference); 2212 // in the case of static variables declared within a compound type, 2213 // the specification may point to a member entry rather than 2214 // a variable entry 2215 if (fSpecification == NULL) 2216 fSpecification = dynamic_cast<DIEMember*>(value.reference); 2217 2218 return fSpecification != NULL ? B_OK : B_BAD_DATA; 2219} 2220 2221 2222status_t 2223DIEVariable::AddAttribute_abstract_origin(uint16 attributeName, 2224 const AttributeValue& value) 2225{ 2226 fAbstractOrigin = dynamic_cast<DIEVariable*>(value.reference); 2227 return fAbstractOrigin != NULL ? B_OK : B_BAD_DATA; 2228} 2229 2230 2231status_t 2232DIEVariable::AddAttribute_start_scope(uint16 attributeName, 2233 const AttributeValue& value) 2234{ 2235 fStartScope = value.constant; 2236 return B_OK; 2237} 2238 2239 2240// #pragma mark - DIEVolatileType 2241 2242 2243DIEVolatileType::DIEVolatileType() 2244{ 2245} 2246 2247 2248uint16 2249DIEVolatileType::Tag() const 2250{ 2251 return DW_TAG_volatile_type; 2252} 2253 2254 2255status_t 2256DIEVolatileType::AddAttribute_decl_file(uint16 attributeName, 2257 const AttributeValue& value) 2258{ 2259 fDeclarationLocation.SetFile(value.constant); 2260 return B_OK; 2261} 2262 2263 2264status_t 2265DIEVolatileType::AddAttribute_decl_line(uint16 attributeName, 2266 const AttributeValue& value) 2267{ 2268 fDeclarationLocation.SetLine(value.constant); 2269 return B_OK; 2270} 2271 2272 2273status_t 2274DIEVolatileType::AddAttribute_decl_column(uint16 attributeName, 2275 const AttributeValue& value) 2276{ 2277 fDeclarationLocation.SetColumn(value.constant); 2278 return B_OK; 2279} 2280 2281 2282// #pragma mark - DIEDwarfProcedure 2283 2284 2285DIEDwarfProcedure::DIEDwarfProcedure() 2286{ 2287} 2288 2289 2290uint16 2291DIEDwarfProcedure::Tag() const 2292{ 2293 return DW_TAG_dwarf_procedure; 2294} 2295 2296 2297LocationDescription* 2298DIEDwarfProcedure::GetLocationDescription() 2299{ 2300 return &fLocationDescription; 2301} 2302 2303 2304// #pragma mark - DIERestrictType 2305 2306 2307DIERestrictType::DIERestrictType() 2308{ 2309} 2310 2311 2312uint16 2313DIERestrictType::Tag() const 2314{ 2315 return DW_TAG_restrict_type; 2316} 2317 2318 2319// #pragma mark - DIEInterfaceType 2320 2321 2322DIEInterfaceType::DIEInterfaceType() 2323{ 2324} 2325 2326 2327uint16 2328DIEInterfaceType::Tag() const 2329{ 2330 return DW_TAG_interface_type; 2331} 2332 2333 2334// #pragma mark - DIENamespace 2335 2336 2337DIENamespace::DIENamespace() 2338{ 2339} 2340 2341 2342uint16 2343DIENamespace::Tag() const 2344{ 2345 return DW_TAG_namespace; 2346} 2347 2348 2349bool 2350DIENamespace::IsNamespace() const 2351{ 2352 return true; 2353} 2354 2355 2356status_t 2357DIENamespace::AddChild(DebugInfoEntry* child) 2358{ 2359 fChildren.Add(child); 2360 return B_OK; 2361} 2362 2363 2364// #pragma mark - DIEImportedModule 2365 2366 2367DIEImportedModule::DIEImportedModule() 2368{ 2369} 2370 2371 2372uint16 2373DIEImportedModule::Tag() const 2374{ 2375 return DW_TAG_imported_module; 2376} 2377 2378 2379// #pragma mark - DIEUnspecifiedType 2380 2381 2382DIEUnspecifiedType::DIEUnspecifiedType() 2383{ 2384} 2385 2386 2387uint16 2388DIEUnspecifiedType::Tag() const 2389{ 2390 return DW_TAG_unspecified_type; 2391} 2392 2393 2394status_t 2395DIEUnspecifiedType::AddAttribute_decl_file(uint16 attributeName, 2396 const AttributeValue& value) 2397{ 2398 fDeclarationLocation.SetFile(value.constant); 2399 return B_OK; 2400} 2401 2402 2403status_t 2404DIEUnspecifiedType::AddAttribute_decl_line(uint16 attributeName, 2405 const AttributeValue& value) 2406{ 2407 fDeclarationLocation.SetLine(value.constant); 2408 return B_OK; 2409} 2410 2411 2412status_t 2413DIEUnspecifiedType::AddAttribute_decl_column(uint16 attributeName, 2414 const AttributeValue& value) 2415{ 2416 fDeclarationLocation.SetColumn(value.constant); 2417 return B_OK; 2418} 2419 2420 2421// #pragma mark - DIEPartialUnit 2422 2423 2424DIEPartialUnit::DIEPartialUnit() 2425{ 2426} 2427 2428 2429uint16 2430DIEPartialUnit::Tag() const 2431{ 2432 return DW_TAG_partial_unit; 2433} 2434 2435 2436// #pragma mark - DIEImportedUnit 2437 2438 2439DIEImportedUnit::DIEImportedUnit() 2440{ 2441} 2442 2443 2444uint16 2445DIEImportedUnit::Tag() const 2446{ 2447 return DW_TAG_imported_unit; 2448} 2449 2450 2451// #pragma mark - DIECondition 2452 2453 2454DIECondition::DIECondition() 2455{ 2456} 2457 2458 2459uint16 2460DIECondition::Tag() const 2461{ 2462 return DW_TAG_condition; 2463} 2464 2465 2466// #pragma mark - DIESharedType 2467 2468 2469DIESharedType::DIESharedType() 2470{ 2471 fBlockSize.SetTo(~(uint64)0); 2472} 2473 2474 2475uint16 2476DIESharedType::Tag() const 2477{ 2478 return DW_TAG_shared_type; 2479} 2480 2481 2482status_t 2483DIESharedType::AddAttribute_count(uint16 attributeName, 2484 const AttributeValue& value) 2485{ 2486 return SetDynamicAttributeValue(fBlockSize, value); 2487} 2488 2489 2490status_t 2491DIESharedType::AddAttribute_decl_file(uint16 attributeName, 2492 const AttributeValue& value) 2493{ 2494 fDeclarationLocation.SetFile(value.constant); 2495 return B_OK; 2496} 2497 2498 2499status_t 2500DIESharedType::AddAttribute_decl_line(uint16 attributeName, 2501 const AttributeValue& value) 2502{ 2503 fDeclarationLocation.SetLine(value.constant); 2504 return B_OK; 2505} 2506 2507 2508status_t 2509DIESharedType::AddAttribute_decl_column(uint16 attributeName, 2510 const AttributeValue& value) 2511{ 2512 fDeclarationLocation.SetColumn(value.constant); 2513 return B_OK; 2514} 2515 2516 2517// #pragma mark - DIETemplateTypeParameterPack 2518 2519 2520DIETemplateTypeParameterPack::DIETemplateTypeParameterPack() 2521 : 2522 fName(NULL) 2523{ 2524} 2525 2526 2527uint16 2528DIETemplateTypeParameterPack::Tag() const 2529{ 2530 return DW_TAG_GNU_template_parameter_pack; 2531} 2532 2533 2534const char* 2535DIETemplateTypeParameterPack::Name() const 2536{ 2537 return fName; 2538} 2539 2540 2541status_t 2542DIETemplateTypeParameterPack::AddAttribute_name(uint16 attributeName, 2543 const AttributeValue& value) 2544{ 2545 fName = value.string; 2546 return B_OK; 2547} 2548 2549 2550status_t 2551DIETemplateTypeParameterPack::AddChild(DebugInfoEntry* child) 2552{ 2553 if (child->Tag() == DW_TAG_template_type_parameter) { 2554 fChildren.Add(child); 2555 return B_OK; 2556 } 2557 2558 return DIEDeclaredBase::AddChild(child); 2559} 2560 2561 2562// #pragma mark - DIETemplateValueParameterPack 2563 2564 2565DIETemplateValueParameterPack::DIETemplateValueParameterPack() 2566 : 2567 fName(NULL) 2568{ 2569} 2570 2571 2572uint16 2573DIETemplateValueParameterPack::Tag() const 2574{ 2575 return DW_TAG_GNU_formal_parameter_pack; 2576} 2577 2578 2579const char* 2580DIETemplateValueParameterPack::Name() const 2581{ 2582 return fName; 2583} 2584 2585 2586status_t 2587DIETemplateValueParameterPack::AddAttribute_name(uint16 attributeName, 2588 const AttributeValue& value) 2589{ 2590 fName = value.string; 2591 return B_OK; 2592} 2593 2594 2595status_t 2596DIETemplateValueParameterPack::AddChild(DebugInfoEntry* child) 2597{ 2598 if (child->Tag() == DW_TAG_formal_parameter) { 2599 fChildren.Add(child); 2600 return B_OK; 2601 } 2602 2603 return DIEDeclaredBase::AddChild(child); 2604} 2605 2606 2607// #pragma mark - DebugInfoEntryFactory 2608 2609 2610DebugInfoEntryFactory::DebugInfoEntryFactory() 2611{ 2612} 2613 2614 2615status_t 2616DebugInfoEntryFactory::CreateDebugInfoEntry(uint16 tag, DebugInfoEntry*& _entry) 2617{ 2618 DebugInfoEntry* entry = NULL; 2619 2620 switch (tag) { 2621 case DW_TAG_array_type: 2622 entry = new(std::nothrow) DIEArrayType; 2623 break; 2624 case DW_TAG_class_type: 2625 entry = new(std::nothrow) DIEClassType; 2626 break; 2627 case DW_TAG_entry_point: 2628 entry = new(std::nothrow) DIEEntryPoint; 2629 break; 2630 case DW_TAG_enumeration_type: 2631 entry = new(std::nothrow) DIEEnumerationType; 2632 break; 2633 case DW_TAG_formal_parameter: 2634 entry = new(std::nothrow) DIEFormalParameter; 2635 break; 2636 case DW_TAG_imported_declaration: 2637 entry = new(std::nothrow) DIEImportedDeclaration; 2638 break; 2639 case DW_TAG_label: 2640 entry = new(std::nothrow) DIELabel; 2641 break; 2642 case DW_TAG_lexical_block: 2643 entry = new(std::nothrow) DIELexicalBlock; 2644 break; 2645 case DW_TAG_member: 2646 entry = new(std::nothrow) DIEMember; 2647 break; 2648 case DW_TAG_pointer_type: 2649 entry = new(std::nothrow) DIEPointerType; 2650 break; 2651 case DW_TAG_reference_type: 2652 entry = new(std::nothrow) DIEReferenceType; 2653 break; 2654 case DW_TAG_compile_unit: 2655 entry = new(std::nothrow) DIECompileUnit; 2656 break; 2657 case DW_TAG_string_type: 2658 entry = new(std::nothrow) DIEStringType; 2659 break; 2660 case DW_TAG_structure_type: 2661 entry = new(std::nothrow) DIEStructureType; 2662 break; 2663 case DW_TAG_subroutine_type: 2664 entry = new(std::nothrow) DIESubroutineType; 2665 break; 2666 case DW_TAG_typedef: 2667 entry = new(std::nothrow) DIETypedef; 2668 break; 2669 case DW_TAG_union_type: 2670 entry = new(std::nothrow) DIEUnionType; 2671 break; 2672 case DW_TAG_unspecified_parameters: 2673 entry = new(std::nothrow) DIEUnspecifiedParameters; 2674 break; 2675 case DW_TAG_variant: 2676 entry = new(std::nothrow) DIEVariant; 2677 break; 2678 case DW_TAG_common_block: 2679 entry = new(std::nothrow) DIECommonBlock; 2680 break; 2681 case DW_TAG_common_inclusion: 2682 entry = new(std::nothrow) DIECommonInclusion; 2683 break; 2684 case DW_TAG_inheritance: 2685 entry = new(std::nothrow) DIEInheritance; 2686 break; 2687 case DW_TAG_inlined_subroutine: 2688 entry = new(std::nothrow) DIEInlinedSubroutine; 2689 break; 2690 case DW_TAG_module: 2691 entry = new(std::nothrow) DIEModule; 2692 break; 2693 case DW_TAG_ptr_to_member_type: 2694 entry = new(std::nothrow) DIEPointerToMemberType; 2695 break; 2696 case DW_TAG_set_type: 2697 entry = new(std::nothrow) DIESetType; 2698 break; 2699 case DW_TAG_subrange_type: 2700 entry = new(std::nothrow) DIESubrangeType; 2701 break; 2702 case DW_TAG_with_stmt: 2703 entry = new(std::nothrow) DIEWithStatement; 2704 break; 2705 case DW_TAG_access_declaration: 2706 entry = new(std::nothrow) DIEAccessDeclaration; 2707 break; 2708 case DW_TAG_base_type: 2709 entry = new(std::nothrow) DIEBaseType; 2710 break; 2711 case DW_TAG_catch_block: 2712 entry = new(std::nothrow) DIECatchBlock; 2713 break; 2714 case DW_TAG_const_type: 2715 entry = new(std::nothrow) DIEConstType; 2716 break; 2717 case DW_TAG_constant: 2718 entry = new(std::nothrow) DIEConstant; 2719 break; 2720 case DW_TAG_enumerator: 2721 entry = new(std::nothrow) DIEEnumerator; 2722 break; 2723 case DW_TAG_file_type: 2724 entry = new(std::nothrow) DIEFileType; 2725 break; 2726 case DW_TAG_friend: 2727 entry = new(std::nothrow) DIEFriend; 2728 break; 2729 case DW_TAG_namelist: 2730 entry = new(std::nothrow) DIENameList; 2731 break; 2732 case DW_TAG_namelist_item: 2733 entry = new(std::nothrow) DIENameListItem; 2734 break; 2735 case DW_TAG_packed_type: 2736 entry = new(std::nothrow) DIEPackedType; 2737 break; 2738 case DW_TAG_subprogram: 2739 entry = new(std::nothrow) DIESubprogram; 2740 break; 2741 case DW_TAG_template_type_parameter: 2742 entry = new(std::nothrow) DIETemplateTypeParameter; 2743 break; 2744 case DW_TAG_template_value_parameter: 2745 entry = new(std::nothrow) DIETemplateValueParameter; 2746 break; 2747 case DW_TAG_thrown_type: 2748 entry = new(std::nothrow) DIEThrownType; 2749 break; 2750 case DW_TAG_try_block: 2751 entry = new(std::nothrow) DIETryBlock; 2752 break; 2753 case DW_TAG_variant_part: 2754 entry = new(std::nothrow) DIEVariantPart; 2755 break; 2756 case DW_TAG_variable: 2757 entry = new(std::nothrow) DIEVariable; 2758 break; 2759 case DW_TAG_volatile_type: 2760 entry = new(std::nothrow) DIEVolatileType; 2761 break; 2762 case DW_TAG_dwarf_procedure: 2763 entry = new(std::nothrow) DIEDwarfProcedure; 2764 break; 2765 case DW_TAG_restrict_type: 2766 entry = new(std::nothrow) DIERestrictType; 2767 break; 2768 case DW_TAG_interface_type: 2769 entry = new(std::nothrow) DIEInterfaceType; 2770 break; 2771 case DW_TAG_namespace: 2772 entry = new(std::nothrow) DIENamespace; 2773 break; 2774 case DW_TAG_imported_module: 2775 entry = new(std::nothrow) DIEImportedModule; 2776 break; 2777 case DW_TAG_unspecified_type: 2778 entry = new(std::nothrow) DIEUnspecifiedType; 2779 break; 2780 case DW_TAG_partial_unit: 2781 entry = new(std::nothrow) DIEPartialUnit; 2782 break; 2783 case DW_TAG_imported_unit: 2784 entry = new(std::nothrow) DIEImportedUnit; 2785 break; 2786 case DW_TAG_condition: 2787 entry = new(std::nothrow) DIECondition; 2788 break; 2789 case DW_TAG_shared_type: 2790 entry = new(std::nothrow) DIESharedType; 2791 break; 2792 case DW_TAG_GNU_template_parameter_pack: 2793 entry = new(std::nothrow) DIETemplateTypeParameterPack; 2794 break; 2795 case DW_TAG_GNU_formal_parameter_pack: 2796 entry = new(std::nothrow) DIETemplateValueParameterPack; 2797 break; 2798 default: 2799 return B_ENTRY_NOT_FOUND; 2800 break; 2801 } 2802 2803 _entry = entry; 2804 return B_OK; 2805} 2806