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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [valops.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* Perform non-arithmetic operations on values, for GDB.
2
 
3
   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4
   1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5
   2008, 2009, 2010 Free Software Foundation, Inc.
6
 
7
   This file is part of GDB.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
 
22
#include "defs.h"
23
#include "symtab.h"
24
#include "gdbtypes.h"
25
#include "value.h"
26
#include "frame.h"
27
#include "inferior.h"
28
#include "gdbcore.h"
29
#include "target.h"
30
#include "demangle.h"
31
#include "language.h"
32
#include "gdbcmd.h"
33
#include "regcache.h"
34
#include "cp-abi.h"
35
#include "block.h"
36
#include "infcall.h"
37
#include "dictionary.h"
38
#include "cp-support.h"
39
#include "dfp.h"
40
#include "user-regs.h"
41
 
42
#include <errno.h>
43
#include "gdb_string.h"
44
#include "gdb_assert.h"
45
#include "cp-support.h"
46
#include "observer.h"
47
#include "objfiles.h"
48
#include "symtab.h"
49
 
50
extern int overload_debug;
51
/* Local functions.  */
52
 
53
static int typecmp (int staticp, int varargs, int nargs,
54
                    struct field t1[], struct value *t2[]);
55
 
56
static struct value *search_struct_field (const char *, struct value *,
57
                                          int, struct type *, int);
58
 
59
static struct value *search_struct_method (const char *, struct value **,
60
                                           struct value **,
61
                                           int, int *, struct type *);
62
 
63
static int find_oload_champ_namespace (struct type **, int,
64
                                       const char *, const char *,
65
                                       struct symbol ***,
66
                                       struct badness_vector **,
67
                                       const int no_adl);
68
 
69
static
70
int find_oload_champ_namespace_loop (struct type **, int,
71
                                     const char *, const char *,
72
                                     int, struct symbol ***,
73
                                     struct badness_vector **, int *,
74
                                     const int no_adl);
75
 
76
static int find_oload_champ (struct type **, int, int, int,
77
                             struct fn_field *, struct symbol **,
78
                             struct badness_vector **);
79
 
80
static int oload_method_static (int, struct fn_field *, int);
81
 
82
enum oload_classification { STANDARD, NON_STANDARD, INCOMPATIBLE };
83
 
84
static enum
85
oload_classification classify_oload_match (struct badness_vector *,
86
                                           int, int);
87
 
88
static struct value *value_struct_elt_for_reference (struct type *,
89
                                                     int, struct type *,
90
                                                     char *,
91
                                                     struct type *,
92
                                                     int, enum noside);
93
 
94
static struct value *value_namespace_elt (const struct type *,
95
                                          char *, int , enum noside);
96
 
97
static struct value *value_maybe_namespace_elt (const struct type *,
98
                                                char *, int,
99
                                                enum noside);
100
 
101
static CORE_ADDR allocate_space_in_inferior (int);
102
 
103
static struct value *cast_into_complex (struct type *, struct value *);
104
 
105
static struct fn_field *find_method_list (struct value **, const char *,
106
                                          int, struct type *, int *,
107
                                          struct type **, int *);
108
 
109
void _initialize_valops (void);
110
 
111
#if 0
112
/* Flag for whether we want to abandon failed expression evals by
113
   default.  */
114
 
115
static int auto_abandon = 0;
116
#endif
117
 
118
int overload_resolution = 0;
119
static void
120
show_overload_resolution (struct ui_file *file, int from_tty,
121
                          struct cmd_list_element *c,
122
                          const char *value)
123
{
124
  fprintf_filtered (file, _("\
125
Overload resolution in evaluating C++ functions is %s.\n"),
126
                    value);
127
}
128
 
129
/* Find the address of function name NAME in the inferior.  If OBJF_P
130
   is non-NULL, *OBJF_P will be set to the OBJFILE where the function
131
   is defined.  */
132
 
133
struct value *
134
find_function_in_inferior (const char *name, struct objfile **objf_p)
135
{
136
  struct symbol *sym;
137
 
138
  sym = lookup_symbol (name, 0, VAR_DOMAIN, 0);
139
  if (sym != NULL)
140
    {
141
      if (SYMBOL_CLASS (sym) != LOC_BLOCK)
142
        {
143
          error (_("\"%s\" exists in this program but is not a function."),
144
                 name);
145
        }
146
 
147
      if (objf_p)
148
        *objf_p = SYMBOL_SYMTAB (sym)->objfile;
149
 
150
      return value_of_variable (sym, NULL);
151
    }
152
  else
153
    {
154
      struct minimal_symbol *msymbol =
155
        lookup_minimal_symbol (name, NULL, NULL);
156
 
157
      if (msymbol != NULL)
158
        {
159
          struct objfile *objfile = msymbol_objfile (msymbol);
160
          struct gdbarch *gdbarch = get_objfile_arch (objfile);
161
 
162
          struct type *type;
163
          CORE_ADDR maddr;
164
          type = lookup_pointer_type (builtin_type (gdbarch)->builtin_char);
165
          type = lookup_function_type (type);
166
          type = lookup_pointer_type (type);
167
          maddr = SYMBOL_VALUE_ADDRESS (msymbol);
168
 
169
          if (objf_p)
170
            *objf_p = objfile;
171
 
172
          return value_from_pointer (type, maddr);
173
        }
174
      else
175
        {
176
          if (!target_has_execution)
177
            error (_("evaluation of this expression requires the target program to be active"));
178
          else
179
            error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
180
        }
181
    }
182
}
183
 
184
/* Allocate NBYTES of space in the inferior using the inferior's
185
   malloc and return a value that is a pointer to the allocated
186
   space.  */
187
 
188
struct value *
189
value_allocate_space_in_inferior (int len)
190
{
191
  struct objfile *objf;
192
  struct value *val = find_function_in_inferior ("malloc", &objf);
193
  struct gdbarch *gdbarch = get_objfile_arch (objf);
194
  struct value *blocklen;
195
 
196
  blocklen = value_from_longest (builtin_type (gdbarch)->builtin_int, len);
197
  val = call_function_by_hand (val, 1, &blocklen);
198
  if (value_logical_not (val))
199
    {
200
      if (!target_has_execution)
201
        error (_("No memory available to program now: you need to start the target first"));
202
      else
203
        error (_("No memory available to program: call to malloc failed"));
204
    }
205
  return val;
206
}
207
 
208
static CORE_ADDR
209
allocate_space_in_inferior (int len)
210
{
211
  return value_as_long (value_allocate_space_in_inferior (len));
212
}
213
 
214
/* Cast struct value VAL to type TYPE and return as a value.
215
   Both type and val must be of TYPE_CODE_STRUCT or TYPE_CODE_UNION
216
   for this to work.  Typedef to one of the codes is permitted.
217
   Returns NULL if the cast is neither an upcast nor a downcast.  */
218
 
219
static struct value *
220
value_cast_structs (struct type *type, struct value *v2)
221
{
222
  struct type *t1;
223
  struct type *t2;
224
  struct value *v;
225
 
226
  gdb_assert (type != NULL && v2 != NULL);
227
 
228
  t1 = check_typedef (type);
229
  t2 = check_typedef (value_type (v2));
230
 
231
  /* Check preconditions.  */
232
  gdb_assert ((TYPE_CODE (t1) == TYPE_CODE_STRUCT
233
               || TYPE_CODE (t1) == TYPE_CODE_UNION)
234
              && !!"Precondition is that type is of STRUCT or UNION kind.");
235
  gdb_assert ((TYPE_CODE (t2) == TYPE_CODE_STRUCT
236
               || TYPE_CODE (t2) == TYPE_CODE_UNION)
237
              && !!"Precondition is that value is of STRUCT or UNION kind");
238
 
239
  if (TYPE_NAME (t1) != NULL
240
      && TYPE_NAME (t2) != NULL
241
      && !strcmp (TYPE_NAME (t1), TYPE_NAME (t2)))
242
    return NULL;
243
 
244
  /* Upcasting: 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 pointer rather than just change its type.  */
247
  if (TYPE_NAME (t1) != NULL)
248
    {
249
      v = search_struct_field (type_name_no_tag (t1),
250
                               v2, 0, t2, 1);
251
      if (v)
252
        return v;
253
    }
254
 
255
  /* Downcasting: look in the type of the target to see if it contains the
256
     type of the source as a superclass.  If so, we'll need to
257
     offset the pointer rather than just change its type.  */
258
  if (TYPE_NAME (t2) != NULL)
259
    {
260
      /* Try downcasting using the run-time type of the value.  */
261
      int full, top, using_enc;
262
      struct type *real_type;
263
 
264
      real_type = value_rtti_type (v2, &full, &top, &using_enc);
265
      if (real_type)
266
        {
267
          v = value_full_object (v2, real_type, full, top, using_enc);
268
          v = value_at_lazy (real_type, value_address (v));
269
 
270
          /* We might be trying to cast to the outermost enclosing
271
             type, in which case search_struct_field won't work.  */
272
          if (TYPE_NAME (real_type) != NULL
273
              && !strcmp (TYPE_NAME (real_type), TYPE_NAME (t1)))
274
            return v;
275
 
276
          v = search_struct_field (type_name_no_tag (t2), v, 0, real_type, 1);
277
          if (v)
278
            return v;
279
        }
280
 
281
      /* Try downcasting using information from the destination type
282
         T2.  This wouldn't work properly for classes with virtual
283
         bases, but those were handled above.  */
284
      v = search_struct_field (type_name_no_tag (t2),
285
                               value_zero (t1, not_lval), 0, t1, 1);
286
      if (v)
287
        {
288
          /* Downcasting is possible (t1 is superclass of v2).  */
289
          CORE_ADDR addr2 = value_address (v2);
290
 
291
          addr2 -= value_address (v) + value_embedded_offset (v);
292
          return value_at (type, addr2);
293
        }
294
    }
295
 
296
  return NULL;
297
}
298
 
299
/* Cast one pointer or reference type to another.  Both TYPE and
300
   the type of ARG2 should be pointer types, or else both should be
301
   reference types.  Returns the new pointer or reference.  */
302
 
303
struct value *
304
value_cast_pointers (struct type *type, struct value *arg2)
305
{
306
  struct type *type1 = check_typedef (type);
307
  struct type *type2 = check_typedef (value_type (arg2));
308
  struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type1));
309
  struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
310
 
311
  if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
312
      && TYPE_CODE (t2) == TYPE_CODE_STRUCT
313
      && !value_logical_not (arg2))
314
    {
315
      struct value *v2;
316
 
317
      if (TYPE_CODE (type2) == TYPE_CODE_REF)
318
        v2 = coerce_ref (arg2);
319
      else
320
        v2 = value_ind (arg2);
321
      gdb_assert (TYPE_CODE (check_typedef (value_type (v2))) == TYPE_CODE_STRUCT
322
                  && !!"Why did coercion fail?");
323
      v2 = value_cast_structs (t1, v2);
324
      /* At this point we have what we can have, un-dereference if needed.  */
325
      if (v2)
326
        {
327
          struct value *v = value_addr (v2);
328
 
329
          deprecated_set_value_type (v, type);
330
          return v;
331
        }
332
   }
333
 
334
  /* No superclass found, just change the pointer type.  */
335
  arg2 = value_copy (arg2);
336
  deprecated_set_value_type (arg2, type);
337
  arg2 = value_change_enclosing_type (arg2, type);
338
  set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
339
  return arg2;
340
}
341
 
342
/* Cast value ARG2 to type TYPE and return as a value.
343
   More general than a C cast: accepts any two types of the same length,
344
   and if ARG2 is an lvalue it can be cast into anything at all.  */
345
/* In C++, casts may change pointer or object representations.  */
346
 
347
struct value *
348
value_cast (struct type *type, struct value *arg2)
349
{
350
  enum type_code code1;
351
  enum type_code code2;
352
  int scalar;
353
  struct type *type2;
354
 
355
  int convert_to_boolean = 0;
356
 
357
  if (value_type (arg2) == type)
358
    return arg2;
359
 
360
  code1 = TYPE_CODE (check_typedef (type));
361
 
362
  /* Check if we are casting struct reference to struct reference.  */
363
  if (code1 == TYPE_CODE_REF)
364
    {
365
      /* We dereference type; then we recurse and finally
366
         we generate value of the given reference. Nothing wrong with
367
         that.  */
368
      struct type *t1 = check_typedef (type);
369
      struct type *dereftype = check_typedef (TYPE_TARGET_TYPE (t1));
370
      struct value *val =  value_cast (dereftype, arg2);
371
 
372
      return value_ref (val);
373
    }
374
 
375
  code2 = TYPE_CODE (check_typedef (value_type (arg2)));
376
 
377
  if (code2 == TYPE_CODE_REF)
378
    /* We deref the value and then do the cast.  */
379
    return value_cast (type, coerce_ref (arg2));
380
 
381
  CHECK_TYPEDEF (type);
382
  code1 = TYPE_CODE (type);
383
  arg2 = coerce_ref (arg2);
384
  type2 = check_typedef (value_type (arg2));
385
 
386
  /* You can't cast to a reference type.  See value_cast_pointers
387
     instead.  */
388
  gdb_assert (code1 != TYPE_CODE_REF);
389
 
390
  /* A cast to an undetermined-length array_type, such as
391
     (TYPE [])OBJECT, is treated like a cast to (TYPE [N])OBJECT,
392
     where N is sizeof(OBJECT)/sizeof(TYPE).  */
393
  if (code1 == TYPE_CODE_ARRAY)
394
    {
395
      struct type *element_type = TYPE_TARGET_TYPE (type);
396
      unsigned element_length = TYPE_LENGTH (check_typedef (element_type));
397
 
398
      if (element_length > 0 && TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
399
        {
400
          struct type *range_type = TYPE_INDEX_TYPE (type);
401
          int val_length = TYPE_LENGTH (type2);
402
          LONGEST low_bound, high_bound, new_length;
403
 
404
          if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
405
            low_bound = 0, high_bound = 0;
406
          new_length = val_length / element_length;
407
          if (val_length % element_length != 0)
408
            warning (_("array element type size does not divide object size in cast"));
409
          /* FIXME-type-allocation: need a way to free this type when
410
             we are done with it.  */
411
          range_type = create_range_type ((struct type *) NULL,
412
                                          TYPE_TARGET_TYPE (range_type),
413
                                          low_bound,
414
                                          new_length + low_bound - 1);
415
          deprecated_set_value_type (arg2,
416
                                     create_array_type ((struct type *) NULL,
417
                                                        element_type,
418
                                                        range_type));
419
          return arg2;
420
        }
421
    }
422
 
423
  if (current_language->c_style_arrays
424
      && TYPE_CODE (type2) == TYPE_CODE_ARRAY)
425
    arg2 = value_coerce_array (arg2);
426
 
427
  if (TYPE_CODE (type2) == TYPE_CODE_FUNC)
428
    arg2 = value_coerce_function (arg2);
429
 
430
  type2 = check_typedef (value_type (arg2));
431
  code2 = TYPE_CODE (type2);
432
 
433
  if (code1 == TYPE_CODE_COMPLEX)
434
    return cast_into_complex (type, arg2);
435
  if (code1 == TYPE_CODE_BOOL)
436
    {
437
      code1 = TYPE_CODE_INT;
438
      convert_to_boolean = 1;
439
    }
440
  if (code1 == TYPE_CODE_CHAR)
441
    code1 = TYPE_CODE_INT;
442
  if (code2 == TYPE_CODE_BOOL || code2 == TYPE_CODE_CHAR)
443
    code2 = TYPE_CODE_INT;
444
 
445
  scalar = (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_FLT
446
            || code2 == TYPE_CODE_DECFLOAT || code2 == TYPE_CODE_ENUM
447
            || code2 == TYPE_CODE_RANGE);
448
 
449
  if ((code1 == TYPE_CODE_STRUCT || code1 == TYPE_CODE_UNION)
450
      && (code2 == TYPE_CODE_STRUCT || code2 == TYPE_CODE_UNION)
451
      && TYPE_NAME (type) != 0)
452
    {
453
      struct value *v = value_cast_structs (type, arg2);
454
 
455
      if (v)
456
        return v;
457
    }
458
 
459
  if (code1 == TYPE_CODE_FLT && scalar)
460
    return value_from_double (type, value_as_double (arg2));
461
  else if (code1 == TYPE_CODE_DECFLOAT && scalar)
462
    {
463
      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
464
      int dec_len = TYPE_LENGTH (type);
465
      gdb_byte dec[16];
466
 
467
      if (code2 == TYPE_CODE_FLT)
468
        decimal_from_floating (arg2, dec, dec_len, byte_order);
469
      else if (code2 == TYPE_CODE_DECFLOAT)
470
        decimal_convert (value_contents (arg2), TYPE_LENGTH (type2),
471
                         byte_order, dec, dec_len, byte_order);
472
      else
473
        /* The only option left is an integral type.  */
474
        decimal_from_integral (arg2, dec, dec_len, byte_order);
475
 
476
      return value_from_decfloat (type, dec);
477
    }
478
  else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
479
            || code1 == TYPE_CODE_RANGE)
480
           && (scalar || code2 == TYPE_CODE_PTR
481
               || code2 == TYPE_CODE_MEMBERPTR))
