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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [cp/] [name-lookup.c] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 283 jeremybenn
/* Definitions for C++ name lookup routines.
2
   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
   Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 3, or (at your option)
11
any later version.
12
 
13
GCC is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
GNU General Public License for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#include "config.h"
23
#include "system.h"
24
#include "coretypes.h"
25
#include "tm.h"
26
#include "flags.h"
27
#include "tree.h"
28
#include "cp-tree.h"
29
#include "name-lookup.h"
30
#include "timevar.h"
31
#include "toplev.h"
32
#include "diagnostic.h"
33
#include "debug.h"
34
#include "c-pragma.h"
35
 
36
/* The bindings for a particular name in a particular scope.  */
37
 
38
struct scope_binding {
39
  tree value;
40
  tree type;
41
};
42
#define EMPTY_SCOPE_BINDING { NULL_TREE, NULL_TREE }
43
 
44
static cxx_scope *innermost_nonclass_level (void);
45
static cxx_binding *binding_for_name (cxx_scope *, tree);
46
static tree push_overloaded_decl (tree, int, bool);
47
static bool lookup_using_namespace (tree, struct scope_binding *, tree,
48
                                    tree, int);
49
static bool qualified_lookup_using_namespace (tree, tree,
50
                                              struct scope_binding *, int);
51
static tree lookup_type_current_level (tree);
52
static tree push_using_directive (tree);
53
static cxx_binding* lookup_extern_c_fun_binding_in_all_ns (tree);
54
 
55
/* The :: namespace.  */
56
 
57
tree global_namespace;
58
 
59
/* The name of the anonymous namespace, throughout this translation
60
   unit.  */
61
static GTY(()) tree anonymous_namespace_name;
62
 
63
/* Initialize anonymous_namespace_name if necessary, and return it.  */
64
 
65
static tree
66
get_anonymous_namespace_name (void)
67
{
68
  if (!anonymous_namespace_name)
69
    {
70
      /* The anonymous namespace has to have a unique name
71
         if typeinfo objects are being compared by name.  */
72
      if (! flag_weak || ! SUPPORTS_ONE_ONLY)
73
       anonymous_namespace_name = get_file_function_name ("N");
74
      else
75
       /* The demangler expects anonymous namespaces to be called
76
          something starting with '_GLOBAL__N_'.  */
77
       anonymous_namespace_name = get_identifier ("_GLOBAL__N_1");
78
    }
79
  return anonymous_namespace_name;
80
}
81
 
82
/* Compute the chain index of a binding_entry given the HASH value of its
83
   name and the total COUNT of chains.  COUNT is assumed to be a power
84
   of 2.  */
85
 
86
#define ENTRY_INDEX(HASH, COUNT) (((HASH) >> 3) & ((COUNT) - 1))
87
 
88
/* A free list of "binding_entry"s awaiting for re-use.  */
89
 
90
static GTY((deletable)) binding_entry free_binding_entry = NULL;
91
 
92
/* Create a binding_entry object for (NAME, TYPE).  */
93
 
94
static inline binding_entry
95
binding_entry_make (tree name, tree type)
96
{
97
  binding_entry entry;
98
 
99
  if (free_binding_entry)
100
    {
101
      entry = free_binding_entry;
102
      free_binding_entry = entry->chain;
103
    }
104
  else
105
    entry = GGC_NEW (struct binding_entry_s);
106
 
107
  entry->name = name;
108
  entry->type = type;
109
  entry->chain = NULL;
110
 
111
  return entry;
112
}
113
 
114
/* Put ENTRY back on the free list.  */
115
#if 0
116
static inline void
117
binding_entry_free (binding_entry entry)
118
{
119
  entry->name = NULL;
120
  entry->type = NULL;
121
  entry->chain = free_binding_entry;
122
  free_binding_entry = entry;
123
}
124
#endif
125
 
126
/* The datatype used to implement the mapping from names to types at
127
   a given scope.  */
128
struct GTY(()) binding_table_s {
129
  /* Array of chains of "binding_entry"s  */
130
  binding_entry * GTY((length ("%h.chain_count"))) chain;
131
 
132
  /* The number of chains in this table.  This is the length of the
133
     member "chain" considered as an array.  */
134
  size_t chain_count;
135
 
136
  /* Number of "binding_entry"s in this table.  */
137
  size_t entry_count;
138
};
139
 
140
/* Construct TABLE with an initial CHAIN_COUNT.  */
141
 
142
static inline void
143
binding_table_construct (binding_table table, size_t chain_count)
144
{
145
  table->chain_count = chain_count;
146
  table->entry_count = 0;
147
  table->chain = GGC_CNEWVEC (binding_entry, table->chain_count);
148
}
149
 
150
/* Make TABLE's entries ready for reuse.  */
151
#if 0
152
static void
153
binding_table_free (binding_table table)
154
{
155
  size_t i;
156
  size_t count;
157
 
158
  if (table == NULL)
159
    return;
160
 
161
  for (i = 0, count = table->chain_count; i < count; ++i)
162
    {
163
      binding_entry temp = table->chain[i];
164
      while (temp != NULL)
165
        {
166
          binding_entry entry = temp;
167
          temp = entry->chain;
168
          binding_entry_free (entry);
169
        }
170
      table->chain[i] = NULL;
171
    }
172
  table->entry_count = 0;
173
}
174
#endif
175
 
176
/* Allocate a table with CHAIN_COUNT, assumed to be a power of two.  */
177
 
178
static inline binding_table
179
binding_table_new (size_t chain_count)
180
{
181
  binding_table table = GGC_NEW (struct binding_table_s);
182
  table->chain = NULL;
183
  binding_table_construct (table, chain_count);
184
  return table;
185
}
186
 
187
/* Expand TABLE to twice its current chain_count.  */
188
 
189
static void
190
binding_table_expand (binding_table table)
191
{
192
  const size_t old_chain_count = table->chain_count;
193
  const size_t old_entry_count = table->entry_count;
194
  const size_t new_chain_count = 2 * old_chain_count;
195
  binding_entry *old_chains = table->chain;
196
  size_t i;
197
 
198
  binding_table_construct (table, new_chain_count);
199
  for (i = 0; i < old_chain_count; ++i)
200
    {
201
      binding_entry entry = old_chains[i];
202
      for (; entry != NULL; entry = old_chains[i])
203
        {
204
          const unsigned int hash = IDENTIFIER_HASH_VALUE (entry->name);
205
          const size_t j = ENTRY_INDEX (hash, new_chain_count);
206
 
207
          old_chains[i] = entry->chain;
208
          entry->chain = table->chain[j];
209
          table->chain[j] = entry;
210
        }
211
    }
212
  table->entry_count = old_entry_count;
213
}
214
 
215
/* Insert a binding for NAME to TYPE into TABLE.  */
216
 
217
static void
218
binding_table_insert (binding_table table, tree name, tree type)
219
{
220
  const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
221
  const size_t i = ENTRY_INDEX (hash, table->chain_count);
222
  binding_entry entry = binding_entry_make (name, type);
223
 
224
  entry->chain = table->chain[i];
225
  table->chain[i] = entry;
226
  ++table->entry_count;
227
 
228
  if (3 * table->chain_count < 5 * table->entry_count)
229
    binding_table_expand (table);
230
}
231
 
232
/* Return the binding_entry, if any, that maps NAME.  */
233
 
234
binding_entry
235
binding_table_find (binding_table table, tree name)
236
{
237
  const unsigned int hash = IDENTIFIER_HASH_VALUE (name);
238
  binding_entry entry = table->chain[ENTRY_INDEX (hash, table->chain_count)];
239
 
240
  while (entry != NULL && entry->name != name)
241
    entry = entry->chain;
242
 
243
  return entry;
244
}
245
 
246
/* Apply PROC -- with DATA -- to all entries in TABLE.  */
247
 
248
void
249
binding_table_foreach (binding_table table, bt_foreach_proc proc, void *data)
250
{
251
  const size_t chain_count = table->chain_count;
252
  size_t i;
253
 
254
  for (i = 0; i < chain_count; ++i)
255
    {
256
      binding_entry entry = table->chain[i];
257
      for (; entry != NULL; entry = entry->chain)
258
        proc (entry, data);
259
    }
260
}
261
 
262
#ifndef ENABLE_SCOPE_CHECKING
263
#  define ENABLE_SCOPE_CHECKING 0
264
#else
265
#  define ENABLE_SCOPE_CHECKING 1
266
#endif
267
 
268
/* A free list of "cxx_binding"s, connected by their PREVIOUS.  */
269
 
270
static GTY((deletable)) cxx_binding *free_bindings;
271
 
272
/* Initialize VALUE and TYPE field for BINDING, and set the PREVIOUS
273
   field to NULL.  */
274
 
275
static inline void
276
cxx_binding_init (cxx_binding *binding, tree value, tree type)
277
{
278
  binding->value = value;
279
  binding->type = type;
280
  binding->previous = NULL;
281
}
282
 
283
/* (GC)-allocate a binding object with VALUE and TYPE member initialized.  */
284
 
285
static cxx_binding *
286
cxx_binding_make (tree value, tree type)
287
{
288
  cxx_binding *binding;
289
  if (free_bindings)
290
    {
291
      binding = free_bindings;
292
      free_bindings = binding->previous;
293
    }
294
  else
295
    binding = GGC_NEW (cxx_binding);
296
 
297
  cxx_binding_init (binding, value, type);
298
 
299
  return binding;
300
}
301
 
302
/* Put BINDING back on the free list.  */
303
 
304
static inline void
305
cxx_binding_free (cxx_binding *binding)
306
{
307
  binding->scope = NULL;
308
  binding->previous = free_bindings;
309
  free_bindings = binding;
310
}
311
 
312
/* Create a new binding for NAME (with the indicated VALUE and TYPE
313
   bindings) in the class scope indicated by SCOPE.  */
314
 
315
static cxx_binding *
316
new_class_binding (tree name, tree value, tree type, cxx_scope *scope)
317
{
318
  cp_class_binding *cb;
319
  cxx_binding *binding;
320
 
321
  if (VEC_length (cp_class_binding, scope->class_shadowed))
322
    {
323
      cp_class_binding *old_base;
324
      old_base = VEC_index (cp_class_binding, scope->class_shadowed, 0);
325
      if (VEC_reserve (cp_class_binding, gc, scope->class_shadowed, 1))
326
        {
327
          /* Fixup the current bindings, as they might have moved.  */
328
          size_t i;
329
 
330
          for (i = 0;
331
               VEC_iterate (cp_class_binding, scope->class_shadowed, i, cb);
332
               i++)
333
            {
334
              cxx_binding **b;
335
              b = &IDENTIFIER_BINDING (cb->identifier);
336
              while (*b != &old_base[i].base)
337
                b = &((*b)->previous);
338
              *b = &cb->base;
339
            }
340
        }
341
      cb = VEC_quick_push (cp_class_binding, scope->class_shadowed, NULL);
342
    }
343
  else
344
    cb = VEC_safe_push (cp_class_binding, gc, scope->class_shadowed, NULL);
345
 
346
  cb->identifier = name;
347
  binding = &cb->base;
348
  binding->scope = scope;
349
  cxx_binding_init (binding, value, type);
350
  return binding;
351
}
352
 
353
/* Make DECL the innermost binding for ID.  The LEVEL is the binding
354
   level at which this declaration is being bound.  */
355
 
356
static void
357
push_binding (tree id, tree decl, cxx_scope* level)
358
{
359
  cxx_binding *binding;
360
 
361
  if (level != class_binding_level)
362
    {
363
      binding = cxx_binding_make (decl, NULL_TREE);
364
      binding->scope = level;
365
    }
366
  else
367
    binding = new_class_binding (id, decl, /*type=*/NULL_TREE, level);
368
 
369
  /* Now, fill in the binding information.  */
370
  binding->previous = IDENTIFIER_BINDING (id);
371
  INHERITED_VALUE_BINDING_P (binding) = 0;
372
  LOCAL_BINDING_P (binding) = (level != class_binding_level);
373
 
374
  /* And put it on the front of the list of bindings for ID.  */
375
  IDENTIFIER_BINDING (id) = binding;
376
}
377
 
378
/* Remove the binding for DECL which should be the innermost binding
379
   for ID.  */
380
 
381
void
382
pop_binding (tree id, tree decl)
383
{
384
  cxx_binding *binding;
385
 
386
  if (id == NULL_TREE)
387
    /* It's easiest to write the loops that call this function without
388
       checking whether or not the entities involved have names.  We
389
       get here for such an entity.  */
390
    return;
391
 
392
  /* Get the innermost binding for ID.  */
393
  binding = IDENTIFIER_BINDING (id);
394
 
395
  /* The name should be bound.  */
396
  gcc_assert (binding != NULL);
397
 
398
  /* The DECL will be either the ordinary binding or the type
399
     binding for this identifier.  Remove that binding.  */
400
  if (binding->value == decl)
401
    binding->value = NULL_TREE;
402
  else
403
    {
404
      gcc_assert (binding->type == decl);
405
      binding->type = NULL_TREE;
406
    }
407
 
408
  if (!binding->value && !binding->type)
409
    {
410
      /* We're completely done with the innermost binding for this
411
         identifier.  Unhook it from the list of bindings.  */
412
      IDENTIFIER_BINDING (id) = binding->previous;
413
 
414
      /* Add it to the free list.  */
415
      cxx_binding_free (binding);
416
    }
417
}
418
 
419
/* BINDING records an existing declaration for a name in the current scope.
420
   But, DECL is another declaration for that same identifier in the
421
   same scope.  This is the `struct stat' hack whereby a non-typedef
422
   class name or enum-name can be bound at the same level as some other
423
   kind of entity.
424
   3.3.7/1
425
 
426
     A class name (9.1) or enumeration name (7.2) can be hidden by the
427
     name of an object, function, or enumerator declared in the same scope.
428
     If a class or enumeration name and an object, function, or enumerator
429
     are declared in the same scope (in any order) with the same name, the
430
     class or enumeration name is hidden wherever the object, function, or
431
     enumerator name is visible.
432
 
433
   It's the responsibility of the caller to check that
434
   inserting this name is valid here.  Returns nonzero if the new binding
435
   was successful.  */
436
 
437
static bool
438
supplement_binding (cxx_binding *binding, tree decl)
439
{
440
  tree bval = binding->value;
441
  bool ok = true;
442
 
443
  timevar_push (TV_NAME_LOOKUP);
444
  if (TREE_CODE (decl) == TYPE_DECL && DECL_ARTIFICIAL (decl))
445
    /* The new name is the type name.  */
446
    binding->type = decl;
447
  else if (/* BVAL is null when push_class_level_binding moves an
448
              inherited type-binding out of the way to make room for a
449
              new value binding.  */
450
           !bval
451
           /* BVAL is error_mark_node when DECL's name has been used
452
              in a non-class scope prior declaration.  In that case,
453
              we should have already issued a diagnostic; for graceful
454
              error recovery purpose, pretend this was the intended
455
              declaration for that name.  */
456
           || bval == error_mark_node
457
           /* If BVAL is anticipated but has not yet been declared,
458
              pretend it is not there at all.  */
459
           || (TREE_CODE (bval) == FUNCTION_DECL
460
               && DECL_ANTICIPATED (bval)
461
               && !DECL_HIDDEN_FRIEND_P (bval)))
462
    binding->value = decl;
463
  else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
464
    {
465
      /* The old binding was a type name.  It was placed in
466
         VALUE field because it was thought, at the point it was
467
         declared, to be the only entity with such a name.  Move the
468
         type name into the type slot; it is now hidden by the new
469
         binding.  */
470
      binding->type = bval;
471
      binding->value = decl;
472
      binding->value_is_inherited = false;
473
    }
474
  else if (TREE_CODE (bval) == TYPE_DECL
475
           && TREE_CODE (decl) == TYPE_DECL
476
           && DECL_NAME (decl) == DECL_NAME (bval)
477
           && binding->scope->kind != sk_class
478
           && (same_type_p (TREE_TYPE (decl), TREE_TYPE (bval))
479
               /* If either type involves template parameters, we must
480
                  wait until instantiation.  */
481
               || uses_template_parms (TREE_TYPE (decl))
482
               || uses_template_parms (TREE_TYPE (bval))))
483
    /* We have two typedef-names, both naming the same type to have
484
       the same name.  In general, this is OK because of:
485
 
486
         [dcl.typedef]
487
 
488
         In a given scope, a typedef specifier can be used to redefine
489
         the name of any type declared in that scope to refer to the
490
         type to which it already refers.
491
 
492
       However, in class scopes, this rule does not apply due to the
493
       stricter language in [class.mem] prohibiting redeclarations of
494
       members.  */
495
    ok = false;
496
  /* There can be two block-scope declarations of the same variable,
497
     so long as they are `extern' declarations.  However, there cannot
498
     be two declarations of the same static data member:
499
 
500
       [class.mem]
501
 
502
       A member shall not be declared twice in the
503
       member-specification.  */
504
  else if (TREE_CODE (decl) == VAR_DECL && TREE_CODE (bval) == VAR_DECL
505
           && DECL_EXTERNAL (decl) && DECL_EXTERNAL (bval)
506
           && !DECL_CLASS_SCOPE_P (decl))
507
    {
508
      duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false);
509
      ok = false;
510
    }
511
  else if (TREE_CODE (decl) == NAMESPACE_DECL
512
           && TREE_CODE (bval) == NAMESPACE_DECL
513
           && DECL_NAMESPACE_ALIAS (decl)
514
           && DECL_NAMESPACE_ALIAS (bval)
515
           && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl))
516
    /* [namespace.alias]
517
 
518
      In a declarative region, a namespace-alias-definition can be
519
      used to redefine a namespace-alias declared in that declarative
520
      region to refer only to the namespace to which it already
521
      refers.  */
522
    ok = false;
523
  else
524
    {
525
      error ("declaration of %q#D", decl);
526
      error ("conflicts with previous declaration %q+#D", bval);
527
      ok = false;
528
    }
529
 
530
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
531
}
532
 
533
/* Add DECL to the list of things declared in B.  */
534
 
535
static void
536
add_decl_to_level (tree decl, cxx_scope *b)
537
{
538
  /* We used to record virtual tables as if they were ordinary
539
     variables, but no longer do so.  */
540
  gcc_assert (!(TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl)));
541
 
542
  if (TREE_CODE (decl) == NAMESPACE_DECL
543
      && !DECL_NAMESPACE_ALIAS (decl))
544
    {
545
      TREE_CHAIN (decl) = b->namespaces;
546
      b->namespaces = decl;
547
    }
548
  else
549
    {
550
      /* We build up the list in reverse order, and reverse it later if
551
         necessary.  */
552
      TREE_CHAIN (decl) = b->names;
553
      b->names = decl;
554
      b->names_size++;
555
 
556
      /* If appropriate, add decl to separate list of statics.  We
557
         include extern variables because they might turn out to be
558
         static later.  It's OK for this list to contain a few false
559
         positives.  */
560
      if (b->kind == sk_namespace)
561
        if ((TREE_CODE (decl) == VAR_DECL
562
             && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
563
            || (TREE_CODE (decl) == FUNCTION_DECL
564
                && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))
565
          VEC_safe_push (tree, gc, b->static_decls, decl);
566
    }
567
}
568
 
569
/* Record a decl-node X as belonging to the current lexical scope.
570
   Check for errors (such as an incompatible declaration for the same
571
   name already seen in the same scope).  IS_FRIEND is true if X is
572
   declared as a friend.
573
 
574
   Returns either X or an old decl for the same name.
575
   If an old decl is returned, it may have been smashed
576
   to agree with what X says.  */
577
 
578
tree
579
pushdecl_maybe_friend (tree x, bool is_friend)
580
{
581
  tree t;
582
  tree name;
583
  int need_new_binding;
584
 
585
  timevar_push (TV_NAME_LOOKUP);
586
 
587
  if (x == error_mark_node)
588
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
589
 
590
  need_new_binding = 1;
591
 
592
  if (DECL_TEMPLATE_PARM_P (x))
593
    /* Template parameters have no context; they are not X::T even
594
       when declared within a class or namespace.  */
595
    ;
596
  else
597
    {
598
      if (current_function_decl && x != current_function_decl
599
          /* A local declaration for a function doesn't constitute
600
             nesting.  */
601
          && TREE_CODE (x) != FUNCTION_DECL
602
          /* A local declaration for an `extern' variable is in the
603
             scope of the current namespace, not the current
604
             function.  */
605
          && !(TREE_CODE (x) == VAR_DECL && DECL_EXTERNAL (x))
606
          /* When parsing the parameter list of a function declarator,
607
             don't set DECL_CONTEXT to an enclosing function.  When we
608
             push the PARM_DECLs in order to process the function body,
609
             current_binding_level->this_entity will be set.  */
610
          && !(TREE_CODE (x) == PARM_DECL
611
               && current_binding_level->kind == sk_function_parms
612
               && current_binding_level->this_entity == NULL)
613
          && !DECL_CONTEXT (x))
614
        DECL_CONTEXT (x) = current_function_decl;
615
 
616
      /* If this is the declaration for a namespace-scope function,
617
         but the declaration itself is in a local scope, mark the
618
         declaration.  */
619
      if (TREE_CODE (x) == FUNCTION_DECL
620
          && DECL_NAMESPACE_SCOPE_P (x)
621
          && current_function_decl
622
          && x != current_function_decl)
623
        DECL_LOCAL_FUNCTION_P (x) = 1;
624
    }
625
 
626
  name = DECL_NAME (x);
627
  if (name)
628
    {
629
      int different_binding_level = 0;
630
 
631
      if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
632
        name = TREE_OPERAND (name, 0);
633
 
634
      /* In case this decl was explicitly namespace-qualified, look it
635
         up in its namespace context.  */
636
      if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())
637
        t = namespace_binding (name, DECL_CONTEXT (x));
638
      else
639
        t = lookup_name_innermost_nonclass_level (name);
640
 
641
      /* [basic.link] If there is a visible declaration of an entity
642
         with linkage having the same name and type, ignoring entities
643
         declared outside the innermost enclosing namespace scope, the
644
         block scope declaration declares that same entity and
645
         receives the linkage of the previous declaration.  */
646
      if (! t && current_function_decl && x != current_function_decl
647
          && (TREE_CODE (x) == FUNCTION_DECL || TREE_CODE (x) == VAR_DECL)
648
          && DECL_EXTERNAL (x))
649
        {
650
          /* Look in block scope.  */
651
          t = innermost_non_namespace_value (name);
652
          /* Or in the innermost namespace.  */
653
          if (! t)
654
            t = namespace_binding (name, DECL_CONTEXT (x));
655
          /* Does it have linkage?  Note that if this isn't a DECL, it's an
656
             OVERLOAD, which is OK.  */
657
          if (t && DECL_P (t) && ! (TREE_STATIC (t) || DECL_EXTERNAL (t)))
658
            t = NULL_TREE;
659
          if (t)
660
            different_binding_level = 1;
661
        }
662
 
663
      /* If we are declaring a function, and the result of name-lookup
664
         was an OVERLOAD, look for an overloaded instance that is
665
         actually the same as the function we are declaring.  (If
666
         there is one, we have to merge our declaration with the
667
         previous declaration.)  */
668
      if (t && TREE_CODE (t) == OVERLOAD)
669
        {
670
          tree match;
671
 
672
          if (TREE_CODE (x) == FUNCTION_DECL)
673
            for (match = t; match; match = OVL_NEXT (match))
674
              {
675
                if (decls_match (OVL_CURRENT (match), x))
676
                  break;
677
              }
678
          else
679
            /* Just choose one.  */
680
            match = t;
681
 
682
          if (match)
683
            t = OVL_CURRENT (match);
684
          else
685
            t = NULL_TREE;
686
        }
687
 
688
      if (t && t != error_mark_node)
689
        {
690
          if (different_binding_level)
691
            {
692
              if (decls_match (x, t))
693
                /* The standard only says that the local extern
694
                   inherits linkage from the previous decl; in
695
                   particular, default args are not shared.  Add
696
                   the decl into a hash table to make sure only
697
                   the previous decl in this case is seen by the
698
                   middle end.  */
699
                {
700
                  struct cxx_int_tree_map *h;
701
                  void **loc;
702
 
703
                  TREE_PUBLIC (x) = TREE_PUBLIC (t);
704
 
705
                  if (cp_function_chain->extern_decl_map == NULL)
706
                    cp_function_chain->extern_decl_map
707
                      = htab_create_ggc (20, cxx_int_tree_map_hash,
708
                                         cxx_int_tree_map_eq, NULL);
709
 
710
                  h = GGC_NEW (struct cxx_int_tree_map);
711
                  h->uid = DECL_UID (x);
712
                  h->to = t;
713
                  loc = htab_find_slot_with_hash
714
                          (cp_function_chain->extern_decl_map, h,
715
                           h->uid, INSERT);
716
                  *(struct cxx_int_tree_map **) loc = h;
717
                }
718
            }
719
          else if (TREE_CODE (t) == PARM_DECL)
720
            {
721
              /* Check for duplicate params.  */
722
              tree d = duplicate_decls (x, t, is_friend);
723
              if (d)
724
                POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, d);
725
            }
726
          else if ((DECL_EXTERN_C_FUNCTION_P (x)
727
                    || DECL_FUNCTION_TEMPLATE_P (x))
728
                   && is_overloaded_fn (t))
729
            /* Don't do anything just yet.  */;
730
          else if (t == wchar_decl_node)
731
            {
732
              if (! DECL_IN_SYSTEM_HEADER (x))
733
                pedwarn (input_location, OPT_pedantic, "redeclaration of %<wchar_t%> as %qT",
734
                         TREE_TYPE (x));
735
 
736
              /* Throw away the redeclaration.  */
737
              POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
738
            }
739
          else
740
            {
741
              tree olddecl = duplicate_decls (x, t, is_friend);
742
 
743
              /* If the redeclaration failed, we can stop at this
744
                 point.  */
745
              if (olddecl == error_mark_node)
746
                POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
747
 
748
              if (olddecl)
749
                {
750
                  if (TREE_CODE (t) == TYPE_DECL)
751
                    SET_IDENTIFIER_TYPE_VALUE (name, TREE_TYPE (t));
752
 
753
                  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
754
                }
755
              else if (DECL_MAIN_P (x) && TREE_CODE (t) == FUNCTION_DECL)
756
                {
757
                  /* A redeclaration of main, but not a duplicate of the
758
                     previous one.
759
 
760
                     [basic.start.main]
761
 
762
                     This function shall not be overloaded.  */
763
                  error ("invalid redeclaration of %q+D", t);
764
                  error ("as %qD", x);
765
                  /* We don't try to push this declaration since that
766
                     causes a crash.  */
767
                  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
768
                }
769
            }
770
        }
