Studying note of GCC-3.4.6 source (55)

最新推荐文章于 2011-03-26 09:33:00 发布

wuhui_gdnt

最新推荐文章于 2011-03-26 09:33:00 发布

阅读量885

点赞数

分类专栏： Studying note of GCC-3.4.6 source 文章标签： binding tree namespaces class function null

本文链接：https://blog.csdn.net/wuhui_gdnt/article/details/5720982

版权

Studying note of GCC-3.4.6 source 专栏收录该内容

202 篇文章 1 订阅

订阅专栏

4.3.1.7.4. Create namespace “std”

4.3.1.7.4.1. Add in global namespace

“std” namespace is part of the standaer. And this namespace is also part of the C++ runtime environment, for example, the exception mechanism, runtime type information, std standard library and etc. come out of this space. So next, it will create entity for this namespace and push it into global namespace. Here std_identifier is the unique identifier for std namespace, which has been created in initialize_predefined_identifiers.

cxx_init_decl_processing (continue)

2995 /* Create the `std' namespace. */

2996 push_namespace (std_identifier);

2997 std_node = current_namespace;

2998 pop_namespace ();

Function push_namespace monopolizes the instantiation of std namespace, its addition to global namespace (more precisely, current namespace), and being current scope. Pay attention to line 3075 below, if name is null, the namespace is annoymous, which could only be accessed via below way:

namespace A {

int x1;

namespace { // first annoymous namespace

int x2; // the only way to visit x2

... // definition

namespace { // another annoymous namespace

...

}

A::x1 = 5; // no applicable to annoymous namespace

See that annoymous namespace at different level can coexist. Though annoymous namespace is nameless at side of user, the compiler must name it uniquely. anonymous_namespace_name is the name, which is also shared if there are more than one annoymous namespace. And, as annoymous namespace is only accessed in above way, sharing the same name will not cause any problem.

3059 void

3060 push_namespace (tree name) in name-lookup.c

3061 {

3062 tree d = NULL_TREE;

3063 int need_new = 1;

3064 int implicit_use = 0;

3065 bool anon = !name;

3066

3067 timevar_push (TV_NAME_LOOKUP);

3068

3069 /* We should not get here if the global_namespace is not yet constructed

3070 nor if NAME designates the global namespace: The global scope is

3071 constructed elsewhere. */

3072 my_friendly_assert (global_namespace != NULL && name != global_scope_name,

3073 20030531);

3074

3075 if (anon)

3076 {

3077 /* The name of anonymous namespace is unique for the translation

3078 unit. */

3079 if (!anonymous_namespace_name)

3080 anonymous_namespace_name = get_file_function_name ('N');

3081 name = anonymous_namespace_name;

3082 d = IDENTIFIER_NAMESPACE_VALUE (name);

3083 if (d)

3084 /* Reopening anonymous namespace. */

3085 need_new = 0;

3086 implicit_use = 1;

3087 }

3088 else

3089 {

3090 /* Check whether this is an extended namespace definition. */

3091 d = IDENTIFIER_NAMESPACE_VALUE (name);

3092 if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)

3093 {

3094 need_new = 0;

3095 if (DECL_NAMESPACE_ALIAS (d))

3096 {

3097 error ("namespace alias `%D' not allowed here, assuming `%D'",

3098 d, DECL_NAMESPACE_ALIAS (d));

3099 d = DECL_NAMESPACE_ALIAS (d);

3100 }

3101 }

3102 }

As soon as getting the name, the duty is passed to IDENTIFIER_NAMESPACE_VALUE.

264 #define IDENTIFIER_NAMESPACE_VALUE(NODE) / in cp-tree.h

265 namespace_binding ((NODE), current_namespace)

The name of current_namespace beguiles, in fact, this macro returns the namespace currently in used or last in used (current scope is not of namespace).

719 #define current_namespace scope_chain->old_namespace in cp-tree.h

Note for global namespace, scope_chain is an empty node, so current_namespace returns null. This special value in namespace searching means the global namespace.

2943 tree

2944 namespace_binding (tree name, tree scope) in name-lookup.c

2945 {

2946 cxx_binding *binding;

2947

2948 if (scope == NULL)

2949 scope = global_namespace;

2950 scope = ORIGINAL_NAMESPACE (scope);

2951 binding = cxx_scope_find_binding_for_name (NAMESPACE_LEVEL (scope), name);

2952

2953 return binding ? binding->value : NULL_TREE;

2954 }

For any sort of a *_DECL node, field abstract_origin points to the original (abstract) decl node which this decl is an instance of, or else it is NULL indicating that this decl is not an instance of some other decl. For below example, in a nested declaration of the inline function f, this field points back to the definition (this code snippet can’t pass compilation as the nested f hasn’t been defined).

inline int f (void) { return 0; }

int main (void)