482
    {
483
      LONGEST longest;
484
 
485
      /* When we cast pointers to integers, we mustn't use
486
         gdbarch_pointer_to_address to find the address the pointer
487
         represents, as value_as_long would.  GDB should evaluate
488
         expressions just as the compiler would --- and the compiler
489
         sees a cast as a simple reinterpretation of the pointer's
490
         bits.  */
491
      if (code2 == TYPE_CODE_PTR)
492
        longest = extract_unsigned_integer
493
                    (value_contents (arg2), TYPE_LENGTH (type2),
494
                     gdbarch_byte_order (get_type_arch (type2)));
495
      else
496
        longest = value_as_long (arg2);
497
      return value_from_longest (type, convert_to_boolean ?
498
                                 (LONGEST) (longest ? 1 : 0) : longest);
499
    }
500
  else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT
501
                                      || code2 == TYPE_CODE_ENUM
502
                                      || code2 == TYPE_CODE_RANGE))
503
    {
504
      /* TYPE_LENGTH (type) is the length of a pointer, but we really
505
         want the length of an address! -- we are really dealing with
506
         addresses (i.e., gdb representations) not pointers (i.e.,
507
         target representations) here.
508
 
509
         This allows things like "print *(int *)0x01000234" to work
510
         without printing a misleading message -- which would
511
         otherwise occur when dealing with a target having two byte
512
         pointers and four byte addresses.  */
513
 
514
      int addr_bit = gdbarch_addr_bit (get_type_arch (type2));
515
      LONGEST longest = value_as_long (arg2);
516
 
517
      if (addr_bit < sizeof (LONGEST) * HOST_CHAR_BIT)
518
        {
519
          if (longest >= ((LONGEST) 1 << addr_bit)
520
              || longest <= -((LONGEST) 1 << addr_bit))
521
            warning (_("value truncated"));
522
        }
523
      return value_from_longest (type, longest);
524
    }
525
  else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
526
           && value_as_long (arg2) == 0)
527
    {
528
      struct value *result = allocate_value (type);
529
 
530
      cplus_make_method_ptr (type, value_contents_writeable (result), 0, 0);
531
      return result;
532
    }
533
  else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
534
           && value_as_long (arg2) == 0)
535
    {
536
      /* The Itanium C++ ABI represents NULL pointers to members as
537
         minus one, instead of biasing the normal case.  */
538
      return value_from_longest (type, -1);
539
    }
540
  else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
541
    {
542
      if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
543
        return value_cast_pointers (type, arg2);
544
 
545
      arg2 = value_copy (arg2);
546
      deprecated_set_value_type (arg2, type);
547
      arg2 = value_change_enclosing_type (arg2, type);
548
      set_value_pointed_to_offset (arg2, 0);     /* pai: chk_val */
549
      return arg2;
550
    }
551
  else if (VALUE_LVAL (arg2) == lval_memory)
552
    return value_at_lazy (type, value_address (arg2));
553
  else if (code1 == TYPE_CODE_VOID)
554
    {
555
      return value_zero (type, not_lval);
556
    }
557
  else
558
    {
559
      error (_("Invalid cast."));
560
      return 0;
561
    }
562
}
563
 
564
/* The C++ reinterpret_cast operator.  */
565
 
566
struct value *
567
value_reinterpret_cast (struct type *type, struct value *arg)
568
{
569
  struct value *result;
570
  struct type *real_type = check_typedef (type);
571
  struct type *arg_type, *dest_type;
572
  int is_ref = 0;
573
  enum type_code dest_code, arg_code;
574
 
575
  /* Do reference, function, and array conversion.  */
576
  arg = coerce_array (arg);
577
 
578
  /* Attempt to preserve the type the user asked for.  */
579
  dest_type = type;
580
 
581
  /* If we are casting to a reference type, transform
582
     reinterpret_cast<T&>(V) to *reinterpret_cast<T*>(&V).  */
583
  if (TYPE_CODE (real_type) == TYPE_CODE_REF)
584
    {
585
      is_ref = 1;
586
      arg = value_addr (arg);
587
      dest_type = lookup_pointer_type (TYPE_TARGET_TYPE (dest_type));
588
      real_type = lookup_pointer_type (real_type);
589
    }
590
 
591
  arg_type = value_type (arg);
592
 
593
  dest_code = TYPE_CODE (real_type);
594
  arg_code = TYPE_CODE (arg_type);
595
 
596
  /* We can convert pointer types, or any pointer type to int, or int
597
     type to pointer.  */
598
  if ((dest_code == TYPE_CODE_PTR && arg_code == TYPE_CODE_INT)
599
      || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_PTR)
600
      || (dest_code == TYPE_CODE_METHODPTR && arg_code == TYPE_CODE_INT)
601
      || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_METHODPTR)
602
      || (dest_code == TYPE_CODE_MEMBERPTR && arg_code == TYPE_CODE_INT)
603
      || (dest_code == TYPE_CODE_INT && arg_code == TYPE_CODE_MEMBERPTR)
604
      || (dest_code == arg_code
605
          && (dest_code == TYPE_CODE_PTR
606
              || dest_code == TYPE_CODE_METHODPTR
607
              || dest_code == TYPE_CODE_MEMBERPTR)))
608
    result = value_cast (dest_type, arg);
609
  else
610
    error (_("Invalid reinterpret_cast"));
611
 
612
  if (is_ref)
613
    result = value_cast (type, value_ref (value_ind (result)));
614
 
615
  return result;
616
}
617
 
618
/* A helper for value_dynamic_cast.  This implements the first of two
619
   runtime checks: we iterate over all the base classes of the value's
620
   class which are equal to the desired class; if only one of these
621
   holds the value, then it is the answer.  */
622
 
623
static int
624
dynamic_cast_check_1 (struct type *desired_type,
625
                      const bfd_byte *contents,
626
                      CORE_ADDR address,
627
                      struct type *search_type,
628
                      CORE_ADDR arg_addr,
629
                      struct type *arg_type,
630
                      struct value **result)
631
{
632
  int i, result_count = 0;
633
 
634
  for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
635
    {
636
      int offset = baseclass_offset (search_type, i, contents, address);
637
 
638
      if (offset == -1)
639
        error (_("virtual baseclass botch"));
640
      if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
641
        {
642
          if (address + offset >= arg_addr
643
              && address + offset < arg_addr + TYPE_LENGTH (arg_type))
644
            {
645
              ++result_count;
646
              if (!*result)
647
                *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
648
                                         address + offset);
649
            }
650
        }
651
      else
652
        result_count += dynamic_cast_check_1 (desired_type,
653
                                              contents + offset,
654
                                              address + offset,
655
                                              TYPE_BASECLASS (search_type, i),
656
                                              arg_addr,
657
                                              arg_type,
658
                                              result);
659
    }
660
 
661
  return result_count;
662
}
663
 
664
/* A helper for value_dynamic_cast.  This implements the second of two
665
   runtime checks: we look for a unique public sibling class of the
666
   argument's declared class.  */
667
 
668
static int
669
dynamic_cast_check_2 (struct type *desired_type,
670
                      const bfd_byte *contents,
671
                      CORE_ADDR address,
672
                      struct type *search_type,
673
                      struct value **result)
674
{
675
  int i, result_count = 0;
676
 
677
  for (i = 0; i < TYPE_N_BASECLASSES (search_type) && result_count < 2; ++i)
678
    {
679
      int offset;
680
 
681
      if (! BASETYPE_VIA_PUBLIC (search_type, i))
682
        continue;
683
 
684
      offset = baseclass_offset (search_type, i, contents, address);
685
      if (offset == -1)
686
        error (_("virtual baseclass botch"));
687
      if (class_types_same_p (desired_type, TYPE_BASECLASS (search_type, i)))
688
        {
689
          ++result_count;
690
          if (*result == NULL)
691
            *result = value_at_lazy (TYPE_BASECLASS (search_type, i),
692
                                     address + offset);
693
        }
694
      else
695
        result_count += dynamic_cast_check_2 (desired_type,
696
                                              contents + offset,
697
                                              address + offset,
698
                                              TYPE_BASECLASS (search_type, i),
699
                                              result);
700
    }
701
 
702
  return result_count;
703
}
704
 
705
/* The C++ dynamic_cast operator.  */
706
 
707
struct value *
708
value_dynamic_cast (struct type *type, struct value *arg)
709
{
710
  int full, top, using_enc;
711
  struct type *resolved_type = check_typedef (type);
712
  struct type *arg_type = check_typedef (value_type (arg));
713
  struct type *class_type, *rtti_type;
714
  struct value *result, *tem, *original_arg = arg;
715
  CORE_ADDR addr;
716
  int is_ref = TYPE_CODE (resolved_type) == TYPE_CODE_REF;
717
 
718
  if (TYPE_CODE (resolved_type) != TYPE_CODE_PTR
719
      && TYPE_CODE (resolved_type) != TYPE_CODE_REF)
720
    error (_("Argument to dynamic_cast must be a pointer or reference type"));
721
  if (TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_VOID
722
      && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) != TYPE_CODE_CLASS)
723
    error (_("Argument to dynamic_cast must be pointer to class or `void *'"));
724
 
725
  class_type = check_typedef (TYPE_TARGET_TYPE (resolved_type));
726
  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
727
    {
728
      if (TYPE_CODE (arg_type) != TYPE_CODE_PTR
729
          && ! (TYPE_CODE (arg_type) == TYPE_CODE_INT
730
                && value_as_long (arg) == 0))
731
        error (_("Argument to dynamic_cast does not have pointer type"));
732
      if (TYPE_CODE (arg_type) == TYPE_CODE_PTR)
733
        {
734
          arg_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
735
          if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
736
            error (_("Argument to dynamic_cast does not have pointer to class type"));
737
        }
738
 
739
      /* Handle NULL pointers.  */
740
      if (value_as_long (arg) == 0)
741
        return value_zero (type, not_lval);
742
 
743
      arg = value_ind (arg);
744
    }
745
  else
746
    {
747
      if (TYPE_CODE (arg_type) != TYPE_CODE_CLASS)
748
        error (_("Argument to dynamic_cast does not have class type"));
749
    }
750
 
751
  /* If the classes are the same, just return the argument.  */
752
  if (class_types_same_p (class_type, arg_type))
753
    return value_cast (type, arg);
754
 
755
  /* If the target type is a unique base class of the argument's
756
     declared type, just cast it.  */
757
  if (is_ancestor (class_type, arg_type))
758
    {
759
      if (is_unique_ancestor (class_type, arg))
760
        return value_cast (type, original_arg);
761
      error (_("Ambiguous dynamic_cast"));
762
    }
763
 
764
  rtti_type = value_rtti_type (arg, &full, &top, &using_enc);
765
  if (! rtti_type)
766
    error (_("Couldn't determine value's most derived type for dynamic_cast"));
767
 
768
  /* Compute the most derived object's address.  */
769
  addr = value_address (arg);
770
  if (full)
771
    {
772
      /* Done.  */
773
    }
774
  else if (using_enc)
775
    addr += top;
776
  else
777
    addr += top + value_embedded_offset (arg);
778
 
779
  /* dynamic_cast<void *> means to return a pointer to the
780
     most-derived object.  */
781
  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR
782
      && TYPE_CODE (TYPE_TARGET_TYPE (resolved_type)) == TYPE_CODE_VOID)
783
    return value_at_lazy (type, addr);
784
 
785
  tem = value_at (type, addr);
786
 
787
  /* The first dynamic check specified in 5.2.7.  */
788
  if (is_public_ancestor (arg_type, TYPE_TARGET_TYPE (resolved_type)))
789
    {
790
      if (class_types_same_p (rtti_type, TYPE_TARGET_TYPE (resolved_type)))
791
        return tem;
792
      result = NULL;
793
      if (dynamic_cast_check_1 (TYPE_TARGET_TYPE (resolved_type),
794
                                value_contents (tem), value_address (tem),
795
                                rtti_type, addr,
796
                                arg_type,
797
                                &result) == 1)
798
        return value_cast (type,
799
                           is_ref ? value_ref (result) : value_addr (result));
800
    }
801
 
802
  /* The second dynamic check specified in 5.2.7.  */
803
  result = NULL;
804
  if (is_public_ancestor (arg_type, rtti_type)
805
      && dynamic_cast_check_2 (TYPE_TARGET_TYPE (resolved_type),
806
                               value_contents (tem), value_address (tem),
807
                               rtti_type, &result) == 1)
808
    return value_cast (type,
809
                       is_ref ? value_ref (result) : value_addr (result));
810
 
811
  if (TYPE_CODE (resolved_type) == TYPE_CODE_PTR)
812
    return value_zero (type, not_lval);
813
 
814
  error (_("dynamic_cast failed"));
815
}
816
 
817
/* Create a value of type TYPE that is zero, and return it.  */
818
 
819
struct value *
820
value_zero (struct type *type, enum lval_type lv)
821
{
822
  struct value *val = allocate_value (type);
823
 
824
  VALUE_LVAL (val) = lv;
825
  return val;
826
}
827
 
828
/* Create a value of numeric type TYPE that is one, and return it.  */
829
 
830
struct value *
831
value_one (struct type *type, enum lval_type lv)
832
{
833
  struct type *type1 = check_typedef (type);
834
  struct value *val;
835
 
836
  if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT)
837
    {
838
      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
839
      gdb_byte v[16];
840
 
841
      decimal_from_string (v, TYPE_LENGTH (type), byte_order, "1");
842
      val = value_from_decfloat (type, v);
843
    }
844
  else if (TYPE_CODE (type1) == TYPE_CODE_FLT)
845
    {
846
      val = value_from_double (type, (DOUBLEST) 1);
847
    }
848
  else if (is_integral_type (type1))
849
    {
850
      val = value_from_longest (type, (LONGEST) 1);
851
    }
852
  else
853
    {
854
      error (_("Not a numeric type."));
855
    }
856
 
857
  VALUE_LVAL (val) = lv;
858
  return val;
859
}
860
 
861
/* Helper function for value_at, value_at_lazy, and value_at_lazy_stack.  */
862
 
863
static struct value *
864
get_value_at (struct type *type, CORE_ADDR addr, int lazy)
865
{
866
  struct value *val;
867
 
868
  if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
869
    error (_("Attempt to dereference a generic pointer."));
870
 
871
  if (lazy)
872
    {
873
      val = allocate_value_lazy (type);
874
    }
875
  else
876
    {
877
      val = allocate_value (type);
878
      read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
879
    }
880
 
881
  VALUE_LVAL (val) = lval_memory;
882
  set_value_address (val, addr);
883
 
884
  return val;
885
}
886
 
887
/* Return a value with type TYPE located at ADDR.
888
 
889
   Call value_at only if the data needs to be fetched immediately;
890
   if we can be 'lazy' and defer the fetch, perhaps indefinately, call
891
   value_at_lazy instead.  value_at_lazy simply records the address of
892
   the data and sets the lazy-evaluation-required flag.  The lazy flag
893
   is tested in the value_contents macro, which is used if and when
894
   the contents are actually required.
895
 
896
   Note: value_at does *NOT* handle embedded offsets; perform such
897
   adjustments before or after calling it.  */
898
 
899
struct value *
900
value_at (struct type *type, CORE_ADDR addr)
901
{
902
  return get_value_at (type, addr, 0);
903
}
904
 
905
/* Return a lazy value with type TYPE located at ADDR (cf. value_at).  */
906
 
907
struct value *
908
value_at_lazy (struct type *type, CORE_ADDR addr)
909
{
910
  return get_value_at (type, addr, 1);
911
}
912
 
913
/* Called only from the value_contents and value_contents_all()
914
   macros, if the current data for a variable needs to be loaded into
915
   value_contents(VAL).  Fetches the data from the user's process, and
916
   clears the lazy flag to indicate that the data in the buffer is
917
   valid.
918
 
919
   If the value is zero-length, we avoid calling read_memory, which
920
   would abort.  We mark the value as fetched anyway -- all 0 bytes of
921
   it.
922
 
923
   This function returns a value because it is used in the
924
   value_contents macro as part of an expression, where a void would
925
   not work.  The value is ignored.  */
926
 
