Subversion Repositories openrisc

/* support.c -- Support code for Or1ksim testing.

   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org

   Copyright (C) 2008, 2010 Embecosm Limited

   Contributor Damjan Lampret <lampret@opencores.org>

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   This file is part of OpenRISC 1000 Architectural Simulator.

   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/>. */

/* ----------------------------------------------------------------------------

   This code is commented throughout for use with Doxygen.

   --------------------------------------------------------------------------*/

/* Support */

#include "spr-defs.h"

#include "support.h"

#include "int.h"

/* Forward declarations of interrupt handlers */

static void excpt_dummy();

extern void int_main();

/* Exception handlers. All are dummy except the interrupt handler */

unsigned long excpt_buserr   = (unsigned long) excpt_dummy;

unsigned long excpt_dpfault  = (unsigned long) excpt_dummy;

unsigned long excpt_ipfault  = (unsigned long) excpt_dummy;

unsigned long excpt_tick     = (unsigned long) excpt_dummy;

unsigned long excpt_align    = (unsigned long) excpt_dummy;

unsigned long excpt_illinsn  = (unsigned long) excpt_dummy;

unsigned long excpt_int      = (unsigned long) int_main;

unsigned long excpt_dtlbmiss = (unsigned long) excpt_dummy;

unsigned long excpt_itlbmiss = (unsigned long) excpt_dummy;

unsigned long excpt_range    = (unsigned long) excpt_dummy;

unsigned long excpt_syscall  = (unsigned long) excpt_dummy;

unsigned long excpt_break    = (unsigned long) excpt_dummy;

unsigned long excpt_trap     = (unsigned long) excpt_dummy;

/* --------------------------------------------------------------------------*/

/*!Is a character a decimal digit?

   @param[in] c  The character to test

   @return  1 (TRUE) if the character is a decimal digit, 0 (FALSE)

            otherwise                                                        */

/* --------------------------------------------------------------------------*/

static int

is_digit (char  c)

{

  return ('0' <= c) && (c <= '9');

}       /* is_digit () */

/* --------------------------------------------------------------------------*/

/*!Print a char in a width

   The char is always right justified.

   @param[in] c      The character to print

   @param[in] width  The width to print in

   @return  The number of characters actually printed (always width)         */

/* --------------------------------------------------------------------------*/

static int

printf_char (char  c,

             int   width)

{

  int  i;

  /* Spacing */

  for (i = 1; i < width; i++)

    {

      putchar (' ');

    }

  /* The char */

  putchar (c);

  return  width;

}       /* printf_char () */

/* --------------------------------------------------------------------------*/

/*!Convert a digit to a char

   We don't worry about the base. If the value supplied is over 10, we assume

   its a letter.

   @param[in] d  The digit to convert.

   @return  The character representation.                                    */

/* --------------------------------------------------------------------------*/

static char

dig2char (int  d)

{

  return (d < 10) ? '0' + d : 'a' + d - 10;

}       /* dit2char () */

/* --------------------------------------------------------------------------*/

/*!Print a number to a base to a string

   The number is unsigned, left justified and null terminated

   @param[in] uval  The value to print

   @param[in] buf   The buffer to print in

   @param[in] base  The base to use.

   @return  the length of the string created.                                */

/* --------------------------------------------------------------------------*/

static int

print_base (long unsigned int  uval,

            char               buf[],

            unsigned int       base)

{

  /* Initially print backwards. Always have at least a zero. */

  int  i = 0;

  do

    {

      buf[i] = dig2char (uval % base);

      uval = uval / base;

      i++;

    }

  while (0 != uval);

  buf[i] = 0;                    /* End of string */

  int  len = i;                 /* Length of the string */

  /* Reverse the string */

  for (i = 0; i < (len / 2); i++)

    {

      char  c          = buf[i];

      buf[i]           = buf[len - i - 1];

      buf[len - i - 1] = c;

    }

  return  len;

}       /* print_base () */

/* --------------------------------------------------------------------------*/

/*!Print a character multiple times

   @param[in] c    The char to print

   @param[in] num  Number of times to print                                 */

/* --------------------------------------------------------------------------*/

static void

print_multichar (char  c,

                 int   num)

{

  for (; num > 0; num--)

    {

      putchar (c);

    }

}       /* print_multichar () */

/* --------------------------------------------------------------------------*/

/*!Print a string

   @param[in] str  The string to print                                       */

/* --------------------------------------------------------------------------*/

static void