  int f();

  return f ();

2090 #define DECL_NAMESPACE_ALIAS(NODE) / in cp-tree.h

2091 DECL_ABSTRACT_ORIGIN (NAMESPACE_DECL_CHECK (NODE))

2092 #define ORIGINAL_NAMESPACE(NODE) /

2093 (DECL_NAMESPACE_ALIAS (NODE) ? DECL_NAMESPACE_ALIAS (NODE) : (NODE))

1407 #define DECL_ABSTRACT_ORIGIN(NODE) (DECL_CHECK (NODE)->decl.abstract_origin)

ORIGINAL_NAMESPACE relates to the feature of namespace-alias of C++. According to [3], namespace-alias has following rules:

1. A namespace-alias-definition declares an alternate name for a namespace according to the following grammar:

namespace-alias:

identifier

namespace-alias-definition:

namespace identifier = qualified-namespace-specifier ;

qualified-namespace-specifier:

::opt nested-name-specifieropt namespace-name

2. The identifier in a namespace-alias-definition is a synonym for the name of the namespace denoted by the qualified-namespace-specifier and becomes a namespace-alias. [Note: when looking up a namespace-name (Note: includes both original-namespace-name and namespace-alias) in a namespace-alias-definition, only namespace names are considered, see 3.4.6. ]

3. In a declarative region, a namespace-alias-definition can be used to redefine a namespace-alias declared in that declarative region to refer only to the namespace to which it already refers. [Example: the following declarations are well-formed:

namespace Company_with_very_long_name { /* ... */ }

namespace CWVLN = Company_with_very_long_name;

namespace CWVLN = Company_with_very_long_name; // OK: duplicate

namespace CWVLN = CWVLN;

4. A namespace-name or namespace-alias shall not be declared as the name of any other entity in the same declarative region. A namespace-name defined at global scope shall not be declared as the name of any other entity in any global scope of the program. No diagnostic is required for a violation of this rule by declarations in different translation units.

Above at line 2950, ORIGNINAL_NAMESPACE returns the namepsace (instead of namespace-alias), then NAMESPACE_LEVEL returns the corresponding cp_binding_level instance, that is the scope object of the namespace. In current implement, this function is used for searching within namespace scope.

1587 NAMESPACE_LEVEL #define NAMESPACE_LEVEL(NODE) / in cp-tree.h

1588 (DECL_LANG_SPECIFIC (NODE)->decl_flags.u.level)

1444 #define DECL_LANG_SPECIFIC(NODE) (DECL_CHECK (NODE)->decl.lang_specific)

Function cxx_scope_find_binding_for_name searches within the scope specified by scope for declaration of name, and returns the matching cxx_binding instance.

1877 static inline cxx_binding *

1878 cxx_scope_find_binding_for_name (cxx_scope *scope, tree name) in name-lookup.c

1879 {

1880 cxx_binding *b = IDENTIFIER_NAMESPACE_BINDINGS (name);

1881 if (b)

1882 {

1883 /* Fold-in case where NAME is used only once. */

1884 if (scope == b->scope && b->previous == NULL)

1885 return b;

1886 return find_binding (scope, b);

1887 }

1888 return NULL;

1889 }

IDENTIFIER_NAMESPACE_BINDINGS accesses field namespace_bindings of the identifier, which records all declarations of the name in namespaces (note, in C++, namespaces form the outmost scopes, it can’t be defined within class scope, nor within funciton scope). Identifier also has field bindings, which denotes from innermost scope and concatenated with namespace_bindings.

369 #define IDENTIFIER_NAMESPACE_BINDINGS(NODE) / in cp-tree.h

370 (LANG_IDENTIFIER_CAST (NODE)->namespace_bindings)

238 #define LANG_IDENTIFIER_CAST(NODE) /

339 ((struct lang_identifier*)IDENTIFIER_NODE_CHECK (NODE)) in cp-tree.h

We have known that in identifier, cxx_binding chains declarations of same name together, function find_bindings finds out the instance of cxx_binding of the declaration in the scope specified by parameter scope.

1863 static inline cxx_binding *

1864 find_binding (cxx_scope *scope, cxx_binding *binding) in name-lookup.c

1865 {

1866 timevar_push (TV_NAME_LOOKUP);

1867

1868 for (; binding != NULL; binding = binding->previous)

1869 if (binding->scope == scope)

1870 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);

1871

1872 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);

1873 }

Namespace alias can’t be used in defining namespace, for example:

namespace A { .. }

namespace aliasA = A;

namespace aliasA { ... } // error: namespace alias “aliasA” not allowed here, assuming “A”

will trigger error message at line 3097. At line 3099, the compiler corrects this error to be able to catch more errors.

And push_namespace continues below operation with the searching result.

push_namespace (continue)

3104 if (need_new)

3105 {

3106 /* Make a new namespace, binding the name to it. */

3107 d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);

3108 DECL_CONTEXT (d) = FROB_CONTEXT (current_namespace);

3109 d = pushdecl (d);

3110 if (anon)

3111 {

3112 /* Clear DECL_NAME for the benefit of debugging back ends. */

3113 SET_DECL_ASSEMBLER_NAME (d, name);

3114 DECL_NAME (d) = NULL_TREE;

3115 }

3116 begin_scope (sk_namespace, d);

3117 }

