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

#include <stdio.h>

#include "ValueLocation.h"


// #pragma mark - ValuePieceLocation


ValuePieceLocation&
ValuePieceLocation::Normalize(bool bigEndian)
{
        uint64 excessMSBs = bitOffset / 8;
        uint64 excessLSBs = size - (bitOffset + bitSize + 7) / 8;

        if (excessMSBs > 0 || excessLSBs > 0) {
                switch (type) {
                        case VALUE_PIECE_LOCATION_MEMORY:
                                if (bigEndian)
                                        address += excessMSBs;
                                else
                                        address += excessLSBs;
                                bitOffset -= excessMSBs * 8;
                                size -= excessMSBs + excessLSBs;
                                break;
                        case VALUE_PIECE_LOCATION_UNKNOWN:
                                bitOffset -= excessMSBs * 8;
                                size -= excessMSBs + excessLSBs;
                                break;
                        case VALUE_PIECE_LOCATION_REGISTER:
                        default:
                                break;
                }
        }

        return *this;
}


// #pragma mark - ValueLocation


ValueLocation::ValueLocation()
        :
        fBigEndian(false),
        fWritable(false)
{
}


ValueLocation::ValueLocation(bool bigEndian)
        :
        fBigEndian(bigEndian),
        fWritable(false)
{
}


ValueLocation::ValueLocation(bool bigEndian, const ValuePieceLocation& piece)
        :
        fBigEndian(bigEndian)
{
        AddPiece(piece);
}


ValueLocation::ValueLocation(const ValueLocation& other)
        :
        fPieces(other.fPieces),
        fBigEndian(other.fBigEndian)
{
}


bool
ValueLocation::SetToByteOffset(const ValueLocation& other, uint64 byteOffset,
        uint64 byteSize)
{
        Clear();

        fBigEndian = other.fBigEndian;
        ValuePieceLocation piece = other.PieceAt(0);
        piece.SetToMemory(piece.address + byteOffset);
        piece.SetSize(byteSize);

        return AddPiece(piece);
}


bool
ValueLocation::SetTo(const ValueLocation& other, uint64 bitOffset,
        uint64 bitSize)
{
        Clear();

        fBigEndian = other.fBigEndian;

        // compute the total bit size
        int32 count = other.CountPieces();
        uint64 totalBitSize = 0;
        for (int32 i = 0; i < count; i++) {
                const ValuePieceLocation &piece = other.PieceAt(i);
                totalBitSize += piece.bitSize;
        }

        // adjust requested bit offset/size to something reasonable, if necessary
        if (bitOffset + bitSize > totalBitSize) {
                if (bitOffset >= totalBitSize)
                        return true;
                bitSize = totalBitSize - bitOffset;
        }

        if (fBigEndian) {
                // Big endian: Skip the superfluous most significant bits, copy the
                // pieces we need (cutting the first and the last one as needed) and
                // ignore the remaining pieces.

                // skip pieces for the most significant bits we don't need anymore
                uint64 bitsToSkip = bitOffset;
                int32 i;
                ValuePieceLocation piece;
                for (i = 0; i < count; i++) {
                        const ValuePieceLocation& tempPiece = other.PieceAt(i);
                        if (tempPiece.bitSize > bitsToSkip) {
                                if (!piece.Copy(tempPiece))
                                        return false;
                                break;
                        }
                        bitsToSkip -= tempPiece.bitSize;
                }

                // handle partial piece
                if (bitsToSkip > 0) {
                        piece.bitOffset += bitsToSkip;
                        piece.bitSize -= bitsToSkip;
                        piece.Normalize(fBigEndian);
                }

                // handle remaining pieces
                while (bitSize > 0) {
                        if (piece.bitSize > bitSize) {
                                // the piece is bigger than the remaining size -- cut it
                                piece.bitSize = bitSize;
                                piece.Normalize(fBigEndian);
                                bitSize = 0;
                        } else
                                bitSize -= piece.bitSize;

                        if (!AddPiece(piece))
                                return false;

                        if (++i >= count)
                                break;

                        if (!piece.Copy(other.PieceAt(i)))
                                return false;
                }
        } else {
                // Little endian: Skip the superfluous least significant bits, copy the
                // pieces we need (cutting the first and the last one as needed) and
                // ignore the remaining pieces.

                // skip pieces for the least significant bits we don't need anymore
                uint64 bitsToSkip = totalBitSize - bitOffset - bitSize;
                int32 i;
                ValuePieceLocation piece;
                for (i = 0; i < count; i++) {
                        const ValuePieceLocation& tempPiece = other.PieceAt(i);
                        if (tempPiece.bitSize > bitsToSkip) {
                                if (!piece.Copy(tempPiece))
                                        return false;
                                break;
                        }
                        bitsToSkip -= piece.bitSize;
                }

                // handle partial piece
                if (bitsToSkip > 0) {
                        piece.bitSize -= bitsToSkip;
                        piece.Normalize(fBigEndian);
                }

                // handle remaining pieces
                while (bitSize > 0) {
                        if (piece.bitSize > bitSize) {
                                // the piece is bigger than the remaining size -- cut it
                                piece.bitOffset += piece.bitSize - bitSize;
                                piece.bitSize = bitSize;
                                piece.Normalize(fBigEndian);
                                bitSize = 0;
                        } else
                                bitSize -= piece.bitSize;

                        if (!AddPiece(piece))
                                return false;

                        if (++i >= count)
                                break;

                        if (!piece.Copy(other.PieceAt(i)))
                                return false;
                }
        }

        return true;
}


