/*
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copryight 2012-2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "DwarfTypes.h"

#include <new>

#include "Architecture.h"
#include "ArrayIndexPath.h"
#include "CompilationUnit.h"
#include "Dwarf.h"
#include "DwarfFile.h"
#include "DwarfTargetInterface.h"
#include "DwarfUtils.h"
#include "Register.h"
#include "RegisterMap.h"
#include "Tracing.h"
#include "ValueLocation.h"


namespace {


// #pragma mark - HasBitStridePredicate


template<typename EntryType>
struct HasBitStridePredicate {
        inline bool operator()(EntryType* entry) const
        {
                return entry->BitStride()->IsValid();
        }
};


// #pragma mark - HasByteStridePredicate


template<typename EntryType>
struct HasByteStridePredicate {
        inline bool operator()(EntryType* entry) const
        {
                return entry->ByteStride()->IsValid();
        }
};


}       // unnamed namespace


type_kind
dwarf_tag_to_type_kind(int32 tag)
{
        switch (tag) {
                case DW_TAG_class_type:
                case DW_TAG_structure_type:
                case DW_TAG_union_type:
                case DW_TAG_interface_type:
                        return TYPE_COMPOUND;

                case DW_TAG_base_type:
                        return TYPE_PRIMITIVE;

                case DW_TAG_pointer_type:
                case DW_TAG_reference_type:
                        return TYPE_ADDRESS;

                case DW_TAG_const_type:
                case DW_TAG_packed_type:
                case DW_TAG_volatile_type:
                case DW_TAG_restrict_type:
                case DW_TAG_shared_type:
                        return TYPE_MODIFIED;

                case DW_TAG_typedef:
                        return TYPE_TYPEDEF;

                case DW_TAG_array_type:
                        return TYPE_ARRAY;

                case DW_TAG_enumeration_type:
                        return TYPE_ENUMERATION;

                case DW_TAG_subrange_type:
                        return TYPE_SUBRANGE;

                case DW_TAG_unspecified_type:
                        return TYPE_UNSPECIFIED;

                case DW_TAG_subroutine_type:
                        return TYPE_FUNCTION;

                case DW_TAG_ptr_to_member_type:
                        return TYPE_POINTER_TO_MEMBER;

        }

        return TYPE_UNSPECIFIED;
}


int32
dwarf_tag_to_subtype_kind(int32 tag)
{
        switch (tag) {
                case DW_TAG_class_type:
                        return COMPOUND_TYPE_CLASS;

                case DW_TAG_structure_type:
                        return COMPOUND_TYPE_STRUCT;

                case DW_TAG_union_type:
                        return COMPOUND_TYPE_UNION;

                case DW_TAG_interface_type:
                        return COMPOUND_TYPE_INTERFACE;

                case DW_TAG_pointer_type:
                        return DERIVED_TYPE_POINTER;

                case DW_TAG_reference_type:
                        return DERIVED_TYPE_REFERENCE;
        }

        return -1;
}


// #pragma mark - DwarfTypeContext


DwarfTypeContext::DwarfTypeContext(Architecture* architecture, image_id imageID,
        DwarfFile* file, CompilationUnit* compilationUnit,
        DIESubprogram* subprogramEntry, target_addr_t instructionPointer,
        target_addr_t framePointer, target_addr_t relocationDelta,
        DwarfTargetInterface* targetInterface, RegisterMap* fromDwarfRegisterMap)
        :
        fArchitecture(architecture),
        fImageID(imageID),
        fFile(file),
        fCompilationUnit(compilationUnit),
        fSubprogramEntry(subprogramEntry),
        fInstructionPointer(instructionPointer),
        fFramePointer(framePointer),
        fRelocationDelta(relocationDelta),
        fTargetInterface(targetInterface),
        fFromDwarfRegisterMap(fromDwarfRegisterMap)
{
        fArchitecture->AcquireReference();
        fFile->AcquireReference();
        if (fTargetInterface != NULL)
                fTargetInterface->AcquireReference();
}


DwarfTypeContext::~DwarfTypeContext()
{
        fArchitecture->ReleaseReference();
        fFile->ReleaseReference();
        if (fTargetInterface != NULL)
                fTargetInterface->ReleaseReference();
}


uint8
DwarfTypeContext::AddressSize() const
{
        return fCompilationUnit != NULL ? fCompilationUnit->AddressSize()
                : fArchitecture->AddressSize();
}


bool
DwarfTypeContext::IsBigEndian() const
{
        return fCompilationUnit != NULL ? fCompilationUnit->IsBigEndian()
                : fArchitecture->IsBigEndian();
}


// #pragma mark - DwarfType


DwarfType::DwarfType(DwarfTypeContext* typeContext, const BString& name,
        const DIEType* entry)
        :
        fTypeContext(typeContext),
        fName(name),
        fByteSize(0)
{
        fTypeContext->AcquireReference();

        GetTypeID(entry, fID);
}


DwarfType::~DwarfType()
{
        fTypeContext->ReleaseReference();
}


/*static*/ bool
DwarfType::GetTypeID(const DIEType* entry, BString& _id)
{
        char buffer[32];
        snprintf(buffer, sizeof(buffer), "dwarf:%p", entry);
        BString id = buffer;
        if (id.Length() == 0)
                return false;

        _id = id;
        return true;
}


