Studying note of GCC-3.4.6 source (67)

4.3.1.7.8.3.      Exception handler

Next, if we don’t prohibit exception via switch -fno-exception, C++ runtime will setup the functions’ declaration excepted by exception handling. In C++, if throw an exception but not catch it, then in global namespace, the runtime would catch it and call std::terminate() to terminate the program. This funcationality is provided by the runtime function__cxa_call_unexpected defined in “gcc-3.4.6/libstdc++-v3/libstdsupc++/eh_personality.cc”.

In parsing throw and catch statement, the compiler would setup the context carried by the exception object, and invokes exception handling logic with the context, __cxa_call_unexpected, __gxx_personality_v0 or __gxx_personality_sj0 are all handlers refered by the context. The exception handling logic and the setup of the context is very complex, we don’t plan to go deep into it. After finishing the follow-up sections about parsing and hanlding complex types, code of this part isn’t very hard for understanding.

 

60      void

61      init_exception_processing (void)                                                                      in expt.c

62      {

63        tree tmp;

64     

65        /* void std::terminate (); */

66        push_namespace (std_identifier);

67        tmp = build_function_type (void_type_node, void_list_node);

68        terminate_node = build_cp_library_fn_ptr ("terminate", tmp);

69        TREE_THIS_VOLATILE (terminate_node) = 1;

70        TREE_NOTHROW (terminate_node) = 1;

71        pop_namespace ();

72     

73        /* void __cxa_call_unexpected(void *); */

74        tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);

75        tmp = build_function_type (void_type_node, tmp);

76        call_unexpected_node

77          = push_throw_library_fn (get_identifier ("__cxa_call_unexpected"), tmp);

78     

79        eh_personality_libfunc = init_one_libfunc (USING_SJLJ_EXCEPTIONS

80                                            ? "__gxx_personality_sj0"

81                                            : "__gxx_personality_v0");

82     

83        lang_eh_runtime_type = build_eh_type_type;

84        lang_protect_cleanup_actions = &cp_protect_cleanup_actions;

85      }

 

As std::terminate is a library routine, its declaration is built by build_cp_library_fn_ptr. Remember that build_cp_library_fn will find out (create if not find) the identifer node for mangled version for the declaration and set it as the assemble name for the declaration node. Then at linking stage, linker will find the function by this assemble name in the space of library.

 

3350   tree

3351   build_cp_library_fn_ptr (const char* name, tree type)                                        in decl.c

3352   {

3353     return build_cp_library_fn (get_identifier (name), ERROR_MARK, type);

3354   }

 

Routine __cxa_call_unexpected is declared as extern “C”, which means a C version function declaration. Its name will not undergo mangling.

 

3393   tree

3394   push_throw_library_fn (tree name, tree type)                                                    in decl.c

3395   {

3396     tree fn = push_library_fn (name, type);

3397     TREE_THIS_VOLATILE (fn) = 1;

3398     TREE_NOTHROW (fn) = 0;

3399     return fn;

3400   }

 

Notice that in build_library_fn, the language for the declaration is set as C, and no assemble name is set as its name can’t be mangled under C.

 

3359   tree

3360   push_library_fn (tree name, tree type)                                                              in decl.c

3361   {

3362     tree fn = build_library_fn (name, type);

3363     pushdecl_top_level (fn);

3364     return fn;

3365   }

 

Now pushdecl_top_level will push this declaration into namespace of global.

 

3414   tree

3415   pushdecl_top_level (tree x)                                                               in name-lookup.c

3416   {

3417     return pushdecl_top_level_1 (x, NULL);

3418   }

 

Below push_to_top_level caches identifiers from current bindng scope to global namespace and it will leave us at global namespace. And pop_from_top_level would restore current scope.

 

3400   static tree

3401   pushdecl_top_level_1 (tree x, tree *init)                                             in name-lookup.c

3402   {

3403     timevar_push (TV_NAME_LOOKUP);

3404     push_to_top_level ();

3405     x = pushdecl_namespace_level (x);

3406     if (init)

3407       cp_finish_decl (x, *init, NULL_TREE, 0);

3408     pop_from_top_level ();

3409     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

3410   }

 