927
int
928
value_fetch_lazy (struct value *val)
929
{
930
  gdb_assert (value_lazy (val));
931
  allocate_value_contents (val);
932
  if (value_bitsize (val))
933
    {
934
      /* To read a lazy bitfield, read the entire enclosing value.  This
935
         prevents reading the same block of (possibly volatile) memory once
936
         per bitfield.  It would be even better to read only the containing
937
         word, but we have no way to record that just specific bits of a
938
         value have been fetched.  */
939
      struct type *type = check_typedef (value_type (val));
940
      enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
941
      struct value *parent = value_parent (val);
942
      LONGEST offset = value_offset (val);
943
      LONGEST num = unpack_bits_as_long (value_type (val),
944
                                         (value_contents_for_printing (parent)
945
                                          + offset),
946
                                         value_bitpos (val),
947
                                         value_bitsize (val));
948
      int length = TYPE_LENGTH (type);
949
 
950
      if (!value_bits_valid (val,
951
                             TARGET_CHAR_BIT * offset + value_bitpos (val),
952
                             value_bitsize (val)))
953
        error (_("value has been optimized out"));
954
 
955
      store_signed_integer (value_contents_raw (val), length, byte_order, num);
956
    }
957
  else if (VALUE_LVAL (val) == lval_memory)
958
    {
959
      CORE_ADDR addr = value_address (val);
960
      int length = TYPE_LENGTH (check_typedef (value_enclosing_type (val)));
961
 
962
      if (length)
963
        {
964
          if (value_stack (val))
965
            read_stack (addr, value_contents_all_raw (val), length);
966
          else
967
            read_memory (addr, value_contents_all_raw (val), length);
968
        }
969
    }
970
  else if (VALUE_LVAL (val) == lval_register)
971
    {
972
      struct frame_info *frame;
973
      int regnum;
974
      struct type *type = check_typedef (value_type (val));
975
      struct value *new_val = val, *mark = value_mark ();
976
 
977
      /* Offsets are not supported here; lazy register values must
978
         refer to the entire register.  */
979
      gdb_assert (value_offset (val) == 0);
980
 
981
      while (VALUE_LVAL (new_val) == lval_register && value_lazy (new_val))
982
        {
983
          frame = frame_find_by_id (VALUE_FRAME_ID (new_val));
984
          regnum = VALUE_REGNUM (new_val);
985
 
986
          gdb_assert (frame != NULL);
987
 
988
          /* Convertible register routines are used for multi-register
989
             values and for interpretation in different types
990
             (e.g. float or int from a double register).  Lazy
991
             register values should have the register's natural type,
992
             so they do not apply.  */
993
          gdb_assert (!gdbarch_convert_register_p (get_frame_arch (frame),
994
                                                   regnum, type));
995
 
996
          new_val = get_frame_register_value (frame, regnum);
997
        }
998
 
999
      /* If it's still lazy (for instance, a saved register on the
1000
         stack), fetch it.  */
1001
      if (value_lazy (new_val))
1002
        value_fetch_lazy (new_val);
1003
 
1004
      /* If the register was not saved, mark it unavailable.  */
1005
      if (value_optimized_out (new_val))
1006
        set_value_optimized_out (val, 1);
1007
      else
1008
        memcpy (value_contents_raw (val), value_contents (new_val),
1009
                TYPE_LENGTH (type));
1010
 
1011
      if (frame_debug)
1012
        {
1013
          struct gdbarch *gdbarch;
1014
          frame = frame_find_by_id (VALUE_FRAME_ID (val));
1015
          regnum = VALUE_REGNUM (val);
1016
          gdbarch = get_frame_arch (frame);
1017
 
1018
          fprintf_unfiltered (gdb_stdlog, "\
1019
{ value_fetch_lazy (frame=%d,regnum=%d(%s),...) ",
1020
                              frame_relative_level (frame), regnum,
1021
                              user_reg_map_regnum_to_name (gdbarch, regnum));
1022
 
1023
          fprintf_unfiltered (gdb_stdlog, "->");
1024
          if (value_optimized_out (new_val))
1025
            fprintf_unfiltered (gdb_stdlog, " optimized out");
1026
          else
1027
            {
1028
              int i;
1029
              const gdb_byte *buf = value_contents (new_val);
1030
 
1031
              if (VALUE_LVAL (new_val) == lval_register)
1032
                fprintf_unfiltered (gdb_stdlog, " register=%d",
1033
                                    VALUE_REGNUM (new_val));
1034
              else if (VALUE_LVAL (new_val) == lval_memory)
1035
                fprintf_unfiltered (gdb_stdlog, " address=%s",
1036
                                    paddress (gdbarch,
1037
                                              value_address (new_val)));
1038
              else
1039
                fprintf_unfiltered (gdb_stdlog, " computed");
1040
 
1041
              fprintf_unfiltered (gdb_stdlog, " bytes=");
1042
              fprintf_unfiltered (gdb_stdlog, "[");
1043
              for (i = 0; i < register_size (gdbarch, regnum); i++)
1044
                fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1045
              fprintf_unfiltered (gdb_stdlog, "]");
1046
            }
1047
 
1048
          fprintf_unfiltered (gdb_stdlog, " }\n");
1049
        }
1050
 
1051
      /* Dispose of the intermediate values.  This prevents
1052
         watchpoints from trying to watch the saved frame pointer.  */
1053
      value_free_to_mark (mark);
1054
    }
1055
  else if (VALUE_LVAL (val) == lval_computed)
1056
    value_computed_funcs (val)->read (val);
1057
  else
1058
    internal_error (__FILE__, __LINE__, "Unexpected lazy value type.");
1059
 
1060
  set_value_lazy (val, 0);
1061
  return 0;
1062
}
1063
 
1064
 
1065
/* Store the contents of FROMVAL into the location of TOVAL.
1066
   Return a new value with the location of TOVAL and contents of FROMVAL.  */
1067
 
1068
struct value *
1069
value_assign (struct value *toval, struct value *fromval)
1070
{
1071
  struct type *type;
1072
  struct value *val;
1073
  struct frame_id old_frame;
1074
 
1075
  if (!deprecated_value_modifiable (toval))
1076
    error (_("Left operand of assignment is not a modifiable lvalue."));
1077
 
1078
  toval = coerce_ref (toval);
1079
 
1080
  type = value_type (toval);
1081
  if (VALUE_LVAL (toval) != lval_internalvar)
1082
    {
1083
      toval = value_coerce_to_target (toval);
1084
      fromval = value_cast (type, fromval);
1085
    }
1086
  else
1087
    {
1088
      /* Coerce arrays and functions to pointers, except for arrays
1089
         which only live in GDB's storage.  */
1090
      if (!value_must_coerce_to_target (fromval))
1091
        fromval = coerce_array (fromval);
1092
    }
1093
 
1094
  CHECK_TYPEDEF (type);
1095
 
1096
  /* Since modifying a register can trash the frame chain, and
1097
     modifying memory can trash the frame cache, we save the old frame
1098
     and then restore the new frame afterwards.  */
1099
  old_frame = get_frame_id (deprecated_safe_get_selected_frame ());
1100
 
1101
  switch (VALUE_LVAL (toval))
1102
    {
1103
    case lval_internalvar:
1104
      set_internalvar (VALUE_INTERNALVAR (toval), fromval);
1105
      val = value_copy (fromval);
1106
      val = value_change_enclosing_type (val,
1107
                                         value_enclosing_type (fromval));
1108
      set_value_embedded_offset (val, value_embedded_offset (fromval));
1109
      set_value_pointed_to_offset (val,
1110
                                   value_pointed_to_offset (fromval));
1111
      return val;
1112
 
1113
    case lval_internalvar_component:
1114
      set_internalvar_component (VALUE_INTERNALVAR (toval),
1115
                                 value_offset (toval),
1116
                                 value_bitpos (toval),
1117
                                 value_bitsize (toval),
1118
                                 fromval);
1119
      break;
1120
 
1121
    case lval_memory:
1122
      {
1123
        const gdb_byte *dest_buffer;
1124
        CORE_ADDR changed_addr;
1125
        int changed_len;
1126
        gdb_byte buffer[sizeof (LONGEST)];
1127
 
1128
        if (value_bitsize (toval))
1129
          {
1130
            struct value *parent = value_parent (toval);
1131
 
1132
            changed_addr = value_address (parent) + value_offset (toval);
1133
            changed_len = (value_bitpos (toval)
1134
                           + value_bitsize (toval)
1135
                           + HOST_CHAR_BIT - 1)
1136
              / HOST_CHAR_BIT;
1137
 
1138
            /* If we can read-modify-write exactly the size of the
1139
               containing type (e.g. short or int) then do so.  This
1140
               is safer for volatile bitfields mapped to hardware
1141
               registers.  */
1142
            if (changed_len < TYPE_LENGTH (type)
1143
                && TYPE_LENGTH (type) <= (int) sizeof (LONGEST)
1144
                && ((LONGEST) changed_addr % TYPE_LENGTH (type)) == 0)
1145
              changed_len = TYPE_LENGTH (type);
1146
 
1147
            if (changed_len > (int) sizeof (LONGEST))
1148
              error (_("Can't handle bitfields which don't fit in a %d bit word."),
1149
                     (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1150
 
1151
            read_memory (changed_addr, buffer, changed_len);
1152
            modify_field (type, buffer, value_as_long (fromval),
1153
                          value_bitpos (toval), value_bitsize (toval));
1154
            dest_buffer = buffer;
1155
          }
1156
        else
1157
          {
1158
            changed_addr = value_address (toval);
1159
            changed_len = TYPE_LENGTH (type);
1160
            dest_buffer = value_contents (fromval);
1161
          }
1162
 
1163
        write_memory (changed_addr, dest_buffer, changed_len);
1164
        observer_notify_memory_changed (changed_addr, changed_len,
1165
                                        dest_buffer);
1166
      }
1167
      break;
1168
 
1169
    case lval_register:
1170
      {
1171
        struct frame_info *frame;
1172
        struct gdbarch *gdbarch;
1173
        int value_reg;
1174
 
1175
        /* Figure out which frame this is in currently.  */
1176
        frame = frame_find_by_id (VALUE_FRAME_ID (toval));
1177
        value_reg = VALUE_REGNUM (toval);
1178
 
1179
        if (!frame)
1180
          error (_("Value being assigned to is no longer active."));
1181
 
1182
        gdbarch = get_frame_arch (frame);
1183
        if (gdbarch_convert_register_p (gdbarch, VALUE_REGNUM (toval), type))
1184
          {
1185
            /* If TOVAL is a special machine register requiring
1186
               conversion of program values to a special raw
1187
               format.  */
1188
            gdbarch_value_to_register (gdbarch, frame,
1189
                                       VALUE_REGNUM (toval), type,
1190
                                       value_contents (fromval));
1191
          }
1192
        else
1193
          {
1194
            if (value_bitsize (toval))
1195
              {
1196
                struct value *parent = value_parent (toval);
1197
                int offset = value_offset (parent) + value_offset (toval);
1198
                int changed_len;
1199
                gdb_byte buffer[sizeof (LONGEST)];
1200
 
1201
                changed_len = (value_bitpos (toval)
1202
                               + value_bitsize (toval)
1203
                               + HOST_CHAR_BIT - 1)
1204
                  / HOST_CHAR_BIT;
1205
 
1206
                if (changed_len > (int) sizeof (LONGEST))
1207
                  error (_("Can't handle bitfields which don't fit in a %d bit word."),
1208
                         (int) sizeof (LONGEST) * HOST_CHAR_BIT);
1209
 
1210
                get_frame_register_bytes (frame, value_reg, offset,
1211
                                          changed_len, buffer);
1212
 
1213
                modify_field (type, buffer, value_as_long (fromval),
1214
                              value_bitpos (toval), value_bitsize (toval));
1215
 
1216
                put_frame_register_bytes (frame, value_reg, offset,
1217
                                          changed_len, buffer);
1218
              }
1219
            else
1220
              {
1221
                put_frame_register_bytes (frame, value_reg,
1222
                                          value_offset (toval),
1223
                                          TYPE_LENGTH (type),
1224
                                          value_contents (fromval));
1225
              }
1226
          }
1227
 
1228
        if (deprecated_register_changed_hook)
1229
          deprecated_register_changed_hook (-1);
1230
        observer_notify_target_changed (&current_target);
1231
        break;
1232
      }
1233
 
1234
    case lval_computed:
1235
      {
1236
        struct lval_funcs *funcs = value_computed_funcs (toval);
1237
 
1238
        funcs->write (toval, fromval);
1239
      }
1240
      break;
1241
 
1242
    default:
1243
      error (_("Left operand of assignment is not an lvalue."));
1244
    }
1245
 
1246
  /* Assigning to the stack pointer, frame pointer, and other
1247
     (architecture and calling convention specific) registers may
1248
     cause the frame cache to be out of date.  Assigning to memory
1249
     also can.  We just do this on all assignments to registers or
1250
     memory, for simplicity's sake; I doubt the slowdown matters.  */
1251
  switch (VALUE_LVAL (toval))
1252
    {
1253
    case lval_memory:
1254
    case lval_register:
1255
    case lval_computed:
1256
 
1257
      reinit_frame_cache ();
1258
 
1259
      /* Having destroyed the frame cache, restore the selected
1260
         frame.  */
1261
 
1262
      /* FIXME: cagney/2002-11-02: There has to be a better way of
1263
         doing this.  Instead of constantly saving/restoring the
1264
         frame.  Why not create a get_selected_frame() function that,
1265
         having saved the selected frame's ID can automatically
1266
         re-find the previously selected frame automatically.  */
1267
 
1268
      {
1269
        struct frame_info *fi = frame_find_by_id (old_frame);
1270
 
1271
        if (fi != NULL)
1272
          select_frame (fi);
1273
      }
1274
 
1275
      break;
1276
    default:
1277
      break;
1278
    }
1279
 
1280
  /* If the field does not entirely fill a LONGEST, then zero the sign
1281
     bits.  If the field is signed, and is negative, then sign
1282
     extend.  */
1283
  if ((value_bitsize (toval) > 0)
1284
      && (value_bitsize (toval) < 8 * (int) sizeof (LONGEST)))
1285
    {
1286
      LONGEST fieldval = value_as_long (fromval);
1287
      LONGEST valmask = (((ULONGEST) 1) << value_bitsize (toval)) - 1;
1288
 
1289
      fieldval &= valmask;
1290
      if (!TYPE_UNSIGNED (type)
1291
          && (fieldval & (valmask ^ (valmask >> 1))))
1292
        fieldval |= ~valmask;
1293
 
1294
      fromval = value_from_longest (type, fieldval);
1295
    }
1296
 
1297
  val = value_copy (toval);
1298
  memcpy (value_contents_raw (val), value_contents (fromval),
1299
          TYPE_LENGTH (type));
1300
  deprecated_set_value_type (val, type);
1301
  val = value_change_enclosing_type (val,
1302
                                     value_enclosing_type (fromval));
1303
  set_value_embedded_offset (val, value_embedded_offset (fromval));
1304
  set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
1305
 
1306
  return val;
1307
}
1308
 
1309
/* Extend a value VAL to COUNT repetitions of its type.  */
1310
 
1311
struct value *
1312
value_repeat (struct value *arg1, int count)
1313
{
1314
  struct value *val;
1315
 
1316
  if (VALUE_LVAL (arg1) != lval_memory)
1317
    error (_("Only values in memory can be extended with '@'."));
1318
  if (count < 1)
1319
    error (_("Invalid number %d of repetitions."), count);
1320
 
1321
  val = allocate_repeat_value (value_enclosing_type (arg1), count);
1322
 
1323
  read_memory (value_address (arg1),
1324
               value_contents_all_raw (val),
1325
               TYPE_LENGTH (value_enclosing_type (val)));
1326
  VALUE_LVAL (val) = lval_memory;
1327
  set_value_address (val, value_address (arg1));
1328
 
1329
  return val;
1330
}
1331
 
1332
struct value *
1333
value_of_variable (struct symbol *var, struct block *b)
1334
{
1335
  struct value *val;
1336
  struct frame_info *frame;
1337
 
1338
  if (!symbol_read_needs_frame (var))
1339
    frame = NULL;
1340
  else if (!b)
1341
    frame = get_selected_frame (_("No frame selected."));
1342
  else
1343
    {
1344
      frame = block_innermost_frame (b);
1345
      if (!frame)
1346
        {
1347
          if (BLOCK_FUNCTION (b) && !block_inlined_p (b)
1348
              && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
1349
            error (_("No frame is currently executing in block %s."),
1350
                   SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
1351
          else
1352
            error (_("No frame is currently executing in specified block"));
1353
        }
1354
    }
1355
 
1356
  val = read_var_value (var, frame);
1357
  if (!val)
1358
    error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
1359
 
1360
  return val;
1361
}
1362
 
1363
struct value *
1364
address_of_variable (struct symbol *var, struct block *b)
1365
{
1366
  struct type *type = SYMBOL_TYPE (var);
1367
  struct value *val;
1368
 
1369
  /* Evaluate it first; if the result is a memory address, we're fine.
1370
     Lazy evaluation pays off here. */
1371
 
1372
  val = value_of_variable (var, b);
1373
 
1374
  if ((VALUE_LVAL (val) == lval_memory && value_lazy (val))
1375
      || TYPE_CODE (type) == TYPE_CODE_FUNC)
1376
    {
1377
      CORE_ADDR addr = value_address (val);
1378
 
1379
      return value_from_pointer (lookup_pointer_type (type), addr);
1380
    }
1381
 
1382
  /* Not a memory address; check what the problem was.  */
1383
  switch (VALUE_LVAL (val))
1384
    {
1385
    case lval_register:
1386
      {
1387
        struct frame_info *frame;
1388
        const char *regname;
1389
 
1390
        frame = frame_find_by_id (VALUE_FRAME_ID (val));
1391
        gdb_assert (frame);
1392
 
1393
        regname = gdbarch_register_name (get_frame_arch (frame),
1394
                                         VALUE_REGNUM (val));
1395
        gdb_assert (regname && *regname);
1396
 
1397
        error (_("Address requested for identifier "
1398
                 "\"%s\" which is in register $%s"),
1399
               SYMBOL_PRINT_NAME (var), regname);
1400
        break;
1401
      }
1402
 
1403
    default:
1404
      error (_("Can't take address of \"%s\" which isn't an lvalue."),
1405
             SYMBOL_PRINT_NAME (var));
1406
      break;
1407
    }
1408
 
1409
  return val;
1410
}
1411
 
1412
/* Return one if VAL does not live in target memory, but should in order
1413
   to operate on it.  Otherwise return zero.  */
1414
 
1415
int
1416
value_must_coerce_to_target (struct value *val)
1417
{
1418
  struct type *valtype;
1419
 
1420
  /* The only lval kinds which do not live in target memory.  */
1421
  if (VALUE_LVAL (val) != not_lval
1422
      && VALUE_LVAL (val) != lval_internalvar)
1423
    return 0;
1424
 
1425
  valtype = check_typedef (value_type (val));
1426
 
1427
  switch (TYPE_CODE (valtype))
1428
    {
1429
    case TYPE_CODE_ARRAY:
1430
    case TYPE_CODE_STRING:
1431
      return 1;
1432
    default:
1433
      return 0;
1434
    }
1435
}
1436
 
1437
/* Make sure that VAL lives in target memory if it's supposed to.  For instance,
1438
   strings are constructed as character arrays in GDB's storage, and this
1439
   function copies them to the target.  */
1440
 
1441
struct value *
1442
value_coerce_to_target (struct value *val)
1443
{
1444
  LONGEST length;
1445
  CORE_ADDR addr;
1446
 
1447
  if (!value_must_coerce_to_target (val))
1448
    return val;
1449
 
1450
  length = TYPE_LENGTH (check_typedef (value_type (val)));
1451
  addr = allocate_space_in_inferior (length);
1452
  write_memory (addr, value_contents (val), length);
1453
  return value_at_lazy (value_type (val), addr);
1454
}
1455
 
1456
/* Given a value which is an array, return a value which is a pointer
1457
   to its first element, regardless of whether or not the array has a
1458
   nonzero lower bound.
1459
 
1460
   FIXME: A previous comment here indicated that this routine should
1461
   be substracting the array's lower bound.  It's not clear to me that
1462
   this is correct.  Given an array subscripting operation, it would
1463
   certainly work to do the adjustment here, essentially computing:
1464
 
1465
   (&array[0] - (lowerbound * sizeof array[0])) + (index * sizeof array[0])
1466
 
1467
   However I believe a more appropriate and logical place to account
1468
   for the lower bound is to do so in value_subscript, essentially
1469
   computing:
1470
 
1471
   (&array[0] + ((index - lowerbound) * sizeof array[0]))
1472
 
1473
   As further evidence consider what would happen with operations
1474
   other than array subscripting, where the caller would get back a
1475
   value that had an address somewhere before the actual first element
1476
   of the array, and the information about the lower bound would be
1477
   lost because of the coercion to pointer type.
1478
 */
1479
 
1480
struct value *
1481
value_coerce_array (struct value *arg1)
1482
{
1483
  struct type *type = check_typedef (value_type (arg1));
1484
 
1485
  /* If the user tries to do something requiring a pointer with an
1486
     array that has not yet been pushed to the target, then this would
1487
     be a good time to do so.  */
1488
  arg1 = value_coerce_to_target (arg1);
1489
 
1490
  if (VALUE_LVAL (arg1) != lval_memory)
1491
    error (_("Attempt to take address of value not located in memory."));
1492
 
1493
  return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
1494
                             value_address (arg1));
1495
}
1496
 
1497
/* Given a value which is a function, return a value which is a pointer
1498
   to it.  */
1499
 
1500
struct value *
1501
value_coerce_function (struct value *arg1)
1502
{
1503
  struct value *retval;
1504
 
1505
  if (VALUE_LVAL (arg1) != lval_memory)
1506
    error (_("Attempt to take address of value not located in memory."));
1507
 
1508
  retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1509
                               value_address (arg1));
1510
  return retval;
1511
}
1512
 
1513
/* Return a pointer value for the object for which ARG1 is the
1514
   contents.  */
1515
 
1516
struct value *
1517
value_addr (struct value *arg1)
1518
{
1519
  struct value *arg2;
1520
  struct type *type = check_typedef (value_type (arg1));
1521
 
1522
  if (TYPE_CODE (type) == TYPE_CODE_REF)
1523
    {
1524
      /* Copy the value, but change the type from (T&) to (T*).  We
1525
         keep the same location information, which is efficient, and
1526
         allows &(&X) to get the location containing the reference.  */
1527
      arg2 = value_copy (arg1);
1528
      deprecated_set_value_type (arg2,
1529
                                 lookup_pointer_type (TYPE_TARGET_TYPE (type)));
1530
      return arg2;
1531
    }
1532
  if (TYPE_CODE (type) == TYPE_CODE_FUNC)
1533
    return value_coerce_function (arg1);
1534
 
1535
  /* If this is an array that has not yet been pushed to the target,
1536
     then this would be a good time to force it to memory.  */
1537
  arg1 = value_coerce_to_target (arg1);
1538
 
1539
  if (VALUE_LVAL (arg1) != lval_memory)
1540
    error (_("Attempt to take address of value not located in memory."));
1541
 
1542
  /* Get target memory address */
1543
  arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
1544
                             (value_address (arg1)
1545
                              + value_embedded_offset (arg1)));
1546
 
1547
  /* This may be a pointer to a base subobject; so remember the
1548
     full derived object's type ...  */
1549
  arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
1550
  /* ... and also the relative position of the subobject in the full
1551
     object.  */
1552
  set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
1553
  return arg2;
1554
}
1555
 
1556
/* Return a reference value for the object for which ARG1 is the
1557
   contents.  */
1558
 
1559
struct value *
1560
value_ref (struct value *arg1)
1561
{
1562
  struct value *arg2;
1563
  struct type *type = check_typedef (value_type (arg1));
1564
 
1565
  if (TYPE_CODE (type) == TYPE_CODE_REF)
1566
    return arg1;
1567
 
1568
  arg2 = value_addr (arg1);
1569
  deprecated_set_value_type (arg2, lookup_reference_type (type));
1570
  return arg2;
1571
}
1572
 
1573
/* Given a value of a pointer type, apply the C unary * operator to
1574
   it.  */
1575
 
1576
struct value *
1577
value_ind (struct value *arg1)
1578
{
1579
  struct type *base_type;
1580
  struct value *arg2;
1581
 
1582
  arg1 = coerce_array (arg1);
1583
 
1584
  base_type = check_typedef (value_type (arg1));
1585
 
1586
  if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
1587
    {
1588
      struct type *enc_type;
1589
 
1590
      /* We may be pointing to something embedded in a larger object.
1591
         Get the real type of the enclosing object.  */
1592
      enc_type = check_typedef (value_enclosing_type (arg1));
1593
      enc_type = TYPE_TARGET_TYPE (enc_type);
1594
 
1595
      if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
1596
          || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
1597
        /* For functions, go through find_function_addr, which knows
1598
           how to handle function descriptors.  */
1599
        arg2 = value_at_lazy (enc_type,
1600
                              find_function_addr (arg1, NULL));
1601
      else
1602
        /* Retrieve the enclosing object pointed to */
1603
        arg2 = value_at_lazy (enc_type,
1604
                              (value_as_address (arg1)
1605
                               - value_pointed_to_offset (arg1)));
1606
 
1607
      /* Re-adjust type.  */
1608
      deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
1609
      /* Add embedding info.  */
1610
      arg2 = value_change_enclosing_type (arg2, enc_type);
1611
      set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
1612
 
1613
      /* We may be pointing to an object of some derived type.  */
1614
      arg2 = value_full_object (arg2, NULL, 0, 0, 0);
1615
      return arg2;
1616
    }
1617
 
1618
  error (_("Attempt to take contents of a non-pointer value."));
1619
  return 0;                      /* For lint -- never reached.  */
1620
}
1621
 
1622
/* Create a value for an array by allocating space in GDB, copying
1623
   copying the data into that space, and then setting up an array
1624
   value.
1625
 
1626
   The array bounds are set from LOWBOUND and HIGHBOUND, and the array
1627
   is populated from the values passed in ELEMVEC.
1628
 
1629
   The element type of the array is inherited from the type of the
1630
   first element, and all elements must have the same size (though we
1631
   don't currently enforce any restriction on their types).  */
1632
 
1633
struct value *
1634
value_array (int lowbound, int highbound, struct value **elemvec)
1635
{
1636
  int nelem;
1637
  int idx;
1638
  unsigned int typelength;
1639
  struct value *val;
1640
  struct type *arraytype;
1641
 
1642
  /* Validate that the bounds are reasonable and that each of the
1643
     elements have the same size.  */
1644
 
1645
  nelem = highbound - lowbound + 1;
1646
  if (nelem <= 0)
1647
    {
1648
      error (_("bad array bounds (%d, %d)"), lowbound, highbound);
1649
    }
1650
  typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
1651
  for (idx = 1; idx < nelem; idx++)
1652
    {
1653
      if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
1654
        {
1655
          error (_("array elements must all be the same size"));
1656
        }
1657
    }
1658
 
1659
  arraytype = lookup_array_range_type (value_enclosing_type (elemvec[0]),
1660
                                       lowbound, highbound);
1661
 
1662
  if (!current_language->c_style_arrays)
1663
    {
1664
      val = allocate_value (arraytype);
1665
      for (idx = 0; idx < nelem; idx++)
1666
        {
1667
          memcpy (value_contents_all_raw (val) + (idx * typelength),
1668
                  value_contents_all (elemvec[idx]),
1669
                  typelength);
1670
        }
1671
      return val;
1672
    }
1673
 
1674
  /* Allocate space to store the array, and then initialize it by
1675
     copying in each element.  */
1676
 
1677
  val = allocate_value (arraytype);
1678
  for (idx = 0; idx < nelem; idx++)
1679
    memcpy (value_contents_writeable (val) + (idx * typelength),
1680
            value_contents_all (elemvec[idx]),
1681
            typelength);
1682
  return val;
1683
}
1684
 
1685
struct value *
1686
value_cstring (char *ptr, int len, struct type *char_type)
1687
{
1688
  struct value *val;
1689
  int lowbound = current_language->string_lower_bound;
1690
  int highbound = len / TYPE_LENGTH (char_type);
1691
  struct type *stringtype
1692
    = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
1693
 
1694
  val = allocate_value (stringtype);
1695
  memcpy (value_contents_raw (val), ptr, len);
1696
  return val;
1697
}
1698
 
1699
/* Create a value for a string constant by allocating space in the
1700
   inferior, copying the data into that space, and returning the
1701
   address with type TYPE_CODE_STRING.  PTR points to the string
1702
   constant data; LEN is number of characters.
1703
 
1704
   Note that string types are like array of char types with a lower
1705
   bound of zero and an upper bound of LEN - 1.  Also note that the
1706
   string may contain embedded null bytes.  */
1707
 
1708
struct value *
1709
value_string (char *ptr, int len, struct type *char_type)
1710
{
1711
  struct value *val;
1712
  int lowbound = current_language->string_lower_bound;
1713
  int highbound = len / TYPE_LENGTH (char_type);
1714
  struct type *stringtype
1715
    = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
1716
 
1717
  val = allocate_value (stringtype);
1718
  memcpy (value_contents_raw (val), ptr, len);
1719
  return val;
1720
}
1721
 
1722
struct value *
1723
value_bitstring (char *ptr, int len, struct type *index_type)
1724
{
1725
  struct value *val;
1726
  struct type *domain_type
1727
    = create_range_type (NULL, index_type, 0, len - 1);
1728
  struct type *type = create_set_type (NULL, domain_type);
1729
 
1730
  TYPE_CODE (type) = TYPE_CODE_BITSTRING;
1731
  val = allocate_value (type);
1732
  memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
1733
  return val;
1734
}
1735
 
1736
/* See if we can pass arguments in T2 to a function which takes
1737
   arguments of types T1.  T1 is a list of NARGS arguments, and T2 is
1738
   a NULL-terminated vector.  If some arguments need coercion of some
1739
   sort, then the coerced values are written into T2.  Return value is
1740
 
1741
   differ if not.
1742
 
1743
   STATICP is nonzero if the T1 argument list came from a static
1744
   member function.  T2 will still include the ``this'' pointer, but
1745
   it will be skipped.
1746
 
1747
   For non-static member functions, we ignore the first argument,
1748
   which is the type of the instance variable.  This is because we
1749
   want to handle calls with objects from derived classes.  This is
1750
   not entirely correct: we should actually check to make sure that a
1751
   requested operation is type secure, shouldn't we?  FIXME.  */
1752
 
1753
static int
1754
typecmp (int staticp, int varargs, int nargs,
1755
         struct field t1[], struct value *t2[])
1756
{
1757
  int i;
1758
 
1759
  if (t2 == 0)
1760
    internal_error (__FILE__, __LINE__,
1761
                    _("typecmp: no argument list"));
1762
 
1763
  /* Skip ``this'' argument if applicable.  T2 will always include
1764
     THIS.  */
1765
  if (staticp)
1766
    t2 ++;
1767
 
1768
  for (i = 0;
1769
       (i < nargs) && TYPE_CODE (t1[i].type) != TYPE_CODE_VOID;
1770
       i++)
1771
    {
1772
      struct type *tt1, *tt2;
1773
 
1774
      if (!t2[i])
1775
        return i + 1;
1776
 
1777
      tt1 = check_typedef (t1[i].type);
1778
      tt2 = check_typedef (value_type (t2[i]));
1779
 
1780
      if (TYPE_CODE (tt1) == TYPE_CODE_REF
1781
      /* We should be doing hairy argument matching, as below.  */
1782
          && (TYPE_CODE (check_typedef (TYPE_TARGET_TYPE (tt1))) == TYPE_CODE (tt2)))
1783
        {
1784
          if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
1785
            t2[i] = value_coerce_array (t2[i]);
1786
          else
1787
            t2[i] = value_ref (t2[i]);
1788
          continue;
1789
        }
1790
 
1791
      /* djb - 20000715 - Until the new type structure is in the
1792
         place, and we can attempt things like implicit conversions,
1793
         we need to do this so you can take something like a map<const
1794
         char *>, and properly access map["hello"], because the
1795
         argument to [] will be a reference to a pointer to a char,
1796
         and the argument will be a pointer to a char.  */
1797
      while (TYPE_CODE(tt1) == TYPE_CODE_REF
1798
             || TYPE_CODE (tt1) == TYPE_CODE_PTR)
1799
        {
1800
          tt1 = check_typedef( TYPE_TARGET_TYPE(tt1) );
1801
        }
1802
      while (TYPE_CODE(tt2) == TYPE_CODE_ARRAY
1803
             || TYPE_CODE(tt2) == TYPE_CODE_PTR
1804
             || TYPE_CODE(tt2) == TYPE_CODE_REF)
1805
        {
1806
          tt2 = check_typedef (TYPE_TARGET_TYPE(tt2));
1807
        }
1808
      if (TYPE_CODE (tt1) == TYPE_CODE (tt2))
1809
        continue;
1810
      /* Array to pointer is a `trivial conversion' according to the
1811
         ARM.  */
1812
 
1813
      /* We should be doing much hairier argument matching (see
1814
         section 13.2 of the ARM), but as a quick kludge, just check
1815
         for the same type code.  */
1816
      if (TYPE_CODE (t1[i].type) != TYPE_CODE (value_type (t2[i])))
1817
        return i + 1;
1818
    }
1819
  if (varargs || t2[i] == NULL)
1820
    return 0;
1821
  return i + 1;
1822
}
1823
 
1824
/* Helper function used by value_struct_elt to recurse through
1825
   baseclasses.  Look for a field NAME in ARG1. Adjust the address of
1826
   ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1827
   TYPE.  If found, return value, else return NULL.
1828
 
1829
   If LOOKING_FOR_BASECLASS, then instead of looking for struct
1830
   fields, look for a baseclass named NAME.  */
1831
 
1832
static struct value *
1833
search_struct_field (const char *name, struct value *arg1, int offset,
1834
                     struct type *type, int looking_for_baseclass)
1835
{
1836
  int i;
1837
  int nbases;
1838
 
1839
  CHECK_TYPEDEF (type);
1840
  nbases = TYPE_N_BASECLASSES (type);
1841
 
1842
  if (!looking_for_baseclass)
1843
    for (i = TYPE_NFIELDS (type) - 1; i >= nbases; i--)
1844
      {
1845
        char *t_field_name = TYPE_FIELD_NAME (type, i);
1846
 
1847
        if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
1848
          {
1849
            struct value *v;
1850
 
1851
            if (field_is_static (&TYPE_FIELD (type, i)))
1852
              {
1853
                v = value_static_field (type, i);
1854
                if (v == 0)
1855
                  error (_("field %s is nonexistent or has been optimized out"),
1856
                         name);
1857
              }
1858
            else
1859
              {
1860
                v = value_primitive_field (arg1, offset, i, type);
1861
                if (v == 0)
1862
                  error (_("there is no field named %s"), name);
1863
              }
1864
            return v;
1865
          }
1866
 
1867
        if (t_field_name
1868
            && (t_field_name[0] == '\0'
1869
                || (TYPE_CODE (type) == TYPE_CODE_UNION
1870
                    && (strcmp_iw (t_field_name, "else") == 0))))
1871
          {
1872
            struct type *field_type = TYPE_FIELD_TYPE (type, i);
1873
 
1874
            if (TYPE_CODE (field_type) == TYPE_CODE_UNION
1875
                || TYPE_CODE (field_type) == TYPE_CODE_STRUCT)
1876
              {
1877
                /* Look for a match through the fields of an anonymous
1878
                   union, or anonymous struct.  C++ provides anonymous
1879
                   unions.
1880
 
1881
                   In the GNU Chill (now deleted from GDB)
1882
                   implementation of variant record types, each
1883
                   <alternative field> has an (anonymous) union type,
1884
                   each member of the union represents a <variant
1885
                   alternative>.  Each <variant alternative> is
1886
                   represented as a struct, with a member for each
1887
                   <variant field>.  */
1888
 
1889
                struct value *v;
1890
                int new_offset = offset;
1891
 
1892
                /* This is pretty gross.  In G++, the offset in an
1893
                   anonymous union is relative to the beginning of the
1894
                   enclosing struct.  In the GNU Chill (now deleted
1895
                   from GDB) implementation of variant records, the
1896
                   bitpos is zero in an anonymous union field, so we
1897
                   have to add the offset of the union here.  */
1898
                if (TYPE_CODE (field_type) == TYPE_CODE_STRUCT
1899
                    || (TYPE_NFIELDS (field_type) > 0
1900
                        && TYPE_FIELD_BITPOS (field_type, 0) == 0))
1901
                  new_offset += TYPE_FIELD_BITPOS (type, i) / 8;
1902
 
1903
                v = search_struct_field (name, arg1, new_offset,
1904
                                         field_type,
1905
                                         looking_for_baseclass);
1906
                if (v)
1907
                  return v;
1908
              }
1909
          }
1910
      }
1911
 
1912
  for (i = 0; i < nbases; i++)
1913
    {
1914
      struct value *v;
1915
      struct type *basetype = check_typedef (TYPE_BASECLASS (type, i));
1916
      /* If we are looking for baseclasses, this is what we get when
1917
         we hit them.  But it could happen that the base part's member
1918
         name is not yet filled in.  */
1919
      int found_baseclass = (looking_for_baseclass
1920
                             && TYPE_BASECLASS_NAME (type, i) != NULL
1921
                             && (strcmp_iw (name,
1922
                                            TYPE_BASECLASS_NAME (type,
1923
                                                                 i)) == 0));
1924
 
1925
      if (BASETYPE_VIA_VIRTUAL (type, i))
1926
        {
1927
          int boffset;
1928
          struct value *v2;
1929
 
1930
          boffset = baseclass_offset (type, i,
1931
                                      value_contents (arg1) + offset,
1932
                                      value_address (arg1)
1933
                                      + value_embedded_offset (arg1)
1934
                                      + offset);
1935
          if (boffset == -1)
1936
            error (_("virtual baseclass botch"));
1937
 
1938
          /* The virtual base class pointer might have been clobbered
1939
             by the user program. Make sure that it still points to a
1940
             valid memory location.  */
1941
 
1942
          boffset += value_embedded_offset (arg1) + offset;
1943
          if (boffset < 0
1944
              || boffset >= TYPE_LENGTH (value_enclosing_type (arg1)))
1945
            {
1946
              CORE_ADDR base_addr;
1947
 
1948
              v2  = allocate_value (basetype);
1949
              base_addr = value_address (arg1) + boffset;
1950
              if (target_read_memory (base_addr,
1951
                                      value_contents_raw (v2),
1952
                                      TYPE_LENGTH (basetype)) != 0)
1953
                error (_("virtual baseclass botch"));
1954
              VALUE_LVAL (v2) = lval_memory;
1955
              set_value_address (v2, base_addr);
1956
            }
1957
          else
1958
            {
1959
              v2 = value_copy (arg1);
1960
              deprecated_set_value_type (v2, basetype);
1961
              set_value_embedded_offset (v2, boffset);
1962
            }
1963
 
1964
          if (found_baseclass)
1965
            return v2;
1966
          v = search_struct_field (name, v2, 0,
1967
                                   TYPE_BASECLASS (type, i),
1968
                                   looking_for_baseclass);
1969
        }
1970
      else if (found_baseclass)
1971
        v = value_primitive_field (arg1, offset, i, type);
1972
      else
1973
        v = search_struct_field (name, arg1,
1974
                                 offset + TYPE_BASECLASS_BITPOS (type,
1975
                                                                 i) / 8,
1976
                                 basetype, looking_for_baseclass);
1977
      if (v)
1978
        return v;
1979
    }
1980
  return NULL;
1981
}
1982
 
1983
/* Helper function used by value_struct_elt to recurse through
1984
   baseclasses.  Look for a field NAME in ARG1. Adjust the address of
1985
   ARG1 by OFFSET bytes, and search in it assuming it has (class) type
1986
   TYPE.
1987
 
1988
   If found, return value, else if name matched and args not return
1989
   (value) -1, else return NULL.  */
1990
 
1991
static struct value *
1992
search_struct_method (const char *name, struct value **arg1p,
1993
                      struct value **args, int offset,
1994
                      int *static_memfuncp, struct type *type)
1995
{
1996
  int i;
1997
  struct value *v;
1998
  int name_matched = 0;
1999
  char dem_opname[64];
2000
 
2001
  CHECK_TYPEDEF (type);
2002
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2003
    {
2004
      char *t_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2005
 
2006
      /* FIXME!  May need to check for ARM demangling here */
2007
      if (strncmp (t_field_name, "__", 2) == 0 ||
2008
          strncmp (t_field_name, "op", 2) == 0 ||
2009
          strncmp (t_field_name, "type", 4) == 0)
2010
        {
2011
          if (cplus_demangle_opname (t_field_name, dem_opname, DMGL_ANSI))
2012
            t_field_name = dem_opname;
2013
          else if (cplus_demangle_opname (t_field_name, dem_opname, 0))
2014
            t_field_name = dem_opname;
2015
        }
2016
      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2017
        {
2018
          int j = TYPE_FN_FIELDLIST_LENGTH (type, i) - 1;
2019
          struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2020
 
2021
          name_matched = 1;
2022
          check_stub_method_group (type, i);
2023
          if (j > 0 && args == 0)
2024
            error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
2025
          else if (j == 0 && args == 0)
2026
            {
2027
              v = value_fn_field (arg1p, f, j, type, offset);
2028
              if (v != NULL)
2029
                return v;
2030
            }
2031
          else
2032
            while (j >= 0)
2033
              {
2034
                if (!typecmp (TYPE_FN_FIELD_STATIC_P (f, j),
2035
                              TYPE_VARARGS (TYPE_FN_FIELD_TYPE (f, j)),
2036
                              TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (f, j)),
2037
                              TYPE_FN_FIELD_ARGS (f, j), args))
2038
                  {
2039
                    if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
2040
                      return value_virtual_fn_field (arg1p, f, j,
2041
                                                     type, offset);
2042
                    if (TYPE_FN_FIELD_STATIC_P (f, j)
2043
                        && static_memfuncp)
2044
                      *static_memfuncp = 1;
2045
                    v = value_fn_field (arg1p, f, j, type, offset);
2046
                    if (v != NULL)
2047
                      return v;
2048
                  }
2049
                j--;
2050
              }
2051
        }
2052
    }
2053
 
2054
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2055
    {
2056
      int base_offset;
2057
 
2058
      if (BASETYPE_VIA_VIRTUAL (type, i))
2059
        {
2060
          struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
2061
          const gdb_byte *base_valaddr;
2062
 
2063
          /* The virtual base class pointer might have been
2064
             clobbered by the user program. Make sure that it
2065
            still points to a valid memory location.  */
2066
 
2067
          if (offset < 0 || offset >= TYPE_LENGTH (type))
2068
            {
2069
              gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
2070
 
2071
              if (target_read_memory (value_address (*arg1p) + offset,
2072
                                      tmp, TYPE_LENGTH (baseclass)) != 0)
2073
                error (_("virtual baseclass botch"));
2074
              base_valaddr = tmp;
2075
            }
2076
          else
2077
            base_valaddr = value_contents (*arg1p) + offset;
2078
 
2079
          base_offset = baseclass_offset (type, i, base_valaddr,
2080
                                          value_address (*arg1p) + offset);
2081
          if (base_offset == -1)
2082
            error (_("virtual baseclass botch"));
2083
        }
2084
      else
2085
        {
2086
          base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2087
        }
2088
      v = search_struct_method (name, arg1p, args, base_offset + offset,
2089
                                static_memfuncp, TYPE_BASECLASS (type, i));
2090
      if (v == (struct value *) - 1)
2091
        {
2092
          name_matched = 1;
2093
        }
2094
      else if (v)
2095
        {
2096
          /* FIXME-bothner:  Why is this commented out?  Why is it here?  */
2097
          /* *arg1p = arg1_tmp; */
2098
          return v;
2099
        }
2100
    }
2101
  if (name_matched)
2102
    return (struct value *) - 1;
2103
  else
2104
    return NULL;
2105
}
2106
 
2107
/* Given *ARGP, a value of type (pointer to a)* structure/union,
2108
   extract the component named NAME from the ultimate target
2109
   structure/union and return it as a value with its appropriate type.
2110
   ERR is used in the error message if *ARGP's type is wrong.
2111
 
2112
   C++: ARGS is a list of argument types to aid in the selection of
2113
   an appropriate method. Also, handle derived types.
2114
 
2115
   STATIC_MEMFUNCP, if non-NULL, points to a caller-supplied location
2116
   where the truthvalue of whether the function that was resolved was
2117
   a static member function or not is stored.
2118
 
2119
   ERR is an error message to be printed in case the field is not
2120
   found.  */
2121
 
2122
struct value *
2123
value_struct_elt (struct value **argp, struct value **args,
2124
                  const char *name, int *static_memfuncp, const char *err)
2125
{
2126
  struct type *t;
2127
  struct value *v;
2128
 
2129
  *argp = coerce_array (*argp);
2130
 
2131
  t = check_typedef (value_type (*argp));
2132
 
2133
  /* Follow pointers until we get to a non-pointer.  */
2134
 
2135
  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2136
    {
2137
      *argp = value_ind (*argp);
2138
      /* Don't coerce fn pointer to fn and then back again!  */
2139
      if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2140
        *argp = coerce_array (*argp);
2141
      t = check_typedef (value_type (*argp));
2142
    }
2143
 
2144
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2145
      && TYPE_CODE (t) != TYPE_CODE_UNION)
2146
    error (_("Attempt to extract a component of a value that is not a %s."), err);
2147
 
2148
  /* Assume it's not, unless we see that it is.  */
2149
  if (static_memfuncp)
2150
    *static_memfuncp = 0;
2151
 
2152
  if (!args)
2153
    {
2154
      /* if there are no arguments ...do this...  */
2155
 
2156
      /* Try as a field first, because if we succeed, there is less
2157
         work to be done.  */
2158
      v = search_struct_field (name, *argp, 0, t, 0);
2159
      if (v)
2160
        return v;
2161
 
2162
      /* C++: If it was not found as a data field, then try to
2163
         return it as a pointer to a method.  */
2164
      v = search_struct_method (name, argp, args, 0,
2165
                                static_memfuncp, t);
2166
 
2167
      if (v == (struct value *) - 1)
2168
        error (_("Cannot take address of method %s."), name);
2169
      else if (v == 0)
2170
        {
2171
          if (TYPE_NFN_FIELDS (t))
2172
            error (_("There is no member or method named %s."), name);
2173
          else
2174
            error (_("There is no member named %s."), name);
2175
        }
2176
      return v;
2177
    }
2178
 
2179
    v = search_struct_method (name, argp, args, 0,
2180
                              static_memfuncp, t);
2181
 
2182
  if (v == (struct value *) - 1)
2183
    {
2184
      error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
2185
    }
2186
  else if (v == 0)
2187
    {
2188
      /* See if user tried to invoke data as function.  If so, hand it
2189
         back.  If it's not callable (i.e., a pointer to function),
2190
         gdb should give an error.  */
2191
      v = search_struct_field (name, *argp, 0, t, 0);
2192
      /* If we found an ordinary field, then it is not a method call.
2193
         So, treat it as if it were a static member function.  */
2194
      if (v && static_memfuncp)
2195
        *static_memfuncp = 1;
2196
    }
2197
 
2198
  if (!v)
2199
    error (_("Structure has no component named %s."), name);
2200
  return v;
2201
}
2202
 