image_id
DwarfType::ImageID() const
{
        return fTypeContext->ImageID();
}


const BString&
DwarfType::ID() const
{
        return fID;
}


const BString&
DwarfType::Name() const
{
        return fName;
}


target_size_t
DwarfType::ByteSize() const
{
        return fByteSize;
}


status_t
DwarfType::CreateDerivedAddressType(address_type_kind addressType,
        AddressType*& _resultType)
{
        BString derivedName;
        derivedName.SetToFormat("%s%c", fName.String(),
                addressType == DERIVED_TYPE_POINTER ? '*' : '&');
        DwarfAddressType* resultType = new(std::nothrow)
                DwarfAddressType(fTypeContext, derivedName, NULL, addressType, this);

        if (resultType == NULL)
                return B_NO_MEMORY;

        resultType->SetByteSize(fTypeContext->GetArchitecture()->AddressSize());

        _resultType = resultType;
        return B_OK;
}


status_t
DwarfType::CreateDerivedArrayType(int64 lowerBound, int64 elementCount,
        bool extendExisting, ArrayType*& _resultType)
{
        DwarfArrayType* resultType = NULL;
        BReference<DwarfType> baseTypeReference;
        if (extendExisting)
                resultType = dynamic_cast<DwarfArrayType*>(this);

        if (resultType == NULL) {
                BString derivedName;
                derivedName.SetToFormat("%s[]", fName.String());
                resultType = new(std::nothrow)
                        DwarfArrayType(fTypeContext, derivedName, NULL, this);
                baseTypeReference.SetTo(resultType, true);
        }

        if (resultType == NULL)
                return B_NO_MEMORY;

        DwarfSubrangeType* subrangeType = new(std::nothrow) DwarfSubrangeType(
                fTypeContext, fName, NULL, resultType, BVariant(lowerBound),
                BVariant(lowerBound + elementCount - 1));
        if (subrangeType == NULL)
                return B_NO_MEMORY;

        BReference<DwarfSubrangeType> subrangeReference(subrangeType, true);

        DwarfArrayDimension* dimension = new(std::nothrow) DwarfArrayDimension(
                subrangeType);
        if (dimension == NULL)
                return B_NO_MEMORY;
        BReference<DwarfArrayDimension> dimensionReference(dimension, true);

        if (!resultType->AddDimension(dimension))
                return B_NO_MEMORY;

        baseTypeReference.Detach();

        _resultType = resultType;
        return B_OK;
}


status_t
DwarfType::ResolveObjectDataLocation(const ValueLocation& objectLocation,
        ValueLocation*& _location)
{
        // TODO: In some source languages the object address might be a pointer
        // to a descriptor, not the actual object data.

        // If the given location looks good already, just clone it.
        int32 count = objectLocation.CountPieces();
        if (count == 0)
                return B_BAD_VALUE;

        ValuePieceLocation piece;
        if (!piece.Copy(objectLocation.PieceAt(0)))
                return B_NO_MEMORY;

        if (count > 1 || piece.type != VALUE_PIECE_LOCATION_MEMORY
                || piece.size != 0 || piece.bitSize != 0) {
                ValueLocation* location
                        = new(std::nothrow) ValueLocation(objectLocation);
                if (location == NULL || location->CountPieces() != count) {
                        delete location;
                        return B_NO_MEMORY;
                }

                _location = location;
                return B_OK;
        }

        // The location contains just a single address piece with a zero size
        // -- set the type's size.
        piece.SetSize(ByteSize());
                // TODO: Use bit size and bit offset, if specified!

        ValueLocation* location = new(std::nothrow) ValueLocation(
                objectLocation.IsBigEndian());
        if (location == NULL || !location->AddPiece(piece)) {
                delete location;
                return B_NO_MEMORY;
        }

        _location = location;
        return B_OK;
}


status_t
DwarfType::ResolveObjectDataLocation(target_addr_t objectAddress,
        ValueLocation*& _location)
{
        ValuePieceLocation piece;
        piece.SetToMemory(objectAddress);
        piece.SetSize(0);
                // We set the piece size to 0 as an indicator that the size has to be
                // set.
                // TODO: We could set the byte size from type, but that may not be
                // accurate. We may want to add bit offset and size to Type.

        ValueLocation location(fTypeContext->GetArchitecture()->IsBigEndian());
        if (!location.AddPiece(piece))
                return B_NO_MEMORY;

        return ResolveObjectDataLocation(location, _location);
}