Though it tries to push the entity into current namespace, it is possible that we are also within a binding scope within current namespace (of course, for our case here we just in global namespace, but from view of pushdecl_namespace_level, it is possible). Below at line 3232 current binding scope (current namespace or may not) is fetched.

 

3229   tree

3230   pushdecl_namespace_level (tree x)                                                     in name-lookup.c

3231   {

3232     struct cp_binding_level *b = current_binding_level;

3233     tree t;

3234  

3235     timevar_push (TV_NAME_LOOKUP);

3236     t = pushdecl_with_scope (x, NAMESPACE_LEVEL (current_namespace));

 

For push entity within namespace, pushdecl_with_scope acts like pushdecl except it works for specified namespace instead of current ones, so caching current binding scope and restoring after that is required.

 

1941   tree

1942   pushdecl_with_scope (tree x, cxx_scope *level)                                   in name-lookup.c

1943   {

1944     struct cp_binding_level *b;

1945     tree function_decl = current_function_decl;

1946  

1947     timevar_push (TV_NAME_LOOKUP);

1948     current_function_decl = NULL_TREE;

1949     if (level->kind == sk_class)

1950     {

1951       b = class_binding_level;

1952       class_binding_level = level;

1953       pushdecl_class_level (x);

1954       class_binding_level = b;

1955     }

1956     else

1957     {

1958       b = current_binding_level;

1959       current_binding_level = level;

1960       x = pushdecl (x);

1961       current_binding_level = b;

1962     }

1963     current_function_decl = function_decl;

1964     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);

1965   }

 

For each binding scope, if it is a class scope, field class_shadowed records types bound in. While field type_shadowed is not confined to class scope, but in all non-namespace scopes to record types being shadowed (if no shadowed type, it is itself). Why is non-namespace scope? Because via field level_chain, it is easily to determine whether specified identifier is visible at specified namespace due to they are always the outer-most scopes and effective.

 

pushdecl_namespace_level (continue)

 

3238     /* Now, the type_shadowed stack may screw us. Munge it so it does

3239       what we want.  */

3240     if (TREE_CODE (x) == TYPE_DECL)

3241     {

3242       tree name = DECL_NAME (x);

3243       tree newval;

3244       tree *ptr = (tree *)0;

3245       for (; !global_scope_p (b); b = b->level_chain)

3246       {

3247         tree shadowed = b->type_shadowed;

3248         for (; shadowed; shadowed = TREE_CHAIN (shadowed))

3249           if (TREE_PURPOSE (shadowed) == name)

3250           {

3251             ptr = &TREE_VALUE (shadowed);

3252             /* Can't break out of the loop here because sometimes

3253               a binding level will have duplicate bindings for

3254               PT names. It's gross, but I haven't time to fix it.  */

3255           }

3256       }

3257       newval = TREE_TYPE (x);

3258       if (ptr == (tree *)0)

3259       {

3260         /* @@ This shouldn't be needed. My test case "zstring.cc" trips

3261           up here if this is changed to an assertion.  --KR  */

3262         SET_IDENTIFIER_TYPE_VALUE (name, x);

3263       }

3264       else

3265       {

3266         *ptr = newval;

3267       }

3268     }

3269     POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, t);

3270   }

 

As we have mentioned above, current binding scope may be in current namespace. Now we have added new type into current namespace, then it needs to check if between current scope and current namespace, this type would be shadowed. At line 3245, b is the current scope, via level_chain, it can climb up to global namespace, but because type_shadowed is not used by namespace, so the entity found by FOR loop at line 3245, is the type shadowed by inner scope closest to current namespace, which is declared in outside namespace (the usage of the function promises this). No doubt, the type shadowed should be updated as currently adding type (line 3262). If these inner scopes haven’t type declaration of the name, ptr would be 0 (line 3258).

Both __gxx_personality_sj0 and __gxx_personality_v0 are declared with C signature (extern “C”). Their declaration is generated by init_one_libfunc, which likes: int __gxx_personality_sj0().

 

