gdb/values.c

   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 \f
  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 \f
 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   release_value (val);
 259
 260   /* Now we regard value_history_count as origin-one
 261      and applying to the value just stored.  */
 262
 263   return ++value_history_count;
 264 }
 265
 266 /* Return a copy of the value in the history with sequence number NUM.  */
 267
 268 value
 269 access_value_history (num)
 270      int num;
 271 {
 272   register struct value_history_chunk *chunk;
 273   register int i;
 274   register int absnum = num;
 275
 276   if (absnum <= 0)
 277     absnum += value_history_count;
 278
 279   if (absnum <= 0)
 280     {
 281       if (num == 0)
 282         error ("The history is empty.");
 283       else if (num == 1)
 284         error ("There is only one value in the history.");
 285       else
 286         error ("History does not go back to $$%d.", -num);
 287     }
 288   if (absnum > value_history_count)
 289     error ("History has not yet reached $%d.", absnum);
 290
 291   absnum--;
 292
 293   /* Now absnum is always absolute and origin zero.  */
 294
 295   chunk = value_history_chain;
 296   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
 297        i > 0; i--)
 298     chunk = chunk->next;
 299
 300   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
 301 }
 302
 303 /* Clear the value history entirely.
 304    Must be done when new symbol tables are loaded,
 305    because the type pointers become invalid.  */
 306
 307 void
 308 clear_value_history ()
 309 {
 310   register struct value_history_chunk *next;
 311   register int i;
 312   register value val;
 313
 314   while (value_history_chain)
 315     {
 316       for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
 317         if (val = value_history_chain->values[i])
 318           free ((PTR)val);
 319       next = value_history_chain->next;
 320       free ((PTR)value_history_chain);
 321       value_history_chain = next;
 322     }
 323   value_history_count = 0;
 324 }
 325
 326 static void
 327 show_values (num_exp, from_tty)
 328      char *num_exp;
 329      int from_tty;
 330 {
 331   register int i;
 332   register value val;
 333   static int num = 1;
 334
 335   if (num_exp)
 336     {
 337       if (num_exp[0] == '+' && num_exp[1] == '\0')
 338         /* "info history +" should print from the stored position.  */
 339         ;
 340       else
 341         /* "info history <exp>" should print around value number <exp>.  */
 342         num = parse_and_eval_address (num_exp) - 5;
 343     }
 344   else
 345     {
 346       /* "info history" means print the last 10 values.  */
 347       num = value_history_count - 9;
 348     }
 349
 350   if (num <= 0)
 351     num = 1;
 352
 353   for (i = num; i < num + 10 && i <= value_history_count; i++)
 354     {
 355       val = access_value_history (i);
 356       printf_filtered ("$%d = ", i);
 357       value_print (val, stdout, 0, Val_pretty_default);
 358       printf_filtered ("\n");
 359     }
 360
 361   /* The next "info history +" should start after what we just printed.  */
 362   num += 10;
 363
 364   /* Hitting just return after this command should do the same thing as
 365      "info history +".  If num_exp is null, this is unnecessary, since
 366      "info history +" is not useful after "info history".  */
 367   if (from_tty && num_exp)
 368     {
 369       num_exp[0] = '+';
 370       num_exp[1] = '\0';
 371     }
 372 }
 373 \f
 374 /* Internal variables.  These are variables within the debugger
 375    that hold values assigned by debugger commands.
 376    The user refers to them with a '$' prefix
 377    that does not appear in the variable names stored internally.  */
 378
 379 static struct internalvar *internalvars;
 380
 381 /* Look up an internal variable with name NAME.  NAME should not
 382    normally include a dollar sign.
 383
 384    If the specified internal variable does not exist,
 385    one is created, with a void value.  */
 386
 387 struct internalvar *
 388 lookup_internalvar (name)
 389      char *name;
 390 {
 391   register struct internalvar *var;
 392
 393   for (var = internalvars; var; var = var->next)
 394     if (!strcmp (var->name, name))
 395       return var;
 396
 397   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
 398   var->name = concat (name, NULL);
 399   var->value = allocate_value (builtin_type_void);
 400   release_value (var->value);
 401   var->next = internalvars;
 402   internalvars = var;
 403   return var;
 404 }
 405
 406 value
 407 value_of_internalvar (var)
 408      struct internalvar *var;
 409 {
 410   register value val;
 411
 412 #ifdef IS_TRAPPED_INTERNALVAR
 413   if (IS_TRAPPED_INTERNALVAR (var->name))
 414     return VALUE_OF_TRAPPED_INTERNALVAR (var);
 415 #endif
 416
 417   val = value_copy (var->value);
 418   if (VALUE_LAZY (val))
 419     value_fetch_lazy (val);
 420   VALUE_LVAL (val) = lval_internalvar;
 421   VALUE_INTERNALVAR (val) = var;
 422   return val;
 423 }
 424
 425 void
 426 set_internalvar_component (var, offset, bitpos, bitsize, newval)
 427      struct internalvar *var;
 428      int offset, bitpos, bitsize;
 429      value newval;
 430 {
 431   register char *addr = VALUE_CONTENTS (var->value) + offset;
 432
 433 #ifdef IS_TRAPPED_INTERNALVAR
 434   if (IS_TRAPPED_INTERNALVAR (var->name))
 435     SET_TRAPPED_INTERNALVAR (var, newval, bitpos, bitsize, offset);
 436 #endif
 437
 438   if (bitsize)
 439     modify_field (addr, (int) value_as_long (newval),
 440                   bitpos, bitsize);
 441   else
 442     memcpy (addr, VALUE_CONTENTS (newval), TYPE_LENGTH (VALUE_TYPE (newval)));
 443 }
 444
 445 void
 446 set_internalvar (var, val)
 447      struct internalvar *var;
 448      value val;
 449 {
 450 #ifdef IS_TRAPPED_INTERNALVAR
 451   if (IS_TRAPPED_INTERNALVAR (var->name))
 452     SET_TRAPPED_INTERNALVAR (var, val, 0, 0, 0);
 453 #endif
 454
 455   free ((PTR)var->value);
 456   var->value = value_copy (val);
 457   /* Force the value to be fetched from the target now, to avoid problems
 458      later when this internalvar is referenced and the target is gone or
 459      has changed.  */
 460   if (VALUE_LAZY (var->value))
 461     value_fetch_lazy (var->value);
 462   release_value (var->value);
 463 }
 464
 465 char *
 466 internalvar_name (var)
 467      struct internalvar *var;
 468 {
 469   return var->name;
 470 }
 471
 472 /* Free all internalvars.  Done when new symtabs are loaded,
 473    because that makes the values invalid.  */
 474
 475 void
 476 clear_internalvars ()
 477 {
 478   register struct internalvar *var;
 479
 480   while (internalvars)
 481     {
 482       var = internalvars;
 483       internalvars = var->next;
 484       free ((PTR)var->name);
 485       free ((PTR)var->value);
 486       free ((PTR)var);
 487     }
 488 }
 489
 490 static void
 491 show_convenience (ignore, from_tty)
 492      char *ignore;
 493      int from_tty;
 494 {
 495   register struct internalvar *var;
 496   int varseen = 0;
 497
 498   for (var = internalvars; var; var = var->next)
 499     {
 500 #ifdef IS_TRAPPED_INTERNALVAR
 501       if (IS_TRAPPED_INTERNALVAR (var->name))
 502         continue;
 503 #endif
 504       if (!varseen)
 505         {
 506           varseen = 1;
 507         }
 508       printf_filtered ("$%s = ", var->name);
 509       value_print (var->value, stdout, 0, Val_pretty_default);
 510       printf_filtered ("\n");
 511     }
 512   if (!varseen)
 513     printf ("No debugger convenience variables now defined.\n\
 514 Convenience variables have names starting with \"$\";\n\
 515 use \"set\" as in \"set $foo = 5\" to define them.\n");
 516 }
 517 \f
 518 /* Extract a value as a C number (either long or double).
 519    Knows how to convert fixed values to double, or
 520    floating values to long.
 521    Does not deallocate the value.  */
 522
 523 LONGEST
 524 value_as_long (val)
 525      register value val;
 526 {
 527   /* This coerces arrays and functions, which is necessary (e.g.
 528      in disassemble_command).  It also dereferences references, which
 529      I suspect is the most logical thing to do.  */
 530   if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM)
 531     COERCE_ARRAY (val);
 532   return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
 533 }
 534
 535 double
 536 value_as_double (val)
 537      register value val;
 538 {
 539   double foo;
 540   int inv;
 541
 542   foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
 543   if (inv)
 544     error ("Invalid floating value found in program.");
 545   return foo;
 546 }
 547 /* Extract a value as a C pointer.
 548    Does not deallocate the value.  */
 549 CORE_ADDR
 550 value_as_pointer (val)
 551      value val;
 552 {
 553   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 554      whether we want this to be true eventually.  */
 555   return ADDR_BITS_REMOVE(value_as_long (val));
 556 }
 557 \f
 558 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 559    as a long, or as a double, assuming the raw data is described
 560    by type TYPE.  Knows how to convert different sizes of values
 561    and can convert between fixed and floating point.  We don't assume
 562    any alignment for the raw data.  Return value is in host byte order.
 563
 564    If you want functions and arrays to be coerced to pointers, and
 565    references to be dereferenced, call value_as_long() instead.
 566
 567    C++: It is assumed that the front-end has taken care of
 568    all matters concerning pointers to members.  A pointer
 569    to member which reaches here is considered to be equivalent
 570    to an INT (or some size).  After all, it is only an offset.  */
 571
 572 /* FIXME:  This should be rewritten as a switch statement for speed and
 573    ease of comprehension.  */
 574
 575 LONGEST
 576 unpack_long (type, valaddr)
 577      struct type *type;
 578      char *valaddr;
 579 {
 580   register enum type_code code = TYPE_CODE (type);
 581   register int len = TYPE_LENGTH (type);
 582   register int nosign = TYPE_UNSIGNED (type);
 583
 584   if (code == TYPE_CODE_ENUM || code == TYPE_CODE_BOOL)
 585     code = TYPE_CODE_INT;
 586   if (code == TYPE_CODE_FLT)
 587     {
 588       if (len == sizeof (float))
 589         {
 590           float retval;
 591           memcpy (&retval, valaddr, sizeof (retval));
 592           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 593           return retval;
 594         }
 595
 596       if (len == sizeof (double))
 597         {
 598           double retval;
 599           memcpy (&retval, valaddr, sizeof (retval));
 600           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 601           return retval;
 602         }
 603       else
 604         {
 605           error ("Unexpected type of floating point number.");
 606         }
 607     }
 608   else if (code == TYPE_CODE_INT && nosign)
 609     {
 610       if (len == sizeof (char))
 611         {
 612           unsigned char retval = * (unsigned char *) valaddr;
 613           /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
 614           return retval;
 615         }
 616
 617       if (len == sizeof (short))
 618         {
 619           unsigned short retval;
 620           memcpy (&retval, valaddr, sizeof (retval));
 621           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 622           return retval;
 623         }
 624
 625       if (len == sizeof (int))
 626         {
 627           unsigned int retval;
 628           memcpy (&retval, valaddr, sizeof (retval));
 629           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 630           return retval;
 631         }
 632
 633       if (len == sizeof (long))
 634         {
 635           unsigned long retval;
 636           memcpy (&retval, valaddr, sizeof (retval));
 637           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 638           return retval;
 639         }
 640 #ifdef LONG_LONG
 641       if (len == sizeof (long long))
 642         {
 643           unsigned long long retval;
 644           memcpy (&retval, valaddr, sizeof (retval));
 645           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 646           return retval;
 647         }
 648 #endif
 649       else
 650         {
 651           error ("That operation is not possible on an integer of that size.");
 652         }
 653     }
 654   else if (code == TYPE_CODE_INT)
 655     {
 656       if (len == sizeof (char))
 657         {
 658           SIGNED char retval;   /* plain chars might be unsigned on host */
 659           memcpy (&retval, valaddr, sizeof (retval));
 660           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 661           return retval;
 662         }
 663
 664       if (len == sizeof (short))
 665         {
 666           short retval;
 667           memcpy (&retval, valaddr, sizeof (retval));
 668           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 669           return retval;
 670         }
 671
 672       if (len == sizeof (int))
 673         {
 674           int retval;
 675           memcpy (&retval, valaddr, sizeof (retval));
 676           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 677           return retval;
 678         }
 679
 680       if (len == sizeof (long))
 681         {
 682           long retval;
 683           memcpy (&retval, valaddr, sizeof (retval));
 684           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 685           return retval;
 686         }
 687
 688 #ifdef LONG_LONG
 689       if (len == sizeof (long long))
 690         {
 691           long long retval;
 692           memcpy (&retval, valaddr, sizeof (retval));
 693           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 694           return retval;
 695         }
 696 #endif
 697       else
 698         {
 699           error ("That operation is not possible on an integer of that size.");
 700         }
 701     }
 702   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 703      whether we want this to be true eventually.  */
 704   else if (code == TYPE_CODE_PTR
 705            || code == TYPE_CODE_REF)
 706     {
 707       if (len == sizeof(long))
 708       {
 709         unsigned long retval;
 710         memcpy (&retval, valaddr, sizeof(retval));
 711         SWAP_TARGET_AND_HOST (&retval, sizeof(retval));
 712         return retval;
 713       }
 714       else if (len == sizeof(short))
 715       {
 716         unsigned short retval;
 717         memcpy (&retval, valaddr, len);
 718         SWAP_TARGET_AND_HOST (&retval, len);
 719         return retval;
 720       }
 721     }
 722   else if (code == TYPE_CODE_MEMBER)
 723     error ("not implemented: member types in unpack_long");
 724   else if (code == TYPE_CODE_CHAR)
 725     return *(unsigned char *)valaddr;
 726
 727   error ("Value not integer or pointer.");
 728   return 0;     /* For lint -- never reached */
 729 }
 730
 731 /* Return a double value from the specified type and address.
 732    INVP points to an int which is set to 0 for valid value,
 733    1 for invalid value (bad float format).  In either case,
 734    the returned double is OK to use.  Argument is in target
 735    format, result is in host format.  */
 736
 737 double
 738 unpack_double (type, valaddr, invp)
 739      struct type *type;
 740      char *valaddr;
 741      int *invp;
 742 {
 743   register enum type_code code = TYPE_CODE (type);
 744   register int len = TYPE_LENGTH (type);
 745   register int nosign = TYPE_UNSIGNED (type);
 746
 747   *invp = 0;                    /* Assume valid.   */
 748   if (code == TYPE_CODE_FLT)
 749     {
 750       if (INVALID_FLOAT (valaddr, len))
 751         {
 752           *invp = 1;
 753           return 1.234567891011121314;
 754         }
 755
 756       if (len == sizeof (float))
 757         {
 758           float retval;
 759           memcpy (&retval, valaddr, sizeof (retval));
 760           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 761           return retval;
 762         }
 763
 764       if (len == sizeof (double))
 765         {
 766           double retval;
 767           memcpy (&retval, valaddr, sizeof (retval));
 768           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 769           return retval;
 770         }
 771       else
 772         {
 773           error ("Unexpected type of floating point number.");
 774           return 0; /* Placate lint.  */
 775         }
 776     }
 777   else if (nosign) {
 778    /* Unsigned -- be sure we compensate for signed LONGEST.  */
 779 #ifdef LONG_LONG
 780    return (unsigned long long) unpack_long (type, valaddr);
 781 #else
 782    return (unsigned long     ) unpack_long (type, valaddr);
 783 #endif
 784   } else {
 785     /* Signed -- we are OK with unpack_long.  */
 786     return unpack_long (type, valaddr);
 787   }
 788 }
 789
 790 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 791    as a CORE_ADDR, assuming the raw data is described by type TYPE.
 792    We don't assume any alignment for the raw data.  Return value is in
 793    host byte order.
 794
 795    If you want functions and arrays to be coerced to pointers, and
 796    references to be dereferenced, call value_as_pointer() instead.
 797
 798    C++: It is assumed that the front-end has taken care of
 799    all matters concerning pointers to members.  A pointer
 800    to member which reaches here is considered to be equivalent
 801    to an INT (or some size).  After all, it is only an offset.  */
 802
 803 CORE_ADDR
 804 unpack_pointer (type, valaddr)
 805      struct type *type;
 806      char *valaddr;
 807 {
 808 #if 0
 809   /* The user should be able to use an int (e.g. 0x7892) in contexts
 810      where a pointer is expected.  So this doesn't do enough.  */
 811   register enum type_code code = TYPE_CODE (type);
 812   register int len = TYPE_LENGTH (type);
 813
 814   if (code == TYPE_CODE_PTR
 815       || code == TYPE_CODE_REF)
 816     {
 817       if (len == sizeof (CORE_ADDR))
 818         {
 819           CORE_ADDR retval;
 820           memcpy (&retval, valaddr, sizeof (retval));
 821           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 822           return retval;
 823         }
 824       error ("Unrecognized pointer size.");
 825     }
 826   else if (code == TYPE_CODE_MEMBER)
 827     error ("not implemented: member types in unpack_pointer");
 828
 829   error ("Value is not a pointer.");
 830   return 0;     /* For lint -- never reached */
 831 #else
 832   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 833      whether we want this to be true eventually.  */
 834   return unpack_long (type, valaddr);
 835 #endif
 836 }
 837 \f
 838 /* Given a value ARG1 (offset by OFFSET bytes)
 839    of a struct or union type ARG_TYPE,
 840    extract and return the value of one of its fields.
 841    FIELDNO says which field.
 842
 843    For C++, must also be able to return values from static fields */
 844
 845 value
 846 value_primitive_field (arg1, offset, fieldno, arg_type)
 847      register value arg1;
 848      int offset;
 849      register int fieldno;
 850      register struct type *arg_type;
 851 {
 852   register value v;
 853   register struct type *type;
 854
 855   check_stub_type (arg_type);
 856   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 857
 858   /* Handle packed fields */
 859
 860   offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
 861   if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
 862     {
 863       v = value_from_longest (type,
 864                            unpack_field_as_long (arg_type,
 865                                                  VALUE_CONTENTS (arg1),
 866                                                  fieldno));
 867       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
 868       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
 869     }
 870   else
 871     {
 872       v = allocate_value (type);
 873       if (VALUE_LAZY (arg1))
 874         VALUE_LAZY (v) = 1;
 875       else
 876         memcpy (VALUE_CONTENTS_RAW (v), VALUE_CONTENTS_RAW (arg1) + offset,
 877                 TYPE_LENGTH (type));
 878     }
 879   VALUE_LVAL (v) = VALUE_LVAL (arg1);
 880   if (VALUE_LVAL (arg1) == lval_internalvar)
 881     VALUE_LVAL (v) = lval_internalvar_component;
 882   VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
 883   VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
 884   return v;
 885 }
 886
 887 /* Given a value ARG1 of a struct or union type,
 888    extract and return the value of one of its fields.
 889    FIELDNO says which field.
 890
 891    For C++, must also be able to return values from static fields */
 892
 893 value
 894 value_field (arg1, fieldno)
 895      register value arg1;
 896      register int fieldno;
 897 {
 898   return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
 899 }
 900
 901 /* Return a non-virtual function as a value.
 902    F is the list of member functions which contains the desired method.
 903    J is an index into F which provides the desired method. */
 904
 905 value
 906 value_fn_field (f, j)
 907      struct fn_field *f;
 908      int j;
 909 {
 910   register value v;
 911   register struct type *type = TYPE_FN_FIELD_TYPE (f, j);
 912   struct symbol *sym;
 913
 914   sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
 915                        0, VAR_NAMESPACE, 0, NULL);
 916   if (! sym) error ("Internal error: could not find physical method named %s",
 917                     TYPE_FN_FIELD_PHYSNAME (f, j));
 918
 919   v = allocate_value (type);
 920   VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
 921   VALUE_TYPE (v) = type;
 922   return v;
 923 }
 924
 925 /* Return a virtual function as a value.
 926    ARG1 is the object which provides the virtual function
 927    table pointer.  ARG1 is side-effected in calling this function.
 928    F is the list of member functions which contains the desired virtual
 929    function.
 930    J is an index into F which provides the desired virtual function.
 931
 932    TYPE is the type in which F is located.  */
 933 value
 934 value_virtual_fn_field (arg1, f, j, type)
 935      value arg1;
 936      struct fn_field *f;
 937      int j;
 938      struct type *type;
 939 {
 940   /* First, get the virtual function table pointer.  That comes
 941      with a strange type, so cast it to type `pointer to long' (which
 942      should serve just fine as a function type).  Then, index into
 943      the table, and convert final value to appropriate function type.  */
 944   value entry, vfn, vtbl;
 945   value vi = value_from_longest (builtin_type_int,
 946                               (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
 947   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 948   struct type *context;
 949   if (fcontext == NULL)
 950    /* We don't have an fcontext (e.g. the program was compiled with
 951       g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
 952       This won't work right for multiple inheritance, but at least we
 953       should do as well as GDB 3.x did.  */
 954     fcontext = TYPE_VPTR_BASETYPE (type);
 955   context = lookup_pointer_type (fcontext);
 956   /* Now context is a pointer to the basetype containing the vtbl.  */
 957   if (TYPE_TARGET_TYPE (context) != VALUE_TYPE (arg1))
 958     arg1 = value_ind (value_cast (context, value_addr (arg1)));
 959
 960   context = VALUE_TYPE (arg1);
 961   /* Now context is the basetype containing the vtbl.  */
 962
 963   /* This type may have been defined before its virtual function table
 964      was.  If so, fill in the virtual function table entry for the
 965      type now.  */
 966   if (TYPE_VPTR_FIELDNO (context) < 0)
 967     fill_in_vptr_fieldno (context);
 968
 969   /* The virtual function table is now an array of structures
 970      which have the form { int16 offset, delta; void *pfn; }.  */
 971   vtbl = value_ind (value_field (arg1, TYPE_VPTR_FIELDNO (context)));
 972
 973   /* Index into the virtual function table.  This is hard-coded because
 974      looking up a field is not cheap, and it may be important to save
 975      time, e.g. if the user has set a conditional breakpoint calling
 976      a virtual function.  */
 977   entry = value_subscript (vtbl, vi);
 978
 979   /* Move the `this' pointer according to the virtual function table.  */
 980   VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0));
 981   if (! VALUE_LAZY (arg1))
 982     {
 983       VALUE_LAZY (arg1) = 1;
 984       value_fetch_lazy (arg1);
 985     }
 986
 987   vfn = value_field (entry, 2);
 988   /* Reinstantiate the function pointer with the correct type.  */
 989   VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
 990
 991   return vfn;
 992 }
 993
 994 /* ARG is a pointer to an object we know to be at least
 995    a DTYPE.  BTYPE is the most derived basetype that has
 996    already been searched (and need not be searched again).
 997    After looking at the vtables between BTYPE and DTYPE,
 998    return the most derived type we find.  The caller must
 999    be satisfied when the return value == DTYPE.
1000
1001    FIXME-tiemann: should work with dossier entries as well.  */
1002
1003 static value
1004 value_headof (arg, btype, dtype)
1005      value arg;
1006      struct type *btype, *dtype;
1007 {
1008   /* First collect the vtables we must look at for this object.  */
1009   /* FIXME-tiemann: right now, just look at top-most vtable.  */
1010   value vtbl, entry, best_entry = 0;
1011   int i, nelems;
1012   int offset, best_offset = 0;
1013   struct symbol *sym;
1014   CORE_ADDR pc_for_sym;
1015   char *demangled_name;
1016   struct minimal_symbol *msymbol;
1017
1018   btype = TYPE_VPTR_BASETYPE (dtype);
1019   check_stub_type (btype);
1020   if (btype != dtype)
1021     vtbl = value_cast (lookup_pointer_type (btype), arg);
1022   else
1023     vtbl = arg;
1024   vtbl = value_ind (value_field (value_ind (vtbl), TYPE_VPTR_FIELDNO (btype)));
1025
1026   /* Check that VTBL looks like it points to a virtual function table.  */
1027   msymbol = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl));
1028   if (msymbol == NULL
1029       || !VTBL_PREFIX_P (demangled_name = msymbol -> name))
1030     {
1031       /* If we expected to find a vtable, but did not, let the user
1032          know that we aren't happy, but don't throw an error.
1033          FIXME: there has to be a better way to do this.  */
1034       struct type *error_type = (struct type *)xmalloc (sizeof (struct type));
1035       memcpy (error_type, VALUE_TYPE (arg), sizeof (struct type));
1036       TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
1037       VALUE_TYPE (arg) = error_type;
1038       return arg;
1039     }
1040
1041   /* Now search through the virtual function table.  */
1042   entry = value_ind (vtbl);
1043   nelems = longest_to_int (value_as_long (value_field (entry, 2)));
1044   for (i = 1; i <= nelems; i++)
1045     {
1046       entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
1047                                                       (LONGEST) i));
1048       offset = longest_to_int (value_as_long (value_field (entry, 0)));
1049       /* If we use '<=' we can handle single inheritance
1050        * where all offsets are zero - just use the first entry found. */
1051       if (offset <= best_offset)
1052         {
1053           best_offset = offset;
1054           best_entry = entry;
1055         }
1056     }
1057   /* Move the pointer according to BEST_ENTRY's offset, and figure
1058      out what type we should return as the new pointer.  */
1059   if (best_entry == 0)
1060     {
1061       /* An alternative method (which should no longer be necessary).
1062        * But we leave it in for future use, when we will hopefully
1063        * have optimizes the vtable to use thunks instead of offsets. */
1064       /* Use the name of vtable itself to extract a base type. */
1065       demangled_name += 4;  /* Skip _vt$ prefix. */
1066     }
1067   else
1068     {
1069       pc_for_sym = value_as_pointer (value_field (best_entry, 2));
1070       sym = find_pc_function (pc_for_sym);
1071       demangled_name = cplus_demangle (SYMBOL_NAME (sym), DMGL_ANSI);
1072       *(strchr (demangled_name, ':')) = '\0';
1073     }
1074   sym = lookup_symbol (demangled_name, 0, VAR_NAMESPACE, 0, 0);
1075   if (sym == 0)
1076     error ("could not find type declaration for `%s'", SYMBOL_NAME (sym));
1077   if (best_entry)
1078     {
1079       free (demangled_name);
1080       arg = value_add (value_cast (builtin_type_int, arg),
1081                        value_field (best_entry, 0));
1082     }
1083   VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym));
1084   return arg;
1085 }
1086
1087 /* ARG is a pointer object of type TYPE.  If TYPE has virtual
1088    function tables, probe ARG's tables (including the vtables
1089    of its baseclasses) to figure out the most derived type that ARG
1090    could actually be a pointer to.  */
1091
1092 value
1093 value_from_vtable_info (arg, type)
1094      value arg;
1095      struct type *type;
1096 {
1097   /* Take care of preliminaries.  */
1098   if (TYPE_VPTR_FIELDNO (type) < 0)
1099     fill_in_vptr_fieldno (type);
1100   if (TYPE_VPTR_FIELDNO (type) < 0 || VALUE_REPEATED (arg))
1101     return 0;
1102
1103   return value_headof (arg, 0, type);
1104 }
1105
1106 /* Compute the address of the baseclass which is
1107    the INDEXth baseclass of class TYPE.  The TYPE base
1108    of the object is at VALADDR.
1109
1110    If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1111    or 0 if no error.  In that case the return value is not the address
1112    of the baseclasss, but the address which could not be read
1113    successfully.  */
1114
1115 char *
1116 baseclass_addr (type, index, valaddr, valuep, errp)
1117      struct type *type;
1118      int index;
1119      char *valaddr;
1120      value *valuep;
1121      int *errp;
1122 {
1123   struct type *basetype = TYPE_BASECLASS (type, index);
1124
1125   if (errp)
1126     *errp = 0;
1127
1128   if (BASETYPE_VIA_VIRTUAL (type, index))
1129     {
1130       /* Must hunt for the pointer to this virtual baseclass.  */
1131       register int i, len = TYPE_NFIELDS (type);
1132       register int n_baseclasses = TYPE_N_BASECLASSES (type);
1133       char *vbase_name, *type_name = type_name_no_tag (basetype);
1134
1135       vbase_name = (char *)alloca (strlen (type_name) + 8);
1136       sprintf (vbase_name, "_vb$%s", type_name);
1137       /* First look for the virtual baseclass pointer
1138          in the fields.  */
1139       for (i = n_baseclasses; i < len; i++)
1140         {
1141           if (! strcmp (vbase_name, TYPE_FIELD_NAME (type, i)))
1142             {
1143               value val = allocate_value (basetype);
1144               CORE_ADDR addr;
1145               int status;
1146
1147               addr
1148                 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1149                                   valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
1150
1151               status = target_read_memory (addr,
1152                                            VALUE_CONTENTS_RAW (val),
1153                                            TYPE_LENGTH (basetype));
1154               VALUE_LVAL (val) = lval_memory;
1155               VALUE_ADDRESS (val) = addr;
1156
1157               if (status != 0)
1158                 {
1159                   if (valuep)
1160                     *valuep = NULL;
1161                   release_value (val);
1162                   value_free (val);
1163                   if (errp)
1164                     *errp = status;
1165                   return (char *)addr;
1166                 }
1167               else
1168                 {
1169                   if (valuep)
1170                     *valuep = val;
1171                   return (char *) VALUE_CONTENTS (val);
1172                 }
1173             }
1174         }
1175       /* Not in the fields, so try looking through the baseclasses.  */
1176       for (i = index+1; i < n_baseclasses; i++)
1177         {
1178           char *baddr;
1179
1180           baddr = baseclass_addr (type, i, valaddr, valuep, errp);
1181           if (baddr)
1182             return baddr;
1183         }
1184       /* Not found.  */
1185       if (valuep)
1186         *valuep = 0;
1187       return 0;
1188     }
1189
1190   /* Baseclass is easily computed.  */
1191   if (valuep)
1192     *valuep = 0;
1193   return valaddr + TYPE_BASECLASS_BITPOS (type, index) / 8;
1194 }
1195 \f
1196 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1197    VALADDR.
1198
1199    Extracting bits depends on endianness of the machine.  Compute the
1200    number of least significant bits to discard.  For big endian machines,
1201    we compute the total number of bits in the anonymous object, subtract
1202    off the bit count from the MSB of the object to the MSB of the
1203    bitfield, then the size of the bitfield, which leaves the LSB discard
1204    count.  For little endian machines, the discard count is simply the
1205    number of bits from the LSB of the anonymous object to the LSB of the
1206    bitfield.
1207
1208    If the field is signed, we also do sign extension. */
1209
1210 LONGEST
1211 unpack_field_as_long (type, valaddr, fieldno)
1212      struct type *type;
1213      char *valaddr;
1214      int fieldno;
1215 {
1216   unsigned LONGEST val;
1217   unsigned LONGEST valmask;
1218   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1219   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1220   int lsbcount;
1221
1222   memcpy (&val, valaddr + bitpos / 8, sizeof (val));
1223   SWAP_TARGET_AND_HOST (&val, sizeof (val));
1224
1225   /* Extract bits.  See comment above. */
1226
1227 #if BITS_BIG_ENDIAN
1228   lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1229 #else
1230   lsbcount = (bitpos % 8);
1231 #endif
1232   val >>= lsbcount;
1233
1234   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1235      If the field is signed, and is negative, then sign extend. */
1236
1237   if ((bitsize > 0) && (bitsize < 8 * sizeof (val)))
1238     {
1239       valmask = (((unsigned LONGEST) 1) << bitsize) - 1;
1240       val &= valmask;
1241       if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type, fieldno)))
1242         {
1243           if (val & (valmask ^ (valmask >> 1)))
1244             {
1245               val |= ~valmask;
1246             }
1247         }
1248     }
1249   return (val);
1250 }
1251
1252 /* Modify the value of a bitfield.  ADDR points to a block of memory in
1253    target byte order; the bitfield starts in the byte pointed to.  FIELDVAL
1254    is the desired value of the field, in host byte order.  BITPOS and BITSIZE
1255    indicate which bits (in target bit order) comprise the bitfield.  */
1256
1257 void
1258 modify_field (addr, fieldval, bitpos, bitsize)
1259      char *addr;
1260      int fieldval;
1261      int bitpos, bitsize;
1262 {
1263   long oword;
1264
1265   /* Reject values too big to fit in the field in question,
1266      otherwise adjoining fields may be corrupted.  */
1267   if (bitsize < (8 * sizeof (fieldval))
1268       && 0 != (fieldval & ~((1<<bitsize)-1)))
1269     error ("Value %d does not fit in %d bits.", fieldval, bitsize);
1270
1271   memcpy (&oword, addr, sizeof oword);
1272   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To host format */
1273
1274   /* Shifting for bit field depends on endianness of the target machine.  */
1275 #if BITS_BIG_ENDIAN
1276   bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1277 #endif
1278
1279   /* Mask out old value, while avoiding shifts >= longword size */
1280   if (bitsize < 8 * sizeof (oword))
1281     oword &= ~(((((unsigned long)1) << bitsize) - 1) << bitpos);
1282   else
1283     oword &= ~((-1) << bitpos);
1284   oword |= fieldval << bitpos;
1285
1286   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To target format */
1287   memcpy (addr, &oword, sizeof oword);
1288 }
1289 \f
1290 /* Convert C numbers into newly allocated values */
1291
1292 value
1293 value_from_longest (type, num)
1294      struct type *type;
1295      register LONGEST num;
1296 {
1297   register value val = allocate_value (type);
1298   register enum type_code code = TYPE_CODE (type);
1299   register int len = TYPE_LENGTH (type);
1300
1301   /* FIXME, we assume that pointers have the same form and byte order as
1302      integers, and that all pointers have the same form.  */
1303   if (code == TYPE_CODE_INT  || code == TYPE_CODE_ENUM ||
1304       code == TYPE_CODE_CHAR || code == TYPE_CODE_PTR ||
1305       code == TYPE_CODE_REF)
1306     {
1307       if (len == sizeof (char))
1308         * (char *) VALUE_CONTENTS_RAW (val) = num;
1309       else if (len == sizeof (short))
1310         * (short *) VALUE_CONTENTS_RAW (val) = num;
1311       else if (len == sizeof (int))
1312         * (int *) VALUE_CONTENTS_RAW (val) = num;
1313       else if (len == sizeof (long))
1314         * (long *) VALUE_CONTENTS_RAW (val) = num;
1315 #ifdef LONG_LONG
1316       else if (len == sizeof (long long))
1317         * (long long *) VALUE_CONTENTS_RAW (val) = num;
1318 #endif
1319       else
1320         error ("Integer type encountered with unexpected data length.");
1321     }
1322   else
1323     error ("Unexpected type encountered for integer constant.");
1324
1325   /* num was in host byte order.  So now put the value's contents
1326      into target byte order.  */
1327   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1328
1329   return val;
1330 }
1331
1332 value
1333 value_from_double (type, num)
1334      struct type *type;
1335      double num;
1336 {
1337   register value val = allocate_value (type);
1338   register enum type_code code = TYPE_CODE (type);
1339   register int len = TYPE_LENGTH (type);
1340
1341   if (code == TYPE_CODE_FLT)
1342     {
1343       if (len == sizeof (float))
1344         * (float *) VALUE_CONTENTS_RAW (val) = num;
1345       else if (len == sizeof (double))
1346         * (double *) VALUE_CONTENTS_RAW (val) = num;
1347       else
1348         error ("Floating type encountered with unexpected data length.");
1349     }
1350   else
1351     error ("Unexpected type encountered for floating constant.");
1352
1353   /* num was in host byte order.  So now put the value's contents
1354      into target byte order.  */
1355   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1356
1357   return val;
1358 }
1359 \f
1360 /* Deal with the value that is "about to be returned".  */
1361
1362 /* Return the value that a function returning now
1363    would be returning to its caller, assuming its type is VALTYPE.
1364    RETBUF is where we look for what ought to be the contents
1365    of the registers (in raw form).  This is because it is often
1366    desirable to restore old values to those registers
1367    after saving the contents of interest, and then call
1368    this function using the saved values.
1369    struct_return is non-zero when the function in question is
1370    using the structure return conventions on the machine in question;
1371    0 when it is using the value returning conventions (this often
1372    means returning pointer to where structure is vs. returning value). */
1373
1374 value
1375 value_being_returned (valtype, retbuf, struct_return)
1376      register struct type *valtype;
1377      char retbuf[REGISTER_BYTES];
1378      int struct_return;
1379      /*ARGSUSED*/
1380 {
1381   register value val;
1382   CORE_ADDR addr;
1383
1384 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1385   /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
1386   if (struct_return) {
1387     addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
1388     if (!addr)
1389       error ("Function return value unknown");
1390     return value_at (valtype, addr);
1391   }
1392 #endif
1393
1394   val = allocate_value (valtype);
1395   EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1396
1397   return val;
1398 }
1399
1400 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1401    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1402    and TYPE is the type (which is known to be struct, union or array).
1403
1404    On most machines, the struct convention is used unless we are
1405    using gcc and the type is of a special size.  */
1406 #if !defined (USE_STRUCT_CONVENTION)
1407 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1408   (!((gcc_p) && (TYPE_LENGTH (value_type) == 1                \
1409                  || TYPE_LENGTH (value_type) == 2             \
1410                  || TYPE_LENGTH (value_type) == 4             \
1411                  || TYPE_LENGTH (value_type) == 8             \
1412                  )                                            \
1413      ))
1414 #endif
1415
1416 /* Return true if the function specified is using the structure returning
1417    convention on this machine to return arguments, or 0 if it is using
1418    the value returning convention.  FUNCTION is the value representing
1419    the function, FUNCADDR is the address of the function, and VALUE_TYPE
1420    is the type returned by the function.  GCC_P is nonzero if compiled
1421    with GCC.  */
1422
1423 int
1424 using_struct_return (function, funcaddr, value_type, gcc_p)
1425      value function;
1426      CORE_ADDR funcaddr;
1427      struct type *value_type;
1428      int gcc_p;
1429      /*ARGSUSED*/
1430 {
1431   register enum type_code code = TYPE_CODE (value_type);
1432
1433   if (code == TYPE_CODE_ERROR)
1434     error ("Function return type unknown.");
1435
1436   if (code == TYPE_CODE_STRUCT ||
1437       code == TYPE_CODE_UNION ||
1438       code == TYPE_CODE_ARRAY)
1439     return USE_STRUCT_CONVENTION (gcc_p, value_type);
1440
1441   return 0;
1442 }
1443
1444 /* Store VAL so it will be returned if a function returns now.
1445    Does not verify that VAL's type matches what the current
1446    function wants to return.  */
1447
1448 void
1449 set_return_value (val)
1450      value val;
1451 {
1452   register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
1453   double dbuf;
1454   LONGEST lbuf;
1455
1456   if (code == TYPE_CODE_ERROR)
1457     error ("Function return type unknown.");
1458
1459   if (   code == TYPE_CODE_STRUCT
1460       || code == TYPE_CODE_UNION)       /* FIXME, implement struct return.  */
1461     error ("GDB does not support specifying a struct or union return value.");
1462
1463   /* FIXME, this is bogus.  We don't know what the return conventions
1464      are, or how values should be promoted.... */
1465   if (code == TYPE_CODE_FLT)
1466     {
1467       dbuf = value_as_double (val);
1468
1469       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&dbuf);
1470     }
1471   else
1472     {
1473       lbuf = value_as_long (val);
1474       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&lbuf);
1475     }
1476 }
1477 \f
1478 void
1479 _initialize_values ()
1480 {
1481   add_cmd ("convenience", no_class, show_convenience,
1482             "Debugger convenience (\"$foo\") variables.\n\
1483 These variables are created when you assign them values;\n\
1484 thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
1485 A few convenience variables are given values automatically:\n\
1486 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1487 \"$__\" holds the contents of the last address examined with \"x\".",
1488            &showlist);
1489
1490   add_cmd ("values", no_class, show_values,
1491            "Elements of value history around item number IDX (or last ten).",
1492            &showlist);
1493 }