status_t
DwarfType::ResolveLocation(DwarfTypeContext* typeContext,
        const LocationDescription* description, target_addr_t objectAddress,
        bool hasObjectAddress, ValueLocation& _location)
{
        status_t error = typeContext->File()->ResolveLocation(
                typeContext->GetCompilationUnit(),
                typeContext->AddressSize(), typeContext->IsBigEndian(),
                typeContext->SubprogramEntry(), description,
                typeContext->TargetInterface(), typeContext->InstructionPointer(),
                objectAddress, hasObjectAddress, typeContext->FramePointer(),
                typeContext->RelocationDelta(), _location);
        if (error != B_OK)
                return error;

        // translate the DWARF register indices and the bit offset/size semantics
        const Register* registers = typeContext->GetArchitecture()->Registers();
        bool bigEndian = typeContext->GetArchitecture()->IsBigEndian();
        int32 count = _location.CountPieces();
        for (int32 i = 0; i < count; i++) {
                ValuePieceLocation piece;
                if (!piece.Copy(_location.PieceAt(i)))
                        return B_NO_MEMORY;

                if (piece.type == VALUE_PIECE_LOCATION_REGISTER) {
                        int32 reg = typeContext->FromDwarfRegisterMap()->MapRegisterIndex(
                                piece.reg);
                        if (reg >= 0) {
                                piece.reg = reg;
                                // The bit offset for registers is to the least
                                // significant bit, while we want the offset to the most
                                // significant bit.
                                if (registers[reg].BitSize() > piece.bitSize) {
                                        piece.bitOffset = registers[reg].BitSize() - piece.bitSize
                                                - piece.bitOffset;
                                }
                        } else
                                piece.SetToUnknown();
                } else if (piece.type == VALUE_PIECE_LOCATION_MEMORY) {
                        // Whether the bit offset is to the least or most significant bit
                        // is target architecture and source language specific.
                        // TODO: Check whether this is correct!
                        // TODO: Source language!
                        if (!bigEndian && piece.size * 8 > piece.bitSize) {
                                piece.bitOffset = piece.size * 8 - piece.bitSize
                                        - piece.bitOffset;
                        }
                }

                piece.Normalize(bigEndian);
                if (!_location.SetPieceAt(i, piece))
                        return B_NO_MEMORY;
        }

        // If we only have one piece and that doesn't have a size, try to retrieve
        // the size of the type.
        if (count == 1) {
                ValuePieceLocation piece;
                if (!piece.Copy(_location.PieceAt(0)))
                        return B_NO_MEMORY;

                if (piece.IsValid() && piece.size == 0 && piece.bitSize == 0) {
                        piece.SetSize(ByteSize());
                                // TODO: Use bit size and bit offset, if specified!
                        if (!_location.SetPieceAt(0, piece))
                                return B_NO_MEMORY;

                        TRACE_LOCALS("  set single piece size to %" B_PRIu64 "\n",
                                ByteSize());
                }
        }

        return B_OK;
}


// #pragma mark - DwarfInheritance


DwarfInheritance::DwarfInheritance(DIEInheritance* entry, DwarfType* type)
        :
        fEntry(entry),
        fType(type)
{
        fType->AcquireReference();
}


DwarfInheritance::~DwarfInheritance()
{
        fType->ReleaseReference();
}


Type*
DwarfInheritance::GetType() const
{
        return fType;
}


// #pragma mark - DwarfDataMember


DwarfDataMember::DwarfDataMember(DIEMember* entry, const BString& name,
        DwarfType* type)
        :
        fEntry(entry),
        fName(name),
        fType(type)
{
        fType->AcquireReference();
}


DwarfDataMember::~DwarfDataMember()
{
        fType->ReleaseReference();
}

const char*
DwarfDataMember::Name() const
{
        return fName.Length() > 0 ? fName.String() : NULL;
}


Type*
DwarfDataMember::GetType() const
{
        return fType;
}


// #pragma mark - DwarfEnumeratorValue


DwarfEnumeratorValue::DwarfEnumeratorValue(DIEEnumerator* entry,
        const BString& name, const BVariant& value)
        :
        fEntry(entry),
        fName(name),
        fValue(value)
{
}


DwarfEnumeratorValue::~DwarfEnumeratorValue()
{
}

const char*
DwarfEnumeratorValue::Name() const
{
        return fName.Length() > 0 ? fName.String() : NULL;
}


BVariant
DwarfEnumeratorValue::Value() const
{
        return fValue;
}


// #pragma mark - DwarfArrayDimension


DwarfArrayDimension::DwarfArrayDimension(DwarfType* type)
        :
        fType(type)
{
        fType->AcquireReference();
}


DwarfArrayDimension::~DwarfArrayDimension()
{
        fType->ReleaseReference();
}


Type*
DwarfArrayDimension::GetType() const
{
        return fType;
}


// #pragma mark - DwarfFunctionParameter


DwarfFunctionParameter::DwarfFunctionParameter(DIEFormalParameter* entry,
        const BString& name, DwarfType* type)
        :
        fEntry(entry),
        fName(name),
        fType(type)
{
        fType->AcquireReference();
}


DwarfFunctionParameter::~DwarfFunctionParameter()
{
        fType->ReleaseReference();
}


const char*
DwarfFunctionParameter::Name() const
{
        return fName.Length() > 0 ? fName.String() : NULL;
}


Type*
DwarfFunctionParameter::GetType() const
{
        return fType;
}


// #pragma mark - DwarfTemplateParameter


