gdb/values.c

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