Subversion Repositories open8_urisc

/* dwarf2dbg.c - DWARF2 debug support

   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009

   Free Software Foundation, Inc.

   Contributed by David Mosberger-Tang <davidm@hpl.hp.com>

   This file is part of GAS, the GNU Assembler.

   GAS 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, or (at your option)

   any later version.

   GAS 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 GAS; see the file COPYING.  If not, write to the Free

   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

/* Logical line numbers can be controlled by the compiler via the

   following directives:

        .file FILENO "file.c"

        .loc  FILENO LINENO [COLUMN] [basic_block] [prologue_end] \

              [epilogue_begin] [is_stmt VALUE] [isa VALUE] \

              [discriminator VALUE]

*/

#include "as.h"

#include "safe-ctype.h"

#ifdef HAVE_LIMITS_H

#include <limits.h>

#else

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif

#ifndef INT_MAX

#define INT_MAX (int) (((unsigned) (-1)) >> 1)

#endif

#endif

#include "dwarf2dbg.h"

#include <filenames.h>

#ifdef HAVE_DOS_BASED_FILE_SYSTEM

/* We need to decide which character to use as a directory separator.

   Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not

   necessarily mean that the backslash character is the one to use.

   Some environments, eg Cygwin, can support both naming conventions.

   So we use the heuristic that we only need to use the backslash if

   the path is an absolute path starting with a DOS style drive

   selector.  eg C: or D:  */

# define INSERT_DIR_SEPARATOR(string, offset) \

  do \

    { \

      if (offset > 1 \

          && string[0] != 0 \

          && string[1] == ':') \

       string [offset] = '\\'; \

      else \

       string [offset] = '/'; \

    } \

  while (0)

#else

# define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'

#endif

#ifndef DWARF2_FORMAT

# define DWARF2_FORMAT(SEC) dwarf2_format_32bit

#endif

#ifndef DWARF2_ADDR_SIZE

# define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)

#endif

#ifndef DWARF2_FILE_NAME

#define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME

#endif

#ifndef DWARF2_FILE_TIME_NAME

#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0

#endif

#ifndef DWARF2_FILE_SIZE_NAME

#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0

#endif

#ifndef DWARF2_VERSION

#define DWARF2_VERSION 2

#endif

#include "subsegs.h"

#include "dwarf2.h"

/* Since we can't generate the prolog until the body is complete, we

   use three different subsegments for .debug_line: one holding the

   prolog, one for the directory and filename info, and one for the

   body ("statement program").  */

#define DL_PROLOG       0

#define DL_FILES        1

#define DL_BODY         2

/* If linker relaxation might change offsets in the code, the DWARF special

   opcodes and variable-length operands cannot be used.  If this macro is

   nonzero, use the DW_LNS_fixed_advance_pc opcode instead.  */

#ifndef DWARF2_USE_FIXED_ADVANCE_PC

# define DWARF2_USE_FIXED_ADVANCE_PC    0

#endif

/* First special line opcde - leave room for the standard opcodes.

   Note: If you want to change this, you'll have to update the

   "standard_opcode_lengths" table that is emitted below in

   out_debug_line().  */

#define DWARF2_LINE_OPCODE_BASE         13

#ifndef DWARF2_LINE_BASE

  /* Minimum line offset in a special line info. opcode.  This value

     was chosen to give a reasonable range of values.  */

# define DWARF2_LINE_BASE               -5

#endif

/* Range of line offsets in a special line info. opcode.  */

#ifndef DWARF2_LINE_RANGE

# define DWARF2_LINE_RANGE              14

#endif

#ifndef DWARF2_LINE_MIN_INSN_LENGTH

  /* Define the architecture-dependent minimum instruction length (in

     bytes).  This value should be rather too small than too big.  */

# define DWARF2_LINE_MIN_INSN_LENGTH    1

#endif

/* Flag that indicates the initial value of the is_stmt_start flag.  */

#define DWARF2_LINE_DEFAULT_IS_STMT     1

/* Given a special op, return the line skip amount.  */

#define SPECIAL_LINE(op) \

        (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)

/* Given a special op, return the address skip amount (in units of

   DWARF2_LINE_MIN_INSN_LENGTH.  */

#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)

/* The maximum address skip amount that can be encoded with a special op.  */

#define MAX_SPECIAL_ADDR_DELTA          SPECIAL_ADDR(255)

struct line_entry {

  struct line_entry *next;

  symbolS *label;

  struct dwarf2_line_info loc;

};

struct line_subseg {

  struct line_subseg *next;

  subsegT subseg;

  struct line_entry *head;

  struct line_entry **ptail;

};

struct line_seg {

  struct line_seg *next;

  segT seg;

  struct line_subseg *head;

  symbolS *text_start;

  symbolS *text_end;

};

