path: root/gdb/arc-arguments.c

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

   Copyright 2008, 2009 Free Software Foundation, Inc.

   Contributed by ARC International (www.arc.com)

   Authors:
      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 setting up the command line      */
/*     arguments to the program which is being debugged.                      */
/*                                                                            */
/*     E.g. if we are passing 4 arguments to the program's 'main' function,   */
/*          we must place them on the stack in the layout:                    */
/*                                                                            */
/*        .                                                                   */
/*        .                                                                   */
/*     stack[top + A3] <== <arg_3>                                            */
/*        .                                                                   */
/*        .                                                                   */
/*     stack[top + A2] <== <arg_2>                                            */
/*        .                                                                   */
/*        .                                                                   */
/*     stack[top + A1] <== <arg_1>                                            */
/*        .                                                                   */
/*        .                                                                   */
/*     stack[top + A0] <== <arg_0>                                            */
/*     stack[top + 24] <== 0x0           # ? NULL terminator                  */
/*     stack[top + 20] <== 0x0           # envp NULL terminator               */
/*     stack[top + 16] <== 0x0           # argv NULL terminator               */
/*     stack[top + 12] <== TOP + A3      # argv[3]                            */
/*     stack[top +  8] <== TOP + A2      # argv[2]                            */
/*     stack[top +  4] <== TOP + A1      # argv[1]                            */
/*     stack[top +  0] <== TOP + A0      # argv[0]                            */
/*                                                                            */
/*     where TOP = &stack[top]                                                */
/*       and A0 .. A3 are the offsets of the stored arguments from the stack  */
/*                    top.                                                    */
/*                                                                            */
/******************************************************************************/

/* system header files */
#include <byteswap.h>

/* gdb header files */
#include "defs.h"
#include "target.h"
#include "symtab.h"
#include "regcache.h"
#include "objfiles.h"

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


/* -------------------------------------------------------------------------- */
/*                               local data                                   */
/* -------------------------------------------------------------------------- */

#define MINIMUM_INSTRUCTION_SIZE       2
#define MOV_SP_INSTRUCTION_LE          0x3F80240A
#define MOV_SP_INSTRUCTION_BE          0x803F0A24


/* The address of the top of the target program's stack before the program
   arguments were pushed onto the stack.  */
static CORE_ADDR old_stack_top;

/* The address in the target program code of the instructions which set up the
   stack pointer (SP) at program start-up.  */
static CORE_ADDR stack_pointer_setup_code_operand_address;


/* -------------------------------------------------------------------------- */
/*                               local macros                                 */
/* -------------------------------------------------------------------------- */

#define TARGET_IS_BIG_ENDIAN  (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)

#define TARGET_ENDIAN(word)   ((TARGET_IS_BIG_ENDIAN) ? __bswap_32(word) : (word))

#define MK_OPERAND_LE(x)      (ARC_Word) ((((x) & 0xffff0000) >> 16) | \
                                          (((x) & 0x0000ffff) << 16))

#define MK_OPERAND_BE(x)      (ARC_Word) (__bswap_32(x))


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

/* Find the address in the target program code of the given label.
   Return 0 if the label is not found.  */

static CORE_ADDR
find_label (const char *label)
{
    struct minimal_symbol *msymbol = lookup_minimal_symbol(label, NULL, symfile_objfile);
    CORE_ADDR              address = 0;

    if (msymbol != NULL)
        address = SYMBOL_VALUE_ADDRESS (msymbol);

    DEBUG("%s = %x\n", label, (unsigned int) address);

    return address;
}


/* Write a word of data to target memory.

   Parameters:
       address : the address in memory to write the data
       word    : the data to be written

   Returns TRUE if the data is written. FALSE otherwise.

   If the data is written, the given address is incremented to reference the
   next word in target memory.  */

static Boolean
write_word (CORE_ADDR *address, ARC_Word word)
{
    word = TARGET_ENDIAN(word);

    if (target_write_memory(*address, (gdb_byte*) &word, BYTES_IN_WORD) == 0)
    {
        *address += BYTES_IN_WORD;
        return TRUE;
    }

    return FALSE;
}


