/* Target dependent code for ARC processor family, for GDB, the GNU debugger.

   Copyright 2009 Free Software Foundation, Inc.

   Contributed by ARC International (www.arc.com)

   Author:
      Richard Stuckey <richard.stuckey@arc.com>

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/******************************************************************************/
/*                                                                            */
/* Outline:                                                                   */
/*     This module implements operations for reading data from and writing    */
/*     data to target memory.                                                 */
/*                                                                            */
/*     The operations may be required to transfer arbitrary amounts of data   */
/*     to/from arbitrary addresses in memory; however, the supplied transfer  */
/*     operations must be assumed to be able only to transfer multiple words  */
/*     of data to/from word-aligned addresses.                                */
/*                                                                            */
/*     This gives the general case:                                           */
/*                                                                            */
/*                           word boundaries                                  */
/*                                  |                                         */
/*           -------------------------------------------------                */
/*          |         |         |         |         |         |               */
/*      -----------------------------------------------------------           */
/*          | g g L L | W W W W | W W W W | W W W W | T T e e |               */
/*      -----------------------------------------------------------           */
/*                ^                                                           */
/*                |-------------------------------------|                     */
/*                |                len                                        */
/*                addr                                                        */
/*                                                                            */
/*       where addr is the base address of the data to be transferred         */
/*             len  is the number of bytes of data to be transferred          */
/*             W denotes a byte that can be transfered in a whole word        */
/*             L denotes a leading byte                                       */
/*             T denotes a trailing byte                                      */
/*             g denotes a gap byte                                           */
/*             e denotes a end gap byte                                       */
/*                                                                            */
/*     There may be 0 .. BYTES_IN_WORD - 1 leading bytes, 0 or more whole     */
/*     words, and 0 .. BYTES_IN_WORD - 1 trailing bytes. If the given address */
/*     is word-aligned, there is no gap and hence no leading bytes.           */
/*                                                                            */
/*     There is also a pathological case:                                     */
/*                                                                            */
/*                           word boundaries                                  */
/*                                  |                                         */
/*                               ---------                                    */
/*                              |         |                                   */
/*      -----------------------------------------------------------           */
/*                              | g B B e |                                   */
/*      -----------------------------------------------------------           */
/*                                  ^                                         */
/*                                  |-|                                       */
/*                                  | len                                     */
/*                                  addr                                      */
/*                                                                            */
/*     where 1 .. BYTES_IN_WORD - 2 bytes of data in the middle of a word     */
/*     must be transfered.                                                    */
/*                                                                            */
/*     In a write operation, it is necessary to preserve the contents of the  */
/*     gap and end gap bytes, if any - this is done by first reading the word */
/*     which contains those bytes, constructing a new word which contains     */
/*     those bytes and the new bytes, and writing the new value back to that  */
/*     location.                                                              */
/*                                                                            */
/******************************************************************************/

/* system header files */

/* gdb header files */
#include "defs.h"

/* ARC header files */
#include "arc-memory.h"
#include "arc-tdep.h"


/* -------------------------------------------------------------------------- */
/*                               local types                                  */
/* -------------------------------------------------------------------------- */

typedef struct
{
    unsigned int leading_bytes;
    unsigned int trailing_bytes;
    unsigned int words;
} Layout;


/* -------------------------------------------------------------------------- */
/*                               local functions                              */
/* -------------------------------------------------------------------------- */

/* Split a memory chunk up into its layout - see diagram in file header.  */

static Layout
split (ARC_Address addr, unsigned int bytes)
{
    unsigned int gap = addr % BYTES_IN_WORD;
    Layout       layout;

    layout.leading_bytes  = (gap == 0) ? 0 : (BYTES_IN_WORD - gap);
    layout.trailing_bytes = (addr + bytes) % BYTES_IN_WORD;
    layout.words          = (bytes - layout.leading_bytes
                                   - layout.trailing_bytes) / BYTES_IN_WORD;

    DEBUG("%u leading bytes, %u words, %u trailing bytes\n",
          layout.leading_bytes, layout.words, layout.trailing_bytes);

    return layout;
}


/* Read part of a word of data from memory; the given address must be word-aligned.  */

