OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [valops.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
/* Perform non-arithmetic operations on values, for GDB.
2
   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
3
   1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
4
   Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 2 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 59 Temple Place - Suite 330,
21
   Boston, MA 02111-1307, USA.  */
22
 
23
#include "defs.h"
24
#include "symtab.h"
25
#include "gdbtypes.h"
26
#include "value.h"
27
#include "frame.h"
28
#include "inferior.h"
29
#include "gdbcore.h"
30
#include "target.h"
31
#include "demangle.h"
32
#include "language.h"
33
#include "gdbcmd.h"
34
#include "regcache.h"
35
#include "cp-abi.h"
36
 
37
#include <errno.h>
38
#include "gdb_string.h"
39
#include "gdb_assert.h"
40
 
41
/* Flag indicating HP compilers were used; needed to correctly handle some
42
   value operations with HP aCC code/runtime. */
43
extern int hp_som_som_object_present;
44
 
45
extern int overload_debug;
46
/* Local functions.  */
47
 
48
static int typecmp (int staticp, int varargs, int nargs,
49
                    struct field t1[], struct value *t2[]);
50
 
51
static CORE_ADDR find_function_addr (struct value *, struct type **);
52
static struct value *value_arg_coerce (struct value *, struct type *, int);
53
 
54
 
55
static CORE_ADDR value_push (CORE_ADDR, struct value *);
56
 
57
static struct value *search_struct_field (char *, struct value *, int,
58
                                      struct type *, int);
59
 
60
static struct value *search_struct_method (char *, struct value **,
61
                                       struct value **,
62
                                       int, int *, struct type *);
63
 
64
static int check_field_in (struct type *, const char *);
65
 
66
static CORE_ADDR allocate_space_in_inferior (int);
67
 
68
static struct value *cast_into_complex (struct type *, struct value *);
69
 
70
static struct fn_field *find_method_list (struct value ** argp, char *method,
71
                                          int offset,
72
                                          struct type *type, int *num_fns,
73
                                          struct type **basetype,
74
                                          int *boffset);
75
 
76
void _initialize_valops (void);
77
 
78
/* Flag for whether we want to abandon failed expression evals by default.  */
79
 
80
#if 0
81
static int auto_abandon = 0;
82
#endif
83
 
84
int overload_resolution = 0;
85
 
86
/* This boolean tells what gdb should do if a signal is received while in
87
   a function called from gdb (call dummy).  If set, gdb unwinds the stack
88
   and restore the context to what as it was before the call.
89
   The default is to stop in the frame where the signal was received. */
90
 
91
int unwind_on_signal_p = 0;
92
 
93
 
94
 
95
/* Find the address of function name NAME in the inferior.  */
96
 
97
struct value *
98
find_function_in_inferior (char *name)
99
{
100
  register struct symbol *sym;
101
  sym = lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL);
102
  if (sym != NULL)
103
    {
104
      if (SYMBOL_CLASS (sym) != LOC_BLOCK)
105
        {
106
          error ("\"%s\" exists in this program but is not a function.",
107
                 name);
108
        }
109
      return value_of_variable (sym, NULL);
110
    }
111
  else
112
    {
113
      struct minimal_symbol *msymbol = lookup_minimal_symbol (name, NULL, NULL);
114
      if (msymbol != NULL)
115
        {
116
          struct type *type;
117
          CORE_ADDR maddr;
118
          type = lookup_pointer_type (builtin_type_char);
119
          type = lookup_function_type (type);
120
          type = lookup_pointer_type (type);
121
          maddr = SYMBOL_VALUE_ADDRESS (msymbol);
122
          return value_from_pointer (type, maddr);
123
        }
124
      else
125
        {
126
          if (!target_has_execution)
127
            error ("evaluation of this expression requires the target program to be active");
128
          else
129
            error ("evaluation of this expression requires the program to have a function \"%s\".", name);
130
        }
131
    }
132
}
133
 
134
/* Allocate NBYTES of space in the inferior using the inferior's malloc
135
   and return a value that is a pointer to the allocated space. */
136
 
137
struct value *
138
value_allocate_space_in_inferior (int len)
139
{
140
  struct value *blocklen;
141
  struct value *val = find_function_in_inferior ("malloc");
142
 
143
  blocklen = value_from_longest (builtin_type_int, (LONGEST) len);
144
  val = call_function_by_hand (val, 1, &blocklen);
145
  if (value_logical_not (val))
146
    {
147
      if (!target_has_execution)
148
        error ("No memory available to program now: you need to start the target first");
149
      else
150
        error ("No memory available to program: call to malloc failed");
151
    }
152
  return val;
153
}
154
 
155
static CORE_ADDR
156
allocate_space_in_inferior (int len)
157
{
158
  return value_as_long (value_allocate_space_in_inferior (len));
159
}
160
 
161
/* Cast value ARG2 to type TYPE and return as a value.
162
   More general than a C cast: accepts any two types of the same length,
163
   and if ARG2 is an lvalue it can be cast into anything at all.  */
164
/* In C++, casts may change pointer or object representations.  */
165
 
166
struct value *
167
value_cast (struct type *type, struct value *arg2)
168
{
169
  register enum type_code code1;
170
  register enum type_code code2;
171
  register int scalar;
172
  struct type *type2;
173
 
174
  int convert_to_boolean = 0;
175
 
176
  if (VALUE_TYPE (arg2) == type)
177
    return arg2;
178
 
179
  CHECK_TYPEDEF (type);
180
  code1 = TYPE_CODE (type);
181
  COERCE_REF (arg2);
182
  type2 = check_typedef (VALUE_TYPE (arg2));
183
 
184
  /* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
185
     is treated like a cast to (TYPE [N])OBJECT,
186
     where N is sizeof(OBJECT)/sizeof(TYPE). */
187
  if (code1 == TYPE_CODE_ARRAY)
188
    {
189
      struct type *element_type = TYPE_TARGET_TYPE (type);
190
      unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
191
      if (element_length > 0
192
        && TYPE_ARRAY_UPPER_BOUND_TYPE (type) == BOUND_CANNOT_BE_DETERMINED)
193
        {
194
          struct type *range_type = TYPE_INDEX_TYPE (type);
195
          int val_length = TYPE_LENGTH (type2);
196
          LONGEST low_bound, high_bound, new_length;
197
          if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
198
            low_bound = 0, high_bound = 0;
199
          new_length = val_length / element_length;
200
          if (val_length % element_length != 0)
201
            warning ("array element type size does not divide object size in cast");
202
          /* FIXME-type-allocation: need a way to free this type when we are
203
             done with it.  */
204
          range_type = create_range_type ((struct type *) NULL,
205
                                          TYPE_TARGET_TYPE (range_type),
206
                                          low_bound,
207
                                          new_length + low_bound - 1);
208
          VALUE_TYPE (arg2) = create_array_type ((struct type *) NULL,
209
                                                 element_type, range_type);
210
          return arg2;
211
        }
212
    }
213
 
214
  if (current_language->c_style_arrays
215
      && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
216
    arg2 = value_coerce_array (arg2);
217
 
218
  if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
219
    arg2 = value_coerce_function (arg2);
220
 
221
  type2 = check_typedef (VALUE_TYPE (arg2));
222
  COERCE_VARYING_ARRAY (arg2, type2);
223
  code2 = TYPE_CODE (type2);
224
 
225
  if (code1 == TYPE_CODE_COMPLEX)
226
    return cast_into_complex (type, arg2);
227
  if (code1 == TYPE_CODE_BOOL)
228
    {
229
      code1 = TYPE_CODE_INT;
230
      convert_to_boolean = 1;
231
    }
232
  if (code1 == TYPE_CODE_CHAR)
233
    code1 = TYPE_CODE_INT;
234
  if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
235
    code2 = TYPE_CODE_INT;
236
 
237
  scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
238
            || code2 == TYPE_CODE_ENUM || code2 == TYPE_CODE_RANGE);
239
 
240
  if (code1 == TYPE_CODE_STRUCT
241
      && code2 == TYPE_CODE_STRUCT
242
      && TYPE_NAME (type) != 0)
243
    {
244
      /* Look in the type of the source to see if it contains the
245
         type of the target as a superclass.  If so, we'll need to
246
         offset the object in addition to changing its type.  */
247
      struct value *v = search_struct_field (type_name_no_tag (type),
248
                                         arg2, 0, type2, 1);
249
      if (v)
250
        {
251
          VALUE_TYPE (v) = type;
252
          return v;
253
        }
254
    }
255
  if (code1 == TYPE_CODE_FLT && scalar)
256
    return value_from_double (type, value_as_double (arg2));
257
  else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
258
            || code1 == TYPE_CODE_RANGE)
259
           && (scalar || code2 == TYPE_CODE_PTR))
260
    {
261
      LONGEST longest;
262
 
263
      if (hp_som_som_object_present &&  /* if target compiled by HP aCC */
264
          (code2 == TYPE_CODE_PTR))
265
        {
266
          unsigned int *ptr;
267
          struct value *retvalp;
268
 
269
          switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
270
            {
271
              /* With HP aCC, pointers to data members have a bias */
272
            case TYPE_CODE_MEMBER:
273
              retvalp = value_from_longest (type, value_as_long (arg2));
274
              /* force evaluation */
275
              ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
276
              *ptr &= ~0x20000000;      /* zap 29th bit to remove bias */
277
              return retvalp;
278
 
279
              /* While pointers to methods don't really point to a function */
280
            case TYPE_CODE_METHOD:
281
              error ("Pointers to methods not supported with HP aCC");
282
 
283
            default:
284
              break;            /* fall out and go to normal handling */
285
            }
286
        }
287
 
288
      /* When we cast pointers to integers, we mustn't use
289
         POINTER_TO_ADDRESS to find the address the pointer
290
         represents, as value_as_long would.  GDB should evaluate
291
         expressions just as the compiler would --- and the compiler
292
         sees a cast as a simple reinterpretation of the pointer's
293
         bits.  */
294
      if (code2 == TYPE_CODE_PTR)
295
        longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
296
                                            TYPE_LENGTH (type2));
297
      else
298
        longest = value_as_long (arg2);
299
      return value_from_longest (type, convert_to_boolean ?
300
                                 (LONGEST) (longest ? 1 : 0) : longest);
301
    }
302
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT  ||
303
                                      code2 == TYPE_CODE_ENUM ||
304
                                      code2 == TYPE_CODE_RANGE))
305
    {
306
      /* TYPE_LENGTH (type) is the length of a pointer, but we really
307
         want the length of an address! -- we are really dealing with
308
         addresses (i.e., gdb representations) not pointers (i.e.,
309
         target representations) here.
310
 
311
         This allows things like "print *(int *)0x01000234" to work
312
         without printing a misleading message -- which would
313
         otherwise occur when dealing with a target having two byte
314
         pointers and four byte addresses.  */
315
 
316
      int addr_bit = TARGET_ADDR_BIT;
317
 
318
      LONGEST longest = value_as_long (arg2);
319
      if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
320
        {
321
          if (longest >= ((LONGEST) 1 << addr_bit)
322
              || longest <= -((LONGEST) 1 << addr_bit))
323
            warning ("value truncated");
324
        }
325
      return value_from_longest (type, longest);
326
    }
327
  else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
328
    {
329
      if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
330
        {
331
          struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
332
          struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
333
          if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
334
              && TYPE_CODE (t2) == TYPE_CODE_STRUCT
335
              && !value_logical_not (arg2))
336
            {
337
              struct value *v;
338
 
339
              /* Look in the type of the source to see if it contains the
340
                 type of the target as a superclass.  If so, we'll need to
341
                 offset the pointer rather than just change its type.  */
342
              if (TYPE_NAME (t1) != NULL)
343
                {
344
                  v = search_struct_field (type_name_no_tag (t1),
345
                                           value_ind (arg2), 0, t2, 1);
346
                  if (v)
347
                    {
348
                      v = value_addr (v);
349
                      VALUE_TYPE (v) = type;
350
                      return v;
351
                    }
352
                }
353
 
354
              /* Look in the type of the target to see if it contains the
355
                 type of the source as a superclass.  If so, we'll need to
356
                 offset the pointer rather than just change its type.
357
                 FIXME: This fails silently with virtual inheritance.  */
358
              if (TYPE_NAME (t2) != NULL)
359
                {
360
                  v = search_struct_field (type_name_no_tag (t2),
361
                                       value_zero (t1, not_lval), 0, t1, 1);
362
                  if (v)
363
                    {
364
                      CORE_ADDR addr2 = value_as_address (arg2);
365
                      addr2 -= (VALUE_ADDRESS (v)
366
                                + VALUE_OFFSET (v)
367
                                + VALUE_EMBEDDED_OFFSET (v));
368
                      return value_from_pointer (type, addr2);
369
                    }
370
                }
371
            }
372
          /* No superclass found, just fall through to change ptr type.  */
373
        }
374
      VALUE_TYPE (arg2) = type;
375
      arg2 = value_change_enclosing_type (arg2, type);
376
      VALUE_POINTED_TO_OFFSET (arg2) = 0;        /* pai: chk_val */
377
      return arg2;
378
    }
379
  /* OBSOLETE else if (chill_varying_type (type)) */
380
  /* OBSOLETE   { */
381
  /* OBSOLETE     struct type *range1, *range2, *eltype1, *eltype2; */
382
  /* OBSOLETE     struct value *val; */
383
  /* OBSOLETE     int count1, count2; */
384
  /* OBSOLETE     LONGEST low_bound, high_bound; */
385
  /* OBSOLETE     char *valaddr, *valaddr_data; */
386
  /* OBSOLETE     *//* For lint warning about eltype2 possibly uninitialized: */
387
  /* OBSOLETE     eltype2 = NULL; */
388
  /* OBSOLETE     if (code2 == TYPE_CODE_BITSTRING) */
389
  /* OBSOLETE       error ("not implemented: converting bitstring to varying type"); */
390
  /* OBSOLETE     if ((code2 != TYPE_CODE_ARRAY && code2 != TYPE_CODE_STRING) */
391
  /* OBSOLETE         || (eltype1 = check_typedef (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 1))), */
392
  /* OBSOLETE       eltype2 = check_typedef (TYPE_TARGET_TYPE (type2)), */
393
  /* OBSOLETE                                (TYPE_LENGTH (eltype1) != TYPE_LENGTH (eltype2) */
394
  /* OBSOLETE     *//*|| TYPE_CODE (eltype1) != TYPE_CODE (eltype2) *//* ))) */
395
  /* OBSOLETE      error ("Invalid conversion to varying type"); */
396
  /* OBSOLETE     range1 = TYPE_FIELD_TYPE (TYPE_FIELD_TYPE (type, 1), 0); */
397
  /* OBSOLETE     range2 = TYPE_FIELD_TYPE (type2, 0); */
398
  /* OBSOLETE     if (get_discrete_bounds (range1, &low_bound, &high_bound) < 0) */
399
  /* OBSOLETE       count1 = -1; */
400
  /* OBSOLETE     else */
401
  /* OBSOLETE       count1 = high_bound - low_bound + 1; */
402
  /* OBSOLETE     if (get_discrete_bounds (range2, &low_bound, &high_bound) < 0) */
403
  /* OBSOLETE       count1 = -1, count2 = 0;    *//* To force error before */
404
  /* OBSOLETE     else */
405
  /* OBSOLETE       count2 = high_bound - low_bound + 1; */
406
  /* OBSOLETE     if (count2 > count1) */
407
  /* OBSOLETE       error ("target varying type is too small"); */
408
  /* OBSOLETE     val = allocate_value (type); */
409
  /* OBSOLETE     valaddr = VALUE_CONTENTS_RAW (val); */
410
  /* OBSOLETE     valaddr_data = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8; */
411
  /* OBSOLETE     *//* Set val's __var_length field to count2. */
412
  /* OBSOLETE     store_signed_integer (valaddr, TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)), */
413
  /* OBSOLETE       count2); */
414
  /* OBSOLETE     *//* Set the __var_data field to count2 elements copied from arg2. */
415
  /* OBSOLETE     memcpy (valaddr_data, VALUE_CONTENTS (arg2), */
416
  /* OBSOLETE      count2 * TYPE_LENGTH (eltype2)); */