771
 
772
      /* If x has C linkage-specification, (extern "C"),
773
         lookup its binding, in case it's already bound to an object.
774
         The lookup is done in all namespaces.
775
         If we find an existing binding, make sure it has the same
776
         exception specification as x, otherwise, bail in error [7.5, 7.6].  */
777
      if ((TREE_CODE (x) == FUNCTION_DECL)
778
          && DECL_EXTERN_C_P (x)
779
          /* We should ignore declarations happening in system headers.  */
780
          && !DECL_ARTIFICIAL (x)
781
          && !DECL_IN_SYSTEM_HEADER (x))
782
        {
783
          cxx_binding *function_binding =
784
              lookup_extern_c_fun_binding_in_all_ns (x);
785
          tree previous = (function_binding
786
                           ? function_binding->value
787
                           : NULL_TREE);
788
          if (previous
789
              && !DECL_ARTIFICIAL (previous)
790
              && !DECL_IN_SYSTEM_HEADER (previous)
791
              && DECL_CONTEXT (previous) != DECL_CONTEXT (x))
792
            {
793
              tree previous = function_binding->value;
794
 
795
              /* In case either x or previous is declared to throw an exception,
796
                 make sure both exception specifications are equal.  */
797
              if (decls_match (x, previous))
798
                {
799
                  tree x_exception_spec = NULL_TREE;
800
                  tree previous_exception_spec = NULL_TREE;
801
 
802
                  x_exception_spec =
803
                                TYPE_RAISES_EXCEPTIONS (TREE_TYPE (x));
804
                  previous_exception_spec =
805
                                TYPE_RAISES_EXCEPTIONS (TREE_TYPE (previous));
806
                  if (!comp_except_specs (previous_exception_spec,
807
                                          x_exception_spec,
808
                                          true))
809
                    {
810
                      pedwarn (input_location, 0, "declaration of %q#D with C language linkage",
811
                               x);
812
                      pedwarn (input_location, 0, "conflicts with previous declaration %q+#D",
813
                               previous);
814
                      pedwarn (input_location, 0, "due to different exception specifications");
815
                      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
816
                    }
817
                }
818
              else
819
                {
820
                  pedwarn (input_location, 0,
821
                           "declaration of %q#D with C language linkage", x);
822
                  pedwarn (input_location, 0,
823
                           "conflicts with previous declaration %q+#D",
824
                           previous);
825
                }
826
            }
827
        }
828
 
829
      check_template_shadow (x);
830
 
831
      /* If this is a function conjured up by the back end, massage it
832
         so it looks friendly.  */
833
      if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
834
        {
835
          retrofit_lang_decl (x);
836
          SET_DECL_LANGUAGE (x, lang_c);
837
        }
838
 
839
      t = x;
840
      if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_FUNCTION_MEMBER_P (x))
841
        {
842
          t = push_overloaded_decl (x, PUSH_LOCAL, is_friend);
843
          if (!namespace_bindings_p ())
844
            /* We do not need to create a binding for this name;
845
               push_overloaded_decl will have already done so if
846
               necessary.  */
847
            need_new_binding = 0;
848
        }
849
      else if (DECL_FUNCTION_TEMPLATE_P (x) && DECL_NAMESPACE_SCOPE_P (x))
850
        {
851
          t = push_overloaded_decl (x, PUSH_GLOBAL, is_friend);
852
          if (t == x)
853
            add_decl_to_level (x, NAMESPACE_LEVEL (CP_DECL_CONTEXT (t)));
854
        }
855
 
856
      if (TREE_CODE (t) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (t))
857
        check_default_args (t);
858
 
859
      if (t != x || DECL_FUNCTION_TEMPLATE_P (t))
860
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
861
 
862
      /* If declaring a type as a typedef, copy the type (unless we're
863
         at line 0), and install this TYPE_DECL as the new type's typedef
864
         name.  See the extensive comment of set_underlying_type ().  */
865
      if (TREE_CODE (x) == TYPE_DECL)
866
        {
867
          tree type = TREE_TYPE (x);
868
 
869
          if (DECL_IS_BUILTIN (x)
870
              || (TREE_TYPE (x) != error_mark_node
871
                  && TYPE_NAME (type) != x
872
                  /* We don't want to copy the type when all we're
873
                     doing is making a TYPE_DECL for the purposes of
874
                     inlining.  */
875
                  && (!TYPE_NAME (type)
876
                      || TYPE_NAME (type) != DECL_ABSTRACT_ORIGIN (x))))
877
            cp_set_underlying_type (x);
878
 
879
          if (type != error_mark_node
880
              && TYPE_NAME (type)
881
              && TYPE_IDENTIFIER (type))
882
            set_identifier_type_value (DECL_NAME (x), x);
883
        }
884
 
885
      /* Multiple external decls of the same identifier ought to match.
886
 
887
         We get warnings about inline functions where they are defined.
888
         We get warnings about other functions from push_overloaded_decl.
889
 
890
         Avoid duplicate warnings where they are used.  */
891
      if (TREE_PUBLIC (x) && TREE_CODE (x) != FUNCTION_DECL)
892
        {
893
          tree decl;
894
 
895
          decl = IDENTIFIER_NAMESPACE_VALUE (name);
896
          if (decl && TREE_CODE (decl) == OVERLOAD)
897
            decl = OVL_FUNCTION (decl);
898
 
899
          if (decl && decl != error_mark_node
900
              && (DECL_EXTERNAL (decl) || TREE_PUBLIC (decl))
901
              /* If different sort of thing, we already gave an error.  */
902
              && TREE_CODE (decl) == TREE_CODE (x)
903
              && !same_type_p (TREE_TYPE (x), TREE_TYPE (decl)))
904
            {
905
              permerror (input_location, "type mismatch with previous external decl of %q#D", x);
906
              permerror (input_location, "previous external decl of %q+#D", decl);
907
            }
908
        }
909
 
910
      if (TREE_CODE (x) == FUNCTION_DECL
911
          && is_friend
912
          && !flag_friend_injection)
913
        {
914
          /* This is a new declaration of a friend function, so hide
915
             it from ordinary function lookup.  */
916
          DECL_ANTICIPATED (x) = 1;
917
          DECL_HIDDEN_FRIEND_P (x) = 1;
918
        }
919
 
920
      /* This name is new in its binding level.
921
         Install the new declaration and return it.  */
922
      if (namespace_bindings_p ())
923
        {
924
          /* Install a global value.  */
925
 
926
          /* If the first global decl has external linkage,
927
             warn if we later see static one.  */
928
          if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
929
            TREE_PUBLIC (name) = 1;
930
 
931
          /* Bind the name for the entity.  */
932
          if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
933
                && t != NULL_TREE)
934
              && (TREE_CODE (x) == TYPE_DECL
935
                  || TREE_CODE (x) == VAR_DECL
936
                  || TREE_CODE (x) == NAMESPACE_DECL
937
                  || TREE_CODE (x) == CONST_DECL
938
                  || TREE_CODE (x) == TEMPLATE_DECL))
939
            SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
940
 
941
          /* If new decl is `static' and an `extern' was seen previously,
942
             warn about it.  */
943
          if (x != NULL_TREE && t != NULL_TREE && decls_match (x, t))
944
            warn_extern_redeclared_static (x, t);
945
        }
946
      else
947
        {
948
          /* Here to install a non-global value.  */
949
          tree oldlocal = innermost_non_namespace_value (name);
950
          tree oldglobal = IDENTIFIER_NAMESPACE_VALUE (name);
951
 
952
          if (need_new_binding)
953
            {
954
              push_local_binding (name, x, 0);
955
              /* Because push_local_binding will hook X on to the
956
                 current_binding_level's name list, we don't want to
957
                 do that again below.  */
958
              need_new_binding = 0;
959
            }
960
 
961
          /* If this is a TYPE_DECL, push it into the type value slot.  */
962
          if (TREE_CODE (x) == TYPE_DECL)
963
            set_identifier_type_value (name, x);
964
 
965
          /* Clear out any TYPE_DECL shadowed by a namespace so that
966
             we won't think this is a type.  The C struct hack doesn't
967
             go through namespaces.  */
968
          if (TREE_CODE (x) == NAMESPACE_DECL)
969
            set_identifier_type_value (name, NULL_TREE);
970
 
971
          if (oldlocal)
972
            {
973
              tree d = oldlocal;
974
 
975
              while (oldlocal
976
                     && TREE_CODE (oldlocal) == VAR_DECL
977
                     && DECL_DEAD_FOR_LOCAL (oldlocal))
978
                oldlocal = DECL_SHADOWED_FOR_VAR (oldlocal);
979
 
980
              if (oldlocal == NULL_TREE)
981
                oldlocal = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (d));
982
            }
983
 
984
          /* If this is an extern function declaration, see if we
985
             have a global definition or declaration for the function.  */
986
          if (oldlocal == NULL_TREE
987
              && DECL_EXTERNAL (x)
988
              && oldglobal != NULL_TREE
989
              && TREE_CODE (x) == FUNCTION_DECL
990
              && TREE_CODE (oldglobal) == FUNCTION_DECL)
991
            {
992
              /* We have one.  Their types must agree.  */
993
              if (decls_match (x, oldglobal))
994
                /* OK */;
995
              else
996
                {
997
                  warning (0, "extern declaration of %q#D doesn't match", x);
998
                  warning (0, "global declaration %q+#D", oldglobal);
999
                }
1000
            }
1001
          /* If we have a local external declaration,
1002
             and no file-scope declaration has yet been seen,
1003
             then if we later have a file-scope decl it must not be static.  */
1004
          if (oldlocal == NULL_TREE
1005
              && oldglobal == NULL_TREE
1006
              && DECL_EXTERNAL (x)
1007
              && TREE_PUBLIC (x))
1008
            TREE_PUBLIC (name) = 1;
1009
 
1010
          /* Don't complain about the parms we push and then pop
1011
             while tentatively parsing a function declarator.  */
1012
          if (TREE_CODE (x) == PARM_DECL && DECL_CONTEXT (x) == NULL_TREE)
1013
            /* Ignore.  */;
1014
 
1015
          /* Warn if shadowing an argument at the top level of the body.  */
1016
          else if (oldlocal != NULL_TREE && !DECL_EXTERNAL (x)
1017
                   /* Inline decls shadow nothing.  */
1018
                   && !DECL_FROM_INLINE (x)
1019
                   && TREE_CODE (oldlocal) == PARM_DECL
1020
                   /* Don't check the `this' parameter.  */
1021
                   && !DECL_ARTIFICIAL (oldlocal))
1022
            {
1023
              bool err = false;
1024
 
1025
              /* Don't complain if it's from an enclosing function.  */
1026
              if (DECL_CONTEXT (oldlocal) == current_function_decl
1027
                  && TREE_CODE (x) != PARM_DECL)
1028
                {
1029
                  /* Go to where the parms should be and see if we find
1030
                     them there.  */
1031
                  struct cp_binding_level *b = current_binding_level->level_chain;
1032
 
1033
                  if (FUNCTION_NEEDS_BODY_BLOCK (current_function_decl))
1034
                    /* Skip the ctor/dtor cleanup level.  */
1035
                    b = b->level_chain;
1036
 
1037
                  /* ARM $8.3 */
1038
                  if (b->kind == sk_function_parms)
1039
                    {
1040
                      error ("declaration of %q#D shadows a parameter", x);
1041
                      err = true;
1042
                    }
1043
                }
1044
 
1045
              if (warn_shadow && !err)
1046
                {
1047
                  warning_at (input_location, OPT_Wshadow,
1048
                              "declaration of %q#D shadows a parameter", x);
1049
                  warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1050
                              "shadowed declaration is here");
1051
                }
1052
            }
1053
 
1054
          /* Maybe warn if shadowing something else.  */
1055
          else if (warn_shadow && !DECL_EXTERNAL (x)
1056
              /* No shadow warnings for internally generated vars.  */
1057
              && ! DECL_ARTIFICIAL (x)
1058
              /* No shadow warnings for vars made for inlining.  */
1059
              && ! DECL_FROM_INLINE (x))
1060
            {
1061
              tree member;
1062
 
1063
              if (current_class_ptr)
1064
                member = lookup_member (current_class_type,
1065
                                        name,
1066
                                        /*protect=*/0,
1067
                                        /*want_type=*/false);
1068
              else
1069
                member = NULL_TREE;
1070
 
1071
              if (member && !TREE_STATIC (member))
1072
                {
1073
                  /* Location of previous decl is not useful in this case.  */
1074
                  warning (OPT_Wshadow, "declaration of %qD shadows a member of 'this'",
1075
                           x);
1076
                }
1077
              else if (oldlocal != NULL_TREE
1078
                       && TREE_CODE (oldlocal) == VAR_DECL)
1079
                {
1080
                  warning_at (input_location, OPT_Wshadow,
1081
                              "declaration of %qD shadows a previous local", x);
1082
                  warning_at (DECL_SOURCE_LOCATION (oldlocal), OPT_Wshadow,
1083
                              "shadowed declaration is here");
1084
                }
1085
              else if (oldglobal != NULL_TREE
1086
                       && TREE_CODE (oldglobal) == VAR_DECL)
1087
                /* XXX shadow warnings in outer-more namespaces */
1088
                {
1089
                  warning_at (input_location, OPT_Wshadow,
1090
                              "declaration of %qD shadows a global declaration", x);
1091
                  warning_at (DECL_SOURCE_LOCATION (oldglobal), OPT_Wshadow,
1092
                              "shadowed declaration is here");
1093
                }
1094
            }
1095
        }
1096
 
1097
      if (TREE_CODE (x) == VAR_DECL)
1098
        maybe_register_incomplete_var (x);
1099
    }
1100
 
1101
  if (need_new_binding)
1102
    add_decl_to_level (x,
1103
                       DECL_NAMESPACE_SCOPE_P (x)
1104
                       ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))
1105
                       : current_binding_level);
1106
 
1107
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1108
}
1109
 
1110
/* Record a decl-node X as belonging to the current lexical scope.  */
1111
 
1112
tree
1113
pushdecl (tree x)
1114
{
1115
  return pushdecl_maybe_friend (x, false);
1116
}
1117
 
1118
/* Enter DECL into the symbol table, if that's appropriate.  Returns
1119
   DECL, or a modified version thereof.  */
1120
 
1121
tree
1122
maybe_push_decl (tree decl)
1123
{
1124
  tree type = TREE_TYPE (decl);
1125
 
1126
  /* Add this decl to the current binding level, but not if it comes
1127
     from another scope, e.g. a static member variable.  TEM may equal
1128
     DECL or it may be a previous decl of the same name.  */
1129
  if (decl == error_mark_node
1130
      || (TREE_CODE (decl) != PARM_DECL
1131
          && DECL_CONTEXT (decl) != NULL_TREE
1132
          /* Definitions of namespace members outside their namespace are
1133
             possible.  */
1134
          && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
1135
      || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
1136
      || TREE_CODE (type) == UNKNOWN_TYPE
1137
      /* The declaration of a template specialization does not affect
1138
         the functions available for overload resolution, so we do not
1139
         call pushdecl.  */
1140
      || (TREE_CODE (decl) == FUNCTION_DECL
1141
          && DECL_TEMPLATE_SPECIALIZATION (decl)))
1142
    return decl;
1143
  else
1144
    return pushdecl (decl);
1145
}
1146
 
1147
/* Bind DECL to ID in the current_binding_level, assumed to be a local
1148
   binding level.  If PUSH_USING is set in FLAGS, we know that DECL
1149
   doesn't really belong to this binding level, that it got here
1150
   through a using-declaration.  */
1151
 
1152
void
1153
push_local_binding (tree id, tree decl, int flags)
1154
{
1155
  struct cp_binding_level *b;
1156
 
1157
  /* Skip over any local classes.  This makes sense if we call
1158
     push_local_binding with a friend decl of a local class.  */
1159
  b = innermost_nonclass_level ();
1160
 
1161
  if (lookup_name_innermost_nonclass_level (id))
1162
    {
1163
      /* Supplement the existing binding.  */
1164
      if (!supplement_binding (IDENTIFIER_BINDING (id), decl))
1165
        /* It didn't work.  Something else must be bound at this
1166
           level.  Do not add DECL to the list of things to pop
1167
           later.  */
1168
        return;
1169
    }
1170
  else
1171
    /* Create a new binding.  */
1172
    push_binding (id, decl, b);
1173
 
1174
  if (TREE_CODE (decl) == OVERLOAD || (flags & PUSH_USING))
1175
    /* We must put the OVERLOAD into a TREE_LIST since the
1176
       TREE_CHAIN of an OVERLOAD is already used.  Similarly for
1177
       decls that got here through a using-declaration.  */
1178
    decl = build_tree_list (NULL_TREE, decl);
1179
 
1180
  /* And put DECL on the list of things declared by the current
1181
     binding level.  */
1182
  add_decl_to_level (decl, b);
1183
}
1184
 
1185
/* Check to see whether or not DECL is a variable that would have been
1186
   in scope under the ARM, but is not in scope under the ANSI/ISO
1187
   standard.  If so, issue an error message.  If name lookup would
1188
   work in both cases, but return a different result, this function
1189
   returns the result of ANSI/ISO lookup.  Otherwise, it returns
1190
   DECL.  */
1191
 
1192
tree
1193
check_for_out_of_scope_variable (tree decl)
1194
{
1195
  tree shadowed;
1196
 
1197
  /* We only care about out of scope variables.  */
1198
  if (!(TREE_CODE (decl) == VAR_DECL && DECL_DEAD_FOR_LOCAL (decl)))
1199
    return decl;
1200
 
1201
  shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (decl)
1202
    ? DECL_SHADOWED_FOR_VAR (decl) : NULL_TREE ;
1203
  while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1204
         && DECL_DEAD_FOR_LOCAL (shadowed))
1205
    shadowed = DECL_HAS_SHADOWED_FOR_VAR_P (shadowed)
1206
      ? DECL_SHADOWED_FOR_VAR (shadowed) : NULL_TREE;
1207
  if (!shadowed)
1208
    shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (decl));
1209
  if (shadowed)
1210
    {
1211
      if (!DECL_ERROR_REPORTED (decl))
1212
        {
1213
          warning (0, "name lookup of %qD changed", DECL_NAME (decl));
1214
          warning (0, "  matches this %q+D under ISO standard rules",
1215
                   shadowed);
1216
          warning (0, "  matches this %q+D under old rules", decl);
1217
          DECL_ERROR_REPORTED (decl) = 1;
1218
        }
1219
      return shadowed;
1220
    }
1221
 
1222
  /* If we have already complained about this declaration, there's no
1223
     need to do it again.  */
1224
  if (DECL_ERROR_REPORTED (decl))
1225
    return decl;
1226
 
1227
  DECL_ERROR_REPORTED (decl) = 1;
1228
 
1229
  if (TREE_TYPE (decl) == error_mark_node)
1230
    return decl;
1231
 
1232
  if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (decl)))
1233
    {
1234
      error ("name lookup of %qD changed for ISO %<for%> scoping",
1235
             DECL_NAME (decl));
1236
      error ("  cannot use obsolete binding at %q+D because "
1237
             "it has a destructor", decl);
1238
      return error_mark_node;
1239
    }
1240
  else
1241
    {
1242
      permerror (input_location, "name lookup of %qD changed for ISO %<for%> scoping",
1243
                 DECL_NAME (decl));
1244
      if (flag_permissive)
1245
        permerror (input_location, "  using obsolete binding at %q+D", decl);
1246
      else
1247
        {
1248
          static bool hint;
1249
          if (!hint)
1250
            {
1251
              inform (input_location, "(if you use %<-fpermissive%> G++ will accept your code)");
1252
              hint = true;
1253
            }
1254
        }
1255
    }
1256
 
1257
  return decl;
1258
}
1259
 
1260
/* true means unconditionally make a BLOCK for the next level pushed.  */
1261
 
1262
static bool keep_next_level_flag;
1263
 
1264
static int binding_depth = 0;
1265
 
1266
static void
1267
indent (int depth)
1268
{
1269
  int i;
1270
 
1271
  for (i = 0; i < depth * 2; i++)
1272
    putc (' ', stderr);
1273
}
1274
 
1275
/* Return a string describing the kind of SCOPE we have.  */
1276
static const char *
1277
cxx_scope_descriptor (cxx_scope *scope)
1278
{
1279
  /* The order of this table must match the "scope_kind"
1280
     enumerators.  */
1281
  static const char* scope_kind_names[] = {
1282
    "block-scope",
1283
    "cleanup-scope",
1284
    "try-scope",
1285
    "catch-scope",
1286
    "for-scope",
1287
    "function-parameter-scope",
1288
    "class-scope",
1289
    "namespace-scope",
1290
    "template-parameter-scope",
1291
    "template-explicit-spec-scope"
1292
  };
1293
  const scope_kind kind = scope->explicit_spec_p
1294
    ? sk_template_spec : scope->kind;
1295
 
1296
  return scope_kind_names[kind];
1297
}
1298
 
1299
/* Output a debugging information about SCOPE when performing
1300
   ACTION at LINE.  */
1301
static void
1302
cxx_scope_debug (cxx_scope *scope, int line, const char *action)
1303
{
1304
  const char *desc = cxx_scope_descriptor (scope);
1305
  if (scope->this_entity)
1306
    verbatim ("%s %s(%E) %p %d\n", action, desc,
1307
              scope->this_entity, (void *) scope, line);
1308
  else
1309
    verbatim ("%s %s %p %d\n", action, desc, (void *) scope, line);
1310
}
1311
 
1312
/* Return the estimated initial size of the hashtable of a NAMESPACE
1313
   scope.  */
1314
 
1315
static inline size_t
1316
namespace_scope_ht_size (tree ns)
1317
{
1318
  tree name = DECL_NAME (ns);
1319
 
1320
  return name == std_identifier
1321
    ? NAMESPACE_STD_HT_SIZE
1322
    : (name == global_scope_name
1323
       ? GLOBAL_SCOPE_HT_SIZE
1324
       : NAMESPACE_ORDINARY_HT_SIZE);
1325
}
1326
 
1327
/* A chain of binding_level structures awaiting reuse.  */
1328
 
1329
static GTY((deletable)) struct cp_binding_level *free_binding_level;
1330
 
1331
/* Insert SCOPE as the innermost binding level.  */
1332
 
1333
void
1334
push_binding_level (struct cp_binding_level *scope)
1335
{
1336
  /* Add it to the front of currently active scopes stack.  */
1337
  scope->level_chain = current_binding_level;
1338
  current_binding_level = scope;
1339
  keep_next_level_flag = false;
1340
 
1341
  if (ENABLE_SCOPE_CHECKING)
1342
    {
1343
      scope->binding_depth = binding_depth;
1344
      indent (binding_depth);
1345
      cxx_scope_debug (scope, input_line, "push");
1346
      binding_depth++;
1347
    }
1348
}
1349
 
1350
/* Create a new KIND scope and make it the top of the active scopes stack.
1351
   ENTITY is the scope of the associated C++ entity (namespace, class,
1352
   function, C++0x enumeration); it is NULL otherwise.  */
1353
 
1354
cxx_scope *
1355
begin_scope (scope_kind kind, tree entity)
1356
{
1357
  cxx_scope *scope;
1358
 
1359
  /* Reuse or create a struct for this binding level.  */
1360
  if (!ENABLE_SCOPE_CHECKING && free_binding_level)
1361
    {
1362
      scope = free_binding_level;
1363
      memset (scope, 0, sizeof (cxx_scope));
1364
      free_binding_level = scope->level_chain;
1365
    }
1366
  else
1367
    scope = GGC_CNEW (cxx_scope);
1368
 
1369
  scope->this_entity = entity;
1370
  scope->more_cleanups_ok = true;
1371
  switch (kind)
1372
    {
1373
    case sk_cleanup:
1374
      scope->keep = true;
1375
      break;
1376
 
1377
    case sk_template_spec:
1378
      scope->explicit_spec_p = true;
1379
      kind = sk_template_parms;
1380
      /* Fall through.  */
1381
    case sk_template_parms:
1382
    case sk_block:
1383
    case sk_try:
1384
    case sk_catch:
1385
    case sk_for:
1386
    case sk_class:
1387
    case sk_scoped_enum:
1388
    case sk_function_parms:
1389
    case sk_omp:
1390
      scope->keep = keep_next_level_flag;
1391
      break;
1392
 
1393
    case sk_namespace:
1394
      NAMESPACE_LEVEL (entity) = scope;
1395
      scope->static_decls =
1396
        VEC_alloc (tree, gc,
1397
                   DECL_NAME (entity) == std_identifier
1398
                   || DECL_NAME (entity) == global_scope_name
1399
                   ? 200 : 10);
1400
      break;
1401
 
1402
    default:
1403
      /* Should not happen.  */
1404
      gcc_unreachable ();
1405
      break;
1406
    }
1407
  scope->kind = kind;
1408
 
1409
  push_binding_level (scope);
1410
 
1411
  return scope;
1412
}
1413
 
