Subversion Repositories openrisc_me

/*

 * Copyright (c) 1983, 1993, 2001

 *      The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include "gprof.h"

#include "search_list.h"

#include "source.h"

#include "symtab.h"

#include "cg_arcs.h"

#include "corefile.h"

#include "hist.h"

    /*

     *        opcode of the `callf' instruction

     */

#define CALLF   0xfe

    /*

     *        register for pc relative addressing

     */

#define PC      0xf

enum tahoe_opermodes

  {

    literal, indexed, reg, regdef, autodec, autoinc, autoincdef,

    bytedisp, bytedispdef, worddisp, worddispdef, longdisp, longdispdef,

    immediate, absolute, byterel, bytereldef, wordrel, wordreldef,

    longrel, longreldef

  };

typedef enum tahoe_opermodes tahoe_operandenum;

/*

 * A symbol to be the child of indirect callf:

 */

static Sym indirectchild;

static tahoe_operandenum tahoe_operandmode (unsigned char *);

static char *tahoe_operandname (tahoe_operandenum);

static long tahoe_operandlength (unsigned char *);

static bfd_signed_vma tahoe_offset (unsigned char *);

void tahoe_find_call (Sym *, bfd_vma, bfd_vma);

static tahoe_operandenum

tahoe_operandmode (unsigned char *modep)

{

  long usesreg = *modep & 0xf;

  switch ((*modep >> 4) & 0xf)

    {

    case 0:

    case 1:

    case 2:

    case 3:

      return literal;

    case 4:

      return indexed;

    case 5:

      return reg;

    case 6:

      return regdef;

    case 7:

      return autodec;

    case 8:

      return usesreg != 0xe ? autoinc : immediate;

    case 9:

      return usesreg != PC ? autoincdef : absolute;

    case 10:

      return usesreg != PC ? bytedisp : byterel;

    case 11:

      return usesreg != PC ? bytedispdef : bytereldef;

    case 12:

      return usesreg != PC ? worddisp : wordrel;

    case 13:

      return usesreg != PC ? worddispdef : wordreldef;

    case 14:

      return usesreg != PC ? longdisp : longrel;

    case 15:

      return usesreg != PC ? longdispdef : longreldef;

    }

  /* NOTREACHED */

  abort ();

}

static char *

tahoe_operandname (tahoe_operandenum mode)

{

  switch (mode)

    {

    case literal:

      return "literal";

    case indexed:

      return "indexed";

    case reg:

      return "register";

    case regdef:

      return "register deferred";

    case autodec:

      return "autodecrement";

    case autoinc:

      return "autoincrement";

    case autoincdef:

      return "autoincrement deferred";

    case bytedisp:

      return "byte displacement";

    case bytedispdef:

      return "byte displacement deferred";

    case byterel:

      return "byte relative";

    case bytereldef:

      return "byte relative deferred";

    case worddisp:

      return "word displacement";

    case worddispdef:

      return "word displacement deferred";

    case wordrel:

      return "word relative";

    case wordreldef:

      return "word relative deferred";

    case immediate:

      return "immediate";

    case absolute:

      return "absolute";

    case longdisp:

      return "long displacement";

    case longdispdef:

      return "long displacement deferred";

    case longrel:

      return "long relative";

    case longreldef:

      return "long relative deferred";

    }

  /* NOTREACHED */

  abort ();

}

static long

tahoe_operandlength (unsigned char *modep

)

{

  switch (tahoe_operandmode (modep))

    {

    case literal:

    case reg:

    case regdef:

    case autodec:

    case autoinc:

    case autoincdef:

      return 1;

    case bytedisp:

    case bytedispdef:

    case byterel:

    case bytereldef:

      return 2;

    case worddisp:

    case worddispdef:

    case wordrel:

    case wordreldef:

      return 3;

    case immediate:

    case absolute:

    case longdisp:

    case longdispdef:

    case longrel:

    case longreldef:

      return 5;

    case indexed:

      return 1 + tahoe_operandlength (modep + 1);

    }

  /* NOTREACHED */

  abort ();

}