417
  /* OBSOLETE     *//* Zero the rest of the __var_data field of val. */
418
  /* OBSOLETE     memset (valaddr_data + count2 * TYPE_LENGTH (eltype2), '\0', */
419
  /* OBSOLETE      (count1 - count2) * TYPE_LENGTH (eltype2)); */
420
  /* OBSOLETE     return val; */
421
  /* OBSOLETE   } */
422
  else if (VALUE_LVAL (arg2) == lval_memory)
423
    {
424
      return value_at_lazy (type, VALUE_ADDRESS (arg2) + VALUE_OFFSET (arg2),
425
                            VALUE_BFD_SECTION (arg2));
426
    }
427
  else if (code1 == TYPE_CODE_VOID)
428
    {
429
      return value_zero (builtin_type_void, not_lval);
430
    }
431
  else
432
    {
433
      error ("Invalid cast.");
434
      return 0;
435
    }
436
}
437
 
438
/* Create a value of type TYPE that is zero, and return it.  */
439
 
440
struct value *
441
value_zero (struct type *type, enum lval_type lv)
442
{
443
  struct value *val = allocate_value (type);
444
 
445
  memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
446
  VALUE_LVAL (val) = lv;
447
 
448
  return val;
449
}
450
 
451
/* Return a value with type TYPE located at ADDR.
452
 
453
   Call value_at only if the data needs to be fetched immediately;
454
   if we can be 'lazy' and defer the fetch, perhaps indefinately, call
455
   value_at_lazy instead.  value_at_lazy simply records the address of
456
   the data and sets the lazy-evaluation-required flag.  The lazy flag
457
   is tested in the VALUE_CONTENTS macro, which is used if and when
458
   the contents are actually required.
459
 
460
   Note: value_at does *NOT* handle embedded offsets; perform such
461
   adjustments before or after calling it. */
462
 
463
struct value *
464
value_at (struct type *type, CORE_ADDR addr, asection *sect)
465
{
466
  struct value *val;
467
 
468
  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
469
    error ("Attempt to dereference a generic pointer.");
470
 
471
  val = allocate_value (type);
472
 
473
  read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
474
 
475
  VALUE_LVAL (val) = lval_memory;
476
  VALUE_ADDRESS (val) = addr;
477
  VALUE_BFD_SECTION (val) = sect;
478
 
479
  return val;
480
}
481
 
482
/* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
483
 
484
struct value *
485
value_at_lazy (struct type *type, CORE_ADDR addr, asection *sect)
486
{
487
  struct value *val;
488
 
489
  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
490
    error ("Attempt to dereference a generic pointer.");
491
 
492
  val = allocate_value (type);
493
 
494
  VALUE_LVAL (val) = lval_memory;
495
  VALUE_ADDRESS (val) = addr;
496
  VALUE_LAZY (val) = 1;
497
  VALUE_BFD_SECTION (val) = sect;
498
 
499
  return val;
500
}
501
 
502
/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
503
   if the current data for a variable needs to be loaded into
504
   VALUE_CONTENTS(VAL).  Fetches the data from the user's process, and
505
   clears the lazy flag to indicate that the data in the buffer is valid.
506
 
507
   If the value is zero-length, we avoid calling read_memory, which would
508
   abort.  We mark the value as fetched anyway -- all 0 bytes of it.
509
 
510
   This function returns a value because it is used in the VALUE_CONTENTS
511
   macro as part of an expression, where a void would not work.  The
512
   value is ignored.  */
513
 
514
int
515
value_fetch_lazy (struct value *val)
516
{
517
  CORE_ADDR addr = VALUE_ADDRESS (val) + VALUE_OFFSET (val);
518
  int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
519
 
520
  struct type *type = VALUE_TYPE (val);
521
  if (length)
522
    read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
523
 
524
  VALUE_LAZY (val) = 0;
525
  return 0;
526
}
527
 
528
 
529
/* Store the contents of FROMVAL into the location of TOVAL.
530
   Return a new value with the location of TOVAL and contents of FROMVAL.  */
531
 
532
struct value *
533
value_assign (struct value *toval, struct value *fromval)
534
{
535
  register struct type *type;
536
  struct value *val;
537
  char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
538
  int use_buffer = 0;
539
 
540
  if (!toval->modifiable)
541
    error ("Left operand of assignment is not a modifiable lvalue.");
542
 
543
  COERCE_REF (toval);
544
 
545
  type = VALUE_TYPE (toval);
546
  if (VALUE_LVAL (toval) != lval_internalvar)
547
    fromval = value_cast (type, fromval);
548
  else
549
    COERCE_ARRAY (fromval);
550
  CHECK_TYPEDEF (type);
551
 
552
  /* If TOVAL is a special machine register requiring conversion
553
     of program values to a special raw format,
554
     convert FROMVAL's contents now, with result in `raw_buffer',
555
     and set USE_BUFFER to the number of bytes to write.  */
556
 
557
  if (VALUE_REGNO (toval) >= 0)
558
    {
559
      int regno = VALUE_REGNO (toval);
560
      if (CONVERT_REGISTER_P (regno))
561
        {
562
          struct type *fromtype = check_typedef (VALUE_TYPE (fromval));
563
          VALUE_TO_REGISTER (fromtype, regno, VALUE_CONTENTS (fromval), raw_buffer);
564
          use_buffer = REGISTER_RAW_SIZE (regno);
565
        }
566
    }
567
 
568
  switch (VALUE_LVAL (toval))
569
    {
570
    case lval_internalvar:
571
      set_internalvar (VALUE_INTERNALVAR (toval), fromval);
572
      val = value_copy (VALUE_INTERNALVAR (toval)->value);
573
      val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
574
      VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
575
      VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
576
      return val;
577
 
578
    case lval_internalvar_component:
579
      set_internalvar_component (VALUE_INTERNALVAR (toval),
580
                                 VALUE_OFFSET (toval),
581
                                 VALUE_BITPOS (toval),
582
                                 VALUE_BITSIZE (toval),
583
                                 fromval);
584
      break;
585
 
586
    case lval_memory:
587
      {
588
        char *dest_buffer;
589
        CORE_ADDR changed_addr;
590
        int changed_len;
591
 
592
        if (VALUE_BITSIZE (toval))
593
          {
594
            char buffer[sizeof (LONGEST)];
595
            /* We assume that the argument to read_memory is in units of
596
               host chars.  FIXME:  Is that correct?  */
597
            changed_len = (VALUE_BITPOS (toval)
598
                           + VALUE_BITSIZE (toval)
599
                           + HOST_CHAR_BIT - 1)
600
              / HOST_CHAR_BIT;
601
 
602
            if (changed_len > (int) sizeof (LONGEST))
603
              error ("Can't handle bitfields which don't fit in a %d bit word.",
604
                     (int) sizeof (LONGEST) * HOST_CHAR_BIT);
605
 
606
            read_memory (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
607
                         buffer, changed_len);
608
            modify_field (buffer, value_as_long (fromval),
609
                          VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
610
            changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
611
            dest_buffer = buffer;
612
          }
613
        else if (use_buffer)
614
          {
615
            changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
616
            changed_len = use_buffer;
617
            dest_buffer = raw_buffer;
618
          }
619
        else
620
          {
621
            changed_addr = VALUE_ADDRESS (toval) + VALUE_OFFSET (toval);
622
            changed_len = TYPE_LENGTH (type);
623
            dest_buffer = VALUE_CONTENTS (fromval);
624
          }
625
 
626
        write_memory (changed_addr, dest_buffer, changed_len);
627
        if (memory_changed_hook)
628
          memory_changed_hook (changed_addr, changed_len);
629
        target_changed_event ();
630
      }
631
      break;
632
 
633
    case lval_register:
634
      if (VALUE_BITSIZE (toval))
635
        {
636
          char buffer[sizeof (LONGEST)];
637
          int len =
638
                REGISTER_RAW_SIZE (VALUE_REGNO (toval)) - VALUE_OFFSET (toval);
639
 
640
          if (len > (int) sizeof (LONGEST))
641
            error ("Can't handle bitfields in registers larger than %d bits.",
642
                   (int) sizeof (LONGEST) * HOST_CHAR_BIT);
643
 
644
          if (VALUE_BITPOS (toval) + VALUE_BITSIZE (toval)
645
              > len * HOST_CHAR_BIT)
646
            /* Getting this right would involve being very careful about
647
               byte order.  */
648
            error ("Can't assign to bitfields that cross register "
649
                   "boundaries.");
650
 
651
          read_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
652
                               buffer, len);
653
          modify_field (buffer, value_as_long (fromval),
654
                        VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
655
          write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
656
                                buffer, len);
657
        }
658
      else if (use_buffer)
659
        write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
660
                              raw_buffer, use_buffer);
661
      else
662
        {
663
          /* Do any conversion necessary when storing this type to more
664
             than one register.  */
665
#ifdef REGISTER_CONVERT_FROM_TYPE
666
          memcpy (raw_buffer, VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
667
          REGISTER_CONVERT_FROM_TYPE (VALUE_REGNO (toval), type, raw_buffer);
668
          write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
669
                                raw_buffer, TYPE_LENGTH (type));
670
#else
671
          write_register_bytes (VALUE_ADDRESS (toval) + VALUE_OFFSET (toval),
672
                              VALUE_CONTENTS (fromval), TYPE_LENGTH (type));
673
#endif
674
        }
675
 
676
      target_changed_event ();
677
 
678
      /* Assigning to the stack pointer, frame pointer, and other
679
         (architecture and calling convention specific) registers may
680
         cause the frame cache to be out of date.  We just do this
681
         on all assignments to registers for simplicity; I doubt the slowdown
682
         matters.  */
683
      reinit_frame_cache ();
684
      break;
685
 
686
    case lval_reg_frame_relative:
687
      {
688
        /* value is stored in a series of registers in the frame
689
           specified by the structure.  Copy that value out, modify
690
           it, and copy it back in.  */
691
        int amount_to_copy = (VALUE_BITSIZE (toval) ? 1 : TYPE_LENGTH (type));
692
        int reg_size = REGISTER_RAW_SIZE (VALUE_FRAME_REGNUM (toval));
693
        int byte_offset = VALUE_OFFSET (toval) % reg_size;
694
        int reg_offset = VALUE_OFFSET (toval) / reg_size;
695
        int amount_copied;
696
 
697
        /* Make the buffer large enough in all cases.  */
698
        /* FIXME (alloca): Not safe for very large data types. */
699
        char *buffer = (char *) alloca (amount_to_copy
700
                                        + sizeof (LONGEST)
701
                                        + MAX_REGISTER_RAW_SIZE);
702
 
703
        int regno;
704
        struct frame_info *frame;
705
 
706
        /* Figure out which frame this is in currently.  */
707
        for (frame = get_current_frame ();
708
             frame && FRAME_FP (frame) != VALUE_FRAME (toval);
709
             frame = get_prev_frame (frame))
710
          ;
711
 
712
        if (!frame)
713
          error ("Value being assigned to is no longer active.");
714
 
715
        amount_to_copy += (reg_size - amount_to_copy % reg_size);
716
 
717
        /* Copy it out.  */
718
        for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
719
              amount_copied = 0);
720
             amount_copied < amount_to_copy;
721
             amount_copied += reg_size, regno++)
722
          {
723
            get_saved_register (buffer + amount_copied,
724
                                (int *) NULL, (CORE_ADDR *) NULL,
725
                                frame, regno, (enum lval_type *) NULL);
726
          }
727
 
728
        /* Modify what needs to be modified.  */
729
        if (VALUE_BITSIZE (toval))
730
          modify_field (buffer + byte_offset,
731
                        value_as_long (fromval),
732
                        VALUE_BITPOS (toval), VALUE_BITSIZE (toval));
733
        else if (use_buffer)
734
          memcpy (buffer + byte_offset, raw_buffer, use_buffer);
735
        else
736
          memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
737
                  TYPE_LENGTH (type));
738
 
739
        /* Copy it back.  */
740
        for ((regno = VALUE_FRAME_REGNUM (toval) + reg_offset,
741
              amount_copied = 0);
742
             amount_copied < amount_to_copy;
743
             amount_copied += reg_size, regno++)
744
          {
745
            enum lval_type lval;
746
            CORE_ADDR addr;
747
            int optim;
748
 
749
            /* Just find out where to put it.  */
750
            get_saved_register ((char *) NULL,
751
                                &optim, &addr, frame, regno, &lval);
752
 
753
            if (optim)
754
              error ("Attempt to assign to a value that was optimized out.");
755
            if (lval == lval_memory)
756
              write_memory (addr, buffer + amount_copied, reg_size);
757
            else if (lval == lval_register)
758
              write_register_bytes (addr, buffer + amount_copied, reg_size);
759
            else
760
              error ("Attempt to assign to an unmodifiable value.");
761
          }
762
 
763
        if (register_changed_hook)
764
          register_changed_hook (-1);
765
        target_changed_event ();
766
      }
767
      break;
768
 
769
 
770
    default:
771
      error ("Left operand of assignment is not an lvalue.");
772
    }
773
 
774
  /* If the field does not entirely fill a LONGEST, then zero the sign bits.
775
     If the field is signed, and is negative, then sign extend. */
776
  if ((VALUE_BITSIZE (toval) > 0)
777
      && (VALUE_BITSIZE (toval) < 8 * (int) sizeof (LONGEST)))
778
    {
779
      LONGEST fieldval = value_as_long (fromval);
780
      LONGEST valmask = (((ULONGEST) 1) << VALUE_BITSIZE (toval)) - 1;
781
 
782
      fieldval &= valmask;
783
      if (!TYPE_UNSIGNED (type) && (fieldval & (valmask ^ (valmask >> 1))))
784
        fieldval |= ~valmask;
785
 
786
      fromval = value_from_longest (type, fieldval);
787
    }
788
 
789
  val = value_copy (toval);
790
  memcpy (VALUE_CONTENTS_RAW (val), VALUE_CONTENTS (fromval),
791
          TYPE_LENGTH (type));
792
  VALUE_TYPE (val) = type;
793
  val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
794
  VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
795
  VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
796
 
797
  return val;
798
}
799
 
800
/* Extend a value VAL to COUNT repetitions of its type.  */
801
 
802
struct value *
803
value_repeat (struct value *arg1, int count)
804
{
805
  struct value *val;
806
 
807
  if (VALUE_LVAL (arg1) != lval_memory)
808
    error ("Only values in memory can be extended with '@'.");
809
  if (count < 1)
810
    error ("Invalid number %d of repetitions.", count);
811
 
812
  val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
813
 
814
  read_memory (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1),
815
               VALUE_CONTENTS_ALL_RAW (val),
816
               TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
817
  VALUE_LVAL (val) = lval_memory;
818
  VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1);
819
 
820
  return val;
821
}
822
 
823
struct value *
824
value_of_variable (struct symbol *var, struct block *b)
825
{
826
  struct value *val;
827
  struct frame_info *frame = NULL;
828
 
829
  if (!b)
830
    frame = NULL;               /* Use selected frame.  */
831
  else if (symbol_read_needs_frame (var))
832
    {
833
      frame = block_innermost_frame (b);
834
      if (!frame)
835
        {
836
          if (BLOCK_FUNCTION (b)
837
              && SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)))
838
            error ("No frame is currently executing in block %s.",
839
                   SYMBOL_SOURCE_NAME (BLOCK_FUNCTION (b)));
840
          else
841
            error ("No frame is currently executing in specified block");
842
        }
843
    }
844
 
845
  val = read_var_value (var, frame);
846
  if (!val)
847
    error ("Address of symbol \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
848
 
849
  return val;
850
}
851
 
852
/* Given a value which is an array, return a value which is a pointer to its
853
   first element, regardless of whether or not the array has a nonzero lower
854
   bound.
855
 
856
   FIXME:  A previous comment here indicated that this routine should be
857
   substracting the array's lower bound.  It's not clear to me that this
858
   is correct.  Given an array subscripting operation, it would certainly
859
   work to do the adjustment here, essentially computing:
860
 
861
   (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
862
 
863
   However I believe a more appropriate and logical place to account for
864
   the lower bound is to do so in value_subscript, essentially computing:
865
 
866
   (&array[0] + ((index - lowerbound) * sizeof array[0]))
867
 
868
   As further evidence consider what would happen with operations other
869
   than array subscripting, where the caller would get back a value that
870
   had an address somewhere before the actual first element of the array,
871
   and the information about the lower bound would be lost because of
872
   the coercion to pointer type.
873
 */