print_str (char  str [])

{

  int  i;

  for (i = 0; 0 != str[i]; i++)

    {

      putchar (str[i]);

    }

}       /* print_str () */

/* --------------------------------------------------------------------------*/

/*!Return the length of a string

   @param[in] str    The string whose length is wanted

   @return  The length of the string                                         */

/* --------------------------------------------------------------------------*/

static int

strlen (char  str [])

{

  int  i;

  for (i = 0; str[i] != 0; i++)

    {

    }

  return  i;

}       /* strlen () */

/* --------------------------------------------------------------------------*/

/*!Print a string in a width

   @param[in] str    The string to print

   @param[in] width  The width to print it in (at least)

   @return  The number of chars printed                                      */

/* --------------------------------------------------------------------------*/

static int

printf_str (char  str [],

            int   width)

{

  int len = strlen (str);

  if (width > len)

    {

      print_multichar (' ', width - len);

    }

  print_str (str);

  return  (width > len) ? width : len;

}       /* printf_str () */

/* --------------------------------------------------------------------------*/

/*!Print a decimal in a width

   The number is always right justified and signed.

   @param[in] val              The value to print

   @param[in] width            The width to print in (at least)

   @param[in] leading_zeros_p  1 (TRUE) if we should print leading zeros,

   @return  The number of chars printed                                      */

/* --------------------------------------------------------------------------*/

static int

printf_decimal (long int  val,

                int       width,

                int       leading_zeros_p)

{

  int  is_signed_p = 0;

  /* Note if we need a sign */

  if (val < 0)

    {

      val         = -val;

      is_signed_p = 1;

    }

  /* Array to store the number in. We know the max for 32 bits is 10

     digits. Allow for end of string marker */

  char  num_array[11];

  int  num_width = print_base ((unsigned long int) val, num_array, 10);

  /* Now print out the number. */

  num_width += is_signed_p ? 1 : 0;

  if (num_width < width)

    {

      if (leading_zeros_p)

        {

          if (is_signed_p)

            {

              putchar ('-');

            }

          print_multichar ('0', width - num_width);

        }

      else

        {

          print_multichar (' ', width - num_width);

          if (is_signed_p)

            {

              putchar ('-');

            }

        }

    }

  else

    {

      if (is_signed_p)

        {

          putchar ('-');

        }

    }

  print_str (num_array);

  return  width > num_width ? width : num_width;

}       /* printf_decimal () */

/* --------------------------------------------------------------------------*/

/*!Print a unsigned to a base in a width

   The number is always right justified and unsigned.

   @param[in] val              The value to print

   @param[in] width            The width to print in (at least)

   @param[in] leading_zeros_p  1 (TRUE) if we should print leading zeros,

   @param[in] base             Base to use when printing

   @return  The number of chars printed                                      */

/* --------------------------------------------------------------------------*/

static int

printf_unsigned_base (unsigned long int  val,

                      int                width,

                      int                leading_zeros_p,

                      unsigned int       base)

{

  int  is_signed_p = 0;

  /* Note if we need a sign */

  if (val < 0)

    {

      val         = -val;

      is_signed_p = 1;

    }

  /* Array to store the number in. We know the max for 32 bits of octal is 11

     digits. Allow for end of string marker */

  char  num_array[12];

  int  num_width = print_base (val, num_array, base);

  /* Now print out the number. */

  num_width += is_signed_p ? 1 : 0;

  if (num_width < width)

    {

      print_multichar (leading_zeros_p ? '0' : ' ', width - num_width);

    }

  print_str (num_array);

  return  width > num_width ? width : num_width;

}       /* printf_unsigned_base () */

/* --------------------------------------------------------------------------*/

/*!Dummy exception handler

   Used for most exceptions as the default hander which does nothing.        */

/* --------------------------------------------------------------------------*/

static void

excpt_dummy()

{

}       /* excpt_dummy ()*/

/*! Function to be called at entry point - not defined here. */

extern int main  ();

/* --------------------------------------------------------------------------*/

/*!Start function

   Called by reset exception handler.                                        */

/* --------------------------------------------------------------------------*/

void

reset ()

{

  exit (main ());

}       /* reset () */

/* --------------------------------------------------------------------------*/

/*!Exit function

   Return value by making a syscall

   @param[in] rc  Return code                                                */

/* --------------------------------------------------------------------------*/

void

exit (int rc)