2203
/* Search through the methods of an object (and its bases) to find a
2204
   specified method.  Return the pointer to the fn_field list of
2205
   overloaded instances.
2206
 
2207
   Helper function for value_find_oload_list.
2208
   ARGP is a pointer to a pointer to a value (the object).
2209
   METHOD is a string containing the method name.
2210
   OFFSET is the offset within the value.
2211
   TYPE is the assumed type of the object.
2212
   NUM_FNS is the number of overloaded instances.
2213
   BASETYPE is set to the actual type of the subobject where the
2214
      method is found.
2215
   BOFFSET is the offset of the base subobject where the method is found.
2216
*/
2217
 
2218
static struct fn_field *
2219
find_method_list (struct value **argp, const char *method,
2220
                  int offset, struct type *type, int *num_fns,
2221
                  struct type **basetype, int *boffset)
2222
{
2223
  int i;
2224
  struct fn_field *f;
2225
  CHECK_TYPEDEF (type);
2226
 
2227
  *num_fns = 0;
2228
 
2229
  /* First check in object itself.  */
2230
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; i--)
2231
    {
2232
      /* pai: FIXME What about operators and type conversions?  */
2233
      char *fn_field_name = TYPE_FN_FIELDLIST_NAME (type, i);
2234
 
2235
      if (fn_field_name && (strcmp_iw (fn_field_name, method) == 0))
2236
        {
2237
          int len = TYPE_FN_FIELDLIST_LENGTH (type, i);
2238
          struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
2239
 
2240
          *num_fns = len;
2241
          *basetype = type;
2242
          *boffset = offset;
2243
 
2244
          /* Resolve any stub methods.  */
2245
          check_stub_method_group (type, i);
2246
 
2247
          return f;
2248
        }
2249
    }