874
 
875
struct value *
876
value_coerce_array (struct value *arg1)
877
{
878
  register struct type *type = check_typedef (VALUE_TYPE (arg1));
879
 
880
  if (VALUE_LVAL (arg1) != lval_memory)
881
    error ("Attempt to take address of value not located in memory.");
882
 
883
  return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
884
                             (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
885
}
886
 
887
/* Given a value which is a function, return a value which is a pointer
888
   to it.  */
889
 
890
struct value *
891
value_coerce_function (struct value *arg1)
892
{
893
  struct value *retval;
894
 
895
  if (VALUE_LVAL (arg1) != lval_memory)
896
    error ("Attempt to take address of value not located in memory.");
897
 
898
  retval = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
899
                               (VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1)));
900
  VALUE_BFD_SECTION (retval) = VALUE_BFD_SECTION (arg1);
901
  return retval;
902
}
903
 
904
/* Return a pointer value for the object for which ARG1 is the contents.  */
905
 
906
struct value *
907
value_addr (struct value *arg1)
908
{
909
  struct value *arg2;
910
 
911
  struct type *type = check_typedef (VALUE_TYPE (arg1));
912
  if (TYPE_CODE (type) == TYPE_CODE_REF)
913
    {
914
      /* Copy the value, but change the type from (T&) to (T*).
915
         We keep the same location information, which is efficient,
916
         and allows &(&X) to get the location containing the reference. */
917
      arg2 = value_copy (arg1);
918
      VALUE_TYPE (arg2) = lookup_pointer_type (TYPE_TARGET_TYPE (type));
919
      return arg2;
920
    }
921
  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
922
    return value_coerce_function (arg1);
923
 
924
  if (VALUE_LVAL (arg1) != lval_memory)
925
    error ("Attempt to take address of value not located in memory.");
926
 
927
  /* Get target memory address */
928
  arg2 = value_from_pointer (lookup_pointer_type (VALUE_TYPE (arg1)),
929
                             (VALUE_ADDRESS (arg1)
930
                              + VALUE_OFFSET (arg1)
931
                              + VALUE_EMBEDDED_OFFSET (arg1)));
932
 
933
  /* This may be a pointer to a base subobject; so remember the
934
     full derived object's type ... */
935
  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
936
  /* ... and also the relative position of the subobject in the full object */
937
  VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
938
  VALUE_BFD_SECTION (arg2) = VALUE_BFD_SECTION (arg1);
939
  return arg2;
940
}
941
 
942
/* Given a value of a pointer type, apply the C unary * operator to it.  */
943
 
944
struct value *
945
value_ind (struct value *arg1)
946
{
947
  struct type *base_type;
948
  struct value *arg2;
949
 
950
  COERCE_ARRAY (arg1);
951
 
952
  base_type = check_typedef (VALUE_TYPE (arg1));
953
 
954
  if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
955
    error ("not implemented: member types in value_ind");
956
 
957
  /* Allow * on an integer so we can cast it to whatever we want.
958
     This returns an int, which seems like the most C-like thing
959
     to do.  "long long" variables are rare enough that
960
     BUILTIN_TYPE_LONGEST would seem to be a mistake.  */
961
  if (TYPE_CODE (base_type) == TYPE_CODE_INT)
962
    return value_at_lazy (builtin_type_int,
963
                          (CORE_ADDR) value_as_long (arg1),
964
                          VALUE_BFD_SECTION (arg1));
965
  else if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
966
    {
967
      struct type *enc_type;
968
      /* We may be pointing to something embedded in a larger object */
969
      /* Get the real type of the enclosing object */
970
      enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
971
      enc_type = TYPE_TARGET_TYPE (enc_type);
972
      /* Retrieve the enclosing object pointed to */
973
      arg2 = value_at_lazy (enc_type,
974
                   value_as_address (arg1) - VALUE_POINTED_TO_OFFSET (arg1),
975
                            VALUE_BFD_SECTION (arg1));
976
      /* Re-adjust type */
977
      VALUE_TYPE (arg2) = TYPE_TARGET_TYPE (base_type);
978
      /* Add embedding info */
979
      arg2 = value_change_enclosing_type (arg2, enc_type);
980
      VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
981
 
982
      /* We may be pointing to an object of some derived type */
983
      arg2 = value_full_object (arg2, NULL, 0, 0, 0);
984
      return arg2;
985
    }
986
 
987
  error ("Attempt to take contents of a non-pointer value.");
988
  return 0;                      /* For lint -- never reached */
989
}
990
 
991
/* Pushing small parts of stack frames.  */
992
 
993
/* Push one word (the size of object that a register holds).  */
994
 
995
CORE_ADDR
996
push_word (CORE_ADDR sp, ULONGEST word)
997
{
998
  register int len = REGISTER_SIZE;
999
  char *buffer = alloca (MAX_REGISTER_RAW_SIZE);
1000
 
1001
  store_unsigned_integer (buffer, len, word);
1002
  if (INNER_THAN (1, 2))
1003
    {
1004
      /* stack grows downward */
1005
      sp -= len;
1006
      write_memory (sp, buffer, len);
1007
    }
1008
  else
1009
    {
1010
      /* stack grows upward */
1011
      write_memory (sp, buffer, len);
1012
      sp += len;
1013
    }
1014
 
1015
  return sp;
1016
}
1017
 
1018
/* Push LEN bytes with data at BUFFER.  */
1019
 
1020
CORE_ADDR
1021
push_bytes (CORE_ADDR sp, char *buffer, int len)
1022
{
1023
  if (INNER_THAN (1, 2))
1024
    {
1025
      /* stack grows downward */
1026
      sp -= len;
1027
      write_memory (sp, buffer, len);
1028
    }
1029
  else
1030
    {
1031
      /* stack grows upward */
1032
      write_memory (sp, buffer, len);
1033
      sp += len;
1034
    }
1035
 
1036
  return sp;
1037
}
1038
 
1039
#ifndef PARM_BOUNDARY
1040
#define PARM_BOUNDARY (0)
1041
#endif
1042
 
1043
/* Push onto the stack the specified value VALUE.  Pad it correctly for
1044
   it to be an argument to a function.  */
1045
 
1046
static CORE_ADDR
1047
value_push (register CORE_ADDR sp, struct value *arg)
1048
{
1049
  register int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (arg));
1050
  register int container_len = len;
1051
  register int offset;
1052
 
1053
  /* How big is the container we're going to put this value in?  */
1054
  if (PARM_BOUNDARY)
1055
    container_len = ((len + PARM_BOUNDARY / TARGET_CHAR_BIT - 1)
1056
                     & ~(PARM_BOUNDARY / TARGET_CHAR_BIT - 1));
1057
 
1058
  /* Are we going to put it at the high or low end of the container?  */
1059
  if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
1060
    offset = container_len - len;
1061
  else
1062
    offset = 0;
1063
 
1064
  if (INNER_THAN (1, 2))
1065
    {
1066
      /* stack grows downward */
1067
      sp -= container_len;
1068
      write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1069
    }
1070
  else
1071
    {
1072
      /* stack grows upward */
1073
      write_memory (sp + offset, VALUE_CONTENTS_ALL (arg), len);
1074
      sp += container_len;
1075
    }
1076
 
1077
  return sp;
1078
}
1079
 
1080
CORE_ADDR
1081
default_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
1082
                        int struct_return, CORE_ADDR struct_addr)
1083
{
1084
  /* ASSERT ( !struct_return); */
1085
  int i;
1086
  for (i = nargs - 1; i >= 0; i--)
1087
    sp = value_push (sp, args[i]);
1088
  return sp;
1089
}
1090
 
1091
 
1092
/* Functions to use for the COERCE_FLOAT_TO_DOUBLE gdbarch method.
1093
 
1094
   How you should pass arguments to a function depends on whether it
1095
   was defined in K&R style or prototype style.  If you define a
1096
   function using the K&R syntax that takes a `float' argument, then
1097
   callers must pass that argument as a `double'.  If you define the
1098
   function using the prototype syntax, then you must pass the
1099
   argument as a `float', with no promotion.
1100
 
1101
   Unfortunately, on certain older platforms, the debug info doesn't
1102
   indicate reliably how each function was defined.  A function type's
1103
   TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
1104
   defined in prototype style.  When calling a function whose
1105
   TYPE_FLAG_PROTOTYPED flag is clear, GDB consults the
1106
   COERCE_FLOAT_TO_DOUBLE gdbarch method to decide what to do.
1107
 
1108
   For modern targets, it is proper to assume that, if the prototype
1109
   flag is clear, that can be trusted: `float' arguments should be
1110
   promoted to `double'.  You should register the function
1111
   `standard_coerce_float_to_double' to get this behavior.
1112
 
1113
   For some older targets, if the prototype flag is clear, that
1114
   doesn't tell us anything.  So we guess that, if we don't have a
1115
   type for the formal parameter (i.e., the first argument to
1116
   COERCE_FLOAT_TO_DOUBLE is null), then we should promote it;
1117
   otherwise, we should leave it alone.  The function
1118
   `default_coerce_float_to_double' provides this behavior; it is the
1119
   default value, for compatibility with older configurations.  */
1120
int
1121
default_coerce_float_to_double (struct type *formal, struct type *actual)
1122
{
1123
  return formal == NULL;
1124
}
1125
 
1126
 
1127
int
1128
standard_coerce_float_to_double (struct type *formal, struct type *actual)
1129
{
1130
  return 1;
1131
}
1132
 
1133
 
1134
/* Perform the standard coercions that are specified
1135
   for arguments to be passed to C functions.
1136
 
1137
   If PARAM_TYPE is non-NULL, it is the expected parameter type.
1138
   IS_PROTOTYPED is non-zero if the function declaration is prototyped.  */
1139
 
1140
static struct value *
1141
value_arg_coerce (struct value *arg, struct type *param_type,
1142
                  int is_prototyped)
1143
{
1144
  register struct type *arg_type = check_typedef (VALUE_TYPE (arg));
1145
  register struct type *type
1146
    = param_type ? check_typedef (param_type) : arg_type;
1147
 
1148
  switch (TYPE_CODE (type))
1149
    {
1150
    case TYPE_CODE_REF:
1151
      if (TYPE_CODE (arg_type) != TYPE_CODE_REF
1152
          && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
1153
        {
1154
          arg = value_addr (arg);
1155
          VALUE_TYPE (arg) = param_type;
1156
          return arg;
1157
        }
1158
      break;
1159
    case TYPE_CODE_INT:
1160
    case TYPE_CODE_CHAR:
1161
    case TYPE_CODE_BOOL:
1162
    case TYPE_CODE_ENUM:
1163
      /* If we don't have a prototype, coerce to integer type if necessary.  */
1164
      if (!is_prototyped)
1165
        {
1166
          if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1167
            type = builtin_type_int;
1168
        }
1169
      /* Currently all target ABIs require at least the width of an integer
1170
         type for an argument.  We may have to conditionalize the following
1171
         type coercion for future targets.  */
1172
      if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
1173
        type = builtin_type_int;
1174
      break;
1175
    case TYPE_CODE_FLT:
1176
      /* FIXME: We should always convert floats to doubles in the
1177
         non-prototyped case.  As many debugging formats include
1178
         no information about prototyping, we have to live with
1179
         COERCE_FLOAT_TO_DOUBLE for now.  */
1180
      if (!is_prototyped && COERCE_FLOAT_TO_DOUBLE (param_type, arg_type))
1181
        {
1182
          if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
1183
            type = builtin_type_double;
1184
          else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
1185
            type = builtin_type_long_double;
1186
        }
1187
      break;
1188
    case TYPE_CODE_FUNC:
1189
      type = lookup_pointer_type (type);
1190
      break;
1191
    case TYPE_CODE_ARRAY:
1192
      /* Arrays are coerced to pointers to their first element, unless
1193
         they are vectors, in which case we want to leave them alone,
1194
         because they are passed by value.  */
1195
      if (current_language->c_style_arrays)
1196
        if (!TYPE_VECTOR (type))
1197
          type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
1198
      break;
1199
    case TYPE_CODE_UNDEF:
1200
    case TYPE_CODE_PTR:
1201
    case TYPE_CODE_STRUCT:
1202
    case TYPE_CODE_UNION:
1203
    case TYPE_CODE_VOID:
1204
    case TYPE_CODE_SET:
1205
    case TYPE_CODE_RANGE:
1206
    case TYPE_CODE_STRING:
1207
    case TYPE_CODE_BITSTRING:
1208
    case TYPE_CODE_ERROR:
1209
    case TYPE_CODE_MEMBER:
1210
    case TYPE_CODE_METHOD:
1211
    case TYPE_CODE_COMPLEX:
1212
    default:
1213
      break;
1214
    }
1215
 
1216
  return value_cast (type, arg);
1217
}
1218
 
1219
/* Determine a function's address and its return type from its value.
1220
   Calls error() if the function is not valid for calling.  */
1221
 
1222
static CORE_ADDR
1223
find_function_addr (struct value *function, struct type **retval_type)
1224
{
1225
  register struct type *ftype = check_typedef (VALUE_TYPE (function));
1226
  register enum type_code code = TYPE_CODE (ftype);
1227
  struct type *value_type;
1228
  CORE_ADDR funaddr;
1229
 
1230
  /* If it's a member function, just look at the function
1231
     part of it.  */
1232
 
1233
  /* Determine address to call.  */
1234
  if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
1235
    {
1236
      funaddr = VALUE_ADDRESS (function);
1237
      value_type = TYPE_TARGET_TYPE (ftype);
1238
    }
1239
  else if (code == TYPE_CODE_PTR)
1240
    {
1241
      funaddr = value_as_address (function);
1242
      ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
1243
      if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
1244
          || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1245
        {
1246
          funaddr = CONVERT_FROM_FUNC_PTR_ADDR (funaddr);
1247
          value_type = TYPE_TARGET_TYPE (ftype);
1248
        }
1249
      else
1250
        value_type = builtin_type_int;
1251
    }
1252
  else if (code == TYPE_CODE_INT)
1253
    {
1254
      /* Handle the case of functions lacking debugging info.
1255
         Their values are characters since their addresses are char */
1256
      if (TYPE_LENGTH (ftype) == 1)
1257
        funaddr = value_as_address (value_addr (function));
1258
      else
1259
        /* Handle integer used as address of a function.  */
1260
        funaddr = (CORE_ADDR) value_as_long (function);
1261
 
1262
      value_type = builtin_type_int;
1263
    }
1264
  else
1265
    error ("Invalid data type for function to be called.");
1266
 
1267
  *retval_type = value_type;
1268
  return funaddr;
1269
}
1270
 
1271
/* All this stuff with a dummy frame may seem unnecessarily complicated
1272
   (why not just save registers in GDB?).  The purpose of pushing a dummy
1273
   frame which looks just like a real frame is so that if you call a
1274
   function and then hit a breakpoint (get a signal, etc), "backtrace"
1275
   will look right.  Whether the backtrace needs to actually show the
1276
   stack at the time the inferior function was called is debatable, but
1277
   it certainly needs to not display garbage.  So if you are contemplating
1278
   making dummy frames be different from normal frames, consider that.  */
1279
 
1280
/* Perform a function call in the inferior.
1281
   ARGS is a vector of values of arguments (NARGS of them).
1282
   FUNCTION is a value, the function to be called.
1283
   Returns a value representing what the function returned.
1284
   May fail to return, if a breakpoint or signal is hit
1285
   during the execution of the function.
1286
 
1287
   ARGS is modified to contain coerced values. */
1288
 
1289
static struct value *
1290
hand_function_call (struct value *function, int nargs, struct value **args)
1291
{
1292
  register CORE_ADDR sp;
1293
  register int i;
1294
  int rc;
1295
  CORE_ADDR start_sp;
1296
  /* CALL_DUMMY is an array of words (REGISTER_SIZE), but each word
1297
     is in host byte order.  Before calling FIX_CALL_DUMMY, we byteswap it
1298
     and remove any extra bytes which might exist because ULONGEST is
1299
     bigger than REGISTER_SIZE.
1300
 
1301
     NOTE: This is pretty wierd, as the call dummy is actually a
1302
     sequence of instructions.  But CISC machines will have
1303
     to pack the instructions into REGISTER_SIZE units (and
1304
     so will RISC machines for which INSTRUCTION_SIZE is not
1305
     REGISTER_SIZE).
1306
 
1307
     NOTE: This is pretty stupid.  CALL_DUMMY should be in strict
1308
     target byte order. */
1309
 
1310
  static ULONGEST *dummy;
1311
  int sizeof_dummy1;
1312
  char *dummy1;
1313
  CORE_ADDR old_sp;
1314
  struct type *value_type;
1315
  unsigned char struct_return;
1316
  CORE_ADDR struct_addr = 0;
1317
  struct regcache *retbuf;
1318
  struct cleanup *retbuf_cleanup;
1319
  struct inferior_status *inf_status;
1320
  struct cleanup *inf_status_cleanup;
1321
  CORE_ADDR funaddr;
1322
  int using_gcc;                /* Set to version of gcc in use, or zero if not gcc */
1323
  CORE_ADDR real_pc;
1324
  struct type *param_type = NULL;
1325
  struct type *ftype = check_typedef (SYMBOL_TYPE (function));
1326
  int n_method_args = 0;
1327
 
1328
  dummy = alloca (SIZEOF_CALL_DUMMY_WORDS);
1329
  sizeof_dummy1 = REGISTER_SIZE * SIZEOF_CALL_DUMMY_WORDS / sizeof (ULONGEST);
1330
  dummy1 = alloca (sizeof_dummy1);
1331
  memcpy (dummy, CALL_DUMMY_WORDS, SIZEOF_CALL_DUMMY_WORDS);
1332
 
1333
  if (!target_has_execution)
1334
    noprocess ();
1335
 
1336
  /* Create a cleanup chain that contains the retbuf (buffer
1337
     containing the register values).  This chain is create BEFORE the
1338
     inf_status chain so that the inferior status can cleaned up
1339
     (restored or discarded) without having the retbuf freed.  */
1340
  retbuf = regcache_xmalloc (current_gdbarch);
1341
  retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1342
 
1343
  /* A cleanup for the inferior status.  Create this AFTER the retbuf
1344
     so that this can be discarded or applied without interfering with
1345
     the regbuf.  */
1346
  inf_status = save_inferior_status (1);
1347
  inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
1348
 
1349
  /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers
1350
     (and POP_FRAME for restoring them).  (At least on most machines)
1351
     they are saved on the stack in the inferior.  */
1352
  PUSH_DUMMY_FRAME;
1353
 
1354
  old_sp = sp = read_sp ();
1355
 
1356
  if (INNER_THAN (1, 2))
1357
    {
1358
      /* Stack grows down */
1359
      sp -= sizeof_dummy1;
1360
      start_sp = sp;
1361
    }
1362
  else
1363
    {
1364
      /* Stack grows up */
1365
      start_sp = sp;
1366
      sp += sizeof_dummy1;
1367
    }
1368
 
1369
  funaddr = find_function_addr (function, &value_type);
1370
  CHECK_TYPEDEF (value_type);
1371
 
1372
  {
1373
    struct block *b = block_for_pc (funaddr);
1374
    /* If compiled without -g, assume GCC 2.  */
1375
    using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
1376
  }
1377
 
1378
  /* Are we returning a value using a structure return or a normal
1379
     value return? */
1380
 
1381
  struct_return = using_struct_return (function, funaddr, value_type,
1382
                                       using_gcc);
1383
 
1384
  /* Create a call sequence customized for this function
1385
     and the number of arguments for it.  */
1386
  for (i = 0; i < (int) (SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); i++)
1387
    store_unsigned_integer (&dummy1[i * REGISTER_SIZE],
1388
                            REGISTER_SIZE,
1389
                            (ULONGEST) dummy[i]);
1390
 
1391
#ifdef GDB_TARGET_IS_HPPA
1392
  real_pc = FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1393
                            value_type, using_gcc);
1394
#else
1395
  FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args,
1396
                  value_type, using_gcc);