1414
/* We're about to leave current scope.  Pop the top of the stack of
1415
   currently active scopes.  Return the enclosing scope, now active.  */
1416
 
1417
cxx_scope *
1418
leave_scope (void)
1419
{
1420
  cxx_scope *scope = current_binding_level;
1421
 
1422
  if (scope->kind == sk_namespace && class_binding_level)
1423
    current_binding_level = class_binding_level;
1424
 
1425
  /* We cannot leave a scope, if there are none left.  */
1426
  if (NAMESPACE_LEVEL (global_namespace))
1427
    gcc_assert (!global_scope_p (scope));
1428
 
1429
  if (ENABLE_SCOPE_CHECKING)
1430
    {
1431
      indent (--binding_depth);
1432
      cxx_scope_debug (scope, input_line, "leave");
1433
    }
1434
 
1435
  /* Move one nesting level up.  */
1436
  current_binding_level = scope->level_chain;
1437
 
1438
  /* Namespace-scopes are left most probably temporarily, not
1439
     completely; they can be reopened later, e.g. in namespace-extension
1440
     or any name binding activity that requires us to resume a
1441
     namespace.  For classes, we cache some binding levels.  For other
1442
     scopes, we just make the structure available for reuse.  */
1443
  if (scope->kind != sk_namespace
1444
      && scope->kind != sk_class)
1445
    {
1446
      scope->level_chain = free_binding_level;
1447
      gcc_assert (!ENABLE_SCOPE_CHECKING
1448
                  || scope->binding_depth == binding_depth);
1449
      free_binding_level = scope;
1450
    }
1451
 
1452
  /* Find the innermost enclosing class scope, and reset
1453
     CLASS_BINDING_LEVEL appropriately.  */
1454
  if (scope->kind == sk_class)
1455
    {
1456
      class_binding_level = NULL;
1457
      for (scope = current_binding_level; scope; scope = scope->level_chain)
1458
        if (scope->kind == sk_class)
1459
          {
1460
            class_binding_level = scope;
1461
            break;
1462
          }
1463
    }
1464
 
1465
  return current_binding_level;
1466
}
1467
 
1468
static void
1469
resume_scope (struct cp_binding_level* b)
1470
{
1471
  /* Resuming binding levels is meant only for namespaces,
1472
     and those cannot nest into classes.  */
1473
  gcc_assert (!class_binding_level);
1474
  /* Also, resuming a non-directly nested namespace is a no-no.  */
1475
  gcc_assert (b->level_chain == current_binding_level);
1476
  current_binding_level = b;
1477
  if (ENABLE_SCOPE_CHECKING)
1478
    {
1479
      b->binding_depth = binding_depth;
1480
      indent (binding_depth);
1481
      cxx_scope_debug (b, input_line, "resume");
1482
      binding_depth++;
1483
    }
1484
}
1485
 
1486
/* Return the innermost binding level that is not for a class scope.  */
1487
 
1488
static cxx_scope *
1489
innermost_nonclass_level (void)
1490
{
1491
  cxx_scope *b;
1492
 
1493
  b = current_binding_level;
1494
  while (b->kind == sk_class)
1495
    b = b->level_chain;
1496
 
1497
  return b;
1498
}
1499
 
1500
/* We're defining an object of type TYPE.  If it needs a cleanup, but
1501
   we're not allowed to add any more objects with cleanups to the current
1502
   scope, create a new binding level.  */
1503
 
1504
void
1505
maybe_push_cleanup_level (tree type)
1506
{
1507
  if (type != error_mark_node
1508
      && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
1509
      && current_binding_level->more_cleanups_ok == 0)
1510
    {
1511
      begin_scope (sk_cleanup, NULL);
1512
      current_binding_level->statement_list = push_stmt_list ();
1513
    }
1514
}
1515
 
1516
/* Nonzero if we are currently in the global binding level.  */
1517
 
1518
int
1519
global_bindings_p (void)
1520
{
1521
  return global_scope_p (current_binding_level);
1522
}
1523
 
1524
/* True if we are currently in a toplevel binding level.  This
1525
   means either the global binding level or a namespace in a toplevel
1526
   binding level.  Since there are no non-toplevel namespace levels,
1527
   this really means any namespace or template parameter level.  We
1528
   also include a class whose context is toplevel.  */
1529
 
1530
bool
1531
toplevel_bindings_p (void)
1532
{
1533
  struct cp_binding_level *b = innermost_nonclass_level ();
1534
 
1535
  return b->kind == sk_namespace || b->kind == sk_template_parms;
1536
}
1537
 
1538
/* True if this is a namespace scope, or if we are defining a class
1539
   which is itself at namespace scope, or whose enclosing class is
1540
   such a class, etc.  */
1541
 
1542
bool
1543
namespace_bindings_p (void)
1544
{
1545
  struct cp_binding_level *b = innermost_nonclass_level ();
1546
 
1547
  return b->kind == sk_namespace;
1548
}
1549
 
1550
/* True if the current level needs to have a BLOCK made.  */
1551
 
1552
bool
1553
kept_level_p (void)
1554
{
1555
  return (current_binding_level->blocks != NULL_TREE
1556
          || current_binding_level->keep
1557
          || current_binding_level->kind == sk_cleanup
1558
          || current_binding_level->names != NULL_TREE
1559
          || current_binding_level->using_directives);
1560
}
1561
 
1562
/* Returns the kind of the innermost scope.  */
1563
 
1564
scope_kind
1565
innermost_scope_kind (void)
1566
{
1567
  return current_binding_level->kind;
1568
}
1569
 
1570
/* Returns true if this scope was created to store template parameters.  */
1571
 
1572
bool
1573
template_parm_scope_p (void)
1574
{
1575
  return innermost_scope_kind () == sk_template_parms;
1576
}
1577
 
1578
/* If KEEP is true, make a BLOCK node for the next binding level,
1579
   unconditionally.  Otherwise, use the normal logic to decide whether
1580
   or not to create a BLOCK.  */
1581
 
1582
void
1583
keep_next_level (bool keep)
1584
{
1585
  keep_next_level_flag = keep;
1586
}
1587
 
1588
/* Return the list of declarations of the current level.
1589
   Note that this list is in reverse order unless/until
1590
   you nreverse it; and when you do nreverse it, you must
1591
   store the result back using `storedecls' or you will lose.  */
1592
 
1593
tree
1594
getdecls (void)
1595
{
1596
  return current_binding_level->names;
1597
}
1598
 
1599
/* For debugging.  */
1600
static int no_print_functions = 0;
1601
static int no_print_builtins = 0;
1602
 
1603
static void
1604
print_binding_level (struct cp_binding_level* lvl)
1605
{
1606
  tree t;
1607
  int i = 0, len;
1608
  fprintf (stderr, " blocks=%p", (void *) lvl->blocks);
1609
  if (lvl->more_cleanups_ok)
1610
    fprintf (stderr, " more-cleanups-ok");
1611
  if (lvl->have_cleanups)
1612
    fprintf (stderr, " have-cleanups");
1613
  fprintf (stderr, "\n");
1614
  if (lvl->names)
1615
    {
1616
      fprintf (stderr, " names:\t");
1617
      /* We can probably fit 3 names to a line?  */
1618
      for (t = lvl->names; t; t = TREE_CHAIN (t))
1619
        {
1620
          if (no_print_functions && (TREE_CODE (t) == FUNCTION_DECL))
1621
            continue;
1622
          if (no_print_builtins
1623
              && (TREE_CODE (t) == TYPE_DECL)
1624
              && DECL_IS_BUILTIN (t))
1625
            continue;
1626
 
1627
          /* Function decls tend to have longer names.  */
1628
          if (TREE_CODE (t) == FUNCTION_DECL)
1629
            len = 3;
1630
          else
1631
            len = 2;
1632
          i += len;
1633
          if (i > 6)
1634
            {
1635
              fprintf (stderr, "\n\t");
1636
              i = len;
1637
            }
1638
          print_node_brief (stderr, "", t, 0);
1639
          if (t == error_mark_node)
1640
            break;
1641
        }
1642
      if (i)
1643
        fprintf (stderr, "\n");
1644
    }
1645
  if (VEC_length (cp_class_binding, lvl->class_shadowed))
1646
    {
1647
      size_t i;
1648
      cp_class_binding *b;
1649
      fprintf (stderr, " class-shadowed:");
1650
      for (i = 0;
1651
           VEC_iterate(cp_class_binding, lvl->class_shadowed, i, b);
1652
           ++i)
1653
        fprintf (stderr, " %s ", IDENTIFIER_POINTER (b->identifier));
1654
      fprintf (stderr, "\n");
1655
    }
1656
  if (lvl->type_shadowed)
1657
    {
1658
      fprintf (stderr, " type-shadowed:");
1659
      for (t = lvl->type_shadowed; t; t = TREE_CHAIN (t))
1660
        {
1661
          fprintf (stderr, " %s ", IDENTIFIER_POINTER (TREE_PURPOSE (t)));
1662
        }
1663
      fprintf (stderr, "\n");
1664
    }
1665
}
1666
 
1667
void
1668
print_other_binding_stack (struct cp_binding_level *stack)
1669
{
1670
  struct cp_binding_level *level;
1671
  for (level = stack; !global_scope_p (level); level = level->level_chain)
1672
    {
1673
      fprintf (stderr, "binding level %p\n", (void *) level);
1674
      print_binding_level (level);
1675
    }
1676
}
1677
 
1678
void
1679
print_binding_stack (void)
1680
{
1681
  struct cp_binding_level *b;
1682
  fprintf (stderr, "current_binding_level=%p\n"
1683
           "class_binding_level=%p\n"
1684
           "NAMESPACE_LEVEL (global_namespace)=%p\n",
1685
           (void *) current_binding_level, (void *) class_binding_level,
1686
           (void *) NAMESPACE_LEVEL (global_namespace));
1687
  if (class_binding_level)
1688
    {
1689
      for (b = class_binding_level; b; b = b->level_chain)
1690
        if (b == current_binding_level)
1691
          break;
1692
      if (b)
1693
        b = class_binding_level;
1694
      else
1695
        b = current_binding_level;
1696
    }
1697
  else
1698
    b = current_binding_level;
1699
  print_other_binding_stack (b);
1700
  fprintf (stderr, "global:\n");
1701
  print_binding_level (NAMESPACE_LEVEL (global_namespace));
1702
}
1703
 
1704
/* Return the type associated with id.  */
1705
 
1706
tree
1707
identifier_type_value (tree id)
1708
{
1709
  timevar_push (TV_NAME_LOOKUP);
1710
  /* There is no type with that name, anywhere.  */
1711
  if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
1712
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1713
  /* This is not the type marker, but the real thing.  */
1714
  if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
1715
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, REAL_IDENTIFIER_TYPE_VALUE (id));
1716
  /* Have to search for it. It must be on the global level, now.
1717
     Ask lookup_name not to return non-types.  */
1718
  id = lookup_name_real (id, 2, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
1719
  if (id)
1720
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, TREE_TYPE (id));
1721
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
1722
}
1723
 
1724
/* Return the IDENTIFIER_GLOBAL_VALUE of T, for use in common code, since
1725
   the definition of IDENTIFIER_GLOBAL_VALUE is different for C and C++.  */
1726
 
1727
tree
1728
identifier_global_value (tree t)
1729
{
1730
  return IDENTIFIER_GLOBAL_VALUE (t);
1731
}
1732
 
1733
/* Push a definition of struct, union or enum tag named ID.  into
1734
   binding_level B.  DECL is a TYPE_DECL for the type.  We assume that
1735
   the tag ID is not already defined.  */
1736
 
1737
static void
1738
set_identifier_type_value_with_scope (tree id, tree decl, cxx_scope *b)
1739
{
1740
  tree type;
1741
 
1742
  if (b->kind != sk_namespace)
1743
    {
1744
      /* Shadow the marker, not the real thing, so that the marker
1745
         gets restored later.  */
1746
      tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
1747
      b->type_shadowed
1748
        = tree_cons (id, old_type_value, b->type_shadowed);
1749
      type = decl ? TREE_TYPE (decl) : NULL_TREE;
1750
      TREE_TYPE (b->type_shadowed) = type;
1751
    }
1752
  else
1753
    {
1754
      cxx_binding *binding =
1755
        binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
1756
      gcc_assert (decl);
1757
      if (binding->value)
1758
        supplement_binding (binding, decl);
1759
      else
1760
        binding->value = decl;
1761
 
1762
      /* Store marker instead of real type.  */
1763
      type = global_type_node;
1764
    }
1765
  SET_IDENTIFIER_TYPE_VALUE (id, type);
1766
}
1767
 
1768
/* As set_identifier_type_value_with_scope, but using
1769
   current_binding_level.  */
1770
 
1771
void
1772
set_identifier_type_value (tree id, tree decl)
1773
{
1774
  set_identifier_type_value_with_scope (id, decl, current_binding_level);
1775
}
1776
 
1777
/* Return the name for the constructor (or destructor) for the
1778
   specified class TYPE.  When given a template, this routine doesn't
1779
   lose the specialization.  */
1780
 
1781
static inline tree
1782
constructor_name_full (tree type)
1783
{
1784
  return TYPE_IDENTIFIER (TYPE_MAIN_VARIANT (type));
1785
}
1786
 
1787
/* Return the name for the constructor (or destructor) for the
1788
   specified class.  When given a template, return the plain
1789
   unspecialized name.  */
1790
 
1791
tree
1792
constructor_name (tree type)
1793
{
1794
  tree name;
1795
  name = constructor_name_full (type);
1796
  if (IDENTIFIER_TEMPLATE (name))
1797
    name = IDENTIFIER_TEMPLATE (name);
1798
  return name;
1799
}
1800
 
1801
/* Returns TRUE if NAME is the name for the constructor for TYPE,
1802
   which must be a class type.  */
1803
 
1804
bool
1805
constructor_name_p (tree name, tree type)
1806
{
1807
  tree ctor_name;
1808
 
1809
  gcc_assert (MAYBE_CLASS_TYPE_P (type));
1810
 
1811
  if (!name)
1812
    return false;
1813
 
1814
  if (TREE_CODE (name) != IDENTIFIER_NODE)
1815
    return false;
1816
 
1817
  ctor_name = constructor_name_full (type);
1818
  if (name == ctor_name)
1819
    return true;
1820
  if (IDENTIFIER_TEMPLATE (ctor_name)
1821
      && name == IDENTIFIER_TEMPLATE (ctor_name))
1822
    return true;
1823
  return false;
1824
}
1825
 
1826
/* Counter used to create anonymous type names.  */
1827
 
1828
static GTY(()) int anon_cnt;
1829
 
1830
/* Return an IDENTIFIER which can be used as a name for
1831
   anonymous structs and unions.  */
1832
 
1833
tree
1834
make_anon_name (void)
1835
{
1836
  char buf[32];
1837
 
1838
  sprintf (buf, ANON_AGGRNAME_FORMAT, anon_cnt++);
1839
  return get_identifier (buf);
1840
}
1841
 
1842
/* This code is practically identical to that for creating
1843
   anonymous names, but is just used for lambdas instead.  This is necessary
1844
   because anonymous names are recognized and cannot be passed to template
1845
   functions.  */
1846
/* FIXME is this still necessary? */
1847
 
1848
static GTY(()) int lambda_cnt = 0;
1849
 
1850
tree
1851
make_lambda_name (void)
1852
{
1853
  char buf[32];
1854
 
1855
  sprintf (buf, LAMBDANAME_FORMAT, lambda_cnt++);
1856
  return get_identifier (buf);
1857
}
1858
 
1859
/* Return (from the stack of) the BINDING, if any, established at SCOPE.  */
1860
 
1861
static inline cxx_binding *
1862
find_binding (cxx_scope *scope, cxx_binding *binding)
1863
{
1864
  timevar_push (TV_NAME_LOOKUP);
1865
 
1866
  for (; binding != NULL; binding = binding->previous)
1867
    if (binding->scope == scope)
1868
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
1869
 
1870
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
1871
}
1872
 
1873
/* Return the binding for NAME in SCOPE, if any.  Otherwise, return NULL.  */
1874
 
1875
static inline cxx_binding *
1876
cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
1877
{
1878
  cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);
1879
  if (b)
1880
    {
1881
      /* Fold-in case where NAME is used only once.  */
1882
      if (scope == b->scope && b->previous == NULL)
1883
        return b;
1884
      return find_binding (scope, b);
1885
    }
1886
  return NULL;
1887
}
1888
 
1889
/* Always returns a binding for name in scope.  If no binding is
1890
   found, make a new one.  */
1891
 
1892
static cxx_binding *
1893
binding_for_name (cxx_scope *scope, tree name)
1894
{
1895
  cxx_binding *result;
1896
 
1897
  result = cxx_scope_find_binding_for_name (scope, name);
1898
  if (result)
1899
    return result;
1900
  /* Not found, make a new one.  */
1901
  result = cxx_binding_make (NULL, NULL);
1902
  result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
1903
  result->scope = scope;
1904
  result->is_local = false;
1905
  result->value_is_inherited = false;
1906
  IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
1907
  return result;
1908
}
1909
 
1910
/* Walk through the bindings associated to the name of FUNCTION,
1911
   and return the first binding that declares a function with a
1912
   "C" linkage specification, a.k.a 'extern "C"'.
1913
   This function looks for the binding, regardless of which scope it
1914
   has been defined in. It basically looks in all the known scopes.
1915
   Note that this function does not lookup for bindings of builtin functions
1916
   or for functions declared in system headers.  */
1917
static cxx_binding*
1918
lookup_extern_c_fun_binding_in_all_ns (tree function)
1919
{
1920
  tree name;
1921
  cxx_binding *iter;
1922
 
1923
  gcc_assert (function && TREE_CODE (function) == FUNCTION_DECL);
1924
 
1925
  name = DECL_NAME (function);
1926
  gcc_assert (name && TREE_CODE (name) == IDENTIFIER_NODE);
1927
 
1928
  for (iter = IDENTIFIER_NAMESPACE_BINDINGS (name);
1929
       iter;
1930
       iter = iter->previous)
1931
    {
1932
      if (iter->value
1933
          && TREE_CODE (iter->value) == FUNCTION_DECL
1934
          && DECL_EXTERN_C_P (iter->value)
1935
          && !DECL_ARTIFICIAL (iter->value))
1936
        {
1937
          return iter;
1938
        }
1939
    }
1940
  return NULL;
1941
}
1942
 
1943
/* Insert another USING_DECL into the current binding level, returning
1944
   this declaration. If this is a redeclaration, do nothing, and
1945
   return NULL_TREE if this not in namespace scope (in namespace
1946
   scope, a using decl might extend any previous bindings).  */
1947
 
1948
static tree
1949
push_using_decl (tree scope, tree name)
1950
{
1951
  tree decl;
1952
 
1953
  timevar_push (TV_NAME_LOOKUP);
1954
  gcc_assert (TREE_CODE (scope) == NAMESPACE_DECL);
1955
  gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
1956
  for (decl = current_binding_level->usings; decl; decl = TREE_CHAIN (decl))
1957
    if (USING_DECL_SCOPE (decl) == scope && DECL_NAME (decl) == name)
1958
      break;
1959
  if (decl)
1960
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
1961
                            namespace_bindings_p () ? decl : NULL_TREE);
1962
  decl = build_lang_decl (USING_DECL, name, NULL_TREE);
1963
  USING_DECL_SCOPE (decl) = scope;
1964
  TREE_CHAIN (decl) = current_binding_level->usings;
1965
  current_binding_level->usings = decl;
1966
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
1967
}
1968
 
1969
/* Same as pushdecl, but define X in binding-level LEVEL.  We rely on the
1970
   caller to set DECL_CONTEXT properly.  */
1971
 
1972
tree
1973
pushdecl_with_scope (tree x, cxx_scope *level, bool is_friend)
1974
{
1975
  struct cp_binding_level *b;
1976
  tree function_decl = current_function_decl;
1977
 
1978
  timevar_push (TV_NAME_LOOKUP);
1979
  current_function_decl = NULL_TREE;
1980
  if (level->kind == sk_class)
1981
    {
1982
      b = class_binding_level;
1983
      class_binding_level = level;
1984
      pushdecl_class_level (x);
1985
      class_binding_level = b;
1986
    }
1987
  else
1988
    {
1989
      b = current_binding_level;
1990
      current_binding_level = level;
1991
      x = pushdecl_maybe_friend (x, is_friend);
1992
      current_binding_level = b;
1993
    }
1994
  current_function_decl = function_decl;
1995
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
1996
}
1997
 
1998
/* DECL is a FUNCTION_DECL for a non-member function, which may have
1999
   other definitions already in place.  We get around this by making
2000
   the value of the identifier point to a list of all the things that
2001
   want to be referenced by that name.  It is then up to the users of
2002
   that name to decide what to do with that list.
2003
 
2004
   DECL may also be a TEMPLATE_DECL, with a FUNCTION_DECL in its
2005
   DECL_TEMPLATE_RESULT.  It is dealt with the same way.
2006
 
2007
   FLAGS is a bitwise-or of the following values:
2008
     PUSH_LOCAL: Bind DECL in the current scope, rather than at
2009
                 namespace scope.
2010
     PUSH_USING: DECL is being pushed as the result of a using
2011
                 declaration.
2012
 
2013
   IS_FRIEND is true if this is a friend declaration.
2014
 
2015
   The value returned may be a previous declaration if we guessed wrong
2016
   about what language DECL should belong to (C or C++).  Otherwise,
2017
   it's always DECL (and never something that's not a _DECL).  */
2018
 
2019
static tree
2020
push_overloaded_decl (tree decl, int flags, bool is_friend)
2021
{
2022
  tree name = DECL_NAME (decl);
2023
  tree old;
2024
  tree new_binding;
2025
  int doing_global = (namespace_bindings_p () || !(flags & PUSH_LOCAL));
2026
 
2027
  timevar_push (TV_NAME_LOOKUP);
2028
  if (doing_global)
2029
    old = namespace_binding (name, DECL_CONTEXT (decl));
2030
  else
2031
    old = lookup_name_innermost_nonclass_level (name);
2032
 
2033
  if (old)
2034
    {
2035
      if (TREE_CODE (old) == TYPE_DECL && DECL_ARTIFICIAL (old))
2036
        {
2037
          tree t = TREE_TYPE (old);
2038
          if (MAYBE_CLASS_TYPE_P (t) && warn_shadow
2039
              && (! DECL_IN_SYSTEM_HEADER (decl)
2040
                  || ! DECL_IN_SYSTEM_HEADER (old)))
2041
            warning (OPT_Wshadow, "%q#D hides constructor for %q#T", decl, t);
2042
          old = NULL_TREE;
2043
        }
2044
      else if (is_overloaded_fn (old))
2045
        {
2046
          tree tmp;
2047
 
2048
          for (tmp = old; tmp; tmp = OVL_NEXT (tmp))
2049
            {
2050
              tree fn = OVL_CURRENT (tmp);
2051
              tree dup;
2052
 
2053
              if (TREE_CODE (tmp) == OVERLOAD && OVL_USED (tmp)
2054
                  && !(flags & PUSH_USING)
2055
                  && compparms (TYPE_ARG_TYPES (TREE_TYPE (fn)),
2056
                                TYPE_ARG_TYPES (TREE_TYPE (decl)))
2057
                  && ! decls_match (fn, decl))
2058
                error ("%q#D conflicts with previous using declaration %q#D",
2059
                       decl, fn);
2060
 
2061
              dup = duplicate_decls (decl, fn, is_friend);
2062
              /* If DECL was a redeclaration of FN -- even an invalid
2063
                 one -- pass that information along to our caller.  */
2064
              if (dup == fn || dup == error_mark_node)
2065
                POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, dup);
2066
            }
2067
 
2068
          /* We don't overload implicit built-ins.  duplicate_decls()
2069
             may fail to merge the decls if the new decl is e.g. a
2070
             template function.  */
2071
          if (TREE_CODE (old) == FUNCTION_DECL
2072
              && DECL_ANTICIPATED (old)
2073
              && !DECL_HIDDEN_FRIEND_P (old))
2074
            old = NULL;
2075
        }
2076
      else if (old == error_mark_node)
2077
        /* Ignore the undefined symbol marker.  */
2078
        old = NULL_TREE;
2079
      else
2080
        {
2081
          error ("previous non-function declaration %q+#D", old);
2082
          error ("conflicts with function declaration %q#D", decl);
2083
          POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2084
        }
2085
    }
2086
 
2087
  if (old || TREE_CODE (decl) == TEMPLATE_DECL
2088
      /* If it's a using declaration, we always need to build an OVERLOAD,
2089
         because it's the only way to remember that the declaration comes
2090
         from 'using', and have the lookup behave correctly.  */
2091
      || (flags & PUSH_USING))
2092
    {
2093
      if (old && TREE_CODE (old) != OVERLOAD)
2094
        new_binding = ovl_cons (decl, ovl_cons (old, NULL_TREE));
2095
      else
2096
        new_binding = ovl_cons (decl, old);
2097
      if (flags & PUSH_USING)
2098
        OVL_USED (new_binding) = 1;
2099
    }