2250
 
2251
  /* Not found in object, check in base subobjects.  */
2252
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2253
    {
2254
      int base_offset;
2255
 
2256
      if (BASETYPE_VIA_VIRTUAL (type, i))
2257
        {
2258
          base_offset = value_offset (*argp) + offset;
2259
          base_offset = baseclass_offset (type, i,
2260
                                          value_contents (*argp) + base_offset,
2261
                                          value_address (*argp) + base_offset);
2262
          if (base_offset == -1)
2263
            error (_("virtual baseclass botch"));
2264
        }
2265
      else /* Non-virtual base, simply use bit position from debug
2266
              info.  */
2267
        {
2268
          base_offset = TYPE_BASECLASS_BITPOS (type, i) / 8;
2269
        }
2270
      f = find_method_list (argp, method, base_offset + offset,
2271
                            TYPE_BASECLASS (type, i), num_fns,
2272
                            basetype, boffset);
2273
      if (f)
2274
        return f;
2275
    }
2276
  return NULL;
2277
}
2278
 
2279
/* Return the list of overloaded methods of a specified name.
2280
 
2281
   ARGP is a pointer to a pointer to a value (the object).
2282
   METHOD is the method name.
2283
   OFFSET is the offset within the value contents.
2284
   NUM_FNS is the number of overloaded instances.
2285
   BASETYPE is set to the type of the base subobject that defines the
2286
      method.
2287
   BOFFSET is the offset of the base subobject which defines the method.
2288
*/
2289
 
2290
struct fn_field *
2291
value_find_oload_method_list (struct value **argp, const char *method,
2292
                              int offset, int *num_fns,
2293
                              struct type **basetype, int *boffset)