1397
  real_pc = start_sp;
1398
#endif
1399
 
1400
  if (CALL_DUMMY_LOCATION == ON_STACK)
1401
    {
1402
      write_memory (start_sp, (char *) dummy1, sizeof_dummy1);
1403
      if (USE_GENERIC_DUMMY_FRAMES)
1404
        generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1);
1405
    }
1406
 
1407
  if (CALL_DUMMY_LOCATION == BEFORE_TEXT_END)
1408
    {
1409
      /* Convex Unix prohibits executing in the stack segment. */
1410
      /* Hope there is empty room at the top of the text segment. */
1411
      extern CORE_ADDR text_end;
1412
      static int checked = 0;
1413
      if (!checked)
1414
        for (start_sp = text_end - sizeof_dummy1; start_sp < text_end; ++start_sp)
1415
          if (read_memory_integer (start_sp, 1) != 0)
1416
            error ("text segment full -- no place to put call");
1417
      checked = 1;
1418
      sp = old_sp;
1419
      real_pc = text_end - sizeof_dummy1;
1420
      write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1421
      if (USE_GENERIC_DUMMY_FRAMES)
1422
        generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
1423
    }
1424
 
1425
  if (CALL_DUMMY_LOCATION == AFTER_TEXT_END)
1426
    {
1427
      extern CORE_ADDR text_end;
1428
      int errcode;
1429
      sp = old_sp;
1430
      real_pc = text_end;
1431
      errcode = target_write_memory (real_pc, (char *) dummy1, sizeof_dummy1);
1432
      if (errcode != 0)
1433
        error ("Cannot write text segment -- call_function failed");
1434
      if (USE_GENERIC_DUMMY_FRAMES)
1435
        generic_save_call_dummy_addr (real_pc, real_pc + sizeof_dummy1);
1436
    }
1437
 
1438
  if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
1439
    {
1440
      real_pc = funaddr;
1441
      if (USE_GENERIC_DUMMY_FRAMES)
1442
        /* NOTE: cagney/2002-04-13: The entry point is going to be
1443
           modified with a single breakpoint.  */
1444
        generic_save_call_dummy_addr (CALL_DUMMY_ADDRESS (),
1445
                                      CALL_DUMMY_ADDRESS () + 1);
1446
    }
1447
 
1448
#ifdef lint
1449
  sp = old_sp;                  /* It really is used, for some ifdef's... */
1450
#endif
1451
 
1452
  if (nargs < TYPE_NFIELDS (ftype))
1453
    error ("too few arguments in function call");
1454
 
1455
  for (i = nargs - 1; i >= 0; i--)
1456
    {
1457
      int prototyped;
1458
 
1459
      /* FIXME drow/2002-05-31: Should just always mark methods as
1460
         prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
1461
      if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
1462
        prototyped = 1;
1463
      else
1464
        prototyped = TYPE_PROTOTYPED (ftype);
1465
 
1466
      if (i < TYPE_NFIELDS (ftype))
1467
        args[i] = value_arg_coerce (args[i], TYPE_FIELD_TYPE (ftype, i),
1468
                                    prototyped);
1469
      else
1470
        args[i] = value_arg_coerce (args[i], NULL, 0);
1471
 
1472
      /*elz: this code is to handle the case in which the function to be called
1473
         has a pointer to function as parameter and the corresponding actual argument
1474
         is the address of a function and not a pointer to function variable.
1475
         In aCC compiled code, the calls through pointers to functions (in the body
1476
         of the function called by hand) are made via $$dyncall_external which
1477
         requires some registers setting, this is taken care of if we call
1478
         via a function pointer variable, but not via a function address.
1479
         In cc this is not a problem. */
1480
 
1481
      if (using_gcc == 0)
1482
        if (param_type && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
1483
          /* if this parameter is a pointer to function */
1484
          if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
1485
            if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
1486
              /* elz: FIXME here should go the test about the compiler used
1487
                 to compile the target. We want to issue the error
1488
                 message only if the compiler used was HP's aCC.
1489
                 If we used HP's cc, then there is no problem and no need
1490
                 to return at this point */
1491
              if (using_gcc == 0)        /* && compiler == aCC */
1492
                /* go see if the actual parameter is a variable of type
1493
                   pointer to function or just a function */
1494
                if (args[i]->lval == not_lval)
1495
                  {
1496
                    char *arg_name;
1497
                    if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
1498
                      error ("\
1499
You cannot use function <%s> as argument. \n\
1500
You must use a pointer to function type variable. Command ignored.", arg_name);
1501
                  }
1502
    }
1503
 
1504
  if (REG_STRUCT_HAS_ADDR_P ())
1505
    {
1506
      /* This is a machine like the sparc, where we may need to pass a
1507
         pointer to the structure, not the structure itself.  */
1508
      for (i = nargs - 1; i >= 0; i--)
1509
        {
1510
          struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
1511
          if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
1512
               || TYPE_CODE (arg_type) == TYPE_CODE_UNION
1513
               || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
1514
               || TYPE_CODE (arg_type) == TYPE_CODE_STRING
1515
               || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
1516
               || TYPE_CODE (arg_type) == TYPE_CODE_SET
1517
               || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
1518
                   && TYPE_LENGTH (arg_type) > 8)
1519
               )
1520
              && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
1521
            {
1522
              CORE_ADDR addr;
1523
              int len;          /*  = TYPE_LENGTH (arg_type); */
1524
              int aligned_len;
1525
              arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
1526
              len = TYPE_LENGTH (arg_type);
1527
 
1528
              if (STACK_ALIGN_P ())
1529
                /* MVS 11/22/96: I think at least some of this
1530
                   stack_align code is really broken.  Better to let
1531
                   PUSH_ARGUMENTS adjust the stack in a target-defined
1532
                   manner.  */
1533
                aligned_len = STACK_ALIGN (len);
1534
              else
1535
                aligned_len = len;
1536
              if (INNER_THAN (1, 2))
1537
                {
1538
                  /* stack grows downward */
1539
                  sp -= aligned_len;
1540
                  /* ... so the address of the thing we push is the
1541
                     stack pointer after we push it.  */
1542
                  addr = sp;
1543
                }
1544
              else
1545
                {
1546
                  /* The stack grows up, so the address of the thing
1547
                     we push is the stack pointer before we push it.  */
1548
                  addr = sp;
1549
                  sp += aligned_len;
1550
                }
1551
              /* Push the structure.  */
1552
              write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
1553
              /* The value we're going to pass is the address of the
1554
                 thing we just pushed.  */
1555
              /*args[i] = value_from_longest (lookup_pointer_type (value_type),
1556
                (LONGEST) addr); */
1557
              args[i] = value_from_pointer (lookup_pointer_type (arg_type),
1558
                                            addr);
1559
            }
1560
        }
1561
    }
1562
 
1563
 
1564
  /* Reserve space for the return structure to be written on the
1565
     stack, if necessary */
1566
 
1567
  if (struct_return)
1568
    {
1569
      int len = TYPE_LENGTH (value_type);
1570
      if (STACK_ALIGN_P ())
1571
        /* MVS 11/22/96: I think at least some of this stack_align
1572
           code is really broken.  Better to let PUSH_ARGUMENTS adjust
1573
           the stack in a target-defined manner.  */
1574
        len = STACK_ALIGN (len);
1575
      if (INNER_THAN (1, 2))
1576
        {
1577
          /* stack grows downward */
1578
          sp -= len;
1579
          struct_addr = sp;
1580
        }
1581
      else
1582
        {
1583
          /* stack grows upward */
1584
          struct_addr = sp;
1585
          sp += len;
1586
        }
1587
    }
1588
 
1589
  /* elz: on HPPA no need for this extra alignment, maybe it is needed
1590
     on other architectures. This is because all the alignment is
1591
     taken care of in the above code (ifdef REG_STRUCT_HAS_ADDR) and
1592
     in hppa_push_arguments */
1593
  if (EXTRA_STACK_ALIGNMENT_NEEDED)
1594
    {
1595
      /* MVS 11/22/96: I think at least some of this stack_align code
1596
         is really broken.  Better to let PUSH_ARGUMENTS adjust the
1597
         stack in a target-defined manner.  */
1598
      if (STACK_ALIGN_P () && INNER_THAN (1, 2))
1599
        {
1600
          /* If stack grows down, we must leave a hole at the top. */
1601
          int len = 0;
1602
 
1603
          for (i = nargs - 1; i >= 0; i--)
1604
            len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
1605
          if (CALL_DUMMY_STACK_ADJUST_P)
1606
            len += CALL_DUMMY_STACK_ADJUST;
1607
          sp -= STACK_ALIGN (len) - len;
1608
        }
1609
    }
1610
 
1611
  sp = PUSH_ARGUMENTS (nargs, args, sp, struct_return, struct_addr);
1612
 
1613
  if (PUSH_RETURN_ADDRESS_P ())
1614
    /* for targets that use no CALL_DUMMY */
1615
    /* There are a number of targets now which actually don't write
1616
       any CALL_DUMMY instructions into the target, but instead just
1617
       save the machine state, push the arguments, and jump directly
1618
       to the callee function.  Since this doesn't actually involve
1619
       executing a JSR/BSR instruction, the return address must be set
1620
       up by hand, either by pushing onto the stack or copying into a
1621
       return-address register as appropriate.  Formerly this has been
1622
       done in PUSH_ARGUMENTS, but that's overloading its
1623
       functionality a bit, so I'm making it explicit to do it here.  */
1624
    sp = PUSH_RETURN_ADDRESS (real_pc, sp);
1625
 
1626
  if (STACK_ALIGN_P () && !INNER_THAN (1, 2))
1627
    {
1628
      /* If stack grows up, we must leave a hole at the bottom, note
1629
         that sp already has been advanced for the arguments!  */
1630
      if (CALL_DUMMY_STACK_ADJUST_P)
1631
        sp += CALL_DUMMY_STACK_ADJUST;
1632
      sp = STACK_ALIGN (sp);
1633
    }
1634
 
1635
/* XXX This seems wrong.  For stacks that grow down we shouldn't do
1636
   anything here!  */
1637
  /* MVS 11/22/96: I think at least some of this stack_align code is
1638
     really broken.  Better to let PUSH_ARGUMENTS adjust the stack in
1639
     a target-defined manner.  */
1640
  if (CALL_DUMMY_STACK_ADJUST_P)
1641
    if (INNER_THAN (1, 2))
1642
      {
1643
        /* stack grows downward */
1644
        sp -= CALL_DUMMY_STACK_ADJUST;
1645
      }
1646
 
1647
  /* Store the address at which the structure is supposed to be
1648
     written.  Note that this (and the code which reserved the space
1649
     above) assumes that gcc was used to compile this function.  Since
1650
     it doesn't cost us anything but space and if the function is pcc
1651
     it will ignore this value, we will make that assumption.
1652
 
1653
     Also note that on some machines (like the sparc) pcc uses a
1654
     convention like gcc's.  */
1655
 
1656
  if (struct_return)
1657
    STORE_STRUCT_RETURN (struct_addr, sp);
1658
 
1659
  /* Write the stack pointer.  This is here because the statements above
1660
     might fool with it.  On SPARC, this write also stores the register
1661
     window into the right place in the new stack frame, which otherwise
1662
     wouldn't happen.  (See store_inferior_registers in sparc-nat.c.)  */
1663
  write_sp (sp);
1664
 
1665
  if (SAVE_DUMMY_FRAME_TOS_P ())
1666
    SAVE_DUMMY_FRAME_TOS (sp);
1667
 
