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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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