2294
{
2295
  struct type *t;
2296
 
2297
  t = check_typedef (value_type (*argp));
2298
 
2299
  /* Code snarfed from value_struct_elt.  */
2300
  while (TYPE_CODE (t) == TYPE_CODE_PTR || TYPE_CODE (t) == TYPE_CODE_REF)
2301
    {
2302
      *argp = value_ind (*argp);
2303
      /* Don't coerce fn pointer to fn and then back again!  */
2304
      if (TYPE_CODE (value_type (*argp)) != TYPE_CODE_FUNC)
2305
        *argp = coerce_array (*argp);
2306
      t = check_typedef (value_type (*argp));
2307
    }
2308
 
2309
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
2310
      && TYPE_CODE (t) != TYPE_CODE_UNION)
2311
    error (_("Attempt to extract a component of a value that is not a struct or union"));
2312
 
2313
  return find_method_list (argp, method, 0, t, num_fns,
2314
                           basetype, boffset);
2315
}
2316
 
2317
/* Given an array of argument types (ARGTYPES) (which includes an
2318
   entry for "this" in the case of C++ methods), the number of
2319
   arguments NARGS, the NAME of a function whether it's a method or
2320
   not (METHOD), and the degree of laxness (LAX) in conforming to
2321
   overload resolution rules in ANSI C++, find the best function that
2322
   matches on the argument types according to the overload resolution
2323
   rules.
2324
 
2325
   METHOD can be one of three values:
2326
     NON_METHOD for non-member functions.
2327
     METHOD: for member functions.
2328
     BOTH: used for overload resolution of operators where the
2329
       candidates are expected to be either member or non member
2330
       functions. In this case the first argument ARGTYPES
2331
       (representing 'this') is expected to be a reference to the
2332
       target object, and will be dereferenced when attempting the
2333
       non-member search.
2334
 
2335
   In the case of class methods, the parameter OBJ is an object value
2336
   in which to search for overloaded methods.
2337
 
2338
   In the case of non-method functions, the parameter FSYM is a symbol
2339
   corresponding to one of the overloaded functions.
2340
 
2341
   Return value is an integer: 0 -> good match, 10 -> debugger applied
2342
   non-standard coercions, 100 -> incompatible.
2343
 
2344
   If a method is being searched for, VALP will hold the value.
2345
   If a non-method is being searched for, SYMP will hold the symbol
2346
   for it.
2347
 
2348
   If a method is being searched for, and it is a static method,
2349
   then STATICP will point to a non-zero value.
2350
 
2351
   If NO_ADL argument dependent lookup is disabled.  This is used to prevent
2352
   ADL overload candidates when performing overload resolution for a fully
2353
   qualified name.
2354
 
2355
   Note: This function does *not* check the value of
2356
   overload_resolution.  Caller must check it to see whether overload
2357
   resolution is permitted.
2358
*/
2359
 
2360
int
2361
find_overload_match (struct type **arg_types, int nargs,
2362
                     const char *name, enum oload_search_type method,
2363
                     int lax, struct value **objp, struct symbol *fsym,
2364
                     struct value **valp, struct symbol **symp,
2365
                     int *staticp, const int no_adl)
2366
{
2367
  struct value *obj = (objp ? *objp : NULL);
2368
  /* Index of best overloaded function.  */
2369
  int func_oload_champ = -1;
2370
  int method_oload_champ = -1;
2371
 
2372
  /* The measure for the current best match.  */
2373
  struct badness_vector *method_badness = NULL;
2374
  struct badness_vector *func_badness = NULL;
2375
 
2376
  struct value *temp = obj;
2377
  /* For methods, the list of overloaded methods.  */
2378
  struct fn_field *fns_ptr = NULL;
2379
  /* For non-methods, the list of overloaded function symbols.  */
2380
  struct symbol **oload_syms = NULL;
2381
  /* Number of overloaded instances being considered.  */
2382
  int num_fns = 0;
2383
  struct type *basetype = NULL;
2384
  int boffset;
2385
 
2386
  struct cleanup *all_cleanups = make_cleanup (null_cleanup, NULL);
2387
 
2388
  const char *obj_type_name = NULL;
2389
  const char *func_name = NULL;
2390
  enum oload_classification match_quality;
2391
  enum oload_classification method_match_quality = INCOMPATIBLE;
2392
  enum oload_classification func_match_quality = INCOMPATIBLE;
2393
 
2394
  /* Get the list of overloaded methods or functions.  */
2395
  if (method == METHOD || method == BOTH)
2396
    {
2397
      gdb_assert (obj);
2398
 
2399
      /* OBJ may be a pointer value rather than the object itself.  */
2400
      obj = coerce_ref (obj);
2401
      while (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_PTR)
2402
        obj = coerce_ref (value_ind (obj));
2403
      obj_type_name = TYPE_NAME (value_type (obj));
2404
 
2405
      /* First check whether this is a data member, e.g. a pointer to
2406
         a function.  */
2407
      if (TYPE_CODE (check_typedef (value_type (obj))) == TYPE_CODE_STRUCT)
2408
        {
2409
          *valp = search_struct_field (name, obj, 0,
2410
                                       check_typedef (value_type (obj)), 0);
2411
          if (*valp)
2412
            {
2413
              *staticp = 1;
2414
              return 0;
2415
            }
2416
        }
2417
 
2418
      /* Retrieve the list of methods with the name NAME.  */
2419
      fns_ptr = value_find_oload_method_list (&temp, name,
2420
                                              0, &num_fns,
2421
                                              &basetype, &boffset);
2422
      /* If this is a method only search, and no methods were found
2423
         the search has faild.  */
2424
      if (method == METHOD && (!fns_ptr || !num_fns))
2425
        error (_("Couldn't find method %s%s%s"),
2426
               obj_type_name,
2427
               (obj_type_name && *obj_type_name) ? "::" : "",
2428
               name);
2429
      /* If we are dealing with stub method types, they should have
2430
         been resolved by find_method_list via
2431
         value_find_oload_method_list above.  */
2432
      if (fns_ptr)
2433
        {
2434
          gdb_assert (TYPE_DOMAIN_TYPE (fns_ptr[0].type) != NULL);
2435
          method_oload_champ = find_oload_champ (arg_types, nargs, method,
2436
                                                 num_fns, fns_ptr,
2437
                                                 oload_syms, &method_badness);
2438
 
2439
          method_match_quality =
2440
              classify_oload_match (method_badness, nargs,
2441
                                    oload_method_static (method, fns_ptr,
2442
                                                         method_oload_champ));
2443
 
2444
          make_cleanup (xfree, method_badness);
2445
        }
2446
 
2447
    }
2448
 
2449
  if (method == NON_METHOD || method == BOTH)
2450
    {
2451
      const char *qualified_name = NULL;
2452
 
2453
      /* If the the overload match is being search for both
2454
         as a method and non member function, the first argument
2455
         must now be dereferenced.  */
2456
      if (method == BOTH)
2457
        arg_types[0] = TYPE_TARGET_TYPE (arg_types[0]);
2458
 
2459
      if (fsym)
2460
        {
2461
          qualified_name = SYMBOL_NATURAL_NAME (fsym);
2462
 
2463
          /* If we have a function with a C++ name, try to extract just
2464
             the function part.  Do not try this for non-functions (e.g.
2465
             function pointers).  */
2466
          if (qualified_name
2467
              && TYPE_CODE (check_typedef (SYMBOL_TYPE (fsym))) == TYPE_CODE_FUNC)
2468
            {
2469
              char *temp;
2470
 
2471
              temp = cp_func_name (qualified_name);
2472
 
2473
              /* If cp_func_name did not remove anything, the name of the
2474
                 symbol did not include scope or argument types - it was
2475
                 probably a C-style function.  */
2476
              if (temp)
2477
                {
2478
                  make_cleanup (xfree, temp);
2479
                  if (strcmp (temp, qualified_name) == 0)
2480
                    func_name = NULL;
2481
                  else
2482
                    func_name = temp;
2483
                }
2484
            }
2485
        }
2486
      else
2487
        {
2488
          func_name = name;
2489
          qualified_name = name;
2490
        }
2491
 
2492
      /* If there was no C++ name, this must be a C-style function or
2493
         not a function at all.  Just return the same symbol.  Do the
2494
         same if cp_func_name fails for some reason.  */
2495
      if (func_name == NULL)
2496
        {
2497
          *symp = fsym;
2498
          return 0;
2499
        }
2500
 
2501
      func_oload_champ = find_oload_champ_namespace (arg_types, nargs,
2502
                                                     func_name,
2503
                                                     qualified_name,
2504
                                                     &oload_syms,
2505
                                                     &func_badness,
2506
                                                     no_adl);
2507
 
2508
      if (func_oload_champ >= 0)
2509
        func_match_quality = classify_oload_match (func_badness, nargs, 0);
2510
 
2511
      make_cleanup (xfree, oload_syms);
2512
      make_cleanup (xfree, func_badness);
2513
    }
2514
 
2515
  /* Did we find a match ?  */
2516
  if (method_oload_champ == -1 && func_oload_champ == -1)
2517
    error (_("No symbol \"%s\" in current context."), name);
2518
 
2519
  /* If we have found both a method match and a function
2520
     match, find out which one is better, and calculate match
2521
     quality.  */
2522
  if (method_oload_champ >= 0 && func_oload_champ >= 0)
2523
    {
2524
      switch (compare_badness (func_badness, method_badness))
2525
        {
2526
          case 0: /* Top two contenders are equally good.  */
2527
            /* FIXME: GDB does not support the general ambiguous
2528
             case.  All candidates should be collected and presented
2529
             the the user.  */
2530
            error (_("Ambiguous overload resolution"));
2531
            break;
2532
          case 1: /* Incomparable top contenders.  */
2533
            /* This is an error incompatible candidates
2534
               should not have been proposed.  */
2535
            error (_("Internal error: incompatible overload candidates proposed"));
2536
            break;
2537
          case 2: /* Function champion.  */
2538
            method_oload_champ = -1;
2539
            match_quality = func_match_quality;
2540
            break;
2541
          case 3: /* Method champion.  */
2542
            func_oload_champ = -1;
2543
            match_quality = method_match_quality;
2544
            break;
2545
          default:
2546
            error (_("Internal error: unexpected overload comparison result"));
2547
            break;
2548
        }
2549
    }
2550
  else
2551
    {
2552
      /* We have either a method match or a function match.  */
2553
      if (method_oload_champ >= 0)
2554
        match_quality = method_match_quality;
2555
      else
2556
        match_quality = func_match_quality;
2557
    }
2558
 
2559
  if (match_quality == INCOMPATIBLE)
2560
    {
2561
      if (method == METHOD)
2562
        error (_("Cannot resolve method %s%s%s to any overloaded instance"),
2563
               obj_type_name,
2564
               (obj_type_name && *obj_type_name) ? "::" : "",
2565
               name);
2566
      else
2567
        error (_("Cannot resolve function %s to any overloaded instance"),
2568
               func_name);
2569
    }
2570
  else if (match_quality == NON_STANDARD)
2571
    {
2572
      if (method == METHOD)
2573
        warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
2574
                 obj_type_name,
2575
                 (obj_type_name && *obj_type_name) ? "::" : "",
2576
                 name);
2577
      else
2578
        warning (_("Using non-standard conversion to match function %s to supplied arguments"),
2579
                 func_name);
2580
    }
2581
 
2582
  if (staticp != NULL)
2583
    *staticp = oload_method_static (method, fns_ptr, method_oload_champ);
2584
 
2585
  if (method_oload_champ >= 0)
2586
    {
2587
      if (TYPE_FN_FIELD_VIRTUAL_P (fns_ptr, method_oload_champ))
2588
        *valp = value_virtual_fn_field (&temp, fns_ptr, method_oload_champ,
2589
                                        basetype, boffset);
2590
      else
2591
        *valp = value_fn_field (&temp, fns_ptr, method_oload_champ,
2592
                                basetype, boffset);
2593
    }
2594
  else
2595
    *symp = oload_syms[func_oload_champ];
2596
 
2597
  if (objp)
2598
    {
2599
      struct type *temp_type = check_typedef (value_type (temp));
2600
      struct type *obj_type = check_typedef (value_type (*objp));
2601
 
2602
      if (TYPE_CODE (temp_type) != TYPE_CODE_PTR
2603
          && (TYPE_CODE (obj_type) == TYPE_CODE_PTR
2604
              || TYPE_CODE (obj_type) == TYPE_CODE_REF))
2605
        {
2606
          temp = value_addr (temp);
2607
        }
2608
      *objp = temp;
2609
    }
2610
 
2611
  do_cleanups (all_cleanups);
2612
 
2613
  switch (match_quality)
2614
    {
2615
    case INCOMPATIBLE:
2616
      return 100;
2617
    case NON_STANDARD:
2618
      return 10;
2619
    default:                            /* STANDARD */
2620
      return 0;
2621
    }
2622
}
2623
 
2624
/* Find the best overload match, searching for FUNC_NAME in namespaces
2625
   contained in QUALIFIED_NAME until it either finds a good match or
2626
   runs out of namespaces.  It stores the overloaded functions in
2627
   *OLOAD_SYMS, and the badness vector in *OLOAD_CHAMP_BV.  The
2628
   calling function is responsible for freeing *OLOAD_SYMS and
2629
   *OLOAD_CHAMP_BV.  If NO_ADL, argument dependent lookup is not
2630
   performned.  */
2631
 
2632
static int
2633
find_oload_champ_namespace (struct type **arg_types, int nargs,
2634
                            const char *func_name,
2635
                            const char *qualified_name,
2636
                            struct symbol ***oload_syms,
2637
                            struct badness_vector **oload_champ_bv,
2638
                            const int no_adl)
2639
{
2640
  int oload_champ;
2641
 
2642
  find_oload_champ_namespace_loop (arg_types, nargs,
2643
                                   func_name,
2644
                                   qualified_name, 0,
2645
                                   oload_syms, oload_champ_bv,
2646
                                   &oload_champ,
2647
                                   no_adl);
2648
 
2649
  return oload_champ;
2650
}
2651
 
2652
/* Helper function for find_oload_champ_namespace; NAMESPACE_LEN is
2653
   how deep we've looked for namespaces, and the champ is stored in
2654
   OLOAD_CHAMP.  The return value is 1 if the champ is a good one, 0
2655
   if it isn't.  Other arguments are the same as in
2656
   find_oload_champ_namespace
2657
 
2658
   It is the caller's responsibility to free *OLOAD_SYMS and
2659
   *OLOAD_CHAMP_BV.  */
2660
 
2661
static int
2662
find_oload_champ_namespace_loop (struct type **arg_types, int nargs,
2663
                                 const char *func_name,
2664
                                 const char *qualified_name,
2665
                                 int namespace_len,
2666
                                 struct symbol ***oload_syms,
2667
                                 struct badness_vector **oload_champ_bv,
2668
                                 int *oload_champ,
2669
                                 const int no_adl)