1668
  {
1669
    char *name;
1670
    struct symbol *symbol;
1671
 
1672
    name = NULL;
1673
    symbol = find_pc_function (funaddr);
1674
    if (symbol)
1675
      {
1676
        name = SYMBOL_SOURCE_NAME (symbol);
1677
      }
1678
    else
1679
      {
1680
        /* Try the minimal symbols.  */
1681
        struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
1682
 
1683
        if (msymbol)
1684
          {
1685
            name = SYMBOL_SOURCE_NAME (msymbol);
1686
          }
1687
      }
1688
    if (name == NULL)
1689
      {
1690
        char format[80];
1691
        sprintf (format, "at %s", local_hex_format ());
1692
        name = alloca (80);
1693
        /* FIXME-32x64: assumes funaddr fits in a long.  */
1694
        sprintf (name, format, (unsigned long) funaddr);
1695
      }
1696
 
1697
    /* Execute the stack dummy routine, calling FUNCTION.
1698
       When it is done, discard the empty frame
1699
       after storing the contents of all regs into retbuf.  */
1700
    rc = run_stack_dummy (real_pc + CALL_DUMMY_START_OFFSET, retbuf);
1701
 
1702
    if (rc == 1)
1703
      {
1704
        /* We stopped inside the FUNCTION because of a random signal.
1705
           Further execution of the FUNCTION is not allowed. */
1706
 
1707
        if (unwind_on_signal_p)
1708
          {
1709
            /* The user wants the context restored. */
1710
 
1711
            /* We must get back to the frame we were before the dummy call. */
1712
            POP_FRAME;
1713
 
1714
            /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1715
               a C++ name with arguments and stuff.  */
1716
            error ("\
1717
The program being debugged was signaled while in a function called from GDB.\n\
1718
GDB has restored the context to what it was before the call.\n\
1719
To change this behavior use \"set unwindonsignal off\"\n\
1720
Evaluation of the expression containing the function (%s) will be abandoned.",
1721
                   name);
1722
          }
1723
        else
1724
          {
1725
            /* The user wants to stay in the frame where we stopped (default).*/
1726
 
1727
            /* If we restored the inferior status (via the cleanup),
1728
               we would print a spurious error message (Unable to
1729
               restore previously selected frame), would write the
1730
               registers from the inf_status (which is wrong), and
1731
               would do other wrong things.  */
1732
            discard_cleanups (inf_status_cleanup);
1733
            discard_inferior_status (inf_status);
1734
 
1735
            /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1736
               a C++ name with arguments and stuff.  */
1737
            error ("\
1738
The program being debugged was signaled while in a function called from GDB.\n\
1739
GDB remains in the frame where the signal was received.\n\
1740
To change this behavior use \"set unwindonsignal on\"\n\
1741
Evaluation of the expression containing the function (%s) will be abandoned.",
1742
                   name);
1743
          }
1744
      }
1745
 
1746
    if (rc == 2)
1747
      {
1748
        /* We hit a breakpoint inside the FUNCTION. */
1749
 
1750
        /* If we restored the inferior status (via the cleanup), we
1751
           would print a spurious error message (Unable to restore
1752
           previously selected frame), would write the registers from
1753
           the inf_status (which is wrong), and would do other wrong
1754
           things.  */
1755
        discard_cleanups (inf_status_cleanup);
1756
        discard_inferior_status (inf_status);
1757
 
1758
        /* The following error message used to say "The expression
1759
           which contained the function call has been discarded."  It
1760
           is a hard concept to explain in a few words.  Ideally, GDB
1761
           would be able to resume evaluation of the expression when
1762
           the function finally is done executing.  Perhaps someday
1763
           this will be implemented (it would not be easy).  */
1764
 
1765
        /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1766
           a C++ name with arguments and stuff.  */
1767
        error ("\
1768
The program being debugged stopped while in a function called from GDB.\n\
1769
When the function (%s) is done executing, GDB will silently\n\
1770
stop (instead of continuing to evaluate the expression containing\n\
1771
the function call).", name);
1772
      }
1773
 
1774
    /* If we get here the called FUNCTION run to completion. */
1775
 
1776
    /* Restore the inferior status, via its cleanup.  At this stage,
1777
       leave the RETBUF alone.  */
1778
    do_cleanups (inf_status_cleanup);
1779
 
1780
    /* Figure out the value returned by the function.  */
1781
/* elz: I defined this new macro for the hppa architecture only.
1782
   this gives us a way to get the value returned by the function from the stack,
1783
   at the same address we told the function to put it.
1784
   We cannot assume on the pa that r28 still contains the address of the returned
1785
   structure. Usually this will be overwritten by the callee.
1786
   I don't know about other architectures, so I defined this macro
1787
 */
1788
 
1789
#ifdef VALUE_RETURNED_FROM_STACK
1790
    if (struct_return)
1791
      {
1792
        do_cleanups (retbuf_cleanup);
1793
        return VALUE_RETURNED_FROM_STACK (value_type, struct_addr);
1794
      }
1795
#endif
1796
 
1797
    {
1798
      struct value *retval = value_being_returned (value_type, retbuf, struct_return);
1799
      do_cleanups (retbuf_cleanup);
1800
      return retval;
1801
    }
1802
  }
1803
}
1804
 
1805
struct value *
1806
call_function_by_hand (struct value *function, int nargs, struct value **args)
1807
{
1808
  if (CALL_DUMMY_P)
1809
    {
1810
      return hand_function_call (function, nargs, args);
1811
    }
1812
  else
1813
    {
1814
      error ("Cannot invoke functions on this machine.");
1815
    }
1816
}
1817
 
1818
 
1819
 
1820
/* Create a value for an array by allocating space in the inferior, copying
1821
   the data into that space, and then setting up an array value.
1822
 
1823
   The array bounds are set from LOWBOUND and HIGHBOUND, and the array is
1824
   populated from the values passed in ELEMVEC.
1825
 
1826
   The element type of the array is inherited from the type of the
1827
   first element, and all elements must have the same size (though we
1828
   don't currently enforce any restriction on their types). */
1829
 
1830
struct value *
1831
value_array (int lowbound, int highbound, struct value **elemvec)
1832
{
1833
  int nelem;
1834
  int idx;
1835
  unsigned int typelength;
1836
  struct value *val;
1837
  struct type *rangetype;
1838
  struct type *arraytype;
1839
  CORE_ADDR addr;
1840
 
1841
  /* Validate that the bounds are reasonable and that each of the elements
1842
     have the same size. */
1843
 
1844
  nelem = highbound - lowbound + 1;
1845
  if (nelem <= 0)
1846
    {
1847
      error ("bad array bounds (%d, %d)", lowbound, highbound);
1848
    }
1849
  typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
1850
  for (idx = 1; idx < nelem; idx++)
1851
    {
1852
      if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
1853
        {
1854
          error ("array elements must all be the same size");
1855
        }
1856
    }
1857
 
1858
  rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
1859
                                 lowbound, highbound);
1860
  arraytype = create_array_type ((struct type *) NULL,
1861
                              VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
1862
 
1863
  if (!current_language->c_style_arrays)
1864
    {
1865
      val = allocate_value (arraytype);
1866
      for (idx = 0; idx < nelem; idx++)
1867
        {
1868
          memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
1869
                  VALUE_CONTENTS_ALL (elemvec[idx]),
1870
                  typelength);
1871
        }
1872
      VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (elemvec[0]);
1873
      return val;
1874
    }
1875
 
1876
  /* Allocate space to store the array in the inferior, and then initialize
1877
     it by copying in each element.  FIXME:  Is it worth it to create a
1878
     local buffer in which to collect each value and then write all the
1879
     bytes in one operation? */
1880
 
1881
  addr = allocate_space_in_inferior (nelem * typelength);
1882
  for (idx = 0; idx < nelem; idx++)
1883
    {
1884
      write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
1885
                    typelength);
1886
    }
1887
 
1888
  /* Create the array type and set up an array value to be evaluated lazily. */
1889
 
1890
  val = value_at_lazy (arraytype, addr, VALUE_BFD_SECTION (elemvec[0]));
1891
  return (val);
1892
}
1893
 
1894
/* Create a value for a string constant by allocating space in the inferior,
1895
   copying the data into that space, and returning the address with type
1896
   TYPE_CODE_STRING.  PTR points to the string constant data; LEN is number
1897
   of characters.
1898
   Note that string types are like array of char types with a lower bound of
1899
   zero and an upper bound of LEN - 1.  Also note that the string may contain
1900
   embedded null bytes. */
1901
 
1902
struct value *
1903
value_string (char *ptr, int len)
1904
{
1905
  struct value *val;
1906
  int lowbound = current_language->string_lower_bound;
1907
  struct type *rangetype = create_range_type ((struct type *) NULL,
1908
                                              builtin_type_int,
1909
                                              lowbound, len + lowbound - 1);
1910
  struct type *stringtype
1911
  = create_string_type ((struct type *) NULL, rangetype);
1912
  CORE_ADDR addr;
1913
 
1914
  if (current_language->c_style_arrays == 0)
1915
    {
1916
      val = allocate_value (stringtype);
1917
      memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
1918
      return val;
1919
    }
1920
 
1921
 
1922
  /* Allocate space to store the string in the inferior, and then
1923
     copy LEN bytes from PTR in gdb to that address in the inferior. */
1924
 
1925
  addr = allocate_space_in_inferior (len);
1926
  write_memory (addr, ptr, len);
1927
 
1928
  val = value_at_lazy (stringtype, addr, NULL);
1929
  return (val);
1930
}
1931
 
1932
struct value *
1933
value_bitstring (char *ptr, int len)
1934
{
1935
  struct value *val;
1936
  struct type *domain_type = create_range_type (NULL, builtin_type_int,
1937
                                                0, len - 1);
1938
  struct type *type = create_set_type ((struct type *) NULL, domain_type);
1939
  TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1940
  val = allocate_value (type);
1941
  memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
1942
  return val;
1943
}
1944
 
1945
/* See if we can pass arguments in T2 to a function which takes arguments
1946
   of types T1.  T1 is a list of NARGS arguments, and T2 is a NULL-terminated
1947
   vector.  If some arguments need coercion of some sort, then the coerced
1948
   values are written into T2.  Return value is 0 if the arguments could be
1949
   matched, or the position at which they differ if not.
1950
 
1951
   STATICP is nonzero if the T1 argument list came from a
1952
   static member function.  T2 will still include the ``this'' pointer,
1953
   but it will be skipped.
1954
 
1955
   For non-static member functions, we ignore the first argument,
1956
   which is the type of the instance variable.  This is because we want
1957
   to handle calls with objects from derived classes.  This is not
1958
   entirely correct: we should actually check to make sure that a
1959
   requested operation is type secure, shouldn't we?  FIXME.  */
1960
 
1961
static int
1962
typecmp (int staticp, int varargs, int nargs,
1963
         struct field t1[], struct value *t2[])
1964
{
1965
  int i;
1966
 
1967
  if (t2 == 0)
1968
    internal_error (__FILE__, __LINE__, "typecmp: no argument list");
1969
 
1970
  /* Skip ``this'' argument if applicable.  T2 will always include THIS.  */
1971
  if (staticp)
1972
    t2 ++;
1973
 
1974
  for (i = 0;
1975
       (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1976
       i++)
1977
    {
1978
      struct type *tt1, *tt2;
1979
 
1980
      if (!t2[i])
1981
        return i + 1;
1982
 
1983
      tt1 = check_typedef (t1[i].type);
1984
      tt2 = check_typedef (VALUE_TYPE (t2[i]));
1985
 
1986
      if (TYPE_CODE (tt1) == TYPE_CODE_REF
1987
      /* We should be doing hairy argument matching, as below.  */
1988
          && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1989
        {
1990
          if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1991
            t2[i] = value_coerce_array (t2[i]);
1992
          else
1993
            t2[i] = value_addr (t2[i]);
1994
          continue;
1995
        }
1996
 
1997
      /* djb - 20000715 - Until the new type structure is in the
1998
         place, and we can attempt things like implicit conversions,
1999
         we need to do this so you can take something like a map<const
2000
         char *>, and properly access map["hello"], because the
2001
         argument to [] will be a reference to a pointer to a char,
2002
         and the argument will be a pointer to a char. */
2003
      while ( TYPE_CODE(tt1) == TYPE_CODE_REF ||
2004
              TYPE_CODE (tt1) == TYPE_CODE_PTR)
2005
        {
2006
          tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
2007
        }
2008
      while ( TYPE_CODE(tt2) == TYPE_CODE_ARRAY ||
2009
              TYPE_CODE(tt2) == TYPE_CODE_PTR ||
2010
              TYPE_CODE(tt2) == TYPE_CODE_REF)
2011
        {
2012
          tt2 = check_typedef( TYPE_TARGET_TYPE(tt2) );
2013
        }
2014
      if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
2015
        continue;
2016
      /* Array to pointer is a `trivial conversion' according to the ARM.  */
2017
 
2018
      /* We should be doing much hairier argument matching (see section 13.2
2019
         of the ARM), but as a quick kludge, just check for the same type
2020
         code.  */
2021
      if (TYPE_CODE (t1[i].type) != TYPE_CODE (VALUE_TYPE (t2[i])))
2022
        return i + 1;
2023
    }
2024
  if (varargs || t2[i] == NULL)
2025
    return 0;
2026
  return i + 1;
2027
}
2028
 
2029
/* Helper function used by value_struct_elt to recurse through baseclasses.
2030
   Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2031
   and search in it assuming it has (class) type TYPE.
2032
   If found, return value, else return NULL.
2033
 
2034
   If LOOKING_FOR_BASECLASS, then instead of looking for struct fields,
2035
   look for a baseclass named NAME.  */
2036
 
2037
static struct value *
2038
search_struct_field (char *name, struct value *arg1, int offset,
2039
                     register struct type *type, int looking_for_baseclass)
2040
{
2041
  int i;
2042
  int nbases = TYPE_N_BASECLASSES (type);
2043
 
2044
  CHECK_TYPEDEF (type);
2045
 
2046
  if (!looking_for_baseclass)
2047
    for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
2048
      {
2049
        char *t_field_name = TYPE_FIELD_NAME (type, i);
2050
 
2051
        if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2052
          {
2053
            struct value *v;
2054
            if (TYPE_FIELD_STATIC (type, i))
2055
              {
2056
                v = value_static_field (type, i);
2057
                if (v == 0)
2058
                  error ("field %s is nonexistent or has been optimised out",
2059
                         name);
2060
              }
2061
            else
2062
              {
2063
                v = value_primitive_field (arg1, offset, i, type);
2064
                if (v == 0)
2065
                  error ("there is no field named %s", name);
2066
              }
2067
            return v;
2068
          }
2069
 
2070
        if (t_field_name
2071
            && (t_field_name[0] == '\0'
2072
                || (TYPE_CODE (type) == TYPE_CODE_UNION
2073
                    && (strcmp_iw (t_field_name, "else") == 0))))
2074
          {
2075
            struct type *field_type = TYPE_FIELD_TYPE (type, i);
2076
            if (TYPE_CODE (field_type) == TYPE_CODE_UNION
2077
                || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
2078
              {
2079
                /* Look for a match through the fields of an anonymous union,
2080
                   or anonymous struct.  C++ provides anonymous unions.
2081
 
2082
                   In the GNU Chill (OBSOLETE) implementation of
2083
                   variant record types, each <alternative field> has
2084
                   an (anonymous) union type, each member of the union
2085
                   represents a <variant alternative>.  Each <variant
2086
                   alternative> is represented as a struct, with a
2087
                   member for each <variant field>.  */
2088
 
2089
                struct value *v;
2090
                int new_offset = offset;
2091
 
2092
                /* This is pretty gross.  In G++, the offset in an
2093
                   anonymous union is relative to the beginning of the
2094
                   enclosing struct.  In the GNU Chill (OBSOLETE)
2095
                   implementation of variant records, the bitpos is
2096
                   zero in an anonymous union field, so we have to add
2097
                   the offset of the union here. */
2098
                if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
2099
                    || (TYPE_NFIELDS (field_type) > 0
2100
                        && TYPE_FIELD_BITPOS (field_type, 0) == 0))
2101
                  new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
2102
 
2103
                v = search_struct_field (name, arg1, new_offset, field_type,
2104
                                         looking_for_baseclass);
2105
                if (v)
2106
                  return v;
2107
              }
2108
          }
2109
      }
2110
 
2111
  for (i = 0; i < nbases; i++)
2112
    {
2113
      struct value *v;
2114
      struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
2115
      /* If we are looking for baseclasses, this is what we get when we
2116
         hit them.  But it could happen that the base part's member name
2117
         is not yet filled in.  */
2118
      int found_baseclass = (looking_for_baseclass
2119
                             && TYPE_BASECLASS_NAME (type, i) != NULL
2120
                             && (strcmp_iw (name, TYPE_BASECLASS_NAME (type, i)) == 0));
2121
 
2122
      if (BASETYPE_VIA_VIRTUAL (type, i))
2123
        {
2124
          int boffset;
2125
          struct value *v2 = allocate_value (basetype);
2126
 
2127
          boffset = baseclass_offset (type, i,
2128
                                      VALUE_CONTENTS (arg1) + offset,
2129
                                      VALUE_ADDRESS (arg1)
2130
                                      + VALUE_OFFSET (arg1) + offset);
2131
          if (boffset == -1)
2132
            error ("virtual baseclass botch");
2133
 
2134
          /* The virtual base class pointer might have been clobbered by the
2135
             user program. Make sure that it still points to a valid memory
2136
             location.  */
2137
 
2138
          boffset += offset;
2139
          if (boffset < 0 || boffset >= TYPE_LENGTH (type))
2140
            {
2141
              CORE_ADDR base_addr;
2142
 
2143
              base_addr = VALUE_ADDRESS (arg1) + VALUE_OFFSET (arg1) + boffset;
2144
              if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
2145
                                      TYPE_LENGTH (basetype)) != 0)
2146
                error ("virtual baseclass botch");
2147
              VALUE_LVAL (v2) = lval_memory;
2148
              VALUE_ADDRESS (v2) = base_addr;
2149
            }
2150
          else
2151
            {
2152
              VALUE_LVAL (v2) = VALUE_LVAL (arg1);
2153
              VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
2154
              VALUE_OFFSET (v2) = VALUE_OFFSET (arg1) + boffset;
2155
              if (VALUE_LAZY (arg1))
2156
                VALUE_LAZY (v2) = 1;
2157
              else
2158
                memcpy (VALUE_CONTENTS_RAW (v2),
2159
                        VALUE_CONTENTS_RAW (arg1) + boffset,
2160
                        TYPE_LENGTH (basetype));
2161
            }
2162
 
2163
          if (found_baseclass)
2164
            return v2;
2165
          v = search_struct_field (name, v2, 0, TYPE_BASECLASS (type, i),
2166
                                   looking_for_baseclass);
2167
        }
2168
      else if (found_baseclass)
2169
        v = value_primitive_field (arg1, offset, i, type);
2170
      else
2171
        v = search_struct_field (name, arg1,
2172
                               offset + TYPE_BASECLASS_BITPOS (type, i) / 8,
2173
                                 basetype, looking_for_baseclass);
2174
      if (v)
2175
        return v;
2176
    }
2177
  return NULL;
2178
}
2179
 