{

  __asm__ __volatile__ ("l.add r3,r0,%0\n\t"

                        "l.nop %1": : "r" (rc), "K" (NOP_EXIT));

  /* Header declares function as __noreturn, so ensure that is so. */

  while (1)

    {

    }

}       /* exit () */

/* --------------------------------------------------------------------------*/

/*!Activate printing a character in the simulator

   @param[in] c  The character to print

   @return  The char printed cast to an int                                  */

/* --------------------------------------------------------------------------*/

int

putchar (int  c)

{

  __asm__ __volatile__ ("l.addi\tr3,%0,0\n\t"

                        "l.nop %1": : "r" (c), "K" (NOP_PUTC));

  return  c;

}       /* putchar () */

/* --------------------------------------------------------------------------*/

/*!Print a string

   We need to define this, since the compiler will replace calls to printf

   using just constant strings with trailing newlines with calls to puts

   without the newline.

   @param[in] str  The string to print (without a newline)

   @return  The char printed cast to an int                                  */

/* --------------------------------------------------------------------------*/

int

puts (const char *str)

{

  return  printf ("%s\n", str);

}       /* puts () */

/* --------------------------------------------------------------------------*/

/*!Activate printf support in simulator

   @note This doesn't actually work, so we implement the basics of printf by

         steam, calling useful subsidiary functions based on putchar (), which

         does work.

   @param[in] fmt  The format string

   @param[in] ...  The variable arguments if any

   @return  The number of characters printed                                 */

/* --------------------------------------------------------------------------*/

int

printf(const char *fmt,

          ...)

{

  int  num_chars = 0;                    /* How many chars printed */

  va_list args;

  va_start (args, fmt);

  int  i;                               /* Index into the string */

  for (i = 0; fmt[i] != 0; i++)

    {

      if ('%' == fmt[i])

        {

          int  width;

          int  leading_zeros_p;

          /* Decode the field */

          i++;

          /* Are leading zeros requested? */

          if ('0' == fmt[i])

            {

              leading_zeros_p = 1;

              i++;

            }

          else

            {

              leading_zeros_p = 0;

            }

          /* Is there a width specification? */

          width = 0;

          while (is_digit (fmt[i]))

            {

              width = width * 10 + fmt[i] - '0';

              i++;

            }

          /* We just ignore any "l" specification. We do everything as

             32-bit. */

          i += ('l' == fmt[i]) ? 1 : 0;

          /* Deal with each field according to the type indicactor */

          char              ch;

          char             *str;

          long int          val;

          unsigned long int uval;

          /* There is a bug in GCC for OR1K, which can't handle two many

             cases. For now we split this into two disjoint case statements. */

          switch (fmt[i])

            {

            case 'c':

              ch = va_arg (args, int);

              num_chars += printf_char (ch, width);

              break;

            case 'o':

              uval = va_arg (args, unsigned long int);

              num_chars +=printf_unsigned_base (uval, width, leading_zeros_p,

                                               8);

              break;

            case 's':

              str = va_arg (args, char *);

              num_chars += printf_str (str, width);

              break;

            case 'x':

              uval = va_arg (args, unsigned long int);

              num_chars += printf_unsigned_base (uval, width, leading_zeros_p,

                                                16);

              break;

            default:

              /* Default is to do nothing silently */

              break;

            }

          switch (fmt[i])

            {

            case'd': case 'i':

              val = va_arg (args, long int);

              num_chars += printf_decimal (val, width, leading_zeros_p);

              break;

            }

        }

      else

        {

          putchar (fmt[i]);

          num_chars++;

        }

    }

  va_end (args);

  return  num_chars;

}       /* printf () */

/* --------------------------------------------------------------------------*/

/*!Report a 32-bit value

   Uses the built-in simulator functionality.

   @param[in] value  Value to report.                                        */

/* --------------------------------------------------------------------------*/

void

report (unsigned long int  value)

{

  __asm__ __volatile__ ("l.addi\tr3,%0,0\n\t"

                        "l.nop %1": : "r" (value), "K" (NOP_REPORT));

}       /* report () */

/* --------------------------------------------------------------------------*/

/*!Mutliply two 32-bit values to give a 64-bit result

   This is not supported by the OR1K GCC.

   Use the identity

   (ax + b).(cx + d) = ac.x^2 + (ad + bc).x + bd

   x = 2^16. None of this should overflow.

   @param[in] op1  First operand

   @param[in] op2  Second operand

   @return  The result                                                       */

/* --------------------------------------------------------------------------*/

