gdb/dwarf2loc.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* DWARF 2 location expression support for GDB.

  3.    Copyright (C) 2003-2015 Free Software Foundation, Inc.

  5.    Contributed by Daniel Jacobowitz, MontaVista Software, Inc.

  7.    This file is part of GDB.

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

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

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

  22. #include "defs.h"
  23. #include "ui-out.h"
  24. #include "value.h"
  25. #include "frame.h"
  26. #include "gdbcore.h"
  27. #include "target.h"
  28. #include "inferior.h"
  29. #include "ax.h"
  30. #include "ax-gdb.h"
  31. #include "regcache.h"
  32. #include "objfiles.h"
  33. #include "block.h"
  34. #include "gdbcmd.h"

  36. #include "dwarf2.h"
  37. #include "dwarf2expr.h"
  38. #include "dwarf2loc.h"
  39. #include "dwarf2-frame.h"
  40. #include "compile/compile.h"

  42. extern int dwarf2_always_disassemble;

  44. ‌static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs;

  46. static struct value *dwarf2_evaluate_loc_desc_full (struct type *type,
  47.                                                     struct frame_info *frame,
  48.                                                     const gdb_byte *data,
  49.                                                     size_t size,
  50.                                                     struct dwarf2_per_cu_data *per_cu,
  51.                                                     LONGEST byte_offset);

  53. /* Until these have formal names, we define these here.
  54.    ref: http://gcc.gnu.org/wiki/DebugFission
  55.    Each entry in .debug_loc.dwo begins with a byte that describes the entry,
  56.    and is then followed by data specific to that entry.  */

  58. ‌enum debug_loc_kind
  59. {
  60.   /* Indicates the end of the list of entries.  */
  61.   DEBUG_LOC_END_OF_LIST = 0,

  63.   /* This is followed by an unsigned LEB128 number that is an index into
  64.      .debug_addr and specifies the base address for all following entries.  */
  65.   DEBUG_LOC_BASE_ADDRESS = 1,

  67.   /* This is followed by two unsigned LEB128 numbers that are indices into
  68.      .debug_addr and specify the beginning and ending addresses, and then
  69.      a normal location expression as in .debug_loc.  */
  70.   DEBUG_LOC_START_END = 2,

  72.   /* This is followed by an unsigned LEB128 number that is an index into
  73.      .debug_addr and specifies the beginning address, and a 4 byte unsigned
  74.      number that specifies the length, and then a normal location expression
  75.      as in .debug_loc.  */
  76.   DEBUG_LOC_START_LENGTH = 3,

  78.   /* An internal value indicating there is insufficient data.  */
  79.   DEBUG_LOC_BUFFER_OVERFLOW = -1,

  81.   /* An internal value indicating an invalid kind of entry was found.  */
  82.   DEBUG_LOC_INVALID_ENTRY = -2
  83. };

  85. /* Helper function which throws an error if a synthetic pointer is
  86.    invalid.  */

  88. static void
  89. ‌invalid_synthetic_pointer (void)
  90. {
  91.   error (_("access outside bounds of object "
  92.            "referenced via synthetic pointer"));
  93. }

  95. /* Decode the addresses in a non-dwo .debug_loc entry.
  96.    A pointer to the next byte to examine is returned in *NEW_PTR.
  97.    The encoded low,high addresses are return in *LOW,*HIGH.
  98.    The result indicates the kind of entry found.  */

  100. static enum debug_loc_kind
  101. ‌decode_debug_loc_addresses (const gdb_byte *loc_ptr, const gdb_byte *buf_end,
  102.                             const gdb_byte **new_ptr,
  103.                             CORE_ADDR *low, CORE_ADDR *high,
  104.                             enum bfd_endian byte_order,
  105.                             unsigned int addr_size,
  106.                             int signed_addr_p)
  107. {
  108.   CORE_ADDR base_mask = ~(~(CORE_ADDR)1 << (addr_size * 8 - 1));

  110.   if (buf_end - loc_ptr < 2 * addr_size)
  111.     return DEBUG_LOC_BUFFER_OVERFLOW;

  113.   if (signed_addr_p)
  114.     *low = extract_signed_integer (loc_ptr, addr_size, byte_order);
  115.   else
  116.     *low = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  117.   loc_ptr += addr_size;

  119.   if (signed_addr_p)
  120.     *high = extract_signed_integer (loc_ptr, addr_size, byte_order);
  121.   else
  122.     *high = extract_unsigned_integer (loc_ptr, addr_size, byte_order);
  123.   loc_ptr += addr_size;

  125.   *new_ptr = loc_ptr;

  127.   /* A base-address-selection entry.  */
  128.   if ((*low & base_mask) == base_mask)
  129.     return DEBUG_LOC_BASE_ADDRESS;

  131.   /* An end-of-list entry.  */
  132.   if (*low == 0 && *high == 0)
  133.     return DEBUG_LOC_END_OF_LIST;

  135.   return DEBUG_LOC_START_END;
  136. }

  138. /* Decode the addresses in .debug_loc.dwo entry.
  139.    A pointer to the next byte to examine is returned in *NEW_PTR.
  140.    The encoded low,high addresses are return in *LOW,*HIGH.
  141.    The result indicates the kind of entry found.  */

  143. static enum debug_loc_kind
  144. ‌decode_debug_loc_dwo_addresses (struct dwarf2_per_cu_data *per_cu,
  145.                                 const gdb_byte *loc_ptr,
  146.                                 const gdb_byte *buf_end,
  147.                                 const gdb_byte **new_ptr,
  148.                                 CORE_ADDR *low, CORE_ADDR *high,
  149.                                 enum bfd_endian byte_order)
  150. {
  151.   uint64_t low_index, high_index;

  153.   if (loc_ptr == buf_end)
  154.     return DEBUG_LOC_BUFFER_OVERFLOW;

  156.   switch (*loc_ptr++)
  157.     {
  158.     case DEBUG_LOC_END_OF_LIST:
  159.       *new_ptr = loc_ptr;
  160.       return DEBUG_LOC_END_OF_LIST;
  161.     case DEBUG_LOC_BASE_ADDRESS:
  162.       *low = 0;
  163.       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
  164.       if (loc_ptr == NULL)
  165.         return DEBUG_LOC_BUFFER_OVERFLOW;
  166.       *high = dwarf2_read_addr_index (per_cu, high_index);
  167.       *new_ptr = loc_ptr;
  168.       return DEBUG_LOC_BASE_ADDRESS;
  169.     case DEBUG_LOC_START_END:
  170.       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
  171.       if (loc_ptr == NULL)
  172.         return DEBUG_LOC_BUFFER_OVERFLOW;
  173.       *low = dwarf2_read_addr_index (per_cu, low_index);
  174.       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &high_index);
  175.       if (loc_ptr == NULL)
  176.         return DEBUG_LOC_BUFFER_OVERFLOW;
  177.       *high = dwarf2_read_addr_index (per_cu, high_index);
  178.       *new_ptr = loc_ptr;
  179.       return DEBUG_LOC_START_END;
  180.     case DEBUG_LOC_START_LENGTH:
  181.       loc_ptr = gdb_read_uleb128 (loc_ptr, buf_end, &low_index);
  182.       if (loc_ptr == NULL)
  183.         return DEBUG_LOC_BUFFER_OVERFLOW;
  184.       *low = dwarf2_read_addr_index (per_cu, low_index);
  185.       if (loc_ptr + 4 > buf_end)
  186.         return DEBUG_LOC_BUFFER_OVERFLOW;
  187.       *high = *low;
  188.       *high += extract_unsigned_integer (loc_ptr, 4, byte_order);
  189.       *new_ptr = loc_ptr + 4;
  190.       return DEBUG_LOC_START_LENGTH;
  191.     default:
  192.       return DEBUG_LOC_INVALID_ENTRY;
  193.     }
  194. }

  196. /* A function for dealing with location lists.  Given a
  197.    symbol baton (BATON) and a pc value (PC), find the appropriate
  198.    location expression, set *LOCEXPR_LENGTH, and return a pointer
  199.    to the beginning of the expression.  Returns NULL on failure.

  201.    For now, only return the first matching location expression; there
  202.    can be more than one in the list.  */

  204. const gdb_byte *
  205. ‌dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
  206.                                  size_t *locexpr_length, CORE_ADDR pc)
  207. {
  208.   struct objfile *objfile = dwarf2_per_cu_objfile (baton->per_cu);
  209.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  210.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  211.   unsigned int addr_size = dwarf2_per_cu_addr_size (baton->per_cu);
  212.   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
  213.   /* Adjust base_address for relocatable objects.  */
  214.   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (baton->per_cu);
  215.   CORE_ADDR base_address = baton->base_address + base_offset;
  216.   const gdb_byte *loc_ptr, *buf_end;

  218.   loc_ptr = baton->data;
  219.   buf_end = baton->data + baton->size;

  221.   while (1)
  222.     {
  223.       CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
  224.       int length;
  225.       enum debug_loc_kind kind;
  226.       const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */

  228.       if (baton->from_dwo)
  229.         kind = decode_debug_loc_dwo_addresses (baton->per_cu,
  230.                                                loc_ptr, buf_end, &new_ptr,
  231.                                                &low, &high, byte_order);
  232.       else
  233.         kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
  234.                                            &low, &high,
  235.                                            byte_order, addr_size,
  236.                                            signed_addr_p);
  237.       loc_ptr = new_ptr;
  238.       switch (kind)
  239.         {
  240.         case DEBUG_LOC_END_OF_LIST:
  241.           *locexpr_length = 0;
  242.           return NULL;
  243.         case DEBUG_LOC_BASE_ADDRESS:
  244.           base_address = high + base_offset;
  245.           continue;
  246.         case DEBUG_LOC_START_END:
  247.         case DEBUG_LOC_START_LENGTH:
  248.           break;
  249.         case DEBUG_LOC_BUFFER_OVERFLOW:
  250.         case DEBUG_LOC_INVALID_ENTRY:
  251.           error (_("dwarf2_find_location_expression: "
  252.                    "Corrupted DWARF expression."));
  253.         default:
  254.           gdb_assert_not_reached ("bad debug_loc_kind");
  255.         }

  257.       /* Otherwise, a location expression entry.
  258.          If the entry is from a DWO, don't add base address: the entry is
  259.          from .debug_addr which has absolute addresses.  */
  260.       if (! baton->from_dwo)
  261.         {
  262.           low += base_address;
  263.           high += base_address;
  264.         }

  266.       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
  267.       loc_ptr += 2;

  269.       if (low == high && pc == low)
  270.         {
  271.           /* This is entry PC record present only at entry point
  272.              of a function.  Verify it is really the function entry point.  */

  274.           const struct block *pc_block = block_for_pc (pc);
  275.           struct symbol *pc_func = NULL;

  277.           if (pc_block)
  278.             pc_func = block_linkage_function (pc_block);

  280.           if (pc_func && pc == BLOCK_START (SYMBOL_BLOCK_VALUE (pc_func)))
  281.             {
  282.               *locexpr_length = length;
  283.               return loc_ptr;
  284.             }
  285.         }

  287.       if (pc >= low && pc < high)
  288.         {
  289.           *locexpr_length = length;
  290.           return loc_ptr;
  291.         }

  293.       loc_ptr += length;
  294.     }
  295. }

  297. /* This is the baton used when performing dwarf2 expression
  298.    evaluation.  */
  299. ‌struct dwarf_expr_baton
  300. {
  301.   struct frame_info *frame;
  302.   struct dwarf2_per_cu_data *per_cu;
  303.   CORE_ADDR obj_address;
  304. };

  306. /* Helper functions for dwarf2_evaluate_loc_desc.  */

  308. /* Using the frame specified in BATON, return the value of register
  309.    REGNUM, treated as a pointer.  */
  310. static CORE_ADDR
  311. ‌dwarf_expr_read_addr_from_reg (void *baton, int dwarf_regnum)
  312. {
  313.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
  314.   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
  315.   int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);

  317.   return address_from_register (regnum, debaton->frame);
  318. }

  320. /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback.  */

  322. static struct value *
  323. ‌dwarf_expr_get_reg_value (void *baton, struct type *type, int dwarf_regnum)
  324. {
  325.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
  326.   struct gdbarch *gdbarch = get_frame_arch (debaton->frame);
  327.   int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);

  329.   return value_from_register (type, regnum, debaton->frame);
  330. }

  332. /* Read memory at ADDR (length LEN) into BUF.  */

  334. static void
  335. ‌dwarf_expr_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
  336. {
  337.   read_memory (addr, buf, len);
  338. }

  340. /* Using the frame specified in BATON, find the location expression
  341.    describing the frame base.  Return a pointer to it in START and
  342.    its length in LENGTH.  */
  343. static void
  344. ‌dwarf_expr_frame_base (void *baton, const gdb_byte **start, size_t * length)
  345. {
  346.   /* FIXME: cagney/2003-03-26: This code should be using
  347.      get_frame_base_address(), and then implement a dwarf2 specific
  348.      this_base method.  */
  349.   struct symbol *framefunc;
  350.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
  351.   const struct block *bl = get_frame_block (debaton->frame, NULL);

  353.   if (bl == NULL)
  354.     error (_("frame address is not available."));

  356.   /* Use block_linkage_function, which returns a real (not inlined)
  357.      function, instead of get_frame_function, which may return an
  358.      inlined function.  */
  359.   framefunc = block_linkage_function (bl);

  361.   /* If we found a frame-relative symbol then it was certainly within
  362.      some function associated with a frame. If we can't find the frame,
  363.      something has gone wrong.  */
  364.   gdb_assert (framefunc != NULL);

  366.   func_get_frame_base_dwarf_block (framefunc,
  367.                                    get_frame_address_in_block (debaton->frame),
  368.                                    start, length);
  369. }

  371. /* Implement find_frame_base_location method for LOC_BLOCK functions using
  372.    DWARF expression for its DW_AT_frame_base.  */

  374. static void
  375. ‌locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
  376.                                   const gdb_byte **start, size_t *length)
  377. {
  378.   struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);

  380.   *length = symbaton->size;
  381.   *start = symbaton->data;
  382. }

  384. /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
  385.    function uses DWARF expression for its DW_AT_frame_base.  */

  387. ‌const struct symbol_block_ops dwarf2_block_frame_base_locexpr_funcs =
  388. {
  389.   locexpr_find_frame_base_location
  390. };

  392. /* Implement find_frame_base_location method for LOC_BLOCK functions using
  393.    DWARF location list for its DW_AT_frame_base.  */

  395. static void
  396. ‌loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
  397.                                   const gdb_byte **start, size_t *length)
  398. {
  399.   struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);

  401.   *start = dwarf2_find_location_expression (symbaton, length, pc);
  402. }

  404. /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
  405.    function uses DWARF location list for its DW_AT_frame_base.  */

  407. ‌const struct symbol_block_ops dwarf2_block_frame_base_loclist_funcs =
  408. {
  409.   loclist_find_frame_base_location
  410. };

  412. /* See dwarf2loc.h.  */

  414. void
  415. ‌func_get_frame_base_dwarf_block (struct symbol *framefunc, CORE_ADDR pc,
  416.                                  const gdb_byte **start, size_t *length)
  417. {
  418.   if (SYMBOL_BLOCK_OPS (framefunc) != NULL)
  419.     {
  420.       const struct symbol_block_ops *ops_block = SYMBOL_BLOCK_OPS (framefunc);

  422.       ops_block->find_frame_base_location (framefunc, pc, start, length);
  423.     }
  424.   else
  425.     *length = 0;

  427.   if (*length == 0)
  428.     error (_("Could not find the frame base for \"%s\"."),
  429.            SYMBOL_NATURAL_NAME (framefunc));
  430. }

  432. /* Helper function for dwarf2_evaluate_loc_desc.  Computes the CFA for
  433.    the frame in BATON.  */

  435. static CORE_ADDR
  436. ‌dwarf_expr_frame_cfa (void *baton)
  437. {
  438.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

  440.   return dwarf2_frame_cfa (debaton->frame);
  441. }

  443. /* Helper function for dwarf2_evaluate_loc_desc.  Computes the PC for
  444.    the frame in BATON.  */

  446. static CORE_ADDR
  447. ‌dwarf_expr_frame_pc (void *baton)
  448. {
  449.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

  451.   return get_frame_address_in_block (debaton->frame);
  452. }

  454. /* Using the objfile specified in BATON, find the address for the
  455.    current thread's thread-local storage with offset OFFSET.  */
  456. static CORE_ADDR
  457. ‌dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
  458. {
  459.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
  460.   struct objfile *objfile = dwarf2_per_cu_objfile (debaton->per_cu);

  462.   return target_translate_tls_address (objfile, offset);
  463. }

  465. /* Call DWARF subroutine from DW_AT_location of DIE at DIE_OFFSET in
  466.    current CU (as is PER_CU).  State of the CTX is not affected by the
  467.    call and return.  */

  469. static void
  470. ‌per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
  471.                    struct dwarf2_per_cu_data *per_cu,
  472.                    CORE_ADDR (*get_frame_pc) (void *baton),
  473.                    void *baton)
  474. {
  475.   struct dwarf2_locexpr_baton block;

  477.   block = dwarf2_fetch_die_loc_cu_off (die_offset, per_cu, get_frame_pc, baton);

  479.   /* DW_OP_call_ref is currently not supported.  */
  480.   gdb_assert (block.per_cu == per_cu);

  482.   dwarf_expr_eval (ctx, block.data, block.size);
  483. }

  485. /* Helper interface of per_cu_dwarf_call for dwarf2_evaluate_loc_desc.  */

  487. static void
  488. ‌dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
  489. {
  490.   struct dwarf_expr_baton *debaton = ctx->baton;

  492.   per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
  493.                      ctx->funcs->get_frame_pc, ctx->baton);
  494. }

  496. /* Callback function for dwarf2_evaluate_loc_desc.  */

  498. static struct type *
  499. ‌dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
  500.                           cu_offset die_offset)
  501. {
  502.   struct dwarf_expr_baton *debaton = ctx->baton;

  504.   return dwarf2_get_die_type (die_offset, debaton->per_cu);
  505. }

  507. /* See dwarf2loc.h.  */

  509. ‌unsigned int entry_values_debug = 0;

  511. /* Helper to set entry_values_debug.  */

  513. static void
  514. ‌show_entry_values_debug (struct ui_file *file, int from_tty,
  515.                          struct cmd_list_element *c, const char *value)
  516. {
  517.   fprintf_filtered (file,
  518.                     _("Entry values and tail call frames debugging is %s.\n"),
  519.                     value);
  520. }

  522. /* Find DW_TAG_GNU_call_site's DW_AT_GNU_call_site_target address.
  523.    CALLER_FRAME (for registers) can be NULL if it is not known.  This function
  524.    always returns valid address or it throws NO_ENTRY_VALUE_ERROR.  */

  526. static CORE_ADDR
  527. ‌call_site_to_target_addr (struct gdbarch *call_site_gdbarch,
  528.                           struct call_site *call_site,
  529.                           struct frame_info *caller_frame)
  530. {
  531.   switch (FIELD_LOC_KIND (call_site->target))
  532.     {
  533.     case FIELD_LOC_KIND_DWARF_BLOCK:
  534.       {
  535.         struct dwarf2_locexpr_baton *dwarf_block;
  536.         struct value *val;
  537.         struct type *caller_core_addr_type;
  538.         struct gdbarch *caller_arch;

  540.         dwarf_block = FIELD_DWARF_BLOCK (call_site->target);
  541.         if (dwarf_block == NULL)
  542.           {
  543.             struct bound_minimal_symbol msym;

  545.             msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
  546.             throw_error (NO_ENTRY_VALUE_ERROR,
  547.                          _("DW_AT_GNU_call_site_target is not specified "
  548.                            "at %s in %s"),
  549.                          paddress (call_site_gdbarch, call_site->pc),
  550.                          (msym.minsym == NULL ? "???"
  551.                           : MSYMBOL_PRINT_NAME (msym.minsym)));

  553.           }
  554.         if (caller_frame == NULL)
  555.           {
  556.             struct bound_minimal_symbol msym;

  558.             msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
  559.             throw_error (NO_ENTRY_VALUE_ERROR,
  560.                          _("DW_AT_GNU_call_site_target DWARF block resolving "
  561.                            "requires known frame which is currently not "
  562.                            "available at %s in %s"),
  563.                          paddress (call_site_gdbarch, call_site->pc),
  564.                          (msym.minsym == NULL ? "???"
  565.                           : MSYMBOL_PRINT_NAME (msym.minsym)));

  567.           }
  568.         caller_arch = get_frame_arch (caller_frame);
  569.         caller_core_addr_type = builtin_type (caller_arch)->builtin_func_ptr;
  570.         val = dwarf2_evaluate_loc_desc (caller_core_addr_type, caller_frame,
  571.                                         dwarf_block->data, dwarf_block->size,
  572.                                         dwarf_block->per_cu);
  573.         /* DW_AT_GNU_call_site_target is a DWARF expression, not a DWARF
  574.            location.  */
  575.         if (VALUE_LVAL (val) == lval_memory)
  576.           return value_address (val);
  577.         else
  578.           return value_as_address (val);
  579.       }

  581.     case FIELD_LOC_KIND_PHYSNAME:
  582.       {
  583.         const char *physname;
  584.         struct bound_minimal_symbol msym;

  586.         physname = FIELD_STATIC_PHYSNAME (call_site->target);

  588.         /* Handle both the mangled and demangled PHYSNAME.  */
  589.         msym = lookup_minimal_symbol (physname, NULL, NULL);
  590.         if (msym.minsym == NULL)
  591.           {
  592.             msym = lookup_minimal_symbol_by_pc (call_site->pc - 1);
  593.             throw_error (NO_ENTRY_VALUE_ERROR,
  594.                          _("Cannot find function \"%s\" for a call site target "
  595.                            "at %s in %s"),
  596.                          physname, paddress (call_site_gdbarch, call_site->pc),
  597.                          (msym.minsym == NULL ? "???"
  598.                           : MSYMBOL_PRINT_NAME (msym.minsym)));

  600.           }
  601.         return BMSYMBOL_VALUE_ADDRESS (msym);
  602.       }

  604.     case FIELD_LOC_KIND_PHYSADDR:
  605.       return FIELD_STATIC_PHYSADDR (call_site->target);

  607.     default:
  608.       internal_error (__FILE__, __LINE__, _("invalid call site target kind"));
  609.     }
  610. }

  612. /* Convert function entry point exact address ADDR to the function which is
  613.    compliant with TAIL_CALL_LIST_COMPLETE condition.  Throw
  614.    NO_ENTRY_VALUE_ERROR otherwise.  */

  616. static struct symbol *
  617. ‌func_addr_to_tail_call_list (struct gdbarch *gdbarch, CORE_ADDR addr)
  618. {
  619.   struct symbol *sym = find_pc_function (addr);
  620.   struct type *type;

  622.   if (sym == NULL || BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) != addr)
  623.     throw_error (NO_ENTRY_VALUE_ERROR,
  624.                  _("DW_TAG_GNU_call_site resolving failed to find function "
  625.                    "name for address %s"),
  626.                  paddress (gdbarch, addr));

  628.   type = SYMBOL_TYPE (sym);
  629.   gdb_assert (TYPE_CODE (type) == TYPE_CODE_FUNC);
  630.   gdb_assert (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_FUNC);

  632.   return sym;
  633. }

  635. /* Verify function with entry point exact address ADDR can never call itself
  636.    via its tail calls (incl. transitively).  Throw NO_ENTRY_VALUE_ERROR if it
  637.    can call itself via tail calls.

  639.    If a funtion can tail call itself its entry value based parameters are
  640.    unreliable.  There is no verification whether the value of some/all
  641.    parameters is unchanged through the self tail call, we expect if there is
  642.    a self tail call all the parameters can be modified.  */

  644. static void
  645. ‌func_verify_no_selftailcall (struct gdbarch *gdbarch, CORE_ADDR verify_addr)
  646. {
  647.   struct obstack addr_obstack;
  648.   struct cleanup *old_chain;
  649.   CORE_ADDR addr;

  651.   /* Track here CORE_ADDRs which were already visited.  */
  652.   htab_t addr_hash;

  654.   /* The verification is completely unordered.  Track here function addresses
  655.      which still need to be iterated.  */
  656.   VEC (CORE_ADDR) *todo = NULL;

  658.   obstack_init (&addr_obstack);
  659.   old_chain = make_cleanup_obstack_free (&addr_obstack);
  660.   addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
  661.                                     &addr_obstack, hashtab_obstack_allocate,
  662.                                     NULL);
  663.   make_cleanup_htab_delete (addr_hash);

  665.   make_cleanup (VEC_cleanup (CORE_ADDR), &todo);

  667.   VEC_safe_push (CORE_ADDR, todo, verify_addr);
  668.   while (!VEC_empty (CORE_ADDR, todo))
  669.     {
  670.       struct symbol *func_sym;
  671.       struct call_site *call_site;

  673.       addr = VEC_pop (CORE_ADDR, todo);

  675.       func_sym = func_addr_to_tail_call_list (gdbarch, addr);

  677.       for (call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (func_sym));
  678.            call_site; call_site = call_site->tail_call_next)
  679.         {
  680.           CORE_ADDR target_addr;
  681.           void **slot;

  683.           /* CALLER_FRAME with registers is not available for tail-call jumped
  684.              frames.  */
  685.           target_addr = call_site_to_target_addr (gdbarch, call_site, NULL);

  687.           if (target_addr == verify_addr)
  688.             {
  689.               struct bound_minimal_symbol msym;

  691.               msym = lookup_minimal_symbol_by_pc (verify_addr);
  692.               throw_error (NO_ENTRY_VALUE_ERROR,
  693.                            _("DW_OP_GNU_entry_value resolving has found "
  694.                              "function \"%s\" at %s can call itself via tail "
  695.                              "calls"),
  696.                            (msym.minsym == NULL ? "???"
  697.                             : MSYMBOL_PRINT_NAME (msym.minsym)),
  698.                            paddress (gdbarch, verify_addr));
  699.             }

  701.           slot = htab_find_slot (addr_hash, &target_addr, INSERT);
  702.           if (*slot == NULL)
  703.             {
  704.               *slot = obstack_copy (&addr_obstack, &target_addr,
  705.                                     sizeof (target_addr));
  706.               VEC_safe_push (CORE_ADDR, todo, target_addr);
  707.             }
  708.         }
  709.     }

  711.   do_cleanups (old_chain);
  712. }

  714. /* Print user readable form of CALL_SITE->PC to gdb_stdlog.  Used only for
  715.    ENTRY_VALUES_DEBUG.  */

  717. static void
  718. ‌tailcall_dump (struct gdbarch *gdbarch, const struct call_site *call_site)
  719. {
  720.   CORE_ADDR addr = call_site->pc;
  721.   struct bound_minimal_symbol msym = lookup_minimal_symbol_by_pc (addr - 1);

  723.   fprintf_unfiltered (gdb_stdlog, " %s(%s)", paddress (gdbarch, addr),
  724.                       (msym.minsym == NULL ? "???"
  725.                        : MSYMBOL_PRINT_NAME (msym.minsym)));

  727. }

  729. /* vec.h needs single word type name, typedef it.  */
  730. ‌typedef struct call_site *call_sitep;

  732. /* Define VEC (call_sitep) functions.  */
  733. ‌DEF_VEC_P (call_sitep);

  735. /* Intersect RESULTP with CHAIN to keep RESULTP unambiguous, keep in RESULTP
  736.    only top callers and bottom callees which are present in both.  GDBARCH is
  737.    used only for ENTRY_VALUES_DEBUG.  RESULTP is NULL after return if there are
  738.    no remaining possibilities to provide unambiguous non-trivial result.
  739.    RESULTP should point to NULL on the first (initialization) call.  Caller is
  740.    responsible for xfree of any RESULTP data.  */

  742. static void
  743. ‌chain_candidate (struct gdbarch *gdbarch, struct call_site_chain **resultp,
  744.                  VEC (call_sitep) *chain)
  745. {
  746.   struct call_site_chain *result = *resultp;
  747.   long length = VEC_length (call_sitep, chain);
  748.   int callers, callees, idx;

  750.   if (result == NULL)
  751.     {
  752.       /* Create the initial chain containing all the passed PCs.  */

  754.       result = xmalloc (sizeof (*result) + sizeof (*result->call_site)
  755.                                            * (length - 1));
  756.       result->length = length;
  757.       result->callers = result->callees = length;
  758.       if (!VEC_empty (call_sitep, chain))
  759.         memcpy (result->call_site, VEC_address (call_sitep, chain),
  760.                 sizeof (*result->call_site) * length);
  761.       *resultp = result;

  763.       if (entry_values_debug)
  764.         {
  765.           fprintf_unfiltered (gdb_stdlog, "tailcall: initial:");
  766.           for (idx = 0; idx < length; idx++)
  767.             tailcall_dump (gdbarch, result->call_site[idx]);
  768.           fputc_unfiltered ('\n', gdb_stdlog);
  769.         }

  771.       return;
  772.     }

  774.   if (entry_values_debug)
  775.     {
  776.       fprintf_unfiltered (gdb_stdlog, "tailcall: compare:");
  777.       for (idx = 0; idx < length; idx++)
  778.         tailcall_dump (gdbarch, VEC_index (call_sitep, chain, idx));
  779.       fputc_unfiltered ('\n', gdb_stdlog);
  780.     }

  782.   /* Intersect callers.  */

  784.   callers = min (result->callers, length);
  785.   for (idx = 0; idx < callers; idx++)
  786.     if (result->call_site[idx] != VEC_index (call_sitep, chain, idx))
  787.       {
  788.         result->callers = idx;
  789.         break;
  790.       }

  792.   /* Intersect callees.  */

  794.   callees = min (result->callees, length);
  795.   for (idx = 0; idx < callees; idx++)
  796.     if (result->call_site[result->length - 1 - idx]
  797.         != VEC_index (call_sitep, chain, length - 1 - idx))
  798.       {
  799.         result->callees = idx;
  800.         break;
  801.       }

  803.   if (entry_values_debug)
  804.     {
  805.       fprintf_unfiltered (gdb_stdlog, "tailcall: reduced:");
  806.       for (idx = 0; idx < result->callers; idx++)
  807.         tailcall_dump (gdbarch, result->call_site[idx]);
  808.       fputs_unfiltered (" |", gdb_stdlog);
  809.       for (idx = 0; idx < result->callees; idx++)
  810.         tailcall_dump (gdbarch, result->call_site[result->length
  811.                                                   - result->callees + idx]);
  812.       fputc_unfiltered ('\n', gdb_stdlog);
  813.     }

  815.   if (result->callers == 0 && result->callees == 0)
  816.     {
  817.       /* There are no common callers or callees.  It could be also a direct
  818.          call (which has length 0) with ambiguous possibility of an indirect
  819.          call - CALLERS == CALLEES == 0 is valid during the first allocation
  820.          but any subsequence processing of such entry means ambiguity.  */
  821.       xfree (result);
  822.       *resultp = NULL;
  823.       return;
  824.     }

  826.   /* See call_site_find_chain_1 why there is no way to reach the bottom callee
  827.      PC again.  In such case there must be two different code paths to reach
  828.      it, therefore some of the former determined intermediate PCs must differ
  829.      and the unambiguous chain gets shortened.  */
  830.   gdb_assert (result->callers + result->callees < result->length);
  831. }

  833. /* Create and return call_site_chain for CALLER_PC and CALLEE_PC.  All the
  834.    assumed frames between them use GDBARCH.  Use depth first search so we can
  835.    keep single CHAIN of call_site's back to CALLER_PC.  Function recursion
  836.    would have needless GDB stack overhead.  Caller is responsible for xfree of
  837.    the returned result.  Any unreliability results in thrown
  838.    NO_ENTRY_VALUE_ERROR.  */

  840. static struct call_site_chain *
  841. ‌call_site_find_chain_1 (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
  842.                         CORE_ADDR callee_pc)
  843. {
  844.   CORE_ADDR save_callee_pc = callee_pc;
  845.   struct obstack addr_obstack;
  846.   struct cleanup *back_to_retval, *back_to_workdata;
  847.   struct call_site_chain *retval = NULL;
  848.   struct call_site *call_site;

  850.   /* Mark CALL_SITEs so we do not visit the same ones twice.  */
  851.   htab_t addr_hash;

  853.   /* CHAIN contains only the intermediate CALL_SITEs.  Neither CALLER_PC's
  854.      call_site nor any possible call_site at CALLEE_PC's function is there.
  855.      Any CALL_SITE in CHAIN will be iterated to its siblings - via
  856.      TAIL_CALL_NEXT.  This is inappropriate for CALLER_PC's call_site.  */
  857.   VEC (call_sitep) *chain = NULL;

  859.   /* We are not interested in the specific PC inside the callee function.  */
  860.   callee_pc = get_pc_function_start (callee_pc);
  861.   if (callee_pc == 0)
  862.     throw_error (NO_ENTRY_VALUE_ERROR, _("Unable to find function for PC %s"),
  863.                  paddress (gdbarch, save_callee_pc));

  865.   back_to_retval = make_cleanup (free_current_contents, &retval);

  867.   obstack_init (&addr_obstack);
  868.   back_to_workdata = make_cleanup_obstack_free (&addr_obstack);
  869.   addr_hash = htab_create_alloc_ex (64, core_addr_hash, core_addr_eq, NULL,
  870.                                     &addr_obstack, hashtab_obstack_allocate,
  871.                                     NULL);
  872.   make_cleanup_htab_delete (addr_hash);

  874.   make_cleanup (VEC_cleanup (call_sitep), &chain);

  876.   /* Do not push CALL_SITE to CHAIN.  Push there only the first tail call site
  877.      at the target's function.  All the possible tail call sites in the
  878.      target's function will get iterated as already pushed into CHAIN via their
  879.      TAIL_CALL_NEXT.  */
  880.   call_site = call_site_for_pc (gdbarch, caller_pc);

  882.   while (call_site)
  883.     {
  884.       CORE_ADDR target_func_addr;
  885.       struct call_site *target_call_site;

  887.       /* CALLER_FRAME with registers is not available for tail-call jumped
  888.          frames.  */
  889.       target_func_addr = call_site_to_target_addr (gdbarch, call_site, NULL);

  891.       if (target_func_addr == callee_pc)
  892.         {
  893.           chain_candidate (gdbarch, &retval, chain);
  894.           if (retval == NULL)
  895.             break;

  897.           /* There is no way to reach CALLEE_PC again as we would prevent
  898.              entering it twice as being already marked in ADDR_HASH.  */
  899.           target_call_site = NULL;
  900.         }
  901.       else
  902.         {
  903.           struct symbol *target_func;

  905.           target_func = func_addr_to_tail_call_list (gdbarch, target_func_addr);
  906.           target_call_site = TYPE_TAIL_CALL_LIST (SYMBOL_TYPE (target_func));
  907.         }

  909.       do
  910.         {
  911.           /* Attempt to visit TARGET_CALL_SITE.  */

  913.           if (target_call_site)
  914.             {
  915.               void **slot;

  917.               slot = htab_find_slot (addr_hash, &target_call_site->pc, INSERT);
  918.               if (*slot == NULL)
  919.                 {
  920.                   /* Successfully entered TARGET_CALL_SITE.  */

  922.                   *slot = &target_call_site->pc;
  923.                   VEC_safe_push (call_sitep, chain, target_call_site);
  924.                   break;
  925.                 }
  926.             }

  928.           /* Backtrack (without revisiting the originating call_site).  Try the
  929.              callers's sibling; if there isn't any try the callers's callers's
  930.              sibling etc.  */

  932.           target_call_site = NULL;
  933.           while (!VEC_empty (call_sitep, chain))
  934.             {
  935.               call_site = VEC_pop (call_sitep, chain);

  937.               gdb_assert (htab_find_slot (addr_hash, &call_site->pc,
  938.                                           NO_INSERT) != NULL);
  939.               htab_remove_elt (addr_hash, &call_site->pc);

  941.               target_call_site = call_site->tail_call_next;
  942.               if (target_call_site)
  943.                 break;
  944.             }
  945.         }
  946.       while (target_call_site);

  948.       if (VEC_empty (call_sitep, chain))
  949.         call_site = NULL;
  950.       else
  951.         call_site = VEC_last (call_sitep, chain);
  952.     }

  954.   if (retval == NULL)
  955.     {
  956.       struct bound_minimal_symbol msym_caller, msym_callee;

  958.       msym_caller = lookup_minimal_symbol_by_pc (caller_pc);
  959.       msym_callee = lookup_minimal_symbol_by_pc (callee_pc);
  960.       throw_error (NO_ENTRY_VALUE_ERROR,
  961.                    _("There are no unambiguously determinable intermediate "
  962.                      "callers or callees between caller function \"%s\" at %s "
  963.                      "and callee function \"%s\" at %s"),
  964.                    (msym_caller.minsym == NULL
  965.                     ? "???" : MSYMBOL_PRINT_NAME (msym_caller.minsym)),
  966.                    paddress (gdbarch, caller_pc),
  967.                    (msym_callee.minsym == NULL
  968.                     ? "???" : MSYMBOL_PRINT_NAME (msym_callee.minsym)),
  969.                    paddress (gdbarch, callee_pc));
  970.     }

  972.   do_cleanups (back_to_workdata);
  973.   discard_cleanups (back_to_retval);
  974.   return retval;
  975. }

  977. /* Create and return call_site_chain for CALLER_PC and CALLEE_PC.  All the
  978.    assumed frames between them use GDBARCH.  If valid call_site_chain cannot be
  979.    constructed return NULL.  Caller is responsible for xfree of the returned
  980.    result.  */

  982. struct call_site_chain *
  983. ‌call_site_find_chain (struct gdbarch *gdbarch, CORE_ADDR caller_pc,
  984.                       CORE_ADDR callee_pc)
  985. {
  986.   volatile struct gdb_exception e;
  987.   struct call_site_chain *retval = NULL;

  989.   TRY_CATCH (e, RETURN_MASK_ERROR)
  990.     {
  991.       retval = call_site_find_chain_1 (gdbarch, caller_pc, callee_pc);
  992.     }
  993.   if (e.reason < 0)
  994.     {
  995.       if (e.error == NO_ENTRY_VALUE_ERROR)
  996.         {
  997.           if (entry_values_debug)
  998.             exception_print (gdb_stdout, e);

  1000.           return NULL;
  1001.         }
  1002.       else
  1003.         throw_exception (e);
  1004.     }
  1005.   return retval;
  1006. }

  1008. /* Return 1 if KIND and KIND_U match PARAMETER.  Return 0 otherwise.  */

  1010. static int
  1011. ‌call_site_parameter_matches (struct call_site_parameter *parameter,
  1012.                              enum call_site_parameter_kind kind,
  1013.                              union call_site_parameter_u kind_u)
  1014. {
  1015.   if (kind == parameter->kind)
  1016.     switch (kind)
  1017.       {
  1018.       case CALL_SITE_PARAMETER_DWARF_REG:
  1019.         return kind_u.dwarf_reg == parameter->u.dwarf_reg;
  1020.       case CALL_SITE_PARAMETER_FB_OFFSET:
  1021.         return kind_u.fb_offset == parameter->u.fb_offset;
  1022.       case CALL_SITE_PARAMETER_PARAM_OFFSET:
  1023.         return kind_u.param_offset.cu_off == parameter->u.param_offset.cu_off;
  1024.       }
  1025.   return 0;
  1026. }

  1028. /* Fetch call_site_parameter from caller matching KIND and KIND_U.
  1029.    FRAME is for callee.

  1031.    Function always returns non-NULL, it throws NO_ENTRY_VALUE_ERROR
  1032.    otherwise.  */

  1034. static struct call_site_parameter *
  1035. ‌dwarf_expr_reg_to_entry_parameter (struct frame_info *frame,
  1036.                                    enum call_site_parameter_kind kind,
  1037.                                    union call_site_parameter_u kind_u,
  1038.                                    struct dwarf2_per_cu_data **per_cu_return)
  1039. {
  1040.   CORE_ADDR func_addr, caller_pc;
  1041.   struct gdbarch *gdbarch;
  1042.   struct frame_info *caller_frame;
  1043.   struct call_site *call_site;
  1044.   int iparams;
  1045.   /* Initialize it just to avoid a GCC false warning.  */
  1046.   struct call_site_parameter *parameter = NULL;
  1047.   CORE_ADDR target_addr;

  1049.   while (get_frame_type (frame) == INLINE_FRAME)
  1050.     {
  1051.       frame = get_prev_frame (frame);
  1052.       gdb_assert (frame != NULL);
  1053.     }

  1055.   func_addr = get_frame_func (frame);
  1056.   gdbarch = get_frame_arch (frame);
  1057.   caller_frame = get_prev_frame (frame);
  1058.   if (gdbarch != frame_unwind_arch (frame))
  1059.     {
  1060.       struct bound_minimal_symbol msym
  1061.         = lookup_minimal_symbol_by_pc (func_addr);
  1062.       struct gdbarch *caller_gdbarch = frame_unwind_arch (frame);

  1064.       throw_error (NO_ENTRY_VALUE_ERROR,
  1065.                    _("DW_OP_GNU_entry_value resolving callee gdbarch %s "
  1066.                      "(of %s (%s)) does not match caller gdbarch %s"),
  1067.                    gdbarch_bfd_arch_info (gdbarch)->printable_name,
  1068.                    paddress (gdbarch, func_addr),
  1069.                    (msym.minsym == NULL ? "???"
  1070.                     : MSYMBOL_PRINT_NAME (msym.minsym)),
  1071.                    gdbarch_bfd_arch_info (caller_gdbarch)->printable_name);
  1072.     }

  1074.   if (caller_frame == NULL)
  1075.     {
  1076.       struct bound_minimal_symbol msym
  1077.         = lookup_minimal_symbol_by_pc (func_addr);

  1079.       throw_error (NO_ENTRY_VALUE_ERROR, _("DW_OP_GNU_entry_value resolving "
  1080.                                            "requires caller of %s (%s)"),
  1081.                    paddress (gdbarch, func_addr),
  1082.                    (msym.minsym == NULL ? "???"
  1083.                     : MSYMBOL_PRINT_NAME (msym.minsym)));
  1084.     }
  1085.   caller_pc = get_frame_pc (caller_frame);
  1086.   call_site = call_site_for_pc (gdbarch, caller_pc);

  1088.   target_addr = call_site_to_target_addr (gdbarch, call_site, caller_frame);
  1089.   if (target_addr != func_addr)
  1090.     {
  1091.       struct minimal_symbol *target_msym, *func_msym;

  1093.       target_msym = lookup_minimal_symbol_by_pc (target_addr).minsym;
  1094.       func_msym = lookup_minimal_symbol_by_pc (func_addr).minsym;
  1095.       throw_error (NO_ENTRY_VALUE_ERROR,
  1096.                    _("DW_OP_GNU_entry_value resolving expects callee %s at %s "
  1097.                      "but the called frame is for %s at %s"),
  1098.                    (target_msym == NULL ? "???"
  1099.                                         : MSYMBOL_PRINT_NAME (target_msym)),
  1100.                    paddress (gdbarch, target_addr),
  1101.                    func_msym == NULL ? "???" : MSYMBOL_PRINT_NAME (func_msym),
  1102.                    paddress (gdbarch, func_addr));
  1103.     }

  1105.   /* No entry value based parameters would be reliable if this function can
  1106.      call itself via tail calls.  */
  1107.   func_verify_no_selftailcall (gdbarch, func_addr);

  1109.   for (iparams = 0; iparams < call_site->parameter_count; iparams++)
  1110.     {
  1111.       parameter = &call_site->parameter[iparams];
  1112.       if (call_site_parameter_matches (parameter, kind, kind_u))
  1113.         break;
  1114.     }
  1115.   if (iparams == call_site->parameter_count)
  1116.     {
  1117.       struct minimal_symbol *msym
  1118.         = lookup_minimal_symbol_by_pc (caller_pc).minsym;

  1120.       /* DW_TAG_GNU_call_site_parameter will be missing just if GCC could not
  1121.          determine its value.  */
  1122.       throw_error (NO_ENTRY_VALUE_ERROR, _("Cannot find matching parameter "
  1123.                                            "at DW_TAG_GNU_call_site %s at %s"),
  1124.                    paddress (gdbarch, caller_pc),
  1125.                    msym == NULL ? "???" : MSYMBOL_PRINT_NAME (msym));
  1126.     }

  1128.   *per_cu_return = call_site->per_cu;
  1129.   return parameter;
  1130. }

  1132. /* Return value for PARAMETER matching DEREF_SIZE.  If DEREF_SIZE is -1, return
  1133.    the normal DW_AT_GNU_call_site_value block.  Otherwise return the
  1134.    DW_AT_GNU_call_site_data_value (dereferenced) block.

  1136.    TYPE and CALLER_FRAME specify how to evaluate the DWARF block into returned
  1137.    struct value.

  1139.    Function always returns non-NULL, non-optimized out value.  It throws
  1140.    NO_ENTRY_VALUE_ERROR if it cannot resolve the value for any reason.  */

  1142. static struct value *
  1143. ‌dwarf_entry_parameter_to_value (struct call_site_parameter *parameter,
  1144.                                 CORE_ADDR deref_size, struct type *type,
  1145.                                 struct frame_info *caller_frame,
  1146.                                 struct dwarf2_per_cu_data *per_cu)
  1147. {
  1148.   const gdb_byte *data_src;
  1149.   gdb_byte *data;
  1150.   size_t size;

  1152.   data_src = deref_size == -1 ? parameter->value : parameter->data_value;
  1153.   size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;

  1155.   /* DEREF_SIZE size is not verified here.  */
  1156.   if (data_src == NULL)
  1157.     throw_error (NO_ENTRY_VALUE_ERROR,
  1158.                  _("Cannot resolve DW_AT_GNU_call_site_data_value"));

  1160.   /* DW_AT_GNU_call_site_value is a DWARF expression, not a DWARF
  1161.      location.  Postprocessing of DWARF_VALUE_MEMORY would lose the type from
  1162.      DWARF block.  */
  1163.   data = alloca (size + 1);
  1164.   memcpy (data, data_src, size);
  1165.   data[size] = DW_OP_stack_value;

  1167.   return dwarf2_evaluate_loc_desc (type, caller_frame, data, size + 1, per_cu);
  1168. }

  1170. /* Execute DWARF block of call_site_parameter which matches KIND and KIND_U.
  1171.    Choose DEREF_SIZE value of that parameter.  Search caller of the CTX's
  1172.    frame.  CTX must be of dwarf_expr_ctx_funcs kind.

  1174.    The CTX caller can be from a different CU - per_cu_dwarf_call implementation
  1175.    can be more simple as it does not support cross-CU DWARF executions.  */

  1177. static void
  1178. ‌dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
  1179.                                        enum call_site_parameter_kind kind,
  1180.                                        union call_site_parameter_u kind_u,
  1181.                                        int deref_size)
  1182. {
  1183.   struct dwarf_expr_baton *debaton;
  1184.   struct frame_info *frame, *caller_frame;
  1185.   struct dwarf2_per_cu_data *caller_per_cu;
  1186.   struct dwarf_expr_baton baton_local;
  1187.   struct dwarf_expr_context saved_ctx;
  1188.   struct call_site_parameter *parameter;
  1189.   const gdb_byte *data_src;
  1190.   size_t size;

  1192.   gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
  1193.   debaton = ctx->baton;
  1194.   frame = debaton->frame;
  1195.   caller_frame = get_prev_frame (frame);

  1197.   parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
  1198.                                                  &caller_per_cu);
  1199.   data_src = deref_size == -1 ? parameter->value : parameter->data_value;
  1200.   size = deref_size == -1 ? parameter->value_size : parameter->data_value_size;

  1202.   /* DEREF_SIZE size is not verified here.  */
  1203.   if (data_src == NULL)
  1204.     throw_error (NO_ENTRY_VALUE_ERROR,
  1205.                  _("Cannot resolve DW_AT_GNU_call_site_data_value"));

  1207.   baton_local.frame = caller_frame;
  1208.   baton_local.per_cu = caller_per_cu;
  1209.   baton_local.obj_address = 0;

  1211.   saved_ctx.gdbarch = ctx->gdbarch;
  1212.   saved_ctx.addr_size = ctx->addr_size;
  1213.   saved_ctx.offset = ctx->offset;
  1214.   saved_ctx.baton = ctx->baton;
  1215.   ctx->gdbarch = get_objfile_arch (dwarf2_per_cu_objfile (baton_local.per_cu));
  1216.   ctx->addr_size = dwarf2_per_cu_addr_size (baton_local.per_cu);
  1217.   ctx->offset = dwarf2_per_cu_text_offset (baton_local.per_cu);
  1218.   ctx->baton = &baton_local;

  1220.   dwarf_expr_eval (ctx, data_src, size);

  1222.   ctx->gdbarch = saved_ctx.gdbarch;
  1223.   ctx->addr_size = saved_ctx.addr_size;
  1224.   ctx->offset = saved_ctx.offset;
  1225.   ctx->baton = saved_ctx.baton;
  1226. }

  1228. /* Callback function for dwarf2_evaluate_loc_desc.
  1229.    Fetch the address indexed by DW_OP_GNU_addr_index.  */

  1231. static CORE_ADDR
  1232. ‌dwarf_expr_get_addr_index (void *baton, unsigned int index)
  1233. {
  1234.   struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;

  1236.   return dwarf2_read_addr_index (debaton->per_cu, index);
  1237. }

  1239. /* Callback function for get_object_address. Return the address of the VLA
  1240.    object.  */

  1242. static CORE_ADDR
  1243. ‌dwarf_expr_get_obj_addr (void *baton)
  1244. {
  1245.   struct dwarf_expr_baton *debaton = baton;

  1247.   gdb_assert (debaton != NULL);

  1249.   if (debaton->obj_address == 0)
  1250.     error (_("Location address is not set."));

  1252.   return debaton->obj_address;
  1253. }

  1255. /* VALUE must be of type lval_computed with entry_data_value_funcs.  Perform
  1256.    the indirect method on it, that is use its stored target value, the sole
  1257.    purpose of entry_data_value_funcs..  */

  1259. static struct value *
  1260. ‌entry_data_value_coerce_ref (const struct value *value)
  1261. {
  1262.   struct type *checked_type = check_typedef (value_type (value));
  1263.   struct value *target_val;

  1265.   if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
  1266.     return NULL;

  1268.   target_val = value_computed_closure (value);
  1269.   value_incref (target_val);
  1270.   return target_val;
  1271. }

  1273. /* Implement copy_closure.  */

  1275. static void *
  1276. ‌entry_data_value_copy_closure (const struct value *v)
  1277. {
  1278.   struct value *target_val = value_computed_closure (v);

  1280.   value_incref (target_val);
  1281.   return target_val;
  1282. }

  1284. /* Implement free_closure.  */

  1286. static void
  1287. ‌entry_data_value_free_closure (struct value *v)
  1288. {
  1289.   struct value *target_val = value_computed_closure (v);

  1291.   value_free (target_val);
  1292. }

  1294. /* Vector for methods for an entry value reference where the referenced value
  1295.    is stored in the caller.  On the first dereference use
  1296.    DW_AT_GNU_call_site_data_value in the caller.  */

  1298. ‌static const struct lval_funcs entry_data_value_funcs =
  1299. {
  1300.   NULL,        /* read */
  1301.   NULL,        /* write */
  1302.   NULL,        /* indirect */
  1303.   entry_data_value_coerce_ref,
  1304.   NULL,        /* check_synthetic_pointer */
  1305.   entry_data_value_copy_closure,
  1306.   entry_data_value_free_closure
  1307. };

  1309. /* Read parameter of TYPE at (callee) FRAME's function entry.  KIND and KIND_U
  1310.    are used to match DW_AT_location at the caller's
  1311.    DW_TAG_GNU_call_site_parameter.

  1313.    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
  1314.    cannot resolve the parameter for any reason.  */

  1316. static struct value *
  1317. ‌value_of_dwarf_reg_entry (struct type *type, struct frame_info *frame,
  1318.                           enum call_site_parameter_kind kind,
  1319.                           union call_site_parameter_u kind_u)
  1320. {
  1321.   struct type *checked_type = check_typedef (type);
  1322.   struct type *target_type = TYPE_TARGET_TYPE (checked_type);
  1323.   struct frame_info *caller_frame = get_prev_frame (frame);
  1324.   struct value *outer_val, *target_val, *val;
  1325.   struct call_site_parameter *parameter;
  1326.   struct dwarf2_per_cu_data *caller_per_cu;

  1328.   parameter = dwarf_expr_reg_to_entry_parameter (frame, kind, kind_u,
  1329.                                                  &caller_per_cu);

  1331.   outer_val = dwarf_entry_parameter_to_value (parameter, -1 /* deref_size */,
  1332.                                               type, caller_frame,
  1333.                                               caller_per_cu);

  1335.   /* Check if DW_AT_GNU_call_site_data_value cannot be used.  If it should be
  1336.      used and it is not available do not fall back to OUTER_VAL - dereferencing
  1337.      TYPE_CODE_REF with non-entry data value would give current value - not the
  1338.      entry value.  */

  1340.   if (TYPE_CODE (checked_type) != TYPE_CODE_REF
  1341.       || TYPE_TARGET_TYPE (checked_type) == NULL)
  1342.     return outer_val;

  1344.   target_val = dwarf_entry_parameter_to_value (parameter,
  1345.                                                TYPE_LENGTH (target_type),
  1346.                                                target_type, caller_frame,
  1347.                                                caller_per_cu);

  1349.   release_value (target_val);
  1350.   val = allocate_computed_value (type, &entry_data_value_funcs,
  1351.                                  target_val /* closure */);

  1353.   /* Copy the referencing pointer to the new computed value.  */
  1354.   memcpy (value_contents_raw (val), value_contents_raw (outer_val),
  1355.           TYPE_LENGTH (checked_type));
  1356.   set_value_lazy (val, 0);

  1358.   return val;
  1359. }

  1361. /* Read parameter of TYPE at (callee) FRAME's function entry.  DATA and
  1362.    SIZE are DWARF block used to match DW_AT_location at the caller's
  1363.    DW_TAG_GNU_call_site_parameter.

  1365.    Function always returns non-NULL value.  It throws NO_ENTRY_VALUE_ERROR if it
  1366.    cannot resolve the parameter for any reason.  */

  1368. static struct value *
  1369. ‌value_of_dwarf_block_entry (struct type *type, struct frame_info *frame,
  1370.                             const gdb_byte *block, size_t block_len)
  1371. {
  1372.   union call_site_parameter_u kind_u;

  1374.   kind_u.dwarf_reg = dwarf_block_to_dwarf_reg (block, block + block_len);
  1375.   if (kind_u.dwarf_reg != -1)
  1376.     return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_DWARF_REG,
  1377.                                      kind_u);

  1379.   if (dwarf_block_to_fb_offset (block, block + block_len, &kind_u.fb_offset))
  1380.     return value_of_dwarf_reg_entry (type, frame, CALL_SITE_PARAMETER_FB_OFFSET,
  1381.                                      kind_u);

  1383.   /* This can normally happen - throw NO_ENTRY_VALUE_ERROR to get the message
  1384.      suppressed during normal operation.  The expression can be arbitrary if
  1385.      there is no caller-callee entry value binding expected.  */
  1386.   throw_error (NO_ENTRY_VALUE_ERROR,
  1387.                _("DWARF-2 expression error: DW_OP_GNU_entry_value is supported "
  1388.                  "only for single DW_OP_reg* or for DW_OP_fbreg(*)"));
  1389. }

  1391. ‌struct piece_closure
  1392. {
  1393.   /* Reference count.  */
  1394.   int refc;

  1396.   /* The CU from which this closure's expression came.  */
  1397.   struct dwarf2_per_cu_data *per_cu;

  1399.   /* The number of pieces used to describe this variable.  */
  1400.   int n_pieces;

  1402.   /* The target address size, used only for DWARF_VALUE_STACK.  */
  1403.   int addr_size;

  1405.   /* The pieces themselves.  */
  1406.   struct dwarf_expr_piece *pieces;
  1407. };

  1409. /* Allocate a closure for a value formed from separately-described
  1410.    PIECES.  */

  1412. static struct piece_closure *
  1413. ‌allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
  1414.                         int n_pieces, struct dwarf_expr_piece *pieces,
  1415.                         int addr_size)
  1416. {
  1417.   struct piece_closure *c = XCNEW (struct piece_closure);
  1418.   int i;

  1420.   c->refc = 1;
  1421.   c->per_cu = per_cu;
  1422.   c->n_pieces = n_pieces;
  1423.   c->addr_size = addr_size;
  1424.   c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);

  1426.   memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
  1427.   for (i = 0; i < n_pieces; ++i)
  1428.     if (c->pieces[i].location == DWARF_VALUE_STACK)
  1429.       value_incref (c->pieces[i].v.value);

  1431.   return c;
  1432. }

  1434. /* The lowest-level function to extract bits from a byte buffer.
  1435.    SOURCE is the buffer.  It is updated if we read to the end of a
  1436.    byte.
  1437.    SOURCE_OFFSET_BITS is the offset of the first bit to read.  It is
  1438.    updated to reflect the number of bits actually read.
  1439.    NBITS is the number of bits we want to read.  It is updated to
  1440.    reflect the number of bits actually read.  This function may read
  1441.    fewer bits.
  1442.    BITS_BIG_ENDIAN is taken directly from gdbarch.
  1443.    This function returns the extracted bits.  */

  1445. static unsigned int
  1446. ‌extract_bits_primitive (const gdb_byte **source,
  1447.                         unsigned int *source_offset_bits,
  1448.                         int *nbits, int bits_big_endian)
  1449. {
  1450.   unsigned int avail, mask, datum;

  1452.   gdb_assert (*source_offset_bits < 8);

  1454.   avail = 8 - *source_offset_bits;
  1455.   if (avail > *nbits)
  1456.     avail = *nbits;

  1458.   mask = (1 << avail) - 1;
  1459.   datum = **source;
  1460.   if (bits_big_endian)
  1461.     datum >>= 8 - (*source_offset_bits + *nbits);
  1462.   else
  1463.     datum >>= *source_offset_bits;
  1464.   datum &= mask;

  1466.   *nbits -= avail;
  1467.   *source_offset_bits += avail;
  1468.   if (*source_offset_bits >= 8)
  1469.     {
  1470.       *source_offset_bits -= 8;
  1471.       ++*source;
  1472.     }

  1474.   return datum;
  1475. }

  1477. /* Extract some bits from a source buffer and move forward in the
  1478.    buffer.

  1480.    SOURCE is the source buffer.  It is updated as bytes are read.
  1481.    SOURCE_OFFSET_BITS is the offset into SOURCE.  It is updated as
  1482.    bits are read.
  1483.    NBITS is the number of bits to read.
  1484.    BITS_BIG_ENDIAN is taken directly from gdbarch.

  1486.    This function returns the bits that were read.  */

  1488. static unsigned int
  1489. ‌extract_bits (const gdb_byte **source, unsigned int *source_offset_bits,
  1490.               int nbits, int bits_big_endian)
  1491. {
  1492.   unsigned int datum;

  1494.   gdb_assert (nbits > 0 && nbits <= 8);

  1496.   datum = extract_bits_primitive (source, source_offset_bits, &nbits,
  1497.                                   bits_big_endian);
  1498.   if (nbits > 0)
  1499.     {
  1500.       unsigned int more;

  1502.       more = extract_bits_primitive (source, source_offset_bits, &nbits,
  1503.                                      bits_big_endian);
  1504.       if (bits_big_endian)
  1505.         datum <<= nbits;
  1506.       else
  1507.         more <<= nbits;
  1508.       datum |= more;
  1509.     }

  1511.   return datum;
  1512. }

  1514. /* Write some bits into a buffer and move forward in the buffer.

  1516.    DATUM is the bits to write.  The low-order bits of DATUM are used.
  1517.    DEST is the destination buffer.  It is updated as bytes are
  1518.    written.
  1519.    DEST_OFFSET_BITS is the bit offset in DEST at which writing is
  1520.    done.
  1521.    NBITS is the number of valid bits in DATUM.
  1522.    BITS_BIG_ENDIAN is taken directly from gdbarch.  */

  1524. static void
  1525. ‌insert_bits (unsigned int datum,
  1526.              gdb_byte *dest, unsigned int dest_offset_bits,
  1527.              int nbits, int bits_big_endian)
  1528. {
  1529.   unsigned int mask;

  1531.   gdb_assert (dest_offset_bits + nbits <= 8);

  1533.   mask = (1 << nbits) - 1;
  1534.   if (bits_big_endian)
  1535.     {
  1536.       datum <<= 8 - (dest_offset_bits + nbits);
  1537.       mask <<= 8 - (dest_offset_bits + nbits);
  1538.     }
  1539.   else
  1540.     {
  1541.       datum <<= dest_offset_bits;
  1542.       mask <<= dest_offset_bits;
  1543.     }

  1545.   gdb_assert ((datum & ~mask) == 0);

  1547.   *dest = (*dest & ~mask) | datum;
  1548. }

  1550. /* Copy bits from a source to a destination.

  1552.    DEST is where the bits should be written.
  1553.    DEST_OFFSET_BITS is the bit offset into DEST.
  1554.    SOURCE is the source of bits.
  1555.    SOURCE_OFFSET_BITS is the bit offset into SOURCE.
  1556.    BIT_COUNT is the number of bits to copy.
  1557.    BITS_BIG_ENDIAN is taken directly from gdbarch.  */

  1559. static void
  1560. ‌copy_bitwise (gdb_byte *dest, unsigned int dest_offset_bits,
  1561.               const gdb_byte *source, unsigned int source_offset_bits,
  1562.               unsigned int bit_count,
  1563.               int bits_big_endian)
  1564. {
  1565.   unsigned int dest_avail;
  1566.   int datum;

  1568.   /* Reduce everything to byte-size pieces.  */
  1569.   dest += dest_offset_bits / 8;
  1570.   dest_offset_bits %= 8;
  1571.   source += source_offset_bits / 8;
  1572.   source_offset_bits %= 8;

  1574.   dest_avail = 8 - dest_offset_bits % 8;

  1576.   /* See if we can fill the first destination byte.  */
  1577.   if (dest_avail < bit_count)
  1578.     {
  1579.       datum = extract_bits (&source, &source_offset_bits, dest_avail,
  1580.                             bits_big_endian);
  1581.       insert_bits (datum, dest, dest_offset_bits, dest_avail, bits_big_endian);
  1582.       ++dest;
  1583.       dest_offset_bits = 0;
  1584.       bit_count -= dest_avail;
  1585.     }

  1587.   /* Now, either DEST_OFFSET_BITS is byte-aligned, or we have fewer
  1588.      than 8 bits remaining.  */
  1589.   gdb_assert (dest_offset_bits % 8 == 0 || bit_count < 8);
  1590.   for (; bit_count >= 8; bit_count -= 8)
  1591.     {
  1592.       datum = extract_bits (&source, &source_offset_bits, 8, bits_big_endian);
  1593.       *dest++ = (gdb_byte) datum;
  1594.     }

  1596.   /* Finally, we may have a few leftover bits.  */
  1597.   gdb_assert (bit_count <= 8 - dest_offset_bits % 8);
  1598.   if (bit_count > 0)
  1599.     {
  1600.       datum = extract_bits (&source, &source_offset_bits, bit_count,
  1601.                             bits_big_endian);
  1602.       insert_bits (datum, dest, dest_offset_bits, bit_count, bits_big_endian);
  1603.     }
  1604. }

  1606. static void
  1607. ‌read_pieced_value (struct value *v)
  1608. {
  1609.   int i;
  1610.   long offset = 0;
  1611.   ULONGEST bits_to_skip;
  1612.   gdb_byte *contents;
  1613.   struct piece_closure *c
  1614.     = (struct piece_closure *) value_computed_closure (v);
  1615.   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (v));
  1616.   size_t type_len;
  1617.   size_t buffer_size = 0;
  1618.   gdb_byte *buffer = NULL;
  1619.   struct cleanup *cleanup;
  1620.   int bits_big_endian
  1621.     = gdbarch_bits_big_endian (get_type_arch (value_type (v)));

  1623.   if (value_type (v) != value_enclosing_type (v))
  1624.     internal_error (__FILE__, __LINE__,
  1625.                     _("Should not be able to create a lazy value with "
  1626.                       "an enclosing type"));

  1628.   cleanup = make_cleanup (free_current_contents, &buffer);

  1630.   contents = value_contents_raw (v);
  1631.   bits_to_skip = 8 * value_offset (v);
  1632.   if (value_bitsize (v))
  1633.     {
  1634.       bits_to_skip += value_bitpos (v);
  1635.       type_len = value_bitsize (v);
  1636.     }
  1637.   else
  1638.     type_len = 8 * TYPE_LENGTH (value_type (v));

  1640.   for (i = 0; i < c->n_pieces && offset < type_len; i++)
  1641.     {
  1642.       struct dwarf_expr_piece *p = &c->pieces[i];
  1643.       size_t this_size, this_size_bits;
  1644.       long dest_offset_bits, source_offset_bits, source_offset;
  1645.       const gdb_byte *intermediate_buffer;

  1647.       /* Compute size, source, and destination offsets for copying, in
  1648.          bits.  */
  1649.       this_size_bits = p->size;
  1650.       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
  1651.         {
  1652.           bits_to_skip -= this_size_bits;
  1653.           continue;
  1654.         }
  1655.       if (bits_to_skip > 0)
  1656.         {
  1657.           dest_offset_bits = 0;
  1658.           source_offset_bits = bits_to_skip;
  1659.           this_size_bits -= bits_to_skip;
  1660.           bits_to_skip = 0;
  1661.         }
  1662.       else
  1663.         {
  1664.           dest_offset_bits = offset;
  1665.           source_offset_bits = 0;
  1666.         }
  1667.       if (this_size_bits > type_len - offset)
  1668.         this_size_bits = type_len - offset;

  1670.       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
  1671.       source_offset = source_offset_bits / 8;
  1672.       if (buffer_size < this_size)
  1673.         {
  1674.           buffer_size = this_size;
  1675.           buffer = xrealloc (buffer, buffer_size);
  1676.         }
  1677.       intermediate_buffer = buffer;

  1679.       /* Copy from the source to DEST_BUFFER.  */
  1680.       switch (p->location)
  1681.         {
  1682.         case DWARF_VALUE_REGISTER:
  1683.           {
  1684.             struct gdbarch *arch = get_frame_arch (frame);
  1685.             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);

  1687.             if (gdb_regnum != -1)
  1688.               {
  1689.                 int optim, unavail;
  1690.                 int reg_offset = source_offset;

  1692.                 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
  1693.                     && this_size < register_size (arch, gdb_regnum))
  1694.                   {
  1695.                     /* Big-endian, and we want less than full size.  */
  1696.                     reg_offset = register_size (arch, gdb_regnum) - this_size;
  1697.                     /* We want the lower-order THIS_SIZE_BITS of the bytes
  1698.                        we extract from the register.  */
  1699.                     source_offset_bits += 8 * this_size - this_size_bits;
  1700.                  }

  1702.                 if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
  1703.                                                this_size, buffer,
  1704.                                                &optim, &unavail))
  1705.                   {
  1706.                     /* Just so garbage doesn't ever shine through.  */
  1707.                     memset (buffer, 0, this_size);

  1709.                     if (optim)
  1710.                       mark_value_bits_optimized_out (v, offset, this_size_bits);
  1711.                     if (unavail)
  1712.                       mark_value_bits_unavailable (v, offset, this_size_bits);
  1713.                   }
  1714.               }
  1715.             else
  1716.               {
  1717.                 error (_("Unable to access DWARF register number %s"),
  1718.                        paddress (arch, p->v.regno));
  1719.               }
  1720.           }
  1721.           break;

  1723.         case DWARF_VALUE_MEMORY:
  1724.           read_value_memory (v, offset,
  1725.                              p->v.mem.in_stack_memory,
  1726.                              p->v.mem.addr + source_offset,
  1727.                              buffer, this_size);
  1728.           break;

  1730.         case DWARF_VALUE_STACK:
  1731.           {
  1732.             size_t n = this_size;

  1734.             if (n > c->addr_size - source_offset)
  1735.               n = (c->addr_size >= source_offset
  1736.                    ? c->addr_size - source_offset
  1737.                    : 0);
  1738.             if (n == 0)
  1739.               {
  1740.                 /* Nothing.  */
  1741.               }
  1742.             else
  1743.               {
  1744.                 const gdb_byte *val_bytes = value_contents_all (p->v.value);

  1746.                 intermediate_buffer = val_bytes + source_offset;
  1747.               }
  1748.           }
  1749.           break;

  1751.         case DWARF_VALUE_LITERAL:
  1752.           {
  1753.             size_t n = this_size;

  1755.             if (n > p->v.literal.length - source_offset)
  1756.               n = (p->v.literal.length >= source_offset
  1757.                    ? p->v.literal.length - source_offset
  1758.                    : 0);
  1759.             if (n != 0)
  1760.               intermediate_buffer = p->v.literal.data + source_offset;
  1761.           }
  1762.           break;

  1764.           /* These bits show up as zeros -- but do not cause the value
  1765.              to be considered optimized-out.  */
  1766.         case DWARF_VALUE_IMPLICIT_POINTER:
  1767.           break;

  1769.         case DWARF_VALUE_OPTIMIZED_OUT:
  1770.           mark_value_bits_optimized_out (v, offset, this_size_bits);
  1771.           break;

  1773.         default:
  1774.           internal_error (__FILE__, __LINE__, _("invalid location type"));
  1775.         }

  1777.       if (p->location != DWARF_VALUE_OPTIMIZED_OUT
  1778.           && p->location != DWARF_VALUE_IMPLICIT_POINTER)
  1779.         copy_bitwise (contents, dest_offset_bits,
  1780.                       intermediate_buffer, source_offset_bits % 8,
  1781.                       this_size_bits, bits_big_endian);

  1783.       offset += this_size_bits;
  1784.     }

  1786.   do_cleanups (cleanup);
  1787. }

  1789. static void
  1790. ‌write_pieced_value (struct value *to, struct value *from)
  1791. {
  1792.   int i;
  1793.   long offset = 0;
  1794.   ULONGEST bits_to_skip;
  1795.   const gdb_byte *contents;
  1796.   struct piece_closure *c
  1797.     = (struct piece_closure *) value_computed_closure (to);
  1798.   struct frame_info *frame = frame_find_by_id (VALUE_FRAME_ID (to));
  1799.   size_t type_len;
  1800.   size_t buffer_size = 0;
  1801.   gdb_byte *buffer = NULL;
  1802.   struct cleanup *cleanup;
  1803.   int bits_big_endian
  1804.     = gdbarch_bits_big_endian (get_type_arch (value_type (to)));

  1806.   if (frame == NULL)
  1807.     {
  1808.       mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
  1809.       return;
  1810.     }

  1812.   cleanup = make_cleanup (free_current_contents, &buffer);

  1814.   contents = value_contents (from);
  1815.   bits_to_skip = 8 * value_offset (to);
  1816.   if (value_bitsize (to))
  1817.     {
  1818.       bits_to_skip += value_bitpos (to);
  1819.       type_len = value_bitsize (to);
  1820.     }
  1821.   else
  1822.     type_len = 8 * TYPE_LENGTH (value_type (to));

  1824.   for (i = 0; i < c->n_pieces && offset < type_len; i++)
  1825.     {
  1826.       struct dwarf_expr_piece *p = &c->pieces[i];
  1827.       size_t this_size_bits, this_size;
  1828.       long dest_offset_bits, source_offset_bits, dest_offset, source_offset;
  1829.       int need_bitwise;
  1830.       const gdb_byte *source_buffer;

  1832.       this_size_bits = p->size;
  1833.       if (bits_to_skip > 0 && bits_to_skip >= this_size_bits)
  1834.         {
  1835.           bits_to_skip -= this_size_bits;
  1836.           continue;
  1837.         }
  1838.       if (this_size_bits > type_len - offset)
  1839.         this_size_bits = type_len - offset;
  1840.       if (bits_to_skip > 0)
  1841.         {
  1842.           dest_offset_bits = bits_to_skip;
  1843.           source_offset_bits = 0;
  1844.           this_size_bits -= bits_to_skip;
  1845.           bits_to_skip = 0;
  1846.         }
  1847.       else
  1848.         {
  1849.           dest_offset_bits = 0;
  1850.           source_offset_bits = offset;
  1851.         }

  1853.       this_size = (this_size_bits + source_offset_bits % 8 + 7) / 8;
  1854.       source_offset = source_offset_bits / 8;
  1855.       dest_offset = dest_offset_bits / 8;
  1856.       if (dest_offset_bits % 8 == 0 && source_offset_bits % 8 == 0)
  1857.         {
  1858.           source_buffer = contents + source_offset;
  1859.           need_bitwise = 0;
  1860.         }
  1861.       else
  1862.         {
  1863.           if (buffer_size < this_size)
  1864.             {
  1865.               buffer_size = this_size;
  1866.               buffer = xrealloc (buffer, buffer_size);
  1867.             }
  1868.           source_buffer = buffer;
  1869.           need_bitwise = 1;
  1870.         }

  1872.       switch (p->location)
  1873.         {
  1874.         case DWARF_VALUE_REGISTER:
  1875.           {
  1876.             struct gdbarch *arch = get_frame_arch (frame);
  1877.             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, p->v.regno);

  1879.             if (gdb_regnum != -1)
  1880.               {
  1881.                 int reg_offset = dest_offset;

  1883.                 if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG
  1884.                     && this_size <= register_size (arch, gdb_regnum))
  1885.                   {
  1886.                     /* Big-endian, and we want less than full size.  */
  1887.                     reg_offset = register_size (arch, gdb_regnum) - this_size;
  1888.                   }

  1890.                 if (need_bitwise)
  1891.                   {
  1892.                     int optim, unavail;

  1894.                     if (!get_frame_register_bytes (frame, gdb_regnum, reg_offset,
  1895.                                                    this_size, buffer,
  1896.                                                    &optim, &unavail))
  1897.                       {
  1898.                         if (optim)
  1899.                           throw_error (OPTIMIZED_OUT_ERROR,
  1900.                                        _("Can't do read-modify-write to "
  1901.                                          "update bitfield; containing word "
  1902.                                          "has been optimized out"));
  1903.                         if (unavail)
  1904.                           throw_error (NOT_AVAILABLE_ERROR,
  1905.                                        _("Can't do read-modify-write to update "
  1906.                                          "bitfield; containing word "
  1907.                                          "is unavailable"));
  1908.                       }
  1909.                     copy_bitwise (buffer, dest_offset_bits,
  1910.                                   contents, source_offset_bits,
  1911.                                   this_size_bits,
  1912.                                   bits_big_endian);
  1913.                   }

  1915.                 put_frame_register_bytes (frame, gdb_regnum, reg_offset,
  1916.                                           this_size, source_buffer);
  1917.               }
  1918.             else
  1919.               {
  1920.                 error (_("Unable to write to DWARF register number %s"),
  1921.                        paddress (arch, p->v.regno));
  1922.               }
  1923.           }
  1924.           break;
  1925.         case DWARF_VALUE_MEMORY:
  1926.           if (need_bitwise)
  1927.             {
  1928.               /* Only the first and last bytes can possibly have any
  1929.                  bits reused.  */
  1930.               read_memory (p->v.mem.addr + dest_offset, buffer, 1);
  1931.               read_memory (p->v.mem.addr + dest_offset + this_size - 1,
  1932.                            buffer + this_size - 1, 1);
  1933.               copy_bitwise (buffer, dest_offset_bits,
  1934.                             contents, source_offset_bits,
  1935.                             this_size_bits,
  1936.                             bits_big_endian);
  1937.             }

  1939.           write_memory (p->v.mem.addr + dest_offset,
  1940.                         source_buffer, this_size);
  1941.           break;
  1942.         default:
  1943.           mark_value_bytes_optimized_out (to, 0, TYPE_LENGTH (value_type (to)));
  1944.           break;
  1945.         }
  1946.       offset += this_size_bits;
  1947.     }

  1949.   do_cleanups (cleanup);
  1950. }

  1952. /* An implementation of an lval_funcs method to see whether a value is
  1953.    a synthetic pointer.  */

  1955. static int
  1956. ‌check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
  1957.                                 int bit_length)
  1958. {
  1959.   struct piece_closure *c
  1960.     = (struct piece_closure *) value_computed_closure (value);
  1961.   int i;

  1963.   bit_offset += 8 * value_offset (value);
  1964.   if (value_bitsize (value))
  1965.     bit_offset += value_bitpos (value);

  1967.   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
  1968.     {
  1969.       struct dwarf_expr_piece *p = &c->pieces[i];
  1970.       size_t this_size_bits = p->size;

  1972.       if (bit_offset > 0)
  1973.         {
  1974.           if (bit_offset >= this_size_bits)
  1975.             {
  1976.               bit_offset -= this_size_bits;
  1977.               continue;
  1978.             }

  1980.           bit_length -= this_size_bits - bit_offset;
  1981.           bit_offset = 0;
  1982.         }
  1983.       else
  1984.         bit_length -= this_size_bits;

  1986.       if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
  1987.         return 0;
  1988.     }

  1990.   return 1;
  1991. }

  1993. /* A wrapper function for get_frame_address_in_block.  */

  1995. static CORE_ADDR
  1996. ‌get_frame_address_in_block_wrapper (void *baton)
  1997. {
  1998.   return get_frame_address_in_block (baton);
  1999. }

  2001. /* An implementation of an lval_funcs method to indirect through a
  2002.    pointer.  This handles the synthetic pointer case when needed.  */

  2004. static struct value *
  2005. ‌indirect_pieced_value (struct value *value)
  2006. {
  2007.   struct piece_closure *c
  2008.     = (struct piece_closure *) value_computed_closure (value);
  2009.   struct type *type;
  2010.   struct frame_info *frame;
  2011.   struct dwarf2_locexpr_baton baton;
  2012.   int i, bit_offset, bit_length;
  2013.   struct dwarf_expr_piece *piece = NULL;
  2014.   LONGEST byte_offset;
  2015.   enum bfd_endian byte_order;

  2017.   type = check_typedef (value_type (value));
  2018.   if (TYPE_CODE (type) != TYPE_CODE_PTR)
  2019.     return NULL;

  2021.   bit_length = 8 * TYPE_LENGTH (type);
  2022.   bit_offset = 8 * value_offset (value);
  2023.   if (value_bitsize (value))
  2024.     bit_offset += value_bitpos (value);

  2026.   for (i = 0; i < c->n_pieces && bit_length > 0; i++)
  2027.     {
  2028.       struct dwarf_expr_piece *p = &c->pieces[i];
  2029.       size_t this_size_bits = p->size;

  2031.       if (bit_offset > 0)
  2032.         {
  2033.           if (bit_offset >= this_size_bits)
  2034.             {
  2035.               bit_offset -= this_size_bits;
  2036.               continue;
  2037.             }

  2039.           bit_length -= this_size_bits - bit_offset;
  2040.           bit_offset = 0;
  2041.         }
  2042.       else
  2043.         bit_length -= this_size_bits;

  2045.       if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
  2046.         return NULL;

  2048.       if (bit_length != 0)
  2049.         error (_("Invalid use of DW_OP_GNU_implicit_pointer"));

  2051.       piece = p;
  2052.       break;
  2053.     }

  2055.   frame = get_selected_frame (_("No frame selected."));

  2057.   /* This is an offset requested by GDB, such as value subscripts.
  2058.      However, due to how synthetic pointers are implemented, this is
  2059.      always presented to us as a pointer type.  This means we have to
  2060.      sign-extend it manually as appropriate.  Use raw
  2061.      extract_signed_integer directly rather than value_as_address and
  2062.      sign extend afterwards on architectures that would need it
  2063.      (mostly everywhere except MIPS, which has signed addresses) as
  2064.      the later would go through gdbarch_pointer_to_address and thus
  2065.      return a CORE_ADDR with high bits set on architectures that
  2066.      encode address spaces and other things in CORE_ADDR.  */
  2067.   byte_order = gdbarch_byte_order (get_frame_arch (frame));
  2068.   byte_offset = extract_signed_integer (value_contents (value),
  2069.                                         TYPE_LENGTH (type), byte_order);
  2070.   byte_offset += piece->v.ptr.offset;

  2072.   gdb_assert (piece);
  2073.   baton
  2074.     = dwarf2_fetch_die_loc_sect_off (piece->v.ptr.die, c->per_cu,
  2075.                                      get_frame_address_in_block_wrapper,
  2076.                                      frame);

  2078.   if (baton.data != NULL)
  2079.     return dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
  2080.                                           baton.data, baton.size, baton.per_cu,
  2081.                                           byte_offset);

  2083.   {
  2084.     struct obstack temp_obstack;
  2085.     struct cleanup *cleanup;
  2086.     const gdb_byte *bytes;
  2087.     LONGEST len;
  2088.     struct value *result;

  2090.     obstack_init (&temp_obstack);
  2091.     cleanup = make_cleanup_obstack_free (&temp_obstack);

  2093.     bytes = dwarf2_fetch_constant_bytes (piece->v.ptr.die, c->per_cu,
  2094.                                          &temp_obstack, &len);
  2095.     if (bytes == NULL)
  2096.       result = allocate_optimized_out_value (TYPE_TARGET_TYPE (type));
  2097.     else
  2098.       {
  2099.         if (byte_offset < 0
  2100.             || byte_offset + TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > len)
  2101.           invalid_synthetic_pointer ();
  2102.         bytes += byte_offset;
  2103.         result = value_from_contents (TYPE_TARGET_TYPE (type), bytes);
  2104.       }

  2106.     do_cleanups (cleanup);
  2107.     return result;
  2108.   }
  2109. }

  2111. static void *
  2112. ‌copy_pieced_value_closure (const struct value *v)
  2113. {
  2114.   struct piece_closure *c
  2115.     = (struct piece_closure *) value_computed_closure (v);

  2117.   ++c->refc;
  2118.   return c;
  2119. }

  2121. static void
  2122. ‌free_pieced_value_closure (struct value *v)
  2123. {
  2124.   struct piece_closure *c
  2125.     = (struct piece_closure *) value_computed_closure (v);

  2127.   --c->refc;
  2128.   if (c->refc == 0)
  2129.     {
  2130.       int i;

  2132.       for (i = 0; i < c->n_pieces; ++i)
  2133.         if (c->pieces[i].location == DWARF_VALUE_STACK)
  2134.           value_free (c->pieces[i].v.value);

  2136.       xfree (c->pieces);
  2137.       xfree (c);
  2138.     }
  2139. }

  2141. /* Functions for accessing a variable described by DW_OP_piece.  */
  2142. ‌static const struct lval_funcs pieced_value_funcs = {
  2143.   read_pieced_value,
  2144.   write_pieced_value,
  2145.   indirect_pieced_value,
  2146.   NULL,        /* coerce_ref */
  2147.   check_pieced_synthetic_pointer,
  2148.   copy_pieced_value_closure,
  2149.   free_pieced_value_closure
  2150. };

  2152. /* Virtual method table for dwarf2_evaluate_loc_desc_full below.  */

  2154. ‌static const struct dwarf_expr_context_funcs dwarf_expr_ctx_funcs =
  2155. {
  2156.   dwarf_expr_read_addr_from_reg,
  2157.   dwarf_expr_get_reg_value,
  2158.   dwarf_expr_read_mem,
  2159.   dwarf_expr_frame_base,
  2160.   dwarf_expr_frame_cfa,
  2161.   dwarf_expr_frame_pc,
  2162.   dwarf_expr_tls_address,
  2163.   dwarf_expr_dwarf_call,
  2164.   dwarf_expr_get_base_type,
  2165.   dwarf_expr_push_dwarf_reg_entry_value,
  2166.   dwarf_expr_get_addr_index,
  2167.   dwarf_expr_get_obj_addr
  2168. };

  2170. /* Evaluate a location description, starting at DATA and with length
  2171.    SIZE, to find the current location of variable of TYPE in the
  2172.    context of FRAME.  BYTE_OFFSET is applied after the contents are
  2173.    computed.  */

  2175. static struct value *
  2176. ‌dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
  2177.                                const gdb_byte *data, size_t size,
  2178.                                struct dwarf2_per_cu_data *per_cu,
  2179.                                LONGEST byte_offset)
  2180. {
  2181.   struct value *retval;
  2182.   struct dwarf_expr_baton baton;
  2183.   struct dwarf_expr_context *ctx;
  2184.   struct cleanup *old_chain, *value_chain;
  2185.   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
  2186.   volatile struct gdb_exception ex;

  2188.   if (byte_offset < 0)
  2189.     invalid_synthetic_pointer ();

  2191.   if (size == 0)
  2192.     return allocate_optimized_out_value (type);

  2194.   baton.frame = frame;
  2195.   baton.per_cu = per_cu;
  2196.   baton.obj_address = 0;

  2198.   ctx = new_dwarf_expr_context ();
  2199.   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
  2200.   value_chain = make_cleanup_value_free_to_mark (value_mark ());

  2202.   ctx->gdbarch = get_objfile_arch (objfile);
  2203.   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
  2204.   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
  2205.   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
  2206.   ctx->baton = &baton;
  2207.   ctx->funcs = &dwarf_expr_ctx_funcs;

  2209.   TRY_CATCH (ex, RETURN_MASK_ERROR)
  2210.     {
  2211.       dwarf_expr_eval (ctx, data, size);
  2212.     }
  2213.   if (ex.reason < 0)
  2214.     {
  2215.       if (ex.error == NOT_AVAILABLE_ERROR)
  2216.         {
  2217.           do_cleanups (old_chain);
  2218.           retval = allocate_value (type);
  2219.           mark_value_bytes_unavailable (retval, 0, TYPE_LENGTH (type));
  2220.           return retval;
  2221.         }
  2222.       else if (ex.error == NO_ENTRY_VALUE_ERROR)
  2223.         {
  2224.           if (entry_values_debug)
  2225.             exception_print (gdb_stdout, ex);
  2226.           do_cleanups (old_chain);
  2227.           return allocate_optimized_out_value (type);
  2228.         }
  2229.       else
  2230.         throw_exception (ex);
  2231.     }

  2233.   if (ctx->num_pieces > 0)
  2234.     {
  2235.       struct piece_closure *c;
  2236.       struct frame_id frame_id = get_frame_id (frame);
  2237.       ULONGEST bit_size = 0;
  2238.       int i;

  2240.       for (i = 0; i < ctx->num_pieces; ++i)
  2241.         bit_size += ctx->pieces[i].size;
  2242.       if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
  2243.         invalid_synthetic_pointer ();

  2245.       c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
  2246.                                   ctx->addr_size);
  2247.       /* We must clean up the value chain after creating the piece
  2248.          closure but before allocating the result.  */
  2249.       do_cleanups (value_chain);
  2250.       retval = allocate_computed_value (type, &pieced_value_funcs, c);
  2251.       VALUE_FRAME_ID (retval) = frame_id;
  2252.       set_value_offset (retval, byte_offset);
  2253.     }
  2254.   else
  2255.     {
  2256.       switch (ctx->location)
  2257.         {
  2258.         case DWARF_VALUE_REGISTER:
  2259.           {
  2260.             struct gdbarch *arch = get_frame_arch (frame);
  2261.             int dwarf_regnum
  2262.               = longest_to_int (value_as_long (dwarf_expr_fetch (ctx, 0)));
  2263.             int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);

  2265.             if (byte_offset != 0)
  2266.               error (_("cannot use offset on synthetic pointer to register"));
  2267.             do_cleanups (value_chain);
  2268.            if (gdb_regnum == -1)
  2269.               error (_("Unable to access DWARF register number %d"),
  2270.                      dwarf_regnum);
  2271.            retval = value_from_register (type, gdb_regnum, frame);
  2272.            if (value_optimized_out (retval))
  2273.              {
  2274.                struct value *tmp;

  2276.                /* This means the register has undefined value / was
  2277.                   not saved.  As we're computing the location of some
  2278.                   variable etc. in the program, not a value for
  2279.                   inspecting a register ($pc, $sp, etc.), return a
  2280.                   generic optimized out value instead, so that we show
  2281.                   <optimized out> instead of <not saved>.  */
  2282.                do_cleanups (value_chain);
  2283.                tmp = allocate_value (type);
  2284.                value_contents_copy (tmp, 0, retval, 0, TYPE_LENGTH (type));
  2285.                retval = tmp;
  2286.              }
  2287.           }
  2288.           break;

  2290.         case DWARF_VALUE_MEMORY:
  2291.           {
  2292.             CORE_ADDR address = dwarf_expr_fetch_address (ctx, 0);
  2293.             int in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);

  2295.             do_cleanups (value_chain);
  2296.             retval = value_at_lazy (type, address + byte_offset);
  2297.             if (in_stack_memory)
  2298.               set_value_stack (retval, 1);
  2299.           }
  2300.           break;

  2302.         case DWARF_VALUE_STACK:
  2303.           {
  2304.             struct value *value = dwarf_expr_fetch (ctx, 0);
  2305.             gdb_byte *contents;
  2306.             const gdb_byte *val_bytes;
  2307.             size_t n = TYPE_LENGTH (value_type (value));

  2309.             if (byte_offset + TYPE_LENGTH (type) > n)
  2310.               invalid_synthetic_pointer ();

  2312.             val_bytes = value_contents_all (value);
  2313.             val_bytes += byte_offset;
  2314.             n -= byte_offset;

  2316.             /* Preserve VALUE because we are going to free values back
  2317.                to the mark, but we still need the value contents
  2318.                below.  */
  2319.             value_incref (value);
  2320.             do_cleanups (value_chain);
  2321.             make_cleanup_value_free (value);

  2323.             retval = allocate_value (type);
  2324.             contents = value_contents_raw (retval);
  2325.             if (n > TYPE_LENGTH (type))
  2326.               {
  2327.                 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);

  2329.                 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
  2330.                   val_bytes += n - TYPE_LENGTH (type);
  2331.                 n = TYPE_LENGTH (type);
  2332.               }
  2333.             memcpy (contents, val_bytes, n);
  2334.           }
  2335.           break;

  2337.         case DWARF_VALUE_LITERAL:
  2338.           {
  2339.             bfd_byte *contents;
  2340.             const bfd_byte *ldata;
  2341.             size_t n = ctx->len;

  2343.             if (byte_offset + TYPE_LENGTH (type) > n)
  2344.               invalid_synthetic_pointer ();

  2346.             do_cleanups (value_chain);
  2347.             retval = allocate_value (type);
  2348.             contents = value_contents_raw (retval);

  2350.             ldata = ctx->data + byte_offset;
  2351.             n -= byte_offset;

  2353.             if (n > TYPE_LENGTH (type))
  2354.               {
  2355.                 struct gdbarch *objfile_gdbarch = get_objfile_arch (objfile);

  2357.                 if (gdbarch_byte_order (objfile_gdbarch) == BFD_ENDIAN_BIG)
  2358.                   ldata += n - TYPE_LENGTH (type);
  2359.                 n = TYPE_LENGTH (type);
  2360.               }
  2361.             memcpy (contents, ldata, n);
  2362.           }
  2363.           break;

  2365.         case DWARF_VALUE_OPTIMIZED_OUT:
  2366.           do_cleanups (value_chain);
  2367.           retval = allocate_optimized_out_value (type);
  2368.           break;

  2370.           /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
  2371.              operation by execute_stack_op.  */
  2372.         case DWARF_VALUE_IMPLICIT_POINTER:
  2373.           /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
  2374.              it can only be encountered when making a piece.  */
  2375.         default:
  2376.           internal_error (__FILE__, __LINE__, _("invalid location type"));
  2377.         }
  2378.     }

  2380.   set_value_initialized (retval, ctx->initialized);

  2382.   do_cleanups (old_chain);

  2384.   return retval;
  2385. }

  2387. /* The exported interface to dwarf2_evaluate_loc_desc_full; it always
  2388.    passes 0 as the byte_offset.  */

  2390. struct value *
  2391. ‌dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
  2392.                           const gdb_byte *data, size_t size,
  2393.                           struct dwarf2_per_cu_data *per_cu)
  2394. {
  2395.   return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
  2396. }

  2398. /* Evaluates a dwarf expression and stores the result in VAL, expecting
  2399.    that the dwarf expression only produces a single CORE_ADDR.  ADDR is a
  2400.    context (location of a variable) and might be needed to evaluate the
  2401.    location expression.
  2402.    Returns 1 on success, 0 otherwise.   */

  2404. static int
  2405. ‌dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
  2406.                            CORE_ADDR addr,
  2407.                            CORE_ADDR *valp)
  2408. {
  2409.   struct dwarf_expr_context *ctx;
  2410.   struct dwarf_expr_baton baton;
  2411.   struct objfile *objfile;
  2412.   struct cleanup *cleanup;

  2414.   if (dlbaton == NULL || dlbaton->size == 0)
  2415.     return 0;

  2417.   ctx = new_dwarf_expr_context ();
  2418.   cleanup = make_cleanup_free_dwarf_expr_context (ctx);

  2420.   baton.frame = get_selected_frame (NULL);
  2421.   baton.per_cu = dlbaton->per_cu;
  2422.   baton.obj_address = addr;

  2424.   objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);

  2426.   ctx->gdbarch = get_objfile_arch (objfile);
  2427.   ctx->addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
  2428.   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (dlbaton->per_cu);
  2429.   ctx->offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
  2430.   ctx->funcs = &dwarf_expr_ctx_funcs;
  2431.   ctx->baton = &baton;

  2433.   dwarf_expr_eval (ctx, dlbaton->data, dlbaton->size);

  2435.   switch (ctx->location)
  2436.     {
  2437.     case DWARF_VALUE_REGISTER:
  2438.     case DWARF_VALUE_MEMORY:
  2439.     case DWARF_VALUE_STACK:
  2440.       *valp = dwarf_expr_fetch_address (ctx, 0);
  2441.       if (ctx->location == DWARF_VALUE_REGISTER)
  2442.         *valp = dwarf_expr_read_addr_from_reg (&baton, *valp);
  2443.       do_cleanups (cleanup);
  2444.       return 1;
  2445.     case DWARF_VALUE_LITERAL:
  2446.       *valp = extract_signed_integer (ctx->data, ctx->len,
  2447.                                       gdbarch_byte_order (ctx->gdbarch));
  2448.       do_cleanups (cleanup);
  2449.       return 1;
  2450.       /* Unsupported dwarf values.  */
  2451.     case DWARF_VALUE_OPTIMIZED_OUT:
  2452.     case DWARF_VALUE_IMPLICIT_POINTER:
  2453.       break;
  2454.     }

  2456.   do_cleanups (cleanup);
  2457.   return 0;
  2458. }

  2460. /* See dwarf2loc.h.  */

  2462. int
  2463. ‌dwarf2_evaluate_property (const struct dynamic_prop *prop,
  2464.                           CORE_ADDR address, CORE_ADDR *value)
  2465. {
  2466.   if (prop == NULL)
  2467.     return 0;

  2469.   switch (prop->kind)
  2470.     {
  2471.     case PROP_LOCEXPR:
  2472.       {
  2473.         const struct dwarf2_property_baton *baton = prop->data.baton;

  2475.         if (dwarf2_locexpr_baton_eval (&baton->locexpr, address, value))
  2476.           {
  2477.             if (baton->referenced_type)
  2478.               {
  2479.                 struct value *val = value_at (baton->referenced_type, *value);

  2481.                 *value = value_as_address (val);
  2482.               }
  2483.             return 1;
  2484.           }
  2485.       }
  2486.       break;

  2488.     case PROP_LOCLIST:
  2489.       {
  2490.         struct dwarf2_property_baton *baton = prop->data.baton;
  2491.         struct frame_info *frame = get_selected_frame (NULL);
  2492.         CORE_ADDR pc = get_frame_address_in_block (frame);
  2493.         const gdb_byte *data;
  2494.         struct value *val;
  2495.         size_t size;

  2497.         data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
  2498.         if (data != NULL)
  2499.           {
  2500.             val = dwarf2_evaluate_loc_desc (baton->referenced_type, frame, data,
  2501.                                             size, baton->loclist.per_cu);
  2502.             if (!value_optimized_out (val))
  2503.               {
  2504.                 *value = value_as_address (val);
  2505.                 return 1;
  2506.               }
  2507.           }
  2508.       }
  2509.       break;

  2511.     case PROP_CONST:
  2512.       *value = prop->data.const_val;
  2513.       return 1;
  2514.     }

  2516.   return 0;
  2517. }

  2519. /* See dwarf2loc.h.  */

  2521. void
  2522. ‌dwarf2_compile_property_to_c (struct ui_file *stream,
  2523.                               const char *result_name,
  2524.                               struct gdbarch *gdbarch,
  2525.                               unsigned char *registers_used,
  2526.                               const struct dynamic_prop *prop,
  2527.                               CORE_ADDR pc,
  2528.                               struct symbol *sym)
  2529. {
  2530.   struct dwarf2_property_baton *baton = prop->data.baton;
  2531.   const gdb_byte *data;
  2532.   size_t size;
  2533.   struct dwarf2_per_cu_data *per_cu;

  2535.   if (prop->kind == PROP_LOCEXPR)
  2536.     {
  2537.       data = baton->locexpr.data;
  2538.       size = baton->locexpr.size;
  2539.       per_cu = baton->locexpr.per_cu;
  2540.     }
  2541.   else
  2542.     {
  2543.       gdb_assert (prop->kind == PROP_LOCLIST);

  2545.       data = dwarf2_find_location_expression (&baton->loclist, &size, pc);
  2546.       per_cu = baton->loclist.per_cu;
  2547.     }

  2549.   compile_dwarf_bounds_to_c (stream, result_name, prop, sym, pc,
  2550.                              gdbarch, registers_used,
  2551.                              dwarf2_per_cu_addr_size (per_cu),
  2552.                              data, data + size, per_cu);
  2553. }


  2556. /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */

  2558. ‌struct needs_frame_baton
  2559. {
  2560.   int needs_frame;
  2561.   struct dwarf2_per_cu_data *per_cu;
  2562. };

  2564. /* Reads from registers do require a frame.  */
  2565. static CORE_ADDR
  2566. ‌needs_frame_read_addr_from_reg (void *baton, int regnum)
  2567. {
  2568.   struct needs_frame_baton *nf_baton = baton;

  2570.   nf_baton->needs_frame = 1;
  2571.   return 1;
  2572. }

  2574. /* struct dwarf_expr_context_funcs' "get_reg_value" callback:
  2575.    Reads from registers do require a frame.  */

  2577. static struct value *
  2578. ‌needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
  2579. {
  2580.   struct needs_frame_baton *nf_baton = baton;

  2582.   nf_baton->needs_frame = 1;
  2583.   return value_zero (type, not_lval);
  2584. }

  2586. /* Reads from memory do not require a frame.  */
  2587. static void
  2588. ‌needs_frame_read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
  2589. {
  2590.   memset (buf, 0, len);
  2591. }

  2593. /* Frame-relative accesses do require a frame.  */
  2594. static void
  2595. ‌needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
  2596. {
  2597.   static gdb_byte lit0 = DW_OP_lit0;
  2598.   struct needs_frame_baton *nf_baton = baton;

  2600.   *start = &lit0;
  2601.   *length = 1;

  2603.   nf_baton->needs_frame = 1;
  2604. }

  2606. /* CFA accesses require a frame.  */

  2608. static CORE_ADDR
  2609. ‌needs_frame_frame_cfa (void *baton)
  2610. {
  2611.   struct needs_frame_baton *nf_baton = baton;

  2613.   nf_baton->needs_frame = 1;
  2614.   return 1;
  2615. }

  2617. /* Thread-local accesses do require a frame.  */
  2618. static CORE_ADDR
  2619. ‌needs_frame_tls_address (void *baton, CORE_ADDR offset)
  2620. {
  2621.   struct needs_frame_baton *nf_baton = baton;

  2623.   nf_baton->needs_frame = 1;
  2624.   return 1;
  2625. }

  2627. /* Helper interface of per_cu_dwarf_call for dwarf2_loc_desc_needs_frame.  */

  2629. static void
  2630. ‌needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
  2631. {
  2632.   struct needs_frame_baton *nf_baton = ctx->baton;

  2634.   per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
  2635.                      ctx->funcs->get_frame_pc, ctx->baton);
  2636. }

  2638. /* DW_OP_GNU_entry_value accesses require a caller, therefore a frame.  */

  2640. static void
  2641. ‌needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
  2642.                              enum call_site_parameter_kind kind,
  2643.                              union call_site_parameter_u kind_u, int deref_size)
  2644. {
  2645.   struct needs_frame_baton *nf_baton = ctx->baton;

  2647.   nf_baton->needs_frame = 1;

  2649.   /* The expression may require some stub values on DWARF stack.  */
  2650.   dwarf_expr_push_address (ctx, 0, 0);
  2651. }

  2653. /* DW_OP_GNU_addr_index doesn't require a frame.  */

  2655. static CORE_ADDR
  2656. ‌needs_get_addr_index (void *baton, unsigned int index)
  2657. {
  2658.   /* Nothing to do.  */
  2659.   return 1;
  2660. }

  2662. /* DW_OP_push_object_address has a frame already passed through.  */

  2664. static CORE_ADDR
  2665. ‌needs_get_obj_addr (void *baton)
  2666. {
  2667.   /* Nothing to do.  */
  2668.   return 1;
  2669. }

  2671. /* Virtual method table for dwarf2_loc_desc_needs_frame below.  */

  2673. ‌static const struct dwarf_expr_context_funcs needs_frame_ctx_funcs =
  2674. {
  2675.   needs_frame_read_addr_from_reg,
  2676.   needs_frame_get_reg_value,
  2677.   needs_frame_read_mem,
  2678.   needs_frame_frame_base,
  2679.   needs_frame_frame_cfa,
  2680.   needs_frame_frame_cfa,        /* get_frame_pc */
  2681.   needs_frame_tls_address,
  2682.   needs_frame_dwarf_call,
  2683.   NULL,                                /* get_base_type */
  2684.   needs_dwarf_reg_entry_value,
  2685.   needs_get_addr_index,
  2686.   needs_get_obj_addr
  2687. };

  2689. /* Return non-zero iff the location expression at DATA (length SIZE)
  2690.    requires a frame to evaluate.  */

  2692. static int
  2693. ‌dwarf2_loc_desc_needs_frame (const gdb_byte *data, size_t size,
  2694.                              struct dwarf2_per_cu_data *per_cu)
  2695. {
  2696.   struct needs_frame_baton baton;
  2697.   struct dwarf_expr_context *ctx;
  2698.   int in_reg;
  2699.   struct cleanup *old_chain;
  2700.   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);

  2702.   baton.needs_frame = 0;
  2703.   baton.per_cu = per_cu;

  2705.   ctx = new_dwarf_expr_context ();
  2706.   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
  2707.   make_cleanup_value_free_to_mark (value_mark ());

  2709.   ctx->gdbarch = get_objfile_arch (objfile);
  2710.   ctx->addr_size = dwarf2_per_cu_addr_size (per_cu);
  2711.   ctx->ref_addr_size = dwarf2_per_cu_ref_addr_size (per_cu);
  2712.   ctx->offset = dwarf2_per_cu_text_offset (per_cu);
  2713.   ctx->baton = &baton;
  2714.   ctx->funcs = &needs_frame_ctx_funcs;

  2716.   dwarf_expr_eval (ctx, data, size);

  2718.   in_reg = ctx->location == DWARF_VALUE_REGISTER;

  2720.   if (ctx->num_pieces > 0)
  2721.     {
  2722.       int i;

  2724.       /* If the location has several pieces, and any of them are in
  2725.          registers, then we will need a frame to fetch them from.  */
  2726.       for (i = 0; i < ctx->num_pieces; i++)
  2727.         if (ctx->pieces[i].location == DWARF_VALUE_REGISTER)
  2728.           in_reg = 1;
  2729.     }

  2731.   do_cleanups (old_chain);

  2733.   return baton.needs_frame || in_reg;
  2734. }

  2736. /* A helper function that throws an unimplemented error mentioning a
  2737.    given DWARF operator.  */

  2739. static void
  2740. ‌unimplemented (unsigned int op)
  2741. {
  2742.   const char *name = get_DW_OP_name (op);

  2744.   if (name)
  2745.     error (_("DWARF operator %s cannot be translated to an agent expression"),
  2746.            name);
  2747.   else
  2748.     error (_("Unknown DWARF operator 0x%02x cannot be translated "
  2749.              "to an agent expression"),
  2750.            op);
  2751. }

  2753. /* See dwarf2loc.h.  */

  2755. int
  2756. ‌dwarf2_reg_to_regnum_or_error (struct gdbarch *arch, int dwarf_reg)
  2757. {
  2758.   int reg = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_reg);
  2759.   if (reg == -1)
  2760.     error (_("Unable to access DWARF register number %d"), dwarf_reg);
  2761.   return reg;
  2762. }

  2764. /* A helper function that emits an access to memory.  ARCH is the
  2765.    target architecture.  EXPR is the expression which we are building.
  2766.    NBITS is the number of bits we want to read.  This emits the
  2767.    opcodes needed to read the memory and then extract the desired
  2768.    bits.  */

  2770. static void
  2771. ‌access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
  2772. {
  2773.   ULONGEST nbytes = (nbits + 7) / 8;

  2775.   gdb_assert (nbytes > 0 && nbytes <= sizeof (LONGEST));

  2777.   if (expr->tracing)
  2778.     ax_trace_quick (expr, nbytes);

  2780.   if (nbits <= 8)
  2781.     ax_simple (expr, aop_ref8);
  2782.   else if (nbits <= 16)
  2783.     ax_simple (expr, aop_ref16);
  2784.   else if (nbits <= 32)
  2785.     ax_simple (expr, aop_ref32);
  2786.   else
  2787.     ax_simple (expr, aop_ref64);

  2789.   /* If we read exactly the number of bytes we wanted, we're done.  */
  2790.   if (8 * nbytes == nbits)
  2791.     return;

  2793.   if (gdbarch_bits_big_endian (arch))
  2794.     {
  2795.       /* On a bits-big-endian machine, we want the high-order
  2796.          NBITS.  */
  2797.       ax_const_l (expr, 8 * nbytes - nbits);
  2798.       ax_simple (expr, aop_rsh_unsigned);
  2799.     }
  2800.   else
  2801.     {
  2802.       /* On a bits-little-endian box, we want the low-order NBITS.  */
  2803.       ax_zero_ext (expr, nbits);
  2804.     }
  2805. }

  2807. /* A helper function to return the frame's PC.  */

  2809. static CORE_ADDR
  2810. ‌get_ax_pc (void *baton)
  2811. {
  2812.   struct agent_expr *expr = baton;

  2814.   return expr->scope;
  2815. }

  2817. /* Compile a DWARF location expression to an agent expression.

  2819.    EXPR is the agent expression we are building.
  2820.    LOC is the agent value we modify.
  2821.    ARCH is the architecture.
  2822.    ADDR_SIZE is the size of addresses, in bytes.
  2823.    OP_PTR is the start of the location expression.
  2824.    OP_END is one past the last byte of the location expression.

  2826.    This will throw an exception for various kinds of errors -- for
  2827.    example, if the expression cannot be compiled, or if the expression
  2828.    is invalid.  */

  2830. void
  2831. ‌dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
  2832.                            struct gdbarch *arch, unsigned int addr_size,
  2833.                            const gdb_byte *op_ptr, const gdb_byte *op_end,
  2834.                            struct dwarf2_per_cu_data *per_cu)
  2835. {
  2836.   struct cleanup *cleanups;
  2837.   int i, *offsets;
  2838.   VEC(int) *dw_labels = NULL, *patches = NULL;
  2839.   const gdb_byte * const base = op_ptr;
  2840.   const gdb_byte *previous_piece = op_ptr;
  2841.   enum bfd_endian byte_order = gdbarch_byte_order (arch);
  2842.   ULONGEST bits_collected = 0;
  2843.   unsigned int addr_size_bits = 8 * addr_size;
  2844.   int bits_big_endian = gdbarch_bits_big_endian (arch);

  2846.   offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
  2847.   cleanups = make_cleanup (xfree, offsets);

  2849.   for (i = 0; i < op_end - op_ptr; ++i)
  2850.     offsets[i] = -1;

  2852.   make_cleanup (VEC_cleanup (int), &dw_labels);
  2853.   make_cleanup (VEC_cleanup (int), &patches);

  2855.   /* By default we are making an address.  */
  2856.   loc->kind = axs_lvalue_memory;

  2858.   while (op_ptr < op_end)
  2859.     {
  2860.       enum dwarf_location_atom op = *op_ptr;
  2861.       uint64_t uoffset, reg;
  2862.       int64_t offset;
  2863.       int i;

  2865.       offsets[op_ptr - base] = expr->len;
  2866.       ++op_ptr;

  2868.       /* Our basic approach to code generation is to map DWARF
  2869.          operations directly to AX operations.  However, there are
  2870.          some differences.

  2872.          First, DWARF works on address-sized units, but AX always uses
  2873.          LONGEST.  For most operations we simply ignore this
  2874.          difference; instead we generate sign extensions as needed
  2875.          before division and comparison operations.  It would be nice
  2876.          to omit the sign extensions, but there is no way to determine
  2877.          the size of the target's LONGEST.  (This code uses the size
  2878.          of the host LONGEST in some cases -- that is a bug but it is
  2879.          difficult to fix.)

  2881.          Second, some DWARF operations cannot be translated to AX.
  2882.          For these we simply fail.  See
  2883.          http://sourceware.org/bugzilla/show_bug.cgi?id=11662.  */
  2884.       switch (op)
  2885.         {
  2886.         case DW_OP_lit0:
  2887.         case DW_OP_lit1:
  2888.         case DW_OP_lit2:
  2889.         case DW_OP_lit3:
  2890.         case DW_OP_lit4:
  2891.         case DW_OP_lit5:
  2892.         case DW_OP_lit6:
  2893.         case DW_OP_lit7:
  2894.         case DW_OP_lit8:
  2895.         case DW_OP_lit9:
  2896.         case DW_OP_lit10:
  2897.         case DW_OP_lit11:
  2898.         case DW_OP_lit12:
  2899.         case DW_OP_lit13:
  2900.         case DW_OP_lit14:
  2901.         case DW_OP_lit15:
  2902.         case DW_OP_lit16:
  2903.         case DW_OP_lit17:
  2904.         case DW_OP_lit18:
  2905.         case DW_OP_lit19:
  2906.         case DW_OP_lit20:
  2907.         case DW_OP_lit21:
  2908.         case DW_OP_lit22:
  2909.         case DW_OP_lit23:
  2910.         case DW_OP_lit24:
  2911.         case DW_OP_lit25:
  2912.         case DW_OP_lit26:
  2913.         case DW_OP_lit27:
  2914.         case DW_OP_lit28:
  2915.         case DW_OP_lit29:
  2916.         case DW_OP_lit30:
  2917.         case DW_OP_lit31:
  2918.           ax_const_l (expr, op - DW_OP_lit0);
  2919.           break;

  2921.         case DW_OP_addr:
  2922.           uoffset = extract_unsigned_integer (op_ptr, addr_size, byte_order);
  2923.           op_ptr += addr_size;
  2924.           /* Some versions of GCC emit DW_OP_addr before
  2925.              DW_OP_GNU_push_tls_address.  In this case the value is an
  2926.              index, not an address.  We don't support things like
  2927.              branching between the address and the TLS op.  */
  2928.           if (op_ptr >= op_end || *op_ptr != DW_OP_GNU_push_tls_address)
  2929.             uoffset += dwarf2_per_cu_text_offset (per_cu);
  2930.           ax_const_l (expr, uoffset);
  2931.           break;

  2933.         case DW_OP_const1u:
  2934.           ax_const_l (expr, extract_unsigned_integer (op_ptr, 1, byte_order));
  2935.           op_ptr += 1;
  2936.           break;
  2937.         case DW_OP_const1s:
  2938.           ax_const_l (expr, extract_signed_integer (op_ptr, 1, byte_order));
  2939.           op_ptr += 1;
  2940.           break;
  2941.         case DW_OP_const2u:
  2942.           ax_const_l (expr, extract_unsigned_integer (op_ptr, 2, byte_order));
  2943.           op_ptr += 2;
  2944.           break;
  2945.         case DW_OP_const2s:
  2946.           ax_const_l (expr, extract_signed_integer (op_ptr, 2, byte_order));
  2947.           op_ptr += 2;
  2948.           break;
  2949.         case DW_OP_const4u:
  2950.           ax_const_l (expr, extract_unsigned_integer (op_ptr, 4, byte_order));
  2951.           op_ptr += 4;
  2952.           break;
  2953.         case DW_OP_const4s:
  2954.           ax_const_l (expr, extract_signed_integer (op_ptr, 4, byte_order));
  2955.           op_ptr += 4;
  2956.           break;
  2957.         case DW_OP_const8u:
  2958.           ax_const_l (expr, extract_unsigned_integer (op_ptr, 8, byte_order));
  2959.           op_ptr += 8;
  2960.           break;
  2961.         case DW_OP_const8s:
  2962.           ax_const_l (expr, extract_signed_integer (op_ptr, 8, byte_order));
  2963.           op_ptr += 8;
  2964.           break;
  2965.         case DW_OP_constu:
  2966.           op_ptr = safe_read_uleb128 (op_ptr, op_end, &uoffset);
  2967.           ax_const_l (expr, uoffset);
  2968.           break;
  2969.         case DW_OP_consts:
  2970.           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
  2971.           ax_const_l (expr, offset);
  2972.           break;

  2974.         case DW_OP_reg0:
  2975.         case DW_OP_reg1:
  2976.         case DW_OP_reg2:
  2977.         case DW_OP_reg3:
  2978.         case DW_OP_reg4:
  2979.         case DW_OP_reg5:
  2980.         case DW_OP_reg6:
  2981.         case DW_OP_reg7:
  2982.         case DW_OP_reg8:
  2983.         case DW_OP_reg9:
  2984.         case DW_OP_reg10:
  2985.         case DW_OP_reg11:
  2986.         case DW_OP_reg12:
  2987.         case DW_OP_reg13:
  2988.         case DW_OP_reg14:
  2989.         case DW_OP_reg15:
  2990.         case DW_OP_reg16:
  2991.         case DW_OP_reg17:
  2992.         case DW_OP_reg18:
  2993.         case DW_OP_reg19:
  2994.         case DW_OP_reg20:
  2995.         case DW_OP_reg21:
  2996.         case DW_OP_reg22:
  2997.         case DW_OP_reg23:
  2998.         case DW_OP_reg24:
  2999.         case DW_OP_reg25:
  3000.         case DW_OP_reg26:
  3001.         case DW_OP_reg27:
  3002.         case DW_OP_reg28:
  3003.         case DW_OP_reg29:
  3004.         case DW_OP_reg30:
  3005.         case DW_OP_reg31:
  3006.           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
  3007.           loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_reg0);
  3008.           loc->kind = axs_lvalue_register;
  3009.           break;

  3011.         case DW_OP_regx:
  3012.           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
  3013.           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_regx");
  3014.           loc->u.reg = dwarf2_reg_to_regnum_or_error (arch, reg);
  3015.           loc->kind = axs_lvalue_register;
  3016.           break;

  3018.         case DW_OP_implicit_value:
  3019.           {
  3020.             uint64_t len;

  3022.             op_ptr = safe_read_uleb128 (op_ptr, op_end, &len);
  3023.             if (op_ptr + len > op_end)
  3024.               error (_("DW_OP_implicit_value: too few bytes available."));
  3025.             if (len > sizeof (ULONGEST))
  3026.               error (_("Cannot translate DW_OP_implicit_value of %d bytes"),
  3027.                      (int) len);

  3029.             ax_const_l (expr, extract_unsigned_integer (op_ptr, len,
  3030.                                                         byte_order));
  3031.             op_ptr += len;
  3032.             dwarf_expr_require_composition (op_ptr, op_end,
  3033.                                             "DW_OP_implicit_value");

  3035.             loc->kind = axs_rvalue;
  3036.           }
  3037.           break;

  3039.         case DW_OP_stack_value:
  3040.           dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
  3041.           loc->kind = axs_rvalue;
  3042.           break;

  3044.         case DW_OP_breg0:
  3045.         case DW_OP_breg1:
  3046.         case DW_OP_breg2:
  3047.         case DW_OP_breg3:
  3048.         case DW_OP_breg4:
  3049.         case DW_OP_breg5:
  3050.         case DW_OP_breg6:
  3051.         case DW_OP_breg7:
  3052.         case DW_OP_breg8:
  3053.         case DW_OP_breg9:
  3054.         case DW_OP_breg10:
  3055.         case DW_OP_breg11:
  3056.         case DW_OP_breg12:
  3057.         case DW_OP_breg13:
  3058.         case DW_OP_breg14:
  3059.         case DW_OP_breg15:
  3060.         case DW_OP_breg16:
  3061.         case DW_OP_breg17:
  3062.         case DW_OP_breg18:
  3063.         case DW_OP_breg19:
  3064.         case DW_OP_breg20:
  3065.         case DW_OP_breg21:
  3066.         case DW_OP_breg22:
  3067.         case DW_OP_breg23:
  3068.         case DW_OP_breg24:
  3069.         case DW_OP_breg25:
  3070.         case DW_OP_breg26:
  3071.         case DW_OP_breg27:
  3072.         case DW_OP_breg28:
  3073.         case DW_OP_breg29:
  3074.         case DW_OP_breg30:
  3075.         case DW_OP_breg31:
  3076.           op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
  3077.           i = dwarf2_reg_to_regnum_or_error (arch, op - DW_OP_breg0);
  3078.           ax_reg (expr, i);
  3079.           if (offset != 0)
  3080.             {
  3081.               ax_const_l (expr, offset);
  3082.               ax_simple (expr, aop_add);
  3083.             }
  3084.           break;
  3085.         case DW_OP_bregx:
  3086.           {
  3087.             op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
  3088.             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
  3089.             i = dwarf2_reg_to_regnum_or_error (arch, reg);
  3090.             ax_reg (expr, i);
  3091.             if (offset != 0)
  3092.               {
  3093.                 ax_const_l (expr, offset);
  3094.                 ax_simple (expr, aop_add);
  3095.               }
  3096.           }
  3097.           break;
  3098.         case DW_OP_fbreg:
  3099.           {
  3100.             const gdb_byte *datastart;
  3101.             size_t datalen;
  3102.             const struct block *b;
  3103.             struct symbol *framefunc;

  3105.             b = block_for_pc (expr->scope);

  3107.             if (!b)
  3108.               error (_("No block found for address"));

  3110.             framefunc = block_linkage_function (b);

  3112.             if (!framefunc)
  3113.               error (_("No function found for block"));

  3115.             func_get_frame_base_dwarf_block (framefunc, expr->scope,
  3116.                                              &datastart, &datalen);

  3118.             op_ptr = safe_read_sleb128 (op_ptr, op_end, &offset);
  3119.             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size, datastart,
  3120.                                        datastart + datalen, per_cu);
  3121.             if (loc->kind == axs_lvalue_register)
  3122.               require_rvalue (expr, loc);

  3124.             if (offset != 0)
  3125.               {
  3126.                 ax_const_l (expr, offset);
  3127.                 ax_simple (expr, aop_add);
  3128.               }

  3130.             loc->kind = axs_lvalue_memory;
  3131.           }
  3132.           break;

  3134.         case DW_OP_dup:
  3135.           ax_simple (expr, aop_dup);
  3136.           break;

  3138.         case DW_OP_drop:
  3139.           ax_simple (expr, aop_pop);
  3140.           break;

  3142.         case DW_OP_pick:
  3143.           offset = *op_ptr++;
  3144.           ax_pick (expr, offset);
  3145.           break;

  3147.         case DW_OP_swap:
  3148.           ax_simple (expr, aop_swap);
  3149.           break;

  3151.         case DW_OP_over:
  3152.           ax_pick (expr, 1);
  3153.           break;

  3155.         case DW_OP_rot:
  3156.           ax_simple (expr, aop_rot);
  3157.           break;

  3159.         case DW_OP_deref:
  3160.         case DW_OP_deref_size:
  3161.           {
  3162.             int size;

  3164.             if (op == DW_OP_deref_size)
  3165.               size = *op_ptr++;
  3166.             else
  3167.               size = addr_size;

  3169.             if (size != 1 && size != 2 && size != 4 && size != 8)
  3170.               error (_("Unsupported size %d in %s"),
  3171.                      size, get_DW_OP_name (op));
  3172.             access_memory (arch, expr, size * TARGET_CHAR_BIT);
  3173.           }
  3174.           break;

  3176.         case DW_OP_abs:
  3177.           /* Sign extend the operand.  */
  3178.           ax_ext (expr, addr_size_bits);
  3179.           ax_simple (expr, aop_dup);
  3180.           ax_const_l (expr, 0);
  3181.           ax_simple (expr, aop_less_signed);
  3182.           ax_simple (expr, aop_log_not);
  3183.           i = ax_goto (expr, aop_if_goto);
  3184.           /* We have to emit 0 - X.  */
  3185.           ax_const_l (expr, 0);
  3186.           ax_simple (expr, aop_swap);
  3187.           ax_simple (expr, aop_sub);
  3188.           ax_label (expr, i, expr->len);
  3189.           break;

  3191.         case DW_OP_neg:
  3192.           /* No need to sign extend here.  */
  3193.           ax_const_l (expr, 0);
  3194.           ax_simple (expr, aop_swap);
  3195.           ax_simple (expr, aop_sub);
  3196.           break;

  3198.         case DW_OP_not:
  3199.           /* Sign extend the operand.  */
  3200.           ax_ext (expr, addr_size_bits);
  3201.           ax_simple (expr, aop_bit_not);
  3202.           break;

  3204.         case DW_OP_plus_uconst:
  3205.           op_ptr = safe_read_uleb128 (op_ptr, op_end, &reg);
  3206.           /* It would be really weird to emit `DW_OP_plus_uconst 0',
  3207.              but we micro-optimize anyhow.  */
  3208.           if (reg != 0)
  3209.             {
  3210.               ax_const_l (expr, reg);
  3211.               ax_simple (expr, aop_add);
  3212.             }
  3213.           break;

  3215.         case DW_OP_and:
  3216.           ax_simple (expr, aop_bit_and);
  3217.           break;

  3219.         case DW_OP_div:
  3220.           /* Sign extend the operands.  */
  3221.           ax_ext (expr, addr_size_bits);
  3222.           ax_simple (expr, aop_swap);
  3223.           ax_ext (expr, addr_size_bits);
  3224.           ax_simple (expr, aop_swap);
  3225.           ax_simple (expr, aop_div_signed);
  3226.           break;

  3228.         case DW_OP_minus:
  3229.           ax_simple (expr, aop_sub);
  3230.           break;

  3232.         case DW_OP_mod:
  3233.           ax_simple (expr, aop_rem_unsigned);
  3234.           break;

  3236.         case DW_OP_mul:
  3237.           ax_simple (expr, aop_mul);
  3238.           break;

  3240.         case DW_OP_or:
  3241.           ax_simple (expr, aop_bit_or);
  3242.           break;

  3244.         case DW_OP_plus:
  3245.           ax_simple (expr, aop_add);
  3246.           break;

  3248.         case DW_OP_shl:
  3249.           ax_simple (expr, aop_lsh);
  3250.           break;

  3252.         case DW_OP_shr:
  3253.           ax_simple (expr, aop_rsh_unsigned);
  3254.           break;

  3256.         case DW_OP_shra:
  3257.           ax_simple (expr, aop_rsh_signed);
  3258.           break;

  3260.         case DW_OP_xor:
  3261.           ax_simple (expr, aop_bit_xor);
  3262.           break;

  3264.         case DW_OP_le:
  3265.           /* Sign extend the operands.  */
  3266.           ax_ext (expr, addr_size_bits);
  3267.           ax_simple (expr, aop_swap);
  3268.           ax_ext (expr, addr_size_bits);
  3269.           /* Note no swap here: A <= B is !(B < A).  */
  3270.           ax_simple (expr, aop_less_signed);
  3271.           ax_simple (expr, aop_log_not);
  3272.           break;

  3274.         case DW_OP_ge:
  3275.           /* Sign extend the operands.  */
  3276.           ax_ext (expr, addr_size_bits);
  3277.           ax_simple (expr, aop_swap);
  3278.           ax_ext (expr, addr_size_bits);
  3279.           ax_simple (expr, aop_swap);
  3280.           /* A >= B is !(A < B).  */
  3281.           ax_simple (expr, aop_less_signed);
  3282.           ax_simple (expr, aop_log_not);
  3283.           break;

  3285.         case DW_OP_eq:
  3286.           /* Sign extend the operands.  */
  3287.           ax_ext (expr, addr_size_bits);
  3288.           ax_simple (expr, aop_swap);
  3289.           ax_ext (expr, addr_size_bits);
  3290.           /* No need for a second swap here.  */
  3291.           ax_simple (expr, aop_equal);
  3292.           break;

  3294.         case DW_OP_lt:
  3295.           /* Sign extend the operands.  */
  3296.           ax_ext (expr, addr_size_bits);
  3297.           ax_simple (expr, aop_swap);
  3298.           ax_ext (expr, addr_size_bits);
  3299.           ax_simple (expr, aop_swap);
  3300.           ax_simple (expr, aop_less_signed);
  3301.           break;

  3303.         case DW_OP_gt:
  3304.           /* Sign extend the operands.  */
  3305.           ax_ext (expr, addr_size_bits);
  3306.           ax_simple (expr, aop_swap);
  3307.           ax_ext (expr, addr_size_bits);
  3308.           /* Note no swap here: A > B is B < A.  */
  3309.           ax_simple (expr, aop_less_signed);
  3310.           break;

  3312.         case DW_OP_ne:
  3313.           /* Sign extend the operands.  */
  3314.           ax_ext (expr, addr_size_bits);
  3315.           ax_simple (expr, aop_swap);
  3316.           ax_ext (expr, addr_size_bits);
  3317.           /* No need for a swap here.  */
  3318.           ax_simple (expr, aop_equal);
  3319.           ax_simple (expr, aop_log_not);
  3320.           break;

  3322.         case DW_OP_call_frame_cfa:
  3323.           {
  3324.             int regnum;
  3325.             CORE_ADDR text_offset;
  3326.             LONGEST off;
  3327.             const gdb_byte *cfa_start, *cfa_end;

  3329.             if (dwarf2_fetch_cfa_info (arch, expr->scope, per_cu,
  3330.                                        &regnum, &off,
  3331.                                        &text_offset, &cfa_start, &cfa_end))
  3332.               {
  3333.                 /* Register.  */
  3334.                 ax_reg (expr, regnum);
  3335.                 if (off != 0)
  3336.                   {
  3337.                     ax_const_l (expr, off);
  3338.                     ax_simple (expr, aop_add);
  3339.                   }
  3340.               }
  3341.             else
  3342.               {
  3343.                 /* Another expression.  */
  3344.                 ax_const_l (expr, text_offset);
  3345.                 dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
  3346.                                            cfa_start, cfa_end, per_cu);
  3347.               }

  3349.             loc->kind = axs_lvalue_memory;
  3350.           }
  3351.           break;

  3353.         case DW_OP_GNU_push_tls_address:
  3354.           unimplemented (op);
  3355.           break;

  3357.         case DW_OP_push_object_address:
  3358.           unimplemented (op);
  3359.           break;

  3361.         case DW_OP_skip:
  3362.           offset = extract_signed_integer (op_ptr, 2, byte_order);
  3363.           op_ptr += 2;
  3364.           i = ax_goto (expr, aop_goto);
  3365.           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
  3366.           VEC_safe_push (int, patches, i);
  3367.           break;

  3369.         case DW_OP_bra:
  3370.           offset = extract_signed_integer (op_ptr, 2, byte_order);
  3371.           op_ptr += 2;
  3372.           /* Zero extend the operand.  */
  3373.           ax_zero_ext (expr, addr_size_bits);
  3374.           i = ax_goto (expr, aop_if_goto);
  3375.           VEC_safe_push (int, dw_labels, op_ptr + offset - base);
  3376.           VEC_safe_push (int, patches, i);
  3377.           break;

  3379.         case DW_OP_nop:
  3380.           break;

  3382.         case DW_OP_piece:
  3383.         case DW_OP_bit_piece:
  3384.           {
  3385.             uint64_t size, offset;

  3387.             if (op_ptr - 1 == previous_piece)
  3388.               error (_("Cannot translate empty pieces to agent expressions"));
  3389.             previous_piece = op_ptr - 1;

  3391.             op_ptr = safe_read_uleb128 (op_ptr, op_end, &size);
  3392.             if (op == DW_OP_piece)
  3393.               {
  3394.                 size *= 8;
  3395.                 offset = 0;
  3396.               }
  3397.             else
  3398.               op_ptr = safe_read_uleb128 (op_ptr, op_end, &offset);

  3400.             if (bits_collected + size > 8 * sizeof (LONGEST))
  3401.               error (_("Expression pieces exceed word size"));

  3403.             /* Access the bits.  */
  3404.             switch (loc->kind)
  3405.               {
  3406.               case axs_lvalue_register:
  3407.                 ax_reg (expr, loc->u.reg);
  3408.                 break;

  3410.               case axs_lvalue_memory:
  3411.                 /* Offset the pointer, if needed.  */
  3412.                 if (offset > 8)
  3413.                   {
  3414.                     ax_const_l (expr, offset / 8);
  3415.                     ax_simple (expr, aop_add);
  3416.                     offset %= 8;
  3417.                   }
  3418.                 access_memory (arch, expr, size);
  3419.                 break;
  3420.               }

  3422.             /* For a bits-big-endian target, shift up what we already
  3423.                have.  For a bits-little-endian target, shift up the
  3424.                new data.  Note that there is a potential bug here if
  3425.                the DWARF expression leaves multiple values on the
  3426.                stack.  */
  3427.             if (bits_collected > 0)
  3428.               {
  3429.                 if (bits_big_endian)
  3430.                   {
  3431.                     ax_simple (expr, aop_swap);
  3432.                     ax_const_l (expr, size);
  3433.                     ax_simple (expr, aop_lsh);
  3434.                     /* We don't need a second swap here, because
  3435.                        aop_bit_or is symmetric.  */
  3436.                   }
  3437.                 else
  3438.                   {
  3439.                     ax_const_l (expr, size);
  3440.                     ax_simple (expr, aop_lsh);
  3441.                   }
  3442.                 ax_simple (expr, aop_bit_or);
  3443.               }

  3445.             bits_collected += size;
  3446.             loc->kind = axs_rvalue;
  3447.           }
  3448.           break;

  3450.         case DW_OP_GNU_uninit:
  3451.           unimplemented (op);

  3453.         case DW_OP_call2:
  3454.         case DW_OP_call4:
  3455.           {
  3456.             struct dwarf2_locexpr_baton block;
  3457.             int size = (op == DW_OP_call2 ? 2 : 4);
  3458.             cu_offset offset;

  3460.             uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
  3461.             op_ptr += size;

  3463.             offset.cu_off = uoffset;
  3464.             block = dwarf2_fetch_die_loc_cu_off (offset, per_cu,
  3465.                                                  get_ax_pc, expr);

  3467.             /* DW_OP_call_ref is currently not supported.  */
  3468.             gdb_assert (block.per_cu == per_cu);

  3470.             dwarf2_compile_expr_to_ax (expr, loc, arch, addr_size,
  3471.                                        block.data, block.data + block.size,
  3472.                                        per_cu);
  3473.           }
  3474.           break;

  3476.         case DW_OP_call_ref:
  3477.           unimplemented (op);

  3479.         default:
  3480.           unimplemented (op);
  3481.         }
  3482.     }

  3484.   /* Patch all the branches we emitted.  */
  3485.   for (i = 0; i < VEC_length (int, patches); ++i)
  3486.     {
  3487.       int targ = offsets[VEC_index (int, dw_labels, i)];
  3488.       if (targ == -1)
  3489.         internal_error (__FILE__, __LINE__, _("invalid label"));
  3490.       ax_label (expr, VEC_index (int, patches, i), targ);
  3491.     }

  3493.   do_cleanups (cleanups);
  3494. }


  3497. /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
  3498.    evaluator to calculate the location.  */
  3499. static struct value *
  3500. ‌locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
  3501. {
  3502.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  3503.   struct value *val;

  3505.   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
  3506.                                   dlbaton->size, dlbaton->per_cu);

  3508.   return val;
  3509. }

  3511. /* Return the value of SYMBOL in FRAME at (callee) FRAME's function
  3512.    entry.  SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
  3513.    will be thrown.  */

  3515. static struct value *
  3516. ‌locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
  3517. {
  3518.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

  3520.   return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
  3521.                                      dlbaton->size);
  3522. }

  3524. /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
  3525. static int
  3526. ‌locexpr_read_needs_frame (struct symbol *symbol)
  3527. {
  3528.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);

  3530.   return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
  3531.                                       dlbaton->per_cu);
  3532. }

  3534. /* Return true if DATA points to the end of a piece.  END is one past
  3535.    the last byte in the expression.  */

  3537. static int
  3538. ‌piece_end_p (const gdb_byte *data, const gdb_byte *end)
  3539. {
  3540.   return data == end || data[0] == DW_OP_piece || data[0] == DW_OP_bit_piece;
  3541. }

  3543. /* Helper for locexpr_describe_location_piece that finds the name of a
  3544.    DWARF register.  */

  3546. static const char *
  3547. ‌locexpr_regname (struct gdbarch *gdbarch, int dwarf_regnum)
  3548. {
  3549.   int regnum;

  3551.   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, dwarf_regnum);
  3552.   return gdbarch_register_name (gdbarch, regnum);
  3553. }

  3555. /* Nicely describe a single piece of a location, returning an updated
  3556.    position in the bytecode sequence.  This function cannot recognize
  3557.    all locations; if a location is not recognized, it simply returns
  3558.    DATA.  If there is an error during reading, e.g. we run off the end
  3559.    of the buffer, an error is thrown.  */

  3561. static const gdb_byte *
  3562. ‌locexpr_describe_location_piece (struct symbol *symbol, struct ui_file *stream,
  3563.                                  CORE_ADDR addr, struct objfile *objfile,
  3564.                                  struct dwarf2_per_cu_data *per_cu,
  3565.                                  const gdb_byte *data, const gdb_byte *end,
  3566.                                  unsigned int addr_size)
  3567. {
  3568.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  3569.   size_t leb128_size;

  3571.   if (data[0] >= DW_OP_reg0 && data[0] <= DW_OP_reg31)
  3572.     {
  3573.       fprintf_filtered (stream, _("a variable in $%s"),
  3574.                         locexpr_regname (gdbarch, data[0] - DW_OP_reg0));
  3575.       data += 1;
  3576.     }
  3577.   else if (data[0] == DW_OP_regx)
  3578.     {
  3579.       uint64_t reg;

  3581.       data = safe_read_uleb128 (data + 1, end, &reg);
  3582.       fprintf_filtered (stream, _("a variable in $%s"),
  3583.                         locexpr_regname (gdbarch, reg));
  3584.     }
  3585.   else if (data[0] == DW_OP_fbreg)
  3586.     {
  3587.       const struct block *b;
  3588.       struct symbol *framefunc;
  3589.       int frame_reg = 0;
  3590.       int64_t frame_offset;
  3591.       const gdb_byte *base_data, *new_data, *save_data = data;
  3592.       size_t base_size;
  3593.       int64_t base_offset = 0;

  3595.       new_data = safe_read_sleb128 (data + 1, end, &frame_offset);
  3596.       if (!piece_end_p (new_data, end))
  3597.         return data;
  3598.       data = new_data;

  3600.       b = block_for_pc (addr);

  3602.       if (!b)
  3603.         error (_("No block found for address for symbol \"%s\"."),
  3604.                SYMBOL_PRINT_NAME (symbol));

  3606.       framefunc = block_linkage_function (b);

  3608.       if (!framefunc)
  3609.         error (_("No function found for block for symbol \"%s\"."),
  3610.                SYMBOL_PRINT_NAME (symbol));

  3612.       func_get_frame_base_dwarf_block (framefunc, addr, &base_data, &base_size);

  3614.       if (base_data[0] >= DW_OP_breg0 && base_data[0] <= DW_OP_breg31)
  3615.         {
  3616.           const gdb_byte *buf_end;

  3618.           frame_reg = base_data[0] - DW_OP_breg0;
  3619.           buf_end = safe_read_sleb128 (base_data + 1, base_data + base_size,
  3620.                                        &base_offset);
  3621.           if (buf_end != base_data + base_size)
  3622.             error (_("Unexpected opcode after "
  3623.                      "DW_OP_breg%u for symbol \"%s\"."),
  3624.                    frame_reg, SYMBOL_PRINT_NAME (symbol));
  3625.         }
  3626.       else if (base_data[0] >= DW_OP_reg0 && base_data[0] <= DW_OP_reg31)
  3627.         {
  3628.           /* The frame base is just the register, with no offset.  */
  3629.           frame_reg = base_data[0] - DW_OP_reg0;
  3630.           base_offset = 0;
  3631.         }
  3632.       else
  3633.         {
  3634.           /* We don't know what to do with the frame base expression,
  3635.              so we can't trace this variable; give up.  */
  3636.           return save_data;
  3637.         }

  3639.       fprintf_filtered (stream,
  3640.                         _("a variable at frame base reg $%s offset %s+%s"),
  3641.                         locexpr_regname (gdbarch, frame_reg),
  3642.                         plongest (base_offset), plongest (frame_offset));
  3643.     }
  3644.   else if (data[0] >= DW_OP_breg0 && data[0] <= DW_OP_breg31
  3645.            && piece_end_p (data, end))
  3646.     {
  3647.       int64_t offset;

  3649.       data = safe_read_sleb128 (data + 1, end, &offset);

  3651.       fprintf_filtered (stream,
  3652.                         _("a variable at offset %s from base reg $%s"),
  3653.                         plongest (offset),
  3654.                         locexpr_regname (gdbarch, data[0] - DW_OP_breg0));
  3655.     }

  3657.   /* The location expression for a TLS variable looks like this (on a
  3658.      64-bit LE machine):

  3660.      DW_AT_location    : 10 byte block: 3 4 0 0 0 0 0 0 0 e0
  3661.                         (DW_OP_addr: 4; DW_OP_GNU_push_tls_address)

  3663.      0x3 is the encoding for DW_OP_addr, which has an operand as long
  3664.      as the size of an address on the target machine (here is 8
  3665.      bytes).  Note that more recent version of GCC emit DW_OP_const4u
  3666.      or DW_OP_const8u, depending on address size, rather than
  3667.      DW_OP_addr.  0xe0 is the encoding for DW_OP_GNU_push_tls_address.
  3668.      The operand represents the offset at which the variable is within
  3669.      the thread local storage.  */

  3671.   else if (data + 1 + addr_size < end
  3672.            && (data[0] == DW_OP_addr
  3673.                || (addr_size == 4 && data[0] == DW_OP_const4u)
  3674.                || (addr_size == 8 && data[0] == DW_OP_const8u))
  3675.            && data[1 + addr_size] == DW_OP_GNU_push_tls_address
  3676.            && piece_end_p (data + 2 + addr_size, end))
  3677.     {
  3678.       ULONGEST offset;
  3679.       offset = extract_unsigned_integer (data + 1, addr_size,
  3680.                                          gdbarch_byte_order (gdbarch));

  3682.       fprintf_filtered (stream,
  3683.                         _("a thread-local variable at offset 0x%s "
  3684.                           "in the thread-local storage for `%s'"),
  3685.                         phex_nz (offset, addr_size), objfile_name (objfile));

  3687.       data += 1 + addr_size + 1;
  3688.     }

  3690.   /* With -gsplit-dwarf a TLS variable can also look like this:
  3691.      DW_AT_location    : 3 byte block: fc 4 e0
  3692.                         (DW_OP_GNU_const_index: 4;
  3693.                          DW_OP_GNU_push_tls_address)  */
  3694.   else if (data + 3 <= end
  3695.            && data + 1 + (leb128_size = skip_leb128 (data + 1, end)) < end
  3696.            && data[0] == DW_OP_GNU_const_index
  3697.            && leb128_size > 0
  3698.            && data[1 + leb128_size] == DW_OP_GNU_push_tls_address
  3699.            && piece_end_p (data + 2 + leb128_size, end))
  3700.     {
  3701.       uint64_t offset;

  3703.       data = safe_read_uleb128 (data + 1, end, &offset);
  3704.       offset = dwarf2_read_addr_index (per_cu, offset);
  3705.       fprintf_filtered (stream,
  3706.                         _("a thread-local variable at offset 0x%s "
  3707.                           "in the thread-local storage for `%s'"),
  3708.                         phex_nz (offset, addr_size), objfile_name (objfile));
  3709.       ++data;
  3710.     }

  3712.   else if (data[0] >= DW_OP_lit0
  3713.            && data[0] <= DW_OP_lit31
  3714.            && data + 1 < end
  3715.            && data[1] == DW_OP_stack_value)
  3716.     {
  3717.       fprintf_filtered (stream, _("the constant %d"), data[0] - DW_OP_lit0);
  3718.       data += 2;
  3719.     }

  3721.   return data;
  3722. }

  3724. /* Disassemble an expression, stopping at the end of a piece or at the
  3725.    end of the expression.  Returns a pointer to the next unread byte
  3726.    in the input expression.  If ALL is nonzero, then this function
  3727.    will keep going until it reaches the end of the expression.
  3728.    If there is an error during reading, e.g. we run off the end
  3729.    of the buffer, an error is thrown.  */

  3731. static const gdb_byte *
  3732. ‌disassemble_dwarf_expression (struct ui_file *stream,
  3733.                               struct gdbarch *arch, unsigned int addr_size,
  3734.                               int offset_size, const gdb_byte *start,
  3735.                               const gdb_byte *data, const gdb_byte *end,
  3736.                               int indent, int all,
  3737.                               struct dwarf2_per_cu_data *per_cu)
  3738. {
  3739.   while (data < end
  3740.          && (all
  3741.              || (data[0] != DW_OP_piece && data[0] != DW_OP_bit_piece)))
  3742.     {
  3743.       enum dwarf_location_atom op = *data++;
  3744.       uint64_t ul;
  3745.       int64_t l;
  3746.       const char *name;

  3748.       name = get_DW_OP_name (op);

  3750.       if (!name)
  3751.         error (_("Unrecognized DWARF opcode 0x%02x at %ld"),
  3752.                op, (long) (data - 1 - start));
  3753.       fprintf_filtered (stream, "  %*ld: %s", indent + 4,
  3754.                         (long) (data - 1 - start), name);

  3756.       switch (op)
  3757.         {
  3758.         case DW_OP_addr:
  3759.           ul = extract_unsigned_integer (data, addr_size,
  3760.                                          gdbarch_byte_order (arch));
  3761.           data += addr_size;
  3762.           fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
  3763.           break;

  3765.         case DW_OP_const1u:
  3766.           ul = extract_unsigned_integer (data, 1, gdbarch_byte_order (arch));
  3767.           data += 1;
  3768.           fprintf_filtered (stream, " %s", pulongest (ul));
  3769.           break;
  3770.         case DW_OP_const1s:
  3771.           l = extract_signed_integer (data, 1, gdbarch_byte_order (arch));
  3772.           data += 1;
  3773.           fprintf_filtered (stream, " %s", plongest (l));
  3774.           break;
  3775.         case DW_OP_const2u:
  3776.           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
  3777.           data += 2;
  3778.           fprintf_filtered (stream, " %s", pulongest (ul));
  3779.           break;
  3780.         case DW_OP_const2s:
  3781.           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
  3782.           data += 2;
  3783.           fprintf_filtered (stream, " %s", plongest (l));
  3784.           break;
  3785.         case DW_OP_const4u:
  3786.           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
  3787.           data += 4;
  3788.           fprintf_filtered (stream, " %s", pulongest (ul));
  3789.           break;
  3790.         case DW_OP_const4s:
  3791.           l = extract_signed_integer (data, 4, gdbarch_byte_order (arch));
  3792.           data += 4;
  3793.           fprintf_filtered (stream, " %s", plongest (l));
  3794.           break;
  3795.         case DW_OP_const8u:
  3796.           ul = extract_unsigned_integer (data, 8, gdbarch_byte_order (arch));
  3797.           data += 8;
  3798.           fprintf_filtered (stream, " %s", pulongest (ul));
  3799.           break;
  3800.         case DW_OP_const8s:
  3801.           l = extract_signed_integer (data, 8, gdbarch_byte_order (arch));
  3802.           data += 8;
  3803.           fprintf_filtered (stream, " %s", plongest (l));
  3804.           break;
  3805.         case DW_OP_constu:
  3806.           data = safe_read_uleb128 (data, end, &ul);
  3807.           fprintf_filtered (stream, " %s", pulongest (ul));
  3808.           break;
  3809.         case DW_OP_consts:
  3810.           data = safe_read_sleb128 (data, end, &l);
  3811.           fprintf_filtered (stream, " %s", plongest (l));
  3812.           break;

  3814.         case DW_OP_reg0:
  3815.         case DW_OP_reg1:
  3816.         case DW_OP_reg2:
  3817.         case DW_OP_reg3:
  3818.         case DW_OP_reg4:
  3819.         case DW_OP_reg5:
  3820.         case DW_OP_reg6:
  3821.         case DW_OP_reg7:
  3822.         case DW_OP_reg8:
  3823.         case DW_OP_reg9:
  3824.         case DW_OP_reg10:
  3825.         case DW_OP_reg11:
  3826.         case DW_OP_reg12:
  3827.         case DW_OP_reg13:
  3828.         case DW_OP_reg14:
  3829.         case DW_OP_reg15:
  3830.         case DW_OP_reg16:
  3831.         case DW_OP_reg17:
  3832.         case DW_OP_reg18:
  3833.         case DW_OP_reg19:
  3834.         case DW_OP_reg20:
  3835.         case DW_OP_reg21:
  3836.         case DW_OP_reg22:
  3837.         case DW_OP_reg23:
  3838.         case DW_OP_reg24:
  3839.         case DW_OP_reg25:
  3840.         case DW_OP_reg26:
  3841.         case DW_OP_reg27:
  3842.         case DW_OP_reg28:
  3843.         case DW_OP_reg29:
  3844.         case DW_OP_reg30:
  3845.         case DW_OP_reg31:
  3846.           fprintf_filtered (stream, " [$%s]",
  3847.                             locexpr_regname (arch, op - DW_OP_reg0));
  3848.           break;

  3850.         case DW_OP_regx:
  3851.           data = safe_read_uleb128 (data, end, &ul);
  3852.           fprintf_filtered (stream, " %s [$%s]", pulongest (ul),
  3853.                             locexpr_regname (arch, (int) ul));
  3854.           break;

  3856.         case DW_OP_implicit_value:
  3857.           data = safe_read_uleb128 (data, end, &ul);
  3858.           data += ul;
  3859.           fprintf_filtered (stream, " %s", pulongest (ul));
  3860.           break;

  3862.         case DW_OP_breg0:
  3863.         case DW_OP_breg1:
  3864.         case DW_OP_breg2:
  3865.         case DW_OP_breg3:
  3866.         case DW_OP_breg4:
  3867.         case DW_OP_breg5:
  3868.         case DW_OP_breg6:
  3869.         case DW_OP_breg7:
  3870.         case DW_OP_breg8:
  3871.         case DW_OP_breg9:
  3872.         case DW_OP_breg10:
  3873.         case DW_OP_breg11:
  3874.         case DW_OP_breg12:
  3875.         case DW_OP_breg13:
  3876.         case DW_OP_breg14:
  3877.         case DW_OP_breg15:
  3878.         case DW_OP_breg16:
  3879.         case DW_OP_breg17:
  3880.         case DW_OP_breg18:
  3881.         case DW_OP_breg19:
  3882.         case DW_OP_breg20:
  3883.         case DW_OP_breg21:
  3884.         case DW_OP_breg22:
  3885.         case DW_OP_breg23:
  3886.         case DW_OP_breg24:
  3887.         case DW_OP_breg25:
  3888.         case DW_OP_breg26:
  3889.         case DW_OP_breg27:
  3890.         case DW_OP_breg28:
  3891.         case DW_OP_breg29:
  3892.         case DW_OP_breg30:
  3893.         case DW_OP_breg31:
  3894.           data = safe_read_sleb128 (data, end, &l);
  3895.           fprintf_filtered (stream, " %s [$%s]", plongest (l),
  3896.                             locexpr_regname (arch, op - DW_OP_breg0));
  3897.           break;

  3899.         case DW_OP_bregx:
  3900.           data = safe_read_uleb128 (data, end, &ul);
  3901.           data = safe_read_sleb128 (data, end, &l);
  3902.           fprintf_filtered (stream, " register %s [$%s] offset %s",
  3903.                             pulongest (ul),
  3904.                             locexpr_regname (arch, (int) ul),
  3905.                             plongest (l));
  3906.           break;

  3908.         case DW_OP_fbreg:
  3909.           data = safe_read_sleb128 (data, end, &l);
  3910.           fprintf_filtered (stream, " %s", plongest (l));
  3911.           break;

  3913.         case DW_OP_xderef_size:
  3914.         case DW_OP_deref_size:
  3915.         case DW_OP_pick:
  3916.           fprintf_filtered (stream, " %d", *data);
  3917.           ++data;
  3918.           break;

  3920.         case DW_OP_plus_uconst:
  3921.           data = safe_read_uleb128 (data, end, &ul);
  3922.           fprintf_filtered (stream, " %s", pulongest (ul));
  3923.           break;

  3925.         case DW_OP_skip:
  3926.           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
  3927.           data += 2;
  3928.           fprintf_filtered (stream, " to %ld",
  3929.                             (long) (data + l - start));
  3930.           break;

  3932.         case DW_OP_bra:
  3933.           l = extract_signed_integer (data, 2, gdbarch_byte_order (arch));
  3934.           data += 2;
  3935.           fprintf_filtered (stream, " %ld",
  3936.                             (long) (data + l - start));
  3937.           break;

  3939.         case DW_OP_call2:
  3940.           ul = extract_unsigned_integer (data, 2, gdbarch_byte_order (arch));
  3941.           data += 2;
  3942.           fprintf_filtered (stream, " offset %s", phex_nz (ul, 2));
  3943.           break;

  3945.         case DW_OP_call4:
  3946.           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
  3947.           data += 4;
  3948.           fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
  3949.           break;

  3951.         case DW_OP_call_ref:
  3952.           ul = extract_unsigned_integer (data, offset_size,
  3953.                                          gdbarch_byte_order (arch));
  3954.           data += offset_size;
  3955.           fprintf_filtered (stream, " offset %s", phex_nz (ul, offset_size));
  3956.           break;

  3958.         case DW_OP_piece:
  3959.           data = safe_read_uleb128 (data, end, &ul);
  3960.           fprintf_filtered (stream, " %s (bytes)", pulongest (ul));
  3961.           break;

  3963.         case DW_OP_bit_piece:
  3964.           {
  3965.             uint64_t offset;

  3967.             data = safe_read_uleb128 (data, end, &ul);
  3968.             data = safe_read_uleb128 (data, end, &offset);
  3969.             fprintf_filtered (stream, " size %s offset %s (bits)",
  3970.                               pulongest (ul), pulongest (offset));
  3971.           }
  3972.           break;

  3974.         case DW_OP_GNU_implicit_pointer:
  3975.           {
  3976.             ul = extract_unsigned_integer (data, offset_size,
  3977.                                            gdbarch_byte_order (arch));
  3978.             data += offset_size;

  3980.             data = safe_read_sleb128 (data, end, &l);

  3982.             fprintf_filtered (stream, " DIE %s offset %s",
  3983.                               phex_nz (ul, offset_size),
  3984.                               plongest (l));
  3985.           }
  3986.           break;

  3988.         case DW_OP_GNU_deref_type:
  3989.           {
  3990.             int addr_size = *data++;
  3991.             cu_offset offset;
  3992.             struct type *type;

  3994.             data = safe_read_uleb128 (data, end, &ul);
  3995.             offset.cu_off = ul;
  3996.             type = dwarf2_get_die_type (offset, per_cu);
  3997.             fprintf_filtered (stream, "<");
  3998.             type_print (type, "", stream, -1);
  3999.             fprintf_filtered (stream, " [0x%s]> %d", phex_nz (offset.cu_off, 0),
  4000.                               addr_size);
  4001.           }
  4002.           break;

  4004.         case DW_OP_GNU_const_type:
  4005.           {
  4006.             cu_offset type_die;
  4007.             struct type *type;

  4009.             data = safe_read_uleb128 (data, end, &ul);
  4010.             type_die.cu_off = ul;
  4011.             type = dwarf2_get_die_type (type_die, per_cu);
  4012.             fprintf_filtered (stream, "<");
  4013.             type_print (type, "", stream, -1);
  4014.             fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
  4015.           }
  4016.           break;

  4018.         case DW_OP_GNU_regval_type:
  4019.           {
  4020.             uint64_t reg;
  4021.             cu_offset type_die;
  4022.             struct type *type;

  4024.             data = safe_read_uleb128 (data, end, &reg);
  4025.             data = safe_read_uleb128 (data, end, &ul);
  4026.             type_die.cu_off = ul;

  4028.             type = dwarf2_get_die_type (type_die, per_cu);
  4029.             fprintf_filtered (stream, "<");
  4030.             type_print (type, "", stream, -1);
  4031.             fprintf_filtered (stream, " [0x%s]> [$%s]",
  4032.                               phex_nz (type_die.cu_off, 0),
  4033.                               locexpr_regname (arch, reg));
  4034.           }
  4035.           break;

  4037.         case DW_OP_GNU_convert:
  4038.         case DW_OP_GNU_reinterpret:
  4039.           {
  4040.             cu_offset type_die;

  4042.             data = safe_read_uleb128 (data, end, &ul);
  4043.             type_die.cu_off = ul;

  4045.             if (type_die.cu_off == 0)
  4046.               fprintf_filtered (stream, "<0>");
  4047.             else
  4048.               {
  4049.                 struct type *type;

  4051.                 type = dwarf2_get_die_type (type_die, per_cu);
  4052.                 fprintf_filtered (stream, "<");
  4053.                 type_print (type, "", stream, -1);
  4054.                 fprintf_filtered (stream, " [0x%s]>", phex_nz (type_die.cu_off, 0));
  4055.               }
  4056.           }
  4057.           break;

  4059.         case DW_OP_GNU_entry_value:
  4060.           data = safe_read_uleb128 (data, end, &ul);
  4061.           fputc_filtered ('\n', stream);
  4062.           disassemble_dwarf_expression (stream, arch, addr_size, offset_size,
  4063.                                         start, data, data + ul, indent + 2,
  4064.                                         all, per_cu);
  4065.           data += ul;
  4066.           continue;

  4068.         case DW_OP_GNU_parameter_ref:
  4069.           ul = extract_unsigned_integer (data, 4, gdbarch_byte_order (arch));
  4070.           data += 4;
  4071.           fprintf_filtered (stream, " offset %s", phex_nz (ul, 4));
  4072.           break;

  4074.         case DW_OP_GNU_addr_index:
  4075.           data = safe_read_uleb128 (data, end, &ul);
  4076.           ul = dwarf2_read_addr_index (per_cu, ul);
  4077.           fprintf_filtered (stream, " 0x%s", phex_nz (ul, addr_size));
  4078.           break;
  4079.         case DW_OP_GNU_const_index:
  4080.           data = safe_read_uleb128 (data, end, &ul);
  4081.           ul = dwarf2_read_addr_index (per_cu, ul);
  4082.           fprintf_filtered (stream, " %s", pulongest (ul));
  4083.           break;
  4084.         }

  4086.       fprintf_filtered (stream, "\n");
  4087.     }

  4089.   return data;
  4090. }

  4092. /* Describe a single location, which may in turn consist of multiple
  4093.    pieces.  */

  4095. static void
  4096. ‌locexpr_describe_location_1 (struct symbol *symbol, CORE_ADDR addr,
  4097.                              struct ui_file *stream,
  4098.                              const gdb_byte *data, size_t size,
  4099.                              struct objfile *objfile, unsigned int addr_size,
  4100.                              int offset_size, struct dwarf2_per_cu_data *per_cu)
  4101. {
  4102.   const gdb_byte *end = data + size;
  4103.   int first_piece = 1, bad = 0;

  4105.   while (data < end)
  4106.     {
  4107.       const gdb_byte *here = data;
  4108.       int disassemble = 1;

  4110.       if (first_piece)
  4111.         first_piece = 0;
  4112.       else
  4113.         fprintf_filtered (stream, _(", and "));

  4115.       if (!dwarf2_always_disassemble)
  4116.         {
  4117.           data = locexpr_describe_location_piece (symbol, stream,
  4118.                                                   addr, objfile, per_cu,
  4119.                                                   data, end, addr_size);
  4120.           /* If we printed anything, or if we have an empty piece,
  4121.              then don't disassemble.  */
  4122.           if (data != here
  4123.               || data[0] == DW_OP_piece
  4124.               || data[0] == DW_OP_bit_piece)
  4125.             disassemble = 0;
  4126.         }
  4127.       if (disassemble)
  4128.         {
  4129.           fprintf_filtered (stream, _("a complex DWARF expression:\n"));
  4130.           data = disassemble_dwarf_expression (stream,
  4131.                                                get_objfile_arch (objfile),
  4132.                                                addr_size, offset_size, data,
  4133.                                                data, end, 0,
  4134.                                                dwarf2_always_disassemble,
  4135.                                                per_cu);
  4136.         }

  4138.       if (data < end)
  4139.         {
  4140.           int empty = data == here;

  4142.           if (disassemble)
  4143.             fprintf_filtered (stream, "   ");
  4144.           if (data[0] == DW_OP_piece)
  4145.             {
  4146.               uint64_t bytes;

  4148.               data = safe_read_uleb128 (data + 1, end, &bytes);

  4150.               if (empty)
  4151.                 fprintf_filtered (stream, _("an empty %s-byte piece"),
  4152.                                   pulongest (bytes));
  4153.               else
  4154.                 fprintf_filtered (stream, _(" [%s-byte piece]"),
  4155.                                   pulongest (bytes));
  4156.             }
  4157.           else if (data[0] == DW_OP_bit_piece)
  4158.             {
  4159.               uint64_t bits, offset;

  4161.               data = safe_read_uleb128 (data + 1, end, &bits);
  4162.               data = safe_read_uleb128 (data, end, &offset);

  4164.               if (empty)
  4165.                 fprintf_filtered (stream,
  4166.                                   _("an empty %s-bit piece"),
  4167.                                   pulongest (bits));
  4168.               else
  4169.                 fprintf_filtered (stream,
  4170.                                   _(" [%s-bit piece, offset %s bits]"),
  4171.                                   pulongest (bits), pulongest (offset));
  4172.             }
  4173.           else
  4174.             {
  4175.               bad = 1;
  4176.               break;
  4177.             }
  4178.         }
  4179.     }

  4181.   if (bad || data > end)
  4182.     error (_("Corrupted DWARF2 expression for \"%s\"."),
  4183.            SYMBOL_PRINT_NAME (symbol));
  4184. }

  4186. /* Print a natural-language description of SYMBOL to STREAM.  This
  4187.    version is for a symbol with a single location.  */

  4189. static void
  4190. ‌locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
  4191.                            struct ui_file *stream)
  4192. {
  4193.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4194.   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
  4195.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
  4196.   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);

  4198.   locexpr_describe_location_1 (symbol, addr, stream,
  4199.                                dlbaton->data, dlbaton->size,
  4200.                                objfile, addr_size, offset_size,
  4201.                                dlbaton->per_cu);
  4202. }

  4204. /* Describe the location of SYMBOL as an agent value in VALUE, generating
  4205.    any necessary bytecode in AX.  */

  4207. static void
  4208. ‌locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
  4209.                             struct agent_expr *ax, struct axs_value *value)
  4210. {
  4211.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4212.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);

  4214.   if (dlbaton->size == 0)
  4215.     value->optimized_out = 1;
  4216.   else
  4217.     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size,
  4218.                                dlbaton->data, dlbaton->data + dlbaton->size,
  4219.                                dlbaton->per_cu);
  4220. }

  4222. /* symbol_computed_ops 'generate_c_location' method.  */

  4224. static void
  4225. ‌locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream,
  4226.                              struct gdbarch *gdbarch,
  4227.                              unsigned char *registers_used,
  4228.                              CORE_ADDR pc, const char *result_name)
  4229. {
  4230.   struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
  4231.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);

  4233.   if (dlbaton->size == 0)
  4234.     error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));

  4236.   compile_dwarf_expr_to_c (stream, result_name,
  4237.                            sym, pc, gdbarch, registers_used, addr_size,
  4238.                            dlbaton->data, dlbaton->data + dlbaton->size,
  4239.                            dlbaton->per_cu);
  4240. }

  4242. /* The set of location functions used with the DWARF-2 expression
  4243.    evaluator.  */
  4244. ‌const struct symbol_computed_ops dwarf2_locexpr_funcs = {
  4245.   locexpr_read_variable,
  4246.   locexpr_read_variable_at_entry,
  4247.   locexpr_read_needs_frame,
  4248.   locexpr_describe_location,
  4249.   0,        /* location_has_loclist */
  4250.   locexpr_tracepoint_var_ref,
  4251.   locexpr_generate_c_location
  4252. };


  4255. /* Wrapper functions for location lists.  These generally find
  4256.    the appropriate location expression and call something above.  */

  4258. /* Return the value of SYMBOL in FRAME using the DWARF-2 expression
  4259.    evaluator to calculate the location.  */
  4260. static struct value *
  4261. ‌loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
  4262. {
  4263.   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4264.   struct value *val;
  4265.   const gdb_byte *data;
  4266.   size_t size;
  4267.   CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;

  4269.   data = dwarf2_find_location_expression (dlbaton, &size, pc);
  4270.   val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, data, size,
  4271.                                   dlbaton->per_cu);

  4273.   return val;
  4274. }

  4276. /* Read variable SYMBOL like loclist_read_variable at (callee) FRAME's function
  4277.    entry.  SYMBOL should be a function parameter, otherwise NO_ENTRY_VALUE_ERROR
  4278.    will be thrown.

  4280.    Function always returns non-NULL value, it may be marked optimized out if
  4281.    inferior frame information is not available.  It throws NO_ENTRY_VALUE_ERROR
  4282.    if it cannot resolve the parameter for any reason.  */

  4284. static struct value *
  4285. ‌loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
  4286. {
  4287.   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4288.   const gdb_byte *data;
  4289.   size_t size;
  4290.   CORE_ADDR pc;

  4292.   if (frame == NULL || !get_frame_func_if_available (frame, &pc))
  4293.     return allocate_optimized_out_value (SYMBOL_TYPE (symbol));

  4295.   data = dwarf2_find_location_expression (dlbaton, &size, pc);
  4296.   if (data == NULL)
  4297.     return allocate_optimized_out_value (SYMBOL_TYPE (symbol));

  4299.   return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, data, size);
  4300. }

  4302. /* Return non-zero iff we need a frame to evaluate SYMBOL.  */
  4303. static int
  4304. ‌loclist_read_needs_frame (struct symbol *symbol)
  4305. {
  4306.   /* If there's a location list, then assume we need to have a frame
  4307.      to choose the appropriate location expression.  With tracking of
  4308.      global variables this is not necessarily true, but such tracking
  4309.      is disabled in GCC at the moment until we figure out how to
  4310.      represent it.  */

  4312.   return 1;
  4313. }

  4315. /* Print a natural-language description of SYMBOL to STREAM.  This
  4316.    version applies when there is a list of different locations, each
  4317.    with a specified address range.  */

  4319. static void
  4320. ‌loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
  4321.                            struct ui_file *stream)
  4322. {
  4323.   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4324.   const gdb_byte *loc_ptr, *buf_end;
  4325.   struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
  4326.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  4327.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  4328.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
  4329.   int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
  4330.   int signed_addr_p = bfd_get_sign_extend_vma (objfile->obfd);
  4331.   /* Adjust base_address for relocatable objects.  */
  4332.   CORE_ADDR base_offset = dwarf2_per_cu_text_offset (dlbaton->per_cu);
  4333.   CORE_ADDR base_address = dlbaton->base_address + base_offset;
  4334.   int done = 0;

  4336.   loc_ptr = dlbaton->data;
  4337.   buf_end = dlbaton->data + dlbaton->size;

  4339.   fprintf_filtered (stream, _("multi-location:\n"));

  4341.   /* Iterate through locations until we run out.  */
  4342.   while (!done)
  4343.     {
  4344.       CORE_ADDR low = 0, high = 0; /* init for gcc -Wall */
  4345.       int length;
  4346.       enum debug_loc_kind kind;
  4347.       const gdb_byte *new_ptr = NULL; /* init for gcc -Wall */

  4349.       if (dlbaton->from_dwo)
  4350.         kind = decode_debug_loc_dwo_addresses (dlbaton->per_cu,
  4351.                                                loc_ptr, buf_end, &new_ptr,
  4352.                                                &low, &high, byte_order);
  4353.       else
  4354.         kind = decode_debug_loc_addresses (loc_ptr, buf_end, &new_ptr,
  4355.                                            &low, &high,
  4356.                                            byte_order, addr_size,
  4357.                                            signed_addr_p);
  4358.       loc_ptr = new_ptr;
  4359.       switch (kind)
  4360.         {
  4361.         case DEBUG_LOC_END_OF_LIST:
  4362.           done = 1;
  4363.           continue;
  4364.         case DEBUG_LOC_BASE_ADDRESS:
  4365.           base_address = high + base_offset;
  4366.           fprintf_filtered (stream, _("  Base address %s"),
  4367.                             paddress (gdbarch, base_address));
  4368.           continue;
  4369.         case DEBUG_LOC_START_END:
  4370.         case DEBUG_LOC_START_LENGTH:
  4371.           break;
  4372.         case DEBUG_LOC_BUFFER_OVERFLOW:
  4373.         case DEBUG_LOC_INVALID_ENTRY:
  4374.           error (_("Corrupted DWARF expression for symbol \"%s\"."),
  4375.                  SYMBOL_PRINT_NAME (symbol));
  4376.         default:
  4377.           gdb_assert_not_reached ("bad debug_loc_kind");
  4378.         }

  4380.       /* Otherwise, a location expression entry.  */
  4381.       low += base_address;
  4382.       high += base_address;

  4384.       low = gdbarch_adjust_dwarf2_addr (gdbarch, low);
  4385.       high = gdbarch_adjust_dwarf2_addr (gdbarch, high);

  4387.       length = extract_unsigned_integer (loc_ptr, 2, byte_order);
  4388.       loc_ptr += 2;

  4390.       /* (It would improve readability to print only the minimum
  4391.          necessary digits of the second number of the range.)  */
  4392.       fprintf_filtered (stream, _("  Range %s-%s: "),
  4393.                         paddress (gdbarch, low), paddress (gdbarch, high));

  4395.       /* Now describe this particular location.  */
  4396.       locexpr_describe_location_1 (symbol, low, stream, loc_ptr, length,
  4397.                                    objfile, addr_size, offset_size,
  4398.                                    dlbaton->per_cu);

  4400.       fprintf_filtered (stream, "\n");

  4402.       loc_ptr += length;
  4403.     }
  4404. }

  4406. /* Describe the location of SYMBOL as an agent value in VALUE, generating
  4407.    any necessary bytecode in AX.  */
  4408. static void
  4409. ‌loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
  4410.                             struct agent_expr *ax, struct axs_value *value)
  4411. {
  4412.   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
  4413.   const gdb_byte *data;
  4414.   size_t size;
  4415.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);

  4417.   data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
  4418.   if (size == 0)
  4419.     value->optimized_out = 1;
  4420.   else
  4421.     dwarf2_compile_expr_to_ax (ax, value, gdbarch, addr_size, data, data + size,
  4422.                                dlbaton->per_cu);
  4423. }

  4425. /* symbol_computed_ops 'generate_c_location' method.  */

  4427. static void
  4428. ‌loclist_generate_c_location (struct symbol *sym, struct ui_file *stream,
  4429.                              struct gdbarch *gdbarch,
  4430.                              unsigned char *registers_used,
  4431.                              CORE_ADDR pc, const char *result_name)
  4432. {
  4433.   struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
  4434.   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
  4435.   const gdb_byte *data;
  4436.   size_t size;

  4438.   data = dwarf2_find_location_expression (dlbaton, &size, pc);
  4439.   if (size == 0)
  4440.     error (_("symbol \"%s\" is optimized out"), SYMBOL_NATURAL_NAME (sym));

  4442.   compile_dwarf_expr_to_c (stream, result_name,
  4443.                            sym, pc, gdbarch, registers_used, addr_size,
  4444.                            data, data + size,
  4445.                            dlbaton->per_cu);
  4446. }

  4448. /* The set of location functions used with the DWARF-2 expression
  4449.    evaluator and location lists.  */
  4450. ‌const struct symbol_computed_ops dwarf2_loclist_funcs = {
  4451.   loclist_read_variable,
  4452.   loclist_read_variable_at_entry,
  4453.   loclist_read_needs_frame,
  4454.   loclist_describe_location,
  4455.   1,        /* location_has_loclist */
  4456.   loclist_tracepoint_var_ref,
  4457.   loclist_generate_c_location
  4458. };

  4460. /* Provide a prototype to silence -Wmissing-prototypes.  */
  4461. extern initialize_file_ftype _initialize_dwarf2loc;

  4463. void
  4464. ‌_initialize_dwarf2loc (void)
  4465. {
  4466.   add_setshow_zuinteger_cmd ("entry-values", class_maintenance,
  4467.                              &entry_values_debug,
  4468.                              _("Set entry values and tail call frames "
  4469.                                "debugging."),
  4470.                              _("Show entry values and tail call frames "
  4471.                                "debugging."),
  4472.                              _("When non-zero, the process of determining "
  4473.                                "parameter values from function entry point "
  4474.                                "and tail call frames will be printed."),
  4475.                              NULL,
  4476.                              show_entry_values_debug,
  4477.                              &setdebuglist, &showdebuglist);
  4478. }