2180
 
2181
/* Return the offset (in bytes) of the virtual base of type BASETYPE
2182
 * in an object pointed to by VALADDR (on the host), assumed to be of
2183
 * type TYPE.  OFFSET is number of bytes beyond start of ARG to start
2184
 * looking (in case VALADDR is the contents of an enclosing object).
2185
 *
2186
 * This routine recurses on the primary base of the derived class because
2187
 * the virtual base entries of the primary base appear before the other
2188
 * virtual base entries.
2189
 *
2190
 * If the virtual base is not found, a negative integer is returned.
2191
 * The magnitude of the negative integer is the number of entries in
2192
 * the virtual table to skip over (entries corresponding to various
2193
 * ancestral classes in the chain of primary bases).
2194
 *
2195
 * Important: This assumes the HP / Taligent C++ runtime
2196
 * conventions. Use baseclass_offset() instead to deal with g++
2197
 * conventions.  */
2198
 
2199
void
2200
find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
2201
                      int offset, int *boffset_p, int *skip_p)
2202
{
2203
  int boffset;                  /* offset of virtual base */
2204
  int index;                    /* displacement to use in virtual table */
2205
  int skip;
2206
 
2207
  struct value *vp;
2208
  CORE_ADDR vtbl;               /* the virtual table pointer */
2209
  struct type *pbc;             /* the primary base class */
2210
 
2211
  /* Look for the virtual base recursively in the primary base, first.
2212
   * This is because the derived class object and its primary base
2213
   * subobject share the primary virtual table.  */
2214
 
2215
  boffset = 0;
2216
  pbc = TYPE_PRIMARY_BASE (type);
2217
  if (pbc)
2218
    {
2219
      find_rt_vbase_offset (pbc, basetype, valaddr, offset, &boffset, &skip);
2220
      if (skip < 0)
2221
        {
2222
          *boffset_p = boffset;
2223
          *skip_p = -1;
2224
          return;
2225
        }
2226
    }
2227
  else
2228
    skip = 0;
2229
 
2230
 
2231
  /* Find the index of the virtual base according to HP/Taligent
2232
     runtime spec. (Depth-first, left-to-right.)  */
2233
  index = virtual_base_index_skip_primaries (basetype, type);
2234
 
2235
  if (index < 0)
2236
    {
2237
      *skip_p = skip + virtual_base_list_length_skip_primaries (type);
2238
      *boffset_p = 0;
2239
      return;
2240
    }
2241
 
2242
  /* pai: FIXME -- 32x64 possible problem */
2243
  /* First word (4 bytes) in object layout is the vtable pointer */
2244
  vtbl = *(CORE_ADDR *) (valaddr + offset);
2245
 
2246
  /* Before the constructor is invoked, things are usually zero'd out. */
2247
  if (vtbl == 0)
2248
    error ("Couldn't find virtual table -- object may not be constructed yet.");
2249
 
2250
 
2251
  /* Find virtual base's offset -- jump over entries for primary base
2252
   * ancestors, then use the index computed above.  But also adjust by
2253
   * HP_ACC_VBASE_START for the vtable slots before the start of the
2254
   * virtual base entries.  Offset is negative -- virtual base entries
2255
   * appear _before_ the address point of the virtual table. */
2256
 
2257
  /* pai: FIXME -- 32x64 problem, if word = 8 bytes, change multiplier
2258
     & use long type */
2259
 
2260
  /* epstein : FIXME -- added param for overlay section. May not be correct */
2261
  vp = value_at (builtin_type_int, vtbl + 4 * (-skip - index - HP_ACC_VBASE_START), NULL);
2262
  boffset = value_as_long (vp);
2263
  *skip_p = -1;
2264
  *boffset_p = boffset;
2265
  return;
2266
}
2267
 
2268
 
2269
/* Helper function used by value_struct_elt to recurse through baseclasses.
2270
   Look for a field NAME in ARG1. Adjust the address of ARG1 by OFFSET bytes,
2271
   and search in it assuming it has (class) type TYPE.
2272
   If found, return value, else if name matched and args not return (value)-1,
2273
   else return NULL. */
2274
 
2275
static struct value *
2276
search_struct_method (char *name, struct value **arg1p,
2277
                      struct value **args, int offset,
2278
                      int *static_memfuncp, register struct type *type)
2279
{
2280
  int i;
2281
  struct value *v;
2282
  int name_matched = 0;
2283
  char dem_opname[64];
2284
 
2285
  CHECK_TYPEDEF (type);
2286
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2287
    {
2288
      char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2289
      /* FIXME!  May need to check for ARM demangling here */
2290
      if (strncmp (t_field_name, "__", 2) == 0 ||
2291
          strncmp (t_field_name, "op", 2) == 0 ||
2292
          strncmp (t_field_name, "type", 4) == 0)
2293
        {
2294
          if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2295
            t_field_name = dem_opname;
2296
          else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2297
            t_field_name = dem_opname;
2298
        }
2299
      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2300
        {
2301
          int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2302
          struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2303
          name_matched = 1;
2304
 
2305
          if (j > 0 && args == 0)
2306
            error ("cannot resolve overloaded method `%s': no arguments supplied", name);
2307
          else if (j == 0 && args == 0)
2308
            {
2309
              if (TYPE_FN_FIELD_STUB (f, j))
2310
                check_stub_method (type, i, j);
2311
              v = value_fn_field (arg1p, f, j, type, offset);
2312
              if (v != NULL)
2313
                return v;
2314
            }
2315
          else
2316
            while (j >= 0)
2317
              {
2318
                if (TYPE_FN_FIELD_STUB (f, j))
2319
                  check_stub_method (type, i, j);
2320
                if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2321
                              TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2322
                              TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2323
                              TYPE_FN_FIELD_ARGS (f, j), args))
2324
                  {
2325
                    if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2326
                      return value_virtual_fn_field (arg1p, f, j, type, offset);
2327
                    if (TYPE_FN_FIELD_STATIC_P (f, j) && static_memfuncp)
2328
                      *static_memfuncp = 1;
2329
                    v = value_fn_field (arg1p, f, j, type, offset);
2330
                    if (v != NULL)
2331
                      return v;
2332
                  }
2333
                j--;
2334
              }
2335
        }
2336
    }
2337
 
2338
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2339
    {
2340
      int base_offset;
2341
 
2342
      if (BASETYPE_VIA_VIRTUAL (type, i))
2343
        {
2344
          if (TYPE_HAS_VTABLE (type))
2345
            {
2346
              /* HP aCC compiled type, search for virtual base offset
2347
                 according to HP/Taligent runtime spec.  */
2348
              int skip;
2349
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2350
                                    VALUE_CONTENTS_ALL (*arg1p),
2351
                                    offset + VALUE_EMBEDDED_OFFSET (*arg1p),
2352
                                    &base_offset, &skip);
2353
              if (skip >= 0)
2354
                error ("Virtual base class offset not found in vtable");
2355
            }
2356
          else
2357
            {
2358
              struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2359
              char *base_valaddr;
2360
 
2361
              /* The virtual base class pointer might have been clobbered by the
2362
                 user program. Make sure that it still points to a valid memory
2363
                 location.  */
2364
 
2365
              if (offset < 0 || offset >= TYPE_LENGTH (type))
2366
                {
2367
                  base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
2368
                  if (target_read_memory (VALUE_ADDRESS (*arg1p)
2369
                                          + VALUE_OFFSET (*arg1p) + offset,
2370
                                          base_valaddr,
2371
                                          TYPE_LENGTH (baseclass)) != 0)
2372
                    error ("virtual baseclass botch");
2373
                }
2374
              else
2375
                base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
2376
 
2377
              base_offset =
2378
                baseclass_offset (type, i, base_valaddr,
2379
                                  VALUE_ADDRESS (*arg1p)
2380
                                  + VALUE_OFFSET (*arg1p) + offset);
2381
              if (base_offset == -1)
2382
                error ("virtual baseclass botch");
2383
            }
2384
        }
2385
      else
2386
        {
2387
          base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2388
        }
2389
      v = search_struct_method (name, arg1p, args, base_offset + offset,
2390
                                static_memfuncp, TYPE_BASECLASS (type, i));
2391
      if (v == (struct value *) - 1)
2392
        {
2393
          name_matched = 1;
2394
        }
2395
      else if (v)
2396
        {
2397
/* FIXME-bothner:  Why is this commented out?  Why is it here?  */
2398
/*        *arg1p = arg1_tmp; */
2399
          return v;
2400
        }
2401
    }
2402
  if (name_matched)
2403
    return (struct value *) - 1;
2404
  else
2405
    return NULL;
2406
}
2407
 
2408
/* Given *ARGP, a value of type (pointer to a)* structure/union,
2409
   extract the component named NAME from the ultimate target structure/union
2410
   and return it as a value with its appropriate type.
2411
   ERR is used in the error message if *ARGP's type is wrong.
2412
 
2413
   C++: ARGS is a list of argument types to aid in the selection of
2414
   an appropriate method. Also, handle derived types.
2415
 
2416
   STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2417
   where the truthvalue of whether the function that was resolved was
2418
   a static member function or not is stored.
2419
 
2420
   ERR is an error message to be printed in case the field is not found.  */
2421
 
2422
struct value *
2423
value_struct_elt (struct value **argp, struct value **args,
2424
                  char *name, int *static_memfuncp, char *err)
2425
{
2426
  register struct type *t;
2427
  struct value *v;
2428
 
2429
  COERCE_ARRAY (*argp);
2430
 
2431
  t = check_typedef (VALUE_TYPE (*argp));
2432
 
2433
  /* Follow pointers until we get to a non-pointer.  */
2434
 
2435
  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2436
    {
2437
      *argp = value_ind (*argp);
2438
      /* Don't coerce fn pointer to fn and then back again!  */
2439
      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2440
        COERCE_ARRAY (*argp);
2441
      t = check_typedef (VALUE_TYPE (*argp));
2442
    }
2443
 
2444
  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2445
    error ("not implemented: member type in value_struct_elt");
2446
 
2447
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2448
      && TYPE_CODE (t) != TYPE_CODE_UNION)
2449
    error ("Attempt to extract a component of a value that is not a %s.", err);
2450
 
2451
  /* Assume it's not, unless we see that it is.  */
2452
  if (static_memfuncp)
2453
    *static_memfuncp = 0;
2454
 
2455
  if (!args)
2456
    {
2457
      /* if there are no arguments ...do this...  */
2458
 
2459
      /* Try as a field first, because if we succeed, there
2460
         is less work to be done.  */
2461
      v = search_struct_field (name, *argp, 0, t, 0);
2462
      if (v)
2463
        return v;
2464
 
2465
      /* C++: If it was not found as a data field, then try to
2466
         return it as a pointer to a method.  */
2467
 
2468
      if (destructor_name_p (name, t))
2469
        error ("Cannot get value of destructor");
2470
 
2471
      v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2472
 
2473
      if (v == (struct value *) - 1)
2474
        error ("Cannot take address of a method");
2475
      else if (v == 0)
2476
        {
2477
          if (TYPE_NFN_FIELDS (t))
2478
            error ("There is no member or method named %s.", name);
2479
          else
2480
            error ("There is no member named %s.", name);
2481
        }
2482
      return v;
2483
    }
2484
 
2485
  if (destructor_name_p (name, t))
2486
    {
2487
      if (!args[1])
2488
        {
2489
          /* Destructors are a special case.  */
2490
          int m_index, f_index;
2491
 
2492
          v = NULL;
2493
          if (get_destructor_fn_field (t, &m_index, &f_index))
2494
            {
2495
              v = value_fn_field (NULL, TYPE_FN_FIELDLIST1 (t, m_index),
2496
                                  f_index, NULL, 0);
2497
            }
2498
          if (v == NULL)
2499
            error ("could not find destructor function named %s.", name);
2500
          else
2501
            return v;
2502
        }
2503
      else
2504
        {
2505
          error ("destructor should not have any argument");
2506
        }
2507
    }
2508
  else
2509
    v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
2510
 
2511
  if (v == (struct value *) - 1)
2512
    {
2513
      error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
2514
    }
2515
  else if (v == 0)
2516
    {
2517
      /* See if user tried to invoke data as function.  If so,
2518
         hand it back.  If it's not callable (i.e., a pointer to function),
2519
         gdb should give an error.  */
2520
      v = search_struct_field (name, *argp, 0, t, 0);
2521
    }
2522
 
2523
  if (!v)
2524
    error ("Structure has no component named %s.", name);
2525
  return v;
2526
}
2527
 
2528
/* Search through the methods of an object (and its bases)
2529
 * to find a specified method. Return the pointer to the
2530
 * fn_field list of overloaded instances.
2531
 * Helper function for value_find_oload_list.
2532
 * ARGP is a pointer to a pointer to a value (the object)
2533
 * METHOD is a string containing the method name
2534
 * OFFSET is the offset within the value
2535
 * TYPE is the assumed type of the object
2536
 * NUM_FNS is the number of overloaded instances
2537
 * BASETYPE is set to the actual type of the subobject where the method is found
2538
 * BOFFSET is the offset of the base subobject where the method is found */
2539
 
2540
static struct fn_field *
2541
find_method_list (struct value **argp, char *method, int offset,
2542
                  struct type *type, int *num_fns,
2543
                  struct type **basetype, int *boffset)
