Subversion Repositories or1k

/* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.

   Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001

   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., 59 Temple Place - Suite 330,

   Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "frame.h"

#include "inferior.h"

#include "symtab.h"

#include "value.h"

#include "gdbcmd.h"

#include "gdbcore.h"

#include "dis-asm.h"

#include "symfile.h"

#include "objfiles.h"

#include "gdb_string.h"

#include "linespec.h"

#include "regcache.h"

/* FIXME: Some of this code should perhaps be merged with mips-tdep.c.  */

/* Prototypes for local functions. */

static alpha_extra_func_info_t push_sigtramp_desc (CORE_ADDR low_addr);

static CORE_ADDR read_next_frame_reg (struct frame_info *, int);

static CORE_ADDR heuristic_proc_start (CORE_ADDR);

static alpha_extra_func_info_t heuristic_proc_desc (CORE_ADDR,

                                                    CORE_ADDR,

                                                    struct frame_info *);

static alpha_extra_func_info_t find_proc_desc (CORE_ADDR,

                                               struct frame_info *);

#if 0

static int alpha_in_lenient_prologue (CORE_ADDR, CORE_ADDR);

#endif

static void reinit_frame_cache_sfunc (char *, int, struct cmd_list_element *);

static CORE_ADDR after_prologue (CORE_ADDR pc,

                                 alpha_extra_func_info_t proc_desc);

static int alpha_in_prologue (CORE_ADDR pc,

                              alpha_extra_func_info_t proc_desc);

static int alpha_about_to_return (CORE_ADDR pc);

void _initialize_alpha_tdep (void);

/* Heuristic_proc_start may hunt through the text section for a long

   time across a 2400 baud serial line.  Allows the user to limit this

   search.  */

static unsigned int heuristic_fence_post = 0;

/* *INDENT-OFF* */

/* Layout of a stack frame on the alpha:

                |                               |

 pdr members:   |  7th ... nth arg,             |

                |  `pushed' by caller.          |

                |                               |

----------------|-------------------------------|<--  old_sp == vfp

   ^  ^  ^  ^   |                               |

   |  |  |  |   |                               |

   |  |localoff |  Copies of 1st .. 6th         |

   |  |  |  |   |  argument if necessary.       |

   |  |  |  v   |                               |

   |  |  |  --- |-------------------------------|<-- FRAME_LOCALS_ADDRESS

   |  |  |      |                               |

   |  |  |      |  Locals and temporaries.      |

   |  |  |      |                               |

   |  |  |      |-------------------------------|

   |  |  |      |                               |

   |-fregoffset |  Saved float registers.       |

   |  |  |      |  F9                           |

   |  |  |      |   .                           |

   |  |  |      |   .                           |

   |  |  |      |  F2                           |

   |  |  v      |                               |

   |  |  -------|-------------------------------|

   |  |         |                               |

   |  |         |  Saved registers.             |

   |  |         |  S6                           |

   |-regoffset  |   .                           |

   |  |         |   .                           |

   |  |         |  S0                           |

   |  |         |  pdr.pcreg                    |

   |  v         |                               |

   |  ----------|-------------------------------|

   |            |                               |

 frameoffset    |  Argument build area, gets    |

   |            |  7th ... nth arg for any      |

   |            |  called procedure.            |

   v            |                               |

   -------------|-------------------------------|<-- sp

                |                               |

*/

/* *INDENT-ON* */

#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)   /* least address */

/* These next two fields are kind of being hijacked.  I wonder if

   iline is too small for the values it needs to hold, if GDB is

   running on a 32-bit host.  */

#define PROC_HIGH_ADDR(proc) ((proc)->pdr.iline)        /* upper address bound */

#define PROC_DUMMY_FRAME(proc) ((proc)->pdr.cbLineOffset)       /*CALL_DUMMY frame */

#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)

#define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)

#define PROC_REG_MASK(proc) ((proc)->pdr.regmask)

#define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)

