path: root/gdb/m88k-tdep.c

/* Copyright (C) 1988, 1990 Free Software Foundation, Inc.

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 2 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, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include "defs.h"
#include "param.h"
#include "frame.h"
#include "inferior.h"
#include "value.h"

#ifdef USG
#include <sys/types.h>
#endif

#include <sys/param.h>
#include <sys/dir.h>
#include <signal.h>
#include "gdbcore.h"
#include <sys/user.h>
#ifndef USER			/* added to support BCS ptrace_user */

#define USER ptrace_user
#endif
#include <sys/ioctl.h>
#include <fcntl.h>

#include <sys/file.h>
#include <sys/stat.h>

#include "symtab.h"
#include "setjmp.h"
#include "value.h"

int stack_error;
jmp_buf stack_jmp;

void
tdesc_error_function  (environment, continuable, message)
dc_word_t environment;
dc_boolean_t continuable;
char *message;
{
  if (stack_error) longjmp (stack_jmp, 1);
  if (!continuable)
    {
      printf("%s\n",message);
      abort();
    }
}


void
tdesc_read_function (environment, memory, length, buffer)
dc_word_t environment;
dc_word_t memory;
int length;
char *buffer;
{
  int ptrace_code;
  errno = 0;
  if (memory < 2048) 
#if 0
    /* This is a no-op!  It sets buffer, but doesn't do anything to
       what buffer points to.  What does this function do anyway?
       And this is wrong for cross-debugging.  */
    buffer = ptrace (3, inferior_pid, memory, 0);
#else
    return;
#endif
  else
    read_memory (memory, buffer, length);
}

/* Map function for tdesc */
void
tdesc_map_function (map_env, loc, map_info_in, map_info_out)
dc_word_t map_env;
dc_word_t loc;
dc_map_info_in_t map_info_in;
dc_map_info_out_t *map_info_out;
{
int map_flags = DC_MIO_ENTRY_POINT | DC_MIO_IMPLICIT_PROLOGUE_END;
int entry_point = get_pc_function_start(loc);
map_info_out->flags = map_flags;
map_info_out->entry_point = entry_point;
}

dc_handle_t tdesc_handle;

extern int debug_info;

void
init_tdesc ()
{
  tdesc_handle = dc_initiate (debug_info, tdesc_error_function,
			      0,tdesc_read_function,0,0,0,0,0,tdesc_map_function,0);
} 
dc_dcontext_t current_context;
  
/* setup current context, called from wait_for_inferior */

dc_dcontext_t
init_dcontext()
{
  dc_word_t reg_info[DC_NUM_REG];
  dc_word_t reg_flags[2] = {0,-1};
  dc_word_t aux_info[DC_NUM_AUX];
  dc_word_t aux_flags[2] = {0,-1};
  dc_exactness_t loc_exact = DC_NO;
  dc_word_t psr_info;
  dc_boolean_t psr_ind = 0;
  dc_word_t psr_flags[2] = {0,-1};

  bcopy (&registers, reg_info, DC_NUM_REG * 4);
  aux_info[DC_AUX_LOC] =  read_register(SXIP_REGNUM);
  aux_info[DC_AUX_SXIP] = read_register(SXIP_REGNUM);
  aux_info[DC_AUX_SNIP] = read_register(SNIP_REGNUM);
  aux_info[DC_AUX_SFIP] = read_register(SFIP_REGNUM);
  aux_info[DC_AUX_FPSR] = read_register(FPSR_REGNUM);
  aux_info[DC_AUX_FPCR] = read_register(FPCR_REGNUM);

  psr_info = read_register(PSR_REGNUM);

  return dc_make_dcontext (tdesc_handle, reg_info, reg_flags, aux_info,
                         aux_flags, loc_exact, psr_info, psr_ind, psr_flags);
}


dc_dcontext_t
get_prev_context (context)
  dc_dcontext_t context;
{
  return current_context = dc_previous_dcontext (context); 
}
  



/* Determine frame base for this file's frames.  This will be either
   the CFA or the old style FP_REGNUM; the symtab for the current pc's
   file has the information					      */

CORE_ADDR
get_frame_base(pc)
CORE_ADDR pc;
{
  struct symtab *this_file = find_pc_symtab(pc);
  int coffsem_frame_position;
  
  /* If this_file is null, there's a good chance the file was compiled
     without -g.  If that's the case, use CFA (canonical frame addr) 
     as the default frame pointer.                                 */

  if (this_file)
    {
    coffsem_frame_position = this_file->coffsem & 3;
    if (coffsem_frame_position == 1) 
      return (CORE_ADDR) dc_general_register (current_context, FP_REGNUM);
    else
      /* default is CFA, as well as if coffsem==2 */
      return (CORE_ADDR) dc_frame_address  (current_context);
    }

  return (CORE_ADDR) dc_frame_address (current_context);
}