3118 else

3119 resume_scope (NAMESPACE_LEVEL (d));

3120

3121 if (implicit_use)

3122 do_using_directive (d);

3123 /* Enter the name space. */

3124 current_namespace = d;

3125

3126 timevar_pop (TV_NAME_LOOKUP);

3127 }

If the namespace has been in the current namespace (that is d at line 3091 is not NULL), then it only needs to set it as current scope (ie., line 1414).

1406 static void

1407 resume_scope (struct cp_binding_level* b) in name-lookup.c

1408 {

1409 /* Resuming binding levels is meant only for namespaces,

1410 and those cannot nest into classes. */

1411 my_friendly_assert(!class_binding_level, 386);

1412 /* Also, resuming a non-directly nested namespace is a no-no. */

1413 my_friendly_assert(b->level_chain == current_binding_level, 386);

1414 current_binding_level = b;

1415 if (ENABLE_SCOPE_CHECKING)

1416 {

1417 b->binding_depth = binding_depth;

1418 indent (binding_depth);

1419 cxx_scope_debug (b, input_location.line, "resume");

1420 is_class_level = 0;

1421 binding_depth++;

1422 }

1423 }

Otherwise invokes pushdecl to push the namespace into current scope.

566 tree

567 pushdecl (tree x) in name-lookup.c

