gdb/alpha-mdebug-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Target-dependent mdebug code for the ALPHA architecture.
  2.    Copyright (C) 1993-2015 Free Software Foundation, Inc.

  4.    This file is part of GDB.

  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 3 of the License, or
  9.    (at your option) any later version.

  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.

  16.    You should have received a copy of the GNU General Public License
  17.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  19. #include "defs.h"
  20. #include "frame.h"
  21. #include "frame-unwind.h"
  22. #include "frame-base.h"
  23. #include "symtab.h"
  24. #include "gdbcore.h"
  25. #include "block.h"
  26. #include "trad-frame.h"

  28. #include "alpha-tdep.h"
  29. #include "mdebugread.h"

  31. /* FIXME: Some of this code should perhaps be merged with mips.  */

  33. /* *INDENT-OFF* */
  34. /* Layout of a stack frame on the alpha:

  36.                 |                                |
  37. pdr members:        |  7th ... nth arg,                |
  38.                 |  `pushed' by caller.                |
  39.                 |                                |
  40. ----------------|-------------------------------|<--  old_sp == vfp
  41.    ^  ^  ^  ^        |                                |
  42.    |  |  |  |        |                                |
  43.    |  |localoff        |  Copies of 1st .. 6th                |
  44.    |  |  |  |        |  argument if necessary.        |
  45.    |  |  |  v        |                                |
  46.    |  |  |  ---        |-------------------------------|<-- LOCALS_ADDRESS
  47.    |  |  |      |                                |
  48.    |  |  |      |  Locals and temporaries.        |
  49.    |  |  |      |                                |
  50.    |  |  |      |-------------------------------|
  51.    |  |  |      |                                |
  52.    |-fregoffset        |  Saved float registers.        |
  53.    |  |  |      |  F9                                |
  54.    |  |  |      |   .                                |
  55.    |  |  |      |   .                                |
  56.    |  |  |      |  F2                                |
  57.    |  |  v      |                                |
  58.    |  |  -------|-------------------------------|
  59.    |  |         |                                |
  60.    |  |         |  Saved registers.                |
  61.    |  |         |  S6                                |
  62.    |-regoffset        |   .                                |
  63.    |  |         |   .                                |
  64.    |  |         |  S0                                |
  65.    |  |         |  pdr.pcreg                        |
  66.    |  v         |                                |
  67.    |  ----------|-------------------------------|
  68.    |            |                                |
  69. frameoffset    |  Argument build area, gets        |
  70.    |            |  7th ... nth arg for any        |
  71.    |            |  called procedure.                |
  72.    v            |                                  |
  73.    -------------|-------------------------------|<-- sp
  74.                 |                                |
  75. */
  76. /* *INDENT-ON* */

  78. ‌#define PROC_LOW_ADDR(proc) ((proc)->pdr.adr)
  79. ‌#define PROC_FRAME_OFFSET(proc) ((proc)->pdr.frameoffset)
  80. ‌#define PROC_FRAME_REG(proc) ((proc)->pdr.framereg)
  81. ‌#define PROC_REG_MASK(proc) ((proc)->pdr.regmask)
  82. ‌#define PROC_FREG_MASK(proc) ((proc)->pdr.fregmask)
  83. ‌#define PROC_REG_OFFSET(proc) ((proc)->pdr.regoffset)
  84. ‌#define PROC_FREG_OFFSET(proc) ((proc)->pdr.fregoffset)
  85. ‌#define PROC_PC_REG(proc) ((proc)->pdr.pcreg)
  86. ‌#define PROC_LOCALOFF(proc) ((proc)->pdr.localoff)

  88. /* Locate the mdebug PDR for the given PC.  Return null if one can't
  89.    be found; you'll have to fall back to other methods in that case.  */

  91. static struct mdebug_extra_func_info *
  92. ‌find_proc_desc (CORE_ADDR pc)
  93. {
  94.   const struct block *b = block_for_pc (pc);
  95.   struct mdebug_extra_func_info *proc_desc = NULL;
  96.   struct symbol *sym = NULL;
  97.   const char *sh_name = NULL;

  99.   if (b)
  100.     {
  101.       CORE_ADDR startaddr;
  102.       find_pc_partial_function (pc, &sh_name, &startaddr, NULL);

  104.       if (startaddr > BLOCK_START (b))
  105.         /* This is the "pathological" case referred to in a comment in
  106.            print_frame_info.  It might be better to move this check into
  107.            symbol reading.  */
  108.         sym = NULL;
  109.       else
  110.         sym = lookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, 0);
  111.     }

  113.   if (sym)
  114.     {
  115.       proc_desc = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (sym);

  117.       /* Correct incorrect setjmp procedure descriptor from the library
  118.          to make backtrace through setjmp work.  */
  119.       if (proc_desc->pdr.pcreg == 0
  120.           && strcmp (sh_name, "setjmp") == 0)
  121.         {
  122.           proc_desc->pdr.pcreg = ALPHA_RA_REGNUM;
  123.           proc_desc->pdr.regmask = 0x80000000;
  124.           proc_desc->pdr.regoffset = -4;
  125.         }

  127.       /* If we never found a PDR for this function in symbol reading,
  128.          then examine prologues to find the information.  */
  129.       if (proc_desc->pdr.framereg == -1)
  130.         proc_desc = NULL;
  131.     }

  133.   return proc_desc;
  134. }

  136. /* Return a non-zero result if the function is frameless; zero otherwise.  */

  138. static int
  139. ‌alpha_mdebug_frameless (struct mdebug_extra_func_info *proc_desc)
  140. {
  141.   return (PROC_FRAME_REG (proc_desc) == ALPHA_SP_REGNUM
  142.           && PROC_FRAME_OFFSET (proc_desc) == 0);
  143. }

  145. /* This returns the PC of the first inst after the prologue.  If we can't
  146.    find the prologue, then return 0.  */

  148. static CORE_ADDR
  149. ‌alpha_mdebug_after_prologue (CORE_ADDR pc,
  150.                              struct mdebug_extra_func_info *proc_desc)
  151. {
  152.   if (proc_desc)
  153.     {
  154.       /* If function is frameless, then we need to do it the hard way.  I
  155.          strongly suspect that frameless always means prologueless...  */
  156.       if (alpha_mdebug_frameless (proc_desc))
  157.         return 0;
  158.     }

  160.   return alpha_after_prologue (pc);
  161. }

  163. /* Return non-zero if we *might* be in a function prologue.  Return zero
  164.    if we are definitively *not* in a function prologue.  */

  166. static int
  167. ‌alpha_mdebug_in_prologue (CORE_ADDR pc,
  168.                           struct mdebug_extra_func_info *proc_desc)
  169. {
  170.   CORE_ADDR after_prologue_pc = alpha_mdebug_after_prologue (pc, proc_desc);
  171.   return (after_prologue_pc == 0 || pc < after_prologue_pc);
  172. }


  175. /* Frame unwinder that reads mdebug PDRs.  */

  177. ‌struct alpha_mdebug_unwind_cache
  178. {
  179.   struct mdebug_extra_func_info *proc_desc;
  180.   CORE_ADDR vfp;
  181.   struct trad_frame_saved_reg *saved_regs;
  182. };

  184. /* Extract all of the information about the frame from PROC_DESC
  185.    and store the resulting register save locations in the structure.  */

  187. static struct alpha_mdebug_unwind_cache *
  188. ‌alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame,
  189.                                  void **this_prologue_cache)
  190. {
  191.   struct alpha_mdebug_unwind_cache *info;
  192.   struct mdebug_extra_func_info *proc_desc;
  193.   ULONGEST vfp;
  194.   CORE_ADDR pc, reg_position;
  195.   unsigned long mask;
  196.   int ireg, returnreg;

  198.   if (*this_prologue_cache)
  199.     return *this_prologue_cache;

  201.   info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
  202.   *this_prologue_cache = info;
  203.   pc = get_frame_address_in_block (this_frame);

  205.   /* ??? We don't seem to be able to cache the lookup of the PDR
  206.      from alpha_mdebug_frame_p.  It'd be nice if we could change
  207.      the arguments to that function.  Oh well.  */
  208.   proc_desc = find_proc_desc (pc);
  209.   info->proc_desc = proc_desc;
  210.   gdb_assert (proc_desc != NULL);

  212.   info->saved_regs = trad_frame_alloc_saved_regs (this_frame);

  214.   /* The VFP of the frame is at FRAME_REG+FRAME_OFFSET.  */
  215.   vfp = get_frame_register_unsigned (this_frame, PROC_FRAME_REG (proc_desc));
  216.   vfp += PROC_FRAME_OFFSET (info->proc_desc);
  217.   info->vfp = vfp;

  219.   /* Fill in the offsets for the registers which gen_mask says were saved.  */

  221.   reg_position = vfp + PROC_REG_OFFSET (proc_desc);
  222.   mask = PROC_REG_MASK (proc_desc);
  223.   returnreg = PROC_PC_REG (proc_desc);

  225.   /* Note that RA is always saved first, regardless of its actual
  226.      register number.  */
  227.   if (mask & (1 << returnreg))
  228.     {
  229.       /* Clear bit for RA so we don't save it again later.  */
  230.       mask &= ~(1 << returnreg);

  232.       info->saved_regs[returnreg].addr = reg_position;
  233.       reg_position += 8;
  234.     }

  236.   for (ireg = 0; ireg <= 31; ++ireg)
  237.     if (mask & (1 << ireg))
  238.       {
  239.         info->saved_regs[ireg].addr = reg_position;
  240.         reg_position += 8;
  241.       }

  243.   reg_position = vfp + PROC_FREG_OFFSET (proc_desc);
  244.   mask = PROC_FREG_MASK (proc_desc);

  246.   for (ireg = 0; ireg <= 31; ++ireg)
  247.     if (mask & (1 << ireg))
  248.       {
  249.         info->saved_regs[ALPHA_FP0_REGNUM + ireg].addr = reg_position;
  250.         reg_position += 8;
  251.       }

  253.   /* The stack pointer of the previous frame is computed by popping
  254.      the current stack frame.  */
  255.   if (!trad_frame_addr_p (info->saved_regs, ALPHA_SP_REGNUM))
  256.    trad_frame_set_value (info->saved_regs, ALPHA_SP_REGNUM, vfp);

  258.   return info;
  259. }

  261. /* Given a GDB frame, determine the address of the calling function's
  262.    frame.  This will be used to create a new GDB frame struct.  */

  264. static void
  265. ‌alpha_mdebug_frame_this_id (struct frame_info *this_frame,
  266.                             void **this_prologue_cache,
  267.                             struct frame_id *this_id)
  268. {
  269.   struct alpha_mdebug_unwind_cache *info
  270.     = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);

  272.   *this_id = frame_id_build (info->vfp, get_frame_func (this_frame));
  273. }

  275. /* Retrieve the value of REGNUM in FRAME.  Don't give up!  */

  277. static struct value *
  278. ‌alpha_mdebug_frame_prev_register (struct frame_info *this_frame,
  279.                                   void **this_prologue_cache, int regnum)
  280. {
  281.   struct alpha_mdebug_unwind_cache *info
  282.     = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);

  284.   /* The PC of the previous frame is stored in the link register of
  285.      the current frame.  Frob regnum so that we pull the value from
  286.      the correct place.  */
  287.   if (regnum == ALPHA_PC_REGNUM)
  288.     regnum = PROC_PC_REG (info->proc_desc);

  290.   return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
  291. }

  293. /* Return a non-zero result if the size of the stack frame exceeds the
  294.    maximum debuggable frame size (512 Kbytes); zero otherwise.  */

  296. static int
  297. ‌alpha_mdebug_max_frame_size_exceeded (struct mdebug_extra_func_info *proc_desc)
  298. {
  299.   /* If frame offset is null, we can be in two cases: either the
  300.      function is frameless (the stack frame is null) or its
  301.      frame exceeds the maximum debuggable frame size (512 Kbytes).  */

  303.   return (PROC_FRAME_OFFSET (proc_desc) == 0
  304.           && !alpha_mdebug_frameless (proc_desc));
  305. }

  307. static int
  308. ‌alpha_mdebug_frame_sniffer (const struct frame_unwind *self,
  309.                             struct frame_info *this_frame,
  310.                             void **this_cache)
  311. {
  312.   CORE_ADDR pc = get_frame_address_in_block (this_frame);
  313.   struct mdebug_extra_func_info *proc_desc;

  315.   /* If this PC does not map to a PDR, then clearly this isn't an
  316.      mdebug frame.  */
  317.   proc_desc = find_proc_desc (pc);
  318.   if (proc_desc == NULL)
  319.     return 0;

  321.   /* If we're in the prologue, the PDR for this frame is not yet valid.
  322.      Say no here and we'll fall back on the heuristic unwinder.  */
  323.   if (alpha_mdebug_in_prologue (pc, proc_desc))
  324.     return 0;

  326.   /* If the maximum debuggable frame size has been exceeded, the
  327.      proc desc is bogus.  Fall back on the heuristic unwinder.  */
  328.   if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
  329.     return 0;

  331.   return 1;
  332. }

  334. ‌static const struct frame_unwind alpha_mdebug_frame_unwind = {
  335.   NORMAL_FRAME,
  336.   default_frame_unwind_stop_reason,
  337.   alpha_mdebug_frame_this_id,
  338.   alpha_mdebug_frame_prev_register,
  339.   NULL,
  340.   alpha_mdebug_frame_sniffer
  341. };

  343. static CORE_ADDR
  344. ‌alpha_mdebug_frame_base_address (struct frame_info *this_frame,
  345.                                  void **this_prologue_cache)
  346. {
  347.   struct alpha_mdebug_unwind_cache *info
  348.     = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);

  350.   return info->vfp;
  351. }

  353. static CORE_ADDR
  354. ‌alpha_mdebug_frame_locals_address (struct frame_info *this_frame,
  355.                                    void **this_prologue_cache)
  356. {
  357.   struct alpha_mdebug_unwind_cache *info
  358.     = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);

  360.   return info->vfp - PROC_LOCALOFF (info->proc_desc);
  361. }

  363. static CORE_ADDR
  364. ‌alpha_mdebug_frame_args_address (struct frame_info *this_frame,
  365.                                  void **this_prologue_cache)
  366. {
  367.   struct alpha_mdebug_unwind_cache *info
  368.     = alpha_mdebug_frame_unwind_cache (this_frame, this_prologue_cache);

  370.   return info->vfp - ALPHA_NUM_ARG_REGS * 8;
  371. }

  373. ‌static const struct frame_base alpha_mdebug_frame_base = {
  374.   &alpha_mdebug_frame_unwind,
  375.   alpha_mdebug_frame_base_address,
  376.   alpha_mdebug_frame_locals_address,
  377.   alpha_mdebug_frame_args_address
  378. };

  380. static const struct frame_base *
  381. ‌alpha_mdebug_frame_base_sniffer (struct frame_info *this_frame)
  382. {
  383.   CORE_ADDR pc = get_frame_address_in_block (this_frame);
  384.   struct mdebug_extra_func_info *proc_desc;

  386.   /* If this PC does not map to a PDR, then clearly this isn't an
  387.      mdebug frame.  */
  388.   proc_desc = find_proc_desc (pc);
  389.   if (proc_desc == NULL)
  390.     return NULL;

  392.   /* If the maximum debuggable frame size has been exceeded, the
  393.      proc desc is bogus.  Fall back on the heuristic unwinder.  */
  394.   if (alpha_mdebug_max_frame_size_exceeded (proc_desc))
  395.     return 0;

  397.   return &alpha_mdebug_frame_base;
  398. }


  401. void
  402. ‌alpha_mdebug_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
  403. {
  404.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  406.   frame_unwind_append_unwinder (gdbarch, &alpha_mdebug_frame_unwind);
  407.   frame_base_append_sniffer (gdbarch, alpha_mdebug_frame_base_sniffer);
  408. }