#if TARGET_BYTE_ORDER != HOST_BYTE_ORDER
you lose
#else /* Host and target byte order the same.  */
#define SINGLE_EXP_BITS  8
#define DOUBLE_EXP_BITS 11
int
IEEE_isNAN(fp, len)
     int *fp, len;
     /* fp points to a single precision OR double precision
      * floating point value; len is the number of bytes, either 4 or 8.
      * Returns 1 iff fp points to a valid IEEE floating point number.
      * Returns 0 if fp points to a denormalized number or a NaN
      */
{
  int exponent;
  if (len == 4)
    {
      exponent = *fp;
      exponent = exponent << 1 >> (32 - SINGLE_EXP_BITS - 1);
      return ((exponent == -1) || (! exponent && *fp));
    }
  else if (len == 8)
    {
      exponent = *(fp+1);
      exponent = exponent << 1 >> (32 - DOUBLE_EXP_BITS - 1);
      return ((exponent == -1) || (! exponent && *fp * *(fp+1)));
    }
  else return 1;
}
#endif /* Host and target byte order the same.  */

#define FIRST_PRESERVED_REGNUM	14
#define LAST_PRESERVED_REGNUM	25
#define FIRST_PARM_REGNUM	2
#define LAST_PARM_REGNUM	9

#define MAX_REG_PARMS	(LAST_PARM_REGNUM - FIRST_PARM_REGNUM + 1)

void
frame_find_saved_regs (fi, fsr)
      struct frame_info *fi;
      struct frame_saved_regs *fsr;
{
   register int regnum;
 
   error ("Feature not implemented for the 88k yet.");
   return;
 
#if 0
   for (regnum = FIRST_PARM_REGNUM; regnum <= LAST_PARM_REGNUM; regnum++)
     fsr->regs[regnum]
        = (unsigned) fi->frame - ((regnum - FIRST_PARM_REGNUM) * 4);
 
   fsr->regs[SP_REGNUM] = 0;		/* SP not saved in frames */
   fsr->regs[FP_REGNUM] = fi->frame;
   fsr->regs[PC_REGNUM] = fi->frame + 4;
#endif
}

static int
pushed_size (prev_words, v)
     int prev_words;
     struct value *v;
{
  switch (TYPE_CODE (VALUE_TYPE (v)))
    {
      case TYPE_CODE_VOID:		/* Void type (values zero length) */

	return 0;	/* That was easy! */

      case TYPE_CODE_PTR:		/* Pointer type */
      case TYPE_CODE_ENUM:		/* Enumeration type */
      case TYPE_CODE_INT:		/* Integer type */
      case TYPE_CODE_REF:		/* C++ Reference types */
      case TYPE_CODE_ARRAY:		/* Array type, lower bound zero */

	return 1;

      case TYPE_CODE_FLT:		/* Floating type */

	if (TYPE_LENGTH (VALUE_TYPE (v)) == 4)
	  return 1;
	else
	  /* Assume that it must be a double.  */
	  if (prev_words & 1)		/* at an odd-word boundary */
	    return 3;			/* round to 8-byte boundary */
	  else
	    return 2;

      case TYPE_CODE_STRUCT:		/* C struct or Pascal record */
      case TYPE_CODE_UNION:		/* C union or Pascal variant part */

	return (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4);

      case TYPE_CODE_FUNC:		/* Function type */
      case TYPE_CODE_SET:		/* Pascal sets */
      case TYPE_CODE_RANGE:		/* Range (integers within bounds) */
      case TYPE_CODE_PASCAL_ARRAY:	/* Array with explicit type of index */
      case TYPE_CODE_MEMBER:		/* Member type */
      case TYPE_CODE_METHOD:		/* Method type */
	/* Don't know how to pass these yet.  */

      case TYPE_CODE_UNDEF:		/* Not used; catches errors */
      default:
	abort ();
    }
}

static void
store_parm_word (address, val)
     CORE_ADDR address;
     int val;
{
  write_memory (address, &val, 4);
}

static int
store_parm (prev_words, left_parm_addr, v)
     unsigned int prev_words;
     CORE_ADDR left_parm_addr;
     struct value *v;
{
  CORE_ADDR start = left_parm_addr + (prev_words * 4);
  int *val_addr = (int *)VALUE_CONTENTS(v);