2670
{
2671
  int next_namespace_len = namespace_len;
2672
  int searched_deeper = 0;
2673
  int num_fns = 0;
2674
  struct cleanup *old_cleanups;
2675
  int new_oload_champ;
2676
  struct symbol **new_oload_syms;
2677
  struct badness_vector *new_oload_champ_bv;
2678
  char *new_namespace;
2679
 
2680
  if (next_namespace_len != 0)
2681
    {
2682
      gdb_assert (qualified_name[next_namespace_len] == ':');
2683
      next_namespace_len +=  2;
2684
    }
2685
  next_namespace_len +=
2686
    cp_find_first_component (qualified_name + next_namespace_len);
2687
 
2688
  /* Initialize these to values that can safely be xfree'd.  */
2689
  *oload_syms = NULL;
2690
  *oload_champ_bv = NULL;
2691
 
2692
  /* First, see if we have a deeper namespace we can search in.
2693
     If we get a good match there, use it.  */
2694
 
2695
  if (qualified_name[next_namespace_len] == ':')
2696
    {
2697
      searched_deeper = 1;
2698
 
2699
      if (find_oload_champ_namespace_loop (arg_types, nargs,
2700
                                           func_name, qualified_name,
2701
                                           next_namespace_len,
2702
                                           oload_syms, oload_champ_bv,
2703
                                           oload_champ, no_adl))
2704
        {
2705
          return 1;
2706
        }
2707
    };
2708
 
2709
  /* If we reach here, either we're in the deepest namespace or we
2710
     didn't find a good match in a deeper namespace.  But, in the
2711
     latter case, we still have a bad match in a deeper namespace;
2712
     note that we might not find any match at all in the current
2713
     namespace.  (There's always a match in the deepest namespace,
2714
     because this overload mechanism only gets called if there's a
2715
     function symbol to start off with.)  */
2716
 
2717
  old_cleanups = make_cleanup (xfree, *oload_syms);
2718
  old_cleanups = make_cleanup (xfree, *oload_champ_bv);
2719
  new_namespace = alloca (namespace_len + 1);
2720
  strncpy (new_namespace, qualified_name, namespace_len);
2721
  new_namespace[namespace_len] = '\0';
2722
  new_oload_syms = make_symbol_overload_list (func_name,
2723
                                              new_namespace);
2724
 
2725
  /* If we have reached the deepest level perform argument
2726
     determined lookup.  */
2727
  if (!searched_deeper && !no_adl)
2728
    make_symbol_overload_list_adl (arg_types, nargs, func_name);
2729
 
2730
  while (new_oload_syms[num_fns])
2731
    ++num_fns;
2732
 
2733
  new_oload_champ = find_oload_champ (arg_types, nargs, 0, num_fns,
2734
                                      NULL, new_oload_syms,
2735
                                      &new_oload_champ_bv);
2736
 
2737
  /* Case 1: We found a good match.  Free earlier matches (if any),
2738
     and return it.  Case 2: We didn't find a good match, but we're
2739
     not the deepest function.  Then go with the bad match that the
2740
     deeper function found.  Case 3: We found a bad match, and we're
2741
     the deepest function.  Then return what we found, even though
2742
     it's a bad match.  */
2743
 
2744
  if (new_oload_champ != -1
2745
      && classify_oload_match (new_oload_champ_bv, nargs, 0) == STANDARD)
2746
    {
2747
      *oload_syms = new_oload_syms;
2748
      *oload_champ = new_oload_champ;
2749
      *oload_champ_bv = new_oload_champ_bv;
2750
      do_cleanups (old_cleanups);
2751
      return 1;
2752
    }
2753
  else if (searched_deeper)
2754
    {
2755
      xfree (new_oload_syms);
2756
      xfree (new_oload_champ_bv);
2757
      discard_cleanups (old_cleanups);
2758
      return 0;
2759
    }
2760
  else
2761
    {
2762
      *oload_syms = new_oload_syms;
2763
      *oload_champ = new_oload_champ;
2764
      *oload_champ_bv = new_oload_champ_bv;
2765
      discard_cleanups (old_cleanups);
2766
      return 0;
2767
    }
2768
}
2769
 
2770
/* Look for a function to take NARGS args of types ARG_TYPES.  Find
2771
   the best match from among the overloaded methods or functions
2772
   (depending on METHOD) given by FNS_PTR or OLOAD_SYMS, respectively.
2773
   The number of methods/functions in the list is given by NUM_FNS.
2774
   Return the index of the best match; store an indication of the
2775
   quality of the match in OLOAD_CHAMP_BV.
2776
 
2777
   It is the caller's responsibility to free *OLOAD_CHAMP_BV.  */
2778
 
2779
static int
2780
find_oload_champ (struct type **arg_types, int nargs, int method,
2781
                  int num_fns, struct fn_field *fns_ptr,
2782
                  struct symbol **oload_syms,
2783
                  struct badness_vector **oload_champ_bv)
2784
{
2785
  int ix;
2786
  /* A measure of how good an overloaded instance is.  */
2787
  struct badness_vector *bv;
2788
  /* Index of best overloaded function.  */
2789
  int oload_champ = -1;
2790
  /* Current ambiguity state for overload resolution.  */
2791
  int oload_ambiguous = 0;
2792
  /* 0 => no ambiguity, 1 => two good funcs, 2 => incomparable funcs.  */
2793
 
2794
  *oload_champ_bv = NULL;
2795
 
2796
  /* Consider each candidate in turn.  */
2797
  for (ix = 0; ix < num_fns; ix++)
2798
    {
2799
      int jj;
2800
      int static_offset = oload_method_static (method, fns_ptr, ix);
2801
      int nparms;
2802
      struct type **parm_types;
2803
 
2804
      if (method)
2805
        {
2806
          nparms = TYPE_NFIELDS (TYPE_FN_FIELD_TYPE (fns_ptr, ix));
2807
        }
2808
      else
2809
        {
2810
          /* If it's not a method, this is the proper place.  */
2811
          nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
2812
        }
2813
 
2814
      /* Prepare array of parameter types.  */
2815
      parm_types = (struct type **)
2816
        xmalloc (nparms * (sizeof (struct type *)));
2817
      for (jj = 0; jj < nparms; jj++)
2818
        parm_types[jj] = (method
2819
                          ? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
2820
                          : TYPE_FIELD_TYPE (SYMBOL_TYPE (oload_syms[ix]),
2821
                                             jj));
2822
 
2823
      /* Compare parameter types to supplied argument types.  Skip
2824
         THIS for static methods.  */
2825
      bv = rank_function (parm_types, nparms,
2826
                          arg_types + static_offset,
2827
                          nargs - static_offset);
2828
 
2829
      if (!*oload_champ_bv)
2830
        {
2831
          *oload_champ_bv = bv;
2832
          oload_champ = 0;
2833
        }
2834
      else /* See whether current candidate is better or worse than
2835
              previous best.  */
2836
        switch (compare_badness (bv, *oload_champ_bv))
2837
          {
2838
          case 0:                /* Top two contenders are equally good.  */
2839
            oload_ambiguous = 1;
2840
            break;
2841
          case 1:               /* Incomparable top contenders.  */
2842
            oload_ambiguous = 2;
2843
            break;
2844
          case 2:               /* New champion, record details.  */
2845
            *oload_champ_bv = bv;
2846
            oload_ambiguous = 0;
2847
            oload_champ = ix;
2848
            break;
2849
          case 3:
2850
          default:
2851
            break;
2852
          }
2853
      xfree (parm_types);
2854
      if (overload_debug)
2855
        {
2856
          if (method)
2857
            fprintf_filtered (gdb_stderr,
2858
                              "Overloaded method instance %s, # of parms %d\n",
2859
                              fns_ptr[ix].physname, nparms);
2860
          else
2861
            fprintf_filtered (gdb_stderr,
2862
                              "Overloaded function instance %s # of parms %d\n",
2863
                              SYMBOL_DEMANGLED_NAME (oload_syms[ix]),
2864
                              nparms);
2865
          for (jj = 0; jj < nargs - static_offset; jj++)
2866
            fprintf_filtered (gdb_stderr,
2867
                              "...Badness @ %d : %d\n",
2868
                              jj, bv->rank[jj]);
2869
          fprintf_filtered (gdb_stderr,
2870
                            "Overload resolution champion is %d, ambiguous? %d\n",
2871
                            oload_champ, oload_ambiguous);
2872
        }
2873
    }
2874
 
2875
  return oload_champ;
2876
}
2877
 
2878
/* Return 1 if we're looking at a static method, 0 if we're looking at
2879
   a non-static method or a function that isn't a method.  */
2880
 
2881
static int
2882
oload_method_static (int method, struct fn_field *fns_ptr, int index)
2883
{
2884
  if (method && fns_ptr && index >= 0
2885
      && TYPE_FN_FIELD_STATIC_P (fns_ptr, index))
2886
    return 1;
2887
  else
2888
    return 0;
2889
}
2890
 
2891
/* Check how good an overload match OLOAD_CHAMP_BV represents.  */
2892
 
2893
static enum oload_classification
2894
classify_oload_match (struct badness_vector *oload_champ_bv,
2895
                      int nargs,
2896
                      int static_offset)
2897
{
2898
  int ix;
2899
 
2900
  for (ix = 1; ix <= nargs - static_offset; ix++)
2901
    {
2902
      if (oload_champ_bv->rank[ix] >= 100)
2903
        return INCOMPATIBLE;    /* Truly mismatched types.  */
2904
      else if (oload_champ_bv->rank[ix] >= 10)
2905
        return NON_STANDARD;    /* Non-standard type conversions
2906
                                   needed.  */
2907
    }
2908
 
2909
  return STANDARD;              /* Only standard conversions needed.  */
2910
}
2911
 
2912
/* C++: return 1 is NAME is a legitimate name for the destructor of
2913
   type TYPE.  If TYPE does not have a destructor, or if NAME is
2914
   inappropriate for TYPE, an error is signaled.  */
2915
int
2916
destructor_name_p (const char *name, const struct type *type)
2917
{
2918
  if (name[0] == '~')
2919
    {
2920
      char *dname = type_name_no_tag (type);
2921
      char *cp = strchr (dname, '<');
2922
      unsigned int len;
2923
 
2924
      /* Do not compare the template part for template classes.  */
2925
      if (cp == NULL)
2926
        len = strlen (dname);
2927
      else
2928
        len = cp - dname;
2929
      if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
2930
        error (_("name of destructor must equal name of class"));
2931
      else
2932
        return 1;
2933
    }
2934
  return 0;
2935
}
2936
 
2937
/* Given TYPE, a structure/union,
2938
   return 1 if the component named NAME from the ultimate target
2939
   structure/union is defined, otherwise, return 0.  */
2940
 
2941
int
2942
check_field (struct type *type, const char *name)
2943
{
2944
  int i;
2945
 
2946
  /* The type may be a stub.  */
2947
  CHECK_TYPEDEF (type);
2948
 
2949
  for (i = TYPE_NFIELDS (type) - 1; i >= TYPE_N_BASECLASSES (type); i--)
2950
    {
2951
      char *t_field_name = TYPE_FIELD_NAME (type, i);
2952
 
2953
      if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
2954
        return 1;
2955
    }
2956
 
2957
  /* C++: If it was not found as a data field, then try to return it
2958
     as a pointer to a method.  */
2959
 
2960
  for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
2961
    {
2962
      if (strcmp_iw (TYPE_FN_FIELDLIST_NAME (type, i), name) == 0)
2963
        return 1;
2964
    }
2965
 
2966
  for (i = TYPE_N_BASECLASSES (type) - 1; i >= 0; i--)
2967
    if (check_field (TYPE_BASECLASS (type, i), name))
2968
      return 1;
2969
 
2970
  return 0;
2971
}
2972
 
2973
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
2974
   return the appropriate member (or the address of the member, if
2975
   WANT_ADDRESS).  This function is used to resolve user expressions
2976
   of the form "DOMAIN::NAME".  For more details on what happens, see
2977
   the comment before value_struct_elt_for_reference.  */
2978
 
2979
struct value *
2980
value_aggregate_elt (struct type *curtype, char *name,
2981
                     struct type *expect_type, int want_address,
2982
                     enum noside noside)
2983
{
2984
  switch (TYPE_CODE (curtype))
2985
    {
2986
    case TYPE_CODE_STRUCT:
2987
    case TYPE_CODE_UNION:
2988
      return value_struct_elt_for_reference (curtype, 0, curtype,
2989
                                             name, expect_type,
2990
                                             want_address, noside);
2991
    case TYPE_CODE_NAMESPACE:
2992
      return value_namespace_elt (curtype, name,
2993
                                  want_address, noside);
2994
    default:
2995
      internal_error (__FILE__, __LINE__,
2996
                      _("non-aggregate type in value_aggregate_elt"));
2997
    }
2998
}
2999
 
3000
/* Compares the two method/function types T1 and T2 for "equality"
3001
   with respect to the the methods' parameters.  If the types of the
3002
   two parameter lists are the same, returns 1; 0 otherwise.  This
3003
   comparison may ignore any artificial parameters in T1 if
3004
   SKIP_ARTIFICIAL is non-zero.  This function will ALWAYS skip
3005
   the first artificial parameter in T1, assumed to be a 'this' pointer.
3006
 
3007
   The type T2 is expected to have come from make_params (in eval.c).  */
3008
 
3009
static int
3010
compare_parameters (struct type *t1, struct type *t2, int skip_artificial)
3011
{
3012
  int start = 0;
3013
 
3014
  if (TYPE_FIELD_ARTIFICIAL (t1, 0))
3015
    ++start;
3016
 
3017
  /* If skipping artificial fields, find the first real field
3018
     in T1. */
3019
  if (skip_artificial)
3020
    {
3021
      while (start < TYPE_NFIELDS (t1)
3022
             && TYPE_FIELD_ARTIFICIAL (t1, start))
3023
        ++start;
3024
    }
3025
 
3026
  /* Now compare parameters */
3027
 
3028
  /* Special case: a method taking void.  T1 will contain no
3029
     non-artificial fields, and T2 will contain TYPE_CODE_VOID.  */
3030
  if ((TYPE_NFIELDS (t1) - start) == 0 && TYPE_NFIELDS (t2) == 1
3031
      && TYPE_CODE (TYPE_FIELD_TYPE (t2, 0)) == TYPE_CODE_VOID)
3032
    return 1;
3033
 
3034
  if ((TYPE_NFIELDS (t1) - start) == TYPE_NFIELDS (t2))
3035
    {
3036
      int i;
3037
 
3038
      for (i = 0; i < TYPE_NFIELDS (t2); ++i)
3039
        {
3040
          if (rank_one_type (TYPE_FIELD_TYPE (t1, start + i),
3041
                              TYPE_FIELD_TYPE (t2, i))
3042
              != 0)
3043
            return 0;
3044
        }
3045
 
3046
      return 1;
3047
    }
3048
 
3049
  return 0;
3050
}
3051
 
3052
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
3053
   return the address of this member as a "pointer to member" type.
3054
   If INTYPE is non-null, then it will be the type of the member we
3055
   are looking for.  This will help us resolve "pointers to member
3056
   functions".  This function is used to resolve user expressions of
3057
   the form "DOMAIN::NAME".  */
3058
 
3059
static struct value *
3060
value_struct_elt_for_reference (struct type *domain, int offset,
3061
                                struct type *curtype, char *name,
3062
                                struct type *intype,
3063
                                int want_address,
3064
                                enum noside noside)
3065
{
3066
  struct type *t = curtype;
3067
  int i;
3068
  struct value *v, *result;
3069
 
3070
  if (TYPE_CODE (t) != TYPE_CODE_STRUCT
3071
      && TYPE_CODE (t) != TYPE_CODE_UNION)
3072
    error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
3073
 
3074
  for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
3075
    {
3076
      char *t_field_name = TYPE_FIELD_NAME (t, i);
3077
 
3078
      if (t_field_name && strcmp (t_field_name, name) == 0)
3079
        {
3080
          if (field_is_static (&TYPE_FIELD (t, i)))
3081
            {
3082
              v = value_static_field (t, i);
3083
              if (v == NULL)
3084
                error (_("static field %s has been optimized out"),
3085
                       name);
3086
              if (want_address)
3087
                v = value_addr (v);
3088
              return v;
3089
            }
3090
          if (TYPE_FIELD_PACKED (t, i))
3091
            error (_("pointers to bitfield members not allowed"));
3092
 
3093
          if (want_address)
3094
            return value_from_longest
3095
              (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
3096
               offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
3097
          else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3098
            return allocate_value (TYPE_FIELD_TYPE (t, i));
3099
          else
3100
            error (_("Cannot reference non-static field \"%s\""), name);
3101
        }
3102
    }
3103
 
3104
  /* C++: If it was not found as a data field, then try to return it
3105
     as a pointer to a method.  */
3106
 
3107
  /* Perform all necessary dereferencing.  */
3108
  while (intype && TYPE_CODE (intype) == TYPE_CODE_PTR)
3109
    intype = TYPE_TARGET_TYPE (intype);
3110
 
3111
  for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; --i)
3112
    {
3113
      char *t_field_name = TYPE_FN_FIELDLIST_NAME (t, i);
3114
      char dem_opname[64];
3115
 
3116
      if (strncmp (t_field_name, "__", 2) == 0
3117
          || strncmp (t_field_name, "op", 2) == 0
3118
          || strncmp (t_field_name, "type", 4) == 0)
3119
        {
3120
          if (cplus_demangle_opname (t_field_name,
3121
                                     dem_opname, DMGL_ANSI))
3122
            t_field_name = dem_opname;
3123
          else if (cplus_demangle_opname (t_field_name,
3124
                                          dem_opname, 0))
3125
            t_field_name = dem_opname;
3126
        }
3127
      if (t_field_name && strcmp (t_field_name, name) == 0)
3128
        {
3129
          int j;
3130
          int len = TYPE_FN_FIELDLIST_LENGTH (t, i);
3131
          struct fn_field *f = TYPE_FN_FIELDLIST1 (t, i);
3132
 
3133
          check_stub_method_group (t, i);
3134
 
3135
          if (intype)
3136
            {
3137
              for (j = 0; j < len; ++j)
3138
                {
3139
                  if (compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 0)
3140
                      || compare_parameters (TYPE_FN_FIELD_TYPE (f, j), intype, 1))
3141
                    break;
3142
                }
3143
 
3144
              if (j == len)
3145
                error (_("no member function matches that type instantiation"));
3146
            }
3147
          else
3148
            {
3149
              int ii;
3150
 
3151
              j = -1;
3152
              for (ii = 0; ii < TYPE_FN_FIELDLIST_LENGTH (t, i);
3153
                   ++ii)
3154
                {
3155
                  /* Skip artificial methods.  This is necessary if,
3156
                     for example, the user wants to "print
3157
                     subclass::subclass" with only one user-defined
3158
                     constructor.  There is no ambiguity in this
3159
                     case.  */
3160
                  if (TYPE_FN_FIELD_ARTIFICIAL (f, ii))
3161
                    continue;
3162
 
3163
                  /* Desired method is ambiguous if more than one
3164
                     method is defined.  */
3165
                  if (j != -1)
3166
                    error (_("non-unique member `%s' requires type instantiation"), name);
3167
 
3168
                  j = ii;
3169
                }
3170
            }
3171
 
3172
          if (TYPE_FN_FIELD_STATIC_P (f, j))
3173
            {
3174
              struct symbol *s =
3175
                lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3176
                               0, VAR_DOMAIN, 0);
3177
 
3178
              if (s == NULL)
3179
                return NULL;
3180
 
3181
              if (want_address)
3182
                return value_addr (read_var_value (s, 0));
3183
              else
3184
                return read_var_value (s, 0);
3185
            }
3186
 
3187
          if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
3188
            {
3189
              if (want_address)
3190
                {
3191
                  result = allocate_value
3192
                    (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3193
                  cplus_make_method_ptr (value_type (result),
3194
                                         value_contents_writeable (result),
3195
                                         TYPE_FN_FIELD_VOFFSET (f, j), 1);
3196
                }
3197
              else if (noside == EVAL_AVOID_SIDE_EFFECTS)
3198
                return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
3199
              else
3200
                error (_("Cannot reference virtual member function \"%s\""),
3201
                       name);
3202
            }
3203
          else
3204
            {
3205
              struct symbol *s =
3206
                lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
3207
                               0, VAR_DOMAIN, 0);
3208
 
3209
              if (s == NULL)
3210
                return NULL;
3211
 
3212
              v = read_var_value (s, 0);
3213
              if (!want_address)
3214
                result = v;
3215
              else
3216
                {
3217
                  result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
3218
                  cplus_make_method_ptr (value_type (result),
3219
                                         value_contents_writeable (result),
3220
                                         value_address (v), 0);
3221
                }
3222
            }
3223
          return result;
3224
        }
