| /* RunTime Type Identification |
| Copyright (C) 1995, 1996 Free Software Foundation, Inc. |
| Mostly written by Jason Merrill (jason@cygnus.com). |
| |
| This file is part of GNU CC. |
| |
| GNU CC is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU CC is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU CC; see the file COPYING. If not, write to |
| the Free Software Foundation, 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. */ |
| |
| |
| #include "config.h" |
| #include "tree.h" |
| #include "cp-tree.h" |
| #include "flags.h" |
| #include "output.h" |
| #include "assert.h" |
| |
| #ifndef INT_TYPE_SIZE |
| #define INT_TYPE_SIZE BITS_PER_WORD |
| #endif |
| |
| extern tree define_function (); |
| extern tree build_t_desc_overload (); |
| extern struct obstack *permanent_obstack; |
| |
| tree type_info_type_node; |
| tree tinfo_fn_id; |
| tree tinfo_fn_type; |
| |
| void |
| init_rtti_processing () |
| { |
| type_info_type_node = xref_tag |
| (class_type_node, get_identifier ("type_info"), NULL_TREE, 1); |
| tinfo_fn_id = get_identifier ("__tf"); |
| tinfo_fn_type = build_function_type |
| (build_reference_type (build_type_variant (type_info_type_node, 1, 0)), |
| void_list_node); |
| } |
| |
| /* Given a pointer to an object with at least one virtual table |
| pointer somewhere, return a pointer to a possible sub-object that |
| has a virtual table pointer in it that is the vtable parent for |
| that sub-object. */ |
| |
| static tree |
| build_headof_sub (exp) |
| tree exp; |
| { |
| tree type = TREE_TYPE (TREE_TYPE (exp)); |
| tree basetype = CLASSTYPE_RTTI (type); |
| tree binfo = get_binfo (basetype, type, 0); |
| |
| exp = convert_pointer_to_real (binfo, exp); |
| return exp; |
| } |
| |
| /* Given the expression EXP of type `class *', return the head of the |
| object pointed to by EXP with type cv void*, if the class has any |
| virtual functions (TYPE_VIRTUAL_P), else just return the |
| expression. */ |
| |
| static tree |
| build_headof (exp) |
| tree exp; |
| { |
| tree type = TREE_TYPE (exp); |
| tree aref; |
| tree offset; |
| |
| if (TREE_CODE (type) != POINTER_TYPE) |
| { |
| error ("`headof' applied to non-pointer type"); |
| return error_mark_node; |
| } |
| type = TREE_TYPE (type); |
| |
| if (!TYPE_VIRTUAL_P (type)) |
| return exp; |
| |
| /* If we don't have rtti stuff, get to a sub-object that does. */ |
| if (!CLASSTYPE_VFIELDS (TREE_TYPE (TREE_TYPE (exp)))) |
| exp = build_headof_sub (exp); |
| |
| /* We use this a couple of times below, protect it. */ |
| exp = save_expr (exp); |
| |
| aref = build_vtbl_ref (build_indirect_ref (exp, NULL_PTR), integer_zero_node); |
| |
| if (flag_vtable_thunks) |
| offset = aref; |
| else |
| offset = build_component_ref (aref, delta_identifier, NULL_TREE, 0); |
| |
| type = build_type_variant (ptr_type_node, TREE_READONLY (exp), |
| TREE_THIS_VOLATILE (exp)); |
| return build (PLUS_EXPR, type, exp, |
| cp_convert (ptrdiff_type_node, offset)); |
| } |
| |
| /* Build a call to a generic entry point taking and returning void. */ |
| |
| static tree |
| call_void_fn (name) |
| char *name; |
| { |
| tree d = get_identifier (name); |
| tree type; |
| |
| if (IDENTIFIER_GLOBAL_VALUE (d)) |
| d = IDENTIFIER_GLOBAL_VALUE (d); |
| else |
| { |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| |
| type = build_function_type (void_type_node, void_list_node); |
| d = build_lang_decl (FUNCTION_DECL, d, type); |
| DECL_EXTERNAL (d) = 1; |
| TREE_PUBLIC (d) = 1; |
| DECL_ARTIFICIAL (d) = 1; |
| pushdecl_top_level (d); |
| make_function_rtl (d); |
| assemble_external (d); |
| |
| pop_obstacks (); |
| } |
| |
| return build_call (d, void_type_node, NULL_TREE); |
| } |
| |
| /* Get a bad_cast node for the program to throw... |
| |
| See libstdc++/exception.cc for __throw_bad_cast */ |
| |
| static tree |
| throw_bad_cast () |
| { |
| return call_void_fn ("__throw_bad_cast"); |
| } |
| |
| static tree |
| throw_bad_typeid () |
| { |
| return call_void_fn ("__throw_bad_typeid"); |
| } |
| |
| /* Return the type_info function associated with the expression EXP. If |
| EXP is a reference to a polymorphic class, return the dynamic type; |
| otherwise return the static type of the expression. */ |
| |
| tree |
| get_tinfo_fn_dynamic (exp) |
| tree exp; |
| { |
| tree type; |
| |
| if (exp == error_mark_node) |
| return error_mark_node; |
| |
| if (type_unknown_p (exp)) |
| { |
| error ("typeid of overloaded function"); |
| return error_mark_node; |
| } |
| |
| type = TREE_TYPE (exp); |
| |
| /* peel back references, so they match. */ |
| if (TREE_CODE (type) == REFERENCE_TYPE) |
| type = TREE_TYPE (type); |
| |
| /* Peel off cv qualifiers. */ |
| type = TYPE_MAIN_VARIANT (type); |
| |
| /* If exp is a reference to polymorphic type, get the real type_info. */ |
| if (TYPE_VIRTUAL_P (type) && ! resolves_to_fixed_type_p (exp, 0)) |
| { |
| /* build reference to type_info from vtable. */ |
| tree t; |
| |
| if (! flag_rtti) |
| warning ("taking dynamic typeid of object without -frtti"); |
| |
| /* If we don't have rtti stuff, get to a sub-object that does. */ |
| if (! CLASSTYPE_VFIELDS (type)) |
| { |
| exp = build_unary_op (ADDR_EXPR, exp, 0); |
| exp = build_headof_sub (exp); |
| exp = build_indirect_ref (exp, NULL_PTR); |
| } |
| |
| if (flag_vtable_thunks) |
| t = build_vfn_ref ((tree *) 0, exp, integer_one_node); |
| else |
| t = build_vfn_ref ((tree *) 0, exp, integer_zero_node); |
| TREE_TYPE (t) = build_pointer_type (tinfo_fn_type); |
| return t; |
| } |
| |
| /* otherwise return the type_info for the static type of the expr. */ |
| return get_tinfo_fn (TYPE_MAIN_VARIANT (type)); |
| } |
| |
| tree |
| build_typeid (exp) |
| tree exp; |
| { |
| exp = get_tinfo_fn_dynamic (exp); |
| exp = build_call (exp, TREE_TYPE (tinfo_fn_type), NULL_TREE); |
| return convert_from_reference (exp); |
| } |
| |
| tree |
| build_x_typeid (exp) |
| tree exp; |
| { |
| tree cond = NULL_TREE; |
| tree type = TREE_TYPE (tinfo_fn_type); |
| int nonnull; |
| |
| if (processing_template_decl) |
| return build_min_nt (TYPEID_EXPR, exp); |
| |
| if (TREE_CODE (exp) == INDIRECT_REF |
| && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE |
| && TYPE_VIRTUAL_P (TREE_TYPE (exp)) |
| && ! resolves_to_fixed_type_p (exp, &nonnull) |
| && ! nonnull) |
| { |
| exp = stabilize_reference (exp); |
| cond = cp_convert (boolean_type_node, TREE_OPERAND (exp, 0)); |
| } |
| |
| exp = get_tinfo_fn_dynamic (exp); |
| |
| if (exp == error_mark_node) |
| return error_mark_node; |
| |
| exp = build_call (exp, type, NULL_TREE); |
| |
| if (cond) |
| { |
| tree bad = throw_bad_typeid (); |
| |
| bad = build_compound_expr |
| (tree_cons (NULL_TREE, bad, build_tree_list |
| (NULL_TREE, cp_convert (type, integer_zero_node)))); |
| exp = build (COND_EXPR, type, cond, exp, bad); |
| } |
| |
| return convert_from_reference (exp); |
| } |
| |
| static tree |
| get_tinfo_var (type) |
| tree type; |
| { |
| tree tname = build_overload_with_type (get_identifier ("__ti"), type); |
| tree tdecl, arrtype; |
| int size; |
| |
| if (IDENTIFIER_GLOBAL_VALUE (tname)) |
| return IDENTIFIER_GLOBAL_VALUE (tname); |
| |
| /* Figure out how much space we need to allocate for the type_info object. |
| If our struct layout or the type_info classes are changed, this will |
| need to be modified. */ |
| if (TYPE_VOLATILE (type) || TYPE_READONLY (type)) |
| size = 3 * POINTER_SIZE + INT_TYPE_SIZE; |
| else if (TREE_CODE (type) == POINTER_TYPE |
| && ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE |
| || TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)) |
| size = 3 * POINTER_SIZE; |
| else if (IS_AGGR_TYPE (type)) |
| { |
| if (CLASSTYPE_N_BASECLASSES (type) == 0) |
| size = 2 * POINTER_SIZE; |
| else if (! TYPE_USES_COMPLEX_INHERITANCE (type) |
| && (TREE_VIA_PUBLIC |
| (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)))) |
| size = 3 * POINTER_SIZE; |
| else |
| size = 3 * POINTER_SIZE + TYPE_PRECISION (sizetype); |
| } |
| else |
| size = 2 * POINTER_SIZE; |
| |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| |
| /* The type for a character array of the appropriate size. */ |
| arrtype = build_cplus_array_type |
| (unsigned_char_type_node, |
| build_index_type (size_int (size / BITS_PER_UNIT - 1))); |
| |
| tdecl = build_decl (VAR_DECL, tname, arrtype); |
| TREE_PUBLIC (tdecl) = 1; |
| DECL_EXTERNAL (tdecl) = 1; |
| DECL_ARTIFICIAL (tdecl) = 1; |
| pushdecl_top_level (tdecl); |
| cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0); |
| |
| pop_obstacks (); |
| |
| return tdecl; |
| } |
| |
| tree |
| get_tinfo_fn (type) |
| tree type; |
| { |
| tree name; |
| tree d; |
| |
| if (TREE_CODE (type) == OFFSET_TYPE) |
| type = TREE_TYPE (type); |
| if (TREE_CODE (type) == METHOD_TYPE) |
| type = build_function_type (TREE_TYPE (type), |
| TREE_CHAIN (TYPE_ARG_TYPES (type))); |
| |
| name = build_overload_with_type (tinfo_fn_id, type); |
| |
| if (IDENTIFIER_GLOBAL_VALUE (name)) |
| return IDENTIFIER_GLOBAL_VALUE (name); |
| |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| |
| d = build_lang_decl (FUNCTION_DECL, name, tinfo_fn_type); |
| DECL_EXTERNAL (d) = 1; |
| TREE_PUBLIC (d) = 1; |
| DECL_ARTIFICIAL (d) = 1; |
| DECL_NOT_REALLY_EXTERN (d) = 1; |
| DECL_MUTABLE_P (d) = 1; |
| TREE_TYPE (name) = copy_to_permanent (type); |
| pushdecl_top_level (d); |
| make_function_rtl (d); |
| assemble_external (d); |
| mark_inline_for_output (d); |
| if (at_eof) |
| import_export_decl (d); |
| |
| pop_obstacks (); |
| |
| return d; |
| } |
| |
| static tree |
| get_typeid_1 (type) |
| tree type; |
| { |
| tree t = build_call |
| (get_tinfo_fn (type), TREE_TYPE (tinfo_fn_type), NULL_TREE); |
| return convert_from_reference (t); |
| } |
| |
| /* Return the type_info object for TYPE, creating it if necessary. */ |
| |
| tree |
| get_typeid (type) |
| tree type; |
| { |
| if (type == error_mark_node) |
| return error_mark_node; |
| |
| if (processing_template_decl) |
| return build_min_nt (TYPEID_EXPR, type); |
| |
| /* If the type of the type-id is a reference type, the result of the |
| typeid expression refers to a type_info object representing the |
| referenced type. */ |
| if (TREE_CODE (type) == REFERENCE_TYPE) |
| type = TREE_TYPE (type); |
| |
| /* The top-level cv-qualifiers of the lvalue expression or the type-id |
| that is the operand of typeid are always ignored. */ |
| type = TYPE_MAIN_VARIANT (type); |
| |
| return get_typeid_1 (type); |
| } |
| |
| /* Check whether TEST is null before returning RESULT. If TEST is used in |
| RESULT, it must have previously had a save_expr applied to it. */ |
| |
| static tree |
| ifnonnull (test, result) |
| tree test, result; |
| { |
| return build (COND_EXPR, TREE_TYPE (result), |
| build (EQ_EXPR, boolean_type_node, test, integer_zero_node), |
| cp_convert (TREE_TYPE (result), integer_zero_node), |
| result); |
| } |
| |
| /* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working |
| paper. */ |
| |
| static tree |
| build_dynamic_cast_1 (type, expr) |
| tree type, expr; |
| { |
| enum tree_code tc = TREE_CODE (type); |
| tree exprtype = TREE_TYPE (expr); |
| enum tree_code ec; |
| tree dcast_fn; |
| |
| if (type == error_mark_node || expr == error_mark_node) |
| return error_mark_node; |
| |
| if (processing_template_decl) |
| { |
| tree t = build_min (DYNAMIC_CAST_EXPR, type, expr); |
| return t; |
| } |
| |
| assert (exprtype != NULL_TREE); |
| ec = TREE_CODE (exprtype); |
| |
| switch (tc) |
| { |
| case POINTER_TYPE: |
| if (ec == REFERENCE_TYPE) |
| { |
| expr = convert_from_reference (expr); |
| exprtype = TREE_TYPE (expr); |
| ec = TREE_CODE (exprtype); |
| } |
| if (ec != POINTER_TYPE) |
| goto fail; |
| if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE) |
| goto fail; |
| if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE) |
| goto fail; |
| if (TREE_READONLY (TREE_TYPE (exprtype)) |
| && ! TYPE_READONLY (TREE_TYPE (type))) |
| goto fail; |
| if (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node) |
| break; |
| /* else fall through */ |
| case REFERENCE_TYPE: |
| if (TREE_CODE (TREE_TYPE (type)) != RECORD_TYPE) |
| goto fail; |
| if (TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE) |
| goto fail; |
| break; |
| /* else fall through */ |
| default: |
| goto fail; |
| } |
| |
| /* Apply trivial conversion T -> T& for dereferenced ptrs. */ |
| if (ec == RECORD_TYPE) |
| { |
| exprtype = build_type_variant (exprtype, TREE_READONLY (expr), |
| TREE_THIS_VOLATILE (expr)); |
| exprtype = build_reference_type (exprtype); |
| expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT, |
| LOOKUP_NORMAL, NULL_TREE); |
| ec = REFERENCE_TYPE; |
| } |
| |
| if (tc == REFERENCE_TYPE) |
| { |
| if (ec != REFERENCE_TYPE) |
| goto fail; |
| if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE) |
| goto fail; |
| if (TYPE_SIZE (complete_type (TREE_TYPE (exprtype))) == NULL_TREE) |
| goto fail; |
| if (TREE_READONLY (TREE_TYPE (exprtype)) |
| && ! TYPE_READONLY (TREE_TYPE (type))) |
| goto fail; |
| } |
| |
| /* If *type is an unambiguous accessible base class of *exprtype, |
| convert statically. */ |
| { |
| int distance; |
| tree path; |
| |
| distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1, |
| &path); |
| if (distance >= 0) |
| return build_vbase_path (PLUS_EXPR, type, expr, path, 0); |
| } |
| |
| /* Otherwise *exprtype must be a polymorphic class (have a vtbl). */ |
| if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype))) |
| { |
| tree expr1; |
| /* if TYPE is `void *', return pointer to complete object. */ |
| if (tc == POINTER_TYPE |
| && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node) |
| { |
| /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b. */ |
| if (TREE_CODE (expr) == ADDR_EXPR |
| && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL |
| && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE) |
| return build1 (NOP_EXPR, type, expr); |
| |
| /* Since expr is used twice below, save it. */ |
| expr = save_expr (expr); |
| |
| expr1 = build_headof (expr); |
| if (TREE_TYPE (expr1) != type) |
| expr1 = build1 (NOP_EXPR, type, expr1); |
| return ifnonnull (expr, expr1); |
| } |
| else |
| { |
| tree retval; |
| tree result, td1, td2, td3, elems, expr2; |
| |
| /* If we got here, we can't convert statically. Therefore, |
| dynamic_cast<D&>(b) (b an object) cannot succeed. */ |
| if (ec == REFERENCE_TYPE) |
| { |
| if (TREE_CODE (expr) == VAR_DECL |
| && TREE_CODE (TREE_TYPE (expr)) == RECORD_TYPE) |
| { |
| cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed", |
| expr, type); |
| return throw_bad_cast (); |
| } |
| } |
| /* Ditto for dynamic_cast<D*>(&b). */ |
| else if (TREE_CODE (expr) == ADDR_EXPR) |
| { |
| tree op = TREE_OPERAND (expr, 0); |
| if (TREE_CODE (op) == VAR_DECL |
| && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE) |
| { |
| cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed", |
| expr, type); |
| retval = build_int_2 (0, 0); |
| TREE_TYPE (retval) = type; |
| return retval; |
| } |
| } |
| |
| /* Since expr is used twice below, save it. */ |
| expr = save_expr (expr); |
| |
| expr1 = expr; |
| if (tc == REFERENCE_TYPE) |
| expr1 = build_unary_op (ADDR_EXPR, expr1, 0); |
| |
| /* Build run-time conversion. */ |
| expr2 = build_headof (expr1); |
| |
| if (ec == POINTER_TYPE) |
| td1 = get_tinfo_fn_dynamic (build_indirect_ref (expr, NULL_PTR)); |
| else |
| td1 = get_tinfo_fn_dynamic (expr); |
| td1 = decay_conversion (td1); |
| |
| td2 = decay_conversion |
| (get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (type)))); |
| td3 = decay_conversion |
| (get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (exprtype)))); |
| |
| elems = tree_cons |
| (NULL_TREE, td1, tree_cons |
| (NULL_TREE, td2, tree_cons |
| (NULL_TREE, build_int_2 (1, 0), tree_cons |
| (NULL_TREE, expr2, tree_cons |
| (NULL_TREE, td3, tree_cons |
| (NULL_TREE, expr1, NULL_TREE)))))); |
| |
| dcast_fn = get_identifier ("__dynamic_cast"); |
| if (IDENTIFIER_GLOBAL_VALUE (dcast_fn)) |
| dcast_fn = IDENTIFIER_GLOBAL_VALUE (dcast_fn); |
| else |
| { |
| tree tmp; |
| |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, TREE_TYPE (td1), tree_cons |
| (NULL_TREE, TREE_TYPE (td1), tree_cons |
| (NULL_TREE, integer_type_node, tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, TREE_TYPE (td1), tree_cons |
| (NULL_TREE, ptr_type_node, void_list_node)))))); |
| tmp = build_function_type (ptr_type_node, tmp); |
| dcast_fn = build_lang_decl (FUNCTION_DECL, dcast_fn, tmp); |
| DECL_EXTERNAL (dcast_fn) = 1; |
| TREE_PUBLIC (dcast_fn) = 1; |
| DECL_ARTIFICIAL (dcast_fn) = 1; |
| pushdecl_top_level (dcast_fn); |
| make_function_rtl (dcast_fn); |
| assemble_external (dcast_fn); |
| pop_obstacks (); |
| } |
| |
| result = build_call |
| (dcast_fn, TREE_TYPE (TREE_TYPE (dcast_fn)), elems); |
| |
| if (tc == REFERENCE_TYPE) |
| { |
| expr1 = throw_bad_cast (); |
| expr1 = build_compound_expr |
| (tree_cons (NULL_TREE, expr1, |
| build_tree_list (NULL_TREE, cp_convert (type, integer_zero_node)))); |
| TREE_TYPE (expr1) = type; |
| result = save_expr (result); |
| return build (COND_EXPR, type, result, result, expr1); |
| } |
| |
| /* Now back to the type we want from a void*. */ |
| result = cp_convert (type, result); |
| return ifnonnull (expr, result); |
| } |
| } |
| |
| fail: |
| cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'", |
| expr, exprtype, type); |
| return error_mark_node; |
| } |
| |
| tree |
| build_dynamic_cast (type, expr) |
| tree type, expr; |
| { |
| return convert_from_reference (build_dynamic_cast_1 (type, expr)); |
| } |
| |
| /* Build and initialize various sorts of descriptors. Every descriptor |
| node has a name associated with it (the name created by mangling). |
| For this reason, we use the identifier as our access to the __*_desc |
| nodes, instead of sticking them directly in the types. Otherwise we |
| would burden all built-in types (and pointer types) with slots that |
| we don't necessarily want to use. |
| |
| For each descriptor we build, we build a variable that contains |
| the descriptor's information. When we need this info at runtime, |
| all we need is access to these variables. |
| |
| Note: these constructors always return the address of the descriptor |
| info, since that is simplest for their mutual interaction. */ |
| |
| extern tree const_string_type_node; |
| |
| /* Build an initializer for a __si_type_info node. */ |
| |
| static void |
| expand_si_desc (tdecl, type) |
| tree tdecl; |
| tree type; |
| { |
| tree t, elems, fn; |
| char *name = build_overload_name (type, 1, 1); |
| tree name_string = combine_strings (build_string (strlen (name)+1, name)); |
| |
| type = BINFO_TYPE (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)); |
| expand_expr_stmt (get_typeid_1 (type)); |
| t = decay_conversion (get_tinfo_var (type)); |
| elems = tree_cons |
| (NULL_TREE, decay_conversion (tdecl), tree_cons |
| (NULL_TREE, decay_conversion (name_string), tree_cons |
| (NULL_TREE, t, NULL_TREE))); |
| |
| fn = get_identifier ("__rtti_si"); |
| if (IDENTIFIER_GLOBAL_VALUE (fn)) |
| fn = IDENTIFIER_GLOBAL_VALUE (fn); |
| else |
| { |
| tree tmp; |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, const_string_type_node, tree_cons |
| (NULL_TREE, build_pointer_type (type_info_type_node), |
| void_list_node))); |
| tmp = build_function_type (void_type_node, tmp); |
| |
| fn = build_lang_decl (FUNCTION_DECL, fn, tmp); |
| DECL_EXTERNAL (fn) = 1; |
| TREE_PUBLIC (fn) = 1; |
| DECL_ARTIFICIAL (fn) = 1; |
| pushdecl_top_level (fn); |
| make_function_rtl (fn); |
| assemble_external (fn); |
| pop_obstacks (); |
| } |
| |
| fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems); |
| expand_expr_stmt (fn); |
| } |
| |
| /* Build an initializer for a __class_type_info node. */ |
| |
| static void |
| expand_class_desc (tdecl, type) |
| tree tdecl; |
| tree type; |
| { |
| tree name_string; |
| tree fn, tmp; |
| char *name; |
| |
| int i = CLASSTYPE_N_BASECLASSES (type); |
| int base_cnt = 0; |
| tree binfos = TYPE_BINFO_BASETYPES (type); |
| #if 0 |
| /* See code below that used these. */ |
| tree vb = CLASSTYPE_VBASECLASSES (type); |
| int n_base = i; |
| #endif |
| tree base, elems, access, offset, isvir; |
| tree elt, elts = NULL_TREE; |
| static tree base_info_type_node; |
| |
| if (base_info_type_node == NULL_TREE) |
| { |
| tree fields [4]; |
| |
| /* A reasonably close approximation of __class_type_info::base_info */ |
| |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| base_info_type_node = make_lang_type (RECORD_TYPE); |
| |
| /* Actually const __user_type_info * */ |
| fields [0] = build_lang_field_decl |
| (FIELD_DECL, NULL_TREE, |
| build_pointer_type (build_type_variant (type_info_type_node, 1, 0))); |
| fields [1] = build_lang_field_decl |
| (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); |
| DECL_BIT_FIELD (fields[1]) = 1; |
| DECL_FIELD_SIZE (fields[1]) = 29; |
| |
| fields [2] = build_lang_field_decl |
| (FIELD_DECL, NULL_TREE, boolean_type_node); |
| DECL_BIT_FIELD (fields[2]) = 1; |
| DECL_FIELD_SIZE (fields[2]) = 1; |
| |
| /* Actually enum access */ |
| fields [3] = build_lang_field_decl |
| (FIELD_DECL, NULL_TREE, integer_type_node); |
| DECL_BIT_FIELD (fields[3]) = 1; |
| DECL_FIELD_SIZE (fields[3]) = 2; |
| |
| finish_builtin_type (base_info_type_node, "__base_info", fields, |
| 3, ptr_type_node); |
| pop_obstacks (); |
| } |
| |
| while (--i >= 0) |
| { |
| tree binfo = TREE_VEC_ELT (binfos, i); |
| |
| expand_expr_stmt (get_typeid_1 (BINFO_TYPE (binfo))); |
| base = decay_conversion (get_tinfo_var (BINFO_TYPE (binfo))); |
| |
| if (TREE_VIA_VIRTUAL (binfo)) |
| { |
| tree t = BINFO_TYPE (binfo); |
| char *name; |
| tree field; |
| |
| name = (char *) alloca (TYPE_NAME_LENGTH (t)+sizeof (VBASE_NAME)+1); |
| sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (t)); |
| field = lookup_field (type, get_identifier (name), 0, 0); |
| offset = size_binop (FLOOR_DIV_EXPR, |
| DECL_FIELD_BITPOS (field), size_int (BITS_PER_UNIT)); |
| } |
| else |
| offset = BINFO_OFFSET (binfo); |
| |
| if (TREE_VIA_PUBLIC (binfo)) |
| access = access_public_node; |
| else if (TREE_VIA_PROTECTED (binfo)) |
| access = access_protected_node; |
| else |
| access = access_private_node; |
| if (TREE_VIA_VIRTUAL (binfo)) |
| isvir = boolean_true_node; |
| else |
| isvir = boolean_false_node; |
| |
| elt = build |
| (CONSTRUCTOR, base_info_type_node, NULL_TREE, tree_cons |
| (NULL_TREE, base, tree_cons |
| (NULL_TREE, offset, tree_cons |
| (NULL_TREE, isvir, tree_cons |
| (NULL_TREE, access, NULL_TREE))))); |
| TREE_HAS_CONSTRUCTOR (elt) = TREE_CONSTANT (elt) = TREE_STATIC (elt) = 1; |
| elts = tree_cons (NULL_TREE, elt, elts); |
| base_cnt++; |
| } |
| #if 0 |
| i = n_base; |
| while (vb) |
| { |
| tree b; |
| access = access_public_node; |
| while (--i >= 0) |
| { |
| b = TREE_VEC_ELT (binfos, i); |
| if (BINFO_TYPE (vb) == BINFO_TYPE (b) && TREE_VIA_VIRTUAL (b)) |
| { |
| if (TREE_VIA_PUBLIC (b)) |
| access = access_public_node; |
| else if (TREE_VIA_PROTECTED (b)) |
| access = access_protected_node; |
| else |
| access = access_private_node; |
| break; |
| } |
| } |
| base = build_t_desc (BINFO_TYPE (vb), 1); |
| offset = BINFO_OFFSET (vb); |
| isvir = build_int_2 (1, 0); |
| |
| base_list = tree_cons (NULL_TREE, base, base_list); |
| isvir_list = tree_cons (NULL_TREE, isvir, isvir_list); |
| acc_list = tree_cons (NULL_TREE, access, acc_list); |
| off_list = tree_cons (NULL_TREE, offset, off_list); |
| |
| base_cnt++; |
| vb = TREE_CHAIN (vb); |
| } |
| #endif |
| |
| name = build_overload_name (type, 1, 1); |
| name_string = combine_strings (build_string (strlen (name)+1, name)); |
| |
| { |
| tree arrtype = build_array_type (base_info_type_node, NULL_TREE); |
| elts = build (CONSTRUCTOR, arrtype, NULL_TREE, elts); |
| TREE_HAS_CONSTRUCTOR (elts) = TREE_CONSTANT (elts) |
| = TREE_STATIC (elts) = 1; |
| complete_array_type (arrtype, elts, 1); |
| } |
| |
| elems = tree_cons |
| (NULL_TREE, decay_conversion (tdecl), tree_cons |
| (NULL_TREE, decay_conversion (name_string), tree_cons |
| (NULL_TREE, decay_conversion (elts), tree_cons |
| (NULL_TREE, cp_convert (sizetype, build_int_2 (base_cnt, 0)), |
| NULL_TREE)))); |
| |
| fn = get_identifier ("__rtti_class"); |
| if (IDENTIFIER_GLOBAL_VALUE (fn)) |
| fn = IDENTIFIER_GLOBAL_VALUE (fn); |
| else |
| { |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, const_string_type_node, tree_cons |
| (NULL_TREE, build_pointer_type (base_info_type_node), tree_cons |
| (NULL_TREE, sizetype, void_list_node)))); |
| tmp = build_function_type (void_type_node, tmp); |
| |
| fn = build_lang_decl (FUNCTION_DECL, fn, tmp); |
| DECL_EXTERNAL (fn) = 1; |
| TREE_PUBLIC (fn) = 1; |
| DECL_ARTIFICIAL (fn) = 1; |
| pushdecl_top_level (fn); |
| make_function_rtl (fn); |
| assemble_external (fn); |
| pop_obstacks (); |
| } |
| |
| fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems); |
| expand_expr_stmt (fn); |
| } |
| |
| /* Build an initializer for a __pointer_type_info node. */ |
| |
| static void |
| expand_ptr_desc (tdecl, type) |
| tree tdecl; |
| tree type; |
| { |
| tree t, elems, fn; |
| char *name = build_overload_name (type, 1, 1); |
| tree name_string = combine_strings (build_string (strlen (name)+1, name)); |
| |
| type = TREE_TYPE (type); |
| expand_expr_stmt (get_typeid_1 (type)); |
| t = decay_conversion (get_tinfo_var (type)); |
| elems = tree_cons |
| (NULL_TREE, decay_conversion (tdecl), tree_cons |
| (NULL_TREE, decay_conversion (name_string), tree_cons |
| (NULL_TREE, t, NULL_TREE))); |
| |
| fn = get_identifier ("__rtti_ptr"); |
| if (IDENTIFIER_GLOBAL_VALUE (fn)) |
| fn = IDENTIFIER_GLOBAL_VALUE (fn); |
| else |
| { |
| tree tmp; |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, const_string_type_node, tree_cons |
| (NULL_TREE, build_pointer_type (type_info_type_node), |
| void_list_node))); |
| tmp = build_function_type (void_type_node, tmp); |
| |
| fn = build_lang_decl (FUNCTION_DECL, fn, tmp); |
| DECL_EXTERNAL (fn) = 1; |
| TREE_PUBLIC (fn) = 1; |
| DECL_ARTIFICIAL (fn) = 1; |
| pushdecl_top_level (fn); |
| make_function_rtl (fn); |
| assemble_external (fn); |
| pop_obstacks (); |
| } |
| |
| fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems); |
| expand_expr_stmt (fn); |
| } |
| |
| /* Build an initializer for a __attr_type_info node. */ |
| |
| static void |
| expand_attr_desc (tdecl, type) |
| tree tdecl; |
| tree type; |
| { |
| tree elems, t, fn; |
| char *name = build_overload_name (type, 1, 1); |
| tree name_string = combine_strings (build_string (strlen (name)+1, name)); |
| tree attrval = build_int_2 |
| (TYPE_READONLY (type) | TYPE_VOLATILE (type) * 2, 0); |
| |
| expand_expr_stmt (get_typeid_1 (TYPE_MAIN_VARIANT (type))); |
| t = decay_conversion (get_tinfo_var (TYPE_MAIN_VARIANT (type))); |
| elems = tree_cons |
| (NULL_TREE, decay_conversion (tdecl), tree_cons |
| (NULL_TREE, decay_conversion (name_string), tree_cons |
| (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE)))); |
| |
| fn = get_identifier ("__rtti_attr"); |
| if (IDENTIFIER_GLOBAL_VALUE (fn)) |
| fn = IDENTIFIER_GLOBAL_VALUE (fn); |
| else |
| { |
| tree tmp; |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, const_string_type_node, tree_cons |
| (NULL_TREE, integer_type_node, tree_cons |
| (NULL_TREE, build_pointer_type (type_info_type_node), |
| void_list_node)))); |
| tmp = build_function_type (void_type_node, tmp); |
| |
| fn = build_lang_decl (FUNCTION_DECL, fn, tmp); |
| DECL_EXTERNAL (fn) = 1; |
| TREE_PUBLIC (fn) = 1; |
| DECL_ARTIFICIAL (fn) = 1; |
| pushdecl_top_level (fn); |
| make_function_rtl (fn); |
| assemble_external (fn); |
| pop_obstacks (); |
| } |
| |
| fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems); |
| expand_expr_stmt (fn); |
| } |
| |
| /* Build an initializer for a type_info node that just has a name. */ |
| |
| static void |
| expand_generic_desc (tdecl, type, fnname) |
| tree tdecl; |
| tree type; |
| char *fnname; |
| { |
| char *name = build_overload_name (type, 1, 1); |
| tree name_string = combine_strings (build_string (strlen (name)+1, name)); |
| tree elems = tree_cons |
| (NULL_TREE, decay_conversion (tdecl), tree_cons |
| (NULL_TREE, decay_conversion (name_string), NULL_TREE)); |
| |
| tree fn = get_identifier (fnname); |
| if (IDENTIFIER_GLOBAL_VALUE (fn)) |
| fn = IDENTIFIER_GLOBAL_VALUE (fn); |
| else |
| { |
| tree tmp; |
| push_obstacks (&permanent_obstack, &permanent_obstack); |
| tmp = tree_cons |
| (NULL_TREE, ptr_type_node, tree_cons |
| (NULL_TREE, const_string_type_node, void_list_node)); |
| tmp = build_function_type (void_type_node, tmp); |
| |
| fn = build_lang_decl (FUNCTION_DECL, fn, tmp); |
| DECL_EXTERNAL (fn) = 1; |
| TREE_PUBLIC (fn) = 1; |
| DECL_ARTIFICIAL (fn) = 1; |
| pushdecl_top_level (fn); |
| make_function_rtl (fn); |
| assemble_external (fn); |
| pop_obstacks (); |
| } |
| |
| fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems); |
| expand_expr_stmt (fn); |
| } |
| |
| /* Generate the code for a type_info initialization function. |
| Note that we take advantage of the passage |
| |
| 5.2.7 Type identification [expr.typeid] |
| |
| Whether or not the destructor is called for the type_info object at the |
| end of the program is unspecified. |
| |
| and don't bother to arrange for these objects to be destroyed. It |
| doesn't matter, anyway, since the destructors don't do anything. |
| |
| This must only be called from toplevel (i.e. from finish_file)! */ |
| |
| void |
| synthesize_tinfo_fn (fndecl) |
| tree fndecl; |
| { |
| tree type = TREE_TYPE (DECL_NAME (fndecl)); |
| tree tmp, addr; |
| |
| tree tdecl = get_tinfo_var (type); |
| DECL_EXTERNAL (tdecl) = 0; |
| TREE_STATIC (tdecl) = 1; |
| DECL_COMMON (tdecl) = 1; |
| TREE_USED (tdecl) = 1; |
| DECL_ALIGN (tdecl) = TYPE_ALIGN (ptr_type_node); |
| cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0); |
| |
| start_function (NULL_TREE, fndecl, NULL_TREE, 1); |
| store_parm_decls (); |
| clear_last_expr (); |
| push_momentary (); |
| |
| /* If the first word of the array (the vtable) is non-zero, we've already |
| initialized the object, so don't do it again. */ |
| addr = decay_conversion (tdecl); |
| tmp = cp_convert (build_pointer_type (ptr_type_node), addr); |
| tmp = build_indirect_ref (tmp, 0); |
| tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node, 1); |
| expand_start_cond (tmp, 0); |
| |
| if (TREE_CODE (type) == FUNCTION_TYPE) |
| expand_generic_desc (tdecl, type, "__rtti_func"); |
| else if (TREE_CODE (type) == ARRAY_TYPE) |
| expand_generic_desc (tdecl, type, "__rtti_array"); |
| else if (TYPE_VOLATILE (type) || TYPE_READONLY (type)) |
| expand_attr_desc (tdecl, type); |
| else if (TREE_CODE (type) == POINTER_TYPE) |
| { |
| if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE) |
| expand_generic_desc (tdecl, type, "__rtti_ptmd"); |
| else if (TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE) |
| expand_generic_desc (tdecl, type, "__rtti_ptmf"); |
| else |
| expand_ptr_desc (tdecl, type); |
| } |
| else if (TYPE_PTRMEMFUNC_P (type)) |
| expand_generic_desc (tdecl, type, "__rtti_ptmf"); |
| else if (IS_AGGR_TYPE (type)) |
| { |
| if (CLASSTYPE_N_BASECLASSES (type) == 0) |
| expand_generic_desc (tdecl, type, "__rtti_user"); |
| else if (! TYPE_USES_COMPLEX_INHERITANCE (type) |
| && (TREE_VIA_PUBLIC |
| (TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0)))) |
| expand_si_desc (tdecl, type); |
| else |
| expand_class_desc (tdecl, type); |
| } |
| else if (TREE_CODE (type) == ENUMERAL_TYPE) |
| expand_generic_desc (tdecl, type, "__rtti_user"); |
| else |
| my_friendly_abort (252); |
| |
| expand_end_cond (); |
| |
| /* OK, now return the type_info object. */ |
| tmp = cp_convert (build_pointer_type (type_info_type_node), addr); |
| tmp = build_indirect_ref (tmp, 0); |
| c_expand_return (tmp); |
| finish_function (lineno, 0, 0); |
| } |
| |
| #if 0 |
| /* This is the old dossier type descriptor generation code, it's much |
| more extended than rtti. It's reserved for later use. */ |
| /* Build an initializer for a __t_desc node. So that we can take advantage |
| of recursion, we accept NULL for TYPE. |
| DEFINITION is greater than zero iff we must define the type descriptor |
| (as opposed to merely referencing it). 1 means treat according to |
| #pragma interface/#pragma implementation rules. 2 means define as |
| global and public, no matter what. */ |
| |
| tree |
| build_t_desc (type, definition) |
| tree type; |
| int definition; |
| { |
| tree tdecl; |
| tree tname, name_string; |
| tree elems, fields; |
| tree parents, vbases, offsets, ivars, methods, target_type; |
| int method_count = 0, field_count = 0; |
| |
| if (type == NULL_TREE) |
| return NULL_TREE; |
| |
| tname = build_t_desc_overload (type); |
| if (IDENTIFIER_AS_DESC (tname) |
| && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname)))) |
| return IDENTIFIER_AS_DESC (tname); |
| |
| tdecl = lookup_name (tname, 0); |
| if (tdecl == NULL_TREE) |
| { |
| tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node); |
| DECL_EXTERNAL (tdecl) = 1; |
| TREE_PUBLIC (tdecl) = 1; |
| tdecl = pushdecl_top_level (tdecl); |
| } |
| /* If we previously defined it, return the defined result. */ |
| else if (definition && DECL_INITIAL (tdecl)) |
| return IDENTIFIER_AS_DESC (tname); |
| |
| if (definition) |
| { |
| tree taggr = type; |
| /* Let T* and T& be written only when T is written (if T is an aggr). |
| We do this for const, but not for volatile, since volatile |
| is rare and const is not. */ |
| if (!TYPE_VOLATILE (taggr) |
| && (TREE_CODE (taggr) == POINTER_TYPE |
| || TREE_CODE (taggr) == REFERENCE_TYPE) |
| && IS_AGGR_TYPE (TREE_TYPE (taggr))) |
| taggr = TREE_TYPE (taggr); |
| |
| /* If we know that we don't need to write out this type's |
| vtable, then don't write out it's dossier. Somebody |
| else will take care of that. */ |
| if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr)) |
| { |
| if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr)) |
| { |
| TREE_PUBLIC (tdecl) = ! CLASSTYPE_INTERFACE_ONLY (taggr) |
| && CLASSTYPE_INTERFACE_KNOWN (taggr); |
| DECL_EXTERNAL (tdecl) = 0; |
| } |
| else |
| { |
| if (write_virtuals != 0) |
| TREE_PUBLIC (tdecl) = 1; |
| } |
| } |
| else |
| { |
| DECL_EXTERNAL (tdecl) = 0; |
| TREE_PUBLIC (tdecl) = (definition > 1); |
| } |
| } |
| SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0)); |
| |
| if (!definition || DECL_EXTERNAL (tdecl)) |
| { |
| /* That's it! */ |
| cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0); |
| return IDENTIFIER_AS_DESC (tname); |
| } |
| |
| /* Show that we are defining the t_desc for this type. */ |
| DECL_INITIAL (tdecl) = error_mark_node; |
| |
| parents = build_tree_list (NULL_TREE, integer_zero_node); |
| vbases = build_tree_list (NULL_TREE, integer_zero_node); |
| offsets = build_tree_list (NULL_TREE, integer_zero_node); |
| methods = NULL_TREE; |
| ivars = NULL_TREE; |
| |
| if (TYPE_LANG_SPECIFIC (type)) |
| { |
| int i = CLASSTYPE_N_BASECLASSES (type); |
| tree method_vec = CLASSTYPE_METHOD_VEC (type); |
| tree *meth, *end; |
| tree binfos = TYPE_BINFO_BASETYPES (type); |
| tree vb = CLASSTYPE_VBASECLASSES (type); |
| |
| while (--i >= 0) |
| parents = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (TREE_VEC_ELT (binfos, i)), 0), parents); |
| |
| while (vb) |
| { |
| vbases = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (vb), 0), vbases); |
| offsets = tree_cons (NULL_TREE, BINFO_OFFSET (vb), offsets); |
| vb = TREE_CHAIN (vb); |
| } |
| |
| if (method_vec) |
| for (meth = TREE_VEC_END (method_vec), |
| end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; ) |
| if (*meth) |
| { |
| methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods); |
| method_count++; |
| } |
| } |
| |
| if (IS_AGGR_TYPE (type)) |
| { |
| for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields)) |
| if (TREE_CODE (fields) == FIELD_DECL |
| || TREE_CODE (fields) == VAR_DECL) |
| { |
| ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars); |
| field_count++; |
| } |
| ivars = nreverse (ivars); |
| } |
| |
| parents = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), parents, 0); |
| vbases = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), vbases, 0); |
| offsets = finish_table (NULL_TREE, integer_type_node, offsets, 0); |
| if (methods == NULL_TREE) |
| methods = null_pointer_node; |
| else |
| methods = build_unary_op (ADDR_EXPR, |
| finish_table (NULL_TREE, __m_desc_type_node, methods, 0), |
| 0); |
| if (ivars == NULL_TREE) |
| ivars = null_pointer_node; |
| else |
| ivars = build_unary_op (ADDR_EXPR, |
| finish_table (NULL_TREE, __i_desc_type_node, ivars, 0), |
| 0); |
| if (TREE_TYPE (type)) |
| target_type = build_t_desc (TREE_TYPE (type), definition); |
| else |
| target_type = integer_zero_node; |
| |
| name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname))); |
| |
| elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0), |
| tree_cons (NULL_TREE, |
| TYPE_SIZE(type)? size_in_bytes(type) : integer_zero_node, |
| /* really should use bitfield initialization here. */ |
| tree_cons (NULL_TREE, integer_zero_node, |
| tree_cons (NULL_TREE, target_type, |
| tree_cons (NULL_TREE, build_int_2 (field_count, 2), |
| tree_cons (NULL_TREE, build_int_2 (method_count, 2), |
| tree_cons (NULL_TREE, ivars, |
| tree_cons (NULL_TREE, methods, |
| tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0), |
| tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0), |
| build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0)))))))))))); |
| return build_generic_desc (tdecl, elems); |
| } |
| |
| /* Build an initializer for a __i_desc node. */ |
| |
| tree |
| build_i_desc (decl) |
| tree decl; |
| { |
| tree elems, name_string; |
| tree taggr; |
| |
| name_string = DECL_NAME (decl); |
| name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string))); |
| |
| /* Now decide whether this ivar should cause it's type to get |
| def'd or ref'd in this file. If the type we are looking at |
| has a proxy definition, we look at the proxy (i.e., a |
| `foo *' is equivalent to a `foo'). */ |
| taggr = TREE_TYPE (decl); |
| |
| if ((TREE_CODE (taggr) == POINTER_TYPE |
| || TREE_CODE (taggr) == REFERENCE_TYPE) |
| && TYPE_VOLATILE (taggr) == 0) |
| taggr = TREE_TYPE (taggr); |
| |
| elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0), |
| tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl), |
| build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl), |
| ! IS_AGGR_TYPE (taggr))))); |
| taggr = build (CONSTRUCTOR, __i_desc_type_node, NULL_TREE, elems); |
| TREE_CONSTANT (taggr) = 1; |
| TREE_STATIC (taggr) = 1; |
| TREE_READONLY (taggr) = 1; |
| return taggr; |
| } |
| |
| /* Build an initializer for a __m_desc node. */ |
| |
| tree |
| build_m_desc (decl) |
| tree decl; |
| { |
| tree taggr, elems, name_string; |
| tree parm_count, req_count, vindex, vcontext; |
| tree parms; |
| int p_count, r_count; |
| tree parm_types = NULL_TREE; |
| |
| for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0; |
| parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++) |
| { |
| taggr = TREE_VALUE (parms); |
| if ((TREE_CODE (taggr) == POINTER_TYPE |
| || TREE_CODE (taggr) == REFERENCE_TYPE) |
| && TYPE_VOLATILE (taggr) == 0) |
| taggr = TREE_TYPE (taggr); |
| |
| parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms), |
| ! IS_AGGR_TYPE (taggr)), |
| parm_types); |
| if (TREE_PURPOSE (parms) == NULL_TREE) |
| r_count++; |
| } |
| |
| parm_types = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), |
| nreverse (parm_types), 0); |
| parm_count = build_int_2 (p_count, 0); |
| req_count = build_int_2 (r_count, 0); |
| |
| if (DECL_VINDEX (decl)) |
| vindex = DECL_VINDEX (decl); |
| else |
| vindex = integer_zero_node; |
| if (DECL_CONTEXT (decl) |
| && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't') |
| vcontext = build_t_desc (DECL_CONTEXT (decl), 0); |
| else |
| vcontext = integer_zero_node; |
| name_string = DECL_NAME (decl); |
| if (name_string == NULL) |
| name_string = DECL_ASSEMBLER_NAME (decl); |
| name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string))); |
| |
| /* Now decide whether the return type of this mvar |
| should cause it's type to get def'd or ref'd in this file. |
| If the type we are looking at has a proxy definition, |
| we look at the proxy (i.e., a `foo *' is equivalent to a `foo'). */ |
| taggr = TREE_TYPE (TREE_TYPE (decl)); |
| |
| if ((TREE_CODE (taggr) == POINTER_TYPE |
| || TREE_CODE (taggr) == REFERENCE_TYPE) |
| && TYPE_VOLATILE (taggr) == 0) |
| taggr = TREE_TYPE (taggr); |
| |
| elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0), |
| tree_cons (NULL_TREE, vindex, |
| tree_cons (NULL_TREE, vcontext, |
| tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)), |
| ! IS_AGGR_TYPE (taggr)), |
| tree_cons (NULL_TREE, build_c_cast (build_pointer_type (default_function_type), build_unary_op (ADDR_EXPR, decl, 0)), |
| tree_cons (NULL_TREE, parm_count, |
| tree_cons (NULL_TREE, req_count, |
| build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0))))))))); |
| |
| taggr = build (CONSTRUCTOR, __m_desc_type_node, NULL_TREE, elems); |
| TREE_CONSTANT (taggr) = 1; |
| TREE_STATIC (taggr) = 1; |
| TREE_READONLY (taggr) = 1; |
| return taggr; |
| } |
| #endif /* dossier */ |