/* Collects data for all line table entries during assembly.  */

static struct line_seg *all_segs;

/* Hash used to quickly lookup a segment by name, avoiding the need to search

   through the all_segs list.  */

static struct hash_control *all_segs_hash;

static struct line_seg **last_seg_ptr;

struct file_entry {

  const char *filename;

  unsigned int dir;

};

/* Table of files used by .debug_line.  */

static struct file_entry *files;

static unsigned int files_in_use;

static unsigned int files_allocated;

/* Table of directories used by .debug_line.  */

static char **dirs;

static unsigned int dirs_in_use;

static unsigned int dirs_allocated;

/* TRUE when we've seen a .loc directive recently.  Used to avoid

   doing work when there's nothing to do.  */

bfd_boolean dwarf2_loc_directive_seen;

/* TRUE when we're supposed to set the basic block mark whenever a

   label is seen.  */

bfd_boolean dwarf2_loc_mark_labels;

/* Current location as indicated by the most recent .loc directive.  */

static struct dwarf2_line_info current = {

  1, 1, 0, 0,

  DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,

};

/* Lines that are at the same location as CURRENT, and which are waiting

   for a label.  */

static struct line_entry *pending_lines, **pending_lines_tail = &pending_lines;

/* The size of an address on the target.  */

static unsigned int sizeof_address;

static unsigned int get_filenum (const char *, unsigned int);

#ifndef TC_DWARF2_EMIT_OFFSET

#define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset

/* Create an offset to .dwarf2_*.  */

static void

generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)

{

  expressionS exp;

  exp.X_op = O_symbol;

  exp.X_add_symbol = symbol;

  exp.X_add_number = 0;

  emit_expr (&exp, size);

}

#endif

/* Find or create an entry for SEG+SUBSEG in ALL_SEGS.  */

static struct line_subseg *

get_line_subseg (segT seg, subsegT subseg)

{

  static segT last_seg;

  static subsegT last_subseg;

  static struct line_subseg *last_line_subseg;

  struct line_seg *s;

  struct line_subseg **pss, *lss;

  if (seg == last_seg && subseg == last_subseg)

    return last_line_subseg;

  s = (struct line_seg *) hash_find (all_segs_hash, seg->name);

  if (s == NULL)

    {

      s = (struct line_seg *) xmalloc (sizeof (*s));

      s->next = NULL;

      s->seg = seg;

      s->head = NULL;

      *last_seg_ptr = s;

      last_seg_ptr = &s->next;

      hash_insert (all_segs_hash, seg->name, s);

    }

  gas_assert (seg == s->seg);

  for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)

    {

      if (lss->subseg == subseg)

        goto found_subseg;

      if (lss->subseg > subseg)

        break;

    }

  lss = (struct line_subseg *) xmalloc (sizeof (*lss));

  lss->next = *pss;

  lss->subseg = subseg;

  lss->head = NULL;

  lss->ptail = &lss->head;

  *pss = lss;

 found_subseg:

  last_seg = seg;

  last_subseg = subseg;

  last_line_subseg = lss;

  return lss;

}

/* Push LOC onto the pending lines list.  */

static void

dwarf2_push_line (struct dwarf2_line_info *loc)

{

  struct line_entry *e;

  e = (struct line_entry *) xmalloc (sizeof (*e));

  e->next = NULL;

  e->label = NULL;

  e->loc = *loc;

  *pending_lines_tail = e;

  pending_lines_tail = &(*pending_lines_tail)->next;

}

/* Emit all pending line information.  LABEL is the label with which the

   lines should be associated, or null if they should be associated with

   the current position.  */

static void

dwarf2_flush_pending_lines (symbolS *label)

{

  if (pending_lines)

    {

      struct line_subseg *lss;

      struct line_entry *e;

      if (!label)

        label = symbol_temp_new_now ();

      for (e = pending_lines; e; e = e->next)

        e->label = label;

      lss = get_line_subseg (now_seg, now_subseg);

      *lss->ptail = pending_lines;

      lss->ptail = pending_lines_tail;

      pending_lines = NULL;

      pending_lines_tail = &pending_lines;

    }

}

/* Record an entry for LOC occurring at OFS within the current fragment.  */

void

dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)

{

  static unsigned int line = -1;

  static unsigned int filenum = -1;

  /* Early out for as-yet incomplete location information.  */

  if (loc->filenum == 0 || loc->line == 0)

    return;

  /* Don't emit sequences of line symbols for the same line when the

     symbols apply to assembler code.  It is necessary to emit

     duplicate line symbols when a compiler asks for them, because GDB

     uses them to determine the end of the prologue.  */

  if (debug_type == DEBUG_DWARF2

      && line == loc->line && filenum == loc->filenum)

    return;

  line = loc->line;

  filenum = loc->filenum;

  dwarf2_push_line (loc);

  dwarf2_flush_pending_lines (symbol_temp_new (now_seg, ofs, frag_now));

}