/* Try to find the address in the target program code of the instructions which
   set up the program stack pointer (SP).

   Parameter:
       stack_top: the address which is loaded into SP by the setup code

   Return TRUE if the code is found.

   If the setup code is found, the variable stack_pointer_setup_code_operand_address
   is set to the code's address.  */

static Boolean
find_stack_top_setup_code (CORE_ADDR stack_top)
{
    /* Try to find the start address in the target program.  */
    CORE_ADDR code_start = find_label("__start");

    if (code_start != 0)
    {
        CORE_ADDR code = (ARC_Address) code_start;
        ARC_Word  set_sp_insn[2];
        ARC_Byte  buffer[16 * BYTES_IN_WORD];

        DEBUG("setting up arguments: stack_top = %x, code_start = %x\n",
              (unsigned int) stack_top, (unsigned int) code_start);

        if (TARGET_IS_BIG_ENDIAN)
        {
            set_sp_insn[0] = MOV_SP_INSTRUCTION_BE;
            set_sp_insn[1] = MK_OPERAND_BE(stack_top);
        }
        else
        {
            set_sp_insn[0] = MOV_SP_INSTRUCTION_LE;
            set_sp_insn[1] = MK_OPERAND_LE(stack_top);
        }

        /* Scan through the start code of the program, looking for the code that
           sets up the program's stack pointer; we recognize this as a 32-bit
           'mov sp' instruction followed by a 32-bit operand which is the
           address of the stack top (which we obtained from the executable file).  */
        while (TRUE)
        {
            int result = target_read_memory(code, (gdb_byte*) buffer, (int) sizeof(buffer));

            if (result == 0)
            {
                size_t offset = 0;

                while (offset <= sizeof(buffer) - sizeof(set_sp_insn))
                {
                    if (memcmp(buffer + offset, set_sp_insn, sizeof(set_sp_insn)) == 0)
                    {
                        stack_pointer_setup_code_operand_address = code + (CORE_ADDR) offset + BYTES_IN_WORD;

                        DEBUG("found 'mov sp, <stacktop>' instruction operand at address 0x%x\n",
                              (unsigned int) stack_pointer_setup_code_operand_address);
                        return TRUE;
                    }

                    offset += MINIMUM_INSTRUCTION_SIZE;
                }
            }
            else
            {
                warning(_("can not find read target program start code"));
                break;
            }

            code += (CORE_ADDR) (sizeof(buffer) - sizeof(set_sp_insn));

            /* If we haven't found it in the first 100 bytes.  */
            if (code - code_start > 100)
            {
                warning(_("can not find 'mov sp, <stacktop>' instruction in start code"));
                break;
            }
        }
    }

    return FALSE;
}


/* Try to change the setup code in the program so that SP is loaded with a
   given address.

   Parameters:
       old_stack_top: the address which is currently loaded into SP by the code
       new_stack_top: the address which we wish to be loaded into SP by the code

   Return TRUE if the setup code is changed.  */

static Boolean
set_stack_top (CORE_ADDR old_stack_top, CORE_ADDR new_stack_top)
{
    ARC_Word operand = (TARGET_IS_BIG_ENDIAN) ? MK_OPERAND_BE(new_stack_top)
                                              : MK_OPERAND_LE(new_stack_top);

    /* If we do not yet know the address in the program code at which the
       program's stack pointer is set up.  */
    if (stack_pointer_setup_code_operand_address == 0)
    {
        /* Try to find it.  */
        if (!find_stack_top_setup_code(old_stack_top))
            return FALSE;
    }

    DEBUG("set stack top @ 0x%08X to 0x%08X (0x%08X)\n",
          (unsigned int) stack_pointer_setup_code_operand_address,
          (unsigned int) new_stack_top,
          operand);

    return (target_write_memory(stack_pointer_setup_code_operand_address,
                                (gdb_byte*) &operand,
                                BYTES_IN_WORD) == 0);
}


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

/* This is called when a program is downloaded to the debug target. */

void
arc_program_loaded (void)
{
    /* The program has just been loaded, so we do not yet know the address in
       the program code at which the program's stack pointer is set up.  */
    stack_pointer_setup_code_operand_address = 0;
}


