gdb/values.c

   1 /* Low level packing and unpacking of values for GDB.
   2    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
   3
   4 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
   5 WARRANTY.  No author or distributor accepts responsibility to anyone
   6 for the consequences of using it or for whether it serves any
   7 particular purpose or works at all, unless he says so in writing.
   8 Refer to the GDB General Public License for full details.
   9
  10 Everyone is granted permission to copy, modify and redistribute GDB,
  11 but only under the conditions described in the GDB General Public
  12 License.  A copy of this license is supposed to have been given to you
  13 along with GDB so you can know your rights and responsibilities.  It
  14 should be in a file named COPYING.  Among other things, the copyright
  15 notice and this notice must be preserved on all copies.
  16
  17 In other words, go ahead and share GDB, but don't try to stop
  18 anyone else from sharing it farther.  Help stamp out software hoarding!
  19 */
  20
  21 #include <stdio.h>
  22 #include "defs.h"
  23 #include "initialize.h"
  24 #include "param.h"
  25 #include "symtab.h"
  26 #include "value.h"
  27
  28 /* The value-history records all the values printed
  29    by print commands during this session.  Each chunk
  30    records 60 consecutive values.  The first chunk on
  31    the chain records the most recent values.
  32    The total number of values is in value_history_count.  */
  33
  34 #define VALUE_HISTORY_CHUNK 60
  35
  36 struct value_history_chunk
  37 {
  38   struct value_history_chunk *next;
  39   value values[VALUE_HISTORY_CHUNK];
  40 };
  41
  42 /* Chain of chunks now in use.  */
  43
  44 static struct value_history_chunk *value_history_chain;
  45
  46 static int value_history_count; /* Abs number of last entry stored */
  47
  48 START_FILE
  49 \f
  50 /* List of all value objects currently allocated
  51    (except for those released by calls to release_value)
  52    This is so they can be freed after each command.  */
  53
  54 static value all_values;
  55
  56 /* Allocate a  value  that has the correct length for type TYPE.  */
  57
  58 value
  59 allocate_value (type)
  60      struct type *type;
  61 {
  62   register value val;
  63
  64   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
  65   VALUE_NEXT (val) = all_values;
  66   all_values = val;
  67   VALUE_TYPE (val) = type;
  68   VALUE_LVAL (val) = not_lval;
  69   VALUE_ADDRESS (val) = 0;
  70   VALUE_OFFSET (val) = 0;
  71   VALUE_BITPOS (val) = 0;
  72   VALUE_BITSIZE (val) = 0;
  73   VALUE_REPEATED (val) = 0;
  74   VALUE_REPETITIONS (val) = 0;
  75   VALUE_REGNO (val) = -1;
  76   return val;
  77 }
  78
  79 /* Allocate a  value  that has the correct length
  80    for COUNT repetitions type TYPE.  */
  81
  82 value
  83 allocate_repeat_value (type, count)
  84      struct type *type;
  85      int count;
  86 {
  87   register value val;
  88
  89   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
  90   VALUE_NEXT (val) = all_values;
  91   all_values = val;
  92   VALUE_TYPE (val) = type;
  93   VALUE_LVAL (val) = not_lval;
  94   VALUE_ADDRESS (val) = 0;
  95   VALUE_OFFSET (val) = 0;
  96   VALUE_BITPOS (val) = 0;
  97   VALUE_BITSIZE (val) = 0;
  98   VALUE_REPEATED (val) = 1;
  99   VALUE_REPETITIONS (val) = count;
 100   VALUE_REGNO (val) = -1;
 101   return val;
 102 }
 103
 104 /* Free all the values that have been allocated (except for those released).
 105    Called after each command, successful or not.  */
 106
 107 void
 108 free_all_values ()
 109 {
 110   register value val, next;
 111
 112   for (val = all_values; val; val = next)
 113     {
 114       next = VALUE_NEXT (val);
 115       free (val);
 116     }
 117
 118   all_values = 0;
 119 }
 120
 121 /* Remove VAL from the chain all_values
 122    so it will not be freed automatically.  */
 123
 124 void
 125 release_value (val)
 126      register value val;
 127 {
 128   register value v;
 129
 130   if (all_values == val)
 131     {
 132       all_values = val->next;
 133       return;
 134     }
 135
 136   for (v = all_values; v; v = v->next)
 137     {
 138       if (v->next == val)
 139         {
 140           v->next = val->next;
 141           break;
 142         }
 143     }
 144 }
 145
 146 /* Return a copy of the value ARG.
 147    It contains the same contents, for same memory address,
 148    but it's a different block of storage.  */
 149
 150 static value
 151 value_copy (arg)
 152      value arg;
 153 {
 154   register value val;
 155   register struct type *type = VALUE_TYPE (arg);
 156   if (VALUE_REPEATED (arg))
 157     val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
 158   else
 159     val = allocate_value (type);
 160   VALUE_LVAL (val) = VALUE_LVAL (arg);
 161   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
 162   VALUE_OFFSET (val) = VALUE_OFFSET (arg);
 163   VALUE_BITPOS (val) = VALUE_BITPOS (arg);
 164   VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
 165   VALUE_REGNO (val) = VALUE_REGNO (arg);
 166   bcopy (VALUE_CONTENTS (arg), VALUE_CONTENTS (val),
 167          TYPE_LENGTH (VALUE_TYPE (arg))
 168          * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
 169   return val;
 170 }
 171 \f
 172 /* Access to the value history.  */
 173
 174 /* Record a new value in the value history.
 175    Returns the absolute history index of the entry.  */
 176
 177 int
 178 record_latest_value (val)
 179      value val;
 180 {
 181   register int i;
 182
 183   /* Get error now if about to store an invalid float.  */
 184   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT)
 185     value_as_double (val);
 186
 187   /* Here we treat value_history_count as origin-zero
 188      and applying to the value being stored now.  */
 189
 190   i = value_history_count % VALUE_HISTORY_CHUNK;
 191   if (i == 0)
 192     {
 193       register struct value_history_chunk *new
 194         = (struct value_history_chunk *) xmalloc (sizeof (struct value_history_chunk));
 195       bzero (new->values, sizeof new->values);
 196       new->next = value_history_chain;
 197       value_history_chain = new;
 198     }
 199
 200   value_history_chain->values[i] = val;
 201   release_value (val);
 202
 203   /* Now we regard value_history_count as origin-one
 204      and applying to the value just stored.  */
 205
 206   return ++value_history_count;
 207 }
 208
 209 /* Return a copy of the value in the history with sequence number NUM.  */
 210
 211 value
 212 access_value_history (num)
 213      int num;
 214 {
 215   register struct value_history_chunk *chunk;
 216   register int i;
 217   register int absnum = num;
 218
 219   if (absnum <= 0)
 220     absnum += value_history_count;
 221
 222   if (absnum <= 0)
 223     {
 224       if (num == 0)
 225         error ("The history is empty.");
 226       else if (num == 1)
 227         error ("There is only one value in the history.");
 228       else
 229         error ("History does not go back to $$%d.", -num);
 230     }
 231   if (absnum > value_history_count)
 232     error ("History has not yet reached $%d.", absnum);
 233
 234   absnum--;
 235
 236   /* Now absnum is always absolute and origin zero.  */
 237
 238   chunk = value_history_chain;
 239   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
 240        i > 0; i--)
 241     chunk = chunk->next;
 242
 243   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
 244 }
 245
 246 /* Clear the value history entirely.
 247    Must be done when new symbol tables are loaded,
 248    because the type pointers become invalid.  */
 249
 250 void
 251 clear_value_history ()
 252 {
 253   register struct value_history_chunk *next;
 254   register int i;
 255   register value val;
 256
 257   while (value_history_chain)
 258     {
 259       for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
 260         if (val = value_history_chain->values[i])
 261           free (val);
 262       next = value_history_chain->next;
 263       free (value_history_chain);
 264       value_history_chain = next;
 265     }
 266   value_history_count = 0;
 267 }
 268
 269 static void
 270 history_info (num_exp)
 271      char *num_exp;
 272 {
 273   register int i;
 274   register value val;
 275   register int num;
 276
 277   if (num_exp)
 278     num = parse_and_eval_address (num_exp) - 5;
 279   else
 280     num = value_history_count - 9;
 281
 282   if (num <= 0)
 283     num = 1;
 284
 285   for (i = num; i < num + 10 && i <= value_history_count; i++)
 286     {
 287       val = access_value_history (i);
 288       printf ("$%d = ", i);
 289       value_print (val, stdout);
 290       printf ("\n");
 291     }
 292 }
 293 \f
 294 /* Internal variables.  These are variables within the debugger
 295    that hold values assigned by debugger commands.
 296    The user refers to them with a '$' prefix
 297    that does not appear in the variable names stored internally.  */
 298
 299 static struct internalvar *internalvars;
 300
 301 /* Look up an internal variable with name NAME.  NAME should not
 302    normally include a dollar sign.
 303
 304    If the specified internal variable does not exist,
 305    one is created, with a void value.  */
 306
 307 struct internalvar *
 308 lookup_internalvar (name)
 309      char *name;
 310 {
 311   register struct internalvar *var;
 312
 313   for (var = internalvars; var; var = var->next)
 314     if (!strcmp (var->name, name))
 315       return var;
 316
 317   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
 318   var->name = concat (name, "", "");
 319   var->value = allocate_value (builtin_type_void);
 320   release_value (var->value);
 321   var->next = internalvars;
 322   internalvars = var;
 323   return var;
 324 }
 325
 326 value
 327 value_of_internalvar (var)
 328      struct internalvar *var;
 329 {
 330   register value val = value_copy (var->value);
 331   VALUE_LVAL (val) = lval_internalvar;
 332   VALUE_INTERNALVAR (val) = var;
 333 }
 334
 335 void
 336 set_internalvar_component (var, offset, bitpos, bitsize, newval)
 337      struct internalvar *var;
 338      int offset, bitpos, bitsize;
 339      value newval;
 340 {
 341   register char *addr = VALUE_CONTENTS (var->value) + offset;
 342   if (bitsize)
 343     modify_field (addr, value_as_long (newval),
 344                   bitpos, bitsize);
 345   else
 346     bcopy (VALUE_CONTENTS (newval), addr,
 347            TYPE_LENGTH (VALUE_TYPE (newval)));
 348 }
 349
 350 void
 351 set_internalvar (var, val)
 352      struct internalvar *var;
 353      value val;
 354 {
 355   free (var->value);
 356   var->value = value_copy (val);
 357   release_value (var->value);
 358 }
 359
 360 char *
 361 internalvar_name (var)
 362      struct internalvar *var;
 363 {
 364   return var->name;
 365 }
 366
 367 /* Free all internalvars.  Done when new symtabs are loaded,
 368    because that makes the values invalid.  */
 369
 370 void
 371 clear_internalvars ()
 372 {
 373   register struct internalvar *var;
 374
 375   while (internalvars)
 376     {
 377       var = internalvars;
 378       internalvars = var->next;
 379       free (var->name);
 380       free (var->value);
 381       free (var);
 382     }
 383 }
 384
 385 static void
 386 convenience_info ()
 387 {
 388   register struct internalvar *var;
 389
 390   if (internalvars)
 391     printf ("Debugger convenience variables:\n\n");
 392   else
 393     printf ("No debugger convenience variables now defined.\n\
 394 Convenience variables have names starting with \"$\";\n\
 395 use \"set\" as in \"set $foo = 5\" to define them.\n");
 396
 397   for (var = internalvars; var; var = var->next)
 398     {
 399       printf ("$%s: ", var->name);
 400       value_print (var->value, stdout);
 401       printf ("\n");
 402     }
 403 }
 404 \f
 405 /* Extract a value as a C number (either long or double).
 406    Knows how to convert fixed values to double, or
 407    floating values to long.
 408    Does not deallocate the value.  */
 409
 410 long
 411 value_as_long (val)
 412      register value val;
 413 {
 414   return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
 415 }
 416
 417 double
 418 value_as_double (val)
 419      register value val;
 420 {
 421   return unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val));
 422 }
 423 \f
 424 /* Unpack raw data (copied from debugee) at VALADDR
 425    as a long, or as a double, assuming the raw data is described
 426    by type TYPE.  Knows how to convert different sizes of values
 427    and can convert between fixed and floating point.  */
 428
 429 long
 430 unpack_long (type, valaddr)
 431      struct type *type;
 432      char *valaddr;
 433 {
 434   register enum type_code code = TYPE_CODE (type);
 435   register int len = TYPE_LENGTH (type);
 436   register int nosign = TYPE_UNSIGNED (type);
 437
 438   if (code == TYPE_CODE_ENUM)
 439     code = TYPE_CODE_INT;
 440   if (code == TYPE_CODE_FLT)
 441     {
 442       if (len == sizeof (float))
 443         return * (float *) valaddr;
 444
 445       if (len == sizeof (double))
 446         return * (double *) valaddr;
 447     }
 448   else if (code == TYPE_CODE_INT && nosign)
 449     {
 450       if (len == sizeof (char))
 451         return * (unsigned char *) valaddr;
 452
 453       if (len == sizeof (short))
 454         return * (unsigned short *) valaddr;
 455
 456       if (len == sizeof (int))
 457         return * (unsigned int *) valaddr;
 458
 459       if (len == sizeof (long))
 460         return * (unsigned long *) valaddr;
 461     }
 462   else if (code == TYPE_CODE_INT)
 463     {
 464       if (len == sizeof (char))
 465         return * (char *) valaddr;
 466
 467       if (len == sizeof (short))
 468         return * (short *) valaddr;
 469
 470       if (len == sizeof (int))
 471         return * (int *) valaddr;
 472
 473       if (len == sizeof (long))
 474         return * (long *) valaddr;
 475     }
 476   else if (code == TYPE_CODE_PTR)
 477     {
 478       if (len == sizeof (char *))
 479         return (CORE_ADDR) * (char **) valaddr;
 480     }
 481
 482   error ("Value not integer or pointer.");
 483 }
 484
 485 double
 486 unpack_double (type, valaddr)
 487      struct type *type;
 488      char *valaddr;
 489 {
 490   register enum type_code code = TYPE_CODE (type);
 491   register int len = TYPE_LENGTH (type);
 492   register int nosign = TYPE_UNSIGNED (type);
 493
 494   if (code == TYPE_CODE_FLT)
 495     {
 496       if (INVALID_FLOAT (valaddr, len))
 497         error ("Invalid floating value found in program.");
 498
 499       if (len == sizeof (float))
 500         return * (float *) valaddr;
 501
 502       if (len == sizeof (double))
 503         return * (double *) valaddr;
 504     }
 505   else if (code == TYPE_CODE_INT && nosign)
 506     {
 507       if (len == sizeof (char))
 508         return * (unsigned char *) valaddr;
 509
 510       if (len == sizeof (short))
 511         return * (unsigned short *) valaddr;
 512
 513       if (len == sizeof (int))
 514         return * (unsigned int *) valaddr;
 515
 516       if (len == sizeof (long))
 517         return * (unsigned long *) valaddr;
 518     }
 519   else if (code == TYPE_CODE_INT)
 520     {
 521       if (len == sizeof (char))
 522         return * (char *) valaddr;
 523
 524       if (len == sizeof (short))
 525         return * (short *) valaddr;
 526
 527       if (len == sizeof (int))
 528         return * (int *) valaddr;
 529
 530       if (len == sizeof (long))
 531         return * (long *) valaddr;
 532     }
 533
 534   error ("Value not floating number.");
 535 }
 536 \f
 537 /* Given a value ARG1 of a struct or union type,
 538    extract and return the value of one of its fields.
 539    FIELDNO says which field.  */
 540
 541 value
 542 value_field (arg1, fieldno)
 543      register value arg1;
 544      register int fieldno;
 545 {
 546   register value v;
 547   register struct type *type = TYPE_FIELD_TYPE (VALUE_TYPE (arg1), fieldno);
 548   register int offset;
 549
 550   /* Handle packed fields */
 551
 552   offset = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) / 8;
 553   if (TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno))
 554     {
 555       v = value_from_long (type,
 556                            unpack_field_as_long (VALUE_TYPE (arg1),
 557                                                  VALUE_CONTENTS (arg1),
 558                                                  fieldno));
 559       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (VALUE_TYPE (arg1), fieldno) % 8;
 560       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (VALUE_TYPE (arg1), fieldno);
 561     }
 562   else
 563     {
 564       v = allocate_value (type);
 565       bcopy (VALUE_CONTENTS (arg1) + offset,
 566              VALUE_CONTENTS (v),
 567              TYPE_LENGTH (type));
 568     }
 569   VALUE_LVAL (v) = VALUE_LVAL (arg1);
 570   if (VALUE_LVAL (arg1) == lval_internalvar)
 571     VALUE_LVAL (v) = lval_internalvar_component;
 572   VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
 573   VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
 574   return v;
 575 }
 576
 577 long
 578 unpack_field_as_long (type, valaddr, fieldno)
 579      struct type *type;
 580      char *valaddr;
 581      int fieldno;
 582 {
 583   long val;
 584   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
 585   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
 586   union { int i; char c; } test;
 587
 588   bcopy (valaddr + bitpos / 8, &val, sizeof val);
 589
 590   /* Extracting bits depends on endianness of the machine.  */
 591   test.i = 1;
 592   if (test.c == 1)
 593     /* Little-endian.  */
 594     val = val >> (bitpos % 8);
 595   else
 596     val = val >> (sizeof val * 8 - bitpos % 8 - bitsize);
 597
 598   val &= (1 << bitsize) - 1;
 599   return val;
 600 }
 601
 602 modify_field (addr, fieldval, bitpos, bitsize)
 603      char *addr;
 604      int fieldval;
 605      int bitpos, bitsize;
 606 {
 607   long oword;
 608   union { int i; char c; } test;
 609
 610   bcopy (addr, &oword, sizeof oword);
 611
 612   /* Shifting for bit field depends on endianness of the machine.  */
 613   test.c = 1;
 614   if (test.i != 1)
 615     /* not little-endian: assume big-endian.  */
 616     bitpos = sizeof oword * 8 - bitpos - bitsize;
 617
 618   oword &= ~(((1 << bitsize) - 1) << bitpos);
 619   oword |= fieldval << bitpos;
 620   bcopy (&oword, addr, sizeof oword);
 621 }
 622 \f
 623 /* Convert C numbers into newly allocated values */
 624
 625 value
 626 value_from_long (type, num)
 627      struct type *type;
 628      register long num;
 629 {
 630   register value val = allocate_value (type);
 631   register enum type_code code = TYPE_CODE (type);
 632   register int len = TYPE_LENGTH (type);
 633
 634   if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM)
 635     {
 636       if (len == sizeof (char))
 637         * (char *) VALUE_CONTENTS (val) = num;
 638       else if (len == sizeof (short))
 639         * (short *) VALUE_CONTENTS (val) = num;
 640       else if (len == sizeof (int))
 641         * (int *) VALUE_CONTENTS (val) = num;
 642       else if (len == sizeof (long))
 643         * (long *) VALUE_CONTENTS (val) = num;
 644       else
 645         error ("Integer type encountered with unexpected data length.");
 646     }
 647   else
 648     error ("Unexpected type encountered for integer constant.");
 649
 650   return val;
 651 }
 652
 653 value
 654 value_from_double (type, num)
 655      struct type *type;
 656      double num;
 657 {
 658   register value val = allocate_value (type);
 659   register enum type_code code = TYPE_CODE (type);
 660   register int len = TYPE_LENGTH (type);
 661
 662   if (code == TYPE_CODE_FLT)
 663     {
 664       if (len == sizeof (float))
 665         * (float *) VALUE_CONTENTS (val) = num;
 666       else if (len == sizeof (double))
 667         * (double *) VALUE_CONTENTS (val) = num;
 668       else
 669         error ("Floating type encountered with unexpected data length.");
 670     }
 671   else
 672     error ("Unexpected type encountered for floating constant.");
 673
 674   return val;
 675 }
 676 \f
 677 /* Deal with the value that is "about to be returned".  */
 678
 679 /* Return the value that a function returning now
 680    would be returning to its caller, assuming its type is VALTYPE.
 681    RETBUF is where we look for what ought to be the contents
 682    of the registers (in raw form).  This is because it is often
 683    desirable to restore old values to those registers
 684    after saving the contents of interest, and then call
 685    this function using the saved values.  */
 686
 687 value
 688 value_being_returned (valtype, retbuf)
 689      register struct type *valtype;
 690      char retbuf[REGISTER_BYTES];
 691 {
 692   register value val;
 693
 694   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 695       || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 696     return value_at (valtype, EXTRACT_STRUCT_VALUE_ADDRESS (retbuf));
 697
 698   val = allocate_value (valtype);
 699   EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS (val));
 700
 701   return val;
 702 }
 703
 704 /* Store VAL so it will be returned if a function returns now.
 705    Does not verify that VAL's type matches what the current
 706    function wants to return.  */
 707
 708 void
 709 set_return_value (val)
 710      value val;
 711 {
 712   register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
 713   char regbuf[REGISTER_BYTES];
 714   double dbuf;
 715   long lbuf;
 716
 717   if (code == TYPE_CODE_STRUCT
 718       || code == TYPE_CODE_UNION)
 719     error ("Specifying a struct or union return value is not supported.");
 720
 721   if (code == TYPE_CODE_FLT)
 722     {
 723       dbuf = value_as_double (val);
 724
 725       STORE_RETURN_VALUE (VALUE_TYPE (val), &dbuf);
 726     }
 727   else
 728     {
 729       lbuf = value_as_long (val);
 730       STORE_RETURN_VALUE (VALUE_TYPE (val), &lbuf);
 731     }
 732 }
 733 \f
 734 static
 735 initialize ()
 736 {
 737   add_info ("convenience", convenience_info,
 738             "Debugger convenience (\"$foo\") variables.\n\
 739 These variables are created when you assign them values;\n\
 740 thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
 741 A few convenience variables are given values automatically GDB:\n\
 742 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
 743 \"$__\" holds the contents of the last address examined with \"x\".");
 744
 745   add_info ("history", history_info,
 746             "Elements of value history (around item number IDX, or last ten).");
 747 }
 748
 749 END_FILE