568 {

569 tree t;

570 tree name;

571 int need_new_binding;

572

573 timevar_push (TV_NAME_LOOKUP);

574

575 need_new_binding = 1;

...

604 name = DECL_NAME (x);

605 if (name)

606 {

607 int different_binding_level = 0;

608

609 if (TREE_CODE (x) == FUNCTION_DECL || DECL_FUNCTION_TEMPLATE_P (x))

610 check_default_args (x);

611

612 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)

613 name = TREE_OPERAND (name, 0);

614

615 /* In case this decl was explicitly namespace-qualified, look it

616 up in its namespace context. */

617 if (DECL_NAMESPACE_SCOPE_P (x) && namespace_bindings_p ())

618 t = namespace_binding (name, DECL_CONTEXT (x));

619 else

620 t = lookup_name_current_level (name);

At line 617 namespace_bindings_p finds out if current scope is contained in a namespace. And DECL_NAMESPACE_SCOPE_P if nonzero, indicates the adding entity is a namespace declaration.

1482 bool

1483 namespace_bindings_p (void) in name-lookup.c

1484 {

1485 struct cp_binding_level *b = innermost_nonclass_level ();

1486

1487 return b->kind == sk_namespace;

1488 }

1427 static cxx_scope *

1428 innermost_nonclass_level (void) in name-lookup.c

1429 {

1430 cxx_scope *b;

1431

1432 b = current_binding_level;

1433 while (b->kind == sk_class)

1434 b = b->level_chain;

1435

1436 return b;

1437 }

DECL_CONTEXT (x) at line 168 points to the context containing x. If DECL_CONTEXT is NULL, indicates the context is global namespace. As namespace_binding will return t with NULL, then following code snippet will be executed.

pushdecl (continue)

828 /* This name is new in its binding level.

829 Install the new declaration and return it. */

830 if (namespace_bindings_p ())

831 {

832 /* Install a global value. */

833

834 /* If the first global decl has external linkage,

835 warn if we later see static one. */

836 if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))

837 TREE_PUBLIC (name) = 1;

838

839 /* Bind the name for the entity. */

840 if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)

841 && t != NULL_TREE)

842 && (TREE_CODE (x) == TYPE_DECL

843 || TREE_CODE (x) == VAR_DECL

844 || TREE_CODE (x) == ALIAS_DECL

845 || TREE_CODE (x) == NAMESPACE_DECL

846 || TREE_CODE (x) == CONST_DECL

847 || TREE_CODE (x) == TEMPLATE_DECL))

848 SET_IDENTIFIER_NAMESPACE_VALUE (name, x);

...

872 }

873 else

874 {

...

1003 }

1004

1005 if (TREE_CODE (x) == VAR_DECL)

1006 maybe_register_incomplete_var (x);

1007 }

1008

1009 if (need_new_binding)

1010 add_decl_to_level (x,

1011 DECL_NAMESPACE_SCOPE_P (x)

1012 ? NAMESPACE_LEVEL (CP_DECL_CONTEXT (x))

1013 : current_binding_level);

1014

1015 POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

1016 }

Above IDENTIFIER_GLOBAL_VALUE, and SET_IDENTIFIER_NAMESPACE_VALUE has following definitions. And in an IDENTIFIER_NODE (corresponds to name, while x corresponds to declaration), TREE_PUBLIC if nonzero means an external declaration accessible from outside this module was previously seen for this name in an inner scope.

264 #define IDENTIFIER_GLOBAL_VALUE(NODE) / in cp-tree.h

265 namespace_binding ((NODE), global_namespace)

266 #define SET_IDENTIFIER_NAMESPACE_VALUE(NODE, VAL) / in cp-tree.h

267 set_namespace_binding ((NODE), current_namespace, (VAL))

Function set_namespace_binding may create node of cxx_binding, then bind declaration with scope together. In it, parameter val is the declaration, name is the identifier, and scope is the binding scope.

2958 void

2959 set_namespace_binding (tree name, tree scope, tree val) in name-lookup.c

2960 {

2961 cxx_binding *b;

2962

2963 timevar_push (TV_NAME_LOOKUP);

2964 if (scope == NULL_TREE)

2965 scope = global_namespace;

2966 b = binding_for_name (NAMESPACE_LEVEL (scope), name);

2967 if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)