#define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)

#define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)

#define PROC_PC_REG(proc) ((proc)->pdr.pcreg)

#define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)

#define PROC_SYMBOL(proc) (*(struct symbol**)&(proc)->pdr.isym)

#define _PROC_MAGIC_ 0x0F0F0F0F

#define PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym == _PROC_MAGIC_)

#define SET_PROC_DESC_IS_DUMMY(proc) ((proc)->pdr.isym = _PROC_MAGIC_)

struct linked_proc_info

  {

    struct alpha_extra_func_info info;

    struct linked_proc_info *next;

  }

 *linked_proc_desc_table = NULL;

/* Under GNU/Linux, signal handler invocations can be identified by the

   designated code sequence that is used to return from a signal

   handler.  In particular, the return address of a signal handler

   points to the following sequence (the first instruction is quadword

   aligned):

   bis $30,$30,$16

   addq $31,0x67,$0

   call_pal callsys

   Each instruction has a unique encoding, so we simply attempt to

   match the instruction the pc is pointing to with any of the above

   instructions.  If there is a hit, we know the offset to the start

   of the designated sequence and can then check whether we really are

   executing in a designated sequence.  If not, -1 is returned,

   otherwise the offset from the start of the desingated sequence is

   returned.

   There is a slight chance of false hits: code could jump into the

   middle of the designated sequence, in which case there is no

   guarantee that we are in the middle of a sigreturn syscall.  Don't

   think this will be a problem in praxis, though.

 */

#ifndef TM_LINUXALPHA_H

/* HACK: Provide a prototype when compiling this file for non

   linuxalpha targets. */

long alpha_linux_sigtramp_offset (CORE_ADDR pc);

#endif

long

alpha_linux_sigtramp_offset (CORE_ADDR pc)

{

  unsigned int i[3], w;

  long off;

  if (read_memory_nobpt (pc, (char *) &w, 4) != 0)

    return -1;

  off = -1;

  switch (w)

    {

    case 0x47de0410:

      off = 0;

      break;                    /* bis $30,$30,$16 */

    case 0x43ecf400:

      off = 4;

      break;                    /* addq $31,0x67,$0 */

    case 0x00000083:

      off = 8;

      break;                    /* call_pal callsys */

    default:

      return -1;

    }

  pc -= off;

  if (pc & 0x7)

    {

      /* designated sequence is not quadword aligned */

      return -1;

    }

  if (read_memory_nobpt (pc, (char *) i, sizeof (i)) != 0)

    return -1;

  if (i[0] == 0x47de0410 && i[1] == 0x43ecf400 && i[2] == 0x00000083)

    return off;

  return -1;

}

/* Under OSF/1, the __sigtramp routine is frameless and has a frame

   size of zero, but we are able to backtrace through it.  */

CORE_ADDR

alpha_osf_skip_sigtramp_frame (struct frame_info *frame, CORE_ADDR pc)

{

  char *name;

  find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);

  if (IN_SIGTRAMP (pc, name))

    return frame->frame;

  else

    return 0;

}

/* Dynamically create a signal-handler caller procedure descriptor for

   the signal-handler return code starting at address LOW_ADDR.  The

   descriptor is added to the linked_proc_desc_table.  */

static alpha_extra_func_info_t

push_sigtramp_desc (CORE_ADDR low_addr)

{

  struct linked_proc_info *link;

  alpha_extra_func_info_t proc_desc;

  link = (struct linked_proc_info *)

    xmalloc (sizeof (struct linked_proc_info));

  link->next = linked_proc_desc_table;

  linked_proc_desc_table = link;

  proc_desc = &link->info;

  proc_desc->numargs = 0;

  PROC_LOW_ADDR (proc_desc) = low_addr;

  PROC_HIGH_ADDR (proc_desc) = low_addr + 3 * 4;

  PROC_DUMMY_FRAME (proc_desc) = 0;

  PROC_FRAME_OFFSET (proc_desc) = 0x298;        /* sizeof(struct sigcontext_struct) */

  PROC_FRAME_REG (proc_desc) = SP_REGNUM;

  PROC_REG_MASK (proc_desc) = 0xffff;

  PROC_FREG_MASK (proc_desc) = 0xffff;

  PROC_PC_REG (proc_desc) = 26;

  PROC_LOCALOFF (proc_desc) = 0;

  SET_PROC_DESC_IS_DYN_SIGTRAMP (proc_desc);

  return (proc_desc);

}