  switch (TYPE_CODE (VALUE_TYPE (v)))
    {
      case TYPE_CODE_VOID:		/* Void type (values zero length) */

	return 0;

      case TYPE_CODE_PTR:		/* Pointer type */
      case TYPE_CODE_ENUM:		/* Enumeration type */
      case TYPE_CODE_INT:		/* Integer type */
      case TYPE_CODE_ARRAY:		/* Array type, lower bound zero */
      case TYPE_CODE_REF:		/* C++ Reference types */

	store_parm_word (start, *val_addr);
	return 1;

      case TYPE_CODE_FLT:		/* Floating type */

	if (TYPE_LENGTH (VALUE_TYPE (v)) == 4)
	  {
	    store_parm_word (start, *val_addr);
	    return 1;
	  }
	else
	  {
	    store_parm_word (start + ((prev_words & 1) * 4), val_addr[0]);
	    store_parm_word (start + ((prev_words & 1) * 4) + 4, val_addr[1]);
	    return 2 + (prev_words & 1);
	  }

      case TYPE_CODE_STRUCT:		/* C struct or Pascal record */
      case TYPE_CODE_UNION:		/* C union or Pascal variant part */

	{
	  unsigned int words = (((TYPE_LENGTH (VALUE_TYPE (v)) + 3) / 4) * 4);
	  unsigned int word;

	  for (word = 0; word < words; word++)
	    store_parm_word (start + (word * 4), val_addr[word]);
	  return words;
	}

      default:
	abort ();
    }
}

 /* This routine sets up all of the parameter values needed to make a pseudo
    call.  The name "push_parameters" is a misnomer on some archs,
    because (on the m88k) most parameters generally end up being passed in
    registers rather than on the stack.  In this routine however, we do
    end up storing *all* parameter values onto the stack (even if we will
    realize later that some of these stores were unnecessary).  */

void
push_parameters (return_type, struct_conv, nargs, args)
      struct type *return_type; 
      int struct_conv;
      int nargs;
      value *args;
 {
   int parm_num;
   unsigned int p_words = 0;
   CORE_ADDR left_parm_addr;
 
   /* Start out by creating a space for the return value (if need be).  We
      only need to do this if the return value is a struct or union.  If we
      do make a space for a struct or union return value, then we must also
      arrange for the base address of that space to go into r12, which is the
      standard place to pass the address of the return value area to the
      callee.  Note that only structs and unions are returned in this fashion.
      Ints, enums, pointers, and floats are returned into r2.  Doubles are
      returned into the register pair {r2,r3}.  Note also that the space
      reserved for a struct or union return value only has to be word aligned
      (not double-word) but it is double-word aligned here anyway (just in
      case that becomes important someday).  */
 
   switch (TYPE_CODE (return_type))
     {
       case TYPE_CODE_STRUCT:
       case TYPE_CODE_UNION:
         {
           int return_bytes = ((TYPE_LENGTH (return_type) + 7) / 8) * 8;
           CORE_ADDR rv_addr;
 
           rv_addr = read_register (SP_REGNUM) - return_bytes;
 
           write_register (SP_REGNUM, rv_addr); /* push space onto the stack */
           write_register (SRA_REGNUM, rv_addr);/* set return value register */
         }
     }
 
   /* Here we make a pre-pass on the whole parameter list to figure out exactly
      how many words worth of stuff we are going to pass.  */
 
   for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++)
     p_words += pushed_size (p_words, value_arg_coerce (args[parm_num]));
 
   /* Now, check to see if we have to round up the number of parameter words
      to get up to the next 8-bytes boundary.  This may be necessary because
      of the software convention to always keep the stack aligned on an 8-byte
      boundary.  */
 
   if (p_words & 1)
     p_words++;		/* round to 8-byte boundary */
 
   /* Now figure out the absolute address of the leftmost parameter, and update
      the stack pointer to point at that address.  */
 
   left_parm_addr = read_register (SP_REGNUM) - (p_words * 4);
   write_register (SP_REGNUM, left_parm_addr);
 
   /* Now we can go through all of the parameters (in left-to-right order)
      and write them to their parameter stack slots.  Note that we are not
      really "pushing" the parameter values.  The stack space for these values
      was already allocated above.  Now we are just filling it up.  */
 
   for (p_words = 0, parm_num = 0; parm_num < nargs; parm_num++)
     p_words +=
       store_parm (p_words, left_parm_addr, value_arg_coerce (args[parm_num]));
 
   /* Now that we are all done storing the parameter values into the stack, we
      must go back and load up the parameter registers with the values from the
      corresponding stack slots.  Note that in the two cases of (a) gaps in the
      parameter word sequence causes by (otherwise) misaligned doubles, and (b)
      slots correcponding to structs or unions, the work we do here in loading
      some parameter registers may be unnecessary, but who cares?  */
 
   for (p_words = 0; p_words < 8; p_words++)
     {
       write_register (FIRST_PARM_REGNUM + p_words,
         read_memory_integer (left_parm_addr + (p_words * 4), 4));
     }
}