static unsigned int
read_partial_word (TargetOperations *ops,
                   ARC_Address       addr,
                   ARC_Byte         *data,
                   unsigned int      bytes,
                   unsigned int      offset)  /* Offset of required bytes within word.  */
{
    ARC_Byte word[BYTES_IN_WORD];

    /* Read the word: only some bytes of this are required.  */
    if (ops->read_memory(addr, word, 1) > 0)
    {
        unsigned int i;

        for (i = 0; i < bytes; i++)
            data[i] = word[offset + i];

        /* Have read the specified number of bytes.  */
        return bytes;
    }

    /* Failed: no data read.  */
    return 0;
}


/* Write part of a word of data to memory; the given address must be word-aligned.  */

static unsigned int
write_partial_word (TargetOperations *ops,
                    ARC_Address       addr,
                    ARC_Byte         *data,
                    unsigned int      bytes,
                    unsigned int      offset)   /* Offset of required bytes within word.  */
{
    ARC_Byte word[BYTES_IN_WORD];

    /* First read the word of memory that will be overwritten.  */
    if (ops->read_memory(addr, word, 1) > 0)
    {
        unsigned int i;

        /* Next replace the bytes in that word that are to be written.  */
        for (i = 0; i < bytes; i++)
            word[offset + i] = data[i];

        /* Now write it!  */
        if (ops->write_memory(addr, word, 1) > 0)
            /* Have written the specified number of bytes.  */
            return bytes;
    }

    /* Failed: no data written.  */
    return 0;
}


/* -------------------------------------------------------------------------- */
/*                               externally visible functions                 */
/* -------------------------------------------------------------------------- */

/* Read a chunk of data from target memory.
   Returns number of bytes read.  */

unsigned int
arc_read_memory (TargetOperations *ops,
                 ARC_Address       address,
                 ARC_Byte         *data,
                 unsigned int      bytes)
{
    unsigned int gap        = address % BYTES_IN_WORD;
    unsigned int total_read = 0;

    ENTERARGS("address 0x%08X, bytes %u", address, bytes);

    /* Special fast case for reading a single word.  */
    if (gap == 0 && bytes == BYTES_IN_WORD)
    {
        DEBUG("read single word\n");

        /* N.B. assumes that 'data' is word-aligned, or that host does not care!  */
        total_read = ops->read_memory(address, data, 1);
    }
    /* Pathological case: bytes in middle of word.  */
    else if (gap > 0 && gap + bytes < BYTES_IN_WORD)
    {
        DEBUG("read pathological\n");

        total_read = read_partial_word(ops,
                                       address - gap,   /* Word-aligned address.  */
                                       data,
                                       bytes,
                                       gap);
    }
    else /* The general case.  */
    {
        Layout chunk = split(address, bytes);

        if (chunk.leading_bytes > 0)
        {
            /* Read the first few bytes.  */
            total_read = read_partial_word(ops,
                                           address - gap,   /* Word-aligned addres.  */
                                           data,
                                           chunk.leading_bytes,
                                           gap);
            data += chunk.leading_bytes;
            address += chunk.leading_bytes;
        }

        if (chunk.words > 0)
        {
            unsigned int bytes_read = ops->read_memory(address, data, chunk.words);

            total_read += bytes_read;
            address       += bytes_read;
            data       += bytes_read;
        }

        if (chunk.trailing_bytes > 0)
        {
            /* Read the last few bytes of data.  */
            total_read += read_partial_word(ops,
                                            address,     // Word-aligned address.  */
                                            data,
                                            chunk.trailing_bytes,
                                            0);
        }
    }

    DEBUG("read %u bytes\n", total_read);

    return total_read;
}


/* Write a chunk of data to target memory.
   Returns number of bytes written.  */