2968 b->value = val;

2969 else

2970 supplement_binding (b, val);

2971 timevar_pop (TV_NAME_LOOKUP);

2972 }

Function binding_for_name is also just used for binding declaration within namespace. In below, if it’s a new declaration, its cxx_binding will be inserted at the head of namespace_bindings of the matching identifier.

1894 static cxx_binding *

1895 binding_for_name (cxx_scope *scope, tree name) in name-lookup.c

1896 {

1897 cxx_binding *result;

1898

1899 result = cxx_scope_find_binding_for_name (scope, name);

1900 if (result)

1901 return result;

1902 /* Not found, make a new one. */

1903 result = cxx_binding_make (NULL, NULL);

1904 result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);

1905 result->scope = scope;

1906 result->is_local = false;

1907 result->value_is_inherited = false;

1908 IDENTIFIER_NAMESPACE_BINDINGS (name) = result;

1909 return result;

1910 }

Field value of the cxx_binding returned by binding_for_name is null, as in cxx_binding_make below, notice that parameter value and type are both null. After returning set_namespace_binding, field value is set as the declaration node.

326 static cxx_binding *

327 cxx_binding_make (tree value, tree type) in name-lookup.c

328 {

329 cxx_binding *binding;

330 if (free_bindings)

331 {

332 binding = free_bindings;

333 free_bindings = binding->previous;

334 }

335 else

336 binding = ggc_alloc (sizeof (cxx_binding));

337

338 binding->value = value;

339 binding->type = type;

340 binding->previous = NULL;

341

342 return binding;

343 }

Generally, more than one declarations of same name declared within the same scope means grammar error. But [2] gives an exception:

A class name (9.1) or enumeration name (7.2) can be hidden by the name of an object, function, or enumerator declared in the same scope. If a class or enumeration name and an object, function, or enumerator are declared in the same scope (in any order) with the same name, the class or enumeration name is hidden wherever the object, function, or enumerator name is visible.

Function supplement_binding is defined for the exception, we come it later.

At line 1009 in pushdecl, need_new_binding is set as 1. In add_decl_to_level, node of namespace declaration is linked into namespaces field of corresponding cxx_scope node, and line 532 handles case of vtable, and line 537 processes the other non-namespace declarations.

523 static void

524 add_decl_to_level (tree decl, cxx_scope *b) in name-lookup.c

525 {

526 if (TREE_CODE (decl) == NAMESPACE_DECL

527 && !DECL_NAMESPACE_ALIAS (decl))

528 {

529 TREE_CHAIN (decl) = b->namespaces;

530 b->namespaces = decl;

531 }

532 else if (TREE_CODE (decl) == VAR_DECL && DECL_VIRTUAL_P (decl))

533 {

534 TREE_CHAIN (decl) = b->vtables;

535 b->vtables = decl;

536 }

537 else

538 {

539 /* We build up the list in reverse order, and reverse it later if

540 necessary. */

541 TREE_CHAIN (decl) = b->names;

542 b->names = decl;

543 b->names_size++;

544

545 /* If appropriate, add decl to separate list of statics. We

546 include extern variables because they might turn out to be

547 static later. It's OK for this list to contain a few false

548 positives. */

549 if (b->kind == sk_namespace)

550 if ((TREE_CODE (decl) == VAR_DECL

551 && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))

552 || (TREE_CODE (decl) == FUNCTION_DECL

553 && (!TREE_PUBLIC (decl) || DECL_DECLARED_INLINE_P (decl))))

554 VARRAY_PUSH_TREE (b->static_decls, decl);

555 }

556 }

Figure 34: namespace std and global namespace

Arriving here, we can see part of relation between namespace std and global in above figure.

4.3.1.7.4.1. Exit the namespace scope