/* Store the program's arguments on the stack.
   Return TRUE if they are stored successfully.  */

Boolean
arc_setup_arguments (char *args)
{
    Boolean done = FALSE;

    /* Try to find the top of stack in the target program.  */
    old_stack_top = find_label("__stack_top");

    if (old_stack_top != 0)
    {
        char       **argv = buildargv (args);
        char       **argp;
        size_t       string_length = 0;
        unsigned int argc          = 0;
        unsigned int num_pointers;
        unsigned int total_size;
        CORE_ADDR    new_stack_top;

        if (argv == NULL)
            nomem (0);

        /* Calculate the space required to hold the args.  */

        for (argp = argv; *argp != NULL; argp++)
        {
            string_length += strlen (*argp) + 1;
            argc++;
        }

        DEBUG("%d arguments\n", argc);

        num_pointers = argc + 3;

        total_size = (unsigned int) string_length + num_pointers * BYTES_IN_WORD;

        /* Round up to a multiple of 32: strlen expects memory to come in chunks
         * that are at least cache-line (32 bytes) sized.  */
        total_size +=  31;
        total_size &= -32;

        DEBUG("total size: %d\n", total_size);

        new_stack_top = old_stack_top - total_size;

        DEBUG("new stack top: 0x%08x\n", (unsigned int) new_stack_top);

        /* Adjust the setting of the top of the stack in the object code.  */
        if (set_stack_top(old_stack_top, new_stack_top))
        {
            struct regcache *regcache   = get_current_regcache();
            CORE_ADDR        data_space = new_stack_top + num_pointers * BYTES_IN_WORD;
            CORE_ADDR        stack_top  = new_stack_top;
            unsigned int i;

            DEBUG("data space: 0x%08x\n", (unsigned int) data_space);

            done = TRUE;

            /* Write the args onto the top of the stack.  */

            for (i = 0; i < argc; i++)
            {
                char  *parameter = argv[i];
                size_t length    = strlen(parameter) + 1;
                int    result    = target_write_memory(data_space, (gdb_byte*) parameter, (int) length);

                if (result == 0)
                {
                    DEBUG("written argv[%d] to 0x%08x: \"%s\"\n",
                          i, (unsigned int) data_space, parameter);
                }
                else
                    done = FALSE;

                /* Write a pointer to the argument onto the stack.  */
                if (!write_word(&stack_top, (ARC_Word) data_space))
                    done = FALSE;

                data_space += length;
            }

            /* Try to write the NULLs.  */
            if (!write_word(&stack_top, 0) ||
                !write_word(&stack_top, 0) ||
                !write_word(&stack_top, 0))
                done = FALSE;

            /* Set up the R0 and R1 parameter registers.  */

            /* Convert to target byte order if necessary.  */
            if (HOST_AND_TARGET_ENDIANNESS_DIFFER(current_gdbarch))
            {
                 argc          = __bswap_32(argc);
                 new_stack_top = __bswap_32(new_stack_top);
            }

            regcache_raw_supply   (regcache, 0, &argc);
            regcache_raw_supply   (regcache, 1, &new_stack_top);
            target_store_registers(regcache, 0);
            target_store_registers(regcache, 1);
        }

        freeargv(argv);
    }

    return done;
}


/* This function is called just before disconnection from the debug target.  */

void
arc_restore_stack_top_address (void)
{
    /* If we know the address in the program start-up code at which the stack
       pointer is set up, it must be because we changed the stack top address
       in the code - so change it back to the original address as read from the
       excutable file.

       This is done so that if the user disconnects from the target, then
       reconnects to it in a subsequent debugging session but does NOT download
       the program to the target again (as it is still in target memory), the
       mechanism for altering the stack top will still work.

       Note that this has no effect if the target is allowed to resume execution
       (i.e. a 'detach' is being performed) as we are changing code that has
       already been executed.

       0 is passed as the "old" stack top as it is not used in this situation.  */

    if (stack_pointer_setup_code_operand_address != 0)
        (void) set_stack_top(0, old_stack_top);
}

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