[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