void
ValueLocation::Clear()
{
        fWritable = false;
        fPieces.clear();
}


bool
ValueLocation::AddPiece(const ValuePieceLocation& piece)
{
        // Just add, don't normalize. This allows for using the class with different
        // semantics (e.g. in the DWARF code).
        try {
                fPieces.push_back(piece);
        } catch (...) {
                return false;
        }

        if (fPieces.size() == 1)
                fWritable = piece.writable;
        else
                fWritable = fWritable && piece.writable;

        return true;
}


int32
ValueLocation::CountPieces() const
{
        return fPieces.size();
}


ValuePieceLocation
ValueLocation::PieceAt(int32 index) const
{
        if (index < 0 || index >= (int32)fPieces.size())
                return ValuePieceLocation();

        return fPieces[index];
}


bool
ValueLocation::SetPieceAt(int32 index, const ValuePieceLocation& piece)
{
        if (index < 0 || index >= (int32)fPieces.size())
                return false;

        return fPieces[index].Copy(piece);
}


ValueLocation&
ValueLocation::operator=(const ValueLocation& other)
{
        fPieces = other.fPieces;
        fBigEndian = other.fBigEndian;
        return *this;
}


void
ValueLocation::Dump() const
{
        int32 count = fPieces.size();
        printf("ValueLocation: %s endian, %" B_PRId32 " pieces:\n",
                fBigEndian ? "big" : "little", count);

        for (int32 i = 0; i < count; i++) {
                const ValuePieceLocation& piece = fPieces[i];
                switch (piece.type) {
                        case VALUE_PIECE_LOCATION_INVALID:
                                printf("  invalid\n");
                                continue;
                        case VALUE_PIECE_LOCATION_UNKNOWN:
                                printf("  unknown");
                                break;
                        case VALUE_PIECE_LOCATION_MEMORY:
                                printf("  address %#" B_PRIx64, piece.address);
                                break;
                        case VALUE_PIECE_LOCATION_REGISTER:
                                printf("  register %" B_PRIu32, piece.reg);
                                break;
                        case VALUE_PIECE_LOCATION_IMPLICIT:
                                printf("  implicit value: ");
                                for (uint32 j = 0; j < piece.size; j++)
                                        printf("%x ", ((char *)piece.value)[j]);
                                break;
                }

                printf(" size: %" B_PRIu64 " (%" B_PRIu64 " bits), offset: %" B_PRIu64
                        " bits\n", piece.size, piece.bitSize, piece.bitOffset);
        }
}