2100
  else
2101
    /* NAME is not ambiguous.  */
2102
    new_binding = decl;
2103
 
2104
  if (doing_global)
2105
    set_namespace_binding (name, current_namespace, new_binding);
2106
  else
2107
    {
2108
      /* We only create an OVERLOAD if there was a previous binding at
2109
         this level, or if decl is a template. In the former case, we
2110
         need to remove the old binding and replace it with the new
2111
         binding.  We must also run through the NAMES on the binding
2112
         level where the name was bound to update the chain.  */
2113
 
2114
      if (TREE_CODE (new_binding) == OVERLOAD && old)
2115
        {
2116
          tree *d;
2117
 
2118
          for (d = &IDENTIFIER_BINDING (name)->scope->names;
2119
               *d;
2120
               d = &TREE_CHAIN (*d))
2121
            if (*d == old
2122
                || (TREE_CODE (*d) == TREE_LIST
2123
                    && TREE_VALUE (*d) == old))
2124
              {
2125
                if (TREE_CODE (*d) == TREE_LIST)
2126
                  /* Just replace the old binding with the new.  */
2127
                  TREE_VALUE (*d) = new_binding;
2128
                else
2129
                  /* Build a TREE_LIST to wrap the OVERLOAD.  */
2130
                  *d = tree_cons (NULL_TREE, new_binding,
2131
                                  TREE_CHAIN (*d));
2132
 
2133
                /* And update the cxx_binding node.  */
2134
                IDENTIFIER_BINDING (name)->value = new_binding;
2135
                POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2136
              }
2137
 
2138
          /* We should always find a previous binding in this case.  */
2139
          gcc_unreachable ();
2140
        }
2141
 
2142
      /* Install the new binding.  */
2143
      push_local_binding (name, new_binding, flags);
2144
    }
2145
 
2146
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
2147
}
2148
 
2149
/* Check a non-member using-declaration. Return the name and scope
2150
   being used, and the USING_DECL, or NULL_TREE on failure.  */
2151
 
2152
static tree
2153
validate_nonmember_using_decl (tree decl, tree scope, tree name)
2154
{
2155
  /* [namespace.udecl]
2156
       A using-declaration for a class member shall be a
2157
       member-declaration.  */
2158
  if (TYPE_P (scope))
2159
    {
2160
      error ("%qT is not a namespace", scope);
2161
      return NULL_TREE;
2162
    }
2163
  else if (scope == error_mark_node)
2164
    return NULL_TREE;
2165
 
2166
  if (TREE_CODE (decl) == TEMPLATE_ID_EXPR)
2167
    {
2168
      /* 7.3.3/5
2169
           A using-declaration shall not name a template-id.  */
2170
      error ("a using-declaration cannot specify a template-id.  "
2171
             "Try %<using %D%>", name);
2172
      return NULL_TREE;
2173
    }
2174
 
2175
  if (TREE_CODE (decl) == NAMESPACE_DECL)
2176
    {
2177
      error ("namespace %qD not allowed in using-declaration", decl);
2178
      return NULL_TREE;
2179
    }
2180
 
2181
  if (TREE_CODE (decl) == SCOPE_REF)
2182
    {
2183
      /* It's a nested name with template parameter dependent scope.
2184
         This can only be using-declaration for class member.  */
2185
      error ("%qT is not a namespace", TREE_OPERAND (decl, 0));
2186
      return NULL_TREE;
2187
    }
2188
 
2189
  if (is_overloaded_fn (decl))
2190
    decl = get_first_fn (decl);
2191
 
2192
  gcc_assert (DECL_P (decl));
2193
 
2194
  /* Make a USING_DECL.  */
2195
  return push_using_decl (scope, name);
2196
}
2197
 
2198
/* Process local and global using-declarations.  */
2199
 
2200
static void
2201
do_nonmember_using_decl (tree scope, tree name, tree oldval, tree oldtype,
2202
                         tree *newval, tree *newtype)
2203
{
2204
  struct scope_binding decls = EMPTY_SCOPE_BINDING;
2205
 
2206
  *newval = *newtype = NULL_TREE;
2207
  if (!qualified_lookup_using_namespace (name, scope, &decls, 0))
2208
    /* Lookup error */
2209
    return;
2210
 
2211
  if (!decls.value && !decls.type)
2212
    {
2213
      error ("%qD not declared", name);
2214
      return;
2215
    }
2216
 
2217
  /* Shift the old and new bindings around so we're comparing class and
2218
     enumeration names to each other.  */
2219
  if (oldval && DECL_IMPLICIT_TYPEDEF_P (oldval))
2220
    {
2221
      oldtype = oldval;
2222
      oldval = NULL_TREE;
2223
    }
2224
 
2225
  if (decls.value && DECL_IMPLICIT_TYPEDEF_P (decls.value))
2226
    {
2227
      decls.type = decls.value;
2228
      decls.value = NULL_TREE;
2229
    }
2230
 
2231
  /* It is impossible to overload a built-in function; any explicit
2232
     declaration eliminates the built-in declaration.  So, if OLDVAL
2233
     is a built-in, then we can just pretend it isn't there.  */
2234
  if (oldval
2235
      && TREE_CODE (oldval) == FUNCTION_DECL
2236
      && DECL_ANTICIPATED (oldval)
2237
      && !DECL_HIDDEN_FRIEND_P (oldval))
2238
    oldval = NULL_TREE;
2239
 
2240
  if (decls.value)
2241
    {
2242
      /* Check for using functions.  */
2243
      if (is_overloaded_fn (decls.value))
2244
        {
2245
          tree tmp, tmp1;
2246
 
2247
          if (oldval && !is_overloaded_fn (oldval))
2248
            {
2249
              error ("%qD is already declared in this scope", name);
2250
              oldval = NULL_TREE;
2251
            }
2252
 
2253
          *newval = oldval;
2254
          for (tmp = decls.value; tmp; tmp = OVL_NEXT (tmp))
2255
            {
2256
              tree new_fn = OVL_CURRENT (tmp);
2257
 
2258
              /* [namespace.udecl]
2259
 
2260
                 If a function declaration in namespace scope or block
2261
                 scope has the same name and the same parameter types as a
2262
                 function introduced by a using declaration the program is
2263
                 ill-formed.  */
2264
              for (tmp1 = oldval; tmp1; tmp1 = OVL_NEXT (tmp1))
2265
                {
2266
                  tree old_fn = OVL_CURRENT (tmp1);
2267
 
2268
                  if (new_fn == old_fn)
2269
                    /* The function already exists in the current namespace.  */
2270
                    break;
2271
                  else if (OVL_USED (tmp1))
2272
                    continue; /* this is a using decl */
2273
                  else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (new_fn)),
2274
                                      TYPE_ARG_TYPES (TREE_TYPE (old_fn))))
2275
                    {
2276
                      gcc_assert (!DECL_ANTICIPATED (old_fn)
2277
                                  || DECL_HIDDEN_FRIEND_P (old_fn));
2278
 
2279
                      /* There was already a non-using declaration in
2280
                         this scope with the same parameter types. If both
2281
                         are the same extern "C" functions, that's ok.  */
2282
                      if (decls_match (new_fn, old_fn))
2283
                        break;
2284
                      else
2285
                        {
2286
                          error ("%qD is already declared in this scope", name);
2287
                          break;
2288
                        }
2289
                    }
2290
                }
2291
 
2292
              /* If we broke out of the loop, there's no reason to add
2293
                 this function to the using declarations for this
2294
                 scope.  */
2295
              if (tmp1)
2296
                continue;
2297
 
2298
              /* If we are adding to an existing OVERLOAD, then we no
2299
                 longer know the type of the set of functions.  */
2300
              if (*newval && TREE_CODE (*newval) == OVERLOAD)
2301
                TREE_TYPE (*newval) = unknown_type_node;
2302
              /* Add this new function to the set.  */
2303
              *newval = build_overload (OVL_CURRENT (tmp), *newval);
2304
              /* If there is only one function, then we use its type.  (A
2305
                 using-declaration naming a single function can be used in
2306
                 contexts where overload resolution cannot be
2307
                 performed.)  */
2308
              if (TREE_CODE (*newval) != OVERLOAD)
2309
                {
2310
                  *newval = ovl_cons (*newval, NULL_TREE);
2311
                  TREE_TYPE (*newval) = TREE_TYPE (OVL_CURRENT (tmp));
2312
                }
2313
              OVL_USED (*newval) = 1;
2314
            }
2315
        }
2316
      else
2317
        {
2318
          *newval = decls.value;
2319
          if (oldval && !decls_match (*newval, oldval))
2320
            error ("%qD is already declared in this scope", name);
2321
        }
2322
    }
2323
  else
2324
    *newval = oldval;
2325
 
2326
  if (decls.type && TREE_CODE (decls.type) == TREE_LIST)
2327
    {
2328
      error ("reference to %qD is ambiguous", name);
2329
      print_candidates (decls.type);
2330
    }
2331
  else
2332
    {
2333
      *newtype = decls.type;
2334
      if (oldtype && *newtype && !decls_match (oldtype, *newtype))
2335
        error ("%qD is already declared in this scope", name);
2336
    }
2337
 
2338
    /* If *newval is empty, shift any class or enumeration name down.  */
2339
    if (!*newval)
2340
      {
2341
        *newval = *newtype;
2342
        *newtype = NULL_TREE;
2343
      }
2344
}
2345
 
2346
/* Process a using-declaration at function scope.  */
2347
 
2348
void
2349
do_local_using_decl (tree decl, tree scope, tree name)
2350
{
2351
  tree oldval, oldtype, newval, newtype;
2352
  tree orig_decl = decl;
2353
 
2354
  decl = validate_nonmember_using_decl (decl, scope, name);
2355
  if (decl == NULL_TREE)
2356
    return;
2357
 
2358
  if (building_stmt_tree ()
2359
      && at_function_scope_p ())
2360
    add_decl_expr (decl);
2361
 
2362
  oldval = lookup_name_innermost_nonclass_level (name);
2363
  oldtype = lookup_type_current_level (name);
2364
 
2365
  do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
2366
 
2367
  if (newval)
2368
    {
2369
      if (is_overloaded_fn (newval))
2370
        {
2371
          tree fn, term;
2372
 
2373
          /* We only need to push declarations for those functions
2374
             that were not already bound in the current level.
2375
             The old value might be NULL_TREE, it might be a single
2376
             function, or an OVERLOAD.  */
2377
          if (oldval && TREE_CODE (oldval) == OVERLOAD)
2378
            term = OVL_FUNCTION (oldval);
2379
          else
2380
            term = oldval;
2381
          for (fn = newval; fn && OVL_CURRENT (fn) != term;
2382
               fn = OVL_NEXT (fn))
2383
            push_overloaded_decl (OVL_CURRENT (fn),
2384
                                  PUSH_LOCAL | PUSH_USING,
2385
                                  false);
2386
        }
2387
      else
2388
        push_local_binding (name, newval, PUSH_USING);
2389
    }
2390
  if (newtype)
2391
    {
2392
      push_local_binding (name, newtype, PUSH_USING);
2393
      set_identifier_type_value (name, newtype);
2394
    }
2395
 
2396
  /* Emit debug info.  */
2397
  if (!processing_template_decl)
2398
    cp_emit_debug_info_for_using (orig_decl, current_scope());
2399
}
2400
 
2401
/* Returns true if ROOT (a namespace, class, or function) encloses
2402
   CHILD.  CHILD may be either a class type or a namespace.  */
2403
 
2404
bool
2405
is_ancestor (tree root, tree child)
2406
{
2407
  gcc_assert ((TREE_CODE (root) == NAMESPACE_DECL
2408
               || TREE_CODE (root) == FUNCTION_DECL
2409
               || CLASS_TYPE_P (root)));
2410
  gcc_assert ((TREE_CODE (child) == NAMESPACE_DECL
2411
               || CLASS_TYPE_P (child)));
2412
 
2413
  /* The global namespace encloses everything.  */
2414
  if (root == global_namespace)
2415
    return true;
2416
 
2417
  while (true)
2418
    {
2419
      /* If we've run out of scopes, stop.  */
2420
      if (!child)
2421
        return false;
2422
      /* If we've reached the ROOT, it encloses CHILD.  */
2423
      if (root == child)
2424
        return true;
2425
      /* Go out one level.  */
2426
      if (TYPE_P (child))
2427
        child = TYPE_NAME (child);
2428
      child = DECL_CONTEXT (child);
2429
    }
2430
}
2431
 
2432
/* Enter the class or namespace scope indicated by T suitable for name
2433
   lookup.  T can be arbitrary scope, not necessary nested inside the
2434
   current scope.  Returns a non-null scope to pop iff pop_scope
2435
   should be called later to exit this scope.  */
2436
 
2437
tree
2438
push_scope (tree t)
2439
{
2440
  if (TREE_CODE (t) == NAMESPACE_DECL)
2441
    push_decl_namespace (t);
2442
  else if (CLASS_TYPE_P (t))
2443
    {
2444
      if (!at_class_scope_p ()
2445
          || !same_type_p (current_class_type, t))
2446
        push_nested_class (t);
2447
      else
2448
        /* T is the same as the current scope.  There is therefore no
2449
           need to re-enter the scope.  Since we are not actually
2450
           pushing a new scope, our caller should not call
2451
           pop_scope.  */
2452
        t = NULL_TREE;
2453
    }
2454
 
2455
  return t;
2456
}
2457
 
2458
/* Leave scope pushed by push_scope.  */
2459
 
2460
void
2461
pop_scope (tree t)
2462
{
2463
  if (TREE_CODE (t) == NAMESPACE_DECL)
2464
    pop_decl_namespace ();
2465
  else if CLASS_TYPE_P (t)
2466
    pop_nested_class ();
2467
}
2468
 
2469
/* Subroutine of push_inner_scope.  */
2470
 
2471
static void
2472
push_inner_scope_r (tree outer, tree inner)
2473
{
2474
  tree prev;
2475
 
2476
  if (outer == inner
2477
      || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2478
    return;
2479
 
2480
  prev = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2481
  if (outer != prev)
2482
    push_inner_scope_r (outer, prev);
2483
  if (TREE_CODE (inner) == NAMESPACE_DECL)
2484
    {
2485
      struct cp_binding_level *save_template_parm = 0;
2486
      /* Temporary take out template parameter scopes.  They are saved
2487
         in reversed order in save_template_parm.  */
2488
      while (current_binding_level->kind == sk_template_parms)
2489
        {
2490
          struct cp_binding_level *b = current_binding_level;
2491
          current_binding_level = b->level_chain;
2492
          b->level_chain = save_template_parm;
2493
          save_template_parm = b;
2494
        }
2495
 
2496
      resume_scope (NAMESPACE_LEVEL (inner));
2497
      current_namespace = inner;
2498
 
2499
      /* Restore template parameter scopes.  */
2500
      while (save_template_parm)
2501
        {
2502
          struct cp_binding_level *b = save_template_parm;
2503
          save_template_parm = b->level_chain;
2504
          b->level_chain = current_binding_level;
2505
          current_binding_level = b;
2506
        }
2507
    }
2508
  else
2509
    pushclass (inner);
2510
}
2511
 
2512
/* Enter the scope INNER from current scope.  INNER must be a scope
2513
   nested inside current scope.  This works with both name lookup and
2514
   pushing name into scope.  In case a template parameter scope is present,
2515
   namespace is pushed under the template parameter scope according to
2516
   name lookup rule in 14.6.1/6.
2517
 
2518
   Return the former current scope suitable for pop_inner_scope.  */
2519
 
2520
tree
2521
push_inner_scope (tree inner)
2522
{
2523
  tree outer = current_scope ();
2524
  if (!outer)
2525
    outer = current_namespace;
2526
 
2527
  push_inner_scope_r (outer, inner);
2528
  return outer;
2529
}
2530
 
2531
/* Exit the current scope INNER back to scope OUTER.  */
2532
 
2533
void
2534
pop_inner_scope (tree outer, tree inner)
2535
{
2536
  if (outer == inner
2537
      || (TREE_CODE (inner) != NAMESPACE_DECL && !CLASS_TYPE_P (inner)))
2538
    return;
2539
 
2540
  while (outer != inner)
2541
    {
2542
      if (TREE_CODE (inner) == NAMESPACE_DECL)
2543
        {
2544
          struct cp_binding_level *save_template_parm = 0;
2545
          /* Temporary take out template parameter scopes.  They are saved
2546
             in reversed order in save_template_parm.  */
2547
          while (current_binding_level->kind == sk_template_parms)
2548
            {
2549
              struct cp_binding_level *b = current_binding_level;
2550
              current_binding_level = b->level_chain;
2551
              b->level_chain = save_template_parm;
2552
              save_template_parm = b;
2553
            }
2554
 
2555
          pop_namespace ();
2556
 
2557
          /* Restore template parameter scopes.  */
2558
          while (save_template_parm)
2559
            {
2560
              struct cp_binding_level *b = save_template_parm;
2561
              save_template_parm = b->level_chain;
2562
              b->level_chain = current_binding_level;
2563
              current_binding_level = b;
2564
            }
2565
        }
2566
      else
2567
        popclass ();
2568
 
2569
      inner = CP_DECL_CONTEXT (TREE_CODE (inner) == NAMESPACE_DECL ? inner : TYPE_NAME (inner));
2570
    }
2571
}
2572
 
2573
/* Do a pushlevel for class declarations.  */
2574
 
2575
void
2576
pushlevel_class (void)
2577
{
2578
  class_binding_level = begin_scope (sk_class, current_class_type);
2579
}
2580
 
2581
/* ...and a poplevel for class declarations.  */
2582
 
2583
void
2584
poplevel_class (void)
2585
{
2586
  struct cp_binding_level *level = class_binding_level;
2587
  cp_class_binding *cb;
2588
  size_t i;
2589
  tree shadowed;
2590
 
2591
  timevar_push (TV_NAME_LOOKUP);
2592
  gcc_assert (level != 0);
2593
 
2594
  /* If we're leaving a toplevel class, cache its binding level.  */
2595
  if (current_class_depth == 1)
2596
    previous_class_level = level;
2597
  for (shadowed = level->type_shadowed;
2598
       shadowed;
2599
       shadowed = TREE_CHAIN (shadowed))
2600
    SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (shadowed), TREE_VALUE (shadowed));
2601
 
2602
  /* Remove the bindings for all of the class-level declarations.  */
2603
  if (level->class_shadowed)
2604
    {
2605
      for (i = 0;
2606
           VEC_iterate (cp_class_binding, level->class_shadowed, i, cb);
2607
           ++i)
2608
        IDENTIFIER_BINDING (cb->identifier) = cb->base.previous;
2609
      ggc_free (level->class_shadowed);
2610
      level->class_shadowed = NULL;
2611
    }
2612
 
2613
  /* Now, pop out of the binding level which we created up in the
2614
     `pushlevel_class' routine.  */
2615
  gcc_assert (current_binding_level == level);
2616
  leave_scope ();
2617
  timevar_pop (TV_NAME_LOOKUP);
2618
}
2619
 
2620
/* Set INHERITED_VALUE_BINDING_P on BINDING to true or false, as
2621
   appropriate.  DECL is the value to which a name has just been
2622
   bound.  CLASS_TYPE is the class in which the lookup occurred.  */
2623
 
2624
static void
2625
set_inherited_value_binding_p (cxx_binding *binding, tree decl,
2626
                               tree class_type)
2627
{
2628
  if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
2629
    {
2630
      tree context;
2631
 
2632
      if (TREE_CODE (decl) == OVERLOAD)
2633
        context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
2634
      else
2635
        {
2636
          gcc_assert (DECL_P (decl));
2637
          context = context_for_name_lookup (decl);
2638
        }
2639
 
2640
      if (is_properly_derived_from (class_type, context))
2641
        INHERITED_VALUE_BINDING_P (binding) = 1;
2642
      else
2643
        INHERITED_VALUE_BINDING_P (binding) = 0;
2644
    }
2645
  else if (binding->value == decl)
2646
    /* We only encounter a TREE_LIST when there is an ambiguity in the
2647
       base classes.  Such an ambiguity can be overridden by a
2648
       definition in this class.  */
2649
    INHERITED_VALUE_BINDING_P (binding) = 1;
2650
  else
2651
    INHERITED_VALUE_BINDING_P (binding) = 0;
2652
}
2653
 
2654
/* Make the declaration of X appear in CLASS scope.  */
2655
 
2656
bool
2657
pushdecl_class_level (tree x)
2658
{
2659
  tree name;
2660
  bool is_valid = true;
2661
 
2662
  /* Do nothing if we're adding to an outer lambda closure type,
2663
     outer_binding will add it later if it's needed.  */
2664
  if (current_class_type != class_binding_level->this_entity)
2665
    return true;
2666
 
2667
  timevar_push (TV_NAME_LOOKUP);
2668
  /* Get the name of X.  */
2669
  if (TREE_CODE (x) == OVERLOAD)
2670
    name = DECL_NAME (get_first_fn (x));
2671
  else
2672
    name = DECL_NAME (x);
2673
 
2674
  if (name)
2675
    {
2676
      is_valid = push_class_level_binding (name, x);
2677
      if (TREE_CODE (x) == TYPE_DECL)
2678
        set_identifier_type_value (name, x);
2679
    }
2680
  else if (ANON_AGGR_TYPE_P (TREE_TYPE (x)))
2681
    {
2682
      /* If X is an anonymous aggregate, all of its members are
2683
         treated as if they were members of the class containing the
2684
         aggregate, for naming purposes.  */
2685
      tree f;
2686
 
2687
      for (f = TYPE_FIELDS (TREE_TYPE (x)); f; f = TREE_CHAIN (f))
2688
        {
2689
          location_t save_location = input_location;
2690
          input_location = DECL_SOURCE_LOCATION (f);
2691
          if (!pushdecl_class_level (f))
2692
            is_valid = false;
2693
          input_location = save_location;
2694
        }
2695
    }
2696
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, is_valid);
2697
}
2698
 
2699
/* Return the BINDING (if any) for NAME in SCOPE, which is a class
2700
   scope.  If the value returned is non-NULL, and the PREVIOUS field
2701
   is not set, callers must set the PREVIOUS field explicitly.  */
2702
 
2703
static cxx_binding *
2704
get_class_binding (tree name, cxx_scope *scope)
2705
{
2706
  tree class_type;
2707
  tree type_binding;
2708
  tree value_binding;
2709
  cxx_binding *binding;
2710
 
2711
  class_type = scope->this_entity;
2712
 
2713
  /* Get the type binding.  */
2714
  type_binding = lookup_member (class_type, name,
2715
                                /*protect=*/2, /*want_type=*/true);
2716
  /* Get the value binding.  */
2717
  value_binding = lookup_member (class_type, name,
2718
                                 /*protect=*/2, /*want_type=*/false);
2719
 
2720
  if (value_binding
2721
      && (TREE_CODE (value_binding) == TYPE_DECL
2722
          || DECL_CLASS_TEMPLATE_P (value_binding)
2723
          || (TREE_CODE (value_binding) == TREE_LIST
2724
              && TREE_TYPE (value_binding) == error_mark_node
2725
              && (TREE_CODE (TREE_VALUE (value_binding))
2726
                  == TYPE_DECL))))
2727
    /* We found a type binding, even when looking for a non-type
2728
       binding.  This means that we already processed this binding
2729
       above.  */
2730
    ;
2731
  else if (value_binding)
2732
    {
2733
      if (TREE_CODE (value_binding) == TREE_LIST
2734
          && TREE_TYPE (value_binding) == error_mark_node)
2735
        /* NAME is ambiguous.  */
2736
        ;
2737
      else if (BASELINK_P (value_binding))
2738
        /* NAME is some overloaded functions.  */
2739
        value_binding = BASELINK_FUNCTIONS (value_binding);
2740
    }
2741
 
2742
  /* If we found either a type binding or a value binding, create a
2743
     new binding object.  */
2744
  if (type_binding || value_binding)
2745
    {
2746
      binding = new_class_binding (name,
2747
                                   value_binding,
2748
                                   type_binding,
2749
                                   scope);
2750
      /* This is a class-scope binding, not a block-scope binding.  */
2751
      LOCAL_BINDING_P (binding) = 0;
2752
      set_inherited_value_binding_p (binding, value_binding, class_type);
2753
    }
2754
  else
2755
    binding = NULL;
2756
 
2757
  return binding;
2758
}
2759
 
2760
/* Make the declaration(s) of X appear in CLASS scope under the name
2761
   NAME.  Returns true if the binding is valid.  */
2762
 