void
pop_frame ()
{
  error ("Feature not implemented for the m88k yet.");
  return;
}

 void
 collect_returned_value (rval, value_type, struct_return, nargs, args)
      value *rval;
      struct type *value_type;
      int struct_return;
      int nargs;
      value *args;
 {
   char retbuf[REGISTER_BYTES];
 
   bcopy (registers, retbuf, REGISTER_BYTES);
   *rval = value_being_returned (value_type, retbuf, struct_return);
   return;
 }

#if 0
/* Now handled in a machine independent way with CALL_DUMMY_LOCATION.  */
 /* Stuff a breakpoint instruction onto the stack (or elsewhere if the stack
    is not a good place for it).  Return the address at which the instruction
    got stuffed, or zero if we were unable to stuff it anywhere.  */
  
 CORE_ADDR
 push_breakpoint ()
  {
   static char breakpoint_insn[] = BREAKPOINT;
   extern CORE_ADDR text_end;	/* of inferior */
   static char readback_buffer[] = BREAKPOINT;
   int i;
  
   /* With a little bit of luck, we can just stash the breakpoint instruction
      in the word just beyond the end of normal text space.  For systems on
      which the hardware will not allow us to execute out of the stack segment,
      we have to hope that we *are* at least allowed to effectively extend the
      text segment by one word.  If the actual end of user's the text segment
      happens to fall right at a page boundary this trick may fail.  Note that
      we check for this by reading after writing, and comparing in order to
      be sure that the write worked.  */
 
   write_memory (text_end, &breakpoint_insn, 4);
 
   /* Fill the readback buffer with some garbage which is certain to be
      unequal to the breakpoint insn.  That way we can tell if the
      following read doesn't actually succeed.  */
 
   for (i = 0; i < sizeof (readback_buffer); i++)
     readback_buffer[i] = ~ readback_buffer[i];	/* Invert the bits */
 
   /* Now check that the breakpoint insn was successfully installed.  */
 
   read_memory (text_end, readback_buffer, sizeof (readback_buffer));
   for (i = 0; i < sizeof (readback_buffer); i++)
     if (readback_buffer[i] != breakpoint_insn[i])
       return 0;		/* Failed to install! */
 
   return text_end;
 }
#endif

/* Like dc_psr_register but takes an extra int arg.  */
static dc_word_t
psr_register (context, dummy)
     dc_dcontext_t context;
     int dummy;
{
  return dc_psr_register (context);
}

/* Same functionality as get_saved_register in findvar.c, but implemented
   to use tdesc.  */
void
get_saved_register (raw_buffer, optim, addrp, frame, regnum, lvalp)
     char *raw_buffer;
     int *optim;
     CORE_ADDR *addrp;
     FRAME frame;
     int regnum;
     enum lval_type *lvalp;
{
  struct frame_info *fi = get_frame_info (frame);
  
  /* Functions to say whether a register is optimized out, and
     if not, to get the value.  Take as args a context and the
     value of get_reg_arg.  */
  int (*get_reg_state) ();
  dc_word_t (*get_reg) ();
  int get_reg_arg;

  /* Because tdesc doesn't tell us whether it got it from a register
     or memory, always say we don't have an address for it.  */
  if (addrp != NULL)
    *addrp = 0;
  
  if (regnum < DC_NUM_REG)
    {
      get_reg_state = dc_general_register_state;
      get_reg = dc_general_register;
      get_reg_arg = regnum;
    }
  else
    {
      get_reg_state = dc_auxiliary_register_state;
      get_reg = dc_auxiliary_register;
      switch (regnum)
	{
	case SXIP_REGNUM:
	  get_reg_arg = DC_AUX_SXIP;
	  break;
	case SNIP_REGNUM:
	  get_reg_arg = DC_AUX_SNIP;
	  break;
	case FPSR_REGNUM:
	  get_reg_arg = DC_AUX_FPSR;
	  break;
	case FPCR_REGNUM:
	  get_reg_arg = DC_AUX_FPCR;
	  break;
	case PSR_REGNUM:
	  get_reg_state = dc_psr_register_bit_state;
	  get_reg = psr_register;
	  get_reg_arg = 0;
	  break;
	default:
	  if (optim != NULL)
	    *optim = 1;
	  return;
	}
    }

  if ((*get_reg_state) (fi->frame_context, get_reg_arg))
    {
      if (raw_buffer != NULL)
	*(int *)raw_buffer = (*get_reg) (fi->frame_context, get_reg_arg);
      if (optim != NULL)
	*optim = 0;
      return;
    }
  else
    {
      if (optim != NULL)
	*optim = 1;
      return;
    }

  /* Well, the caller can't treat it as a register or memory...  */
  if (lvalp != NULL)
    *lvalp = not_lval;
}