2544
{
2545
  int i;
2546
  struct fn_field *f;
2547
  CHECK_TYPEDEF (type);
2548
 
2549
  *num_fns = 0;
2550
 
2551
  /* First check in object itself */
2552
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2553
    {
2554
      /* pai: FIXME What about operators and type conversions? */
2555
      char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2556
      if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2557
        {
2558
          /* Resolve any stub methods.  */
2559
          int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2560
          struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2561
          int j;
2562
 
2563
          *num_fns = len;
2564
          *basetype = type;
2565
          *boffset = offset;
2566
 
2567
          for (j = 0; j < len; j++)
2568
            {
2569
              if (TYPE_FN_FIELD_STUB (f, j))
2570
                check_stub_method (type, i, j);
2571
            }
2572
 
2573
          return f;
2574
        }
2575
    }
2576
 
2577
  /* Not found in object, check in base subobjects */
2578
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2579
    {
2580
      int base_offset;
2581
      if (BASETYPE_VIA_VIRTUAL (type, i))
2582
        {
2583
          if (TYPE_HAS_VTABLE (type))
2584
            {
2585
              /* HP aCC compiled type, search for virtual base offset
2586
               * according to HP/Taligent runtime spec.  */
2587
              int skip;
2588
              find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
2589
                                    VALUE_CONTENTS_ALL (*argp),
2590
                                    offset + VALUE_EMBEDDED_OFFSET (*argp),
2591
                                    &base_offset, &skip);
2592
              if (skip >= 0)
2593
                error ("Virtual base class offset not found in vtable");
2594
            }
2595
          else
2596
            {
2597
              /* probably g++ runtime model */
2598
              base_offset = VALUE_OFFSET (*argp) + offset;
2599
              base_offset =
2600
                baseclass_offset (type, i,
2601
                                  VALUE_CONTENTS (*argp) + base_offset,
2602
                                  VALUE_ADDRESS (*argp) + base_offset);
2603
              if (base_offset == -1)
2604
                error ("virtual baseclass botch");
2605
            }
2606
        }
2607
      else
2608
        /* non-virtual base, simply use bit position from debug info */
2609
        {
2610
          base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2611
        }
2612
      f = find_method_list (argp, method, base_offset + offset,
2613
                            TYPE_BASECLASS (type, i), num_fns, basetype,
2614
                            boffset);
2615
      if (f)
2616
        return f;
2617
    }
2618
  return NULL;
2619
}
2620
 
2621
/* Return the list of overloaded methods of a specified name.
2622
 * ARGP is a pointer to a pointer to a value (the object)
2623
 * METHOD is the method name
2624
 * OFFSET is the offset within the value contents
2625
 * NUM_FNS is the number of overloaded instances
2626
 * BASETYPE is set to the type of the base subobject that defines the method
2627
 * BOFFSET is the offset of the base subobject which defines the method */
2628
 
2629
struct fn_field *
2630
value_find_oload_method_list (struct value **argp, char *method, int offset,
2631
                              int *num_fns, struct type **basetype,
2632
                              int *boffset)
2633
{
2634
  struct type *t;
2635
 
2636
  t = check_typedef (VALUE_TYPE (*argp));
2637
 
2638
  /* code snarfed from value_struct_elt */
2639
  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2640
    {
2641
      *argp = value_ind (*argp);
2642
      /* Don't coerce fn pointer to fn and then back again!  */
2643
      if (TYPE_CODE (VALUE_TYPE (*argp)) != TYPE_CODE_FUNC)
2644
        COERCE_ARRAY (*argp);
2645
      t = check_typedef (VALUE_TYPE (*argp));
2646
    }
2647
 
2648
  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
2649
    error ("Not implemented: member type in value_find_oload_lis");
2650
 
2651
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2652
      && TYPE_CODE (t) != TYPE_CODE_UNION)
2653
    error ("Attempt to extract a component of a value that is not a struct or union");
2654
 
2655
  return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
2656
}
2657
 
2658
/* Given an array of argument types (ARGTYPES) (which includes an
2659
   entry for "this" in the case of C++ methods), the number of
2660
   arguments NARGS, the NAME of a function whether it's a method or
2661
   not (METHOD), and the degree of laxness (LAX) in conforming to
2662
   overload resolution rules in ANSI C++, find the best function that
2663
   matches on the argument types according to the overload resolution
2664
   rules.
2665
 
2666
   In the case of class methods, the parameter OBJ is an object value
2667
   in which to search for overloaded methods.
2668
 
2669
   In the case of non-method functions, the parameter FSYM is a symbol
2670
   corresponding to one of the overloaded functions.
2671
 
2672
   Return value is an integer: 0 -> good match, 10 -> debugger applied
2673
   non-standard coercions, 100 -> incompatible.
2674
 
2675
   If a method is being searched for, VALP will hold the value.
2676
   If a non-method is being searched for, SYMP will hold the symbol for it.
2677
 
2678
   If a method is being searched for, and it is a static method,
2679
   then STATICP will point to a non-zero value.
2680
 
2681
   Note: This function does *not* check the value of
2682
   overload_resolution.  Caller must check it to see whether overload
2683
   resolution is permitted.
2684
 */
2685
 
2686
int
2687
find_overload_match (struct type **arg_types, int nargs, char *name, int method,
2688
                     int lax, struct value **objp, struct symbol *fsym,
2689
                     struct value **valp, struct symbol **symp, int *staticp)
2690
{
2691
  int nparms;
2692
  struct type **parm_types;
2693
  int champ_nparms = 0;
2694
  struct value *obj = (objp ? *objp : NULL);
2695
 
2696
  short oload_champ = -1;       /* Index of best overloaded function */
2697
  short oload_ambiguous = 0;     /* Current ambiguity state for overload resolution */
2698
  /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs */
2699
  short oload_ambig_champ = -1; /* 2nd contender for best match */
2700
  short oload_non_standard = 0;  /* did we have to use non-standard conversions? */
2701
  short oload_incompatible = 0;  /* are args supplied incompatible with any function? */
2702
 
2703
  struct badness_vector *bv;    /* A measure of how good an overloaded instance is */
2704
  struct badness_vector *oload_champ_bv = NULL;         /* The measure for the current best match */
2705
 
2706
  struct value *temp = obj;
2707
  struct fn_field *fns_ptr = NULL;      /* For methods, the list of overloaded methods */
2708
  struct symbol **oload_syms = NULL;    /* For non-methods, the list of overloaded function symbols */
2709
  int num_fns = 0;               /* Number of overloaded instances being considered */
2710
  struct type *basetype = NULL;
2711
  int boffset;
2712
  register int jj;
2713
  register int ix;
2714
  int static_offset;
2715
  struct cleanup *cleanups = NULL;
2716
 
2717
  char *obj_type_name = NULL;
2718
  char *func_name = NULL;
2719
 
2720
  /* Get the list of overloaded methods or functions */
2721
  if (method)
2722
    {
2723
      obj_type_name = TYPE_NAME (VALUE_TYPE (obj));
2724
      /* Hack: evaluate_subexp_standard often passes in a pointer
2725
         value rather than the object itself, so try again */
2726
      if ((!obj_type_name || !*obj_type_name) &&
2727
          (TYPE_CODE (VALUE_TYPE (obj)) == TYPE_CODE_PTR))
2728
        obj_type_name = TYPE_NAME (TYPE_TARGET_TYPE (VALUE_TYPE (obj)));
2729
 
2730
      fns_ptr = value_find_oload_method_list (&temp, name, 0,
2731
                                              &num_fns,
2732
                                              &basetype, &boffset);
2733
      if (!fns_ptr || !num_fns)
2734
        error ("Couldn't find method %s%s%s",
2735
               obj_type_name,
2736
               (obj_type_name && *obj_type_name) ? "::" : "",
2737
               name);
2738
      /* If we are dealing with stub method types, they should have
2739
         been resolved by find_method_list via value_find_oload_method_list
2740
         above.  */
2741
      gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2742
    }
2743
  else
2744
    {
2745
      int i = -1;
2746
      func_name = cplus_demangle (SYMBOL_NAME (fsym), DMGL_NO_OPTS);
2747
 
2748
      /* If the name is NULL this must be a C-style function.
2749
         Just return the same symbol. */
2750
      if (!func_name)
2751
        {
2752
          *symp = fsym;
2753
          return 0;
2754
        }
2755
 
2756
      oload_syms = make_symbol_overload_list (fsym);
2757
      cleanups = make_cleanup (xfree, oload_syms);
2758
      while (oload_syms[++i])
2759
        num_fns++;
2760
      if (!num_fns)
2761
        error ("Couldn't find function %s", func_name);
2762
    }
2763
 
2764
  oload_champ_bv = NULL;
2765
 
2766
  /* Consider each candidate in turn */
2767
  for (ix = 0; ix < num_fns; ix++)
2768
    {
2769
      static_offset = 0;
2770
      if (method)
2771
        {
2772
          if (TYPE_FN_FIELD_STATIC_P (fns_ptr, ix))
2773
            static_offset = 1;
2774
          nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2775
        }
2776
      else
2777
        {
2778
          /* If it's not a method, this is the proper place */
2779
          nparms=TYPE_NFIELDS(SYMBOL_TYPE(oload_syms[ix]));
2780
        }
2781
 
2782
      /* Prepare array of parameter types */
2783
      parm_types = (struct type **) xmalloc (nparms * (sizeof (struct type *)));
2784
      for (jj = 0; jj < nparms; jj++)
2785
        parm_types[jj] = (method
2786
                          ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2787
                          : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]), jj));
2788
 
2789
      /* Compare parameter types to supplied argument types.  Skip THIS for
2790
         static methods.  */
2791
      bv = rank_function (parm_types, nparms, arg_types + static_offset,
2792
                          nargs - static_offset);
2793
 
2794
      if (!oload_champ_bv)
2795
        {
2796
          oload_champ_bv = bv;
2797
          oload_champ = 0;
2798
          champ_nparms = nparms;
2799
        }
2800
      else
2801
        /* See whether current candidate is better or worse than previous best */
2802
        switch (compare_badness (bv, oload_champ_bv))
2803
          {
2804
          case 0:
2805
            oload_ambiguous = 1;        /* top two contenders are equally good */
2806
            oload_ambig_champ = ix;
2807
            break;
2808
          case 1:
2809
            oload_ambiguous = 2;        /* incomparable top contenders */
2810
            oload_ambig_champ = ix;
2811
            break;
2812
          case 2:
2813
            oload_champ_bv = bv;        /* new champion, record details */
2814
            oload_ambiguous = 0;
2815
            oload_champ = ix;
2816
            oload_ambig_champ = -1;
2817
            champ_nparms = nparms;
2818
            break;
2819
          case 3:
2820
          default:
2821
            break;
2822
          }
2823
      xfree (parm_types);
2824
      if (overload_debug)
2825
        {
2826
          if (method)
2827
            fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
2828
          else
2829
            fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
2830
          for (jj = 0; jj < nargs - static_offset; jj++)
2831
            fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
2832
          fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
2833
        }
2834
    }                           /* end loop over all candidates */
2835
  /* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
2836
     if they have the exact same goodness. This is because there is no
2837
     way to differentiate based on return type, which we need to in
2838
     cases like overloads of .begin() <It's both const and non-const> */
2839
#if 0
2840
  if (oload_ambiguous)
2841
    {
2842
      if (method)
2843
        error ("Cannot resolve overloaded method %s%s%s to unique instance; disambiguate by specifying function signature",
2844
               obj_type_name,
2845
               (obj_type_name && *obj_type_name) ? "::" : "",
2846
               name);
2847
      else
2848
        error ("Cannot resolve overloaded function %s to unique instance; disambiguate by specifying function signature",
2849
               func_name);
2850
    }
2851
#endif
2852
 
2853
  /* Check how bad the best match is.  */
2854
  static_offset = 0;
2855
  if (method && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2856
    static_offset = 1;
2857
  for (ix = 1; ix <= nargs - static_offset; ix++)
2858
    {
2859
      if (oload_champ_bv->rank[ix] >= 100)
2860
        oload_incompatible = 1; /* truly mismatched types */
2861
 
2862
      else if (oload_champ_bv->rank[ix] >= 10)
2863
        oload_non_standard = 1; /* non-standard type conversions needed */
2864
    }
2865
  if (oload_incompatible)
2866
    {
2867
      if (method)
2868
        error ("Cannot resolve method %s%s%s to any overloaded instance",
2869
               obj_type_name,
2870
               (obj_type_name && *obj_type_name) ? "::" : "",
2871
               name);
2872
      else
2873
        error ("Cannot resolve function %s to any overloaded instance",
2874
               func_name);
2875
    }
2876
  else if (oload_non_standard)
2877
    {
2878
      if (method)
2879
        warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
2880
                 obj_type_name,
2881
                 (obj_type_name && *obj_type_name) ? "::" : "",
2882
                 name);
2883
      else
2884
        warning ("Using non-standard conversion to match function %s to supplied arguments",
2885
                 func_name);
2886
    }
2887
 
2888
  if (method)
2889
    {
2890
      if (staticp && TYPE_FN_FIELD_STATIC_P (fns_ptr, oload_champ))
2891
        *staticp = 1;
2892
      else if (staticp)
2893
        *staticp = 0;
2894
      if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, oload_champ))
2895
        *valp = value_virtual_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2896
      else
2897
        *valp = value_fn_field (&temp, fns_ptr, oload_champ, basetype, boffset);
2898
    }
2899
  else
2900
    {
2901
      *symp = oload_syms[oload_champ];
2902
      xfree (func_name);
2903
    }
2904
 
2905
  if (objp)
2906
    {
2907
      if (TYPE_CODE (VALUE_TYPE (temp)) != TYPE_CODE_PTR
2908
          && TYPE_CODE (VALUE_TYPE (*objp)) == TYPE_CODE_PTR)
2909
        {
2910
          temp = value_addr (temp);
2911
        }
2912
      *objp = temp;
2913
    }
2914
  if (cleanups != NULL)
2915
    do_cleanups (cleanups);
2916
 
2917
  return oload_incompatible ? 100 : (oload_non_standard ? 10 : 0);
2918
}
2919
 
2920
/* C++: return 1 is NAME is a legitimate name for the destructor
2921
   of type TYPE.  If TYPE does not have a destructor, or
2922
   if NAME is inappropriate for TYPE, an error is signaled.  */
2923
int
2924
destructor_name_p (const char *name, const struct type *type)
2925
{
2926
  /* destructors are a special case.  */
2927
 
2928
  if (name[0] == '~')
2929
    {
2930
      char *dname = type_name_no_tag (type);
2931
      char *cp = strchr (dname, '<');
2932
      unsigned int len;
2933
 
2934
      /* Do not compare the template part for template classes.  */
2935
      if (cp == NULL)
2936
        len = strlen (dname);
2937
      else
2938
        len = cp - dname;
2939
      if (strlen (name + 1) != len || !STREQN (dname, name + 1, len))
2940
        error ("name of destructor must equal name of class");
2941
      else
2942
        return 1;
2943
    }
2944
  return 0;
2945
}
2946
 
2947
/* Helper function for check_field: Given TYPE, a structure/union,
2948
   return 1 if the component named NAME from the ultimate
2949
   target structure/union is defined, otherwise, return 0. */
2950
 
2951
static int
2952
check_field_in (register struct type *type, const char *name)
2953
{
2954
  register int i;
2955
 
2956
  for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2957
    {
2958
      char *t_field_name = TYPE_FIELD_NAME (type, i);
2959
      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2960
        return 1;
2961
    }
2962
 
2963
  /* C++: If it was not found as a data field, then try to
2964
     return it as a pointer to a method.  */
2965
 
2966
  /* Destructors are a special case.  */
2967
  if (destructor_name_p (name, type))
2968
    {
2969
      int m_index, f_index;
2970
 
2971
      return get_destructor_fn_field (type, &m_index, &f_index);
2972
    }
2973
 
2974
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2975
    {
2976
      if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2977
        return 1;
2978
    }
2979
 
2980
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2981
    if (check_field_in (TYPE_BASECLASS (type, i), name))
2982
      return 1;
2983
 
2984
  return 0;
2985
}
2986
 
2987
 
2988
/* C++: Given ARG1, a value of type (pointer to a)* structure/union,
2989
   return 1 if the component named NAME from the ultimate
2990
   target structure/union is defined, otherwise, return 0.  */
2991
 
2992
int
2993
check_field (struct value *arg1, const char *name)
2994
{
2995
  register struct type *t;
2996
 
2997
  COERCE_ARRAY (arg1);
2998
 
2999
  t = VALUE_TYPE (arg1);
3000
 
3001
  /* Follow pointers until we get to a non-pointer.  */
3002
 
3003
  for (;;)
3004
    {
3005
      CHECK_TYPEDEF (t);
3006
      if (TYPE_CODE (t) != TYPE_CODE_PTR && TYPE_CODE (t) != TYPE_CODE_REF)
3007
        break;
3008
      t = TYPE_TARGET_TYPE (t);
3009
    }
3010
 
3011
  if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
3012
    error ("not implemented: member type in check_field");
3013
 
3014
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3015
      && TYPE_CODE (t) != TYPE_CODE_UNION)