2763
bool
2764
push_class_level_binding (tree name, tree x)
2765
{
2766
  cxx_binding *binding;
2767
  tree decl = x;
2768
  bool ok;
2769
 
2770
  timevar_push (TV_NAME_LOOKUP);
2771
  /* The class_binding_level will be NULL if x is a template
2772
     parameter name in a member template.  */
2773
  if (!class_binding_level)
2774
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2775
 
2776
  if (name == error_mark_node)
2777
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2778
 
2779
  /* Check for invalid member names.  */
2780
  gcc_assert (TYPE_BEING_DEFINED (current_class_type));
2781
  /* Check that we're pushing into the right binding level.  */
2782
  gcc_assert (current_class_type == class_binding_level->this_entity);
2783
 
2784
  /* We could have been passed a tree list if this is an ambiguous
2785
     declaration. If so, pull the declaration out because
2786
     check_template_shadow will not handle a TREE_LIST.  */
2787
  if (TREE_CODE (decl) == TREE_LIST
2788
      && TREE_TYPE (decl) == error_mark_node)
2789
    decl = TREE_VALUE (decl);
2790
 
2791
  if (!check_template_shadow (decl))
2792
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2793
 
2794
  /* [class.mem]
2795
 
2796
     If T is the name of a class, then each of the following shall
2797
     have a name different from T:
2798
 
2799
     -- every static data member of class T;
2800
 
2801
     -- every member of class T that is itself a type;
2802
 
2803
     -- every enumerator of every member of class T that is an
2804
        enumerated type;
2805
 
2806
     -- every member of every anonymous union that is a member of
2807
        class T.
2808
 
2809
     (Non-static data members were also forbidden to have the same
2810
     name as T until TC1.)  */
2811
  if ((TREE_CODE (x) == VAR_DECL
2812
       || TREE_CODE (x) == CONST_DECL
2813
       || (TREE_CODE (x) == TYPE_DECL
2814
           && !DECL_SELF_REFERENCE_P (x))
2815
       /* A data member of an anonymous union.  */
2816
       || (TREE_CODE (x) == FIELD_DECL
2817
           && DECL_CONTEXT (x) != current_class_type))
2818
      && DECL_NAME (x) == constructor_name (current_class_type))
2819
    {
2820
      tree scope = context_for_name_lookup (x);
2821
      if (TYPE_P (scope) && same_type_p (scope, current_class_type))
2822
        {
2823
          error ("%qD has the same name as the class in which it is "
2824
                 "declared",
2825
                 x);
2826
          POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, false);
2827
        }
2828
    }
2829
 
2830
  /* Get the current binding for NAME in this class, if any.  */
2831
  binding = IDENTIFIER_BINDING (name);
2832
  if (!binding || binding->scope != class_binding_level)
2833
    {
2834
      binding = get_class_binding (name, class_binding_level);
2835
      /* If a new binding was created, put it at the front of the
2836
         IDENTIFIER_BINDING list.  */
2837
      if (binding)
2838
        {
2839
          binding->previous = IDENTIFIER_BINDING (name);
2840
          IDENTIFIER_BINDING (name) = binding;
2841
        }
2842
    }
2843
 
2844
  /* If there is already a binding, then we may need to update the
2845
     current value.  */
2846
  if (binding && binding->value)
2847
    {
2848
      tree bval = binding->value;
2849
      tree old_decl = NULL_TREE;
2850
 
2851
      if (INHERITED_VALUE_BINDING_P (binding))
2852
        {
2853
          /* If the old binding was from a base class, and was for a
2854
             tag name, slide it over to make room for the new binding.
2855
             The old binding is still visible if explicitly qualified
2856
             with a class-key.  */
2857
          if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
2858
              && !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
2859
            {
2860
              old_decl = binding->type;
2861
              binding->type = bval;
2862
              binding->value = NULL_TREE;
2863
              INHERITED_VALUE_BINDING_P (binding) = 0;
2864
            }
2865
          else
2866
            {
2867
              old_decl = bval;
2868
              /* Any inherited type declaration is hidden by the type
2869
                 declaration in the derived class.  */
2870
              if (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))
2871
                binding->type = NULL_TREE;
2872
            }
2873
        }
2874
      else if (TREE_CODE (x) == OVERLOAD && is_overloaded_fn (bval))
2875
        old_decl = bval;
2876
      else if (TREE_CODE (x) == USING_DECL && TREE_CODE (bval) == USING_DECL)
2877
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2878
      else if (TREE_CODE (x) == USING_DECL && is_overloaded_fn (bval))
2879
        old_decl = bval;
2880
      else if (TREE_CODE (bval) == USING_DECL && is_overloaded_fn (x))
2881
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2882
 
2883
      if (old_decl && binding->scope == class_binding_level)
2884
        {
2885
          binding->value = x;
2886
          /* It is always safe to clear INHERITED_VALUE_BINDING_P
2887
             here.  This function is only used to register bindings
2888
             from with the class definition itself.  */
2889
          INHERITED_VALUE_BINDING_P (binding) = 0;
2890
          POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, true);
2891
        }
2892
    }
2893
 
2894
  /* Note that we declared this value so that we can issue an error if
2895
     this is an invalid redeclaration of a name already used for some
2896
     other purpose.  */
2897
  note_name_declared_in_class (name, decl);
2898
 
2899
  /* If we didn't replace an existing binding, put the binding on the
2900
     stack of bindings for the identifier, and update the shadowed
2901
     list.  */
2902
  if (binding && binding->scope == class_binding_level)
2903
    /* Supplement the existing binding.  */
2904
    ok = supplement_binding (binding, decl);
2905
  else
2906
    {
2907
      /* Create a new binding.  */
2908
      push_binding (name, decl, class_binding_level);
2909
      ok = true;
2910
    }
2911
 
2912
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ok);
2913
}
2914
 
2915
/* Process "using SCOPE::NAME" in a class scope.  Return the
2916
   USING_DECL created.  */
2917
 
2918
tree
2919
do_class_using_decl (tree scope, tree name)
2920
{
2921
  /* The USING_DECL returned by this function.  */
2922
  tree value;
2923
  /* The declaration (or declarations) name by this using
2924
     declaration.  NULL if we are in a template and cannot figure out
2925
     what has been named.  */
2926
  tree decl;
2927
  /* True if SCOPE is a dependent type.  */
2928
  bool scope_dependent_p;
2929
  /* True if SCOPE::NAME is dependent.  */
2930
  bool name_dependent_p;
2931
  /* True if any of the bases of CURRENT_CLASS_TYPE are dependent.  */
2932
  bool bases_dependent_p;
2933
  tree binfo;
2934
  tree base_binfo;
2935
  int i;
2936
 
2937
  if (name == error_mark_node)
2938
    return NULL_TREE;
2939
 
2940
  if (!scope || !TYPE_P (scope))
2941
    {
2942
      error ("using-declaration for non-member at class scope");
2943
      return NULL_TREE;
2944
    }
2945
 
2946
  /* Make sure the name is not invalid */
2947
  if (TREE_CODE (name) == BIT_NOT_EXPR)
2948
    {
2949
      error ("%<%T::%D%> names destructor", scope, name);
2950
      return NULL_TREE;
2951
    }
2952
  if (MAYBE_CLASS_TYPE_P (scope) && constructor_name_p (name, scope))
2953
    {
2954
      error ("%<%T::%D%> names constructor", scope, name);
2955
      return NULL_TREE;
2956
    }
2957
  if (constructor_name_p (name, current_class_type))
2958
    {
2959
      error ("%<%T::%D%> names constructor in %qT",
2960
             scope, name, current_class_type);
2961
      return NULL_TREE;
2962
    }
2963
 
2964
  scope_dependent_p = dependent_type_p (scope);
2965
  name_dependent_p = (scope_dependent_p
2966
                      || (IDENTIFIER_TYPENAME_P (name)
2967
                          && dependent_type_p (TREE_TYPE (name))));
2968
 
2969
  bases_dependent_p = false;
2970
  if (processing_template_decl)
2971
    for (binfo = TYPE_BINFO (current_class_type), i = 0;
2972
         BINFO_BASE_ITERATE (binfo, i, base_binfo);
2973
         i++)
2974
      if (dependent_type_p (TREE_TYPE (base_binfo)))
2975
        {
2976
          bases_dependent_p = true;
2977
          break;
2978
        }
2979
 
2980
  decl = NULL_TREE;
2981
 
2982
  /* From [namespace.udecl]:
2983
 
2984
       A using-declaration used as a member-declaration shall refer to a
2985
       member of a base class of the class being defined.
2986
 
2987
     In general, we cannot check this constraint in a template because
2988
     we do not know the entire set of base classes of the current
2989
     class type.  However, if all of the base classes are
2990
     non-dependent, then we can avoid delaying the check until
2991
     instantiation.  */
2992
  if (!scope_dependent_p)
2993
    {
2994
      base_kind b_kind;
2995
      binfo = lookup_base (current_class_type, scope, ba_any, &b_kind);
2996
      if (b_kind < bk_proper_base)
2997
        {
2998
          if (!bases_dependent_p)
2999
            {
3000
              error_not_base_type (scope, current_class_type);
3001
              return NULL_TREE;
3002
            }
3003
        }
3004
      else if (!name_dependent_p)
3005
        {
3006
          decl = lookup_member (binfo, name, 0, false);
3007
          if (!decl)
3008
            {
3009
              error ("no members matching %<%T::%D%> in %q#T", scope, name,
3010
                     scope);
3011
              return NULL_TREE;
3012
            }
3013
          /* The binfo from which the functions came does not matter.  */
3014
          if (BASELINK_P (decl))
3015
            decl = BASELINK_FUNCTIONS (decl);
3016
        }
3017
   }
3018
 
3019
  value = build_lang_decl (USING_DECL, name, NULL_TREE);
3020
  USING_DECL_DECLS (value) = decl;
3021
  USING_DECL_SCOPE (value) = scope;
3022
  DECL_DEPENDENT_P (value) = !decl;
3023
 
3024
  return value;
3025
}
3026
 
3027
 
3028
/* Return the binding value for name in scope.  */
3029
 
3030
tree
3031
namespace_binding (tree name, tree scope)
3032
{
3033
  cxx_binding *binding;
3034
 
3035
  if (scope == NULL)
3036
    scope = global_namespace;
3037
  else
3038
    /* Unnecessary for the global namespace because it can't be an alias. */
3039
    scope = ORIGINAL_NAMESPACE (scope);
3040
 
3041
  binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3042
 
3043
  return binding ? binding->value : NULL_TREE;
3044
}
3045
 
3046
/* Set the binding value for name in scope.  */
3047
 
3048
void
3049
set_namespace_binding (tree name, tree scope, tree val)
3050
{
3051
  cxx_binding *b;
3052
 
3053
  timevar_push (TV_NAME_LOOKUP);
3054
  if (scope == NULL_TREE)
3055
    scope = global_namespace;
3056
  b = binding_for_name (NAMESPACE_LEVEL (scope), name);
3057
  if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
3058
    b->value = val;
3059
  else
3060
    supplement_binding (b, val);
3061
  timevar_pop (TV_NAME_LOOKUP);
3062
}
3063
 
3064
/* Set the context of a declaration to scope. Complain if we are not
3065
   outside scope.  */
3066
 
3067
void
3068
set_decl_namespace (tree decl, tree scope, bool friendp)
3069
{
3070
  tree old;
3071
 
3072
  /* Get rid of namespace aliases.  */
3073
  scope = ORIGINAL_NAMESPACE (scope);
3074
 
3075
  /* It is ok for friends to be qualified in parallel space.  */
3076
  if (!friendp && !is_ancestor (current_namespace, scope))
3077
    error ("declaration of %qD not in a namespace surrounding %qD",
3078
           decl, scope);
3079
  DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3080
 
3081
  /* Writing "int N::i" to declare a variable within "N" is invalid.  */
3082
  if (scope == current_namespace)
3083
    {
3084
      if (at_namespace_scope_p ())
3085
        error ("explicit qualification in declaration of %qD",
3086
               decl);
3087
      return;
3088
    }
3089
 
3090
  /* See whether this has been declared in the namespace.  */
3091
  old = lookup_qualified_name (scope, DECL_NAME (decl), false, true);
3092
  if (old == error_mark_node)
3093
    /* No old declaration at all.  */
3094
    goto complain;
3095
  /* If it's a TREE_LIST, the result of the lookup was ambiguous.  */
3096
  if (TREE_CODE (old) == TREE_LIST)
3097
    {
3098
      error ("reference to %qD is ambiguous", decl);
3099
      print_candidates (old);
3100
      return;
3101
    }
3102
  if (!is_overloaded_fn (decl))
3103
    {
3104
      /* We might have found OLD in an inline namespace inside SCOPE.  */
3105
      if (TREE_CODE (decl) == TREE_CODE (old))
3106
        DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3107
      /* Don't compare non-function decls with decls_match here, since
3108
         it can't check for the correct constness at this
3109
         point. pushdecl will find those errors later.  */
3110
      return;
3111
    }
3112
  /* Since decl is a function, old should contain a function decl.  */
3113
  if (!is_overloaded_fn (old))
3114
    goto complain;
3115
  /* A template can be explicitly specialized in any namespace.  */
3116
  if (processing_explicit_instantiation)
3117
    return;
3118
  if (processing_template_decl || processing_specialization)
3119
    /* We have not yet called push_template_decl to turn a
3120
       FUNCTION_DECL into a TEMPLATE_DECL, so the declarations won't
3121
       match.  But, we'll check later, when we construct the
3122
       template.  */
3123
    return;
3124
  /* Instantiations or specializations of templates may be declared as
3125
     friends in any namespace.  */
3126
  if (friendp && DECL_USE_TEMPLATE (decl))
3127
    return;
3128
  if (is_overloaded_fn (old))
3129
    {
3130
      tree found = NULL_TREE;
3131
      tree elt = old;
3132
      for (; elt; elt = OVL_NEXT (elt))
3133
        {
3134
          tree ofn = OVL_CURRENT (elt);
3135
          /* Adjust DECL_CONTEXT first so decls_match will return true
3136
             if DECL will match a declaration in an inline namespace.  */
3137
          DECL_CONTEXT (decl) = DECL_CONTEXT (ofn);
3138
          if (decls_match (decl, ofn))
3139
            {
3140
              if (found && !decls_match (found, ofn))
3141
                {
3142
                  DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3143
                  error ("reference to %qD is ambiguous", decl);
3144
                  print_candidates (old);
3145
                  return;
3146
                }
3147
              found = ofn;
3148
            }
3149
        }
3150
      if (found)
3151
        {
3152
          if (!is_associated_namespace (scope, CP_DECL_CONTEXT (found)))
3153
            goto complain;
3154
          DECL_CONTEXT (decl) = DECL_CONTEXT (found);
3155
          return;
3156
        }
3157
    }
3158
  else
3159
    {
3160
      DECL_CONTEXT (decl) = DECL_CONTEXT (old);
3161
      if (decls_match (decl, old))
3162
        return;
3163
    }
3164
 
3165
  /* It didn't work, go back to the explicit scope.  */
3166
  DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
3167
 complain:
3168
  error ("%qD should have been declared inside %qD", decl, scope);
3169
}
3170
 
3171
/* Return the namespace where the current declaration is declared.  */
3172
 
3173
static tree
3174
current_decl_namespace (void)
3175
{
3176
  tree result;
3177
  /* If we have been pushed into a different namespace, use it.  */
3178
  if (decl_namespace_list)
3179
    return TREE_PURPOSE (decl_namespace_list);
3180
 
3181
  if (current_class_type)
3182
    result = decl_namespace_context (current_class_type);
3183
  else if (current_function_decl)
3184
    result = decl_namespace_context (current_function_decl);
3185
  else
3186
    result = current_namespace;
3187
  return result;
3188
}
3189
 
3190
/* Process any ATTRIBUTES on a namespace definition.  Currently only
3191
   attribute visibility is meaningful, which is a property of the syntactic
3192
   block rather than the namespace as a whole, so we don't touch the
3193
   NAMESPACE_DECL at all.  Returns true if attribute visibility is seen.  */
3194
 
3195
bool
3196
handle_namespace_attrs (tree ns, tree attributes)
3197
{
3198
  tree d;
3199
  bool saw_vis = false;
3200
 
3201
  for (d = attributes; d; d = TREE_CHAIN (d))
3202
    {
3203
      tree name = TREE_PURPOSE (d);
3204
      tree args = TREE_VALUE (d);
3205
 
3206
#ifdef HANDLE_PRAGMA_VISIBILITY
3207
      if (is_attribute_p ("visibility", name))
3208
        {
3209
          tree x = args ? TREE_VALUE (args) : NULL_TREE;
3210
          if (x == NULL_TREE || TREE_CODE (x) != STRING_CST || TREE_CHAIN (args))
3211
            {
3212
              warning (OPT_Wattributes,
3213
                       "%qD attribute requires a single NTBS argument",
3214
                       name);
3215
              continue;
3216
            }
3217
 
3218
          if (!TREE_PUBLIC (ns))
3219
            warning (OPT_Wattributes,
3220
                     "%qD attribute is meaningless since members of the "
3221
                     "anonymous namespace get local symbols", name);
3222
 
3223
          push_visibility (TREE_STRING_POINTER (x), 1);
3224
          saw_vis = true;
3225
        }
3226
      else
3227
#endif
3228
        {
3229
          warning (OPT_Wattributes, "%qD attribute directive ignored",
3230
                   name);
3231
          continue;
3232
        }
3233
    }
3234
 
3235
  return saw_vis;
3236
}
3237
 
3238
/* Push into the scope of the NAME namespace.  If NAME is NULL_TREE, then we
3239
   select a name that is unique to this compilation unit.  */
3240
 
3241
void
3242
push_namespace (tree name)
3243
{
3244
  tree d = NULL_TREE;
3245
  int need_new = 1;
3246
  int implicit_use = 0;
3247
  bool anon = !name;
3248
 
3249
  timevar_push (TV_NAME_LOOKUP);
3250
 
3251
  /* We should not get here if the global_namespace is not yet constructed
3252
     nor if NAME designates the global namespace:  The global scope is
3253
     constructed elsewhere.  */
3254
  gcc_assert (global_namespace != NULL && name != global_scope_name);
3255
 
3256
  if (anon)
3257
    {
3258
      name = get_anonymous_namespace_name();
3259
      d = IDENTIFIER_NAMESPACE_VALUE (name);
3260
      if (d)
3261
        /* Reopening anonymous namespace.  */
3262
        need_new = 0;
3263
      implicit_use = 1;
3264
    }
3265
  else
3266
    {
3267
      /* Check whether this is an extended namespace definition.  */
3268
      d = IDENTIFIER_NAMESPACE_VALUE (name);
3269
      if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
3270
        {
3271
          need_new = 0;
3272
          if (DECL_NAMESPACE_ALIAS (d))
3273
            {
3274
              error ("namespace alias %qD not allowed here, assuming %qD",
3275
                     d, DECL_NAMESPACE_ALIAS (d));
3276
              d = DECL_NAMESPACE_ALIAS (d);
3277
            }
3278
        }
3279
    }
3280
 
3281
  if (need_new)
3282
    {
3283
      /* Make a new namespace, binding the name to it.  */
3284
      d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
3285
      DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);
3286
      /* The name of this namespace is not visible to other translation
3287
         units if it is an anonymous namespace or member thereof.  */
3288
      if (anon || decl_anon_ns_mem_p (current_namespace))
3289
        TREE_PUBLIC (d) = 0;
3290
      else
3291
        TREE_PUBLIC (d) = 1;
3292
      pushdecl (d);
3293
      if (anon)
3294
        {
3295
          /* Clear DECL_NAME for the benefit of debugging back ends.  */
3296
          SET_DECL_ASSEMBLER_NAME (d, name);
3297
          DECL_NAME (d) = NULL_TREE;
3298
        }
3299
      begin_scope (sk_namespace, d);
3300
    }
3301
  else
3302
    resume_scope (NAMESPACE_LEVEL (d));
3303
 
3304
  if (implicit_use)
3305
    do_using_directive (d);
3306
  /* Enter the name space.  */
3307
  current_namespace = d;
3308
 
3309
  timevar_pop (TV_NAME_LOOKUP);
3310
}
3311
 
3312
/* Pop from the scope of the current namespace.  */
3313
 
3314
void
3315
pop_namespace (void)
3316
{
3317
  gcc_assert (current_namespace != global_namespace);
3318
  current_namespace = CP_DECL_CONTEXT (current_namespace);
3319
  /* The binding level is not popped, as it might be re-opened later.  */
3320
  leave_scope ();
3321
}
3322
 
3323
/* Push into the scope of the namespace NS, even if it is deeply
3324
   nested within another namespace.  */
3325
 
3326
void
3327
push_nested_namespace (tree ns)
3328
{
3329
  if (ns == global_namespace)
3330
    push_to_top_level ();
3331
  else
3332
    {
3333
      push_nested_namespace (CP_DECL_CONTEXT (ns));
3334
      push_namespace (DECL_NAME (ns));
3335
    }
3336
}
3337
 
3338
/* Pop back from the scope of the namespace NS, which was previously
3339
   entered with push_nested_namespace.  */
3340
 
3341
void
3342
pop_nested_namespace (tree ns)
3343
{
3344
  timevar_push (TV_NAME_LOOKUP);
3345
  while (ns != global_namespace)
3346
    {
3347
      pop_namespace ();
3348
      ns = CP_DECL_CONTEXT (ns);
3349
    }
3350
 
3351
  pop_from_top_level ();
3352
  timevar_pop (TV_NAME_LOOKUP);
3353
}
3354
 
3355
/* Temporarily set the namespace for the current declaration.  */
3356
 
3357
void
3358
push_decl_namespace (tree decl)
3359
{
3360
  if (TREE_CODE (decl) != NAMESPACE_DECL)
3361
    decl = decl_namespace_context (decl);
3362
  decl_namespace_list = tree_cons (ORIGINAL_NAMESPACE (decl),
3363
                                   NULL_TREE, decl_namespace_list);
3364
}
3365
 
3366
/* [namespace.memdef]/2 */
3367
 
3368
void
3369
pop_decl_namespace (void)
3370
{
3371
  decl_namespace_list = TREE_CHAIN (decl_namespace_list);
3372
}
3373
 
3374
/* Return the namespace that is the common ancestor
3375
   of two given namespaces.  */
3376
 
3377
static tree
3378
namespace_ancestor (tree ns1, tree ns2)
3379
{
3380
  timevar_push (TV_NAME_LOOKUP);
3381
  if (is_ancestor (ns1, ns2))
3382
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ns1);
3383
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
3384
                          namespace_ancestor (CP_DECL_CONTEXT (ns1), ns2));
3385
}
3386
 
3387
/* Process a namespace-alias declaration.  */
3388
 
3389
void
3390
do_namespace_alias (tree alias, tree name_space)
3391
{
3392
  if (name_space == error_mark_node)
3393
    return;
3394
 
3395
  gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3396
 
3397
  name_space = ORIGINAL_NAMESPACE (name_space);
3398
 
3399
  /* Build the alias.  */
3400
  alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
3401
  DECL_NAMESPACE_ALIAS (alias) = name_space;
3402
  DECL_EXTERNAL (alias) = 1;
3403
  DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
3404
  pushdecl (alias);
3405
 
3406
  /* Emit debug info for namespace alias.  */
3407
  if (!building_stmt_tree ())
3408
    (*debug_hooks->global_decl) (alias);
3409
}
3410
 
3411
/* Like pushdecl, only it places X in the current namespace,
3412
   if appropriate.  */
3413
 
3414
tree
3415
pushdecl_namespace_level (tree x, bool is_friend)
3416
{
3417
  struct cp_binding_level *b = current_binding_level;
3418
  tree t;
3419
 
3420
  timevar_push (TV_NAME_LOOKUP);
3421
  t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace), is_friend);
3422
 
3423
  /* Now, the type_shadowed stack may screw us.  Munge it so it does
3424
     what we want.  */
3425
  if (TREE_CODE (t) == TYPE_DECL)
3426
    {
3427
      tree name = DECL_NAME (t);
3428
      tree newval;
3429
      tree *ptr = (tree *)0;
3430
      for (; !global_scope_p (b); b = b->level_chain)
3431
        {
3432
          tree shadowed = b->type_shadowed;
3433
          for (; shadowed; shadowed = TREE_CHAIN (shadowed))
3434
            if (TREE_PURPOSE (shadowed) == name)
3435
              {
3436
                ptr = &TREE_VALUE (shadowed);
3437
                /* Can't break out of the loop here because sometimes
3438
                   a binding level will have duplicate bindings for
3439
                   PT names.  It's gross, but I haven't time to fix it.  */
3440
              }
3441
        }
3442
      newval = TREE_TYPE (t);
3443
      if (ptr == (tree *)0)
3444
        {
3445
          /* @@ This shouldn't be needed.  My test case "zstring.cc" trips
3446
             up here if this is changed to an assertion.  --KR  */
3447
          SET_IDENTIFIER_TYPE_VALUE (name, t);
3448
        }
3449
      else
3450
        {
3451
          *ptr = newval;
3452
        }
3453
    }
3454
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
3455
}
3456
 
3457
/* Insert USED into the using list of USER. Set INDIRECT_flag if this
3458
   directive is not directly from the source. Also find the common
3459
   ancestor and let our users know about the new namespace */
3460
static void
3461
add_using_namespace (tree user, tree used, bool indirect)
3462
{
3463
  tree t;
3464
  timevar_push (TV_NAME_LOOKUP);
3465
  /* Using oneself is a no-op.  */
3466
  if (user == used)
3467
    {
3468
      timevar_pop (TV_NAME_LOOKUP);
3469
      return;
3470
    }
3471
  gcc_assert (TREE_CODE (user) == NAMESPACE_DECL);
3472
  gcc_assert (TREE_CODE (used) == NAMESPACE_DECL);
3473
  /* Check if we already have this.  */
3474
  t = purpose_member (used, DECL_NAMESPACE_USING (user));
3475
  if (t != NULL_TREE)
3476
    {
3477
      if (!indirect)
3478
        /* Promote to direct usage.  */
3479
        TREE_INDIRECT_USING (t) = 0;
3480
      timevar_pop (TV_NAME_LOOKUP);
3481
      return;
3482
    }
3483
 
3484
  /* Add used to the user's using list.  */
3485
  DECL_NAMESPACE_USING (user)
3486
    = tree_cons (used, namespace_ancestor (user, used),
3487
                 DECL_NAMESPACE_USING (user));
3488
 
3489
  TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
3490
 
3491
  /* Add user to the used's users list.  */
3492
  DECL_NAMESPACE_USERS (used)
3493
    = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
3494
 
3495
  /* Recursively add all namespaces used.  */
3496
  for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
3497
    /* indirect usage */
3498
    add_using_namespace (user, TREE_PURPOSE (t), 1);
3499
 
3500
  /* Tell everyone using us about the new used namespaces.  */
3501
  for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
3502
    add_using_namespace (TREE_PURPOSE (t), used, 1);
3503
  timevar_pop (TV_NAME_LOOKUP);
3504
}
3505
 