/* Returns the current source information.  If .file directives have

   been encountered, the info for the corresponding source file is

   returned.  Otherwise, the info for the assembly source file is

   returned.  */

void

dwarf2_where (struct dwarf2_line_info *line)

{

  if (debug_type == DEBUG_DWARF2)

    {

      char *filename;

      as_where (&filename, &line->line);

      line->filenum = get_filenum (filename, 0);

      line->column = 0;

      line->flags = DWARF2_FLAG_IS_STMT;

      line->isa = current.isa;

      line->discriminator = current.discriminator;

    }

  else

    *line = current;

}

/* A hook to allow the target backend to inform the line number state

   machine of isa changes when assembler debug info is enabled.  */

void

dwarf2_set_isa (unsigned int isa)

{

  current.isa = isa;

}

/* Called for each machine instruction, or relatively atomic group of

   machine instructions (ie built-in macro).  The instruction or group

   is SIZE bytes in length.  If dwarf2 line number generation is called

   for, emit a line statement appropriately.  */

void

dwarf2_emit_insn (int size)

{

  struct dwarf2_line_info loc;

  if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)

    return;

  dwarf2_where (&loc);

  dwarf2_gen_line_info (frag_now_fix () - size, &loc);

  dwarf2_consume_line_info ();

}

/* Called after the current line information has been either used with

   dwarf2_gen_line_info or saved with a machine instruction for later use.

   This resets the state of the line number information to reflect that

   it has been used.  */

void

dwarf2_consume_line_info (void)

{

  /* If the consumer has stashed the current location away for later use,

     assume that any earlier location information should be associated

     with ".".  */

  dwarf2_flush_pending_lines (NULL);

  /* Unless we generate DWARF2 debugging information for each

     assembler line, we only emit one line symbol for one LOC.  */

  dwarf2_loc_directive_seen = FALSE;

  current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK

                     | DWARF2_FLAG_PROLOGUE_END

                     | DWARF2_FLAG_EPILOGUE_BEGIN);

  current.discriminator = 0;

}

/* Called for each (preferably code) label.  If dwarf2_loc_mark_labels

   is enabled, emit a basic block marker.  */

void

dwarf2_emit_label (symbolS *label)

{

  struct dwarf2_line_info loc;

  if (!dwarf2_loc_mark_labels)

    return;

  if (S_GET_SEGMENT (label) != now_seg)

    return;

  if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))

    return;

  if (files_in_use == 0 && debug_type != DEBUG_DWARF2)

    return;

  dwarf2_where (&loc);

  loc.flags |= DWARF2_FLAG_BASIC_BLOCK;

  dwarf2_push_line (&loc);

  dwarf2_flush_pending_lines (label);

  dwarf2_consume_line_info ();

}

/* Get a .debug_line file number for FILENAME.  If NUM is nonzero,

   allocate it on that file table slot, otherwise return the first

   empty one.  */

static unsigned int

get_filenum (const char *filename, unsigned int num)

{

  static unsigned int last_used, last_used_dir_len;

  const char *file;

  size_t dir_len;

  unsigned int i, dir;

  if (num == 0 && last_used)

    {

      if (! files[last_used].dir

          && filename_cmp (filename, files[last_used].filename) == 0)

        return last_used;

      if (files[last_used].dir

          && filename_ncmp (filename, dirs[files[last_used].dir],

                            last_used_dir_len) == 0

          && IS_DIR_SEPARATOR (filename [last_used_dir_len])

          && filename_cmp (filename + last_used_dir_len + 1,

                           files[last_used].filename) == 0)

        return last_used;

    }

  file = lbasename (filename);

  /* Don't make empty string from / or A: from A:/ .  */

#ifdef HAVE_DOS_BASED_FILE_SYSTEM

  if (file <= filename + 3)

    file = filename;

#else

  if (file == filename + 1)

    file = filename;

#endif

  dir_len = file - filename;

  dir = 0;

  if (dir_len)

    {

#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR

      --dir_len;

#endif

      for (dir = 1; dir < dirs_in_use; ++dir)

        if (filename_ncmp (filename, dirs[dir], dir_len) == 0

            && dirs[dir][dir_len] == '\0')

          break;

      if (dir >= dirs_in_use)

        {

          if (dir >= dirs_allocated)

            {

              dirs_allocated = dir + 32;

              dirs = (char **)

                     xrealloc (dirs, (dir + 32) * sizeof (const char *));

            }

          dirs[dir] = (char *) xmalloc (dir_len + 1);

          memcpy (dirs[dir], filename, dir_len);

          dirs[dir][dir_len] = '\0';

          dirs_in_use = dir + 1;

        }

    }

  if (num == 0)

    {

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

        if (files[i].dir == dir

            && files[i].filename

            && filename_cmp (file, files[i].filename) == 0)

          {

            last_used = i;

            last_used_dir_len = dir_len;

            return i;

          }

    }

  else

    i = num;

  if (i >= files_allocated)

    {

      unsigned int old = files_allocated;

      files_allocated = i + 32;

      files = (struct file_entry *)

        xrealloc (files, (i + 32) * sizeof (struct file_entry));

      memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));

    }

  files[i].filename = num ? file : xstrdup (file);

  files[i].dir = dir;

  if (files_in_use < i + 1)

    files_in_use = i + 1;

  last_used = i;

  last_used_dir_len = dir_len;

  return i;

}