5126   rtx

5127   init_one_libfunc (const char *name)                                                          in optabs.c

5128   {

5129     rtx symbol;

5130  

5131     /* Create a FUNCTION_DECL that can be passed to

5132       targetm.encode_section_info.  */

5133     /* ??? We don't have any type information except for this is

5134       a function. Pretend this is "int foo()".  */

5135     tree decl = build_decl (FUNCTION_DECL, get_identifier (name),

5136                        build_function_type (integer_type_node, NULL_TREE));

5137     DECL_ARTIFICIAL (decl) = 1;

5138     DECL_EXTERNAL (decl) = 1;

5139     TREE_PUBLIC (decl) = 1;

5140  

5141     symbol = XEXP (DECL_RTL (decl), 0);

5142  

5143     /* Zap the nonsensical SYMBOL_REF_DECL for this. What we're left with

5144       are the flags assigned by targetm.encode_section_info.  */

5145     SYMBOL_REF_DECL (symbol) = 0;

5146  

5147     return symbol;

5148   }

 

At line 5141, DECL_RTL will invoke make_decl_rtl (to get detail, refer to Create RTX object for builtin). Notice that in that function at line 790, it will fetch the mangled name of the declaration, but we haven’t the correct function signature in hand now (compared with that in unwind-cxx.h)!

Fortunately, here we don’t need fully correct signature of the function to get the entry name in the library. Routines like __gxx_personality_v0 here generated by language-independent part has C linkage. That is the mangled names are the same of their declared name. As long as we provide correct arguments at run-time, everything is OK.

4.3.1.7.8.4.      Detect behavor of linker and other

GCC supports concept of weak symbol.

Having two or more global symbols of the same name will not cause a conflict as long as all but one of them are declared as being weak symbols. The linker ignores the definitions of the weak symbols and uses the normal global symbol definition to resolve all references, but the weak symbols will be used if the normal global symbol is not available. A weak symbol can be used to name functions and data that can be overridden by user code. A weak symbol is also referred to as a weak alias, or simply weak.

Besides, GCC can also output following assembler directive.

linkonce[type]: Marks the current section so it is included by the linker only once, even if the same section appears in multiple modules. The directive must appear once in each instance of the section. The section is selected only by name, so the name must be unique.

The optional type argument can be discard to have duplicates silently discarded (the default). A type of one_only will issue a warning for each duplicate found. A type of same_size will issue a warning if any of the duplicates are not the same size. A type of same_contents will issue a warning if any of the duplicates do not contain exactly the same data.

These are all target dependent. For x86, elf format output, support_one_only returns 0 and sets flag_weak as 0.

 

4549   int

4550   supports_one_only (void)                                                                         in varasm.c

4551   {

4552     if (SUPPORTS_ONE_ONLY)

4553       return 1;

4554     return SUPPORTS_WEAK;

4555   }

 

In coding, we can use __func__, __FUNCTION__, __PRETTY__FUNCTION__ to fetch current function name. Function pointer make_fname_decl saves the processing function, which at line 3129, is set by cp_make_fname_decl. Function start_fname_decls then prepares the stack for saving these functions’ name. Later we will see this funciton again.

4.3.1.8.    Setup preprocessor

Returns from cxx_init_decl_processing, the front-end has C++ runtime setup, it comes to setup preprocessor. First it creates the familiar “null” object, which as we have seen in our program, in fact is an integer of 0. However, note that it has size of a pointer.

 

cxx_init (continue)

 

412   /* Create the built-in __null node.  */

413    null_node = build_int_2 (0, 0);

414    TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);

415    ridpointers[RID_NULL] = null_node;

416 

417    interface_unknown = 1;

418 

419    if (c_common_init () == false)

420    {

421      pop_srcloc();

422      return false;

423    }

 

Below cpp_init_iconv initializes iconv descriptors for conversion from the source character set to the execution character sets. We ignore this part. And flag_preprocess_only if nonzero, means only to do preprocessing, which is ready here, and invokes preprocess_file at line 1207. And we will return here to finish the file’s compilation.

 