DwarfTemplateParameter::DwarfTemplateParameter(DebugInfoEntry* entry,
        DwarfType* type)
        :
        fEntry(entry),
        fType(type)
{
        fType->AcquireReference();
        DIETemplateTypeParameter* typeParameter
                = dynamic_cast<DIETemplateTypeParameter *>(entry);
        if (typeParameter != NULL)
                fTemplateKind = TEMPLATE_TYPE_TYPE;
        else {
                DIETemplateValueParameter* valueParameter
                        = dynamic_cast<DIETemplateValueParameter *>(entry);
                fTemplateKind = TEMPLATE_TYPE_VALUE;
                const ConstantAttributeValue* constValue = valueParameter
                        ->ConstValue();
                switch (constValue->attributeClass) {
                        case ATTRIBUTE_CLASS_CONSTANT:
                                fValue.SetTo(constValue->constant);
                                break;
                        case ATTRIBUTE_CLASS_STRING:
                                fValue.SetTo(constValue->string);
                                break;
                        // TODO: ATTRIBUTE_CLASS_BLOCK_DATA
                }
        }
}


DwarfTemplateParameter::~DwarfTemplateParameter()
{
        fType->ReleaseReference();
}


// #pragma mark - DwarfPrimitiveType


DwarfPrimitiveType::DwarfPrimitiveType(DwarfTypeContext* typeContext,
        const BString& name, DIEBaseType* entry, uint32 typeConstant)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fTypeConstant(typeConstant)
{
}


DIEType*
DwarfPrimitiveType::GetDIEType() const
{
        return fEntry;
}


uint32
DwarfPrimitiveType::TypeConstant() const
{
        return fTypeConstant;
}


// #pragma mark - DwarfCompoundType


DwarfCompoundType::DwarfCompoundType(DwarfTypeContext* typeContext,
        const BString& name, DIECompoundType* entry,
        compound_type_kind compoundKind)
        :
        DwarfType(typeContext, name, entry),
        fCompoundKind(compoundKind),
        fEntry(entry)
{
}


DwarfCompoundType::~DwarfCompoundType()
{
        for (int32 i = 0;
                        DwarfInheritance* inheritance = fInheritances.ItemAt(i); i++) {
                inheritance->ReleaseReference();
        }
        for (int32 i = 0; DwarfDataMember* member = fDataMembers.ItemAt(i); i++)
                member->ReleaseReference();

        for (int32 i = 0; DwarfTemplateParameter* parameter
                = fTemplateParameters.ItemAt(i); i++) {
                parameter->ReleaseReference();
        }
}


compound_type_kind
DwarfCompoundType::CompoundKind() const
{
        return fCompoundKind;
}


int32
DwarfCompoundType::CountBaseTypes() const
{
        return fInheritances.CountItems();
}


BaseType*
DwarfCompoundType::BaseTypeAt(int32 index) const
{
        return fInheritances.ItemAt(index);
}


int32
DwarfCompoundType::CountDataMembers() const
{
        return fDataMembers.CountItems();
}


DataMember*
DwarfCompoundType::DataMemberAt(int32 index) const
{
        return fDataMembers.ItemAt(index);
}


int32
DwarfCompoundType::CountTemplateParameters() const
{
        return fTemplateParameters.CountItems();
}


TemplateParameter*
DwarfCompoundType::TemplateParameterAt(int32 index) const
{
        return fTemplateParameters.ItemAt(index);
}


status_t
DwarfCompoundType::ResolveBaseTypeLocation(BaseType* _baseType,
        const ValueLocation& parentLocation, ValueLocation*& _location)
{
        DwarfInheritance* baseType = dynamic_cast<DwarfInheritance*>(_baseType);
        if (baseType == NULL)
                return B_BAD_VALUE;

        return _ResolveDataMemberLocation(baseType->GetDwarfType(),
                baseType->Entry()->Location(), parentLocation, false, _location);
}