3225
    }
3226
  for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
3227
    {
3228
      struct value *v;
3229
      int base_offset;
3230
 
3231
      if (BASETYPE_VIA_VIRTUAL (t, i))
3232
        base_offset = 0;
3233
      else
3234
        base_offset = TYPE_BASECLASS_BITPOS (t, i) / 8;
3235
      v = value_struct_elt_for_reference (domain,
3236
                                          offset + base_offset,
3237
                                          TYPE_BASECLASS (t, i),
3238
                                          name, intype,
3239
                                          want_address, noside);
3240
      if (v)
3241
        return v;
3242
    }
3243
 
3244
  /* As a last chance, pretend that CURTYPE is a namespace, and look
3245
     it up that way; this (frequently) works for types nested inside
3246
     classes.  */
3247
 
3248
  return value_maybe_namespace_elt (curtype, name,
3249
                                    want_address, noside);
3250
}
3251
 
3252
/* C++: Return the member NAME of the namespace given by the type
3253
   CURTYPE.  */
3254
 
3255
static struct value *
3256
value_namespace_elt (const struct type *curtype,
3257
                     char *name, int want_address,
3258
                     enum noside noside)
3259
{
3260
  struct value *retval = value_maybe_namespace_elt (curtype, name,
3261
                                                    want_address,
3262
                                                    noside);
3263
 
3264
  if (retval == NULL)
3265
    error (_("No symbol \"%s\" in namespace \"%s\"."),
3266
           name, TYPE_TAG_NAME (curtype));
3267
 
3268
  return retval;
3269
}
3270
 
3271
/* A helper function used by value_namespace_elt and
3272
   value_struct_elt_for_reference.  It looks up NAME inside the
3273
   context CURTYPE; this works if CURTYPE is a namespace or if CURTYPE
3274
   is a class and NAME refers to a type in CURTYPE itself (as opposed
3275
   to, say, some base class of CURTYPE).  */
3276
 
3277
static struct value *
3278
value_maybe_namespace_elt (const struct type *curtype,
3279
                           char *name, int want_address,
3280
                           enum noside noside)
3281
{
3282
  const char *namespace_name = TYPE_TAG_NAME (curtype);
3283
  struct symbol *sym;
3284
  struct value *result;
3285
 
3286
  sym = cp_lookup_symbol_namespace (namespace_name, name,
3287
                                    get_selected_block (0), VAR_DOMAIN);
3288
 
3289
  if (sym == NULL)
3290
    {
3291
      char *concatenated_name = alloca (strlen (namespace_name) + 2
3292
                                        + strlen (name) + 1);
3293
 
3294
      sprintf (concatenated_name, "%s::%s", namespace_name, name);
3295
      sym = lookup_static_symbol_aux (concatenated_name, VAR_DOMAIN);
3296
    }
3297
 
3298
  if (sym == NULL)
3299
    return NULL;
3300
  else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
3301
           && (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
3302
    result = allocate_value (SYMBOL_TYPE (sym));
3303
  else
3304
    result = value_of_variable (sym, get_selected_block (0));
3305
 
3306
  if (result && want_address)
3307
    result = value_addr (result);
3308
 
3309
  return result;
3310
}
3311
 
3312
/* Given a pointer value V, find the real (RTTI) type of the object it
3313
   points to.
3314
 
3315
   Other parameters FULL, TOP, USING_ENC as with value_rtti_type()
3316
   and refer to the values computed for the object pointed to.  */
3317
 
3318
struct type *
3319
value_rtti_target_type (struct value *v, int *full,
3320
                        int *top, int *using_enc)
3321
{
3322
  struct value *target;
3323
 
3324
  target = value_ind (v);
3325
 
3326
  return value_rtti_type (target, full, top, using_enc);
3327
}
3328
 
3329
/* Given a value pointed to by ARGP, check its real run-time type, and
3330
   if that is different from the enclosing type, create a new value
3331
   using the real run-time type as the enclosing type (and of the same
3332
   type as ARGP) and return it, with the embedded offset adjusted to
3333
   be the correct offset to the enclosed object.  RTYPE is the type,
3334
   and XFULL, XTOP, and XUSING_ENC are the other parameters, computed
3335
   by value_rtti_type().  If these are available, they can be supplied
3336
   and a second call to value_rtti_type() is avoided.  (Pass RTYPE ==
3337
   NULL if they're not available.  */
3338
 
3339
struct value *
3340
value_full_object (struct value *argp,
3341
                   struct type *rtype,
3342
                   int xfull, int xtop,
3343
                   int xusing_enc)
3344
{
3345
  struct type *real_type;
3346
  int full = 0;
3347
  int top = -1;
3348
  int using_enc = 0;
3349
  struct value *new_val;
3350
 
3351
  if (rtype)
3352
    {
3353
      real_type = rtype;
3354
      full = xfull;
3355
      top = xtop;
3356
      using_enc = xusing_enc;
3357
    }
3358
  else
3359
    real_type = value_rtti_type (argp, &full, &top, &using_enc);
3360
 
3361
  /* If no RTTI data, or if object is already complete, do nothing.  */
3362
  if (!real_type || real_type == value_enclosing_type (argp))
3363
    return argp;
3364
 
3365
  /* If we have the full object, but for some reason the enclosing
3366
     type is wrong, set it.  */
3367
  /* pai: FIXME -- sounds iffy */
3368
  if (full)
3369
    {
3370
      argp = value_change_enclosing_type (argp, real_type);
3371
      return argp;
3372
    }
3373
 
3374
  /* Check if object is in memory */
3375
  if (VALUE_LVAL (argp) != lval_memory)
3376
    {
3377
      warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."),
3378
               TYPE_NAME (real_type));
3379
 
3380
      return argp;
3381
    }
3382
 
3383
  /* All other cases -- retrieve the complete object.  */
3384
  /* Go back by the computed top_offset from the beginning of the
3385
     object, adjusting for the embedded offset of argp if that's what
3386
     value_rtti_type used for its computation.  */
3387
  new_val = value_at_lazy (real_type, value_address (argp) - top +
3388
                           (using_enc ? 0 : value_embedded_offset (argp)));
3389
  deprecated_set_value_type (new_val, value_type (argp));
3390
  set_value_embedded_offset (new_val, (using_enc
3391
                                       ? top + value_embedded_offset (argp)
3392
                                       : top));
3393
  return new_val;
3394
}
3395
 
3396
 
3397
/* Return the value of the local variable, if one exists.
3398
   Flag COMPLAIN signals an error if the request is made in an
3399
   inappropriate context.  */
3400
 
3401
struct value *
3402
value_of_local (const char *name, int complain)
3403
{
3404
  struct symbol *func, *sym;
3405
  struct block *b;
3406
  struct value * ret;
3407
  struct frame_info *frame;
3408
 
3409
  if (complain)
3410
    frame = get_selected_frame (_("no frame selected"));
3411
  else
3412
    {
3413
      frame = deprecated_safe_get_selected_frame ();
3414
      if (frame == 0)
3415
        return 0;
3416
    }
3417
 
3418
  func = get_frame_function (frame);
3419
  if (!func)
3420
    {
3421
      if (complain)
3422
        error (_("no `%s' in nameless context"), name);
3423
      else
3424
        return 0;
3425
    }
3426
 
3427
  b = SYMBOL_BLOCK_VALUE (func);
3428
  if (dict_empty (BLOCK_DICT (b)))
3429
    {
3430
      if (complain)
3431
        error (_("no args, no `%s'"), name);
3432
      else
3433
        return 0;
3434
    }
3435
 
3436
  /* Calling lookup_block_symbol is necessary to get the LOC_REGISTER
3437
     symbol instead of the LOC_ARG one (if both exist).  */
3438
  sym = lookup_block_symbol (b, name, VAR_DOMAIN);
3439
  if (sym == NULL)
3440
    {
3441
      if (complain)
3442
        error (_("current stack frame does not contain a variable named `%s'"),
3443
               name);
3444
      else
3445
        return NULL;
3446
    }
3447
 
3448
  ret = read_var_value (sym, frame);
3449
  if (ret == 0 && complain)
3450
    error (_("`%s' argument unreadable"), name);
3451
  return ret;
3452
}
3453
 
3454
/* C++/Objective-C: return the value of the class instance variable,
3455
   if one exists.  Flag COMPLAIN signals an error if the request is
3456
   made in an inappropriate context.  */
3457
 
3458
struct value *
3459
value_of_this (int complain)
3460
{
3461
  if (!current_language->la_name_of_this)
3462
    return 0;
3463
  return value_of_local (current_language->la_name_of_this, complain);
3464
}
3465
 
3466
/* Create a slice (sub-string, sub-array) of ARRAY, that is LENGTH
3467
   elements long, starting at LOWBOUND.  The result has the same lower
3468
   bound as the original ARRAY.  */
3469
 
3470
struct value *
3471
value_slice (struct value *array, int lowbound, int length)
3472
{
3473
  struct type *slice_range_type, *slice_type, *range_type;
3474
  LONGEST lowerbound, upperbound;
3475
  struct value *slice;
3476
  struct type *array_type;
3477
 
3478
  array_type = check_typedef (value_type (array));
3479
  if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
3480
      && TYPE_CODE (array_type) != TYPE_CODE_STRING
3481
      && TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
3482
    error (_("cannot take slice of non-array"));
3483
 
3484
  range_type = TYPE_INDEX_TYPE (array_type);
3485
  if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
3486
    error (_("slice from bad array or bitstring"));
3487
 
3488
  if (lowbound < lowerbound || length < 0
3489
      || lowbound + length - 1 > upperbound)
3490
    error (_("slice out of range"));
3491
 
3492
  /* FIXME-type-allocation: need a way to free this type when we are
3493
     done with it.  */
3494
  slice_range_type = create_range_type ((struct type *) NULL,
3495
                                        TYPE_TARGET_TYPE (range_type),
3496
                                        lowbound,
3497
                                        lowbound + length - 1);
3498
  if (TYPE_CODE (array_type) == TYPE_CODE_BITSTRING)
3499
    {
3500
      int i;
3501
 
3502
      slice_type = create_set_type ((struct type *) NULL,
3503
                                    slice_range_type);
3504
      TYPE_CODE (slice_type) = TYPE_CODE_BITSTRING;
3505
      slice = value_zero (slice_type, not_lval);
3506
 
3507
      for (i = 0; i < length; i++)
3508
        {
3509
          int element = value_bit_index (array_type,
3510
                                         value_contents (array),
3511
                                         lowbound + i);
3512
 
3513
          if (element < 0)
3514
            error (_("internal error accessing bitstring"));
3515
          else if (element > 0)
3516
            {
3517
              int j = i % TARGET_CHAR_BIT;
3518
 
3519
              if (gdbarch_bits_big_endian (get_type_arch (array_type)))
3520
                j = TARGET_CHAR_BIT - 1 - j;
3521
              value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
3522
            }
3523
        }
3524
      /* We should set the address, bitssize, and bitspos, so the
3525
         slice can be used on the LHS, but that may require extensions
3526
         to value_assign.  For now, just leave as a non_lval.
3527
         FIXME.  */
3528
    }
3529
  else
3530
    {
3531
      struct type *element_type = TYPE_TARGET_TYPE (array_type);
3532
      LONGEST offset =
3533
        (lowbound - lowerbound) * TYPE_LENGTH (check_typedef (element_type));
3534
 
3535
      slice_type = create_array_type ((struct type *) NULL,
3536
                                      element_type,
3537
                                      slice_range_type);
3538
      TYPE_CODE (slice_type) = TYPE_CODE (array_type);
3539
 
3540
      if (VALUE_LVAL (array) == lval_memory && value_lazy (array))
3541
        slice = allocate_value_lazy (slice_type);
3542
      else
3543
        {
3544
          slice = allocate_value (slice_type);
3545
          memcpy (value_contents_writeable (slice),
3546
                  value_contents (array) + offset,
3547
                  TYPE_LENGTH (slice_type));
3548
        }
3549
 
3550
      set_value_component_location (slice, array);
3551
      VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
3552
      set_value_offset (slice, value_offset (array) + offset);
3553
    }
3554
  return slice;
3555
}
3556
 
3557
/* Create a value for a FORTRAN complex number.  Currently most of the
3558
   time values are coerced to COMPLEX*16 (i.e. a complex number
3559
   composed of 2 doubles.  This really should be a smarter routine
3560
   that figures out precision inteligently as opposed to assuming
3561
   doubles.  FIXME: fmb  */
3562
 
3563
struct value *
3564
value_literal_complex (struct value *arg1,
3565
                       struct value *arg2,
3566
                       struct type *type)
3567
{
3568
  struct value *val;
3569
  struct type *real_type = TYPE_TARGET_TYPE (type);
3570
 
3571
  val = allocate_value (type);
3572
  arg1 = value_cast (real_type, arg1);
3573
  arg2 = value_cast (real_type, arg2);
3574
 
3575
  memcpy (value_contents_raw (val),
3576
          value_contents (arg1), TYPE_LENGTH (real_type));
3577
  memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
3578
          value_contents (arg2), TYPE_LENGTH (real_type));
3579
  return val;
3580
}
3581
 
3582
/* Cast a value into the appropriate complex data type.  */
3583
 
3584
static struct value *
3585
cast_into_complex (struct type *type, struct value *val)
3586
{
3587
  struct type *real_type = TYPE_TARGET_TYPE (type);
3588
 
3589
  if (TYPE_CODE (value_type (val)) == TYPE_CODE_COMPLEX)
3590
    {
3591
      struct type *val_real_type = TYPE_TARGET_TYPE (value_type (val));
3592
      struct value *re_val = allocate_value (val_real_type);
3593
      struct value *im_val = allocate_value (val_real_type);
3594
 
3595
      memcpy (value_contents_raw (re_val),
3596
              value_contents (val), TYPE_LENGTH (val_real_type));
3597
      memcpy (value_contents_raw (im_val),
3598
              value_contents (val) + TYPE_LENGTH (val_real_type),
3599
              TYPE_LENGTH (val_real_type));
3600
 
3601
      return value_literal_complex (re_val, im_val, type);
3602
    }
3603
  else if (TYPE_CODE (value_type (val)) == TYPE_CODE_FLT
3604
           || TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
3605
    return value_literal_complex (val,
3606
                                  value_zero (real_type, not_lval),
3607
                                  type);
3608
  else
3609
    error (_("cannot cast non-number to complex"));
3610
}
3611
 
3612
void
3613
_initialize_valops (void)
3614
{
3615
  add_setshow_boolean_cmd ("overload-resolution", class_support,
3616
                           &overload_resolution, _("\
3617
Set overload resolution in evaluating C++ functions."), _("\
3618
Show overload resolution in evaluating C++ functions."),
3619
                           NULL, NULL,
3620
                           show_overload_resolution,
3621
                           &setlist, &showlist);
3622
  overload_resolution = 1;
3623
}

powered by: WebSVN 2.1.0

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