/* Guaranteed to set frame->saved_regs to some values (it never leaves it

   NULL).  */

void

alpha_find_saved_regs (struct frame_info *frame)

{

  int ireg;

  CORE_ADDR reg_position;

  unsigned long mask;

  alpha_extra_func_info_t proc_desc;

  int returnreg;

  frame_saved_regs_zalloc (frame);

  /* If it is the frame for __sigtramp, the saved registers are located

     in a sigcontext structure somewhere on the stack. __sigtramp

     passes a pointer to the sigcontext structure on the stack.

     If the stack layout for __sigtramp changes, or if sigcontext offsets

     change, we might have to update this code.  */

#ifndef SIGFRAME_PC_OFF

#define SIGFRAME_PC_OFF         (2 * 8)

#define SIGFRAME_REGSAVE_OFF    (4 * 8)

#define SIGFRAME_FPREGSAVE_OFF  (SIGFRAME_REGSAVE_OFF + 32 * 8 + 8)

#endif

  if (frame->signal_handler_caller)

    {

      CORE_ADDR sigcontext_addr;

      sigcontext_addr = SIGCONTEXT_ADDR (frame);

      for (ireg = 0; ireg < 32; ireg++)

        {

          reg_position = sigcontext_addr + SIGFRAME_REGSAVE_OFF + ireg * 8;

          frame->saved_regs[ireg] = reg_position;

        }

      for (ireg = 0; ireg < 32; ireg++)

        {

          reg_position = sigcontext_addr + SIGFRAME_FPREGSAVE_OFF + ireg * 8;

          frame->saved_regs[FP0_REGNUM + ireg] = reg_position;

        }

      frame->saved_regs[PC_REGNUM] = sigcontext_addr + SIGFRAME_PC_OFF;

      return;

    }

  proc_desc = frame->proc_desc;

  if (proc_desc == NULL)

    /* I'm not sure how/whether this can happen.  Normally when we can't

       find a proc_desc, we "synthesize" one using heuristic_proc_desc

       and set the saved_regs right away.  */

    return;

  /* Fill in the offsets for the registers which gen_mask says

     were saved.  */

  reg_position = frame->frame + PROC_REG_OFFSET (proc_desc);

  mask = PROC_REG_MASK (proc_desc);

  returnreg = PROC_PC_REG (proc_desc);

  /* Note that RA is always saved first, regardless of its actual

     register number.  */

  if (mask & (1 << returnreg))

    {

      frame->saved_regs[returnreg] = reg_position;

      reg_position += 8;

      mask &= ~(1 << returnreg);        /* Clear bit for RA so we

                                           don't save again later. */

    }

  for (ireg = 0; ireg <= 31; ++ireg)

    if (mask & (1 << ireg))

      {

        frame->saved_regs[ireg] = reg_position;

        reg_position += 8;

      }

  /* Fill in the offsets for the registers which float_mask says

     were saved.  */

  reg_position = frame->frame + PROC_FREG_OFFSET (proc_desc);

  mask = PROC_FREG_MASK (proc_desc);

  for (ireg = 0; ireg <= 31; ++ireg)

    if (mask & (1 << ireg))

      {

        frame->saved_regs[FP0_REGNUM + ireg] = reg_position;

        reg_position += 8;

      }

  frame->saved_regs[PC_REGNUM] = frame->saved_regs[returnreg];

}

static CORE_ADDR

