haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2013-2018, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */
#ifndef DEBUG_INFO_ENTRIES_H
#define DEBUG_INFO_ENTRIES_H


#include "DebugInfoEntry.h"

#include "AttributeValue.h"


// common:
// DW_AT_name
// // not supported by all types:
// DW_AT_allocated
// DW_AT_associated
// DW_AT_data_location
// DW_AT_start_scope

// modified:
// DW_AT_type

// declared:
// DECL
// DW_AT_accessibility		// !file, !pointer to member
// DW_AT_declaration		// !file
// DW_AT_abstract_origin	// !interface
// DW_AT_description		// !interface
// DW_AT_visibility			// !interface

// derived: declared
// DW_AT_type

// addressing: modified
// DW_AT_address_class

// compound: declared
// DW_AT_byte_size			// !interface
// DW_AT_specification		// !interface

// class base: compound

// array index: derived
// DW_AT_bit_stride
// DW_AT_byte_stride
// DW_AT_byte_size


// unspecified: common
// DECL
// DW_AT_description



// class/structure: class base

// interface: class base

// union: compound

// string: declared
// DW_AT_byte_size
// DW_AT_string_length

// subroutine: declared
// DW_AT_address_class
// DW_AT_prototyped
// DW_AT_type


// enumeration: array index
// DW_AT_specification

// pointer to member: derived
// DW_AT_address_class
// DW_AT_containing_type
// DW_AT_use_location

// set: derived
// DW_AT_byte_size

// subrange: array index
// DW_AT_count
// DW_AT_lower_bound
// DW_AT_threads_scaled
// DW_AT_upper_bound

// array: derived
// DW_AT_bit_stride
// DW_AT_byte_size
// DW_AT_ordering
// DW_AT_specification

// typedef: derived

// file: derived
// DW_AT_byte_size


// shared: modified
// DECL
// DW_AT_count

// const: modified

// packed: modified

// volatile: modified
// DECL

// restrict: modified

// pointer: addressing
// DW_AT_specification

// reference: addressing


// basetype:
// DW_AT_binary_scale
// DW_AT_bit_offset
// DW_AT_bit_size
// DW_AT_byte_size
// DW_AT_decimal_scale
// DW_AT_decimal_sign
// DW_AT_description
// DW_AT_digit_count
// DW_AT_encoding
// DW_AT_endianity
// DW_AT_picture_string
// DW_AT_small


class DIECompileUnitBase : public DebugInfoEntry {
public:
								DIECompileUnitBase();
								~DIECompileUnitBase();

	virtual	status_t			InitAfterAttributes(
									DebugInfoEntryInitInfo& info);

	virtual	const char*			Name() const;

			const char*			CompilationDir() const
									{ return fCompilationDir; }

			uint16				Language() const	{ return fLanguage; }

			const DebugInfoEntryList& Types() const	{ return fTypes; }
			const DebugInfoEntryList& OtherChildren() const
										{ return fOtherChildren; }
			off_t				AddressRangesOffset() const
										{ return fAddressRangesOffset; }

			target_addr_t		LowPC() const	{ return fLowPC; }
			target_addr_t		HighPC() const	{ return fHighPC; }

			off_t				StatementListOffset() const
									{ return fStatementListOffset; }

