gdb/values.c

   1 /* Low level packing and unpacking of values for GDB.
   2    Copyright (C) 1986, 1987, 1989 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 <stdio.h>
  21 #include <string.h>
  22 #include "defs.h"
  23 #include "param.h"
  24 #include "symtab.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "frame.h"
  28 #include "command.h"
  29 #include "gdbcmd.h"
  30
  31 extern char *cplus_demangle ();
  32 extern char *cplus_mangle_opname ();
  33
  34 /* The value-history records all the values printed
  35    by print commands during this session.  Each chunk
  36    records 60 consecutive values.  The first chunk on
  37    the chain records the most recent values.
  38    The total number of values is in value_history_count.  */
  39
  40 #define VALUE_HISTORY_CHUNK 60
  41
  42 struct value_history_chunk
  43 {
  44   struct value_history_chunk *next;
  45   value values[VALUE_HISTORY_CHUNK];
  46 };
  47
  48 /* Chain of chunks now in use.  */
  49
  50 static struct value_history_chunk *value_history_chain;
  51
  52 static int value_history_count; /* Abs number of last entry stored */
  53 \f
  54 /* List of all value objects currently allocated
  55    (except for those released by calls to release_value)
  56    This is so they can be freed after each command.  */
  57
  58 static value all_values;
  59
  60 /* Allocate a  value  that has the correct length for type TYPE.  */
  61
  62 value
  63 allocate_value (type)
  64      struct type *type;
  65 {
  66   register value val;
  67
  68   check_stub_type (type);
  69
  70   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type));
  71   VALUE_NEXT (val) = all_values;
  72   all_values = val;
  73   VALUE_TYPE (val) = type;
  74   VALUE_LVAL (val) = not_lval;
  75   VALUE_ADDRESS (val) = 0;
  76   VALUE_FRAME (val) = 0;
  77   VALUE_OFFSET (val) = 0;
  78   VALUE_BITPOS (val) = 0;
  79   VALUE_BITSIZE (val) = 0;
  80   VALUE_REPEATED (val) = 0;
  81   VALUE_REPETITIONS (val) = 0;
  82   VALUE_REGNO (val) = -1;
  83   VALUE_LAZY (val) = 0;
  84   VALUE_OPTIMIZED_OUT (val) = 0;
  85   return val;
  86 }
  87
  88 /* Allocate a  value  that has the correct length
  89    for COUNT repetitions type TYPE.  */
  90
  91 value
  92 allocate_repeat_value (type, count)
  93      struct type *type;
  94      int count;
  95 {
  96   register value val;
  97
  98   val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count);
  99   VALUE_NEXT (val) = all_values;
 100   all_values = val;
 101   VALUE_TYPE (val) = type;
 102   VALUE_LVAL (val) = not_lval;
 103   VALUE_ADDRESS (val) = 0;
 104   VALUE_FRAME (val) = 0;
 105   VALUE_OFFSET (val) = 0;
 106   VALUE_BITPOS (val) = 0;
 107   VALUE_BITSIZE (val) = 0;
 108   VALUE_REPEATED (val) = 1;
 109   VALUE_REPETITIONS (val) = count;
 110   VALUE_REGNO (val) = -1;
 111   VALUE_LAZY (val) = 0;
 112   VALUE_OPTIMIZED_OUT (val) = 0;
 113   return val;
 114 }
 115
 116 /* Return a mark in the value chain.  All values allocated after the
 117    mark is obtained (except for those released) are subject to being freed
 118    if a subsequent value_free_to_mark is passed the mark.  */
 119 value
 120 value_mark ()
 121 {
 122   return all_values;
 123 }
 124
 125 /* Free all values allocated since MARK was obtained by value_mark
 126    (except for those released).  */
 127 void
 128 value_free_to_mark (mark)
 129      value mark;
 130 {
 131   value val, next;
 132
 133   for (val = all_values; val && val != mark; val = next)
 134     {
 135       next = VALUE_NEXT (val);
 136       value_free (val);
 137     }
 138   all_values = val;
 139 }
 140
 141 /* Free all the values that have been allocated (except for those released).
 142    Called after each command, successful or not.  */
 143
 144 void
 145 free_all_values ()
 146 {
 147   register value val, next;
 148
 149   for (val = all_values; val; val = next)
 150     {
 151       next = VALUE_NEXT (val);
 152       value_free (val);
 153     }
 154
 155   all_values = 0;
 156 }
 157
 158 /* Remove VAL from the chain all_values
 159    so it will not be freed automatically.  */
 160
 161 void
 162 release_value (val)
 163      register value val;
 164 {
 165   register value v;
 166
 167   if (all_values == val)
 168     {
 169       all_values = val->next;
 170       return;
 171     }
 172
 173   for (v = all_values; v; v = v->next)
 174     {
 175       if (v->next == val)
 176         {
 177           v->next = val->next;
 178           break;
 179         }
 180     }
 181 }
 182
 183 /* Return a copy of the value ARG.
 184    It contains the same contents, for same memory address,
 185    but it's a different block of storage.  */
 186
 187 static value
 188 value_copy (arg)
 189      value arg;
 190 {
 191   register value val;
 192   register struct type *type = VALUE_TYPE (arg);
 193   if (VALUE_REPEATED (arg))
 194     val = allocate_repeat_value (type, VALUE_REPETITIONS (arg));
 195   else
 196     val = allocate_value (type);
 197   VALUE_LVAL (val) = VALUE_LVAL (arg);
 198   VALUE_ADDRESS (val) = VALUE_ADDRESS (arg);
 199   VALUE_OFFSET (val) = VALUE_OFFSET (arg);
 200   VALUE_BITPOS (val) = VALUE_BITPOS (arg);
 201   VALUE_BITSIZE (val) = VALUE_BITSIZE (arg);
 202   VALUE_REGNO (val) = VALUE_REGNO (arg);
 203   VALUE_LAZY (val) = VALUE_LAZY (arg);
 204   if (!VALUE_LAZY (val))
 205     {
 206       bcopy (VALUE_CONTENTS_RAW (arg), VALUE_CONTENTS_RAW (val),
 207              TYPE_LENGTH (VALUE_TYPE (arg))
 208              * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1));
 209     }
 210   return val;
 211 }
 212 \f
 213 /* Access to the value history.  */
 214
 215 /* Record a new value in the value history.
 216    Returns the absolute history index of the entry.
 217    Result of -1 indicates the value was not saved; otherwise it is the
 218    value history index of this new item.  */
 219
 220 int
 221 record_latest_value (val)
 222      value val;
 223 {
 224   int i;
 225
 226   /* Check error now if about to store an invalid float.  We return -1
 227      to the caller, but allow them to continue, e.g. to print it as "Nan". */
 228   if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT) {
 229     (void) unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i);
 230     if (i) return -1;           /* Indicate value not saved in history */
 231   }
 232
 233   /* Here we treat value_history_count as origin-zero
 234      and applying to the value being stored now.  */
 235
 236   i = value_history_count % VALUE_HISTORY_CHUNK;
 237   if (i == 0)
 238     {
 239       register struct value_history_chunk *new
 240         = (struct value_history_chunk *)
 241           xmalloc (sizeof (struct value_history_chunk));
 242       bzero (new->values, sizeof new->values);
 243       new->next = value_history_chain;
 244       value_history_chain = new;
 245     }
 246
 247   value_history_chain->values[i] = val;
 248   release_value (val);
 249
 250   /* Now we regard value_history_count as origin-one
 251      and applying to the value just stored.  */
 252
 253   return ++value_history_count;
 254 }
 255
 256 /* Return a copy of the value in the history with sequence number NUM.  */
 257
 258 value
 259 access_value_history (num)
 260      int num;
 261 {
 262   register struct value_history_chunk *chunk;
 263   register int i;
 264   register int absnum = num;
 265
 266   if (absnum <= 0)
 267     absnum += value_history_count;
 268
 269   if (absnum <= 0)
 270     {
 271       if (num == 0)
 272         error ("The history is empty.");
 273       else if (num == 1)
 274         error ("There is only one value in the history.");
 275       else
 276         error ("History does not go back to $$%d.", -num);
 277     }
 278   if (absnum > value_history_count)
 279     error ("History has not yet reached $%d.", absnum);
 280
 281   absnum--;
 282
 283   /* Now absnum is always absolute and origin zero.  */
 284
 285   chunk = value_history_chain;
 286   for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK;
 287        i > 0; i--)
 288     chunk = chunk->next;
 289
 290   return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]);
 291 }
 292
 293 /* Clear the value history entirely.
 294    Must be done when new symbol tables are loaded,
 295    because the type pointers become invalid.  */
 296
 297 void
 298 clear_value_history ()
 299 {
 300   register struct value_history_chunk *next;
 301   register int i;
 302   register value val;
 303
 304   while (value_history_chain)
 305     {
 306       for (i = 0; i < VALUE_HISTORY_CHUNK; i++)
 307         if (val = value_history_chain->values[i])
 308           free (val);
 309       next = value_history_chain->next;
 310       free (value_history_chain);
 311       value_history_chain = next;
 312     }
 313   value_history_count = 0;
 314 }
 315
 316 static void
 317 show_values (num_exp, from_tty)
 318      char *num_exp;
 319      int from_tty;
 320 {
 321   register int i;
 322   register value val;
 323   static int num = 1;
 324
 325   if (num_exp)
 326     {
 327       if (num_exp[0] == '+' && num_exp[1] == '\0')
 328         /* "info history +" should print from the stored position.  */
 329         ;
 330       else
 331         /* "info history <exp>" should print around value number <exp>.  */
 332         num = parse_and_eval_address (num_exp) - 5;
 333     }
 334   else
 335     {
 336       /* "info history" means print the last 10 values.  */
 337       num = value_history_count - 9;
 338     }
 339
 340   if (num <= 0)
 341     num = 1;
 342
 343   for (i = num; i < num + 10 && i <= value_history_count; i++)
 344     {
 345       val = access_value_history (i);
 346       printf_filtered ("$%d = ", i);
 347       value_print (val, stdout, 0, Val_pretty_default);
 348       printf_filtered ("\n");
 349     }
 350
 351   /* The next "info history +" should start after what we just printed.  */
 352   num += 10;
 353
 354   /* Hitting just return after this command should do the same thing as
 355      "info history +".  If num_exp is null, this is unnecessary, since
 356      "info history +" is not useful after "info history".  */
 357   if (from_tty && num_exp)
 358     {
 359       num_exp[0] = '+';
 360       num_exp[1] = '\0';
 361     }
 362 }
 363 \f
 364 /* Internal variables.  These are variables within the debugger
 365    that hold values assigned by debugger commands.
 366    The user refers to them with a '$' prefix
 367    that does not appear in the variable names stored internally.  */
 368
 369 static struct internalvar *internalvars;
 370
 371 /* Look up an internal variable with name NAME.  NAME should not
 372    normally include a dollar sign.
 373
 374    If the specified internal variable does not exist,
 375    one is created, with a void value.  */
 376
 377 struct internalvar *
 378 lookup_internalvar (name)
 379      char *name;
 380 {
 381   register struct internalvar *var;
 382
 383   for (var = internalvars; var; var = var->next)
 384     if (!strcmp (var->name, name))
 385       return var;
 386
 387   var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
 388   var->name = concat (name, "", "");
 389   var->value = allocate_value (builtin_type_void);
 390   release_value (var->value);
 391   var->next = internalvars;
 392   internalvars = var;
 393   return var;
 394 }
 395
 396 value
 397 value_of_internalvar (var)
 398      struct internalvar *var;
 399 {
 400   register value val;
 401
 402 #ifdef IS_TRAPPED_INTERNALVAR
 403   if (IS_TRAPPED_INTERNALVAR (var->name))
 404     return VALUE_OF_TRAPPED_INTERNALVAR (var);
 405 #endif
 406
 407   val = value_copy (var->value);
 408   if (VALUE_LAZY (val))
 409     value_fetch_lazy (val);
 410   VALUE_LVAL (val) = lval_internalvar;
 411   VALUE_INTERNALVAR (val) = var;
 412   return val;
 413 }
 414
 415 void
 416 set_internalvar_component (var, offset, bitpos, bitsize, newval)
 417      struct internalvar *var;
 418      int offset, bitpos, bitsize;
 419      value newval;
 420 {
 421   register char *addr = VALUE_CONTENTS (var->value) + offset;
 422
 423 #ifdef IS_TRAPPED_INTERNALVAR
 424   if (IS_TRAPPED_INTERNALVAR (var->name))
 425     SET_TRAPPED_INTERNALVAR (var, newval, bitpos, bitsize, offset);
 426 #endif
 427
 428   if (bitsize)
 429     modify_field (addr, (int) value_as_long (newval),
 430                   bitpos, bitsize);
 431   else
 432     bcopy (VALUE_CONTENTS (newval), addr,
 433            TYPE_LENGTH (VALUE_TYPE (newval)));
 434 }
 435
 436 void
 437 set_internalvar (var, val)
 438      struct internalvar *var;
 439      value val;
 440 {
 441 #ifdef IS_TRAPPED_INTERNALVAR
 442   if (IS_TRAPPED_INTERNALVAR (var->name))
 443     SET_TRAPPED_INTERNALVAR (var, val, 0, 0, 0);
 444 #endif
 445
 446   free (var->value);
 447   var->value = value_copy (val);
 448   release_value (var->value);
 449 }
 450
 451 char *
 452 internalvar_name (var)
 453      struct internalvar *var;
 454 {
 455   return var->name;
 456 }
 457
 458 /* Free all internalvars.  Done when new symtabs are loaded,
 459    because that makes the values invalid.  */
 460
 461 void
 462 clear_internalvars ()
 463 {
 464   register struct internalvar *var;
 465
 466   while (internalvars)
 467     {
 468       var = internalvars;
 469       internalvars = var->next;
 470       free (var->name);
 471       free (var->value);
 472       free (var);
 473     }
 474 }
 475
 476 static void
 477 show_convenience ()
 478 {
 479   register struct internalvar *var;
 480   int varseen = 0;
 481
 482   for (var = internalvars; var; var = var->next)
 483     {
 484 #ifdef IS_TRAPPED_INTERNALVAR
 485       if (IS_TRAPPED_INTERNALVAR (var->name))
 486         continue;
 487 #endif
 488       if (!varseen)
 489         {
 490 #if 0
 491           /* Useless noise.  */
 492           printf ("Debugger convenience variables:\n\n");
 493 #endif
 494           varseen = 1;
 495         }
 496       printf ("$%s = ", var->name);
 497       value_print (var->value, stdout, 0, Val_pretty_default);
 498       printf ("\n");
 499     }
 500   if (!varseen)
 501     printf ("No debugger convenience variables now defined.\n\
 502 Convenience variables have names starting with \"$\";\n\
 503 use \"set\" as in \"set $foo = 5\" to define them.\n");
 504 }
 505 \f
 506 /* Extract a value as a C number (either long or double).
 507    Knows how to convert fixed values to double, or
 508    floating values to long.
 509    Does not deallocate the value.  */
 510
 511 LONGEST
 512 value_as_long (val)
 513      register value val;
 514 {
 515   /* This coerces arrays and functions, which is necessary (e.g.
 516      in disassemble_command).  It also dereferences references, which
 517      I suspect is the most logical thing to do.  */
 518   if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM)
 519     COERCE_ARRAY (val);
 520   return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val));
 521 }
 522
 523 double
 524 value_as_double (val)
 525      register value val;
 526 {
 527   double foo;
 528   int inv;
 529
 530   foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv);
 531   if (inv)
 532     error ("Invalid floating value found in program.");
 533   return foo;
 534 }
 535 /* Extract a value as a C pointer.
 536    Does not deallocate the value.  */
 537 CORE_ADDR
 538 value_as_pointer (val)
 539      value val;
 540 {
 541   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 542      whether we want this to be true eventually.  */
 543   return value_as_long (val);
 544 }
 545 \f
 546 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 547    as a long, or as a double, assuming the raw data is described
 548    by type TYPE.  Knows how to convert different sizes of values
 549    and can convert between fixed and floating point.  We don't assume
 550    any alignment for the raw data.  Return value is in host byte order.
 551
 552    If you want functions and arrays to be coerced to pointers, and
 553    references to be dereferenced, call value_as_long() instead.
 554
 555    C++: It is assumed that the front-end has taken care of
 556    all matters concerning pointers to members.  A pointer
 557    to member which reaches here is considered to be equivalent
 558    to an INT (or some size).  After all, it is only an offset.  */
 559
 560 LONGEST
 561 unpack_long (type, valaddr)
 562      struct type *type;
 563      char *valaddr;
 564 {
 565   register enum type_code code = TYPE_CODE (type);
 566   register int len = TYPE_LENGTH (type);
 567   register int nosign = TYPE_UNSIGNED (type);
 568
 569   if (code == TYPE_CODE_ENUM)
 570     code = TYPE_CODE_INT;
 571   if (code == TYPE_CODE_FLT)
 572     {
 573       if (len == sizeof (float))
 574         {
 575           float retval;
 576           bcopy (valaddr, &retval, sizeof (retval));
 577           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 578           return retval;
 579         }
 580
 581       if (len == sizeof (double))
 582         {
 583           double retval;
 584           bcopy (valaddr, &retval, sizeof (retval));
 585           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 586           return retval;
 587         }
 588       else
 589         {
 590           error ("Unexpected type of floating point number.");
 591         }
 592     }
 593   else if (code == TYPE_CODE_INT && nosign)
 594     {
 595       if (len == sizeof (char))
 596         {
 597           unsigned char retval = * (unsigned char *) valaddr;
 598           /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */
 599           return retval;
 600         }
 601
 602       if (len == sizeof (short))
 603         {
 604           unsigned short retval;
 605           bcopy (valaddr, &retval, sizeof (retval));
 606           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 607           return retval;
 608         }
 609
 610       if (len == sizeof (int))
 611         {
 612           unsigned int retval;
 613           bcopy (valaddr, &retval, sizeof (retval));
 614           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 615           return retval;
 616         }
 617
 618       if (len == sizeof (long))
 619         {
 620           unsigned long retval;
 621           bcopy (valaddr, &retval, sizeof (retval));
 622           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 623           return retval;
 624         }
 625 #ifdef LONG_LONG
 626       if (len == sizeof (long long))
 627         {
 628           unsigned long long retval;
 629           bcopy (valaddr, &retval, sizeof (retval));
 630           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 631           return retval;
 632         }
 633 #endif
 634       else
 635         {
 636           error ("That operation is not possible on an integer of that size.");
 637         }
 638     }
 639   else if (code == TYPE_CODE_INT)
 640     {
 641       if (len == sizeof (char))
 642         {
 643           char retval;
 644           bcopy (valaddr, &retval, sizeof (retval));
 645           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 646           return retval;
 647         }
 648
 649       if (len == sizeof (short))
 650         {
 651           short retval;
 652           bcopy (valaddr, &retval, sizeof (retval));
 653           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 654           return retval;
 655         }
 656
 657       if (len == sizeof (int))
 658         {
 659           int retval;
 660           bcopy (valaddr, &retval, sizeof (retval));
 661           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 662           return retval;
 663         }
 664
 665       if (len == sizeof (long))
 666         {
 667           long retval;
 668           bcopy (valaddr, &retval, sizeof (retval));
 669           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 670           return retval;
 671         }
 672
 673 #ifdef LONG_LONG
 674       if (len == sizeof (long long))
 675         {
 676           long long retval;
 677           bcopy (valaddr, &retval, sizeof (retval));
 678           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 679           return retval;
 680         }
 681 #endif
 682       else
 683         {
 684           error ("That operation is not possible on an integer of that size.");
 685         }
 686     }
 687   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 688      whether we want this to be true eventually.  */
 689   else if (code == TYPE_CODE_PTR
 690            || code == TYPE_CODE_REF)
 691     {
 692       if (len == sizeof (CORE_ADDR))
 693         {
 694           CORE_ADDR retval;
 695           bcopy (valaddr, &retval, sizeof (retval));
 696           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 697           return retval;
 698         }
 699     }
 700   else if (code == TYPE_CODE_MEMBER)
 701     error ("not implemented: member types in unpack_long");
 702
 703   error ("Value not integer or pointer.");
 704   return 0;     /* For lint -- never reached */
 705 }
 706
 707 /* Return a double value from the specified type and address.
 708    INVP points to an int which is set to 0 for valid value,
 709    1 for invalid value (bad float format).  In either case,
 710    the returned double is OK to use.  Argument is in target
 711    format, result is in host format.  */
 712
 713 double
 714 unpack_double (type, valaddr, invp)
 715      struct type *type;
 716      char *valaddr;
 717      int *invp;
 718 {
 719   register enum type_code code = TYPE_CODE (type);
 720   register int len = TYPE_LENGTH (type);
 721   register int nosign = TYPE_UNSIGNED (type);
 722
 723   *invp = 0;                    /* Assume valid.   */
 724   if (code == TYPE_CODE_FLT)
 725     {
 726       if (INVALID_FLOAT (valaddr, len))
 727         {
 728           *invp = 1;
 729           return 1.234567891011121314;
 730         }
 731
 732       if (len == sizeof (float))
 733         {
 734           float retval;
 735           bcopy (valaddr, &retval, sizeof (retval));
 736           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 737           return retval;
 738         }
 739
 740       if (len == sizeof (double))
 741         {
 742           double retval;
 743           bcopy (valaddr, &retval, sizeof (retval));
 744           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 745           return retval;
 746         }
 747       else
 748         {
 749           error ("Unexpected type of floating point number.");
 750           return 0; /* Placate lint.  */
 751         }
 752     }
 753   else if (nosign) {
 754    /* Unsigned -- be sure we compensate for signed LONGEST.  */
 755 #ifdef LONG_LONG
 756    return (unsigned long long) unpack_long (type, valaddr);
 757 #else
 758    return (unsigned long     ) unpack_long (type, valaddr);
 759 #endif
 760   } else {
 761     /* Signed -- we are OK with unpack_long.  */
 762     return unpack_long (type, valaddr);
 763   }
 764 }
 765
 766 /* Unpack raw data (copied from debugee, target byte order) at VALADDR
 767    as a CORE_ADDR, assuming the raw data is described by type TYPE.
 768    We don't assume any alignment for the raw data.  Return value is in
 769    host byte order.
 770
 771    If you want functions and arrays to be coerced to pointers, and
 772    references to be dereferenced, call value_as_pointer() instead.
 773
 774    C++: It is assumed that the front-end has taken care of
 775    all matters concerning pointers to members.  A pointer
 776    to member which reaches here is considered to be equivalent
 777    to an INT (or some size).  After all, it is only an offset.  */
 778
 779 CORE_ADDR
 780 unpack_pointer (type, valaddr)
 781      struct type *type;
 782      char *valaddr;
 783 {
 784 #if 0
 785   /* The user should be able to use an int (e.g. 0x7892) in contexts
 786      where a pointer is expected.  So this doesn't do enough.  */
 787   register enum type_code code = TYPE_CODE (type);
 788   register int len = TYPE_LENGTH (type);
 789
 790   if (code == TYPE_CODE_PTR
 791       || code == TYPE_CODE_REF)
 792     {
 793       if (len == sizeof (CORE_ADDR))
 794         {
 795           CORE_ADDR retval;
 796           bcopy (valaddr, &retval, sizeof (retval));
 797           SWAP_TARGET_AND_HOST (&retval, sizeof (retval));
 798           return retval;
 799         }
 800       error ("Unrecognized pointer size.");
 801     }
 802   else if (code == TYPE_CODE_MEMBER)
 803     error ("not implemented: member types in unpack_pointer");
 804
 805   error ("Value is not a pointer.");
 806   return 0;     /* For lint -- never reached */
 807 #else
 808   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 809      whether we want this to be true eventually.  */
 810   return unpack_long (type, valaddr);
 811 #endif
 812 }
 813 \f
 814 /* Given a value ARG1 (offset by OFFSET bytes)
 815    of a struct or union type ARG_TYPE,
 816    extract and return the value of one of its fields.
 817    FIELDNO says which field.
 818
 819    For C++, must also be able to return values from static fields */
 820
 821 value
 822 value_primitive_field (arg1, offset, fieldno, arg_type)
 823      register value arg1;
 824      int offset;
 825      register int fieldno;
 826      register struct type *arg_type;
 827 {
 828   register value v;
 829   register struct type *type;
 830
 831   check_stub_type (arg_type);
 832   type = TYPE_FIELD_TYPE (arg_type, fieldno);
 833
 834   /* Handle packed fields */
 835
 836   offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8;
 837   if (TYPE_FIELD_BITSIZE (arg_type, fieldno))
 838     {
 839       v = value_from_long (type,
 840                            unpack_field_as_long (arg_type,
 841                                                  VALUE_CONTENTS (arg1),
 842                                                  fieldno));
 843       VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8;
 844       VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno);
 845     }
 846   else
 847     {
 848       v = allocate_value (type);
 849       if (VALUE_LAZY (arg1))
 850         VALUE_LAZY (v) = 1;
 851       else
 852         bcopy (VALUE_CONTENTS_RAW (arg1) + offset,
 853                VALUE_CONTENTS_RAW (v),
 854                TYPE_LENGTH (type));
 855     }
 856   VALUE_LVAL (v) = VALUE_LVAL (arg1);
 857   if (VALUE_LVAL (arg1) == lval_internalvar)
 858     VALUE_LVAL (v) = lval_internalvar_component;
 859   VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1);
 860   VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1);
 861   return v;
 862 }
 863
 864 /* Given a value ARG1 of a struct or union type,
 865    extract and return the value of one of its fields.
 866    FIELDNO says which field.
 867
 868    For C++, must also be able to return values from static fields */
 869
 870 value
 871 value_field (arg1, fieldno)
 872      register value arg1;
 873      register int fieldno;
 874 {
 875   return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1));
 876 }
 877
 878 value
 879 value_fn_field (arg1, fieldno, subfieldno)
 880      register value arg1;
 881      register int fieldno;
 882      int subfieldno;
 883 {
 884   register value v;
 885   struct fn_field *f = TYPE_FN_FIELDLIST1 (VALUE_TYPE (arg1), fieldno);
 886   register struct type *type = TYPE_FN_FIELD_TYPE (f, subfieldno);
 887   struct symbol *sym;
 888
 889   sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, subfieldno),
 890                        0, VAR_NAMESPACE, 0, NULL);
 891   if (! sym) error ("Internal error: could not find physical method named %s",
 892                     TYPE_FN_FIELD_PHYSNAME (f, subfieldno));
 893
 894   v = allocate_value (type);
 895   VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
 896   VALUE_TYPE (v) = type;
 897   return v;
 898 }
 899
 900 /* Return a virtual function as a value.
 901    ARG1 is the object which provides the virtual function
 902    table pointer.  ARG1 is side-effected in calling this function.
 903    F is the list of member functions which contains the desired virtual
 904    function.
 905    J is an index into F which provides the desired virtual function.
 906
 907    TYPE is the type in which F is located.  */
 908 value
 909 value_virtual_fn_field (arg1, f, j, type)
 910      value arg1;
 911      struct fn_field *f;
 912      int j;
 913      struct type *type;
 914 {
 915   /* First, get the virtual function table pointer.  That comes
 916      with a strange type, so cast it to type `pointer to long' (which
 917      should serve just fine as a function type).  Then, index into
 918      the table, and convert final value to appropriate function type.  */
 919   value entry, vfn, vtbl;
 920   value vi = value_from_long (builtin_type_int,
 921                               (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
 922   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
 923   struct type *context;
 924   if (fcontext == NULL)
 925    /* We don't have an fcontext (e.g. the program was compiled with
 926       g++ version 1).  Try to get the vtbl from the TYPE_VPTR_BASETYPE.
 927       This won't work right for multiple inheritance, but at least we
 928       should do as well as GDB 3.x did.  */
 929     fcontext = TYPE_VPTR_BASETYPE (type);
 930   context = lookup_pointer_type (fcontext);
 931   /* Now context is a pointer to the basetype containing the vtbl.  */
 932   if (TYPE_TARGET_TYPE (context) != VALUE_TYPE (arg1))
 933     arg1 = value_ind (value_cast (context, value_addr (arg1)));
 934
 935   context = VALUE_TYPE (arg1);
 936   /* Now context is the basetype containing the vtbl.  */
 937
 938   /* This type may have been defined before its virtual function table
 939      was.  If so, fill in the virtual function table entry for the
 940      type now.  */
 941   if (TYPE_VPTR_FIELDNO (context) < 0)
 942     fill_in_vptr_fieldno (context);
 943
 944   /* The virtual function table is now an array of structures
 945      which have the form { int16 offset, delta; void *pfn; }.  */
 946   vtbl = value_ind (value_field (arg1, TYPE_VPTR_FIELDNO (context)));
 947
 948   /* Index into the virtual function table.  This is hard-coded because
 949      looking up a field is not cheap, and it may be important to save
 950      time, e.g. if the user has set a conditional breakpoint calling
 951      a virtual function.  */
 952   entry = value_subscript (vtbl, vi);
 953
 954   /* Move the `this' pointer according to the virtual function table.  */
 955   VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0));
 956   if (! VALUE_LAZY (arg1))
 957     {
 958       VALUE_LAZY (arg1) = 1;
 959       value_fetch_lazy (arg1);
 960     }
 961
 962   vfn = value_field (entry, 2);
 963   /* Reinstantiate the function pointer with the correct type.  */
 964   VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
 965
 966   return vfn;
 967 }
 968
 969 /* ARG is a pointer to an object we know to be at least
 970    a DTYPE.  BTYPE is the most derived basetype that has
 971    already been searched (and need not be searched again).
 972    After looking at the vtables between BTYPE and DTYPE,
 973    return the most derived type we find.  The caller must
 974    be satisfied when the return value == DTYPE.
 975
 976    FIXME-tiemann: should work with dossier entries as well.  */
 977
 978 static value
 979 value_headof (arg, btype, dtype)
 980      value arg;
 981      struct type *btype, *dtype;
 982 {
 983   /* First collect the vtables we must look at for this object.  */
 984   /* FIXME-tiemann: right now, just look at top-most vtable.  */
 985   value vtbl, entry, best_entry = 0;
 986   /* FIXME: entry_type is never used.  */
 987   struct type *entry_type;
 988   int i, nelems;
 989   int offset, best_offset = 0;
 990   struct symbol *sym;
 991   CORE_ADDR pc_for_sym;
 992   char *demangled_name;
 993
 994   btype = TYPE_VPTR_BASETYPE (dtype);
 995   check_stub_type (btype);
 996   if (btype != dtype)
 997     vtbl = value_cast (lookup_pointer_type (btype), arg);
 998   else
 999     vtbl = arg;
1000   vtbl = value_ind (value_field (value_ind (vtbl), TYPE_VPTR_FIELDNO (btype)));
1001
1002   /* Check that VTBL looks like it points to a virtual function table.  */
1003   i = find_pc_misc_function (VALUE_ADDRESS (vtbl));
1004   if (i < 0 || ! VTBL_PREFIX_P (misc_function_vector[i].name))
1005     {
1006       /* If we expected to find a vtable, but did not, let the user
1007          know that we aren't happy, but don't throw an error.
1008          FIXME: there has to be a better way to do this.  */
1009       struct type *error_type = (struct type *)xmalloc (sizeof (struct type));
1010       bcopy (VALUE_TYPE (arg), error_type, sizeof (struct type));
1011       TYPE_NAME (error_type) = savestring ("suspicious *", sizeof ("suspicious *"));
1012       VALUE_TYPE (arg) = error_type;
1013       return arg;
1014     }
1015
1016   /* Now search through the virtual function table.  */
1017   entry = value_ind (vtbl);
1018   entry_type = VALUE_TYPE (entry);
1019   nelems = longest_to_int (value_as_long (value_field (entry, 2)));
1020   for (i = 1; i <= nelems; i++)
1021     {
1022       entry = value_subscript (vtbl, value_from_long (builtin_type_int, i));
1023       offset = longest_to_int (value_as_long (value_field (entry, 0)));
1024       if (offset < best_offset)
1025         {
1026           best_offset = offset;
1027           best_entry = entry;
1028         }
1029     }
1030   if (best_entry == 0)
1031     return arg;
1032
1033   /* Move the pointer according to BEST_ENTRY's offset, and figure
1034      out what type we should return as the new pointer.  */
1035   pc_for_sym = value_as_pointer (value_field (best_entry, 2));
1036   sym = find_pc_function (pc_for_sym);
1037   demangled_name = cplus_demangle (SYMBOL_NAME (sym), -1);
1038   *(strchr (demangled_name, ':')) = '\0';
1039   sym = lookup_symbol (demangled_name, 0, VAR_NAMESPACE, 0, 0);
1040   if (sym == 0)
1041     error ("could not find type declaration for `%s'", SYMBOL_NAME (sym));
1042   free (demangled_name);
1043   arg = value_add (value_cast (builtin_type_int, arg),
1044                    value_field (best_entry, 0));
1045   VALUE_TYPE (arg) = lookup_pointer_type (SYMBOL_TYPE (sym));
1046   return arg;
1047 }
1048
1049 /* ARG is a pointer object of type TYPE.  If TYPE has virtual
1050    function tables, probe ARG's tables (including the vtables
1051    of its baseclasses) to figure out the most derived type that ARG
1052    could actually be a pointer to.  */
1053
1054 value
1055 value_from_vtable_info (arg, type)
1056      value arg;
1057      struct type *type;
1058 {
1059   /* Take care of preliminaries.  */
1060   if (TYPE_VPTR_FIELDNO (type) < 0)
1061     fill_in_vptr_fieldno (type);
1062   if (TYPE_VPTR_FIELDNO (type) < 0 || VALUE_REPEATED (arg))
1063     return 0;
1064
1065   return value_headof (arg, 0, type);
1066 }
1067
1068 /* The value of a static class member does not depend
1069    on its instance, only on its type.  If FIELDNO >= 0,
1070    then fieldno is a valid field number and is used directly.
1071    Otherwise, FIELDNAME is the name of the field we are
1072    searching for.  If it is not a static field name, an
1073    error is signaled.  TYPE is the type in which we look for the
1074    static field member.
1075
1076    Return zero if we couldn't find anything; the caller may signal
1077    an error in that case.  */
1078
1079 value
1080 value_static_field (type, fieldname, fieldno)
1081      register struct type *type;
1082      char *fieldname;
1083      register int fieldno;
1084 {
1085   register value v;
1086   struct symbol *sym;
1087   char *phys_name;
1088
1089   if (fieldno < 0)
1090     {
1091       /* Look for static field.  */
1092       int i;
1093       for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
1094         if (! strcmp (TYPE_FIELD_NAME (type, i), fieldname))
1095           {
1096             if (TYPE_FIELD_STATIC (type, i))
1097               {
1098                 fieldno = i;
1099                 goto found;
1100               }
1101             else
1102               error ("field `%s' is not static", fieldname);
1103           }
1104       for (; i > 0; i--)
1105         {
1106           v = value_static_field (TYPE_BASECLASS (type, i), fieldname, -1);
1107           if (v != 0)
1108             return v;
1109         }
1110
1111       if (destructor_name_p (fieldname, type))
1112         error ("Cannot get value of destructor");
1113
1114       for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
1115         {
1116           if (! strcmp (TYPE_FN_FIELDLIST_NAME (type, i), fieldname))
1117             error ("Cannot get value of method \"%s\"", fieldname);
1118         }
1119       error("there is no field named %s", fieldname);
1120     }
1121
1122  found:
1123   phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno);
1124   sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL);
1125   if (! sym) error ("Internal error: could not find physical static variable named %s", phys_name);
1126
1127   type = TYPE_FIELD_TYPE (type, fieldno);
1128   v = value_at (type, (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym));
1129   return v;
1130 }
1131
1132 /* Compute the address of the baseclass which is
1133    the INDEXth baseclass of TYPE.  The TYPE base
1134    of the object is at VALADDR.
1135
1136    If ERRP is non-NULL, set *ERRP to be the errno code of any error,
1137    or 0 if no error.  In that case the return value is not the address
1138    of the baseclasss, but the address which could not be read
1139    successfully.  */
1140
1141 char *
1142 baseclass_addr (type, index, valaddr, valuep, errp)
1143      struct type *type;
1144      int index;
1145      char *valaddr;
1146      value *valuep;
1147      int *errp;
1148 {
1149   struct type *basetype = TYPE_BASECLASS (type, index);
1150
1151   if (errp)
1152     *errp = 0;
1153
1154   if (BASETYPE_VIA_VIRTUAL (type, index))
1155     {
1156       /* Must hunt for the pointer to this virtual baseclass.  */
1157       register int i, len = TYPE_NFIELDS (type);
1158       register int n_baseclasses = TYPE_N_BASECLASSES (type);
1159       char *vbase_name, *type_name = type_name_no_tag (basetype);
1160
1161       if (TYPE_MAIN_VARIANT (basetype))
1162         basetype = TYPE_MAIN_VARIANT (basetype);
1163
1164       vbase_name = (char *)alloca (strlen (type_name) + 8);
1165       sprintf (vbase_name, "_vb$%s", type_name);
1166       /* First look for the virtual baseclass pointer
1167          in the fields.  */
1168       for (i = n_baseclasses; i < len; i++)
1169         {
1170           if (! strcmp (vbase_name, TYPE_FIELD_NAME (type, i)))
1171             {
1172               value val = allocate_value (basetype);
1173               CORE_ADDR addr;
1174               int status;
1175
1176               addr
1177                 = unpack_pointer (TYPE_FIELD_TYPE (type, i),
1178                                   valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
1179
1180               status = target_read_memory (addr,
1181                                            VALUE_CONTENTS_RAW (val),
1182                                            TYPE_LENGTH (basetype));
1183               VALUE_LVAL (val) = lval_memory;
1184               VALUE_ADDRESS (val) = addr;
1185
1186               if (status != 0)
1187                 {
1188                   if (valuep)
1189                     *valuep = NULL;
1190                   release_value (val);
1191                   value_free (val);
1192                   if (errp)
1193                     *errp = status;
1194                   return (char *)addr;
1195                 }
1196               else
1197                 {
1198                   if (valuep)
1199                     *valuep = val;
1200                   return (char *) VALUE_CONTENTS (val);
1201                 }
1202             }
1203         }
1204       /* Not in the fields, so try looking through the baseclasses.  */
1205       for (i = index+1; i < n_baseclasses; i++)
1206         {
1207           char *baddr;
1208
1209           baddr = baseclass_addr (type, i, valaddr, valuep, errp);
1210           if (baddr)
1211             return baddr;
1212         }
1213       /* Not found.  */
1214       if (valuep)
1215         *valuep = 0;
1216       return 0;
1217     }
1218
1219   /* Baseclass is easily computed.  */
1220   if (valuep)
1221     *valuep = 0;
1222   return valaddr + TYPE_BASECLASS_BITPOS (type, index) / 8;
1223 }
1224
1225 /* Ugly hack to convert method stubs into method types.
1226
1227    He ain't kiddin'.  This demangles the name of the method into a string
1228    including argument types, parses out each argument type, generates
1229    a string casting a zero to that type, evaluates the string, and stuffs
1230    the resulting type into an argtype vector!!!  Then it knows the type
1231    of the whole function (including argument types for overloading),
1232    which info used to be in the stab's but was removed to hack back
1233    the space required for them.  */
1234 void
1235 check_stub_method (type, i, j)
1236      struct type *type;
1237      int i, j;
1238 {
1239   extern char *gdb_mangle_typename (), *strchr ();
1240   struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1241   char *field_name = TYPE_FN_FIELDLIST_NAME (type, i);
1242   char *inner_name = gdb_mangle_typename (type);
1243   int mangled_name_len = (strlen (field_name)
1244                           + strlen (inner_name)
1245                           + strlen (TYPE_FN_FIELD_PHYSNAME (f, j))
1246                           + 1);
1247   char *mangled_name;
1248   char *demangled_name;
1249   char *argtypetext, *p;
1250   int depth = 0, argcount = 1;
1251   struct type **argtypes;
1252
1253   if (OPNAME_PREFIX_P (field_name))
1254     {
1255       char *opname = cplus_mangle_opname (field_name + 3);
1256       if (opname == NULL)
1257         error ("No mangling for \"%s\"", field_name);
1258       mangled_name_len += strlen (opname);
1259       mangled_name = (char *)xmalloc (mangled_name_len);
1260
1261       strncpy (mangled_name, field_name, 3);
1262       mangled_name[3] = '\0';
1263       strcat (mangled_name, opname);
1264     }
1265   else
1266     {
1267       mangled_name = (char *)xmalloc (mangled_name_len);
1268       strcpy (mangled_name, TYPE_FN_FIELDLIST_NAME (type, i));
1269     }
1270   strcat (mangled_name, inner_name);
1271   strcat (mangled_name, TYPE_FN_FIELD_PHYSNAME (f, j));
1272   demangled_name = cplus_demangle (mangled_name, 0);
1273
1274   /* Now, read in the parameters that define this type.  */
1275   argtypetext = strchr (demangled_name, '(') + 1;
1276   p = argtypetext;
1277   while (*p)
1278     {
1279       if (*p == '(')
1280         depth += 1;
1281       else if (*p == ')')
1282         depth -= 1;
1283       else if (*p == ',' && depth == 0)
1284         argcount += 1;
1285
1286       p += 1;
1287     }
1288   /* We need one more slot for the void [...] or NULL [end of arglist] */
1289   argtypes = (struct type **)xmalloc ((argcount+1) * sizeof (struct type *));
1290   p = argtypetext;
1291   argtypes[0] = lookup_pointer_type (type);
1292   argcount = 1;
1293
1294   if (*p != ')')                        /* () means no args, skip while */
1295     {
1296       while (*p)
1297         {
1298           if (*p == '(')
1299             depth += 1;
1300           else if (*p == ')')
1301             depth -= 1;
1302
1303           if (depth <= 0 && (*p == ',' || *p == ')'))
1304             {
1305               char *tmp = (char *)alloca (p - argtypetext + 4);
1306               value val;
1307               tmp[0] = '(';
1308               bcopy (argtypetext, tmp+1, p - argtypetext);
1309               tmp[p-argtypetext+1] = ')';
1310               tmp[p-argtypetext+2] = '0';
1311               tmp[p-argtypetext+3] = '\0';
1312               val = parse_and_eval (tmp);
1313               argtypes[argcount] = VALUE_TYPE (val);
1314               argcount += 1;
1315               argtypetext = p + 1;
1316             }
1317           p += 1;
1318         }
1319     }
1320
1321   if (p[-2] != '.')                     /* ... */
1322     argtypes[argcount] = builtin_type_void;     /* Ellist terminator */
1323   else
1324     argtypes[argcount] = NULL;          /* List terminator */
1325
1326   free (demangled_name);
1327
1328   type = lookup_method_type (type, TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), argtypes);
1329   /* Free the stub type...it's no longer needed.  */
1330   free (TYPE_FN_FIELD_TYPE (f, j));
1331   TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name;
1332   TYPE_FN_FIELD_TYPE (f, j) = type;
1333 }
1334 \f
1335 long
1336 unpack_field_as_long (type, valaddr, fieldno)
1337      struct type *type;
1338      char *valaddr;
1339      int fieldno;
1340 {
1341   long val;
1342   int bitpos = TYPE_FIELD_BITPOS (type, fieldno);
1343   int bitsize = TYPE_FIELD_BITSIZE (type, fieldno);
1344
1345   bcopy (valaddr + bitpos / 8, &val, sizeof val);
1346   SWAP_TARGET_AND_HOST (&val, sizeof val);
1347
1348   /* Extracting bits depends on endianness of the machine.  */
1349 #if BITS_BIG_ENDIAN
1350   val = val >> (sizeof val * 8 - bitpos % 8 - bitsize);
1351 #else
1352   val = val >> (bitpos % 8);
1353 #endif
1354
1355   if (bitsize < 8 * sizeof (val))
1356     val &= (((unsigned long)1) << bitsize) - 1;
1357   return val;
1358 }
1359
1360 /* Modify the value of a bitfield.  ADDR points to a block of memory in
1361    target byte order; the bitfield starts in the byte pointed to.  FIELDVAL
1362    is the desired value of the field, in host byte order.  BITPOS and BITSIZE
1363    indicate which bits (in target bit order) comprise the bitfield.  */
1364
1365 void
1366 modify_field (addr, fieldval, bitpos, bitsize)
1367      char *addr;
1368      int fieldval;
1369      int bitpos, bitsize;
1370 {
1371   long oword;
1372
1373   /* Reject values too big to fit in the field in question,
1374      otherwise adjoining fields may be corrupted.  */
1375   if ((0 != fieldval & ~((1<<bitsize)-1))
1376    && bitsize < 8 * sizeof (fieldval))
1377     error ("Value %d does not fit in %d bits.", fieldval, bitsize);
1378
1379   bcopy (addr, &oword, sizeof oword);
1380   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To host format */
1381
1382   /* Shifting for bit field depends on endianness of the target machine.  */
1383 #if BITS_BIG_ENDIAN
1384   bitpos = sizeof (oword) * 8 - bitpos - bitsize;
1385 #endif
1386
1387   /* Mask out old value, while avoiding shifts >= longword size */
1388   if (bitsize < 8 * sizeof (oword))
1389     oword &= ~(((((unsigned long)1) << bitsize) - 1) << bitpos);
1390   else
1391     oword &= ~((-1) << bitpos);
1392   oword |= fieldval << bitpos;
1393
1394   SWAP_TARGET_AND_HOST (&oword, sizeof oword);          /* To target format */
1395   bcopy (&oword, addr, sizeof oword);
1396 }
1397 \f
1398 /* Convert C numbers into newly allocated values */
1399
1400 value
1401 value_from_long (type, num)
1402      struct type *type;
1403      register LONGEST num;
1404 {
1405   register value val = allocate_value (type);
1406   register enum type_code code = TYPE_CODE (type);
1407   register int len = TYPE_LENGTH (type);
1408
1409   if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM)
1410     {
1411       if (len == sizeof (char))
1412         * (char *) VALUE_CONTENTS_RAW (val) = num;
1413       else if (len == sizeof (short))
1414         * (short *) VALUE_CONTENTS_RAW (val) = num;
1415       else if (len == sizeof (int))
1416         * (int *) VALUE_CONTENTS_RAW (val) = num;
1417       else if (len == sizeof (long))
1418         * (long *) VALUE_CONTENTS_RAW (val) = num;
1419 #ifdef LONG_LONG
1420       else if (len == sizeof (long long))
1421         * (long long *) VALUE_CONTENTS_RAW (val) = num;
1422 #endif
1423       else
1424         error ("Integer type encountered with unexpected data length.");
1425     }
1426   else
1427     error ("Unexpected type encountered for integer constant.");
1428
1429   /* num was in host byte order.  So now put the value's contents
1430      into target byte order.  */
1431   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1432
1433   return val;
1434 }
1435
1436 value
1437 value_from_double (type, num)
1438      struct type *type;
1439      double num;
1440 {
1441   register value val = allocate_value (type);
1442   register enum type_code code = TYPE_CODE (type);
1443   register int len = TYPE_LENGTH (type);
1444
1445   if (code == TYPE_CODE_FLT)
1446     {
1447       if (len == sizeof (float))
1448         * (float *) VALUE_CONTENTS_RAW (val) = num;
1449       else if (len == sizeof (double))
1450         * (double *) VALUE_CONTENTS_RAW (val) = num;
1451       else
1452         error ("Floating type encountered with unexpected data length.");
1453     }
1454   else
1455     error ("Unexpected type encountered for floating constant.");
1456
1457   /* num was in host byte order.  So now put the value's contents
1458      into target byte order.  */
1459   SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len);
1460
1461   return val;
1462 }
1463 \f
1464 /* Deal with the value that is "about to be returned".  */
1465
1466 /* Return the value that a function returning now
1467    would be returning to its caller, assuming its type is VALTYPE.
1468    RETBUF is where we look for what ought to be the contents
1469    of the registers (in raw form).  This is because it is often
1470    desirable to restore old values to those registers
1471    after saving the contents of interest, and then call
1472    this function using the saved values.
1473    struct_return is non-zero when the function in question is
1474    using the structure return conventions on the machine in question;
1475    0 when it is using the value returning conventions (this often
1476    means returning pointer to where structure is vs. returning value). */
1477
1478 value
1479 value_being_returned (valtype, retbuf, struct_return)
1480      register struct type *valtype;
1481      char retbuf[REGISTER_BYTES];
1482      int struct_return;
1483      /*ARGSUSED*/
1484 {
1485   register value val;
1486   CORE_ADDR addr;
1487
1488 #if defined (EXTRACT_STRUCT_VALUE_ADDRESS)
1489   /* If this is not defined, just use EXTRACT_RETURN_VALUE instead.  */
1490   if (struct_return) {
1491     addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf);
1492     if (!addr)
1493       error ("Function return value unknown");
1494     return value_at (valtype, addr);
1495   }
1496 #endif
1497
1498   val = allocate_value (valtype);
1499   EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val));
1500
1501   return val;
1502 }
1503
1504 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
1505    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
1506    and TYPE is the type (which is known to be struct, union or array).
1507
1508    On most machines, the struct convention is used unless we are
1509    using gcc and the type is of a special size.  */
1510 #if !defined (USE_STRUCT_CONVENTION)
1511 #define USE_STRUCT_CONVENTION(gcc_p, type)\
1512   (!((gcc_p) && (TYPE_LENGTH (value_type) == 1                \
1513                  || TYPE_LENGTH (value_type) == 2             \
1514                  || TYPE_LENGTH (value_type) == 4             \
1515                  || TYPE_LENGTH (value_type) == 8             \
1516                  )                                            \
1517      ))
1518 #endif
1519
1520 /* Return true if the function specified is using the structure returning
1521    convention on this machine to return arguments, or 0 if it is using
1522    the value returning convention.  FUNCTION is the value representing
1523    the function, FUNCADDR is the address of the function, and VALUE_TYPE
1524    is the type returned by the function.  GCC_P is nonzero if compiled
1525    with GCC.  */
1526
1527 int
1528 using_struct_return (function, funcaddr, value_type, gcc_p)
1529      value function;
1530      CORE_ADDR funcaddr;
1531      struct type *value_type;
1532      int gcc_p;
1533      /*ARGSUSED*/
1534 {
1535   register enum type_code code = TYPE_CODE (value_type);
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 ||
1542       code == TYPE_CODE_ARRAY)
1543     return USE_STRUCT_CONVENTION (gcc_p, value_type);
1544
1545   return 0;
1546 }
1547
1548 /* Store VAL so it will be returned if a function returns now.
1549    Does not verify that VAL's type matches what the current
1550    function wants to return.  */
1551
1552 void
1553 set_return_value (val)
1554      value val;
1555 {
1556   register enum type_code code = TYPE_CODE (VALUE_TYPE (val));
1557   double dbuf;
1558   LONGEST lbuf;
1559
1560   if (code == TYPE_CODE_ERROR)
1561     error ("Function return type unknown.");
1562
1563   if (code == TYPE_CODE_STRUCT
1564       || code == TYPE_CODE_UNION)
1565     error ("Specifying a struct or union return value is not supported.");
1566
1567   /* FIXME, this is bogus.  We don't know what the return conventions
1568      are, or how values should be promoted.... */
1569   if (code == TYPE_CODE_FLT)
1570     {
1571       dbuf = value_as_double (val);
1572
1573       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&dbuf);
1574     }
1575   else
1576     {
1577       lbuf = value_as_long (val);
1578       STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&lbuf);
1579     }
1580 }
1581 \f
1582 void
1583 _initialize_values ()
1584 {
1585   add_cmd ("convenience", no_class, show_convenience,
1586             "Debugger convenience (\"$foo\") variables.\n\
1587 These variables are created when you assign them values;\n\
1588 thus, \"print $foo=1\" gives \"$foo\" the value 1.  Values may be any type.\n\n\
1589 A few convenience variables are given values automatically:\n\
1590 \"$_\"holds the last address examined with \"x\" or \"info lines\",\n\
1591 \"$__\" holds the contents of the last address examined with \"x\".",
1592            &showlist);
1593
1594   add_cmd ("values", no_class, show_values,
1595            "Elements of value history around item number IDX (or last ten).",
1596            &showlist);
1597 }