status_t
DwarfCompoundType::ResolveDataMemberLocation(DataMember* _member,
        const ValueLocation& parentLocation, ValueLocation*& _location)
{
        DwarfDataMember* member = dynamic_cast<DwarfDataMember*>(_member);
        if (member == NULL)
                return B_BAD_VALUE;
        DwarfTypeContext* typeContext = TypeContext();

        bool isBitField = true;
        DIEMember* memberEntry = member->Entry();
        // TODO: handle DW_AT_data_bit_offset
        if (!memberEntry->ByteSize()->IsValid()
                && !memberEntry->BitOffset()->IsValid()
                && !memberEntry->BitSize()->IsValid()) {
                isBitField = false;
        }

        ValueLocation* location;
        status_t error = _ResolveDataMemberLocation(member->GetDwarfType(),
                member->Entry()->Location(), parentLocation, isBitField, location);
        if (error != B_OK)
                return error;

        // If the member isn't a bit field, we're done.
        if (!isBitField) {
                _location = location;
                return B_OK;
        }

        BReference<ValueLocation> locationReference(location);

        // get the byte size
        target_addr_t byteSize;
        if (memberEntry->ByteSize()->IsValid()) {
                BVariant value;
                error = typeContext->File()->EvaluateDynamicValue(
                        typeContext->GetCompilationUnit(),
                        typeContext->AddressSize(), typeContext->IsBigEndian(),
                        typeContext->SubprogramEntry(), memberEntry->ByteSize(),
                        typeContext->TargetInterface(), typeContext->InstructionPointer(),
                        typeContext->FramePointer(), value);
                if (error != B_OK)
                        return error;
                byteSize = value.ToUInt64();
        } else
                byteSize = ByteSize();

        // get the bit offset
        uint64 bitOffset = 0;
        if (memberEntry->BitOffset()->IsValid()) {
                BVariant value;
                error = typeContext->File()->EvaluateDynamicValue(
                        typeContext->GetCompilationUnit(),
                        typeContext->AddressSize(), typeContext->IsBigEndian(),
                        typeContext->SubprogramEntry(), memberEntry->BitOffset(),
                        typeContext->TargetInterface(), typeContext->InstructionPointer(),
                        typeContext->FramePointer(), value);
                if (error != B_OK)
                        return error;
                bitOffset = value.ToUInt64();
        }

        // get the bit size
        uint64 bitSize = byteSize * 8;
        if (memberEntry->BitSize()->IsValid()) {
                BVariant value;
                error = typeContext->File()->EvaluateDynamicValue(
                        typeContext->GetCompilationUnit(),
                        typeContext->AddressSize(), typeContext->IsBigEndian(),
                        typeContext->SubprogramEntry(), memberEntry->BitSize(),
                        typeContext->TargetInterface(), typeContext->InstructionPointer(),
                        typeContext->FramePointer(), value);
                if (error != B_OK)
                        return error;
                bitSize = value.ToUInt64();
        }

        TRACE_LOCALS("bit field: byte size: %" B_PRIu64 ", bit offset/size: %"
                B_PRIu64 "/%" B_PRIu64 "\n", byteSize, bitOffset, bitSize);

        if (bitOffset + bitSize > byteSize * 8)
                return B_BAD_VALUE;

        // create the bit field value location
        ValueLocation* bitFieldLocation = new(std::nothrow) ValueLocation;
        if (bitFieldLocation == NULL)
                return B_NO_MEMORY;
        BReference<ValueLocation> bitFieldLocationReference(bitFieldLocation, true);

        if (!bitFieldLocation->SetTo(*location, bitOffset, bitSize))
                return B_NO_MEMORY;

        _location = bitFieldLocationReference.Detach();
        return B_OK;
}


DIEType*
DwarfCompoundType::GetDIEType() const
{
        return fEntry;
}


bool
DwarfCompoundType::AddInheritance(DwarfInheritance* inheritance)
{
        if (!fInheritances.AddItem(inheritance))
                return false;

        inheritance->AcquireReference();
        return true;
}


bool
DwarfCompoundType::AddDataMember(DwarfDataMember* member)
{
        if (!fDataMembers.AddItem(member))
                return false;

        member->AcquireReference();
        return true;
}


bool
DwarfCompoundType::AddTemplateParameter(DwarfTemplateParameter* parameter)
{
        if (!fTemplateParameters.AddItem(parameter))
                return false;

        parameter->AcquireReference();
        return true;
}


status_t
DwarfCompoundType::_ResolveDataMemberLocation(DwarfType* memberType,
        const MemberLocation* memberLocation,
        const ValueLocation& parentLocation, bool isBitField,
        ValueLocation*& _location)
{
        // create the value location object for the member
        ValueLocation* location = new(std::nothrow) ValueLocation(
                parentLocation.IsBigEndian());
        if (location == NULL)
                return B_NO_MEMORY;
        BReference<ValueLocation> locationReference(location, true);

        switch (memberLocation->attributeClass) {
                case ATTRIBUTE_CLASS_CONSTANT:
                {
                        if (isBitField) {
                                if (!location->SetTo(parentLocation,
                                        memberLocation->constant * 8,
                                        memberType->ByteSize() * 8)) {
                                        return B_NO_MEMORY;
                                }
                        } else {
                                if (!location->SetToByteOffset(parentLocation,
                                        memberLocation->constant,
                                        memberType->ByteSize())) {
                                        return B_NO_MEMORY;
                                }
                        }

                        break;
                }
                case ATTRIBUTE_CLASS_BLOCK:
                case ATTRIBUTE_CLASS_LOCLISTPTR:
                {
                        // The attribute is a location description. Since we need to push
                        // the parent object value onto the stack, we require the parent
                        // location to be a memory location.
                        if (parentLocation.CountPieces() != 1)
                                return B_BAD_VALUE;
                        const ValuePieceLocation& piece = parentLocation.PieceAt(0);

                        if (piece.type != VALUE_PIECE_LOCATION_MEMORY)
                                return B_BAD_VALUE;

                        // convert member location to location description
                        LocationDescription locationDescription;
                        if (memberLocation->attributeClass == ATTRIBUTE_CLASS_BLOCK) {
                                locationDescription.SetToExpression(
                                        memberLocation->expression.data,
                                        memberLocation->expression.length);
                        } else {
                                locationDescription.SetToLocationList(
                                        memberLocation->listOffset);
                        }

                        // evaluate the location description
                        status_t error = memberType->ResolveLocation(TypeContext(),
                                &locationDescription, piece.address, true, *location);
                        if (error != B_OK)
                                return error;

                        break;
                }
                default:
                {
                        // for unions the member location can be omitted -- all members
                        // start at the beginning of the parent object
                        if (fEntry->Tag() != DW_TAG_union_type)
                                return B_BAD_VALUE;

                        // since all members start at the same location, set up
                        // the location by hand since we don't want the size difference
                        // between the overall union and the member being
                        // factored into the assigned address.
                        ValuePieceLocation piece;
                        if (!piece.Copy(parentLocation.PieceAt(0)))
                                return B_NO_MEMORY;

                        piece.SetSize(memberType->ByteSize());
                        if (!location->AddPiece(piece))
                                return B_NO_MEMORY;

                        break;
                }
        }

        _location = locationReference.Detach();
        return B_OK;
}