3016
    error ("Internal error: `this' is not an aggregate");
3017
 
3018
  return check_field_in (t, name);
3019
}
3020
 
3021
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
3022
   return the address of this member as a "pointer to member"
3023
   type.  If INTYPE is non-null, then it will be the type
3024
   of the member we are looking for.  This will help us resolve
3025
   "pointers to member functions".  This function is used
3026
   to resolve user expressions of the form "DOMAIN::NAME".  */
3027
 
3028
struct value *
3029
value_struct_elt_for_reference (struct type *domain, int offset,
3030
                                struct type *curtype, char *name,
3031
                                struct type *intype)
3032
{
3033
  register struct type *t = curtype;
3034
  register int i;
3035
  struct value *v;
3036
 
3037
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3038
      && TYPE_CODE (t) != TYPE_CODE_UNION)
3039
    error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
3040
 
3041
  for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3042
    {
3043
      char *t_field_name = TYPE_FIELD_NAME (t, i);
3044
 
3045
      if (t_field_name && STREQ (t_field_name, name))
3046
        {
3047
          if (TYPE_FIELD_STATIC (t, i))
3048
            {
3049
              v = value_static_field (t, i);
3050
              if (v == NULL)
3051
                error ("static field %s has been optimized out",
3052
                       name);
3053
              return v;
3054
            }
3055
          if (TYPE_FIELD_PACKED (t, i))
3056
            error ("pointers to bitfield members not allowed");
3057
 
3058
          return value_from_longest
3059
            (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
3060
                                                        domain)),
3061
             offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3062
        }
3063
    }
3064
 
3065
  /* C++: If it was not found as a data field, then try to
3066
     return it as a pointer to a method.  */
3067
 
3068
  /* Destructors are a special case.  */
3069
  if (destructor_name_p (name, t))
3070
    {
3071
      error ("member pointers to destructors not implemented yet");
3072
    }
3073
 
3074
  /* Perform all necessary dereferencing.  */
3075
  while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3076
    intype = TYPE_TARGET_TYPE (intype);
3077
 
3078
  for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3079
    {
3080
      char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3081
      char dem_opname[64];
3082
 
3083
      if (strncmp (t_field_name, "__", 2) == 0 ||
3084
          strncmp (t_field_name, "op", 2) == 0 ||
3085
          strncmp (t_field_name, "type", 4) == 0)
3086
        {
3087
          if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
3088
            t_field_name = dem_opname;
3089
          else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
3090
            t_field_name = dem_opname;
3091
        }
3092
      if (t_field_name && STREQ (t_field_name, name))
3093
        {
3094
          int j = TYPE_FN_FIELDLIST_LENGTH (t, i);
3095
          struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3096
 
3097
          if (intype == 0 && j > 1)
3098
            error ("non-unique member `%s' requires type instantiation", name);
3099
          if (intype)
3100
            {
3101
              while (j--)
3102
                if (TYPE_FN_FIELD_TYPE (f, j) == intype)
3103
                  break;
3104
              if (j < 0)
3105
                error ("no member function matches that type instantiation");
3106
            }
3107
          else
3108
            j = 0;
3109
 
3110
          if (TYPE_FN_FIELD_STUB (f, j))
3111
            check_stub_method (t, i, j);
3112
          if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3113
            {
3114
              return value_from_longest
3115
                (lookup_reference_type
3116
                 (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3117
                                      domain)),
3118
                 (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
3119
            }
3120
          else
3121
            {
3122
              struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3123
                                                0, VAR_NAMESPACE, 0, NULL);
3124
              if (s == NULL)
3125
                {
3126
                  v = 0;
3127
                }
3128
              else
3129
                {
3130
                  v = read_var_value (s, 0);
3131
#if 0
3132
                  VALUE_TYPE (v) = lookup_reference_type
3133
                    (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
3134
                                         domain));
3135
#endif
3136
                }
3137
              return v;
3138
            }
3139
        }
3140
    }
3141
  for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3142
    {
3143
      struct value *v;
3144
      int base_offset;
3145
 
3146
      if (BASETYPE_VIA_VIRTUAL (t, i))
3147
        base_offset = 0;
3148
      else
3149
        base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3150
      v = value_struct_elt_for_reference (domain,
3151
                                          offset + base_offset,
3152
                                          TYPE_BASECLASS (t, i),
3153
                                          name,
3154
                                          intype);
3155
      if (v)
3156
        return v;
3157
    }
3158
  return 0;
3159
}
3160
 
3161
 
3162
/* Given a pointer value V, find the real (RTTI) type
3163
   of the object it points to.
3164
   Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3165
   and refer to the values computed for the object pointed to. */
3166
 
3167
struct type *
3168
value_rtti_target_type (struct value *v, int *full, int *top, int *using_enc)
3169
{
3170
  struct value *target;
3171
 
3172
  target = value_ind (v);
3173
 
3174
  return value_rtti_type (target, full, top, using_enc);
3175
}
3176
 
3177
/* Given a value pointed to by ARGP, check its real run-time type, and
3178
   if that is different from the enclosing type, create a new value
3179
   using the real run-time type as the enclosing type (and of the same
3180
   type as ARGP) and return it, with the embedded offset adjusted to
3181
   be the correct offset to the enclosed object
3182
   RTYPE is the type, and XFULL, XTOP, and XUSING_ENC are the other
3183
   parameters, computed by value_rtti_type(). If these are available,
3184
   they can be supplied and a second call to value_rtti_type() is avoided.
3185
   (Pass RTYPE == NULL if they're not available */
3186
 
3187
struct value *
3188
value_full_object (struct value *argp, struct type *rtype, int xfull, int xtop,
3189
                   int xusing_enc)
3190
{
3191
  struct type *real_type;
3192
  int full = 0;
3193
  int top = -1;
3194
  int using_enc = 0;
3195
  struct value *new_val;
3196
 
3197
  if (rtype)
3198
    {
3199
      real_type = rtype;
3200
      full = xfull;
3201
      top = xtop;
3202
      using_enc = xusing_enc;
3203
    }
3204
  else
3205
    real_type = value_rtti_type (argp, &full, &top, &using_enc);
3206
 
3207
  /* If no RTTI data, or if object is already complete, do nothing */
3208
  if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
3209
    return argp;
3210
 
3211
  /* If we have the full object, but for some reason the enclosing
3212
     type is wrong, set it *//* pai: FIXME -- sounds iffy */
3213
  if (full)
3214
    {
3215
      argp = value_change_enclosing_type (argp, real_type);
3216
      return argp;
3217
    }
3218
 
3219
  /* Check if object is in memory */
3220
  if (VALUE_LVAL (argp) != lval_memory)
3221
    {
3222
      warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
3223
 
3224
      return argp;
3225
    }
3226
 
3227
  /* All other cases -- retrieve the complete object */
3228
  /* Go back by the computed top_offset from the beginning of the object,
3229
     adjusting for the embedded offset of argp if that's what value_rtti_type
3230
     used for its computation. */
3231
  new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
3232
                           (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)),
3233
                           VALUE_BFD_SECTION (argp));
3234
  VALUE_TYPE (new_val) = VALUE_TYPE (argp);
3235
  VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
3236
  return new_val;
3237
}
3238
 
3239
 
3240
 
3241
 
3242
/* C++: return the value of the class instance variable, if one exists.
3243
   Flag COMPLAIN signals an error if the request is made in an
3244
   inappropriate context.  */
3245
 
3246
struct value *
3247
value_of_this (int complain)
3248
{
3249
  struct symbol *func, *sym;
3250
  struct block *b;
3251
  int i;
3252
  static const char funny_this[] = "this";
3253
  struct value *this;
3254
 
3255
  if (selected_frame == 0)
3256
    {
3257
      if (complain)
3258
        error ("no frame selected");
3259
      else
3260
        return 0;
3261
    }
3262
 
3263
  func = get_frame_function (selected_frame);
3264
  if (!func)
3265
    {
3266
      if (complain)
3267
        error ("no `this' in nameless context");
3268
      else
3269
        return 0;
3270
    }
3271
 
3272
  b = SYMBOL_BLOCK_VALUE (func);
3273
  i = BLOCK_NSYMS (b);
3274
  if (i <= 0)
3275
    {
3276
      if (complain)
3277
        error ("no args, no `this'");
3278
      else
3279
        return 0;
3280
    }
3281
 
3282
  /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3283
     symbol instead of the LOC_ARG one (if both exist).  */
3284
  sym = lookup_block_symbol (b, funny_this, NULL, VAR_NAMESPACE);
3285
  if (sym == NULL)
3286
    {
3287
      if (complain)
3288
        error ("current stack frame not in method");
3289
      else
3290
        return NULL;
3291
    }
3292
 
3293
  this = read_var_value (sym, selected_frame);
3294
  if (this == 0 && complain)
3295
    error ("`this' argument at unknown address");
3296
  return this;
3297
}
3298
 
3299
/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH elements
3300
   long, starting at LOWBOUND.  The result has the same lower bound as
3301
   the original ARRAY.  */
3302
 
3303
struct value *
3304
value_slice (struct value *array, int lowbound, int length)
3305
{
3306
  struct type *slice_range_type, *slice_type, *range_type;
3307
  LONGEST lowerbound, upperbound, offset;
3308
  struct value *slice;
3309
  struct type *array_type;
3310
  array_type = check_typedef (VALUE_TYPE (array));
3311
  COERCE_VARYING_ARRAY (array, array_type);
3312
  if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3313
      && TYPE_CODE (array_type) != TYPE_CODE_STRING
3314
      && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3315
    error ("cannot take slice of non-array");
3316
  range_type = TYPE_INDEX_TYPE (array_type);
3317
  if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3318
    error ("slice from bad array or bitstring");
3319
  if (lowbound < lowerbound || length < 0
3320
      || lowbound + length - 1 > upperbound)
3321
    /* OBSOLETE Chill allows zero-length strings but not arrays. */
3322
    /* OBSOLETE || (current_language->la_language == language_chill */
3323
    /* OBSOLETE && length == 0 && TYPE_CODE (array_type) == TYPE_CODE_ARRAY)) */
3324
    error ("slice out of range");
3325
  /* FIXME-type-allocation: need a way to free this type when we are
3326
     done with it.  */
3327
  slice_range_type = create_range_type ((struct type *) NULL,
3328
                                        TYPE_TARGET_TYPE (range_type),
3329
                                        lowbound, lowbound + length - 1);
3330
  if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3331
    {
3332
      int i;
3333
      slice_type = create_set_type ((struct type *) NULL, slice_range_type);
3334
      TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3335
      slice = value_zero (slice_type, not_lval);
3336
      for (i = 0; i < length; i++)
3337
        {
3338
          int element = value_bit_index (array_type,
3339
                                         VALUE_CONTENTS (array),
3340
                                         lowbound + i);
3341
          if (element < 0)
3342
            error ("internal error accessing bitstring");
3343
          else if (element > 0)
3344
            {
3345
              int j = i % TARGET_CHAR_BIT;
3346
              if (BITS_BIG_ENDIAN)
3347
                j = TARGET_CHAR_BIT - 1 - j;
3348
              VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3349
            }
3350
        }
3351
      /* We should set the address, bitssize, and bitspos, so the clice
3352
         can be used on the LHS, but that may require extensions to
3353
         value_assign.  For now, just leave as a non_lval.  FIXME.  */
3354
    }
3355
  else
3356
    {
3357
      struct type *element_type = TYPE_TARGET_TYPE (array_type);
3358
      offset
3359
        = (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3360
      slice_type = create_array_type ((struct type *) NULL, element_type,
3361
                                      slice_range_type);
3362
      TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3363
      slice = allocate_value (slice_type);
3364
      if (VALUE_LAZY (array))
3365
        VALUE_LAZY (slice) = 1;
3366
      else
3367
        memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
3368
                TYPE_LENGTH (slice_type));
3369
      if (VALUE_LVAL (array) == lval_internalvar)
3370
        VALUE_LVAL (slice) = lval_internalvar_component;
3371
      else
3372
        VALUE_LVAL (slice) = VALUE_LVAL (array);
3373
      VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
3374
      VALUE_OFFSET (slice) = VALUE_OFFSET (array) + offset;
3375
    }
3376
  return slice;
3377
}
3378
 
3379
/* Assuming OBSOLETE chill_varying_type (VARRAY) is true, return an
3380
   equivalent value as a fixed-length array. */
3381
 
3382
struct value *
3383
varying_to_slice (struct value *varray)
3384
{
3385
  struct type *vtype = check_typedef (VALUE_TYPE (varray));
3386
  LONGEST length = unpack_long (TYPE_FIELD_TYPE (vtype, 0),
3387
                                VALUE_CONTENTS (varray)
3388
                                + TYPE_FIELD_BITPOS (vtype, 0) / 8);
3389
  return value_slice (value_primitive_field (varray, 0, 1, vtype), 0, length);
3390
}
3391
 
3392
/* Create a value for a FORTRAN complex number.  Currently most of
3393
   the time values are coerced to COMPLEX*16 (i.e. a complex number
3394
   composed of 2 doubles.  This really should be a smarter routine
3395
   that figures out precision inteligently as opposed to assuming
3396
   doubles. FIXME: fmb */
3397
 
3398
struct value *
3399
value_literal_complex (struct value *arg1, struct value *arg2, struct type *type)
3400
{
3401
  struct value *val;
3402
  struct type *real_type = TYPE_TARGET_TYPE (type);
3403
 
3404
  val = allocate_value (type);
3405
  arg1 = value_cast (real_type, arg1);
3406
  arg2 = value_cast (real_type, arg2);
3407
 
3408
  memcpy (VALUE_CONTENTS_RAW (val),
3409
          VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
3410
  memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
3411
          VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
3412
  return val;
3413
}
3414
 
3415
/* Cast a value into the appropriate complex data type. */
3416
 
3417
static struct value *
3418
cast_into_complex (struct type *type, struct value *val)
3419
{
3420
  struct type *real_type = TYPE_TARGET_TYPE (type);
3421
  if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_COMPLEX)
3422
    {
3423
      struct type *val_real_type = TYPE_TARGET_TYPE (VALUE_TYPE (val));
3424
      struct value *re_val = allocate_value (val_real_type);
3425
      struct value *im_val = allocate_value (val_real_type);
3426
 
3427
      memcpy (VALUE_CONTENTS_RAW (re_val),
3428
              VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
3429
      memcpy (VALUE_CONTENTS_RAW (im_val),
3430
              VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
3431
              TYPE_LENGTH (val_real_type));
3432
 
3433
      return value_literal_complex (re_val, im_val, type);
3434
    }
3435
  else if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT
3436
           || TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT)
3437
    return value_literal_complex (val, value_zero (real_type, not_lval), type);
3438
  else
3439
    error ("cannot cast non-number to complex");
3440
}
3441
 
3442
void
3443
_initialize_valops (void)
3444
{
3445
#if 0
3446
  add_show_from_set
3447
    (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
3448
                  "Set automatic abandonment of expressions upon failure.",
3449
                  &setlist),
3450
     &showlist);
3451
#endif
3452
 
3453
  add_show_from_set
3454
    (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
3455
                  "Set overload resolution in evaluating C++ functions.",
3456
                  &setlist),
3457
     &showlist);
3458
  overload_resolution = 1;
3459
 
3460
  add_show_from_set (
3461
  add_set_cmd ("unwindonsignal", no_class, var_boolean,
3462
               (char *) &unwind_on_signal_p,
3463
"Set unwinding of stack if a signal is received while in a call dummy.\n\
3464
The unwindonsignal lets the user determine what gdb should do if a signal\n\
3465
is received while in a function called from gdb (call dummy).  If set, gdb\n\
3466
unwinds the stack and restore the context to what as it was before the call.\n\
3467
The default is to stop in the frame where the signal was received.", &setlist),
3468
                     &showlist);
3469
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.