3506
/* Process a using-declaration not appearing in class or local scope.  */
3507
 
3508
void
3509
do_toplevel_using_decl (tree decl, tree scope, tree name)
3510
{
3511
  tree oldval, oldtype, newval, newtype;
3512
  tree orig_decl = decl;
3513
  cxx_binding *binding;
3514
 
3515
  decl = validate_nonmember_using_decl (decl, scope, name);
3516
  if (decl == NULL_TREE)
3517
    return;
3518
 
3519
  binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
3520
 
3521
  oldval = binding->value;
3522
  oldtype = binding->type;
3523
 
3524
  do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
3525
 
3526
  /* Emit debug info.  */
3527
  if (!processing_template_decl)
3528
    cp_emit_debug_info_for_using (orig_decl, current_namespace);
3529
 
3530
  /* Copy declarations found.  */
3531
  if (newval)
3532
    binding->value = newval;
3533
  if (newtype)
3534
    binding->type = newtype;
3535
}
3536
 
3537
/* Process a using-directive.  */
3538
 
3539
void
3540
do_using_directive (tree name_space)
3541
{
3542
  tree context = NULL_TREE;
3543
 
3544
  if (name_space == error_mark_node)
3545
    return;
3546
 
3547
  gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
3548
 
3549
  if (building_stmt_tree ())
3550
    add_stmt (build_stmt (input_location, USING_STMT, name_space));
3551
  name_space = ORIGINAL_NAMESPACE (name_space);
3552
 
3553
  if (!toplevel_bindings_p ())
3554
    {
3555
      push_using_directive (name_space);
3556
    }
3557
  else
3558
    {
3559
      /* direct usage */
3560
      add_using_namespace (current_namespace, name_space, 0);
3561
      if (current_namespace != global_namespace)
3562
        context = current_namespace;
3563
 
3564
      /* Emit debugging info.  */
3565
      if (!processing_template_decl)
3566
        (*debug_hooks->imported_module_or_decl) (name_space, NULL_TREE,
3567
                                                 context, false);
3568
    }
3569
}
3570
 
3571
/* Deal with a using-directive seen by the parser.  Currently we only
3572
   handle attributes here, since they cannot appear inside a template.  */
3573
 
3574
void
3575
parse_using_directive (tree name_space, tree attribs)
3576
{
3577
  tree a;
3578
 
3579
  do_using_directive (name_space);
3580
 
3581
  for (a = attribs; a; a = TREE_CHAIN (a))
3582
    {
3583
      tree name = TREE_PURPOSE (a);
3584
      if (is_attribute_p ("strong", name))
3585
        {
3586
          if (!toplevel_bindings_p ())
3587
            error ("strong using only meaningful at namespace scope");
3588
          else if (name_space != error_mark_node)
3589
            {
3590
              if (!is_ancestor (current_namespace, name_space))
3591
                error ("current namespace %qD does not enclose strongly used namespace %qD",
3592
                       current_namespace, name_space);
3593
              DECL_NAMESPACE_ASSOCIATIONS (name_space)
3594
                = tree_cons (current_namespace, 0,
3595
                             DECL_NAMESPACE_ASSOCIATIONS (name_space));
3596
            }
3597
        }
3598
      else
3599
        warning (OPT_Wattributes, "%qD attribute directive ignored", name);
3600
    }
3601
}
3602
 
3603
/* Like pushdecl, only it places X in the global scope if appropriate.
3604
   Calls cp_finish_decl to register the variable, initializing it with
3605
   *INIT, if INIT is non-NULL.  */
3606
 
3607
static tree
3608
pushdecl_top_level_1 (tree x, tree *init, bool is_friend)
3609
{
3610
  timevar_push (TV_NAME_LOOKUP);
3611
  push_to_top_level ();
3612
  x = pushdecl_namespace_level (x, is_friend);
3613
  if (init)
3614
    cp_finish_decl (x, *init, false, NULL_TREE, 0);
3615
  pop_from_top_level ();
3616
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
3617
}
3618
 
3619
/* Like pushdecl, only it places X in the global scope if appropriate.  */
3620
 
3621
tree
3622
pushdecl_top_level (tree x)
3623
{
3624
  return pushdecl_top_level_1 (x, NULL, false);
3625
}
3626
 
3627
/* Like pushdecl_top_level, but adding the IS_FRIEND parameter.  */
3628
 
3629
tree
3630
pushdecl_top_level_maybe_friend (tree x, bool is_friend)
3631
{
3632
  return pushdecl_top_level_1 (x, NULL, is_friend);
3633
}
3634
 
3635
/* Like pushdecl, only it places X in the global scope if
3636
   appropriate.  Calls cp_finish_decl to register the variable,
3637
   initializing it with INIT.  */
3638
 
3639
tree
3640
pushdecl_top_level_and_finish (tree x, tree init)
3641
{
3642
  return pushdecl_top_level_1 (x, &init, false);
3643
}
3644
 
3645
/* Combines two sets of overloaded functions into an OVERLOAD chain, removing
3646
   duplicates.  The first list becomes the tail of the result.
3647
 
3648
   The algorithm is O(n^2).  We could get this down to O(n log n) by
3649
   doing a sort on the addresses of the functions, if that becomes
3650
   necessary.  */
3651
 
3652
static tree
3653
merge_functions (tree s1, tree s2)
3654
{
3655
  for (; s2; s2 = OVL_NEXT (s2))
3656
    {
3657
      tree fn2 = OVL_CURRENT (s2);
3658
      tree fns1;
3659
 
3660
      for (fns1 = s1; fns1; fns1 = OVL_NEXT (fns1))
3661
        {
3662
          tree fn1 = OVL_CURRENT (fns1);
3663
 
3664
          /* If the function from S2 is already in S1, there is no
3665
             need to add it again.  For `extern "C"' functions, we
3666
             might have two FUNCTION_DECLs for the same function, in
3667
             different namespaces, but let's leave them in in case
3668
             they have different default arguments.  */
3669
          if (fn1 == fn2)
3670
            break;
3671
        }
3672
 
3673
      /* If we exhausted all of the functions in S1, FN2 is new.  */
3674
      if (!fns1)
3675
        s1 = build_overload (fn2, s1);
3676
    }
3677
  return s1;
3678
}
3679
 
3680
/* This should return an error not all definitions define functions.
3681
   It is not an error if we find two functions with exactly the
3682
   same signature, only if these are selected in overload resolution.
3683
   old is the current set of bindings, new_binding the freshly-found binding.
3684
   XXX Do we want to give *all* candidates in case of ambiguity?
3685
   XXX In what way should I treat extern declarations?
3686
   XXX I don't want to repeat the entire duplicate_decls here */
3687
 
3688
static void
3689
ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
3690
{
3691
  tree val, type;
3692
  gcc_assert (old != NULL);
3693
 
3694
  /* Copy the type.  */
3695
  type = new_binding->type;
3696
  if (LOOKUP_NAMESPACES_ONLY (flags)
3697
      || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
3698
    type = NULL_TREE;
3699
 
3700
  /* Copy the value.  */
3701
  val = new_binding->value;
3702
  if (val)
3703
    {
3704
      if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
3705
        val = NULL_TREE;
3706
      else
3707
        switch (TREE_CODE (val))
3708
          {
3709
          case TEMPLATE_DECL:
3710
            /* If we expect types or namespaces, and not templates,
3711
               or this is not a template class.  */
3712
            if ((LOOKUP_QUALIFIERS_ONLY (flags)
3713
                 && !DECL_CLASS_TEMPLATE_P (val)))
3714
              val = NULL_TREE;
3715
            break;
3716
          case TYPE_DECL:
3717
            if (LOOKUP_NAMESPACES_ONLY (flags)
3718
                || (type && (flags & LOOKUP_PREFER_TYPES)))
3719
              val = NULL_TREE;
3720
            break;
3721
          case NAMESPACE_DECL:
3722
            if (LOOKUP_TYPES_ONLY (flags))
3723
              val = NULL_TREE;
3724
            break;
3725
          case FUNCTION_DECL:
3726
            /* Ignore built-in functions that are still anticipated.  */
3727
            if (LOOKUP_QUALIFIERS_ONLY (flags))
3728
              val = NULL_TREE;
3729
            break;
3730
          default:
3731
            if (LOOKUP_QUALIFIERS_ONLY (flags))
3732
              val = NULL_TREE;
3733
          }
3734
    }
3735
 
3736
  /* If val is hidden, shift down any class or enumeration name.  */
3737
  if (!val)
3738
    {
3739
      val = type;
3740
      type = NULL_TREE;
3741
    }
3742
 
3743
  if (!old->value)
3744
    old->value = val;
3745
  else if (val && val != old->value)
3746
    {
3747
      if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
3748
        old->value = merge_functions (old->value, val);
3749
      else
3750
        {
3751
          old->value = tree_cons (NULL_TREE, old->value,
3752
                                  build_tree_list (NULL_TREE, val));
3753
          TREE_TYPE (old->value) = error_mark_node;
3754
        }
3755
    }
3756
 
3757
  if (!old->type)
3758
    old->type = type;
3759
  else if (type && old->type != type)
3760
    {
3761
      old->type = tree_cons (NULL_TREE, old->type,
3762
                             build_tree_list (NULL_TREE, type));
3763
      TREE_TYPE (old->type) = error_mark_node;
3764
    }
3765
}
3766
 
3767
/* Return the declarations that are members of the namespace NS.  */
3768
 
3769
tree
3770
cp_namespace_decls (tree ns)
3771
{
3772
  return NAMESPACE_LEVEL (ns)->names;
3773
}
3774
 
3775
/* Combine prefer_type and namespaces_only into flags.  */
3776
 
3777
static int
3778
lookup_flags (int prefer_type, int namespaces_only)
3779
{
3780
  if (namespaces_only)
3781
    return LOOKUP_PREFER_NAMESPACES;
3782
  if (prefer_type > 1)
3783
    return LOOKUP_PREFER_TYPES;
3784
  if (prefer_type > 0)
3785
    return LOOKUP_PREFER_BOTH;
3786
  return 0;
3787
}
3788
 
3789
/* Given a lookup that returned VAL, use FLAGS to decide if we want to
3790
   ignore it or not.  Subroutine of lookup_name_real and
3791
   lookup_type_scope.  */
3792
 
3793
static bool
3794
qualify_lookup (tree val, int flags)
3795
{
3796
  if (val == NULL_TREE)
3797
    return false;
3798
  if ((flags & LOOKUP_PREFER_NAMESPACES) && TREE_CODE (val) == NAMESPACE_DECL)
3799
    return true;
3800
  if ((flags & LOOKUP_PREFER_TYPES)
3801
      && (TREE_CODE (val) == TYPE_DECL || TREE_CODE (val) == TEMPLATE_DECL))
3802
    return true;
3803
  if (flags & (LOOKUP_PREFER_NAMESPACES | LOOKUP_PREFER_TYPES))
3804
    return false;
3805
  /* In unevaluated context, look past normal capture fields.  */
3806
  if (cp_unevaluated_operand && TREE_CODE (val) == FIELD_DECL
3807
      && DECL_NORMAL_CAPTURE_P (val))
3808
    return false;
3809
  /* None of the lookups that use qualify_lookup want the op() from the
3810
     lambda; they want the one from the enclosing class.  */
3811
  if (TREE_CODE (val) == FUNCTION_DECL && LAMBDA_FUNCTION_P (val))
3812
    return false;
3813
  return true;
3814
}
3815
 
3816
/* Given a lookup that returned VAL, decide if we want to ignore it or
3817
   not based on DECL_ANTICIPATED.  */
3818
 
3819
bool
3820
hidden_name_p (tree val)
3821
{
3822
  if (DECL_P (val)
3823
      && DECL_LANG_SPECIFIC (val)
3824
      && DECL_ANTICIPATED (val))
3825
    return true;
3826
  return false;
3827
}
3828
 
3829
/* Remove any hidden friend functions from a possibly overloaded set
3830
   of functions.  */
3831
 
3832
tree
3833
remove_hidden_names (tree fns)
3834
{
3835
  if (!fns)
3836
    return fns;
3837
 
3838
  if (TREE_CODE (fns) == FUNCTION_DECL && hidden_name_p (fns))
3839
    fns = NULL_TREE;
3840
  else if (TREE_CODE (fns) == OVERLOAD)
3841
    {
3842
      tree o;
3843
 
3844
      for (o = fns; o; o = OVL_NEXT (o))
3845
        if (hidden_name_p (OVL_CURRENT (o)))
3846
          break;
3847
      if (o)
3848
        {
3849
          tree n = NULL_TREE;
3850
 
3851
          for (o = fns; o; o = OVL_NEXT (o))
3852
            if (!hidden_name_p (OVL_CURRENT (o)))
3853
              n = build_overload (OVL_CURRENT (o), n);
3854
          fns = n;
3855
        }
3856
    }
3857
 
3858
  return fns;
3859
}
3860
 
3861
/* Unscoped lookup of a global: iterate over current namespaces,
3862
   considering using-directives.  */
3863
 
3864
static tree
3865
unqualified_namespace_lookup (tree name, int flags)
3866
{
3867
  tree initial = current_decl_namespace ();
3868
  tree scope = initial;
3869
  tree siter;
3870
  struct cp_binding_level *level;
3871
  tree val = NULL_TREE;
3872
 
3873
  timevar_push (TV_NAME_LOOKUP);
3874
 
3875
  for (; !val; scope = CP_DECL_CONTEXT (scope))
3876
    {
3877
      struct scope_binding binding = EMPTY_SCOPE_BINDING;
3878
      cxx_binding *b =
3879
         cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
3880
 
3881
      if (b)
3882
        ambiguous_decl (&binding, b, flags);
3883
 
3884
      /* Add all _DECLs seen through local using-directives.  */
3885
      for (level = current_binding_level;
3886
           level->kind != sk_namespace;
3887
           level = level->level_chain)
3888
        if (!lookup_using_namespace (name, &binding, level->using_directives,
3889
                                     scope, flags))
3890
          /* Give up because of error.  */
3891
          POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3892
 
3893
      /* Add all _DECLs seen through global using-directives.  */
3894
      /* XXX local and global using lists should work equally.  */
3895
      siter = initial;
3896
      while (1)
3897
        {
3898
          if (!lookup_using_namespace (name, &binding,
3899
                                       DECL_NAMESPACE_USING (siter),
3900
                                       scope, flags))
3901
            /* Give up because of error.  */
3902
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
3903
          if (siter == scope) break;
3904
          siter = CP_DECL_CONTEXT (siter);
3905
        }
3906
 
3907
      val = binding.value;
3908
      if (scope == global_namespace)
3909
        break;
3910
    }
3911
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
3912
}
3913
 
3914
/* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
3915
   or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
3916
   bindings.
3917
 
3918
   Returns a DECL (or OVERLOAD, or BASELINK) representing the
3919
   declaration found.  If no suitable declaration can be found,
3920
   ERROR_MARK_NODE is returned.  If COMPLAIN is true and SCOPE is
3921
   neither a class-type nor a namespace a diagnostic is issued.  */
3922
 
3923
tree
3924
lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain)
3925
{
3926
  int flags = 0;
3927
  tree t = NULL_TREE;
3928
 
3929
  if (TREE_CODE (scope) == NAMESPACE_DECL)
3930
    {
3931
      struct scope_binding binding = EMPTY_SCOPE_BINDING;
3932
 
3933
      flags |= LOOKUP_COMPLAIN;
3934
      if (is_type_p)
3935
        flags |= LOOKUP_PREFER_TYPES;
3936
      if (qualified_lookup_using_namespace (name, scope, &binding, flags))
3937
        t = binding.value;
3938
    }
3939
  else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
3940
    t = lookup_enumerator (scope, name);
3941
  else if (is_class_type (scope, complain))
3942
    t = lookup_member (scope, name, 2, is_type_p);
3943
 
3944
  if (!t)
3945
    return error_mark_node;
3946
  return t;
3947
}
3948
 
3949
/* Subroutine of unqualified_namespace_lookup:
3950
   Add the bindings of NAME in used namespaces to VAL.
3951
   We are currently looking for names in namespace SCOPE, so we
3952
   look through USINGS for using-directives of namespaces
3953
   which have SCOPE as a common ancestor with the current scope.
3954
   Returns false on errors.  */
3955
 
3956
static bool
3957
lookup_using_namespace (tree name, struct scope_binding *val,
3958
                        tree usings, tree scope, int flags)
3959
{
3960
  tree iter;
3961
  timevar_push (TV_NAME_LOOKUP);
3962
  /* Iterate over all used namespaces in current, searching for using
3963
     directives of scope.  */
3964
  for (iter = usings; iter; iter = TREE_CHAIN (iter))
3965
    if (TREE_VALUE (iter) == scope)
3966
      {
3967
        tree used = ORIGINAL_NAMESPACE (TREE_PURPOSE (iter));
3968
        cxx_binding *val1 =
3969
          cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (used), name);
3970
        /* Resolve ambiguities.  */
3971
        if (val1)
3972
          ambiguous_decl (val, val1, flags);
3973
      }
3974
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
3975
}
3976
 
3977
/* Returns true iff VEC contains TARGET.  */
3978
 
3979
static bool
3980
tree_vec_contains (VEC(tree,gc)* vec, tree target)
3981
{
3982
  unsigned int i;
3983
  tree elt;
3984
  for (i = 0; VEC_iterate(tree,vec,i,elt); ++i)
3985
    if (elt == target)
3986
      return true;
3987
  return false;
3988
}
3989
 
3990
/* [namespace.qual]
3991
   Accepts the NAME to lookup and its qualifying SCOPE.
3992
   Returns the name/type pair found into the cxx_binding *RESULT,
3993
   or false on error.  */
3994
 
3995
static bool
3996
qualified_lookup_using_namespace (tree name, tree scope,
3997
                                  struct scope_binding *result, int flags)
3998
{
3999
  /* Maintain a list of namespaces visited...  */
4000
  VEC(tree,gc) *seen = NULL;
4001
  VEC(tree,gc) *seen_inline = NULL;
4002
  /* ... and a list of namespace yet to see.  */
4003
  VEC(tree,gc) *todo = NULL;
4004
  VEC(tree,gc) *todo_maybe = NULL;
4005
  VEC(tree,gc) *todo_inline = NULL;
4006
  tree usings;
4007
  timevar_push (TV_NAME_LOOKUP);
4008
  /* Look through namespace aliases.  */
4009
  scope = ORIGINAL_NAMESPACE (scope);
4010
 
4011
  /* Algorithm: Starting with SCOPE, walk through the the set of used
4012
     namespaces.  For each used namespace, look through its inline
4013
     namespace set for any bindings and usings.  If no bindings are found,
4014
     add any usings seen to the set of used namespaces.  */
4015
  VEC_safe_push (tree, gc, todo, scope);
4016
 
4017
  while (VEC_length (tree, todo))
4018
    {
4019
      bool found_here;
4020
      scope = VEC_pop (tree, todo);
4021
      if (tree_vec_contains (seen, scope))
4022
        continue;
4023
      VEC_safe_push (tree, gc, seen, scope);
4024
      VEC_safe_push (tree, gc, todo_inline, scope);
4025
 
4026
      found_here = false;
4027
      while (VEC_length (tree, todo_inline))
4028
        {
4029
          cxx_binding *binding;
4030
 
4031
          scope = VEC_pop (tree, todo_inline);
4032
          if (tree_vec_contains (seen_inline, scope))
4033
            continue;
4034
          VEC_safe_push (tree, gc, seen_inline, scope);
4035
 
4036
          binding =
4037
            cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);
4038
          if (binding)
4039
            {
4040
              found_here = true;
4041
              ambiguous_decl (result, binding, flags);
4042
            }
4043
 
4044
          for (usings = DECL_NAMESPACE_USING (scope); usings;
4045
               usings = TREE_CHAIN (usings))
4046
            if (!TREE_INDIRECT_USING (usings))
4047
              {
4048
                if (is_associated_namespace (scope, TREE_PURPOSE (usings)))
4049
                  VEC_safe_push (tree, gc, todo_inline, TREE_PURPOSE (usings));
4050
                else
4051
                  VEC_safe_push (tree, gc, todo_maybe, TREE_PURPOSE (usings));
4052
              }
4053
        }
4054
 
4055
      if (found_here)
4056
        VEC_truncate (tree, todo_maybe, 0);
4057
      else
4058
        while (VEC_length (tree, todo_maybe))
4059
          VEC_safe_push (tree, gc, todo, VEC_pop (tree, todo_maybe));
4060
    }
4061
  VEC_free (tree,gc,todo);
4062
  VEC_free (tree,gc,todo_maybe);
4063
  VEC_free (tree,gc,todo_inline);
4064
  VEC_free (tree,gc,seen);
4065
  VEC_free (tree,gc,seen_inline);
4066
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, result->value != error_mark_node);
4067
}
4068
 
4069
/* Subroutine of outer_binding.
4070
   Returns TRUE if BINDING is a binding to a template parameter of SCOPE,
4071
   FALSE otherwise.  */
4072
 
4073
static bool
4074
binding_to_template_parms_of_scope_p (cxx_binding *binding,
4075
                                      cxx_scope *scope)
4076
{
4077
  tree binding_value;
4078
 
4079
  if (!binding || !scope)
4080
    return false;
4081
 
4082
  binding_value = binding->value ?  binding->value : binding->type;
4083
 
4084
  return (scope
4085
          && scope->this_entity
4086
          && get_template_info (scope->this_entity)
4087
          && parameter_of_template_p (binding_value,
4088
                                      TI_TEMPLATE (get_template_info \
4089
                                                    (scope->this_entity))));
4090
}
4091
 
4092
/* Return the innermost non-namespace binding for NAME from a scope
4093
   containing BINDING, or, if BINDING is NULL, the current scope.
4094
   Please note that for a given template, the template parameters are
4095
   considered to be in the scope containing the current scope.
4096
   If CLASS_P is false, then class bindings are ignored.  */
4097
 
4098
cxx_binding *
4099
outer_binding (tree name,
4100
               cxx_binding *binding,
4101
               bool class_p)
4102
{
4103
  cxx_binding *outer;
4104
  cxx_scope *scope;
4105
  cxx_scope *outer_scope;
4106
 
4107
  if (binding)
4108
    {
4109
      scope = binding->scope->level_chain;
4110
      outer = binding->previous;
4111
    }
4112
  else
4113
    {
4114
      scope = current_binding_level;
4115
      outer = IDENTIFIER_BINDING (name);
4116
    }
4117
  outer_scope = outer ? outer->scope : NULL;
4118
 
4119
  /* Because we create class bindings lazily, we might be missing a
4120
     class binding for NAME.  If there are any class binding levels
4121
     between the LAST_BINDING_LEVEL and the scope in which OUTER was
4122
     declared, we must lookup NAME in those class scopes.  */
4123
  if (class_p)
4124
    while (scope && scope != outer_scope && scope->kind != sk_namespace)
4125
      {
4126
        if (scope->kind == sk_class)
4127
          {
4128
            cxx_binding *class_binding;
4129
 
4130
            class_binding = get_class_binding (name, scope);
4131
            if (class_binding)
4132
              {
4133
                /* Thread this new class-scope binding onto the
4134
                   IDENTIFIER_BINDING list so that future lookups
4135
                   find it quickly.  */
4136
                class_binding->previous = outer;
4137
                if (binding)
4138
                  binding->previous = class_binding;
4139
                else
4140
                  IDENTIFIER_BINDING (name) = class_binding;
4141
                return class_binding;
4142
              }
4143
          }
4144
        /* If we are in a member template, the template parms of the member
4145
           template are considered to be inside the scope of the containing
4146
           class, but within G++ the class bindings are all pushed between the
4147
           template parms and the function body.  So if the outer binding is
4148
           a template parm for the current scope, return it now rather than
4149
           look for a class binding.  */
4150
        if (outer_scope && outer_scope->kind == sk_template_parms
4151
            && binding_to_template_parms_of_scope_p (outer, scope))
4152
          return outer;
4153
 
4154
        scope = scope->level_chain;
4155
      }
4156
 
4157
  return outer;
4158
}
4159
 
4160
/* Return the innermost block-scope or class-scope value binding for
4161
   NAME, or NULL_TREE if there is no such binding.  */
4162
 
4163
tree
4164
innermost_non_namespace_value (tree name)
4165
{
4166
  cxx_binding *binding;
4167
  binding = outer_binding (name, /*binding=*/NULL, /*class_p=*/true);
4168
  return binding ? binding->value : NULL_TREE;
4169
}
4170
 
4171
/* Look up NAME in the current binding level and its superiors in the
4172
   namespace of variables, functions and typedefs.  Return a ..._DECL
4173
   node of some kind representing its definition if there is only one
4174
   such declaration, or return a TREE_LIST with all the overloaded
4175
   definitions if there are many, or return 0 if it is undefined.
4176
   Hidden name, either friend declaration or built-in function, are
4177
   not ignored.
4178
 
4179
   If PREFER_TYPE is > 0, we prefer TYPE_DECLs or namespaces.
4180
   If PREFER_TYPE is > 1, we reject non-type decls (e.g. namespaces).
4181
   Otherwise we prefer non-TYPE_DECLs.
4182
 
4183
   If NONCLASS is nonzero, bindings in class scopes are ignored.  If
4184
   BLOCK_P is false, bindings in block scopes are ignored.  */