As soon as the NAMESPACE_DECL of std_identifier and the associated binding context created, std_node is assignment with this NAMESPACE_DECL, from the figure above, departing from this node, it can easily move to contained and containing scope. After that, it needs to restore back to global namespace by pop_namespace.

3131 void

3132 pop_namespace (void) in name-lookup.c

3133 {

3134 my_friendly_assert (current_namespace != global_namespace, 20010801);

3135 current_namespace = CP_DECL_CONTEXT (current_namespace);

3136 /* The binding level is not popped, as it might be re-opened later. */

3137 leave_scope ();

3138 }

leave_scope returns back upper scope and sets it as current scope. At line 1356, class_binding_level points to the innermost class scope in effective. If condition at line 1356 is satisfied, means we are exitting the definition of the namespace, and at the same time we are within a class definition, which almost indicates error (as class_binding_level if not null, will set is_class_level, and gives out error message at line 1370). Under such situation, the compiler tries to fix current_binding_level, but at line 1376 below, current_binding_level will be revised again and makes the change at line 1357 meaningless.

1351 cxx_scope *

1352 leave_scope (void) in name-lookup.c

1353 {

1354 cxx_scope *scope = current_binding_level;

1355

1356 if (scope->kind == sk_namespace && class_binding_level)

1357 current_binding_level = class_binding_level;

1358

1359 /* We cannot leave a scope, if there are none left. */

1360 if (NAMESPACE_LEVEL (global_namespace))

1361 my_friendly_assert (!global_scope_p (scope), 20030527);

1362

1363 if (ENABLE_SCOPE_CHECKING)

1364 {

1365 indent (--binding_depth);

1366 cxx_scope_debug (scope, input_location.line, "leave");

1367 if (is_class_level != (scope == class_binding_level))

1368 {

1369 indent (binding_depth);

1370 verbatim ("XXX is_class_level != (current_scope == class_scope)/n");

1371 }

1372 is_class_level = 0;

1373 }

1374

1375 /* Move one nesting level up. */

1376 current_binding_level = scope->level_chain;

1377

1378 /* Namespace-scopes are left most probably temporarily, not completely;

1379 they can be reopen later, e.g. in namespace-extension or any name

1380 binding activity that requires us to resume a namespace. For other

1381 scopes, we just make the structure available for reuse. */

1382 if (scope->kind != sk_namespace)

1383 {

1384 scope->level_chain = free_binding_level;

1385 if (scope->kind == sk_class)

1386 scope->type_decls = NULL;

1387 else

1388 binding_table_free (scope->type_decls);

1389 my_friendly_assert (!ENABLE_SCOPE_CHECKING

1390 || scope->binding_depth == binding_depth,

1391 20030529);

1392 free_binding_level = scope;

1393 }

1394

1395 /* Find the innermost enclosing class scope, and reset

1396 CLASS_BINDING_LEVEL appropriately. */

1397 for (scope = current_binding_level;

1398 scope && scope->kind != sk_class;

1399 scope = scope->level_chain)

1400 ;

1401 class_binding_level = scope && scope->kind == sk_class ? scope : NULL;

1402

1403 return current_binding_level;

1404 }

Note line 1382, if the scope isn’t namespace, the object would be freed to free_binding_level. But not is namespace. It because namespaces forms the outtestmost scopes, it almost can ensure they would be entered again later; and all namespaces’ scope are reserved, so are relations among them, which speeds up the searching these objects hereafter. It is why in IDENTIFIER_NODE, there is pointer namespace_bindings. The reason not reserving non-namespace scope object may be: 1) Such objects are in great number, especially when we designe lots of classes, functions and {} blocks; 2) Most of which would be only visited once – it is true for functions and {} blocks. In this way, it keeps the tree of scopes as neat as possible, so as to reduce the possibility of introducing bug, and lowers the memory consumption. And at the same time, it makes reentering these non-namepsace scopes simply – just adding these object into scope tree again.