unsigned int
arc_write_memory (TargetOperations *ops,
                  ARC_Address       address,
                  ARC_Byte         *data,
                  unsigned int      bytes)
{
    unsigned int gap           = address % BYTES_IN_WORD;
    unsigned int total_written = 0;

    ENTERARGS("address 0x%08X, bytes %u", address, bytes);

    /* Useful debugging code: just change 0 to 1.  */
    if (0)
    {
        unsigned int i;
        for (i = 0; i < bytes; i++)
        {
            DEBUG("%02X", data[i]);
            if ((i + 1) % 16 == 0)
                DEBUG("\n");
        }
        DEBUG("\n");
    }

    /* Special fast case for writing a single word.  */
    if (gap == 0 && bytes == BYTES_IN_WORD)
    {
        DEBUG("write single word (%02X %02X %02X %02X)\n", data[0], data[1], data[2], data[3]);

        total_written = ops->write_memory(address, data, 1);
    }
    /* Pathological case: bytes in middle of word.  */
    else if (gap > 0 && gap + bytes < BYTES_IN_WORD)
    {
        DEBUG("write pathological\n");

        total_written = write_partial_word(ops,
                                           address - gap,   /* Word-aligned address.  */
                                           data,
                                           bytes,
                                           gap);
    }
    else /* general case */
    {
        Layout chunk = split(address, bytes);

        if (chunk.leading_bytes > 0)
        {
            /* Write the first few bytes.  */
            total_written = write_partial_word(ops,
                                               address - gap,   /* Word-aligned address.  */
                                               data,
                                               chunk.leading_bytes,
                                               gap);
            data += chunk.leading_bytes;
            address += chunk.leading_bytes;
        }

        if (chunk.words > 0)
        {
            unsigned int bytes_written = ops->write_memory(address, data, chunk.words);

            total_written += bytes_written;
            address          += bytes_written;
            data          += bytes_written;
        }

        if (chunk.trailing_bytes > 0)
        {
            /* Write the last few bytes of data.  */
            total_written += write_partial_word(ops,
                                                address,    /* Word-aligned address.  */
                                                data,
                                                chunk.trailing_bytes,
                                                0);
        }
    }

    DEBUG("written %u bytes\n", total_written);

    return total_written;
}


/* Write a repeated pattern of data to memory;
   the start of each pattern is always word-aligned, so if the given address is
   not word-aligned, the first partial word written will contain trailing bytes
   of the pattern.  */

unsigned int
arc_write_pattern (TargetOperations *ops,
                   ARC_Address       address,
                   ARC_Word          pattern,
                   unsigned int      bytes)
{
    unsigned int gap           = address % BYTES_IN_WORD;
    unsigned int total_written = 0;

    ENTERARGS("address 0x%08X, pattern 0x%08X, bytes %u", address, pattern, bytes);

    /* Special fast case for writing a single word.  */
    if (gap == 0 && bytes == BYTES_IN_WORD)
    {
        DEBUG("write single word (%08X)\n", pattern);

        total_written = ops->write_memory(address, (ARC_Byte*) &pattern, 1);
    }
    /* Pathological case: bytes in middle of word.  */
    else if (gap > 0 && gap + bytes < BYTES_IN_WORD)
    {
        DEBUG("write pathological\n");

        total_written = write_partial_word(ops,
                                           address - gap,   /* Word-aligned address.  */
                                           ((ARC_Byte*) &pattern) + gap ,
                                           bytes,
                                           gap);
    }
    else /* General case.  */
    {
        Layout chunk = split(address, bytes);

        if (chunk.leading_bytes > 0)
        {
            /* Write the first few bytes.  */
            total_written = write_partial_word(ops,
                                               address - gap,   /* Word-aligned address.   */
                                               ((ARC_Byte*) &pattern) + gap ,
                                               chunk.leading_bytes,
                                               gap);

            address += chunk.leading_bytes;
        }

        /* If we have been given a fill_memory operation.  */
        if (ops->fill_memory)
        {
            /* Write the complete words of data in one go.  */
            unsigned int bytes_written = ops->fill_memory(address, pattern, chunk.words);

            total_written += bytes_written;
            address       += bytes_written;
        }
        else
        {
            /* Write all the complete words of data, one word at a time.  */
            while (chunk.words--)
            {
                unsigned int bytes_written = ops->write_memory(address, (ARC_Byte*) &pattern, 1);

                total_written += bytes_written;
                address       += bytes_written;
            }
        }

        if (chunk.trailing_bytes > 0)
        {
            /* Write the last few bytes of data.  */
            total_written += write_partial_word(ops,
                                                address,    /* Word-aligned address.  */
                                                ((ARC_Byte*) &pattern),
                                                chunk.trailing_bytes,
                                                0);
        }
    }

    DEBUG("written %u bytes\n", total_written);

    return total_written;
}

/******************************************************************************/