4185
 
4186
tree
4187
lookup_name_real (tree name, int prefer_type, int nonclass, bool block_p,
4188
                  int namespaces_only, int flags)
4189
{
4190
  cxx_binding *iter;
4191
  tree val = NULL_TREE;
4192
 
4193
  timevar_push (TV_NAME_LOOKUP);
4194
  /* Conversion operators are handled specially because ordinary
4195
     unqualified name lookup will not find template conversion
4196
     operators.  */
4197
  if (IDENTIFIER_TYPENAME_P (name))
4198
    {
4199
      struct cp_binding_level *level;
4200
 
4201
      for (level = current_binding_level;
4202
           level && level->kind != sk_namespace;
4203
           level = level->level_chain)
4204
        {
4205
          tree class_type;
4206
          tree operators;
4207
 
4208
          /* A conversion operator can only be declared in a class
4209
             scope.  */
4210
          if (level->kind != sk_class)
4211
            continue;
4212
 
4213
          /* Lookup the conversion operator in the class.  */
4214
          class_type = level->this_entity;
4215
          operators = lookup_fnfields (class_type, name, /*protect=*/0);
4216
          if (operators)
4217
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, operators);
4218
        }
4219
 
4220
      POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4221
    }
4222
 
4223
  flags |= lookup_flags (prefer_type, namespaces_only);
4224
 
4225
  /* First, look in non-namespace scopes.  */
4226
 
4227
  if (current_class_type == NULL_TREE)
4228
    nonclass = 1;
4229
 
4230
  if (block_p || !nonclass)
4231
    for (iter = outer_binding (name, NULL, !nonclass);
4232
         iter;
4233
         iter = outer_binding (name, iter, !nonclass))
4234
      {
4235
        tree binding;
4236
 
4237
        /* Skip entities we don't want.  */
4238
        if (LOCAL_BINDING_P (iter) ? !block_p : nonclass)
4239
          continue;
4240
 
4241
        /* If this is the kind of thing we're looking for, we're done.  */
4242
        if (qualify_lookup (iter->value, flags))
4243
          binding = iter->value;
4244
        else if ((flags & LOOKUP_PREFER_TYPES)
4245
                 && qualify_lookup (iter->type, flags))
4246
          binding = iter->type;
4247
        else
4248
          binding = NULL_TREE;
4249
 
4250
        if (binding)
4251
          {
4252
            if (hidden_name_p (binding))
4253
              {
4254
                /* A non namespace-scope binding can only be hidden in the
4255
                   presence of a local class, due to friend declarations.
4256
 
4257
                   In particular, consider:
4258
 
4259
                   struct C;
4260
                   void f() {
4261
                     struct A {
4262
                       friend struct B;
4263
                       friend struct C;
4264
                       void g() {
4265
                         B* b; // error: B is hidden
4266
                         C* c; // OK, finds ::C
4267
                       }
4268
                     };
4269
                     B *b;  // error: B is hidden
4270
                     C *c;  // OK, finds ::C
4271
                     struct B {};
4272
                     B *bb; // OK
4273
                   }
4274
 
4275
                   The standard says that "B" is a local class in "f"
4276
                   (but not nested within "A") -- but that name lookup
4277
                   for "B" does not find this declaration until it is
4278
                   declared directly with "f".
4279
 
4280
                   In particular:
4281
 
4282
                   [class.friend]
4283
 
4284
                   If a friend declaration appears in a local class and
4285
                   the name specified is an unqualified name, a prior
4286
                   declaration is looked up without considering scopes
4287
                   that are outside the innermost enclosing non-class
4288
                   scope. For a friend function declaration, if there is
4289
                   no prior declaration, the program is ill-formed. For a
4290
                   friend class declaration, if there is no prior
4291
                   declaration, the class that is specified belongs to the
4292
                   innermost enclosing non-class scope, but if it is
4293
                   subsequently referenced, its name is not found by name
4294
                   lookup until a matching declaration is provided in the
4295
                   innermost enclosing nonclass scope.
4296
 
4297
                   So just keep looking for a non-hidden binding.
4298
                */
4299
                gcc_assert (TREE_CODE (binding) == TYPE_DECL);
4300
                continue;
4301
              }
4302
            val = binding;
4303
            break;
4304
          }
4305
      }
4306
 
4307
  /* Now lookup in namespace scopes.  */
4308
  if (!val)
4309
    val = unqualified_namespace_lookup (name, flags);
4310
 
4311
  /* If we have a single function from a using decl, pull it out.  */
4312
  if (val && TREE_CODE (val) == OVERLOAD && !really_overloaded_fn (val))
4313
    val = OVL_FUNCTION (val);
4314
 
4315
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4316
}
4317
 
4318
tree
4319
lookup_name_nonclass (tree name)
4320
{
4321
  return lookup_name_real (name, 0, 1, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4322
}
4323
 
4324
tree
4325
lookup_function_nonclass (tree name, VEC(tree,gc) *args, bool block_p)
4326
{
4327
  return
4328
    lookup_arg_dependent (name,
4329
                          lookup_name_real (name, 0, 1, block_p, 0,
4330
                                            LOOKUP_COMPLAIN),
4331
                          args);
4332
}
4333
 
4334
tree
4335
lookup_name (tree name)
4336
{
4337
  return lookup_name_real (name, 0, 0, /*block_p=*/true, 0, LOOKUP_COMPLAIN);
4338
}
4339
 
4340
tree
4341
lookup_name_prefer_type (tree name, int prefer_type)
4342
{
4343
  return lookup_name_real (name, prefer_type, 0, /*block_p=*/true,
4344
                           0, LOOKUP_COMPLAIN);
4345
}
4346
 
4347
/* Look up NAME for type used in elaborated name specifier in
4348
   the scopes given by SCOPE.  SCOPE can be either TS_CURRENT or
4349
   TS_WITHIN_ENCLOSING_NON_CLASS.  Although not implied by the
4350
   name, more scopes are checked if cleanup or template parameter
4351
   scope is encountered.
4352
 
4353
   Unlike lookup_name_real, we make sure that NAME is actually
4354
   declared in the desired scope, not from inheritance, nor using
4355
   directive.  For using declaration, there is DR138 still waiting
4356
   to be resolved.  Hidden name coming from an earlier friend
4357
   declaration is also returned.
4358
 
4359
   A TYPE_DECL best matching the NAME is returned.  Catching error
4360
   and issuing diagnostics are caller's responsibility.  */
4361
 
4362
tree
4363
lookup_type_scope (tree name, tag_scope scope)
4364
{
4365
  cxx_binding *iter = NULL;
4366
  tree val = NULL_TREE;
4367
 
4368
  timevar_push (TV_NAME_LOOKUP);
4369
 
4370
  /* Look in non-namespace scope first.  */
4371
  if (current_binding_level->kind != sk_namespace)
4372
    iter = outer_binding (name, NULL, /*class_p=*/ true);
4373
  for (; iter; iter = outer_binding (name, iter, /*class_p=*/ true))
4374
    {
4375
      /* Check if this is the kind of thing we're looking for.
4376
         If SCOPE is TS_CURRENT, also make sure it doesn't come from
4377
         base class.  For ITER->VALUE, we can simply use
4378
         INHERITED_VALUE_BINDING_P.  For ITER->TYPE, we have to use
4379
         our own check.
4380
 
4381
         We check ITER->TYPE before ITER->VALUE in order to handle
4382
           typedef struct C {} C;
4383
         correctly.  */
4384
 
4385
      if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES)
4386
          && (scope != ts_current
4387
              || LOCAL_BINDING_P (iter)
4388
              || DECL_CONTEXT (iter->type) == iter->scope->this_entity))
4389
        val = iter->type;
4390
      else if ((scope != ts_current
4391
                || !INHERITED_VALUE_BINDING_P (iter))
4392
               && qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4393
        val = iter->value;
4394
 
4395
      if (val)
4396
        break;
4397
    }
4398
 
4399
  /* Look in namespace scope.  */
4400
  if (!val)
4401
    {
4402
      iter = cxx_scope_find_binding_for_name
4403
               (NAMESPACE_LEVEL (current_decl_namespace ()), name);
4404
 
4405
      if (iter)
4406
        {
4407
          /* If this is the kind of thing we're looking for, we're done.  */
4408
          if (qualify_lookup (iter->type, LOOKUP_PREFER_TYPES))
4409
            val = iter->type;
4410
          else if (qualify_lookup (iter->value, LOOKUP_PREFER_TYPES))
4411
            val = iter->value;
4412
        }
4413
 
4414
    }
4415
 
4416
  /* Type found, check if it is in the allowed scopes, ignoring cleanup
4417
     and template parameter scopes.  */
4418
  if (val)
4419
    {
4420
      struct cp_binding_level *b = current_binding_level;
4421
      while (b)
4422
        {
4423
          if (iter->scope == b)
4424
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val);
4425
 
4426
          if (b->kind == sk_cleanup || b->kind == sk_template_parms
4427
              || b->kind == sk_function_parms)
4428
            b = b->level_chain;
4429
          else if (b->kind == sk_class
4430
                   && scope == ts_within_enclosing_non_class)
4431
            b = b->level_chain;
4432
          else
4433
            break;
4434
        }
4435
    }
4436
 
4437
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
4438
}
4439
 
4440
/* Similar to `lookup_name' but look only in the innermost non-class
4441
   binding level.  */
4442
 
4443
tree
4444
lookup_name_innermost_nonclass_level (tree name)
4445
{
4446
  struct cp_binding_level *b;
4447
  tree t = NULL_TREE;
4448
 
4449
  timevar_push (TV_NAME_LOOKUP);
4450
  b = innermost_nonclass_level ();
4451
 
4452
  if (b->kind == sk_namespace)
4453
    {
4454
      t = IDENTIFIER_NAMESPACE_VALUE (name);
4455
 
4456
      /* extern "C" function() */
4457
      if (t != NULL_TREE && TREE_CODE (t) == TREE_LIST)
4458
        t = TREE_VALUE (t);
4459
    }
4460
  else if (IDENTIFIER_BINDING (name)
4461
           && LOCAL_BINDING_P (IDENTIFIER_BINDING (name)))
4462
    {
4463
      cxx_binding *binding;
4464
      binding = IDENTIFIER_BINDING (name);
4465
      while (1)
4466
        {
4467
          if (binding->scope == b
4468
              && !(TREE_CODE (binding->value) == VAR_DECL
4469
                   && DECL_DEAD_FOR_LOCAL (binding->value)))
4470
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding->value);
4471
 
4472
          if (b->kind == sk_cleanup)
4473
            b = b->level_chain;
4474
          else
4475
            break;
4476
        }
4477
    }
4478
 
4479
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4480
}
4481
 
4482
/* Returns true iff DECL is a block-scope extern declaration of a function
4483
   or variable.  */
4484
 
4485
bool
4486
is_local_extern (tree decl)
4487
{
4488
  cxx_binding *binding;
4489
 
4490
  /* For functions, this is easy.  */
4491
  if (TREE_CODE (decl) == FUNCTION_DECL)
4492
    return DECL_LOCAL_FUNCTION_P (decl);
4493
 
4494
  if (TREE_CODE (decl) != VAR_DECL)
4495
    return false;
4496
  if (!current_function_decl)
4497
    return false;
4498
 
4499
  /* For variables, this is not easy.  We need to look at the binding stack
4500
     for the identifier to see whether the decl we have is a local.  */
4501
  for (binding = IDENTIFIER_BINDING (DECL_NAME (decl));
4502
       binding && binding->scope->kind != sk_namespace;
4503
       binding = binding->previous)
4504
    if (binding->value == decl)
4505
      return LOCAL_BINDING_P (binding);
4506
 
4507
  return false;
4508
}
4509
 
4510
/* Like lookup_name_innermost_nonclass_level, but for types.  */
4511
 
4512
static tree
4513
lookup_type_current_level (tree name)
4514
{
4515
  tree t = NULL_TREE;
4516
 
4517
  timevar_push (TV_NAME_LOOKUP);
4518
  gcc_assert (current_binding_level->kind != sk_namespace);
4519
 
4520
  if (REAL_IDENTIFIER_TYPE_VALUE (name) != NULL_TREE
4521
      && REAL_IDENTIFIER_TYPE_VALUE (name) != global_type_node)
4522
    {
4523
      struct cp_binding_level *b = current_binding_level;
4524
      while (1)
4525
        {
4526
          if (purpose_member (name, b->type_shadowed))
4527
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
4528
                                    REAL_IDENTIFIER_TYPE_VALUE (name));
4529
          if (b->kind == sk_cleanup)
4530
            b = b->level_chain;
4531
          else
4532
            break;
4533
        }
4534
    }
4535
 
4536
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);
4537
}
4538
 
4539
/* [basic.lookup.koenig] */
4540
/* A nonzero return value in the functions below indicates an error.  */
4541
 
4542
struct arg_lookup
4543
{
4544
  tree name;
4545
  VEC(tree,gc) *args;
4546
  tree namespaces;
4547
  tree classes;
4548
  tree functions;
4549
};
4550
 
4551
static bool arg_assoc (struct arg_lookup*, tree);
4552
static bool arg_assoc_args (struct arg_lookup*, tree);
4553
static bool arg_assoc_args_vec (struct arg_lookup*, VEC(tree,gc) *);
4554
static bool arg_assoc_type (struct arg_lookup*, tree);
4555
static bool add_function (struct arg_lookup *, tree);
4556
static bool arg_assoc_namespace (struct arg_lookup *, tree);
4557
static bool arg_assoc_class_only (struct arg_lookup *, tree);
4558
static bool arg_assoc_bases (struct arg_lookup *, tree);
4559
static bool arg_assoc_class (struct arg_lookup *, tree);
4560
static bool arg_assoc_template_arg (struct arg_lookup*, tree);
4561
 
4562
/* Add a function to the lookup structure.
4563
   Returns true on error.  */
4564
 
4565
static bool
4566
add_function (struct arg_lookup *k, tree fn)
4567
{
4568
  /* We used to check here to see if the function was already in the list,
4569
     but that's O(n^2), which is just too expensive for function lookup.
4570
     Now we deal with the occasional duplicate in joust.  In doing this, we
4571
     assume that the number of duplicates will be small compared to the
4572
     total number of functions being compared, which should usually be the
4573
     case.  */
4574
 
4575
  if (!is_overloaded_fn (fn))
4576
    /* All names except those of (possibly overloaded) functions and
4577
       function templates are ignored.  */;
4578
  else if (!k->functions)
4579
    k->functions = fn;
4580
  else if (fn == k->functions)
4581
    ;
4582
  else
4583
    k->functions = build_overload (fn, k->functions);
4584
 
4585
  return false;
4586
}
4587
 
4588
/* Returns true iff CURRENT has declared itself to be an associated
4589
   namespace of SCOPE via a strong using-directive (or transitive chain
4590
   thereof).  Both are namespaces.  */
4591
 
4592
bool
4593
is_associated_namespace (tree current, tree scope)
4594
{
4595
  tree seen = NULL_TREE;
4596
  tree todo = NULL_TREE;
4597
  tree t;
4598
  while (1)
4599
    {
4600
      if (scope == current)
4601
        return true;
4602
      seen = tree_cons (scope, NULL_TREE, seen);
4603
      for (t = DECL_NAMESPACE_ASSOCIATIONS (scope); t; t = TREE_CHAIN (t))
4604
        if (!purpose_member (TREE_PURPOSE (t), seen))
4605
          todo = tree_cons (TREE_PURPOSE (t), NULL_TREE, todo);
4606
      if (todo)
4607
        {
4608
          scope = TREE_PURPOSE (todo);
4609
          todo = TREE_CHAIN (todo);
4610
        }
4611
      else
4612
        return false;
4613
    }
4614
}
4615
 
4616
/* Add functions of a namespace to the lookup structure.
4617
   Returns true on error.  */
4618
 
4619
static bool
4620
arg_assoc_namespace (struct arg_lookup *k, tree scope)
4621
{
4622
  tree value;
4623
 
4624
  if (purpose_member (scope, k->namespaces))
4625
    return 0;
4626
  k->namespaces = tree_cons (scope, NULL_TREE, k->namespaces);
4627
 
4628
  /* Check out our super-users.  */
4629
  for (value = DECL_NAMESPACE_ASSOCIATIONS (scope); value;
4630
       value = TREE_CHAIN (value))
4631
    if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4632
      return true;
4633
 
4634
  /* Also look down into inline namespaces.  */
4635
  for (value = DECL_NAMESPACE_USING (scope); value;
4636
       value = TREE_CHAIN (value))
4637
    if (is_associated_namespace (scope, TREE_PURPOSE (value)))
4638
      if (arg_assoc_namespace (k, TREE_PURPOSE (value)))
4639
        return true;
4640
 
4641
  value = namespace_binding (k->name, scope);
4642
  if (!value)
4643
    return false;
4644
 
4645
  for (; value; value = OVL_NEXT (value))
4646
    {
4647
      /* We don't want to find arbitrary hidden functions via argument
4648
         dependent lookup.  We only want to find friends of associated
4649
         classes, which we'll do via arg_assoc_class.  */
4650
      if (hidden_name_p (OVL_CURRENT (value)))
4651
        continue;
4652
 
4653
      if (add_function (k, OVL_CURRENT (value)))
4654
        return true;
4655
    }
4656
 
4657
  return false;
4658
}
4659
 
4660
/* Adds everything associated with a template argument to the lookup
4661
   structure.  Returns true on error.  */
4662
 
4663
static bool
4664
arg_assoc_template_arg (struct arg_lookup *k, tree arg)
4665
{
4666
  /* [basic.lookup.koenig]
4667
 
4668
     If T is a template-id, its associated namespaces and classes are
4669
     ... the namespaces and classes associated with the types of the
4670
     template arguments provided for template type parameters
4671
     (excluding template template parameters); the namespaces in which
4672
     any template template arguments are defined; and the classes in
4673
     which any member templates used as template template arguments
4674
     are defined.  [Note: non-type template arguments do not
4675
     contribute to the set of associated namespaces.  ]  */
4676
 
4677
  /* Consider first template template arguments.  */
4678
  if (TREE_CODE (arg) == TEMPLATE_TEMPLATE_PARM
4679
      || TREE_CODE (arg) == UNBOUND_CLASS_TEMPLATE)
4680
    return false;
4681
  else if (TREE_CODE (arg) == TEMPLATE_DECL)
4682
    {
4683
      tree ctx = CP_DECL_CONTEXT (arg);
4684
 
4685
      /* It's not a member template.  */
4686
      if (TREE_CODE (ctx) == NAMESPACE_DECL)
4687
        return arg_assoc_namespace (k, ctx);
4688
      /* Otherwise, it must be member template.  */
4689
      else
4690
        return arg_assoc_class_only (k, ctx);
4691
    }
4692
  /* It's an argument pack; handle it recursively.  */
4693
  else if (ARGUMENT_PACK_P (arg))
4694
    {
4695
      tree args = ARGUMENT_PACK_ARGS (arg);
4696
      int i, len = TREE_VEC_LENGTH (args);
4697
      for (i = 0; i < len; ++i)
4698
        if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, i)))
4699
          return true;
4700
 
4701
      return false;
4702
    }
4703
  /* It's not a template template argument, but it is a type template
4704
     argument.  */
4705
  else if (TYPE_P (arg))
4706
    return arg_assoc_type (k, arg);
4707
  /* It's a non-type template argument.  */
4708
  else
4709
    return false;
4710
}
4711
 
4712
/* Adds the class and its friends to the lookup structure.
4713
   Returns true on error.  */
4714
 
4715
static bool
4716
arg_assoc_class_only (struct arg_lookup *k, tree type)
4717
{
4718
  tree list, friends, context;
4719
 
4720
  /* Backend-built structures, such as __builtin_va_list, aren't
4721
     affected by all this.  */
4722
  if (!CLASS_TYPE_P (type))
4723
    return false;
4724
 
4725
  context = decl_namespace_context (type);
4726
  if (arg_assoc_namespace (k, context))
4727
    return true;
4728
 
4729
  complete_type (type);
4730
 
4731
  /* Process friends.  */
4732
  for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
4733
       list = TREE_CHAIN (list))
4734
    if (k->name == FRIEND_NAME (list))
4735
      for (friends = FRIEND_DECLS (list); friends;
4736
           friends = TREE_CHAIN (friends))
4737
        {
4738
          tree fn = TREE_VALUE (friends);
4739
 
4740
          /* Only interested in global functions with potentially hidden
4741
             (i.e. unqualified) declarations.  */
4742
          if (CP_DECL_CONTEXT (fn) != context)
4743
            continue;
4744
          /* Template specializations are never found by name lookup.
4745
             (Templates themselves can be found, but not template
4746
             specializations.)  */
4747
          if (TREE_CODE (fn) == FUNCTION_DECL && DECL_USE_TEMPLATE (fn))
4748
            continue;
4749
          if (add_function (k, fn))
4750
            return true;
4751
        }
4752
 
4753
  return false;
4754
}
4755
 
4756
/* Adds the class and its bases to the lookup structure.
4757
   Returns true on error.  */
4758
 
4759
static bool
4760
arg_assoc_bases (struct arg_lookup *k, tree type)
4761
{
4762
  if (arg_assoc_class_only (k, type))
4763
    return true;
4764
 
4765
  if (TYPE_BINFO (type))
4766
    {
4767
      /* Process baseclasses.  */
4768
      tree binfo, base_binfo;
4769
      int i;
4770
 
4771
      for (binfo = TYPE_BINFO (type), i = 0;
4772
           BINFO_BASE_ITERATE (binfo, i, base_binfo); i++)
4773
        if (arg_assoc_bases (k, BINFO_TYPE (base_binfo)))
4774
          return true;
4775
    }
4776
 
4777
  return false;
4778
}
4779
 
4780
/* Adds everything associated with a class argument type to the lookup
4781
   structure.  Returns true on error.
4782
 
4783
   If T is a class type (including unions), its associated classes are: the
4784
   class itself; the class of which it is a member, if any; and its direct
4785
   and indirect base classes. Its associated namespaces are the namespaces
4786
   of which its associated classes are members. Furthermore, if T is a
4787
   class template specialization, its associated namespaces and classes
4788
   also include: the namespaces and classes associated with the types of
4789
   the template arguments provided for template type parameters (excluding
4790
   template template parameters); the namespaces of which any template
4791
   template arguments are members; and the classes of which any member
4792
   templates used as template template arguments are members. [ Note:
4793
   non-type template arguments do not contribute to the set of associated
4794
   namespaces.  --end note] */
4795
 
4796
static bool
4797
arg_assoc_class (struct arg_lookup *k, tree type)
4798
{
4799
  tree list;
4800
  int i;
4801
 
4802
  /* Backend build structures, such as __builtin_va_list, aren't
4803
     affected by all this.  */
4804
  if (!CLASS_TYPE_P (type))
4805
    return false;
4806
 
4807
  if (purpose_member (type, k->classes))
4808
    return false;
4809
  k->classes = tree_cons (type, NULL_TREE, k->classes);
4810
 
4811
  if (TYPE_CLASS_SCOPE_P (type)
4812
      && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
4813
    return true;
4814
 
4815
  if (arg_assoc_bases (k, type))
4816
    return true;
4817
 
4818
  /* Process template arguments.  */
4819
  if (CLASSTYPE_TEMPLATE_INFO (type)
4820
      && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (type)))
4821
    {
4822
      list = INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type));
4823
      for (i = 0; i < TREE_VEC_LENGTH (list); ++i)
4824
        if (arg_assoc_template_arg (k, TREE_VEC_ELT (list, i)))
4825
          return true;
4826
    }
4827
 
4828
  return false;
4829
}
4830
 
4831
/* Adds everything associated with a given type.
4832
   Returns 1 on error.  */
4833
 
4834
static bool
4835
arg_assoc_type (struct arg_lookup *k, tree type)
4836
{
4837
  /* As we do not get the type of non-type dependent expressions
4838
     right, we can end up with such things without a type.  */
4839
  if (!type)
4840
    return false;
4841
 
4842
  if (TYPE_PTRMEM_P (type))
4843
    {
4844
      /* Pointer to member: associate class type and value type.  */
4845
      if (arg_assoc_type (k, TYPE_PTRMEM_CLASS_TYPE (type)))
4846
        return true;
4847
      return arg_assoc_type (k, TYPE_PTRMEM_POINTED_TO_TYPE (type));
4848
    }
4849
  else switch (TREE_CODE (type))
4850
    {
4851
    case ERROR_MARK:
4852
      return false;
4853
    case VOID_TYPE:
4854
    case INTEGER_TYPE:
4855
    case REAL_TYPE:
4856
    case COMPLEX_TYPE:
4857
    case VECTOR_TYPE:
4858
    case BOOLEAN_TYPE:
4859
    case FIXED_POINT_TYPE:
4860
    case DECLTYPE_TYPE:
4861
      return false;
4862
    case RECORD_TYPE:
4863
      if (TYPE_PTRMEMFUNC_P (type))
4864
        return arg_assoc_type (k, TYPE_PTRMEMFUNC_FN_TYPE (type));
4865
    case UNION_TYPE:
4866
      return arg_assoc_class (k, type);
4867
    case POINTER_TYPE:
4868
    case REFERENCE_TYPE:
4869
    case ARRAY_TYPE:
4870
      return arg_assoc_type (k, TREE_TYPE (type));
4871
    case ENUMERAL_TYPE:
4872
      if (TYPE_CLASS_SCOPE_P (type)
4873
          && arg_assoc_class_only (k, TYPE_CONTEXT (type)))
4874
        return true;
4875
      return arg_assoc_namespace (k, decl_namespace_context (type));
4876
    case METHOD_TYPE:
4877
      /* The basetype is referenced in the first arg type, so just
4878
         fall through.  */
4879
    case FUNCTION_TYPE:
4880
      /* Associate the parameter types.  */
4881
      if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
4882
        return true;
4883
      /* Associate the return type.  */
4884
      return arg_assoc_type (k, TREE_TYPE (type));
4885
    case TEMPLATE_TYPE_PARM:
4886
    case BOUND_TEMPLATE_TEMPLATE_PARM:
4887
      return false;
4888
    case TYPENAME_TYPE:
4889
      return false;
4890
    case LANG_TYPE:
4891
      gcc_assert (type == unknown_type_node
4892
                  || type == init_list_type_node);
4893
      return false;
4894
    case TYPE_PACK_EXPANSION:
4895
      return arg_assoc_type (k, PACK_EXPANSION_PATTERN (type));
4896
 
4897
    default:
4898
      gcc_unreachable ();
4899
    }
4900
  return false;
4901
}
4902
 