read_next_frame_reg (struct frame_info *fi, int regno)

{

  for (; fi; fi = fi->next)

    {

      /* We have to get the saved sp from the sigcontext

         if it is a signal handler frame.  */

      if (regno == SP_REGNUM && !fi->signal_handler_caller)

        return fi->frame;

      else

        {

          if (fi->saved_regs == NULL)

            alpha_find_saved_regs (fi);

          if (fi->saved_regs[regno])

            return read_memory_integer (fi->saved_regs[regno], 8);

        }

    }

  return read_register (regno);

}

CORE_ADDR

alpha_frame_saved_pc (struct frame_info *frame)

{

  alpha_extra_func_info_t proc_desc = frame->proc_desc;

  /* We have to get the saved pc from the sigcontext

     if it is a signal handler frame.  */

  int pcreg = frame->signal_handler_caller ? PC_REGNUM : frame->pc_reg;

  if (proc_desc && PROC_DESC_IS_DUMMY (proc_desc))

    return read_memory_integer (frame->frame - 8, 8);

  return read_next_frame_reg (frame, pcreg);

}

CORE_ADDR

alpha_saved_pc_after_call (struct frame_info *frame)

{

  CORE_ADDR pc = frame->pc;

  CORE_ADDR tmp;

  alpha_extra_func_info_t proc_desc;

  int pcreg;

  /* Skip over shared library trampoline if necessary.  */

  tmp = SKIP_TRAMPOLINE_CODE (pc);

  if (tmp != 0)

    pc = tmp;

  proc_desc = find_proc_desc (pc, frame->next);

  pcreg = proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM;

  if (frame->signal_handler_caller)

    return alpha_frame_saved_pc (frame);

  else

    return read_register (pcreg);

}

static struct alpha_extra_func_info temp_proc_desc;

static struct frame_saved_regs temp_saved_regs;

/* Nonzero if instruction at PC is a return instruction.  "ret

   $zero,($ra),1" on alpha. */

static int

alpha_about_to_return (CORE_ADDR pc)

{

  return read_memory_integer (pc, 4) == 0x6bfa8001;

}

/* This fencepost looks highly suspicious to me.  Removing it also

   seems suspicious as it could affect remote debugging across serial

   lines.  */

static CORE_ADDR

heuristic_proc_start (CORE_ADDR pc)