// #pragma mark - DwarfArrayType


DwarfArrayType::DwarfArrayType(DwarfTypeContext* typeContext,
        const BString& name, DIEArrayType* entry, DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fBaseType(baseType)
{
        fBaseType->AcquireReference();
}


DwarfArrayType::~DwarfArrayType()
{
        for (int32 i = 0;
                DwarfArrayDimension* dimension = fDimensions.ItemAt(i); i++) {
                dimension->ReleaseReference();
        }

        fBaseType->ReleaseReference();
}


Type*
DwarfArrayType::BaseType() const
{
        return fBaseType;
}


int32
DwarfArrayType::CountDimensions() const
{
        return fDimensions.CountItems();
}


ArrayDimension*
DwarfArrayType::DimensionAt(int32 index) const
{
        return fDimensions.ItemAt(index);
}


status_t
DwarfArrayType::ResolveElementLocation(const ArrayIndexPath& indexPath,
        const ValueLocation& parentLocation, ValueLocation*& _location)
{
        if (indexPath.CountIndices() != CountDimensions())
                return B_BAD_VALUE;
        DwarfTypeContext* typeContext = TypeContext();

        // If the array entry has a bit stride, get it. Otherwise fall back to the
        // element type size.
        int64 bitStride;
        DIEArrayType* bitStrideOwnerEntry = NULL;
        if (fEntry != NULL && (bitStrideOwnerEntry = DwarfUtils::GetDIEByPredicate(
                        fEntry, HasBitStridePredicate<DIEArrayType>()))) {
                BVariant value;
                status_t error = typeContext->File()->EvaluateDynamicValue(
                        typeContext->GetCompilationUnit(),
                        typeContext->AddressSize(), typeContext->IsBigEndian(),
                        typeContext->SubprogramEntry(), bitStrideOwnerEntry->BitStride(),
                        typeContext->TargetInterface(), typeContext->InstructionPointer(),
                        typeContext->FramePointer(), value);
                if (error != B_OK)
                        return error;
                if (!value.IsInteger())
                        return B_BAD_VALUE;
                bitStride = value.ToInt64();
        } else
                bitStride = BaseType()->ByteSize() * 8;

        // Iterate backward through the dimensions and compute the total offset of
        // the element.
        int64 elementOffset = 0;
        DwarfArrayDimension* previousDimension = NULL;
        int64 previousDimensionStride = 0;
        for (int32 dimensionIndex = CountDimensions() - 1;
                        dimensionIndex >= 0; dimensionIndex--) {
                DwarfArrayDimension* dimension = DwarfDimensionAt(dimensionIndex);
                int64 index = indexPath.IndexAt(dimensionIndex);

                // If the dimension has a special bit/byte stride, get it.
                int64 dimensionStride = 0;
                DwarfType* dimensionType = dimension->GetDwarfType();
                DIEArrayIndexType* dimensionTypeEntry = dimensionType != NULL
                        ? dynamic_cast<DIEArrayIndexType*>(dimensionType->GetDIEType())
                        : NULL;
                if (dimensionTypeEntry != NULL) {
                        DIEArrayIndexType* bitStrideOwnerEntry
                                = DwarfUtils::GetDIEByPredicate(dimensionTypeEntry,
                                        HasBitStridePredicate<DIEArrayIndexType>());
                        if (bitStrideOwnerEntry != NULL) {
                                BVariant value;
                                status_t error = typeContext->File()->EvaluateDynamicValue(
                                        typeContext->GetCompilationUnit(),
                                        typeContext->AddressSize(), typeContext->IsBigEndian(),
                                        typeContext->SubprogramEntry(),
                                        bitStrideOwnerEntry->BitStride(),
                                        typeContext->TargetInterface(),
                                        typeContext->InstructionPointer(),
                                        typeContext->FramePointer(), value);
                                if (error != B_OK)
                                        return error;
                                if (!value.IsInteger())
                                        return B_BAD_VALUE;
                                dimensionStride = value.ToInt64();
                        } else {
                                DIEArrayIndexType* byteStrideOwnerEntry
                                        = DwarfUtils::GetDIEByPredicate(dimensionTypeEntry,
                                                HasByteStridePredicate<DIEArrayIndexType>());
                                if (byteStrideOwnerEntry != NULL) {
                                        BVariant value;
                                        status_t error = typeContext->File()->EvaluateDynamicValue(
                                                typeContext->GetCompilationUnit(),
                                                typeContext->AddressSize(), typeContext->IsBigEndian(),
                                                typeContext->SubprogramEntry(),
                                                byteStrideOwnerEntry->ByteStride(),
                                                typeContext->TargetInterface(),
                                                typeContext->InstructionPointer(),
                                                typeContext->FramePointer(), value);
                                        if (error != B_OK)
                                                return error;
                                        if (!value.IsInteger())
                                                return B_BAD_VALUE;
                                        dimensionStride = value.ToInt64() * 8;
                                }
                        }
                }

                // If we don't have a stride for the dimension yet, use the stride of
                // the previous dimension multiplied by the size of the dimension.
                if (dimensionStride == 0) {
                        if (previousDimension != NULL) {
                                dimensionStride = previousDimensionStride
                                        * previousDimension->CountElements();
                        } else {
                                // the last dimension -- use the element bit stride
                                dimensionStride = bitStride;
                        }
                }

                // If the dimension stride is still 0 (that can happen, if the dimension
                // doesn't have a stride and the previous dimension's element count is
                // not known), we can only resolve the first element.
                if (dimensionStride == 0 && index != 0) {
                        WARNING("No dimension bit stride for dimension %" B_PRId32 " and "
                                "element index is not 0.\n", dimensionIndex);
                        return B_BAD_VALUE;
                }

                elementOffset += dimensionStride * index;

                previousDimension = dimension;
                previousDimensionStride = dimensionStride;
        }

        TRACE_LOCALS("total element bit offset: %" B_PRId64 "\n", elementOffset);

        // create the value location object for the element
        ValueLocation* location = new(std::nothrow) ValueLocation(
                parentLocation.IsBigEndian());
        if (location == NULL)
                return B_NO_MEMORY;
        BReference<ValueLocation> locationReference(location, true);

        // If we have a single memory piece location for the array, we compute the
        // element's location by hand -- not uncommonly the array size isn't known.
        if (parentLocation.CountPieces() == 1) {
                ValuePieceLocation piece;
                if (!piece.Copy(parentLocation.PieceAt(0)))
                        return B_NO_MEMORY;

                if (piece.type == VALUE_PIECE_LOCATION_MEMORY) {
                        int64 byteOffset = elementOffset >= 0
                                ? elementOffset / 8 : (elementOffset - 7) / 8;
                        piece.SetToMemory(piece.address + byteOffset);
                        piece.SetSize(BaseType()->ByteSize());
                        // TODO: Support bit offsets correctly!
                        // TODO: Support bit fields (primitive types) correctly!

                        if (!location->AddPiece(piece))
                                return B_NO_MEMORY;

                        _location = locationReference.Detach();
                        return B_OK;
                }
        }

        // We can't deal with negative element offsets at this point. It doesn't
        // make a lot of sense anyway, if the array location consists of multiple
        // pieces or lives in a register.
        if (elementOffset < 0) {
                WARNING("Negative element offset unsupported for multiple location "
                        "pieces or register pieces.\n");
                return B_UNSUPPORTED;
        }

        if (!location->SetTo(parentLocation, elementOffset,
                        BaseType()->ByteSize() * 8)) {
                return B_NO_MEMORY;
        }

        _location = locationReference.Detach();
        return B_OK;
}



DIEType*
DwarfArrayType::GetDIEType() const
{
        return fEntry;
}


bool
DwarfArrayType::AddDimension(DwarfArrayDimension* dimension)
{
        if (!fDimensions.AddItem(dimension))
                return false;

        dimension->AcquireReference();
        return true;
}


// #pragma mark - DwarfModifiedType


DwarfModifiedType::DwarfModifiedType(DwarfTypeContext* typeContext,
        const BString& name, DIEModifiedType* entry, uint32 modifiers,
        DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fModifiers(modifiers),
        fBaseType(baseType)
{
        fBaseType->AcquireReference();
}


DwarfModifiedType::~DwarfModifiedType()
{
        fBaseType->ReleaseReference();
}


uint32
DwarfModifiedType::Modifiers() const
{
        return fModifiers;
}


Type*
DwarfModifiedType::BaseType() const
{
        return fBaseType;
}


DIEType*
DwarfModifiedType::GetDIEType() const
{
        return fEntry;
}


// #pragma mark - DwarfTypedefType


DwarfTypedefType::DwarfTypedefType(DwarfTypeContext* typeContext,
        const BString& name, DIETypedef* entry, DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fBaseType(baseType)
{
        fBaseType->AcquireReference();
}


DwarfTypedefType::~DwarfTypedefType()
{
        fBaseType->ReleaseReference();
}


Type*
DwarfTypedefType::BaseType() const
{
        return fBaseType;
}


DIEType*
DwarfTypedefType::GetDIEType() const
{
        return fEntry;
}


// #pragma mark - DwarfAddressType


DwarfAddressType::DwarfAddressType(DwarfTypeContext* typeContext,
        const BString& name, DIEAddressingType* entry,
        address_type_kind addressKind, DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fAddressKind(addressKind),
        fBaseType(baseType)
{
        fBaseType->AcquireReference();
}


DwarfAddressType::~DwarfAddressType()
{
        fBaseType->ReleaseReference();
}


address_type_kind
DwarfAddressType::AddressKind() const
{
        return fAddressKind;
}


Type*
DwarfAddressType::BaseType() const
{
        return fBaseType;
}


DIEType*
DwarfAddressType::GetDIEType() const
{
        return fEntry;
}


// #pragma mark - DwarfEnumerationType


DwarfEnumerationType::DwarfEnumerationType(DwarfTypeContext* typeContext,
        const BString& name, DIEEnumerationType* entry, DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fBaseType(baseType)
{
        if (fBaseType != NULL)
                fBaseType->AcquireReference();
}


DwarfEnumerationType::~DwarfEnumerationType()
{
        for (int32 i = 0; DwarfEnumeratorValue* value = fValues.ItemAt(i); i++)
                value->ReleaseReference();

        if (fBaseType != NULL)
                fBaseType->ReleaseReference();
}


Type*
DwarfEnumerationType::BaseType() const
{
        return fBaseType;
}


int32
DwarfEnumerationType::CountValues() const
{
        return fValues.CountItems();
}


EnumeratorValue*
DwarfEnumerationType::ValueAt(int32 index) const
{
        return fValues.ItemAt(index);
}


DIEType*
DwarfEnumerationType::GetDIEType() const
{
        return fEntry;
}


bool
DwarfEnumerationType::AddValue(DwarfEnumeratorValue* value)
{
        if (!fValues.AddItem(value))
                return false;

        value->AcquireReference();
        return true;
}


// #pragma mark - DwarfSubrangeType


DwarfSubrangeType::DwarfSubrangeType(DwarfTypeContext* typeContext,
        const BString& name, DIESubrangeType* entry, Type* baseType,
        const BVariant& lowerBound, const BVariant& upperBound)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fBaseType(baseType),
        fLowerBound(lowerBound),
        fUpperBound(upperBound)
{
        fBaseType->AcquireReference();
}


DwarfSubrangeType::~DwarfSubrangeType()
{
        fBaseType->ReleaseReference();
}


Type*
DwarfSubrangeType::BaseType() const
{
        return fBaseType;
}


DIEType*
DwarfSubrangeType::GetDIEType() const
{
        return fEntry;
}


BVariant
DwarfSubrangeType::LowerBound() const
{
        return fLowerBound;
}


BVariant
DwarfSubrangeType::UpperBound() const
{
        return fUpperBound;
}


// #pragma mark - DwarfUnspecifiedType


DwarfUnspecifiedType::DwarfUnspecifiedType(DwarfTypeContext* typeContext,
        const BString& name, DIEUnspecifiedType* entry)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry)
{
}


DwarfUnspecifiedType::~DwarfUnspecifiedType()
{
}


DIEType*
DwarfUnspecifiedType::GetDIEType() const
{
        return fEntry;
}


// #pragma mark - DwarfFunctionType


DwarfFunctionType::DwarfFunctionType(DwarfTypeContext* typeContext,
        const BString& name, DIESubroutineType* entry, DwarfType* returnType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fReturnType(returnType),
        fHasVariableArguments(false)
{
        if (fReturnType != NULL)
                fReturnType->AcquireReference();
}


DwarfFunctionType::~DwarfFunctionType()
{
        for (int32 i = 0;
                DwarfFunctionParameter* parameter = fParameters.ItemAt(i); i++) {
                parameter->ReleaseReference();
        }

        if (fReturnType != NULL)
                fReturnType->ReleaseReference();
}


Type*
DwarfFunctionType::ReturnType() const
{
        return fReturnType;
}


int32
DwarfFunctionType::CountParameters() const
{
        return fParameters.CountItems();
}


FunctionParameter*
DwarfFunctionType::ParameterAt(int32 index) const
{
        return fParameters.ItemAt(index);
}


bool
DwarfFunctionType::HasVariableArguments() const
{
        return fHasVariableArguments;
}


void
DwarfFunctionType::SetHasVariableArguments(bool hasVarArgs)
{
        fHasVariableArguments = hasVarArgs;
}


DIEType*
DwarfFunctionType::GetDIEType() const
{
        return fEntry;
}


bool
DwarfFunctionType::AddParameter(DwarfFunctionParameter* parameter)
{
        if (!fParameters.AddItem(parameter))
                return false;

        parameter->AcquireReference();
        return true;
}


// #pragma mark - DwarfPointerToMemberType


DwarfPointerToMemberType::DwarfPointerToMemberType(
        DwarfTypeContext* typeContext, const BString& name,
        DIEPointerToMemberType* entry, DwarfCompoundType* containingType,
        DwarfType* baseType)
        :
        DwarfType(typeContext, name, entry),
        fEntry(entry),
        fContainingType(containingType),
        fBaseType(baseType)
{
        fContainingType->AcquireReference();
        fBaseType->AcquireReference();
}


DwarfPointerToMemberType::~DwarfPointerToMemberType()
{
        fContainingType->ReleaseReference();
        fBaseType->ReleaseReference();
}


CompoundType*
DwarfPointerToMemberType::ContainingType() const
{
        return fContainingType;
}


Type*
DwarfPointerToMemberType::BaseType() const
{
        return fBaseType;
}


DIEType*
DwarfPointerToMemberType::GetDIEType() const
{
        return fEntry;
}