static bfd_signed_vma

tahoe_offset (unsigned char *modep)

{

  tahoe_operandenum mode = tahoe_operandmode (modep);

  ++modep;                              /* skip over the mode */

  switch (mode)

    {

    default:

      fprintf (stderr, "[reladdr] not relative address\n");

      return 0;

    case byterel:

      return 1 + bfd_get_signed_8 (core_bfd, modep);

    case wordrel:

      return 2 + bfd_get_signed_16 (core_bfd, modep);

    case longrel:

      return 4 + bfd_get_signed_32 (core_bfd, modep);

    }

}

void

tahoe_find_call (Sym *parent, bfd_vma p_lowpc, bfd_vma p_highpc)

{

  unsigned char *instructp;

  long length;

  Sym *child;

  tahoe_operandenum mode;

  tahoe_operandenum firstmode;

  bfd_vma pc, destpc;

  static bfd_boolean inited = FALSE;

  if (!inited)

    {

      inited = TRUE;

      sym_init (&indirectchild);

      indirectchild.cg.prop.fract = 1.0;

      indirectchild.cg.cyc.head = &indirectchild;

    }

  DBG (CALLDEBUG, printf ("[findcall] %s: 0x%lx to 0x%lx\n",

                          parent->name, (unsigned long) p_lowpc,

                          (unsigned long) p_highpc));

  for (pc = p_lowpc; pc < p_highpc; pc += length)

    {

      length = 1;

      instructp = ((unsigned char *) core_text_space

                   + pc - core_text_sect->vma);

      if ((*instructp & 0xff) == CALLF)

        {

          /*

           *    maybe a callf, better check it out.

           *      skip the count of the number of arguments.

           */

          DBG (CALLDEBUG, printf ("[findcall]\t0x%lx:callf",

                                  (unsigned long) pc));

          firstmode = tahoe_operandmode (instructp + length);

          switch (firstmode)

            {

            case literal:

            case immediate:

              break;

            default:

              goto botched;

            }

          length += tahoe_operandlength (instructp + length);

          mode = tahoe_operandmode (instructp + length);

          DBG (CALLDEBUG,

               printf ("\tfirst operand is %s", tahoe_operandname (firstmode));

               printf ("\tsecond operand is %s\n", tahoe_operandname (mode));

            );

          switch (mode)

            {

            case regdef:

            case bytedispdef:

            case worddispdef:

            case longdispdef:

            case bytereldef:

            case wordreldef:

            case longreldef:

              /*

               *    indirect call: call through pointer

               *      either  *d(r)   as a parameter or local

               *              (r)     as a return value

               *              *f      as a global pointer

               *      [are there others that we miss?,

               *       e.g. arrays of pointers to functions???]

               */

              arc_add (parent, &indirectchild, (unsigned long) 0);

              length += tahoe_operandlength (instructp + length);

              continue;

            case byterel:

            case wordrel:

            case longrel:

              /*

               *    regular pc relative addressing

               *      check that this is the address of

               *      a function.

               */

              destpc = pc + tahoe_offset (instructp + length);

              if (hist_check_address (destpc))

                {

                  child = sym_lookup (&symtab, destpc);

                  if (child)

                    {

                      DBG (CALLDEBUG,

                           printf ("[findcall]\tdestpc 0x%lx",

                                   (unsigned long) destpc);

                           printf (" child->name %s", child->name);

                           printf (" child->addr 0x%lx\n",

                                   (unsigned long) child->addr);

                        );

                      if (child->addr == destpc)

                        {

                          /*

                           *    a hit

                           */

                          arc_add (parent, child, (unsigned long) 0);

                          length += tahoe_operandlength (instructp + length);

                          continue;

                        }

                    }

                  goto botched;

                }

              /*

               *    else:

               *      it looked like a callf,

               *      but it wasn't to anywhere.

               */

              goto botched;

            default:

            botched:

              /*

               *    something funny going on.

               */

              DBG (CALLDEBUG, printf ("[findcall]\tbut it's a botch\n"));

              length = 1;

              continue;

            }

        }

    }

}