static unsigned long long int

l_mulu (unsigned long int  op1,

        unsigned long int  op2)

{

  unsigned long int a, b, c, d;

  a = op1 >> 16;

  b = op1 & 0xffff;

  c = op2 >> 16;

  d = op2 & 0xffff;

  /* Add in the terms */

  unsigned long long int  res;

  /* printf ("a = 0x%08lx, b = 0x%08lx, c = 0x%08lx, d = 0x%08lx\n", a, b, c, d); */

  res  =  (unsigned long long int) (a * c) << 32;

  /* printf ("  interim res = 0x%08lx%08lx\n", (unsigned long int) (res >> 32), */

  /*      (unsigned long int) res); */

  res += ((unsigned long long int) (a * d) << 16);

  /* printf ("  interim res = 0x%08lx%08lx\n", (unsigned long int) (res >> 32), */

  /*      (unsigned long int) res); */

  res += ((unsigned long long int) (b * c) << 16);

  /* printf ("  interim res = 0x%08lx%08lx\n", (unsigned long int) (res >> 32), */

  /*      (unsigned long int) res); */

  res +=  (unsigned long long int) (b * d);

  /* printf ("  interim res = 0x%08lx%08lx\n", (unsigned long int) (res >> 32), */

  /*      (unsigned long int) res); */

  /* printf ("0x%08lx * 0x%08lx = 0x%08lx%08lx\n", op1, op2, */

  /*      (unsigned long int) (res >> 32), (unsigned long int) res); */

  return  res;

}       /* l_mulu () */

/* --------------------------------------------------------------------------*/

/*!Mutliply two 64-bit values

   This is not supported by the OR1K GCC.

   Use the identity

   (ax + b).(cx + d) = ac.x^2 + (ad + bc).x + bd

   x = 2^32. We can discard the first term (overflow), though since this is

   for testing we'll print a message.

   The second term may overflow, so we compute the coefficient to 64-bit to

   see if we have overflowed.

   The final term may overflow, so we also compute this to 64-bit, so we can

   add the top 64-bits in.

   @param[in] op1  First operand

   @param[in] op2  Second operand

   @return  The result                                                       */

/* --------------------------------------------------------------------------*/

static unsigned long long int

ll_mulu (unsigned long long int  op1,

         unsigned long long int  op2)

{

  unsigned long int       a, b, c, d;

  unsigned long long int  tmp, res;

  a = op1 >> 32;

  b = op1 & 0xffffffff;

  c = op2 >> 32;

  d = op2 & 0xffffffff;

  if ((a > 0) && (c > 0))

    {

      printf ("ll_mulu overflows\n");

    }

  /* Compute and test the second term */

  tmp = l_mulu (a, d);

  if (tmp >= 0x100000000ULL)

    {

      printf ("ll_mulu overflows\n");

    }

  res = tmp << 32;

  tmp = l_mulu (b, c);

  if (tmp >= 0x100000000ULL)

    {

      printf ("ll_mulu overflows\n");

    }

  res += tmp << 32;

  /* Compute the third term. Although the term can't overflow, it could

     overflow the result. So just check our answer is larger when the final

     term is added in. */

  tmp = res;

  res += l_mulu (b, d);

  if (res < tmp)

    {

      printf ("ll_mulu overflows\n");

    }

  /* printf ("0x%08lx%08lx * 0x%08lx%08lx = 0x%08lx%08lx\n", a, b, c, d, */

  /*      (unsigned long int) (res >> 32), (unsigned long int) res); */

  return  res;

}       /* ll_mulu () */

/* --------------------------------------------------------------------------*/

/*!Divide a 64-bit value by a 32 bit value

   Until I can get hold of a copy of Knuth volume 2 to check the algorithm,

   this is a bitwise version.

   @param[in] op1  First operand

   @param[in] op2  Second operand

   @return  The result                                                       */

/* --------------------------------------------------------------------------*/

static unsigned long long int

ll_divu (unsigned long long int  dividend,

         unsigned long int       divisor)

{

  unsigned long long int  t, num_bits;

  unsigned long long int  q, bit, d;

  int            i;

  if (divisor == 0)

    {

      printf ("ERROR: Invalid division by zero\n");

      return  0;

    }

  if (divisor > dividend)

    {

      return  0;

    }

  if (divisor == dividend)

    {

      return  1ULL;

    }

  /* printf ("0x%08x%08x / 0x%08x = ", (unsigned int) (dividend >> 32), */