1186   bool

1187   c_common_init (void)                                                                              in c-opts.c

1188   {

1189     input_line = saved_lineno;

1190  

1191     /* Set up preprocessor arithmetic. Must be done after call to

1192       c_common_nodes_and_builtins for type nodes to be good.  */

1193     cpp_opts->precision = TYPE_PRECISION (intmax_type_node);

1194     cpp_opts->char_precision = TYPE_PRECISION (char_type_node);

1195     cpp_opts->int_precision = TYPE_PRECISION (integer_type_node);

1196     cpp_opts->wchar_precision = TYPE_PRECISION (wchar_type_node);

1197     cpp_opts->unsigned_wchar = TREE_UNSIGNED (wchar_type_node);

1198     cpp_opts->bytes_big_endian = BYTES_BIG_ENDIAN;

1199  

1200     /* This can't happen until after wchar_precision and bytes_big_endian

1201       are known.  */

1202     cpp_init_iconv (parse_in);

1203  

1204     if (flag_preprocess_only)

1205     {

1206       finish_options ();

1207       preprocess_file (parse_in);

1208       return false;

1209     }

1210  

1211    /* Has to wait until now so that cpplib has its hash table.  */

1212     init_pragma ();

1213  

1214     return true;

1215   }

 

And if full compilation is expected, then for x86 linux, here only two directives “pack”, and “weak” are available for C (they will appear in __attribute__() block), as #pragma directive is architecture dependent.

 

494    void

495    init_pragma (void)                                                                           in c-pragma.c

496    {

497    #ifdef HANDLE_PRAGMA_PACK

498      c_register_pragma (0, "pack", handle_pragma_pack);

499    #endif

500    #ifdef HANDLE_PRAGMA_WEAK

501      c_register_pragma (0, "weak", handle_pragma_weak);

502    #endif

503    #ifdef HANDLE_PRAGMA_REDEFINE_EXTNAME

504      c_register_pragma (0, "redefine_extname", handle_pragma_redefine_extname);

505    #endif

506    #ifdef HANDLE_PRAGMA_EXTERN_PREFIX

507      c_register_pragma (0, "extern_prefix", handle_pragma_extern_prefix);

508    #endif

509   

510    #ifdef REGISTER_TARGET_PRAGMAS

511       REGISTER_TARGET_PRAGMAS ();

512    #endif

513    }

 

c_register_pragma inserts identifier of directives into hashtable of ident_hash and binds them with their handler.

 

486    void

487    c_register_pragma (const char *space, const char *name,                      in c-pragma.c

488                   void (*handler) (struct cpp_reader *))

489    {

490      cpp_register_pragma (parse_in, space, name, handler);

491    }

4.3.1.9.    Finish front-end initialization

C++ supports more #pragma directives, so initializes them in below.

 

cxx_init (continue)

 

425    init_cp_pragma ();

426 

427    init_repo (main_input_filename);

428 

429    pop_srcloc();

430    return true;

431  }

 

Below #pragma vtable is no longer supported, and #pragma unit, gcc doesn’t implement it yet.

 

368    static void

369    init_cp_pragma (void)                                                                                    in lex.c

370    {

371      c_register_pragma (0, "vtable", handle_pragma_vtable);

372      c_register_pragma (0, "unit", handle_pragma_unit);

373      c_register_pragma (0, "interface", handle_pragma_interface);

374      c_register_pragma (0, "implementation", handle_pragma_implementation);

375      c_register_pragma ("GCC", "interface", handle_pragma_interface);

376      c_register_pragma ("GCC", "implementation", handle_pragma_implementation);

377      c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);

378    }

 

When compiles the code using the -frepo option, it causes the creation of files with the suffix .rpo, each listing the template instantiations to be found in its corresponding object file. The link wrapper utility, named collect2, will then be invoked to update the .rpo files with instructions to the linker as to the placement of the template instances in the final program. The only difficulty with this approach has to do with libraries—unless the associated .rpo files are also present, linking template instantiations stored in a library will fail.

At line 427, init_repo creates .rpo version file for main input file.