{

  CORE_ADDR start_pc = pc;

  CORE_ADDR fence = start_pc - heuristic_fence_post;

  if (start_pc == 0)

    return 0;

  if (heuristic_fence_post == UINT_MAX

      || fence < VM_MIN_ADDRESS)

    fence = VM_MIN_ADDRESS;

  /* search back for previous return */

  for (start_pc -= 4;; start_pc -= 4)

    if (start_pc < fence)

      {

        /* It's not clear to me why we reach this point when

           stop_soon_quietly, but with this test, at least we

           don't print out warnings for every child forked (eg, on

           decstation).  22apr93 rich@cygnus.com.  */

        if (!stop_soon_quietly)

          {

            static int blurb_printed = 0;

            if (fence == VM_MIN_ADDRESS)

              warning ("Hit beginning of text section without finding");

            else

              warning ("Hit heuristic-fence-post without finding");

            warning ("enclosing function for address 0x%s", paddr_nz (pc));

            if (!blurb_printed)

              {

                printf_filtered ("\

This warning occurs if you are debugging a function without any symbols\n\

(for example, in a stripped executable).  In that case, you may wish to\n\

increase the size of the search with the `set heuristic-fence-post' command.\n\

\n\

Otherwise, you told GDB there was a function where there isn't one, or\n\

(more likely) you have encountered a bug in GDB.\n");

                blurb_printed = 1;

              }

          }

        return 0;

      }

    else if (alpha_about_to_return (start_pc))

      break;

  start_pc += 4;                /* skip return */

  return start_pc;

}

static alpha_extra_func_info_t

heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,

                     struct frame_info *next_frame)

{

  CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);

  CORE_ADDR cur_pc;

  int frame_size;

  int has_frame_reg = 0;

  unsigned long reg_mask = 0;

  int pcreg = -1;

  if (start_pc == 0)

    return NULL;

  memset (&temp_proc_desc, '\0', sizeof (temp_proc_desc));

  memset (&temp_saved_regs, '\0', sizeof (struct frame_saved_regs));

  PROC_LOW_ADDR (&temp_proc_desc) = start_pc;

  if (start_pc + 200 < limit_pc)

    limit_pc = start_pc + 200;

  frame_size = 0;

  for (cur_pc = start_pc; cur_pc < limit_pc; cur_pc += 4)

    {

      char buf[4];

      unsigned long word;

      int status;

      status = read_memory_nobpt (cur_pc, buf, 4);

      if (status)

        memory_error (status, cur_pc);

      word = extract_unsigned_integer (buf, 4);

      if ((word & 0xffff0000) == 0x23de0000)    /* lda $sp,n($sp) */

        {

          if (word & 0x8000)

            frame_size += (-word) & 0xffff;

          else

            /* Exit loop if a positive stack adjustment is found, which

               usually means that the stack cleanup code in the function

               epilogue is reached.  */

            break;

        }

      else if ((word & 0xfc1f0000) == 0xb41e0000        /* stq reg,n($sp) */

               && (word & 0xffff0000) != 0xb7fe0000)    /* reg != $zero */

        {

          int reg = (word & 0x03e00000) >> 21;

          reg_mask |= 1 << reg;

          temp_saved_regs.regs[reg] = sp + (short) word;

          /* Starting with OSF/1-3.2C, the system libraries are shipped

             without local symbols, but they still contain procedure

             descriptors without a symbol reference. GDB is currently

             unable to find these procedure descriptors and uses

             heuristic_proc_desc instead.

             As some low level compiler support routines (__div*, __add*)

             use a non-standard return address register, we have to

             add some heuristics to determine the return address register,

             or stepping over these routines will fail.

             Usually the return address register is the first register

             saved on the stack, but assembler optimization might

             rearrange the register saves.

             So we recognize only a few registers (t7, t9, ra) within

             the procedure prologue as valid return address registers.

             If we encounter a return instruction, we extract the

             the return address register from it.

             FIXME: Rewriting GDB to access the procedure descriptors,

             e.g. via the minimal symbol table, might obviate this hack.  */

          if (pcreg == -1

              && cur_pc < (start_pc + 80)

              && (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM))

            pcreg = reg;

        }

      else if ((word & 0xffe0ffff) == 0x6be08001)       /* ret zero,reg,1 */

        pcreg = (word >> 16) & 0x1f;

      else if (word == 0x47de040f)      /* bis sp,sp fp */

        has_frame_reg = 1;

    }

  if (pcreg == -1)

    {

      /* If we haven't found a valid return address register yet,

         keep searching in the procedure prologue.  */

      while (cur_pc < (limit_pc + 80) && cur_pc < (start_pc + 80))

        {

          char buf[4];

          unsigned long word;

          if (read_memory_nobpt (cur_pc, buf, 4))

            break;

          cur_pc += 4;

          word = extract_unsigned_integer (buf, 4);

          if ((word & 0xfc1f0000) == 0xb41e0000         /* stq reg,n($sp) */

              && (word & 0xffff0000) != 0xb7fe0000)     /* reg != $zero */

            {

              int reg = (word & 0x03e00000) >> 21;

              if (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM)

                {

                  pcreg = reg;

                  break;

                }

            }

          else if ((word & 0xffe0ffff) == 0x6be08001)   /* ret zero,reg,1 */

            {

              pcreg = (word >> 16) & 0x1f;

              break;

            }

        }

    }

  if (has_frame_reg)

    PROC_FRAME_REG (&temp_proc_desc) = GCC_FP_REGNUM;

  else

    PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;

  PROC_FRAME_OFFSET (&temp_proc_desc) = frame_size;

  PROC_REG_MASK (&temp_proc_desc) = reg_mask;

  PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? RA_REGNUM : pcreg;

  PROC_LOCALOFF (&temp_proc_desc) = 0;   /* XXX - bogus */

  return &temp_proc_desc;

}

/* This returns the PC of the first inst after the prologue.  If we can't

   find the prologue, then return 0.  */

static CORE_ADDR

after_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc)

{

  struct symtab_and_line sal;

  CORE_ADDR func_addr, func_end;

  if (!proc_desc)

    proc_desc = find_proc_desc (pc, NULL);

  if (proc_desc)

    {

      if (PROC_DESC_IS_DYN_SIGTRAMP (proc_desc))

        return PROC_LOW_ADDR (proc_desc);       /* "prologue" is in kernel */

      /* If function is frameless, then we need to do it the hard way.  I

         strongly suspect that frameless always means prologueless... */

      if (PROC_FRAME_REG (proc_desc) == SP_REGNUM

          && PROC_FRAME_OFFSET (proc_desc) == 0)

        return 0;

    }

  if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))

    return 0;                    /* Unknown */

  sal = find_pc_line (func_addr, 0);

  if (sal.end < func_end)

    return sal.end;

  /* The line after the prologue is after the end of the function.  In this

     case, tell the caller to find the prologue the hard way.  */

  return 0;

}

/* Return non-zero if we *might* be in a function prologue.  Return zero if we

   are definitively *not* in a function prologue.  */

static int

alpha_in_prologue (CORE_ADDR pc, alpha_extra_func_info_t proc_desc)

{

  CORE_ADDR after_prologue_pc;

  after_prologue_pc = after_prologue (pc, proc_desc);

  if (after_prologue_pc == 0

      || pc < after_prologue_pc)

    return 1;

  else

    return 0;

}

static alpha_extra_func_info_t

find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame)

{

  alpha_extra_func_info_t proc_desc;

  struct block *b;

  struct symbol *sym;

  CORE_ADDR startaddr;

  /* Try to get the proc_desc from the linked call dummy proc_descs

     if the pc is in the call dummy.

     This is hairy. In the case of nested dummy calls we have to find the

     right proc_desc, but we might not yet know the frame for the dummy

     as it will be contained in the proc_desc we are searching for.

     So we have to find the proc_desc whose frame is closest to the current

     stack pointer.  */

  if (PC_IN_CALL_DUMMY (pc, 0, 0))

    {

      struct linked_proc_info *link;

      CORE_ADDR sp = read_next_frame_reg (next_frame, SP_REGNUM);

      alpha_extra_func_info_t found_proc_desc = NULL;

      long min_distance = LONG_MAX;

      for (link = linked_proc_desc_table; link; link = link->next)

        {

          long distance = (CORE_ADDR) PROC_DUMMY_FRAME (&link->info) - sp;

          if (distance > 0 && distance < min_distance)

            {

              min_distance = distance;

              found_proc_desc = &link->info;

            }

        }

      if (found_proc_desc != NULL)

        return found_proc_desc;

    }

  b = block_for_pc (pc);

  find_pc_partial_function (pc, NULL, &startaddr, NULL);

  if (b == NULL)

    sym = NULL;

  else

    {

      if (startaddr > BLOCK_START (b))

        /* This is the "pathological" case referred to in a comment in

           print_frame_info.  It might be better to move this check into

           symbol reading.  */

        sym = NULL;

      else

        sym = lookup_symbol (MIPS_EFI_SYMBOL_NAME, b, LABEL_NAMESPACE,

                             0, NULL);

    }

  /* If we never found a PDR for this function in symbol reading, then

     examine prologues to find the information.  */

  if (sym && ((mips_extra_func_info_t) SYMBOL_VALUE (sym))->pdr.framereg == -1)

    sym = NULL;

  if (sym)

    {