home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gdb-4.12-src.lha / GNU / src / amiga / gdb-4.12 / gdb / values.c < prev    next >
C/C++ Source or Header  |  1994-02-03  |  43KB  |  1,465 lines
  1. /* Low level packing and unpacking of values for GDB, the GNU Debugger.
  2.    Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include <string.h>
  22. #include "symtab.h"
  23. #include "gdbtypes.h"
  24. #include "value.h"
  25. #include "gdbcore.h"
  26. #include "frame.h"
  27. #include "command.h"
  28. #include "gdbcmd.h"
  29. #include "target.h"
  30. #include "demangle.h"
  31.  
  32. /* Local function prototypes. */
  33.  
  34. static value
  35. value_headof PARAMS ((value, struct type *, struct type *));
  36.  
  37. static void
  38. show_values PARAMS ((char *, int));
  39.  
  40. static void
  41. show_convenience PARAMS ((char *, int));
  42.  
  43. /* The value-history records all the values printed
  44.    by print commands during this session.  Each chunk
  45.    records 60 consecutive values.  The first chunk on
  46.    the chain records the most recent values.
  47.    The total number of values is in value_history_count.  */
  48.  
  49. #define VALUE_HISTORY_CHUNK 60
  50.  
  51. struct value_history_chunk
  52. {
  53.   struct value_history_chunk *next;
  54.   value values[VALUE_HISTORY_CHUNK];
  55. };
  56.  
  57. /* Chain of chunks now in use.  */
  58.  
  59. static struct value_history_chunk *value_history_chain;
  60.  
  61. static int value_history_count;    /* Abs number of last entry stored */
  62.  
  63. /* List of all value objects currently allocated
  64.    (except for those released by calls to release_value)
  65.    This is so they can be freed after each command.  */
  66.  
  67. static value all_values;
  68.  
  69. /* Allocate a  value  that has the correct length for type TYPE.  */
  70.  
  71. value
  72. allocate_value (type)
  73.      struct type *type;
  74. {
  75.   register value val;
  76.  
  77.   check_stub_type (type);
  78.  
  79.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
  80.   VALUE_NEXT (val) = all_values;
  81.   all_values = val;
  82.   VALUE_TYPE (val) = type;
  83.   VALUE_LVAL (val) = not_lval;
  84.   VALUE_ADDRESS (val) = 0;
  85.   VALUE_FRAME (val) = 0;
  86.   VALUE_OFFSET (val) = 0;
  87.   VALUE_BITPOS (val) = 0;
  88.   VALUE_BITSIZE (val) = 0;
  89.   VALUE_REPEATED (val) = 0;
  90.   VALUE_REPETITIONS (val) = 0;
  91.   VALUE_REGNO (val) = -1;
  92.   VALUE_LAZY (val) = 0;
  93.   VALUE_OPTIMIZED_OUT (val) = 0;
  94.   return val;
  95. }
  96.  
  97. /* Allocate a  value  that has the correct length
  98.    for COUNT repetitions type TYPE.  */
  99.  
  100. value
  101. allocate_repeat_value (type, count)
  102.      struct type *type;
  103.      int count;
  104. {
  105.   register value val;
  106.  
  107.   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
  108.   VALUE_NEXT (val) = all_values;
  109.   all_values = val;
  110.   VALUE_TYPE (val) = type;
  111.   VALUE_LVAL (val) = not_lval;
  112.   VALUE_ADDRESS (val) = 0;
  113.   VALUE_FRAME (val) = 0;
  114.   VALUE_OFFSET (val) = 0;
  115.   VALUE_BITPOS (val) = 0;
  116.   VALUE_BITSIZE (val) = 0;
  117.   VALUE_REPEATED (val) = 1;
  118.   VALUE_REPETITIONS (val) = count;
  119.   VALUE_REGNO (val) = -1;
  120.   VALUE_LAZY (val) = 0;
  121.   VALUE_OPTIMIZED_OUT (val) = 0;
  122.   return val;
  123. }
  124.  
  125. /* Return a mark in the value chain.  All values allocated after the
  126.    mark is obtained (except for those released) are subject to being freed
  127.    if a subsequent value_free_to_mark is passed the mark.  */
  128. value
  129. value_mark ()
  130. {
  131.   return all_values;
  132. }
  133.  
  134. /* Free all values allocated since MARK was obtained by value_mark
  135.    (except for those released).  */
  136. void
  137. value_free_to_mark (mark)
  138.      value mark;
  139. {
  140.   value val, next;
  141.  
  142.   for (val = all_values; val && val != mark; val = next)
  143.     {
  144.       next = VALUE_NEXT (val);
  145.       value_free (val);
  146.     }
  147.   all_values = val;
  148. }
  149.  
  150. /* Free all the values that have been allocated (except for those released).
  151.    Called after each command, successful or not.  */
  152.  
  153. void
  154. free_all_values ()
  155. {
  156.   register value val, next;
  157.  
  158.   for (val = all_values; val; val = next)
  159.     {
  160.       next = VALUE_NEXT (val);
  161.       value_free (val);
  162.     }
  163.  
  164.   all_values = 0;
  165. }
  166.  
  167. /* Remove VAL from the chain all_values
  168.    so it will not be freed automatically.  */
  169.  
  170. void
  171. release_value (val)
  172.      register value val;
  173. {
  174.   register value v;
  175.  
  176.   if (all_values == val)
  177.     {
  178.       all_values = val->next;
  179.       return;
  180.     }
  181.  
  182.   for (v = all_values; v; v = v->next)
  183.     {
  184.       if (v->next == val)
  185.     {
  186.       v->next = val->next;
  187.       break;
  188.     }
  189.     }
  190. }
  191.  
  192. /* Return a copy of the value ARG.
  193.    It contains the same contents, for same memory address,
  194.    but it's a different block of storage.  */
  195.  
  196. value
  197. value_copy (arg)
  198.      value arg;
  199. {
  200.   register value val;
  201.   register struct type *type = VALUE_TYPE (arg);
  202.   if (VALUE_REPEATED (arg))
  203.     val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
  204.   else
  205.     val = allocate_value (type);
  206.   VALUE_LVAL (val) = VALUE_LVAL (arg);
  207.   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
  208.   VALUE_OFFSET (val) = VALUE_OFFSET (arg);
  209.   VALUE_BITPOS (val) = VALUE_BITPOS (arg);
  210.   VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
  211.   VALUE_REGNO (val) = VALUE_REGNO (arg);
  212.   VALUE_LAZY (val) = VALUE_LAZY (arg);
  213.   if (!VALUE_LAZY (val))
  214.     {
  215.       memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS_RAW (arg),
  216.           TYPE_LENGTH (VALUE_TYPE (arg))
  217.           * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
  218.     }
  219.   return val;
  220. }
  221.  
  222. /* Access to the value history.  */
  223.  
  224. /* Record a new value in the value history.
  225.    Returns the absolute history index of the entry.
  226.    Result of -1 indicates the value was not saved; otherwise it is the
  227.    value history index of this new item.  */
  228.  
  229. int
  230. record_latest_value (val)
  231.      value val;
  232. {
  233.   int i;
  234.  
  235.   /* Check error now if about to store an invalid float.  We return -1
  236.      to the caller, but allow them to continue, e.g. to print it as "Nan". */
  237.   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
  238.     {
  239.       unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i);
  240.       if (i) return -1;        /* Indicate value not saved in history */
  241.     }
  242.  
  243.   /* Here we treat value_history_count as origin-zero
  244.      and applying to the value being stored now.  */
  245.  
  246.   i = value_history_count % VALUE_HISTORY_CHUNK;
  247.   if (i == 0)
  248.     {
  249.       register struct value_history_chunk *new
  250.     = (struct value_history_chunk *)
  251.       xmalloc (sizeof (struct value_history_chunk));
  252.       memset (new->values, 0, sizeof new->values);
  253.       new->next = value_history_chain;
  254.       value_history_chain = new;
  255.     }
  256.  
  257.   value_history_chain->values[i] = val;
  258.  
  259.   /* We don't want this value to have anything to do with the inferior anymore.
  260.      In particular, "set $1 = 50" should not affect the variable from which
  261.      the value was taken, and fast watchpoints should be able to assume that
  262.      a value on the value history never changes.  */
  263.   if (VALUE_LAZY (val))
  264.     value_fetch_lazy (val);
  265.   VALUE_LVAL (val) = not_lval;
  266.   release_value (val);
  267.  
  268.   /* Now we regard value_history_count as origin-one
  269.      and applying to the value just stored.  */
  270.  
  271.   return ++value_history_count;
  272. }
  273.  
  274. /* Return a copy of the value in the history with sequence number NUM.  */
  275.  
  276. value
  277. access_value_history (num)
  278.      int num;
  279. {
  280.   register struct value_history_chunk *chunk;
  281.   register int i;
  282.   register int absnum = num;
  283.  
  284.   if (absnum <= 0)
  285.     absnum += value_history_count;
  286.  
  287.   if (absnum <= 0)
  288.     {
  289.       if (num == 0)
  290.     error ("The history is empty.");
  291.       else if (num == 1)
  292.     error ("There is only one value in the history.");
  293.       else
  294.     error ("History does not go back to $$%d.", -num);
  295.     }
  296.   if (absnum > value_history_count)
  297.     error ("History has not yet reached $%d.", absnum);
  298.  
  299.   absnum--;
  300.  
  301.   /* Now absnum is always absolute and origin zero.  */
  302.  
  303.   chunk = value_history_chain;
  304.   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
  305.        i > 0; i--)
  306.     chunk = chunk->next;
  307.  
  308.   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
  309. }
  310.  
  311. /* Clear the value history entirely.
  312.    Must be done when new symbol tables are loaded,
  313.    because the type pointers beco