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