			bool				ContainsMainSubprogram() const
									{ return fContainsMainSubprogram; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_comp_dir(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_low_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_high_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_producer(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_stmt_list(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_macro_info(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_base_types(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_language(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_identifier_case(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_use_UTF8(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_ranges(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_main_subprogram(
									uint16 attributeName,
									const AttributeValue& value);

//TODO:
//	virtual	status_t			AddAttribute_segment(uint16 attributeName,
//									const AttributeValue& value);

// TODO: DW_AT_import

protected:
			const char*			fName;
			const char*			fCompilationDir;
			target_addr_t		fLowPC;
			target_addr_t		fHighPC;
			off_t				fStatementListOffset;
			off_t				fMacroInfoOffset;
			off_t				fAddressRangesOffset;
			DIECompileUnitBase*	fBaseTypesUnit;
			DebugInfoEntryList	fTypes;
			DebugInfoEntryList	fOtherChildren;
			uint16				fLanguage;
			uint8				fIdentifierCase;
			bool				fUseUTF8;
			bool				fContainsMainSubprogram;
};


class DIEType : public DebugInfoEntry {
public:
								DIEType();

	virtual	bool				IsType() const;

	virtual	const char*			Name() const;

	virtual	bool				IsDeclaration() const;
	virtual	const DynamicAttributeValue* ByteSize() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_allocated(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_associated(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_data_location
// DW_AT_start_scope

protected:
			const char*			fName;
			DynamicAttributeValue fAllocated;
			DynamicAttributeValue fAssociated;
};


class DIEModifiedType : public DIEType {
public:
								DIEModifiedType();

			DIEType*			GetType() const	{ return fType; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

protected:
			DIEType*			fType;
};


class DIEAddressingType : public DIEModifiedType {
public:
								DIEAddressingType();

	virtual	status_t			AddAttribute_address_class(uint16 attributeName,
									const AttributeValue& value);

protected:
			uint8				fAddressClass;
};


class DIEDeclaredType : public DIEType {
public:
								DIEDeclaredType();

	virtual	const char*			Description() const;
	virtual	DebugInfoEntry*		AbstractOrigin() const;

	virtual DebugInfoEntry*		SignatureType() const;

	virtual	bool				IsDeclaration() const;

	virtual	status_t			AddAttribute_accessibility(uint16 attributeName,
									const AttributeValue& value);
										// TODO: !file, !pointer to member
	virtual	status_t			AddAttribute_declaration(uint16 attributeName,
									const AttributeValue& value);
										// TODO: !file
	virtual	status_t			AddAttribute_description(uint16 attributeName,
									const AttributeValue& value);
										// TODO: !interface
	virtual	status_t			AddAttribute_abstract_origin(
									uint16 attributeName,
									const AttributeValue& value);
										// TODO: !interface
	virtual	status_t			AddAttribute_signature(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_visibility			// !interface

protected:
	virtual	DeclarationLocation* GetDeclarationLocation();

protected:
			const char*			fDescription;
			DeclarationLocation	fDeclarationLocation;
			DebugInfoEntry*		fAbstractOrigin;
			DebugInfoEntry*		fSignatureType;
			uint8				fAccessibility;
			bool				fDeclaration;
};


class DIEDerivedType : public DIEDeclaredType {
public:
								DIEDerivedType();

			DIEType*			GetType() const	{ return fType; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

protected:
			DIEType*			fType;
};


class DIECompoundType : public DIEDeclaredType {
public:
								DIECompoundType();

	virtual	bool				IsNamespace() const;

	virtual	DebugInfoEntry*		Specification() const;

	virtual	const DynamicAttributeValue* ByteSize() const;

			const DebugInfoEntryList& DataMembers() const
									{ return fDataMembers; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);
										// TODO: !interface
	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);
										// TODO: !interface

protected:
			DynamicAttributeValue fByteSize;
			DIECompoundType*	fSpecification;
			DebugInfoEntryList	fDataMembers;
};


class DIEClassBaseType : public DIECompoundType {
public:
								DIEClassBaseType();

			const DebugInfoEntryList& BaseTypes() const
									{ return fBaseTypes; }
			const DebugInfoEntryList& MemberFunctions() const
									{ return fMemberFunctions; }
			const DebugInfoEntryList& InnerTypes() const
									{ return fInnerTypes; }
			const DebugInfoEntryList& TemplateParameters() const
									{ return fTemplateParameters; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

protected:
			DebugInfoEntryList	fBaseTypes;
			DebugInfoEntryList	fFriends;
			DebugInfoEntryList	fAccessDeclarations;
			DebugInfoEntryList	fMemberFunctions;
			DebugInfoEntryList	fInnerTypes;
			DebugInfoEntryList	fTemplateParameters;
};


class DIENamedBase : public DebugInfoEntry {
public:
								DIENamedBase();

	virtual	const char*			Name() const;
	virtual	const char*			Description() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_description(uint16 attributeName,
									const AttributeValue& value);

protected:
			const char*			fName;
			const char*			fDescription;
};


class DIEDeclaredBase : public DebugInfoEntry {
public:
								DIEDeclaredBase();

protected:
	virtual	DeclarationLocation* GetDeclarationLocation();

protected:
			DeclarationLocation	fDeclarationLocation;
};


class DIEDeclaredNamedBase : public DIEDeclaredBase {
public:
								DIEDeclaredNamedBase();

	virtual	const char*			Name() const;
	virtual	const char*			Description() const;

			uint8				Accessibility() const { return fAccessibility; }
			uint8				Visibility() const	{ return fVisibility; }
	virtual	bool				IsDeclaration() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_description(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_accessibility(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_declaration(uint16 attributeName,
									const AttributeValue& value);

protected:
			const char*			fName;
			const char*			fDescription;
			uint8				fAccessibility;
			uint8				fVisibility;
			bool				fDeclaration;
};


class DIEArrayIndexType : public DIEDerivedType {
public:
								DIEArrayIndexType();

	virtual	const DynamicAttributeValue* ByteSize() const;

			const DynamicAttributeValue* BitStride() const
									{ return &fBitStride; }
			const DynamicAttributeValue* ByteStride() const
									{ return &fByteStride; }

	virtual	status_t			AddAttribute_bit_stride(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_byte_stride(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fBitStride;
			DynamicAttributeValue fByteSize;
			DynamicAttributeValue fByteStride;
};


// #pragma mark -


class DIEArrayType : public DIEDerivedType {
public:
								DIEArrayType();

	virtual	uint16				Tag() const;

	virtual	status_t			InitAfterHierarchy(
									DebugInfoEntryInitInfo& info);

	virtual	DebugInfoEntry*		Specification() const;

	virtual	const DynamicAttributeValue* ByteSize() const;

			const DynamicAttributeValue* BitStride() const
									{ return &fBitStride; }

			const DebugInfoEntryList& Dimensions() const
									{ return fDimensions; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_ordering(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_bit_stride(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_stride_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fBitStride;
			DynamicAttributeValue fByteSize;
			DebugInfoEntryList	fDimensions;
			DIEArrayType*		fSpecification;
			uint8				fOrdering;
};


class DIEClassType : public DIEClassBaseType {
public:
								DIEClassType();

	virtual	uint16				Tag() const;
};


class DIEEntryPoint : public DebugInfoEntry {
public:
// TODO: Maybe introduce a common base class for DIEEntryPoint and
// DIESubprogram.
								DIEEntryPoint();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_address_class
// DW_AT_description
// DW_AT_frame_base
// DW_AT_low_pc
// DW_AT_name
// DW_AT_return_addr
// DW_AT_segment
// DW_AT_static_link
// DW_AT_type
};


class DIEEnumerationType : public DIEArrayIndexType {
public:
								DIEEnumerationType();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		Specification() const;

			const DebugInfoEntryList& Enumerators() const
									{ return fEnumerators; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);

private:
			DIEEnumerationType*	fSpecification;
			DebugInfoEntryList	fEnumerators;
};


class DIEFormalParameter : public DIEDeclaredNamedBase {
public:
								DIEFormalParameter();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		AbstractOrigin() const;
	virtual	LocationDescription* GetLocationDescription();

			DIEType*			GetType() const	{ return fType; }

			const ConstantAttributeValue* ConstValue() const
									{ return &fValue; }

			bool				IsArtificial() const { return fArtificial; }

	virtual	status_t			AddAttribute_abstract_origin(
									uint16 attributeName,
									const AttributeValue& value);
	virtual status_t			AddAttribute_artificial(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_const_value(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_default_value
// DW_AT_endianity
// DW_AT_is_optional
// DW_AT_segment
// DW_AT_variable_parameter

private:
			LocationDescription	fLocationDescription;
			DebugInfoEntry*		fAbstractOrigin;
			DIEType*			fType;
			ConstantAttributeValue fValue;
			bool				fArtificial;
};


class DIEImportedDeclaration : public DIEDeclaredNamedBase {
public:
								DIEImportedDeclaration();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_import
// DW_AT_start_scope
};


class DIELabel : public DIEDeclaredNamedBase {
public:
								DIELabel();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_low_pc
// DW_AT_segment
// DW_AT_start_scope
};


class DIELexicalBlock : public DIENamedBase {
public:
								DIELexicalBlock();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		AbstractOrigin() const;

			off_t				AddressRangesOffset() const
										{ return fAddressRangesOffset; }

			target_addr_t		LowPC() const	{ return fLowPC; }
			target_addr_t		HighPC() const	{ return fHighPC; }

			const DebugInfoEntryList& Variables() const	{ return fVariables; }
			const DebugInfoEntryList& Blocks() const	{ return fBlocks; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_low_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_high_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_ranges(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_abstract_origin(
									uint16 attributeName,
									const AttributeValue& value);

protected:
			DebugInfoEntryList	fVariables;
			DebugInfoEntryList	fBlocks;
			target_addr_t		fLowPC;
			target_addr_t		fHighPC;
			off_t				fAddressRangesOffset;
			DIELexicalBlock*	fAbstractOrigin;

// TODO:
// DW_AT_segment
};


class DIEMember : public DIEDeclaredNamedBase {
public:
								DIEMember();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }
			const DynamicAttributeValue* ByteSize() const
									{ return &fByteSize; }
			const DynamicAttributeValue* BitOffset() const
									{ return &fBitOffset; }
			const DynamicAttributeValue* DataBitOffset() const
									{ return &fDataBitOffset; }
			const DynamicAttributeValue* BitSize() const
									{ return &fBitSize; }
			const MemberLocation* Location() const
									{ return &fLocation; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_bit_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_bit_offset(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_data_bit_offset(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_data_member_location(
									uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_mutable

private:
			DIEType*			fType;
			DynamicAttributeValue fByteSize;
			DynamicAttributeValue fBitOffset;
			DynamicAttributeValue fDataBitOffset;
			DynamicAttributeValue fBitSize;
			MemberLocation		fLocation;
};


class DIEPointerType : public DIEAddressingType {
public:
								DIEPointerType();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		Specification() const;

	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);

private:
			DIEPointerType*		fSpecification;
};


class DIEReferenceType : public DIEAddressingType {
public:
								DIEReferenceType();

	virtual	uint16				Tag() const;
};


class DIECompileUnit : public DIECompileUnitBase {
public:
								DIECompileUnit();

	virtual	uint16				Tag() const;
};


class DIEStringType : public DIEDeclaredType {
public:
								DIEStringType();

	virtual	uint16				Tag() const;

	virtual	const DynamicAttributeValue* ByteSize() const;

	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fByteSize;
// TODO:
// DW_AT_string_length
};


class DIEStructureType : public DIEClassBaseType {
public:
								DIEStructureType();

	virtual	uint16				Tag() const;
};


class DIESubroutineType : public DIEDeclaredType {
public:
								DIESubroutineType();

	virtual	uint16				Tag() const;

			DIEType*			ReturnType() const	{ return fReturnType; }

			const DebugInfoEntryList& Parameters() const { return fParameters; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_address_class(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_prototyped(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

protected:
			DebugInfoEntryList	fParameters;
			DIEType*			fReturnType;
			uint8				fAddressClass;
			bool				fPrototyped;
};


class DIETypedef : public DIEDerivedType {
public:
								DIETypedef();

	virtual	uint16				Tag() const;
};


class DIEUnionType : public DIECompoundType {
public:
								DIEUnionType();

	virtual	uint16				Tag() const;
};


class DIEUnspecifiedParameters : public DIEDeclaredBase {
public:
								DIEUnspecifiedParameters();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_artificial
};


class DIEVariant : public DIEDeclaredBase {
public:
								DIEVariant();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_accessibility
// DW_AT_abstract_origin
// DW_AT_declaration
// DW_AT_discr_list
// DW_AT_discr_value
};


class DIECommonBlock : public DIEDeclaredNamedBase {
public:
								DIECommonBlock();

	virtual	uint16				Tag() const;

	virtual	LocationDescription* GetLocationDescription();

// TODO:
// DW_AT_segment

private:
			LocationDescription	fLocationDescription;
};


class DIECommonInclusion : public DIEDeclaredBase {
public:
								DIECommonInclusion();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_common_reference
// DW_AT_declaration
// DW_AT_visibility

};


class DIEInheritance : public DIEDeclaredBase {
public:
								DIEInheritance();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }
			const MemberLocation* Location() const
									{ return &fLocation; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_data_member_location(
									uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_accessibility
// DW_AT_virtuality

private:
			DIEType*			fType;
			MemberLocation		fLocation;
};


class DIEInlinedSubroutine : public DebugInfoEntry {
public:
								DIEInlinedSubroutine();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_call_column
// DW_AT_call_file
// DW_AT_call_line
// DW_AT_entry_pc
// DW_AT_high_pc
// DW_AT_low_pc
// DW_AT_ranges
// DW_AT_return_addr
// DW_AT_segment
// DW_AT_start_scope
// DW_AT_trampoline
};


class DIEModule : public DIEDeclaredNamedBase {
public:
								DIEModule();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_entry_pc
// DW_AT_high_pc
// DW_AT_low_pc
// DW_AT_priority
// DW_AT_ranges
// DW_AT_segment
// DW_AT_specification
};


class DIEPointerToMemberType : public DIEDerivedType {
public:
								DIEPointerToMemberType();

	virtual	uint16				Tag() const;

			DIECompoundType*	ContainingType() const
									{ return fContainingType; }

			const LocationDescription& UseLocation() const
									{ return fUseLocation; }

	virtual	status_t			AddAttribute_address_class(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_containing_type(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_use_location(uint16 attributeName,
									const AttributeValue& value);

protected:
			DIECompoundType*	fContainingType;
			LocationDescription	fUseLocation;
			uint8				fAddressClass;
};


class DIESetType : public DIEDerivedType {
public:
								DIESetType();

	virtual	uint16				Tag() const;

	virtual	const DynamicAttributeValue* ByteSize() const;

	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fByteSize;
};


class DIESubrangeType : public DIEArrayIndexType {
public:
								DIESubrangeType();

	virtual	uint16				Tag() const;

			const DynamicAttributeValue* LowerBound() const
									{ return &fLowerBound; }
			const DynamicAttributeValue* UpperBound() const
									{ return &fUpperBound; }
			const DynamicAttributeValue* Count() const
									{ return &fCount; }

	virtual	status_t			AddAttribute_count(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_lower_bound(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_upper_bound(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_threads_scaled(
									uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fCount;
			DynamicAttributeValue fLowerBound;
			DynamicAttributeValue fUpperBound;
			bool				fThreadsScaled;
};


class DIEWithStatement : public DebugInfoEntry {
public:
								DIEWithStatement();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

	virtual	LocationDescription* GetLocationDescription();

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_accessibility
// DW_AT_address_class
// DW_AT_declaration
// DW_AT_high_pc
// DW_AT_low_pc
// DW_AT_ranges
// DW_AT_segment
// DW_AT_visibility

private:
			DIEType*			fType;
			LocationDescription	fLocationDescription;
};


class DIEAccessDeclaration : public DIEDeclaredNamedBase {
public:
								DIEAccessDeclaration();

	virtual	uint16				Tag() const;
};


class DIEBaseType : public DIEType {
public:
								DIEBaseType();

	virtual	uint16				Tag() const;

	virtual	const DynamicAttributeValue* ByteSize() const;
			const DynamicAttributeValue* BitOffset() const
									{ return &fBitOffset; }
			const DynamicAttributeValue* DataBitOffset() const
									{ return &fDataBitOffset; }
			const DynamicAttributeValue* BitSize() const
									{ return &fBitSize; }
			uint8				Encoding() const	{ return fEncoding; }
			uint8				Endianity() const	{ return fEndianity; }

	virtual	status_t			AddAttribute_encoding(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_bit_size(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_bit_offset(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_data_bit_offset(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_endianity(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_binary_scale
// DW_AT_decimal_scale
// DW_AT_decimal_sign
// DW_AT_description
// DW_AT_digit_count
// DW_AT_picture_string
// DW_AT_small

private:
			DynamicAttributeValue fByteSize;
			DynamicAttributeValue fBitOffset;
			DynamicAttributeValue fDataBitOffset;
			DynamicAttributeValue fBitSize;
			uint8				fEncoding;
			uint8				fEndianity;
};


class DIECatchBlock : public DebugInfoEntry {
public:
								DIECatchBlock();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_high_pc
// DW_AT_low_pc
// DW_AT_ranges
// DW_AT_segment
};


class DIEConstType : public DIEModifiedType {
public:
								DIEConstType();

	virtual	uint16				Tag() const;
};


class DIEConstant : public DIEDeclaredNamedBase {
public:
								DIEConstant();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

			const ConstantAttributeValue* ConstValue() const
									{ return &fValue; }

	virtual	status_t			AddAttribute_const_value(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_endianity
// DW_AT_external
// DW_AT_start_scope

private:
			DIEType*			fType;
			ConstantAttributeValue fValue;
};


class DIEEnumerator : public DIEDeclaredNamedBase {
public:
								DIEEnumerator();

	virtual	uint16				Tag() const;

			const ConstantAttributeValue* ConstValue() const
									{ return &fValue; }

	virtual	status_t			AddAttribute_const_value(uint16 attributeName,
									const AttributeValue& value);

private:
			ConstantAttributeValue fValue;
};


class DIEFileType : public DIEDerivedType {
public:
								DIEFileType();

	virtual	uint16				Tag() const;

	virtual	const DynamicAttributeValue* ByteSize() const;

	virtual	status_t			AddAttribute_byte_size(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fByteSize;
};


class DIEFriend : public DIEDeclaredBase {
public:
								DIEFriend();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_friend
};


class DIENameList : public DIEDeclaredNamedBase {
public:
								DIENameList();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
};


class DIENameListItem : public DIEDeclaredBase {
public:
								DIENameListItem();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_namelist_item
};


class DIENamespace : public DIEDeclaredNamedBase {
public:
								DIENamespace();

	virtual	uint16				Tag() const;

	virtual	bool				IsNamespace() const;

			const DebugInfoEntryList& Children() const
										{ return fChildren; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

private:
			DebugInfoEntryList	fChildren;

// TODO:
// DW_AT_extension
// DW_AT_start_scope
};


class DIEPackedType : public DIEModifiedType {
public:
								DIEPackedType();

	virtual	uint16				Tag() const;
};


class DIESubprogram : public DIENamespace {
public:
								DIESubprogram();
								~DIESubprogram();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		Specification() const;
	virtual	DebugInfoEntry*		AbstractOrigin() const;

			off_t				AddressRangesOffset() const
										{ return fAddressRangesOffset; }

			target_addr_t		LowPC() const	{ return fLowPC; }
			target_addr_t		HighPC() const	{ return fHighPC; }

			const LocationDescription* FrameBase() const { return &fFrameBase; }

			const DebugInfoEntryList Parameters() const	{ return fParameters; }
			const DebugInfoEntryList Variables() const	{ return fVariables; }
			const DebugInfoEntryList Blocks() const		{ return fBlocks; }
			const DebugInfoEntryList TemplateTypeParameters() const
										{ return fTemplateTypeParameters; }
			const DebugInfoEntryList TemplateValueParameters() const
										{ return fTemplateValueParameters; }
			const DebugInfoEntryList CallSites() const
										{ return fCallSites; }

			bool				IsPrototyped() const	{ return fPrototyped; }
			uint8				Inline() const			{ return fInline; }
			bool				IsArtificial() const	{ return fArtificial; }
			uint8				CallingConvention() const
										{ return fCallingConvention; }
			bool				IsMain() const			{ return fMain; }

			DIEType*			ReturnType() const		{ return fReturnType; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

	virtual	status_t			AddAttribute_low_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_high_pc(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_ranges(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_address_class(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_prototyped(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_inline(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_abstract_origin(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_frame_base(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_artificial(
									uint16 attributeName,
									const AttributeValue& value);
	virtual status_t			AddAttribute_calling_convention(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_main_subprogram(
									uint16 attributeName,
									const AttributeValue& value);


protected:
			DebugInfoEntryList	fParameters;
			DebugInfoEntryList	fVariables;
			DebugInfoEntryList	fBlocks;
			DebugInfoEntryList	fTemplateTypeParameters;
			DebugInfoEntryList	fTemplateValueParameters;
			DebugInfoEntryList	fCallSites;
			target_addr_t		fLowPC;
			target_addr_t		fHighPC;
			off_t				fAddressRangesOffset;
			DIESubprogram*		fSpecification;
			DIESubprogram*		fAbstractOrigin;
			DIEType*			fReturnType;
			LocationDescription	fFrameBase;
			uint8				fAddressClass;
			bool				fPrototyped;
			uint8				fInline;
			bool				fMain;
			bool				fArtificial;
			uint8				fCallingConvention;

// TODO:
// DW_AT_elemental
// DW_AT_entry_pc
// DW_AT_explicit
// DW_AT_external
// DW_AT_object_pointer
// DW_AT_pure
// DW_AT_recursive
// DW_AT_return_addr
// DW_AT_segment
// DW_AT_start_scope
// DW_AT_static_link
// DW_AT_trampoline
// DW_AT_virtuality
// DW_AT_vtable_elem_location
};


class DIETemplateTypeParameter : public DIEDeclaredNamedBase {
public:
								DIETemplateTypeParameter();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

private:
			DIEType*			fType;
};


class DIETemplateValueParameter : public DIEDeclaredNamedBase {
public:
								DIETemplateValueParameter();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

			const ConstantAttributeValue* ConstValue() const
									{ return &fValue; }

	virtual	status_t			AddAttribute_const_value(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

private:
			DIEType*			fType;
			ConstantAttributeValue fValue;
};


class DIEThrownType : public DIEDeclaredBase {
public:
								DIEThrownType();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_allocated
// DW_AT_associated
// DW_AT_data_location

private:
			DIEType*			fType;
};


class DIETryBlock : public DebugInfoEntry {
public:
								DIETryBlock();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_abstract_origin
// DW_AT_high_pc
// DW_AT_low_pc
// DW_AT_ranges
// DW_AT_segment
};


class DIEVariantPart : public DIEDeclaredBase {
public:
								DIEVariantPart();

	virtual	uint16				Tag() const;

			DIEType*			GetType() const	{ return fType; }

	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_abstract_origin
// DW_AT_accessibility
// DW_AT_declaration
// DW_AT_discr

private:
			DIEType*			fType;
};


class DIEVariable : public DIEDeclaredNamedBase {
public:
								DIEVariable();

	virtual	uint16				Tag() const;

	virtual	DebugInfoEntry*		Specification() const;
	virtual	DebugInfoEntry*		AbstractOrigin() const;

	virtual	LocationDescription* GetLocationDescription();

			DIEType*			GetType() const	{ return fType; }

			const ConstantAttributeValue* ConstValue() const
									{ return &fValue; }

			uint64				StartScope() const	{ return fStartScope; }

			bool				IsExternal() const	{ return fIsExternal; }

	virtual	status_t			AddAttribute_const_value(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_type(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_specification(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_abstract_origin(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_start_scope(
									uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_external(
									uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_endianity
// DW_AT_segment

private:
			LocationDescription	fLocationDescription;
			ConstantAttributeValue fValue;
			DIEType*			fType;
			DebugInfoEntry*		fSpecification;
			DIEVariable*		fAbstractOrigin;
			uint64				fStartScope;
			bool				fIsExternal;
};


class DIEVolatileType : public DIEModifiedType {
public:
								DIEVolatileType();

	virtual	uint16				Tag() const;

	virtual	status_t			AddAttribute_decl_file(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_line(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_column(uint16 attributeName,
									const AttributeValue& value);

private:
			DeclarationLocation	fDeclarationLocation;
};


class DIEDwarfProcedure : public DebugInfoEntry {
public:
								DIEDwarfProcedure();

	virtual	uint16				Tag() const;

	virtual	LocationDescription* GetLocationDescription();

private:
			LocationDescription	fLocationDescription;
};


class DIERestrictType : public DIEModifiedType {
public:
								DIERestrictType();

	virtual	uint16				Tag() const;
};


class DIEInterfaceType : public DIEClassBaseType {
public:
								DIEInterfaceType();

	virtual	uint16				Tag() const;
};


class DIEImportedModule : public DIEDeclaredBase {
public:
								DIEImportedModule();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_import
// DW_AT_start_scope
};


class DIEUnspecifiedType : public DIEType {
public:
								DIEUnspecifiedType();

	virtual	uint16				Tag() const;

	virtual	status_t			AddAttribute_decl_file(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_line(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_column(uint16 attributeName,
									const AttributeValue& value);

// TODO:
// DW_AT_description

private:
			DeclarationLocation	fDeclarationLocation;
};


class DIEPartialUnit : public DIECompileUnitBase {
public:
								DIEPartialUnit();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_description
};


class DIEImportedUnit : public DebugInfoEntry {
public:
								DIEImportedUnit();

	virtual	uint16				Tag() const;

// TODO:
// DW_AT_import
};


class DIECondition : public DIEDeclaredNamedBase {
public:
								DIECondition();

	virtual	uint16				Tag() const;
};


class DIESharedType : public DIEModifiedType {
public:
								DIESharedType();

	virtual	uint16				Tag() const;

	virtual	status_t			AddAttribute_count(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_file(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_line(uint16 attributeName,
									const AttributeValue& value);
	virtual	status_t			AddAttribute_decl_column(uint16 attributeName,
									const AttributeValue& value);

private:
			DynamicAttributeValue fBlockSize;
			DeclarationLocation	fDeclarationLocation;
};


class DIETypeUnit : public DIECompileUnitBase {
public:
								DIETypeUnit();

	virtual	uint16				Tag() const;
};


class DIERValueReferenceType : public DIEReferenceType {
public:
								DIERValueReferenceType();

	virtual	uint16				Tag() const;
};


class DIETemplateTemplateParameter : public DIEDeclaredBase {
public:
								DIETemplateTemplateParameter();

	virtual	uint16				Tag() const;

	virtual	const char*			Name() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);

private:
			const char*			fName;
};


class DIETemplateTypeParameterPack : public DIEDeclaredBase {
public:
								DIETemplateTypeParameterPack();

	virtual	uint16				Tag() const;

	virtual	const char*			Name() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);

			const DebugInfoEntryList& Children() const
										{ return fChildren; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

private:
			const char*			fName;
			DebugInfoEntryList	fChildren;
};


class DIETemplateValueParameterPack : public DIEDeclaredBase {
public:
								DIETemplateValueParameterPack();

	virtual	uint16				Tag() const;

	virtual	const char*			Name() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);

			const DebugInfoEntryList& Children() const
										{ return fChildren; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

private:
			const char*			fName;
			DebugInfoEntryList	fChildren;
};


class DIECallSite : public DIEDeclaredBase {
public:
								DIECallSite();

	virtual	uint16				Tag() const;

	virtual	const char*			Name() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);

			const DebugInfoEntryList& Children() const
										{ return fChildren; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

private:
			const char*			fName;
			DebugInfoEntryList	fChildren;
};


class DIECallSiteParameter : public DIEDeclaredBase {
public:
								DIECallSiteParameter();

	virtual	uint16				Tag() const;

	virtual	const char*			Name() const;

	virtual	status_t			AddAttribute_name(uint16 attributeName,
									const AttributeValue& value);

			const DebugInfoEntryList& Children() const
										{ return fChildren; }

	virtual	status_t			AddChild(DebugInfoEntry* child);

private:
			const char*			fName;
			DebugInfoEntryList	fChildren;
};


// #pragma mark - DebugInfoEntryFactory


class DebugInfoEntryFactory {
public:
								DebugInfoEntryFactory();

			status_t			CreateDebugInfoEntry(uint16 tag,
									DebugInfoEntry*& entry);
};


#endif	// DEBUG_INFO_ENTRIES_H