/* Handle two forms of .file directive:

   - Pass .file "source.c" to s_app_file

   - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table

   If an entry is added to the file table, return a pointer to the filename. */

char *

dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)

{

  offsetT num;

  char *filename;

  int filename_len;

  /* Continue to accept a bare string and pass it off.  */

  SKIP_WHITESPACE ();

  if (*input_line_pointer == '"')

    {

      s_app_file (0);

      return NULL;

    }

  num = get_absolute_expression ();

  filename = demand_copy_C_string (&filename_len);

  if (filename == NULL)

    return NULL;

  demand_empty_rest_of_line ();

  if (num < 1)

    {

      as_bad (_("file number less than one"));

      return NULL;

    }

  /* A .file directive implies compiler generated debug information is

     being supplied.  Turn off gas generated debug info.  */

  debug_type = DEBUG_NONE;

  if (num < (int) files_in_use && files[num].filename != 0)

    {

      as_bad (_("file number %ld already allocated"), (long) num);

      return NULL;

    }

  get_filenum (filename, num);

  return filename;

}

void

dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)

{

  offsetT filenum, line;

  /* If we see two .loc directives in a row, force the first one to be

     output now.  */

  if (dwarf2_loc_directive_seen)

    dwarf2_push_line (&current);

  filenum = get_absolute_expression ();

  SKIP_WHITESPACE ();

  line = get_absolute_expression ();

  if (filenum < 1)

    {

      as_bad (_("file number less than one"));

      return;

    }

  if (filenum >= (int) files_in_use || files[filenum].filename == 0)

    {

      as_bad (_("unassigned file number %ld"), (long) filenum);

      return;

    }

  current.filenum = filenum;

  current.line = line;

  current.discriminator = 0;

#ifndef NO_LISTING

  if (listing)

    {

      if (files[filenum].dir)

        {

          size_t dir_len = strlen (dirs[files[filenum].dir]);

          size_t file_len = strlen (files[filenum].filename);

          char *cp = (char *) alloca (dir_len + 1 + file_len + 1);

          memcpy (cp, dirs[files[filenum].dir], dir_len);

          INSERT_DIR_SEPARATOR (cp, dir_len);

          memcpy (cp + dir_len + 1, files[filenum].filename, file_len);

          cp[dir_len + file_len + 1] = '\0';

          listing_source_file (cp);

        }

      else

        listing_source_file (files[filenum].filename);

      listing_source_line (line);

    }

#endif

  SKIP_WHITESPACE ();

  if (ISDIGIT (*input_line_pointer))

    {

      current.column = get_absolute_expression ();

      SKIP_WHITESPACE ();

    }

  while (ISALPHA (*input_line_pointer))

    {

      char *p, c;

      offsetT value;

      p = input_line_pointer;

      c = get_symbol_end ();

      if (strcmp (p, "basic_block") == 0)

        {

          current.flags |= DWARF2_FLAG_BASIC_BLOCK;

          *input_line_pointer = c;

        }

      else if (strcmp (p, "prologue_end") == 0)

        {

          current.flags |= DWARF2_FLAG_PROLOGUE_END;

          *input_line_pointer = c;

        }

      else if (strcmp (p, "epilogue_begin") == 0)

        {

          current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;

          *input_line_pointer = c;

        }

      else if (strcmp (p, "is_stmt") == 0)

        {

          *input_line_pointer = c;

          value = get_absolute_expression ();

          if (value == 0)

            current.flags &= ~DWARF2_FLAG_IS_STMT;

          else if (value == 1)

            current.flags |= DWARF2_FLAG_IS_STMT;

          else

            {

              as_bad (_("is_stmt value not 0 or 1"));

              return;

            }

        }

      else if (strcmp (p, "isa") == 0)

        {

          *input_line_pointer = c;

          value = get_absolute_expression ();

          if (value >= 0)

            current.isa = value;

          else

            {

              as_bad (_("isa number less than zero"));

              return;

            }