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]) != NULL)
 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 (STREQ (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 || code == TYPE_CODE_REF)
 705     {
 706       if (len == sizeof(long))
 707       {
 708         unsigned long retval;
 709         memcpy (&retval, valaddr, sizeof(retval));
 710         SWAP_TARGET_AND_HOST (&retval, sizeof(retval));
 711         return retval;
 712       }
 713       else if (len == sizeof(short))
 714       {
 715         unsigned short retval;
 716         memcpy (&retval, valaddr, len);
 717         SWAP_TARGET_AND_HOST (&retval, len);
 718         return retval;
 719       }
 720     }
 721   else if (code == TYPE_CODE_MEMBER)
 722     error ("not implemented: member types in unpack_long");
 723   else if (code == TYPE_CODE_CHAR)
 724     return *(unsigned char *)valaddr;
 725
 726   error ("Value not integer or pointer.");
 727   return 0;     /* For lint -- never reached */
 728 }
 729
 730 /* Return a double value from the specified type and address.
 731    INVP points to an int which is set to 0 for valid value,
 732    1 for invalid value (bad float format).  In either case,
 733    the returned double is OK to use.  Argument is in target
 734    format, result is in host format.  */
 735
 736 double
 737 unpack_double (type, valaddr, invp)
 738      struct type *type;
 739      char *valaddr;
 740      int *invp;
 741 {
 742   register enum type_code code = TYPE_CODE (type);
 743   register int len = TYPE_LENGTH (type);
 744   register int nosign = TYPE_UNSIGNED (type);
 745
 746   *invp = 0;                    /* Assume valid.   */
 747   if (code == TYPE_CODE_FLT)
 748     {
 749       if (INVALID_FLOAT (valaddr, len))
 750         {
 751           *invp = 1;
 752           return 1.234567891011121314;
 753         }
 754
 755       if (len == sizeof (float))
 756         {
 757           float retval;
 758           memcpy (&retval, valaddr, sizeof (retval));
 759           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 760           return retval;
 761         }
 762
 763       if (len == sizeof (double))
 764         {
 765           double retval;
 766           memcpy (&retval, valaddr, sizeof (retval));
 767           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 768           return retval;
 769         }
 770       else
 771         {
 772           error ("Unexpected type of floating point number.");
 773           return 0; /* Placate lint.  */
 774         }
 775     }
 776   else if (nosign) {
 777    /* Unsigned -- be sure we compensate for signed LONGEST.  */
 778 #ifdef LONG_LONG
 779    return (unsigned long long) unpack_long (type, valaddr);
 780 #else
 781    return (unsigned long     ) unpack_long (type, valaddr);
 782 #endif
 783   } else {
 784     /* Signed -- we are OK with unpack_long.  */
 785     return unpack_long (type, valaddr);
 786   }
 787 }
 788
 789 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 790    as a CORE_ADDR, assuming the raw data is described by type TYPE.
 791    We don't assume any alignment for the raw data.  Return value is in
 792    host byte order.
 793
 794    If you want functions and arrays to be coerced to pointers, and
 795    references to be dereferenced, call value_as_pointer() instead.
 796
 797    C++: It is assumed that the front-end has taken care of
 798    all matters concerning pointers to members.  A pointer
 799    to member which reaches here is considered to be equivalent
 800    to an INT (or some size).  After all, it is only an offset.  */
 801
 802 CORE_ADDR
 803 unpack_pointer (type, valaddr)
 804      struct type *type;
 805      char *valaddr;
 806 {
 807 #if 0
 808   /* The user should be able to use an int (e.g. 0x7892) in contexts
 809      where a pointer is expected.  So this doesn't do enough.  */
 810   register enum type_code code = TYPE_CODE (type);
 811   register int len = TYPE_LENGTH (type);
 812
 813   if (code == TYPE_CODE_PTR
 814       || code == TYPE_CODE_REF)
 815     {
 816       if (len == sizeof (CORE_ADDR))
 817         {
 818           CORE_ADDR retval;
 819           memcpy (&retval, valaddr, sizeof (retval));
 820           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 821           return retval;
 822         }
 823       error ("Unrecognized pointer size.");
 824     }
 825   else if (code == TYPE_CODE_MEMBER)
 826     error ("not implemented: member types in unpack_pointer");
 827
 828   error ("Value is not a pointer.");
 829   return 0;     /* For lint -- never reached */
 830 #else
 831   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 832      whether we want this to be true eventually.  */
 833   return unpack_long (type, valaddr);
 834 #endif
 835 }
 836 \f
 837 /* Given a value ARG1 (offset by OFFSET bytes)
 838    of a struct or union type ARG_TYPE,
 839    extract and return the value of one of its fields.
 840    FIELDNO says which field.
 841
 842    For C++, must also be able to return values from static fields */
 843
 844 value
 845 value_primitive_field (arg1, offset, fieldno, arg_type)
 846      register value arg1;
 847      int offset;
 848      register int fieldno;
 849      register struct type *arg_type;
 850 {
 851   register value v;
 852   register struct type *type;
 853
 854   check_stub_type (arg_type);
 855   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 856
 857   /* Handle packed fields */
 858
 859   offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
 860   if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
 861     {
 862       v = value_from_longest (type,
 863                            unpack_field_as_long (arg_type,
 864                                                  VALUE_CONTENTS (arg1),
 865                                                  fieldno));
 866       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
 867       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
 868     }
 869   else
 870     {
 871       v = allocate_value (type);
 872       if (VALUE_LAZY (arg1))
 873         VALUE_LAZY (v) = 1;
 874       else
 875         memcpy (VALUE_CONTENTS_RAW (v), VALUE_CONTENTS_RAW (arg1) + offset,
 876                 TYPE_LENGTH (type));
 877     }
 878   VALUE_LVAL (v) = VALUE_LVAL (arg1);
 879   if (VALUE_LVAL (arg1) == lval_internalvar)
 880     VALUE_LVAL (v) = lval_internalvar_component;
 881   VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
 882   VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
 883   return v;
 884 }
 885
 886 /* Given a value ARG1 of a struct or union type,
 887    extract and return the value of one of its fields.
 888    FIELDNO says which field.
 889
 890    For C++, must also be able to return values from static fields */
 891
 892 value
 893 value_field (arg1, fieldno)
 894      register value arg1;
 895      register int fieldno;
 896 {
 897   return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
 898 }
 899
 900 /* Return a non-virtual function as a value.
 901    F is the list of member functions which contains the desired method.
 902    J is an index into F which provides the desired method. */
 903
 904 value
 905 value_fn_field (arg1p, f, j, type, offset)
 906      value *arg1p;
 907      struct fn_field *f;
 908      int j;
 909      struct type *type;
 910      int offset;
 911 {
 912   register value v;
 913   register struct type *ftype = TYPE_FN_FIELD_TYPE (f, j);
 914   struct symbol *sym;
 915
 916   sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
 917                        0, VAR_NAMESPACE, 0, NULL);
 918   if (! sym) error ("Internal error: could not find physical method named %s",
 919                     TYPE_FN_FIELD_PHYSNAME (f, j));
 920
 921   v = allocate_value (ftype);
 922   VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
 923   VALUE_TYPE (v) = ftype;
 924
 925   if (arg1p)
 926    {
 927     if (type != VALUE_TYPE (*arg1p))
 928       *arg1p = value_ind (value_cast (lookup_pointer_type (type),
 929                                       value_addr (*arg1p)));
 930
 931     /* Move the `this' pointer according to the offset. */
 932     VALUE_OFFSET (*arg1p) += offset;
 933     }
 934
 935   return v;
 936 }
 937
 938 /* Return a virtual function as a value.
 939    ARG1 is the object which provides the virtual function
 940    table pointer.  *ARG1P is side-effected in calling this function.
 941    F is the list of member functions which contains the desired virtual
 942    function.
 943    J is an index into F which provides the desired virtual function.
 944
 945    TYPE is the type in which F is located.  */
 946 value
 947 value_virtual_fn_field (arg1p, f, j, type, offset)
 948      value *arg1p;
 949      struct fn_field *f;
 950      int j;
 951      struct type *type;
 952      int offset;
 953 {
 954   value arg1 = *arg1p;
 955   /* First, get the virtual function table pointer.  That comes
 956      with a strange type, so cast it to type `pointer to long' (which
 957      should serve just fine as a function type).  Then, index into
 958      the table, and convert final value to appropriate function type.  */
 959   value entry, vfn, vtbl;
 960   value vi = value_from_longest (builtin_type_int,
 961                               (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
 962   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 963   struct type *context;
 964   if (fcontext == NULL)
 965    /* We don't have an fcontext (e.g. the program was compiled with
 966       g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
 967       This won't work right for multiple inheritance, but at least we
 968       should do as well as GDB 3.x did.  */
 969     fcontext = TYPE_VPTR_BASETYPE (type);
 970   context = lookup_pointer_type (fcontext);
 971   /* Now context is a pointer to the basetype containing the vtbl.  */
 972   if (TYPE_TARGET_TYPE (context) != VALUE_TYPE (arg1))
 973     arg1 = value_ind (value_cast (context, value_addr (arg1)));
 974
 975   context = VALUE_TYPE (arg1);
 976   /* Now context is the basetype containing the vtbl.  */
 977
 978   /* This type may have been defined before its virtual function table
 979      was.  If so, fill in the virtual function table entry for the
 980      type now.  */
 981   if (TYPE_VPTR_FIELDNO (context) < 0)
 982     fill_in_vptr_fieldno (context);
 983
 984   /* The virtual function table is now an array of structures
 985      which have the form { int16 offset, delta; void *pfn; }.  */
 986   vtbl = value_ind (value_primitive_field (arg1, 0,
 987                                            TYPE_VPTR_FIELDNO (context),
 988                                            TYPE_VPTR_BASETYPE (context)));
 989
 990   /* Index into the virtual function table.  This is hard-coded because
 991      looking up a field is not cheap, and it may be important to save
 992      time, e.g. if the user has set a conditional breakpoint calling
 993      a virtual function.  */
 994   entry = value_subscript (vtbl, vi);
 995
 996   /* Move the `this' pointer according to the virtual function table.  */
 997   VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0)) + offset;
 998   if (! VALUE_LAZY (arg1))
 999     {
1000       VALUE_LAZY (arg1) = 1;
1001       value_fetch_lazy (arg1);
1002     }
1003
1004   vfn = value_field (entry, 2);
1005   /* Reinstantiate the function pointer with the correct type.  */
1006   VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
1007
1008   *arg1p = arg1;
1009   return vfn;
1010 }
1011
1012 /* ARG is a pointer to an object we know to be at least
1013    a DTYPE.  BTYPE is the most derived basetype that has
1014    already been searched (and need not be searched again).
1015    After looking at the vtables between BTYPE and DTYPE,
1016    return the most derived type we find.  The caller must
1017    be satisfied when the return value == DTYPE.
1018
1019    FIXME-tiemann: should work with dossier entries as well.  */
1020
1021 static value
1022 value_headof (in_arg, btype, dtype)
1023      value in_arg;
1024      struct type *btype, *dtype;
1025 {
1026   /* First collect the vtables we must look at for this object.  */
1027   /* FIXME-tiemann: right now, just look at top-most vtable.  */
1028   value arg, vtbl, entry, best_entry = 0;
1029   int i, nelems;
1030   int offset, best_offset = 0;
1031   struct symbol *sym;
1032   CORE_ADDR pc_for_sym;
1033   char *demangled_name;
1034   struct minimal_symbol *msymbol;
1035
1036   btype = TYPE_VPTR_BASETYPE (dtype);
1037   check_stub_type (btype);
1038   arg = in_arg;
1039   if (btype != dtype)
1040     arg = value_cast (lookup_pointer_type (btype), arg);
1041   vtbl = value_ind (value_field (value_ind (arg), TYPE_VPTR_FIELDNO (btype)));
1042
1043   /* Check that VTBL looks like it points to a virtual function table.  */
1044   msymbol = lookup_minimal_symbol_by_pc (VALUE_ADDRESS (vtbl));
1045   if (msymbol == NULL
1046       || !VTBL_PREFIX_P (demangled_name = SYMBOL_NAME (msymbol)))
1047     {
1048       /* If we expected to find a vtable, but did not, let the user
1049          know that we aren't happy, but don't throw an error.
1050          FIXME: there has to be a better way to do this.  */
1051       struct type *error_type = (struct type *)xmalloc (sizeof (struct type));
1052       memcpy (error_type, VALUE_TYPE (in_arg), sizeof (struct type));
1053       TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
1054       VALUE_TYPE (in_arg) = error_type;
1055       return in_arg;
1056     }
1057
1058   /* Now search through the virtual function table.  */
1059   entry = value_ind (vtbl);
1060   nelems = longest_to_int (value_as_long (value_field (entry, 2)));
1061   for (i = 1; i <= nelems; i++)
1062     {
1063       entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
1064                                                       (LONGEST) i));
1065       offset = longest_to_int (value_as_long (value_field (entry, 0)));
1066       /* If we use '<=' we can handle single inheritance
1067        * where all offsets are zero - just use the first entry found. */
1068       if (offset <= best_offset)
1069         {
1070           best_offset = offset;
1071           best_entry = entry;
1072         }
1073     }
1074   /* Move the pointer according to BEST_ENTRY's offset, and figure
1075      out what type we should return as the new pointer.  */
1076   if (best_entry == 0)
1077     {
1078       /* An alternative method (which should no longer be necessary).
1079        * But we leave it in for future use, when we will hopefully
1080        * have optimizes the vtable to use thunks instead of offsets. */
1081       /* Use the name of vtable itself to extract a base type. */
1082       demangled_name += 4;  /* Skip _vt$ prefix. */
1083     }
1084   else
1085     {
1086       pc_for_sym = value_as_pointer (value_field (best_entry, 2));
1087       sym = find_pc_function (pc_for_sym);
1088       demangled_name = cplus_demangle (SYMBOL_NAME (sym), DMGL_ANSI);
1089       *(strchr (demangled_name, ':')) = '\0';
1090     }
1091   sym = lookup_symbol (demangled_name, 0, VAR_NAMESPACE, 0, 0);
1092   if (sym == NULL)
1093     error ("could not find type declaration for `%s'", demangled_name);
1094   if (best_entry)
1095     {
1096       free (demangled_name);
1097       arg = value_add (value_cast (builtin_type_int, arg),
1098                        value_field (best_entry, 0));
1099     }
1100   else arg = in_arg;
1101   VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym));
1102   return arg;
1103 }
1104
1105 /* ARG is a pointer object of type TYPE.  If TYPE has virtual
1106    function tables, probe ARG's tables (including the vtables
1107    of its baseclasses) to figure out the most derived type that ARG
1108    could actually be a pointer to.  */
1109
1110 value
1111 value_from_vtable_info (arg, type)
1112      value arg;
1113      struct type *type;
1114 {
1115   /* Take care of preliminaries.  */
1116   if (TYPE_VPTR_FIELDNO (type) < 0)
1117     fill_in_vptr_fieldno (type);
1118   if (TYPE_VPTR_FIELDNO (type) < 0 || VALUE_REPEATED (arg))
1119     return 0;
1120
1121   return value_headof (arg, 0, type);
1122 }
1123
1124 /* Compute the offset of the baseclass which is
1125    the INDEXth baseclass of class TYPE, for a value ARG,
1126    wih extra offset of OFFSET.
1127    The result is the offste of the baseclass value relative
1128    to (the address of)(ARG) + OFFSET.
1129
1130    -1 is returned on error. */
1131
1132 int
1133 baseclass_offset (type, index, arg, offset)
1134      struct type *type;
1135      int index;
1136      value arg;
1137      int offset;
1138 {
1139   struct type *basetype = TYPE_BASECLASS (type, index);
1140
1141   if (BASETYPE_VIA_VIRTUAL (type, index))
1142     {
1143       /* Must hunt for the pointer to this virtual baseclass.  */
1144       register int i, len = TYPE_NFIELDS (type);
1145       register int n_baseclasses = TYPE_N_BASECLASSES (type);
1146       char *vbase_name, *type_name = type_name_no_tag (basetype);
1147
1148       vbase_name = (char *)alloca (strlen (type_name) + 8);
1149       sprintf (vbase_name, "_vb%c%s", CPLUS_MARKER, type_name);
1150       /* First look for the virtual baseclass pointer
1151          in the fields.  */
1152       for (i = n_baseclasses; i < len; i++)
1153         {
1154           if (STREQ (vbase_name, TYPE_FIELD_NAME (type, i)))
1155             {
1156               CORE_ADDR addr
1157                 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1158                                   VALUE_CONTENTS (arg) + VALUE_OFFSET (arg)
1159                                   + offset
1160                                   + (TYPE_FIELD_BITPOS (type, i) / 8));
1161
1162               if (VALUE_LVAL (arg) != lval_memory)
1163                   return -1;
1164
1165               return addr -
1166                   (LONGEST) (VALUE_ADDRESS (arg) + VALUE_OFFSET (arg) + offset);
1167             }
1168         }
1169       /* Not in the fields, so try looking through the baseclasses.  */
1170       for (i = index+1; i < n_baseclasses; i++)
1171         {
1172           int boffset =
1173               baseclass_offset (type, i, arg, offset);
1174           if (boffset)
1175             return boffset;
1176         }
1177       /* Not found.  */
1178       return -1;
1179     }
1180
1181   /* Baseclass is easily computed.  */
1182   return TYPE_BASECLASS_BITPOS (type, index) / 8;
1183 }
1184
1185 /* Compute the address of the baseclass which is
1186    the INDEXth baseclass of class TYPE.  The TYPE base
1187    of the object is at VALADDR.
1188
1189    If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1190    or 0 if no error.  In that case the return value is not the address
1191    of the baseclasss, but the address which could not be read
1192    successfully.  */
1193
1194 /* FIXME Fix remaining uses of baseclass_addr to use baseclass_offset */
1195
1196 char *
1197 baseclass_addr (type, index, valaddr, valuep, errp)
1198      struct type *type;
1199      int index;
1200      char *valaddr;
1201      value *valuep;
1202      int *errp;
1203 {
1204   struct type *basetype = TYPE_BASECLASS (type, index);
1205
1206   if (errp)
1207     *errp = 0;
1208
1209   if (BASETYPE_VIA_VIRTUAL (type, index))
1210     {
1211       /* Must hunt for the pointer to this virtual baseclass.  */
1212       register int i, len = TYPE_NFIELDS (type);
1213       register int n_baseclasses = TYPE_N_BASECLASSES (type);
1214       char *vbase_name, *type_name = type_name_no_tag (basetype);
1215
1216       vbase_name = (char *)alloca (strlen (type_name) + 8);
1217       sprintf (vbase_name, "_vb%c%s", CPLUS_MARKER, type_name);
1218       /* First look for the virtual baseclass pointer
1219          in the fields.  */
1220       for (i = n_baseclasses; i < len; i++)
1221         {
1222           if (STREQ (vbase_name, TYPE_FIELD_NAME (type, i)))
1223             {
1224               value val = allocate_value (basetype);
1225               CORE_ADDR addr;
1226               int status;
1227
1228               addr
1229                 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1230                                   valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
1231
1232               status = target_read_memory (addr,
1233                                            VALUE_CONTENTS_RAW (val),
1234                                            TYPE_LENGTH (basetype));
1235               VALUE_LVAL (val) = lval_memory;
1236               VALUE_ADDRESS (val) = addr;
1237
1238               if (status != 0)
1239                 {
1240                   if (valuep)
1241                     *valuep = NULL;
1242                   release_value (val);
1243                   value_free (val);
1244                   if (errp)
1245                     *errp = status;
1246                   return (char *)addr;
1247                 }
1248               else
1249                 {
1250                   if (valuep)
1251                     *valuep = val;
1252                   return (char *) VALUE_CONTENTS (val);
1253                 }
1254             }
1255         }
1256       /* Not in the fields, so try looking through the baseclasses.  */
1257       for (i = index+1; i < n_baseclasses; i++)
1258         {
1259           char *baddr;
1260
1261           baddr = baseclass_addr (type, i, valaddr, valuep, errp);
1262           if (baddr)
1263             return baddr;
1264         }
1265       /* Not found.  */
1266       if (valuep)
1267         *valuep = 0;
1268       return 0;
1269     }
1270
1271   /* Baseclass is easily computed.  */
1272   if (valuep)
1273     *valuep = 0;
1274   return valaddr + TYPE_BASECLASS_BITPOS (type, index) / 8;
1275 }
1276 \f
1277 /* Unpack a field FIELDNO of the specified TYPE, from the anonymous object at
1278    VALADDR.
1279
1280    Extracting bits depends on endianness of the machine.  Compute the
1281    number of least significant bits to discard.  For big endian machines,
1282    we compute the total number of bits in the anonymous object, subtract
1283    off the bit count from the MSB of the object to the MSB of the
1284    bitfield, then the size of the bitfield, which leaves the LSB discard
1285    count.  For little endian machines, the discard count is simply the
1286    number of bits from the LSB of the anonymous object to the LSB of the
1287    bitfield.
1288
1289    If the field is signed, we also do sign extension. */
1290
1291 LONGEST
1292 unpack_field_as_long (type, valaddr, fieldno)
1293      struct type *type;
1294      char *valaddr;
1295      int fieldno;
1296 {
1297   unsigned LONGEST val;
1298   unsigned LONGEST valmask;
1299   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1300   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1301   int lsbcount;
1302
1303   memcpy (&val, valaddr + bitpos / 8, sizeof (val));
1304   SWAP_TARGET_AND_HOST (&val, sizeof (val));
1305
1306   /* Extract bits.  See comment above. */
1307
1308 #if BITS_BIG_ENDIAN
1309   lsbcount = (sizeof val * 8 - bitpos % 8 - bitsize);
1310 #else
1311   lsbcount = (bitpos % 8);
1312 #endif
1313   val >>= lsbcount;
1314
1315   /* If the field does not entirely fill a LONGEST, then zero the sign bits.
1316      If the field is signed, and is negative, then sign extend. */
1317
1318   if ((bitsize > 0) && (bitsize < 8 * sizeof (val)))
1319     {
1320       valmask = (((unsigned LONGEST) 1) << bitsize) - 1;
1321       val &= valmask;
1322       if (!TYPE_UNSIGNED (TYPE_FIELD_TYPE (type, fieldno)))
1323         {
1324           if (val & (valmask ^ (valmask >> 1)))
1325             {
1326               val |= ~valmask;
1327             }
1328         }
1329     }
1330   return (val);
1331 }
1332
1333 /* Modify the value of a bitfield.  ADDR points to a block of memory in
1334    target byte order; the bitfield starts in the byte pointed to.  FIELDVAL
1335    is the desired value of the field, in host byte order.  BITPOS and BITSIZE
1336    indicate which bits (in target bit order) comprise the bitfield.  */
1337
1338 void
1339 modify_field (addr, fieldval, bitpos, bitsize)
1340      char *addr;
1341      int fieldval;
1342      int bitpos, bitsize;
1343 {
1344   long oword;
1345
1346   /* Reject values too big to fit in the field in question,
1347      otherwise adjoining fields may be corrupted.  */
1348   if (bitsize < (8 * sizeof (fieldval))
1349       && 0 != (fieldval & ~((1<<bitsize)-1)))
1350     error ("Value %d does not fit in %d bits.", fieldval, bitsize);
1351
1352   memcpy (&oword, addr, sizeof oword);
1353   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To host format */
1354
1355   /* Shifting for bit field depends on endianness of the target machine.  */
1356 #if BITS_BIG_ENDIAN
1357   bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1358 #endif
1359
1360   /* Mask out old value, while avoiding shifts >= longword size */
1361   if (bitsize < 8 * sizeof (oword))
1362     oword &= ~(((((unsigned long)1) << bitsize) - 1) << bitpos);
1363   else
1364     oword &= ~((-1) << bitpos);
1365   oword |= fieldval << bitpos;
1366
1367   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To target format */
1368   memcpy (addr, &oword, sizeof oword);
1369 }
1370 \f
1371 /* Convert C numbers into newly allocated values */
1372
1373 value
1374 value_from_longest (type, num)
1375      struct type *type;
1376      register LONGEST num;
1377 {
1378   register value val = allocate_value (type);
1379   register enum type_code code = TYPE_CODE (type);
1380   register int len = TYPE_LENGTH (type);
1381
1382   /* FIXME, we assume that pointers have the same form and byte order as
1383      integers, and that all pointers have the same form.  */
1384   if (code == TYPE_CODE_INT  || code == TYPE_CODE_ENUM ||
1385       code == TYPE_CODE_CHAR || code == TYPE_CODE_PTR ||
1386       code == TYPE_CODE_REF  || code == TYPE_CODE_BOOL)
1387     {
1388       if (len == sizeof (char))
1389         * (char *) VALUE_CONTENTS_RAW (val) = num;
1390       else if (len == sizeof (short))
1391         * (short *) VALUE_CONTENTS_RAW (val) = num;
1392       else if (len == sizeof (int))
1393         * (int *) VALUE_CONTENTS_RAW (val) = num;
1394       else if (len == sizeof (long))
1395         * (long *) VALUE_CONTENTS_RAW (val) = num;
1396 #ifdef LONG_LONG
1397       else if (len == sizeof (long long))
1398         * (long long *) VALUE_CONTENTS_RAW (val) = num;
1399 #endif
1400       else
1401         error ("Integer type encountered with unexpected data length.");
1402     }
1403   else
1404     error ("Unexpected type encountered for integer constant.");
1405
1406   /* num was in host byte order.  So now put the value's contents
1407      into target byte order.  */
1408   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1409
1410   return val;
1411 }
1412
1413 value
1414 value_from_double (type, num)
1415      struct type *type;
1416      double num;
1417 {
1418   register value val = allocate_value (type);
1419   register enum type_code code = TYPE_CODE (type);
1420   register int len = TYPE_LENGTH (type);
1421
1422   if (code == TYPE_CODE_FLT)
1423     {
1424       if (len == sizeof (float))
1425         * (float *) VALUE_CONTENTS_RAW (val) = num;
1426       else if (len == sizeof (double))
1427         * (double *) VALUE_CONTENTS_RAW (val) = num;
1428       else
1429         error ("Floating type encountered with unexpected data length.");
1430     }
1431   else
1432     error ("Unexpected type encountered for floating constant.");
1433
1434   /* num was in host byte order.  So now put the value's contents
1435      into target byte order.  */
1436   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1437
1438   return val;
1439 }
1440 \f
1441 /* Deal with the value that is "about to be returned".  */
1442
1443 /* Return the value that a function returning now
1444    would be returning to its caller, assuming its type is VALTYPE.
1445    RETBUF is where we look for what ought to be the contents
1446    of the registers (in raw form).  This is because it is often
1447    desirable to restore old values to those registers
1448    after saving the contents of interest, and then call
1449    this function using the saved values.
1450    struct_return is non-zero when the function in question is
1451    using the structure return conventions on the machine in question;
1452    0 when it is using the value returning conventions (this often
1453    means returning pointer to where structure is vs. returning value). */
1454
1455 value
1456 value_being_returned (valtype, retbuf, struct_return)
1457      register struct type *valtype;
1458      char retbuf[REGISTER_BYTES];
1459      int struct_return;
1460      /*ARGSUSED*/
1461 {
1462   register value val;
1463   CORE_ADDR addr;
1464
1465 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1466   /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
1467   if (struct_return) {
1468     addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
1469     if (!addr)
1470       error ("Function return value unknown");
1471     return value_at (valtype, addr);
1472   }
1473 #endif
1474
1475   val = allocate_value (valtype);
1476   EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1477
1478   return val;
1479 }
1480
1481 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1482    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1483    and TYPE is the type (which is known to be struct, union or array).
1484
1485    On most machines, the struct convention is used unless we are
1486    using gcc and the type is of a special size.  */
1487 #if !defined (USE_STRUCT_CONVENTION)
1488 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1489   (!((gcc_p) && (TYPE_LENGTH (value_type) == 1                \
1490                  || TYPE_LENGTH (value_type) == 2             \
1491                  || TYPE_LENGTH (value_type) == 4             \
1492                  || TYPE_LENGTH (value_type) == 8             \
1493                  )                                            \
1494      ))
1495 #endif
1496
1497 /* Return true if the function specified is using the structure returning
1498    convention on this machine to return arguments, or 0 if it is using
1499    the value returning convention.  FUNCTION is the value representing
1500    the function, FUNCADDR is the address of the function, and VALUE_TYPE
1501    is the type returned by the function.  GCC_P is nonzero if compiled
1502    with GCC.  */
1503
1504 int
1505 using_struct_return (function, funcaddr, value_type, gcc_p)
1506      value function;
1507      CORE_ADDR funcaddr;
1508      struct type *value_type;
1509      int gcc_p;
1510      /*ARGSUSED*/
1511 {
1512   register enum type_code code = TYPE_CODE (value_type);
1513
1514   if (code == TYPE_CODE_ERROR)
1515     error ("Function return type unknown.");
1516
1517   if (code == TYPE_CODE_STRUCT ||
1518       code == TYPE_CODE_UNION ||
1519       code == TYPE_CODE_ARRAY)
1520     return USE_STRUCT_CONVENTION (gcc_p, value_type);
1521
1522   return 0;
1523 }
1524
1525 /* Store VAL so it will be returned if a function returns now.
1526    Does not verify that VAL's type matches what the current
1527    function wants to return.  */
1528
1529 void
1530 set_return_value (val)
1531      value val;
1532 {
1533   register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
1534   double dbuf;
1535   LONGEST lbuf;
1536
1537   if (code == TYPE_CODE_ERROR)
1538     error ("Function return type unknown.");
1539
1540   if (   code == TYPE_CODE_STRUCT
1541       || code == TYPE_CODE_UNION)       /* FIXME, implement struct return.  */
1542     error ("GDB does not support specifying a struct or union return value.");
1543
1544   /* FIXME, this is bogus.  We don't know what the return conventions
1545      are, or how values should be promoted.... */
1546   if (code == TYPE_CODE_FLT)
1547     {
1548       dbuf = value_as_double (val);
1549
1550       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&dbuf);
1551     }
1552   else
1553     {
1554       lbuf = value_as_long (val);
1555       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&lbuf);
1556     }
1557 }
1558 \f
1559 void
1560 _initialize_values ()
1561 {
1562   add_cmd ("convenience", no_class, show_convenience,
1563             "Debugger convenience (\"$foo\") variables.\n\
1564 These variables are created when you assign them values;\n\
1565 thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
1566 A few convenience variables are given values automatically:\n\
1567 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1568 \"$__\" holds the contents of the last address examined with \"x\".",
1569            &showlist);
1570
1571   add_cmd ("values", no_class, show_values,
1572            "Elements of value history around item number IDX (or last ten).",
1573            &showlist);
1574 }