[Haiku-commits] r31047 - in haiku/trunk/src/apps: . debugger
bonefish at mail.berlios.de
bonefish at mail.berlios.de
Sun Jun 14 14:53:33 CEST 2009
Author: bonefish
Date: 2009-06-14 14:53:29 +0200 (Sun, 14 Jun 2009)
New Revision: 31047
ViewCVS: http://svn.berlios.de/viewcvs/haiku?rev=31047&view=rev
Added:
haiku/trunk/src/apps/debugger/
haiku/trunk/src/apps/debugger/Array.h
haiku/trunk/src/apps/debugger/AttributeValue.cpp
haiku/trunk/src/apps/debugger/AttributeValue.h
haiku/trunk/src/apps/debugger/DataReader.h
haiku/trunk/src/apps/debugger/DebugInfoEntries.cpp
haiku/trunk/src/apps/debugger/DebugInfoEntries.h
haiku/trunk/src/apps/debugger/DebugInfoEntry.cpp
haiku/trunk/src/apps/debugger/DebugInfoEntry.h
haiku/trunk/src/apps/debugger/DwarfManager.cpp
haiku/trunk/src/apps/debugger/DwarfManager.h
haiku/trunk/src/apps/debugger/ElfFile.cpp
haiku/trunk/src/apps/debugger/ElfFile.h
haiku/trunk/src/apps/debugger/HaikuTypes.h
haiku/trunk/src/apps/debugger/Jamfile
haiku/trunk/src/apps/debugger/SourceLanguageInfo.cpp
haiku/trunk/src/apps/debugger/SourceLanguageInfo.h
haiku/trunk/src/apps/debugger/arch_elf.h
haiku/trunk/src/apps/debugger/attribute_classes.cpp
haiku/trunk/src/apps/debugger/attribute_classes.h
haiku/trunk/src/apps/debugger/debugger.cpp
haiku/trunk/src/apps/debugger/dwarf.h
haiku/trunk/src/apps/debugger/tag_names.cpp
haiku/trunk/src/apps/debugger/tag_names.h
haiku/trunk/src/apps/debugger/types.h
Modified:
haiku/trunk/src/apps/Jamfile
Log:
The very beginnings of a debugger. Currently consisting only of the beginnings
of a DWARF 3 reader. It can read the .debug_info section and create objects for
the entries, but most attributes are ignored yet.
Modified: haiku/trunk/src/apps/Jamfile
===================================================================
--- haiku/trunk/src/apps/Jamfile 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/Jamfile 2009-06-14 12:53:29 UTC (rev 31047)
@@ -12,6 +12,7 @@
HaikuSubInclude codycam ;
HaikuSubInclude cortex ;
HaikuSubInclude debuganalyzer ;
+HaikuSubInclude debugger ;
HaikuSubInclude deskbar ;
HaikuSubInclude deskcalc ;
HaikuSubInclude diskprobe ;
Added: haiku/trunk/src/apps/debugger/Array.h
===================================================================
--- haiku/trunk/src/apps/debugger/Array.h 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/debugger/Array.h 2009-06-14 12:53:29 UTC (rev 31047)
@@ -0,0 +1,193 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold at gmx.de. All Rights Reserved.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef ARRAY_H
+#define ARRAY_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+template<typename Element>
+class Array {
+public:
+ inline Array();
+ ~Array();
+
+ inline int Size() const { return fSize; }
+ inline int Count() const { return fSize; }
+ inline bool IsEmpty() const { return fSize == 0; }
+ inline Element* Elements() const { return fElements; }
+
+ inline bool Add(const Element& element);
+ inline bool Insert(const Element& element, int index);
+ inline bool Remove(int index);
+
+ inline Element& ElementAt(int index);
+ inline const Element& ElementAt(int index) const;
+
+ inline Element& operator[](int index);
+ inline const Element& operator[](int index) const;
+
+private:
+ static const int kMinCapacity = 8;
+
+ bool _Resize(int index, int delta);
+
+private:
+ Element* fElements;
+ int fSize;
+ int fCapacity;
+};
+
+
+template<typename Element>
+Array<Element>::Array()
+ :
+ fElements(NULL),
+ fSize(0),
+ fCapacity(0)
+{
+}
+
+
+template<typename Element>
+Array<Element>::~Array()
+{
+ free(fElements);
+}
+
+
+template<typename Element>
+bool
+Array<Element>::Add(const Element& element)
+{
+ if (fSize == fCapacity) {
+ if (!_Resize(fSize, 1))
+ return false;
+ }
+
+ fElements[fSize] = element;
+ fSize++;
+ return true;
+}
+
+
+template<typename Element>
+bool
+Array<Element>::Insert(const Element& element, int index)
+{
+ if (index < 0 || index > fSize)
+ index = fSize;
+
+ if (fSize == fCapacity) {
+ if (!_Resize(index, 1))
+ return false;
+ } else if (index < fSize) {
+ memmove(fElements + index + 1, fElements + index,
+ sizeof(Element) * (fSize - index));
+ }
+
+ fElements[index] = element;
+ fSize++;
+ return false;
+}
+
+
+template<typename Element>
+bool
+Array<Element>::Remove(int index)
+{
+ if (index < 0 || index >= fSize) {
+ char buffer[128];
+ snprintf(buffer, sizeof(buffer), "Array::Remove(): index: %d, size: %d",
+ index, fSize);
+ return false;
+ }
+
+ if (fSize <= fCapacity / 2 && fCapacity > kMinCapacity) {
+ _Resize(index, -1);
+ } else if (index < fSize) {
+ memmove(fElements + index, fElements + index + 1,
+ sizeof(Element) * (fSize - index - 1));
+ }
+
+ fSize--;
+ return true;
+}
+
+
+template<typename Element>
+Element&
+Array<Element>::ElementAt(int index)
+{
+ return fElements[index];
+}
+
+
+template<typename Element>
+const Element&
+Array<Element>::ElementAt(int index) const
+{
+ return fElements[index];
+}
+
+
+template<typename Element>
+Element&
+Array<Element>::operator[](int index)
+{
+ return fElements[index];
+}
+
+
+template<typename Element>
+const Element&
+Array<Element>::operator[](int index) const
+{
+ return fElements[index];
+}
+
+
+template<typename Element>
+bool
+Array<Element>::_Resize(int index, int delta)
+{
+ // determine new capacity
+ int newSize = fSize + delta;
+ int newCapacity = kMinCapacity;
+ while (newCapacity < newSize)
+ newCapacity *= 2;
+
+ if (newCapacity == fCapacity)
+ return true;
+
+ // allocate new array
+ Element* elements = (Element*)malloc(newCapacity * sizeof(Element));
+ if (elements == NULL)
+ return false;
+
+ if (index > 0)
+ memcpy(elements, fElements, index * sizeof(Element));
+ if (index < fSize) {
+ if (delta > 0) {
+ // leave a gap of delta elements
+ memcpy(elements + index + delta, fElements + index,
+ (fSize - index) * sizeof(Element));
+ } else if (index < fSize + delta) {
+ // drop -delta elements
+ memcpy(elements + index, fElements + index - delta,
+ (fSize - index + delta) * sizeof(Element));
+ }
+ }
+
+ free(fElements);
+ fElements = elements;
+ fCapacity = newCapacity;
+ return true;
+}
+
+
+#endif // ARRAY_H
Added: haiku/trunk/src/apps/debugger/AttributeValue.cpp
===================================================================
--- haiku/trunk/src/apps/debugger/AttributeValue.cpp 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/debugger/AttributeValue.cpp 2009-06-14 12:53:29 UTC (rev 31047)
@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold at gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "AttributeValue.h"
+
+#include <stdio.h>
+
+#include "attribute_classes.h"
+
+
+const char*
+AttributeValue::ToString(char* buffer, size_t size)
+{
+ switch (attributeClass) {
+ case ATTRIBUTE_CLASS_ADDRESS:
+ snprintf(buffer, size, "%#lx", address);
+ return buffer;
+ case ATTRIBUTE_CLASS_BLOCK:
+ snprintf(buffer, size, "(%p, %#lx)", block.data, block.length);
+ return buffer;
+ case ATTRIBUTE_CLASS_CONSTANT:
+ snprintf(buffer, size, "%#llx", constant);
+ return buffer;
+ case ATTRIBUTE_CLASS_FLAG:
+ snprintf(buffer, size, "%s", flag ? "true" : "false");
+ return buffer;
+ case ATTRIBUTE_CLASS_LINEPTR:
+ case ATTRIBUTE_CLASS_LOCLISTPTR:
+ case ATTRIBUTE_CLASS_MACPTR:
+ case ATTRIBUTE_CLASS_RANGELISTPTR:
+ snprintf(buffer, size, "%#lx", pointer);
+ return buffer;
+ case ATTRIBUTE_CLASS_REFERENCE:
+ snprintf(buffer, size, "%p", reference);
+ return buffer;
+ case ATTRIBUTE_CLASS_STRING:
+ snprintf(buffer, size, "\"%s\"", string);
+ return buffer;
+
+ default:
+ case ATTRIBUTE_CLASS_UNKNOWN:
+ return "<unknown>";
+ }
+
+ return buffer;
+}
Added: haiku/trunk/src/apps/debugger/AttributeValue.h
===================================================================
--- haiku/trunk/src/apps/debugger/AttributeValue.h 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/debugger/AttributeValue.h 2009-06-14 12:53:29 UTC (rev 31047)
@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold at gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef ATTRIBUTE_VALUE_H
+#define ATTRIBUTE_VALUE_H
+
+#include "attribute_classes.h"
+#include "types.h"
+
+
+class DebugInfoEntry;
+
+
+struct AttributeValue {
+ union {
+ dwarf_addr_t address;
+ struct {
+ const void* data;
+ dwarf_size_t length;
+ } block;
+ uint64 constant;
+ bool flag;
+ dwarf_off_t pointer;
+ DebugInfoEntry* reference;
+ const char* string;
+ };
+
+ uint16 attributeForm;
+ uint8 attributeClass;
+ bool isSigned;
+
+ const char* ToString(char* buffer, size_t size);
+};
+
+
+struct DynamicAttributeValue {
+ union {
+ uint64 constant;
+ DebugInfoEntry* reference;
+ struct {
+ const void* data;
+ dwarf_size_t length;
+ } block;
+ };
+ uint8 attributeClass;
+
+ void SetTo(uint64 constant)
+ {
+ this->constant = constant;
+ attributeClass = ATTRIBUTE_CLASS_CONSTANT;
+ }
+
+ void SetTo(DebugInfoEntry* reference)
+ {
+ this->reference = reference;
+ attributeClass = ATTRIBUTE_CLASS_REFERENCE;
+ }
+
+ void SetTo(const void* data, dwarf_size_t length)
+ {
+ block.data = data;
+ block.length = length;
+ attributeClass = ATTRIBUTE_CLASS_BLOCK;
+ }
+};
+
+
+#endif // ATTRIBUTE_VALUE_H
Added: haiku/trunk/src/apps/debugger/DataReader.h
===================================================================
--- haiku/trunk/src/apps/debugger/DataReader.h 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/debugger/DataReader.h 2009-06-14 12:53:29 UTC (rev 31047)
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold at gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef DATA_READER_H
+#define DATA_READER_H
+
+#include <SupportDefs.h>
+
+
+class DataReader {
+public:
+ DataReader()
+ :
+ fData(NULL),
+ fSize(0),
+ fInitialSize(0),
+ fOverflow(false)
+ {
+ }
+
+ DataReader(const void* data, off_t size)
+ {
+ SetTo(data, size);
+ }
+
+ void SetTo(const void* data, off_t size)
+ {
+ fData = (const uint8*)data;
+ fInitialSize = fSize = size;
+ fOverflow = false;
+ }
+
+ bool HasData() const
+ {
+ return fSize > 0;
+ }
+
+ bool HasOverflow() const
+ {
+ return fOverflow;
+ }
+
+ const void* Data() const
+ {
+ return fData;
+ }
+
+ off_t BytesRemaining() const
+ {
+ return fSize;
+ }
+
+ off_t Offset() const
+ {
+ return fInitialSize - fSize;
+ }
+
+ void SeekAbsolute(off_t offset)
+ {
+ if (offset < 0)
+ offset = 0;
+ else if (offset > fInitialSize)
+ offset = fInitialSize;
+
+ fData += offset - Offset();
+ fSize = fInitialSize - offset;
+ }
+
+ template<typename Type>
+ Type Read(const Type& defaultValue)
+ {
+ if (fSize < sizeof(Type)) {
+ fOverflow = true;
+ fSize = 0;
+ return defaultValue;
+ }
+
+ Type data;
+ memcpy(&data, fData, sizeof(Type));
+
+ fData += sizeof(Type);
+ fSize -= sizeof(Type);
+
+ return data;
+ }
+
+ uint64 ReadUnsignedLEB128(uint64 defaultValue)
+ {
+ uint64 result = 0;
+ int shift = 0;
+ while (true) {
+ uint8 byte = Read<uint8>(0);
+ result |= uint64(byte & 0x7f) << shift;
+ if ((byte & 0x80) == 0)
+ break;
+ shift += 7;
+ }
+
+ return fOverflow ? defaultValue : result;
+ }
+
+ int64 ReadSignedLEB128(int64 defaultValue)
+ {
+ int64 result = 0;
+ int shift = 0;
+ while (true) {
+ uint8 byte = Read<uint8>(0);
+ result |= uint64(byte & 0x7f) << shift;
+ shift += 7;
+
+ if ((byte & 0x80) == 0) {
+ // sign extend
+ if ((byte & 0x40) != 0 && shift < 64)
+ result |= -((uint64)1 << shift);
+ break;
+ }
+ }
+
+ return fOverflow ? defaultValue : result;
+ }
+
+ const char* ReadString()
+ {
+ const char* string = (const char*)fData;
+ while (fSize > 0) {
+ fData++;
+ fSize--;
+
+ if (fData[-1] == 0)
+ return string;
+ }
+
+ fOverflow = true;
+ return NULL;
+ }
+
+ bool Skip(off_t bytes)
+ {
+ if (bytes < 0)
+ return false;
+
+ if (bytes > fSize) {
+ fSize = 0;
+ fOverflow = true;
+ return false;
+ }
+
+ fData += bytes;
+ fSize -= bytes;
+
+ return true;
+ }
+
+private:
+ const uint8* fData;
+ off_t fSize;
+ off_t fInitialSize;
+ bool fOverflow;
+};
+
+
+#endif // DATA_READER_H
Added: haiku/trunk/src/apps/debugger/DebugInfoEntries.cpp
===================================================================
--- haiku/trunk/src/apps/debugger/DebugInfoEntries.cpp 2009-06-14 12:16:18 UTC (rev 31046)
+++ haiku/trunk/src/apps/debugger/DebugInfoEntries.cpp 2009-06-14 12:53:29 UTC (rev 31047)
@@ -0,0 +1,1483 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold at gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "DebugInfoEntries.h"
+
+#include <new>
+
+#include "AttributeValue.h"
+#include "dwarf.h"
+#include "SourceLanguageInfo.h"
+
+
+// #pragma mark - DIECompileUnitBase
+
+
+DIECompileUnitBase::DIECompileUnitBase()
+ :
+ fName(NULL),
+ fCompilationDir(NULL),
+ fLowPC(0),
+ fHighPC(0),
+ fStatementListOffset(0),
+ fMacroInfoOffset(0),
+ // TODO: Is 0 a good invalid offset?
+ fBaseTypesUnit(NULL),
+ fLanguage(0),
+ fIdentifierCase(0),
+ fUseUTF8(true)
+{
+}
+
+
+status_t
+DIECompileUnitBase::InitAfterAttributes(DebugInfoEntryInitInfo& info)
+{
+ switch (fLanguage) {
+ case 0:
+ info.languageInfo = &kUnknownLanguageInfo;
+ return B_OK;
+ case DW_LANG_C89:
+ info.languageInfo = &kC89LanguageInfo;
+ return B_OK;
+ case DW_LANG_C:
+ info.languageInfo = &kCLanguageInfo;
+ return B_OK;
+ case DW_LANG_C_plus_plus:
+ info.languageInfo = &kCPlusPlusLanguageInfo;
+ return B_OK;
+ case DW_LANG_C99:
+ info.languageInfo = &kC99LanguageInfo;
+ return B_OK;
+ default:
+ info.languageInfo = &kUnsupportedLanguageInfo;
+ return B_OK;
+ }
+}
+
+
+const char*
+DIECompileUnitBase::Name() const
+{
+ return fName;
+}
+
+
+status_t
+DIECompileUnitBase::AddChild(DebugInfoEntry* child)
+{
+ if (child->IsType())
+ fTypes.Add(child);
+ else
+ fOtherChildren.Add(child);
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_name(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fName = value.string;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_comp_dir(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fCompilationDir = value.string;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_low_pc(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fLowPC = value.address;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_high_pc(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fHighPC = value.address;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_producer(uint16 attributeName,
+ const AttributeValue& value)
+{
+ // not interesting
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_stmt_list(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fStatementListOffset = value.pointer;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_macro_info(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fMacroInfoOffset = value.pointer;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_base_types(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fBaseTypesUnit = dynamic_cast<DIECompileUnitBase*>(value.reference);
+ return fBaseTypesUnit != NULL ? B_OK : B_BAD_DATA;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_language(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fLanguage = value.constant;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_identifier_case(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fIdentifierCase = value.constant;
+ return B_OK;
+}
+
+
+status_t
+DIECompileUnitBase::AddAttribute_use_UTF8(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fUseUTF8 = value.flag;
+ return B_OK;
+}
+
+
+// #pragma mark - DIEType
+
+
+DIEType::DIEType()
+ :
+ fName(NULL)
+{
+ fAllocated.SetTo((uint64)0);
+ fAssociated.SetTo((uint64)0);
+}
+
+
+bool
+DIEType::IsType() const
+{
+ return true;
+}
+
+
+const char*
+DIEType::Name() const
+{
+ return fName;
+}
+
+
+status_t
+DIEType::AddAttribute_name(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fName = value.string;
+ return B_OK;
+}
+
+
+status_t
+DIEType::AddAttribute_allocated(uint16 attributeName,
+ const AttributeValue& value)
+{
+ return SetDynamicAttributeValue(fAllocated, value);
+}
+
+
+status_t
+DIEType::AddAttribute_associated(uint16 attributeName,
+ const AttributeValue& value)
+{
+ return SetDynamicAttributeValue(fAssociated, value);
+}
+
+
+// #pragma mark - DIEModifiedType
+
+
+DIEModifiedType::DIEModifiedType()
+ :
+ fType(NULL)
+{
+}
+
+
+status_t
+DIEModifiedType::AddAttribute_type(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fType = dynamic_cast<DIEType*>(value.reference);
+ return B_OK;
+}
+
+
+// #pragma mark - DIEAddressingType
+
+
+DIEAddressingType::DIEAddressingType()
+ :
+ fAddressClass(0)
+{
+}
+
+
+status_t
+DIEAddressingType::AddAttribute_address_class(uint16 attributeName,
+ const AttributeValue& value)
+{
+// TODO: How is the address class handled?
+ fAddressClass = value.constant;
+ return B_OK;
+}
+
+
+// #pragma mark - DIEDeclaredType
+
+
+DIEDeclaredType::DIEDeclaredType()
+{
+}
+
+
+// #pragma mark - DIEDerivedType
+
+
+DIEDerivedType::DIEDerivedType()
+ :
+ fType(NULL)
+{
+}
+
+
+status_t
+DIEDerivedType::AddAttribute_type(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fType = dynamic_cast<DIEType*>(value.reference);
+ return B_OK;
+}
+
+
+
+
+// #pragma mark - DIECompoundType
+
+
+DIECompoundType::DIECompoundType()
+{
+}
+
+
+// #pragma mark - DIEClassBaseType
+
+
+DIEClassBaseType::DIEClassBaseType()
+{
+}
+
+
+// #pragma mark - DIEArrayType
+
+
+DIEArrayType::DIEArrayType()
+ :
+ fBitStride(0),
+ fByteSize(0),
+ fOrdering(DW_ORD_row_major)
+{
+}
+
+
+uint16
+DIEArrayType::Tag() const
+{
+ return DW_TAG_array_type;
+}
+
+
+status_t
+DIEArrayType::InitAfterHierarchy(DebugInfoEntryInitInfo& info)
+{
+ fOrdering = info.languageInfo->arrayOrdering;
+ return B_OK;
+}
+
+
+status_t
+DIEArrayType::AddChild(DebugInfoEntry* child)
+{
+ // a dimension child must be of subrange or enumeration type
+ uint16 tag = child->Tag();
+ if (tag == DW_TAG_subrange_type || tag == DW_TAG_enumeration_type) {
+ fDimensions.Add(child);
+ return B_OK;
+ }
+
+ return DIEDerivedType::AddChild(child);
+}
+
+
+status_t
+DIEArrayType::AddAttribute_ordering(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fOrdering = value.constant;
+ return B_OK;
+}
+
+
+status_t
+DIEArrayType::AddAttribute_bit_stride(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fBitStride = value.constant;
+ return B_OK;
+}
+
+
+status_t
+DIEArrayType::AddAttribute_stride_size(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fBitStride = value.constant;
+ return B_OK;
+}
+
+
+status_t
+DIEArrayType::AddAttribute_byte_size(uint16 attributeName,
+ const AttributeValue& value)
+{
+ fByteSize = value.constant;
+ return B_OK;
+}
+
+
+// #pragma mark - DIEClassType
+
+
+DIEClassType::DIEClassType()
+{
+}
+
+
+uint16
+DIEClassType::Tag() const
+{
+ return DW_TAG_class_type;
+}
+
+
+// #pragma mark - DIEEntryPoint
+
+
+DIEEntryPoint::DIEEntryPoint()
+{
+}
+
+
+uint16
+DIEEntryPoint::Tag() const
+{
+ return DW_TAG_entry_point;
+}
+
+
+// #pragma mark - DIEEnumerationType
+
+
+DIEEnumerationType::DIEEnumerationType()
+{
+}
+
+
+uint16
+DIEEnumerationType::Tag() const
+{
+ return DW_TAG_enumeration_type;
+}
+
+
+// #pragma mark - DIEFormalParameter
+
+
+DIEFormalParameter::DIEFormalParameter()
+{
+}
+
+
+uint16
+DIEFormalParameter::Tag() const
+{
+ return DW_TAG_formal_parameter;
+}
+
+
+// #pragma mark - DIEImportedDeclaration
+
+
+DIEImportedDeclaration::DIEImportedDeclaration()
+{
+}
+
+
+uint16
+DIEImportedDeclaration::Tag() const
+{
+ return DW_TAG_imported_declaration;
+}
+
+
+// #pragma mark - DIELabel
+
+
+DIELabel::DIELabel()
+{
+}
+
+
+uint16
+DIELabel::Tag() const
+{
+ return DW_TAG_label;
+}
+
+
+// #pragma mark - DIELexicalBlock
+
+
+DIELexicalBlock::DIELexicalBlock()
+{
+}
[... truncated: 4738 lines follow ...]
More information about the Haiku-commits
mailing list