4903
/* Adds everything associated with arguments.  Returns true on error.  */
4904
 
4905
static bool
4906
arg_assoc_args (struct arg_lookup *k, tree args)
4907
{
4908
  for (; args; args = TREE_CHAIN (args))
4909
    if (arg_assoc (k, TREE_VALUE (args)))
4910
      return true;
4911
  return false;
4912
}
4913
 
4914
/* Adds everything associated with an argument vector.  Returns true
4915
   on error.  */
4916
 
4917
static bool
4918
arg_assoc_args_vec (struct arg_lookup *k, VEC(tree,gc) *args)
4919
{
4920
  unsigned int ix;
4921
  tree arg;
4922
 
4923
  for (ix = 0; VEC_iterate (tree, args, ix, arg); ++ix)
4924
    if (arg_assoc (k, arg))
4925
      return true;
4926
  return false;
4927
}
4928
 
4929
/* Adds everything associated with a given tree_node.  Returns 1 on error.  */
4930
 
4931
static bool
4932
arg_assoc (struct arg_lookup *k, tree n)
4933
{
4934
  if (n == error_mark_node)
4935
    return false;
4936
 
4937
  if (TYPE_P (n))
4938
    return arg_assoc_type (k, n);
4939
 
4940
  if (! type_unknown_p (n))
4941
    return arg_assoc_type (k, TREE_TYPE (n));
4942
 
4943
  if (TREE_CODE (n) == ADDR_EXPR)
4944
    n = TREE_OPERAND (n, 0);
4945
  if (TREE_CODE (n) == COMPONENT_REF)
4946
    n = TREE_OPERAND (n, 1);
4947
  if (TREE_CODE (n) == OFFSET_REF)
4948
    n = TREE_OPERAND (n, 1);
4949
  while (TREE_CODE (n) == TREE_LIST)
4950
    n = TREE_VALUE (n);
4951
  if (TREE_CODE (n) == BASELINK)
4952
    n = BASELINK_FUNCTIONS (n);
4953
 
4954
  if (TREE_CODE (n) == FUNCTION_DECL)
4955
    return arg_assoc_type (k, TREE_TYPE (n));
4956
  if (TREE_CODE (n) == TEMPLATE_ID_EXPR)
4957
    {
4958
      /* The working paper doesn't currently say how to handle template-id
4959
         arguments.  The sensible thing would seem to be to handle the list
4960
         of template candidates like a normal overload set, and handle the
4961
         template arguments like we do for class template
4962
         specializations.  */
4963
      tree templ = TREE_OPERAND (n, 0);
4964
      tree args = TREE_OPERAND (n, 1);
4965
      int ix;
4966
 
4967
      /* First the templates.  */
4968
      if (arg_assoc (k, templ))
4969
        return true;
4970
 
4971
      /* Now the arguments.  */
4972
      if (args)
4973
        for (ix = TREE_VEC_LENGTH (args); ix--;)
4974
          if (arg_assoc_template_arg (k, TREE_VEC_ELT (args, ix)) == 1)
4975
            return true;
4976
    }
4977
  else if (TREE_CODE (n) == OVERLOAD)
4978
    {
4979
      for (; n; n = OVL_CHAIN (n))
4980
        if (arg_assoc_type (k, TREE_TYPE (OVL_FUNCTION (n))))
4981
          return true;
4982
    }
4983
 
4984
  return false;
4985
}
4986
 
4987
/* Performs Koenig lookup depending on arguments, where fns
4988
   are the functions found in normal lookup.  */
4989
 
4990
tree
4991
lookup_arg_dependent (tree name, tree fns, VEC(tree,gc) *args)
4992
{
4993
  struct arg_lookup k;
4994
 
4995
  timevar_push (TV_NAME_LOOKUP);
4996
 
4997
  /* Remove any hidden friend functions from the list of functions
4998
     found so far.  They will be added back by arg_assoc_class as
4999
     appropriate.  */
5000
  fns = remove_hidden_names (fns);
5001
 
5002
  k.name = name;
5003
  k.args = args;
5004
  k.functions = fns;
5005
  k.classes = NULL_TREE;
5006
 
5007
  /* We previously performed an optimization here by setting
5008
     NAMESPACES to the current namespace when it was safe. However, DR
5009
     164 says that namespaces that were already searched in the first
5010
     stage of template processing are searched again (potentially
5011
     picking up later definitions) in the second stage. */
5012
  k.namespaces = NULL_TREE;
5013
 
5014
  arg_assoc_args_vec (&k, args);
5015
 
5016
  fns = k.functions;
5017
 
5018
  if (fns
5019
      && TREE_CODE (fns) != VAR_DECL
5020
      && !is_overloaded_fn (fns))
5021
    {
5022
      error ("argument dependent lookup finds %q+D", fns);
5023
      error ("  in call to %qD", name);
5024
      fns = error_mark_node;
5025
    }
5026
 
5027
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, fns);
5028
}
5029
 
5030
/* Add namespace to using_directives. Return NULL_TREE if nothing was
5031
   changed (i.e. there was already a directive), or the fresh
5032
   TREE_LIST otherwise.  */
5033
 
5034
static tree
5035
push_using_directive (tree used)
5036
{
5037
  tree ud = current_binding_level->using_directives;
5038
  tree iter, ancestor;
5039
 
5040
  timevar_push (TV_NAME_LOOKUP);
5041
  /* Check if we already have this.  */
5042
  if (purpose_member (used, ud) != NULL_TREE)
5043
    POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, NULL_TREE);
5044
 
5045
  ancestor = namespace_ancestor (current_decl_namespace (), used);
5046
  ud = current_binding_level->using_directives;
5047
  ud = tree_cons (used, ancestor, ud);
5048
  current_binding_level->using_directives = ud;
5049
 
5050
  /* Recursively add all namespaces used.  */
5051
  for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
5052
    push_using_directive (TREE_PURPOSE (iter));
5053
 
5054
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, ud);
5055
}
5056
 
5057
/* The type TYPE is being declared.  If it is a class template, or a
5058
   specialization of a class template, do any processing required and
5059
   perform error-checking.  If IS_FRIEND is nonzero, this TYPE is
5060
   being declared a friend.  B is the binding level at which this TYPE
5061
   should be bound.
5062
 
5063
   Returns the TYPE_DECL for TYPE, which may have been altered by this
5064
   processing.  */
5065
 
5066
static tree
5067
maybe_process_template_type_declaration (tree type, int is_friend,
5068
                                         cxx_scope *b)
5069
{
5070
  tree decl = TYPE_NAME (type);
5071
 
5072
  if (processing_template_parmlist)
5073
    /* You can't declare a new template type in a template parameter
5074
       list.  But, you can declare a non-template type:
5075
 
5076
         template <class A*> struct S;
5077
 
5078
       is a forward-declaration of `A'.  */
5079
    ;
5080
  else if (b->kind == sk_namespace
5081
           && current_binding_level->kind != sk_namespace)
5082
    /* If this new type is being injected into a containing scope,
5083
       then it's not a template type.  */
5084
    ;
5085
  else
5086
    {
5087
      gcc_assert (MAYBE_CLASS_TYPE_P (type)
5088
                  || TREE_CODE (type) == ENUMERAL_TYPE);
5089
 
5090
      if (processing_template_decl)
5091
        {
5092
          /* This may change after the call to
5093
             push_template_decl_real, but we want the original value.  */
5094
          tree name = DECL_NAME (decl);
5095
 
5096
          decl = push_template_decl_real (decl, is_friend);
5097
          if (decl == error_mark_node)
5098
            return error_mark_node;
5099
 
5100
          /* If the current binding level is the binding level for the
5101
             template parameters (see the comment in
5102
             begin_template_parm_list) and the enclosing level is a class
5103
             scope, and we're not looking at a friend, push the
5104
             declaration of the member class into the class scope.  In the
5105
             friend case, push_template_decl will already have put the
5106
             friend into global scope, if appropriate.  */
5107
          if (TREE_CODE (type) != ENUMERAL_TYPE
5108
              && !is_friend && b->kind == sk_template_parms
5109
              && b->level_chain->kind == sk_class)
5110
            {
5111
              finish_member_declaration (CLASSTYPE_TI_TEMPLATE (type));
5112
 
5113
              if (!COMPLETE_TYPE_P (current_class_type))
5114
                {
5115
                  maybe_add_class_template_decl_list (current_class_type,
5116
                                                      type, /*friend_p=*/0);
5117
                  /* Put this UTD in the table of UTDs for the class.  */
5118
                  if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5119
                    CLASSTYPE_NESTED_UTDS (current_class_type) =
5120
                      binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5121
 
5122
                  binding_table_insert
5123
                    (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5124
                }
5125
            }
5126
        }
5127
    }
5128
 
5129
  return decl;
5130
}
5131
 
5132
/* Push a tag name NAME for struct/class/union/enum type TYPE.  In case
5133
   that the NAME is a class template, the tag is processed but not pushed.
5134
 
5135
   The pushed scope depend on the SCOPE parameter:
5136
   - When SCOPE is TS_CURRENT, put it into the inner-most non-sk_cleanup
5137
     scope.
5138
   - When SCOPE is TS_GLOBAL, put it in the inner-most non-class and
5139
     non-template-parameter scope.  This case is needed for forward
5140
     declarations.
5141
   - When SCOPE is TS_WITHIN_ENCLOSING_NON_CLASS, this is similar to
5142
     TS_GLOBAL case except that names within template-parameter scopes
5143
     are not pushed at all.
5144
 
5145
   Returns TYPE upon success and ERROR_MARK_NODE otherwise.  */
5146
 
5147
tree
5148
pushtag (tree name, tree type, tag_scope scope)
5149
{
5150
  struct cp_binding_level *b;
5151
  tree decl;
5152
 
5153
  timevar_push (TV_NAME_LOOKUP);
5154
  b = current_binding_level;
5155
  while (/* Cleanup scopes are not scopes from the point of view of
5156
            the language.  */
5157
         b->kind == sk_cleanup
5158
         /* Neither are function parameter scopes.  */
5159
         || b->kind == sk_function_parms
5160
         /* Neither are the scopes used to hold template parameters
5161
            for an explicit specialization.  For an ordinary template
5162
            declaration, these scopes are not scopes from the point of
5163
            view of the language.  */
5164
         || (b->kind == sk_template_parms
5165
             && (b->explicit_spec_p || scope == ts_global))
5166
         || (b->kind == sk_class
5167
             && (scope != ts_current
5168
                 /* We may be defining a new type in the initializer
5169
                    of a static member variable. We allow this when
5170
                    not pedantic, and it is particularly useful for
5171
                    type punning via an anonymous union.  */
5172
                 || COMPLETE_TYPE_P (b->this_entity))))
5173
    b = b->level_chain;
5174
 
5175
  gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
5176
 
5177
  /* Do C++ gratuitous typedefing.  */
5178
  if (IDENTIFIER_TYPE_VALUE (name) != type)
5179
    {
5180
      tree tdef;
5181
      int in_class = 0;
5182
      tree context = TYPE_CONTEXT (type);
5183
 
5184
      if (! context)
5185
        {
5186
          tree cs = current_scope ();
5187
 
5188
          if (scope == ts_current
5189
              || (cs && TREE_CODE (cs) == FUNCTION_DECL))
5190
            context = cs;
5191
          else if (cs != NULL_TREE && TYPE_P (cs))
5192
            /* When declaring a friend class of a local class, we want
5193
               to inject the newly named class into the scope
5194
               containing the local class, not the namespace
5195
               scope.  */
5196
            context = decl_function_context (get_type_decl (cs));
5197
        }
5198
      if (!context)
5199
        context = current_namespace;
5200
 
5201
      if (b->kind == sk_class
5202
          || (b->kind == sk_template_parms
5203
              && b->level_chain->kind == sk_class))
5204
        in_class = 1;
5205
 
5206
      if (current_lang_name == lang_name_java)
5207
        TYPE_FOR_JAVA (type) = 1;
5208
 
5209
      tdef = create_implicit_typedef (name, type);
5210
      DECL_CONTEXT (tdef) = FROB_CONTEXT (context);
5211
      if (scope == ts_within_enclosing_non_class)
5212
        {
5213
          /* This is a friend.  Make this TYPE_DECL node hidden from
5214
             ordinary name lookup.  Its corresponding TEMPLATE_DECL
5215
             will be marked in push_template_decl_real.  */
5216
          retrofit_lang_decl (tdef);
5217
          DECL_ANTICIPATED (tdef) = 1;
5218
          DECL_FRIEND_P (tdef) = 1;
5219
        }
5220
 
5221
      decl = maybe_process_template_type_declaration
5222
        (type, scope == ts_within_enclosing_non_class, b);
5223
      if (decl == error_mark_node)
5224
        POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5225
 
5226
      if (b->kind == sk_class)
5227
        {
5228
          if (!TYPE_BEING_DEFINED (current_class_type))
5229
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
5230
 
5231
          if (!PROCESSING_REAL_TEMPLATE_DECL_P ())
5232
            /* Put this TYPE_DECL on the TYPE_FIELDS list for the
5233
               class.  But if it's a member template class, we want
5234
               the TEMPLATE_DECL, not the TYPE_DECL, so this is done
5235
               later.  */
5236
            finish_member_declaration (decl);
5237
          else
5238
            pushdecl_class_level (decl);
5239
        }
5240
      else if (b->kind != sk_template_parms)
5241
        {
5242
          decl = pushdecl_with_scope (decl, b, /*is_friend=*/false);
5243
          if (decl == error_mark_node)
5244
            POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
5245
        }
5246
 
5247
      if (! in_class)
5248
        set_identifier_type_value_with_scope (name, tdef, b);
5249
 
5250
      TYPE_CONTEXT (type) = DECL_CONTEXT (decl);
5251
 
5252
      /* If this is a local class, keep track of it.  We need this
5253
         information for name-mangling, and so that it is possible to
5254
         find all function definitions in a translation unit in a
5255
         convenient way.  (It's otherwise tricky to find a member
5256
         function definition it's only pointed to from within a local
5257
         class.)  */
5258
      if (TYPE_CONTEXT (type)
5259
          && TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL)
5260
        VEC_safe_push (tree, gc, local_classes, type);
5261
    }
5262
  if (b->kind == sk_class
5263
      && !COMPLETE_TYPE_P (current_class_type))
5264
    {
5265
      maybe_add_class_template_decl_list (current_class_type,
5266
                                          type, /*friend_p=*/0);
5267
 
5268
      if (CLASSTYPE_NESTED_UTDS (current_class_type) == NULL)
5269
        CLASSTYPE_NESTED_UTDS (current_class_type)
5270
          = binding_table_new (SCOPE_DEFAULT_HT_SIZE);
5271
 
5272
      binding_table_insert
5273
        (CLASSTYPE_NESTED_UTDS (current_class_type), name, type);
5274
    }
5275
 
5276
  decl = TYPE_NAME (type);
5277
  gcc_assert (TREE_CODE (decl) == TYPE_DECL);
5278
 
5279
  /* Set type visibility now if this is a forward declaration.  */
5280
  TREE_PUBLIC (decl) = 1;
5281
  determine_visibility (decl);
5282
 
5283
  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, type);
5284
}
5285
 
5286
/* Subroutines for reverting temporarily to top-level for instantiation
5287
   of templates and such.  We actually need to clear out the class- and
5288
   local-value slots of all identifiers, so that only the global values
5289
   are at all visible.  Simply setting current_binding_level to the global
5290
   scope isn't enough, because more binding levels may be pushed.  */
5291
struct saved_scope *scope_chain;
5292
 
5293
/* If ID has not already been marked, add an appropriate binding to
5294
   *OLD_BINDINGS.  */
5295
 
5296
static void
5297
store_binding (tree id, VEC(cxx_saved_binding,gc) **old_bindings)
5298
{
5299
  cxx_saved_binding *saved;
5300
 
5301
  if (!id || !IDENTIFIER_BINDING (id))
5302
    return;
5303
 
5304
  if (IDENTIFIER_MARKED (id))
5305
    return;
5306
 
5307
  IDENTIFIER_MARKED (id) = 1;
5308
 
5309
  saved = VEC_safe_push (cxx_saved_binding, gc, *old_bindings, NULL);
5310
  saved->identifier = id;
5311
  saved->binding = IDENTIFIER_BINDING (id);
5312
  saved->real_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
5313
  IDENTIFIER_BINDING (id) = NULL;
5314
}
5315
 
5316
static void
5317
store_bindings (tree names, VEC(cxx_saved_binding,gc) **old_bindings)
5318
{
5319
  tree t;
5320
 
5321
  timevar_push (TV_NAME_LOOKUP);
5322
  for (t = names; t; t = TREE_CHAIN (t))
5323
    {
5324
      tree id;
5325
 
5326
      if (TREE_CODE (t) == TREE_LIST)
5327
        id = TREE_PURPOSE (t);
5328
      else
5329
        id = DECL_NAME (t);
5330
 
5331
      store_binding (id, old_bindings);
5332
    }
5333
  timevar_pop (TV_NAME_LOOKUP);
5334
}
5335
 
5336
/* Like store_bindings, but NAMES is a vector of cp_class_binding
5337
   objects, rather than a TREE_LIST.  */
5338
 
5339
static void
5340
store_class_bindings (VEC(cp_class_binding,gc) *names,
5341
                      VEC(cxx_saved_binding,gc) **old_bindings)
5342
{
5343
  size_t i;
5344
  cp_class_binding *cb;
5345
 
5346
  timevar_push (TV_NAME_LOOKUP);
5347
  for (i = 0; VEC_iterate(cp_class_binding, names, i, cb); ++i)
5348
    store_binding (cb->identifier, old_bindings);
5349
  timevar_pop (TV_NAME_LOOKUP);
5350
}
5351
 
5352
void
5353
push_to_top_level (void)
5354
{
5355
  struct saved_scope *s;
5356
  struct cp_binding_level *b;
5357
  cxx_saved_binding *sb;
5358
  size_t i;
5359
  bool need_pop;
5360
 
5361
  timevar_push (TV_NAME_LOOKUP);
5362
  s = GGC_CNEW (struct saved_scope);
5363
 
5364
  b = scope_chain ? current_binding_level : 0;
5365
 
5366
  /* If we're in the middle of some function, save our state.  */
5367
  if (cfun)
5368
    {
5369
      need_pop = true;
5370
      push_function_context ();
5371
    }
5372
  else
5373
    need_pop = false;
5374
 
5375
  if (scope_chain && previous_class_level)
5376
    store_class_bindings (previous_class_level->class_shadowed,
5377
                          &s->old_bindings);
5378
 
5379
  /* Have to include the global scope, because class-scope decls
5380
     aren't listed anywhere useful.  */
5381
  for (; b; b = b->level_chain)
5382
    {
5383
      tree t;
5384
 
5385
      /* Template IDs are inserted into the global level. If they were
5386
         inserted into namespace level, finish_file wouldn't find them
5387
         when doing pending instantiations. Therefore, don't stop at
5388
         namespace level, but continue until :: .  */
5389
      if (global_scope_p (b))
5390
        break;
5391
 
5392
      store_bindings (b->names, &s->old_bindings);
5393
      /* We also need to check class_shadowed to save class-level type
5394
         bindings, since pushclass doesn't fill in b->names.  */
5395
      if (b->kind == sk_class)
5396
        store_class_bindings (b->class_shadowed, &s->old_bindings);
5397
 
5398
      /* Unwind type-value slots back to top level.  */
5399
      for (t = b->type_shadowed; t; t = TREE_CHAIN (t))
5400
        SET_IDENTIFIER_TYPE_VALUE (TREE_PURPOSE (t), TREE_VALUE (t));
5401
    }
5402
 
5403
  for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, sb); ++i)
5404
    IDENTIFIER_MARKED (sb->identifier) = 0;
5405
 
5406
  s->prev = scope_chain;
5407
  s->bindings = b;
5408
  s->need_pop_function_context = need_pop;
5409
  s->function_decl = current_function_decl;
5410
  s->unevaluated_operand = cp_unevaluated_operand;
5411
  s->inhibit_evaluation_warnings = c_inhibit_evaluation_warnings;
5412
 
5413
  scope_chain = s;
5414
  current_function_decl = NULL_TREE;
5415
  current_lang_base = VEC_alloc (tree, gc, 10);
5416
  current_lang_name = lang_name_cplusplus;
5417
  current_namespace = global_namespace;
5418
  push_class_stack ();
5419
  cp_unevaluated_operand = 0;
5420
  c_inhibit_evaluation_warnings = 0;
5421
  timevar_pop (TV_NAME_LOOKUP);
5422
}
5423
 
5424
void
5425
pop_from_top_level (void)
5426
{
5427
  struct saved_scope *s = scope_chain;
5428
  cxx_saved_binding *saved;
5429
  size_t i;
5430
 
5431
  timevar_push (TV_NAME_LOOKUP);
5432
  /* Clear out class-level bindings cache.  */
5433
  if (previous_class_level)
5434
    invalidate_class_lookup_cache ();
5435
  pop_class_stack ();
5436
 
5437
  current_lang_base = 0;
5438
 
5439
  scope_chain = s->prev;
5440
  for (i = 0; VEC_iterate (cxx_saved_binding, s->old_bindings, i, saved); ++i)
5441
    {
5442
      tree id = saved->identifier;
5443
 
5444
      IDENTIFIER_BINDING (id) = saved->binding;
5445
      SET_IDENTIFIER_TYPE_VALUE (id, saved->real_type_value);
5446
    }
5447
 
5448
  /* If we were in the middle of compiling a function, restore our
5449
     state.  */
5450
  if (s->need_pop_function_context)
5451
    pop_function_context ();
5452
  current_function_decl = s->function_decl;
5453
  cp_unevaluated_operand = s->unevaluated_operand;
5454
  c_inhibit_evaluation_warnings = s->inhibit_evaluation_warnings;
5455
  timevar_pop (TV_NAME_LOOKUP);
5456
}
5457
 
5458
/* Pop off extraneous binding levels left over due to syntax errors.
5459
 
5460
   We don't pop past namespaces, as they might be valid.  */
5461
 
5462
void
5463
pop_everything (void)
5464
{
5465
  if (ENABLE_SCOPE_CHECKING)
5466
    verbatim ("XXX entering pop_everything ()\n");
5467
  while (!toplevel_bindings_p ())
5468
    {
5469
      if (current_binding_level->kind == sk_class)
5470
        pop_nested_class ();
5471
      else
5472
        poplevel (0, 0, 0);
5473
    }
5474
  if (ENABLE_SCOPE_CHECKING)
5475
    verbatim ("XXX leaving pop_everything ()\n");
5476
}
5477
 
5478
/* Emit debugging information for using declarations and directives.
5479
   If input tree is overloaded fn then emit debug info for all
5480
   candidates.  */
5481
 
5482
void
5483
cp_emit_debug_info_for_using (tree t, tree context)
5484
{
5485
  /* Don't try to emit any debug information if we have errors.  */
5486
  if (sorrycount || errorcount)
5487
    return;
5488
 
5489
  /* Ignore this FUNCTION_DECL if it refers to a builtin declaration
5490
     of a builtin function.  */
5491
  if (TREE_CODE (t) == FUNCTION_DECL
5492
      && DECL_EXTERNAL (t)
5493
      && DECL_BUILT_IN (t))
5494
    return;
5495
 
5496
  /* Do not supply context to imported_module_or_decl, if
5497
     it is a global namespace.  */
5498
  if (context == global_namespace)
5499
    context = NULL_TREE;
5500
 
5501
  if (BASELINK_P (t))
5502
    t = BASELINK_FUNCTIONS (t);
5503
 
5504
  /* FIXME: Handle TEMPLATE_DECLs.  */
5505
  for (t = OVL_CURRENT (t); t; t = OVL_NEXT (t))
5506
    if (TREE_CODE (t) != TEMPLATE_DECL)
5507
      {
5508
        if (building_stmt_tree ())
5509
          add_stmt (build_stmt (input_location, USING_STMT, t));
5510
        else
5511
          (*debug_hooks->imported_module_or_decl) (t, NULL_TREE, context, false);
5512
      }
5513
}
5514
 
5515
#include "gt-cp-name-lookup.h"

powered by: WebSVN 2.1.0

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