* tree.h (DECL_ASSEMBLER_NAME): Compute it lazily.
(DECL_ASSEMBLER_NAME_SET_P): New macro.
(SET_DECL_ASSEMBLER_NAME): Likewise.
(COPY_DECL_ASSEMBLER_NAME): Likewise.
(set_decl_assembler_name): Declare.
(lang_set_decl_assembler_name): Likewise.
* tree.c (lang_set_decl_assembler_name): New variab.e
(set_decl_assembler_name): New function.
(init_obstacks): Set lang_set_decl_assembler_name.
(build_decl): Don't set DECL_ASSEMBLER_NAME.
* c-decl.c (duplicate_decls): Use SET_DECL_ASSEMBLER_NAME,
COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
where it's not necessary.
(builtin_function): Likewise.
(finish_decl): Likewise.
* dbxout.c (dbxout_type_methods): Likewise.
* ggc-common.c (ggc_mark_trees): Likewise.
* profile.c (output_func_start_profiler): Likewise.
* varasm.c (make_decl_rtl): Likewise.
* class.c (get_vtable_decl): Use SET_DECL_ASSEMBLER_NAME,
COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
where it's not necessary.
(add_method): Remove optimization involving comparison of
DECL_ASSEMBLER_NAME.
(build_vtbl_or_vbase_field): Use SET_DECL_ASSEMBLER_NAME,
COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
where it's not necessary.
(check_methods): Likewise.
(build_clone): Likewise.
(built_vtt): Likewise.
* cp-tree.h (DECL_NEEDED_P): Likewise.
* decl.c (pushtag): Likewise.
(duplicate_decls): Likewise.
(pushdecl): Likewise.
(builtin_function): Likewise.
(build_library_fn_1): Set DECL_LANGUAGE for library functions.
(build_cp_library_fn): Likewise.
(maybe_commonize_var): Use SET_DECL_ASSEMBLER_NAME,
COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
where it's not necessary.
(make_rtl_for_nonlocal_decl): Likewise.
(cp_finish_decl): Likewise.
(grokfndecl): Likewise.
(grokvardecl): Likewise.
(grokdeclarator): Likewise.
(start_function): Likewise.
(cp_missing_return_ok_p): Likewise.
* decl2.c (grokclassfn): Likewise.
(check_classfn): Likewise.
(finish_static_data_member_decl): Likewise.
(grokfield): Likewise.
* error.c (GLOBAL_IORD_P): Remove.
(dump_global_iord): Improve output.
(dump_decl): Avoid using DECL_ASSEMBLER_NAME.
* except.c (nothrow_libfn_p): Summarily reject any function not in
namespace-scope.
* init.c (build_java_class_ref): Don't explicitly set
DECL_ASSEMBLER_NAME after calling mangle_decl.
* mangle.c (mangle_decl_string): Handle extern "C" functions.
(mangle_decl): Set the DECL_ASSEMBLER_NAME for the decl.
* method.c (set_mangled_name_for_decl): Don't explicitly set
DECL_ASSEMBLER_NAME after calling mangle_decl.
(make_thunk): Explicitly set the DECL_ASSEMBLER_NAME and
IDENTIFIER_GLOBAL_VALUE for the thunk.
* pt.c (set_mangled_name_for_template_decl): Remove.
(check_explicit_specialization): Don't use it.
(looup_template_class): Don't set DECL_ASSEMBLER_NAME.
(tsubst_friend_function): Likewise.
(tsubst_decl): Likewise.
(regenerate_decl_from_template): Use COPY_DECL_ASSEMBLER_NAME.
* rtti.c (get_tinfo_decl): Use SET_DECL_ASSEMBLER_NAME,
COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
where it's not necessary.
(tinfo_base_init): Likewise.
(create_real_tinfo_var): Likewise.
* search.c (looup_field_1): Likewise.
* semantics.c (finish_named_return_value): Likewise.
* tree.c (init_tree): Set lang_set_decl_assembler_name.
* com.c (builtin_function): Use SET_DECL_ASSEMBLER_NAME.
* class.c (build_class_ref): Use SET_DECL_ASSEMBLER_NAME.
(layout_class): Likewise.
(layout_class_method): Likewise.
(emit_register_classes): Likewise.
* decl.c (builtin_function): Likewise.
(give_name_to_locals): Likewise.
From-SVN: r40642
2001-03-19 Mark Mitchell <mark@codesourcery.com>
+ Compute DECL_ASSEMBLER_NAME lazily.
+ * tree.h (DECL_ASSEMBLER_NAME): Compute it lazily.
+ (DECL_ASSEMBLER_NAME_SET_P): New macro.
+ (SET_DECL_ASSEMBLER_NAME): Likewise.
+ (COPY_DECL_ASSEMBLER_NAME): Likewise.
+ (set_decl_assembler_name): Declare.
+ (lang_set_decl_assembler_name): Likewise.
+ * tree.c (lang_set_decl_assembler_name): New variab.e
+ (set_decl_assembler_name): New function.
+ (init_obstacks): Set lang_set_decl_assembler_name.
+ (build_decl): Don't set DECL_ASSEMBLER_NAME.
+ * c-decl.c (duplicate_decls): Use SET_DECL_ASSEMBLER_NAME,
+ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
+ where it's not necessary.
+ (builtin_function): Likewise.
+ (finish_decl): Likewise.
+ * dbxout.c (dbxout_type_methods): Likewise.
+ * ggc-common.c (ggc_mark_trees): Likewise.
+ * profile.c (output_func_start_profiler): Likewise.
+ * varasm.c (make_decl_rtl): Likewise.
+
* cse.c (find_comparison_args): Update documentation. Fix
mishandling of COMPARE operations.
/* Copy the assembler name.
Currently, it can only be defined in the prototype. */
- DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
+ COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
if (flag_traditional && name[0] != '_')
DECL_BUILT_IN_NONANSI (decl) = 1;
if (library_name)
- DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
make_decl_rtl (decl, NULL_PTR);
pushdecl (decl);
DECL_BUILT_IN_CLASS (decl) = class;
{
DECL_BUILT_IN_CLASS (decl) = NOT_BUILT_IN;
SET_DECL_RTL (decl, NULL_RTX);
- DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
}
/* Output the assembler code and/or RTL code for variables and functions,
{
if (asmspec)
{
- DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
DECL_C_HARD_REGISTER (decl) = 1;
}
add_decl_stmt (decl);
+2001-03-19 Mark Mitchell <mark@codesourcery.com>
+
+ * class.c (get_vtable_decl): Use SET_DECL_ASSEMBLER_NAME,
+ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
+ where it's not necessary.
+ (add_method): Remove optimization involving comparison of
+ DECL_ASSEMBLER_NAME.
+ (build_vtbl_or_vbase_field): Use SET_DECL_ASSEMBLER_NAME,
+ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
+ where it's not necessary.
+ (check_methods): Likewise.
+ (build_clone): Likewise.
+ (built_vtt): Likewise.
+ * cp-tree.h (DECL_NEEDED_P): Likewise.
+ * decl.c (pushtag): Likewise.
+ (duplicate_decls): Likewise.
+ (pushdecl): Likewise.
+ (builtin_function): Likewise.
+ (build_library_fn_1): Set DECL_LANGUAGE for library functions.
+ (build_cp_library_fn): Likewise.
+ (maybe_commonize_var): Use SET_DECL_ASSEMBLER_NAME,
+ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
+ where it's not necessary.
+ (make_rtl_for_nonlocal_decl): Likewise.
+ (cp_finish_decl): Likewise.
+ (grokfndecl): Likewise.
+ (grokvardecl): Likewise.
+ (grokdeclarator): Likewise.
+ (start_function): Likewise.
+ (cp_missing_return_ok_p): Likewise.
+ * decl2.c (grokclassfn): Likewise.
+ (check_classfn): Likewise.
+ (finish_static_data_member_decl): Likewise.
+ (grokfield): Likewise.
+ * error.c (GLOBAL_IORD_P): Remove.
+ (dump_global_iord): Improve output.
+ (dump_decl): Avoid using DECL_ASSEMBLER_NAME.
+ * except.c (nothrow_libfn_p): Summarily reject any function not in
+ namespace-scope.
+ * init.c (build_java_class_ref): Don't explicitly set
+ DECL_ASSEMBLER_NAME after calling mangle_decl.
+ * mangle.c (mangle_decl_string): Handle extern "C" functions.
+ (mangle_decl): Set the DECL_ASSEMBLER_NAME for the decl.
+ * method.c (set_mangled_name_for_decl): Don't explicitly set
+ DECL_ASSEMBLER_NAME after calling mangle_decl.
+ (make_thunk): Explicitly set the DECL_ASSEMBLER_NAME and
+ IDENTIFIER_GLOBAL_VALUE for the thunk.
+ * pt.c (set_mangled_name_for_template_decl): Remove.
+ (check_explicit_specialization): Don't use it.
+ (looup_template_class): Don't set DECL_ASSEMBLER_NAME.
+ (tsubst_friend_function): Likewise.
+ (tsubst_decl): Likewise.
+ (regenerate_decl_from_template): Use COPY_DECL_ASSEMBLER_NAME.
+ * rtti.c (get_tinfo_decl): Use SET_DECL_ASSEMBLER_NAME,
+ COPY_DECL_ASSEMBLER_NAME, etc. Don't set DECL_ASSEMBLER_NAME
+ where it's not necessary.
+ (tinfo_base_init): Likewise.
+ (create_real_tinfo_var): Likewise.
+ * search.c (looup_field_1): Likewise.
+ * semantics.c (finish_named_return_value): Likewise.
+ * tree.c (init_tree): Set lang_set_decl_assembler_name.
+
2001-03-15 Gabriel Dos Reis <gdr@codesourcery.com>
Correct semantics restrictions checking in throw-expression.
}
decl = build_vtable (type, name, void_type_node);
+ SET_DECL_ASSEMBLER_NAME (decl, name);
decl = pushdecl_top_level (decl);
my_friendly_assert (IDENTIFIER_GLOBAL_VALUE (name) == decl,
20000517);
fn, method);
}
}
-
- /* Since this is an ordinary function in a
- non-template class, it's mangled name can be used
- as a unique identifier. This technique is only
- an optimization; we would get the same results if
- we just used decls_match here. */
- if (DECL_ASSEMBLER_NAME (fn)
- != DECL_ASSEMBLER_NAME (method))
- continue;
}
- else if (!decls_match (fn, method))
+
+ if (!decls_match (fn, method))
continue;
/* There has already been a declaration of this method
/* Build the FIELD_DECL. */
field = build_decl (FIELD_DECL, name, type);
- DECL_ASSEMBLER_NAME (field) = assembler_name;
+ SET_DECL_ASSEMBLER_NAME (field, assembler_name);
DECL_VIRTUAL_P (field) = 1;
DECL_ARTIFICIAL (field) = 1;
DECL_FIELD_CONTEXT (field) = class_type;
GNU_xref_member (current_class_name, x);
/* If this was an evil function, don't keep it in class. */
- if (IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
+ if (DECL_ASSEMBLER_NAME_SET_P (x)
+ && IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (x)))
continue;
check_for_override (x, t);
DECL_ABSTRACT_ORIGIN (clone) = fn;
/* Reset the function name. */
DECL_NAME (clone) = name;
- DECL_ASSEMBLER_NAME (clone) = DECL_NAME (clone);
/* There's no pending inline data for this function. */
DECL_PENDING_INLINE_INFO (clone) = NULL;
DECL_PENDING_INLINE_P (clone) = 0;
}
}
- /* Mangle the function name. */
- set_mangled_name_for_decl (clone);
-
/* Create the RTL for this function. */
SET_DECL_RTL (clone, NULL_RTX);
rest_of_decl_compilation (clone, NULL, /*top_level=*/1, at_eof);
/* Now, build the VTT object itself. */
vtt = build_vtable (t, get_vtt_name (t), type);
+ SET_DECL_ASSEMBLER_NAME (vtt, DECL_NAME (vtt));
pushdecl_top_level (vtt);
initialize_array (vtt, inits);
}
just been used somewhere, even if it's not really needed. We need
anything that isn't comdat, but we don't know for sure whether or
not something is comdat until end-of-file. */
-#define DECL_NEEDED_P(DECL) \
- ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL)) \
- || (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME ((DECL)))) \
+#define DECL_NEEDED_P(DECL) \
+ ((at_eof && TREE_PUBLIC (DECL) && !DECL_COMDAT (DECL)) \
+ || (DECL_ASSEMBLER_NAME_SET_P (DECL) \
+ && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME ((DECL)))) \
|| (flag_syntax_only && TREE_USED ((DECL))))
/* Non-zero iff DECL is memory-based. The DECL_RTL of
/* in mangle.c */
extern void init_mangle PARAMS ((void));
-extern tree mangle_decl PARAMS ((tree));
+extern void mangle_decl PARAMS ((tree));
extern const char *mangle_type_string PARAMS ((tree));
extern tree mangle_type PARAMS ((tree));
extern tree mangle_typeinfo_for_type PARAMS ((tree));
DECL_IGNORED_P (d) = 1;
TYPE_CONTEXT (type) = DECL_CONTEXT (d);
- DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
/* If this is a local class, keep track of it. We need this
information for name-mangling, and so that it is possible to find
&& TREE_CODE (TYPE_CONTEXT (type)) == FUNCTION_DECL
&& !processing_template_decl)
VARRAY_PUSH_TREE (local_classes, type);
-
- if (!uses_template_parms (type))
- DECL_ASSEMBLER_NAME (d) = mangle_type (type);
}
if (b->parm_flag == 2)
{
will be banished. */
DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
- DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
+ COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (newdecl),
newdecl);
}
if (! types_match)
{
DECL_LANGUAGE (olddecl) = DECL_LANGUAGE (newdecl);
- DECL_ASSEMBLER_NAME (olddecl) = DECL_ASSEMBLER_NAME (newdecl);
+ COPY_DECL_ASSEMBLER_NAME (newdecl, olddecl);
SET_DECL_RTL (olddecl, DECL_RTL (newdecl));
}
if (! types_match || new_defines_function)
TREE_ADDRESSABLE (newdecl) = TREE_ADDRESSABLE (olddecl);
TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl);
DECL_COMMON (newdecl) = DECL_COMMON (olddecl);
- DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
+ COPY_DECL_ASSEMBLER_NAME (olddecl, newdecl);
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
if (TREE_CODE (x) == FUNCTION_DECL)
for (match = t; match; match = OVL_NEXT (match))
{
- if (DECL_ASSEMBLER_NAME (OVL_CURRENT (t))
- == DECL_ASSEMBLER_NAME (x))
+ if (decls_match (OVL_CURRENT (match), x))
break;
}
else
if (IDENTIFIER_GLOBAL_VALUE (name) == NULL_TREE && TREE_PUBLIC (x))
TREE_PUBLIC (name) = 1;
- /* Bind the mangled name for the entity. In the future, we
- should not need to do this; mangled names are an
- implementation detail of which the front-end should not
- need to be aware. */
- if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
- && t != NULL_TREE)
- /* For an ordinary function, we create a binding from
- the mangled name (i.e., NAME) to the DECL. But, for
- an `extern "C"' function, the mangled name and the
- ordinary name are the same so we need not do this. */
- && !DECL_EXTERN_C_FUNCTION_P (x))
- {
- tree mangled_name;
-
- if (TREE_CODE (x) == TYPE_DECL || TREE_CODE (x) == VAR_DECL
- || TREE_CODE (x) == NAMESPACE_DECL)
- mangled_name = name;
- else
- mangled_name = DECL_ASSEMBLER_NAME (x);
-
- if (TREE_CODE (x) == FUNCTION_DECL)
- my_friendly_assert
- ((IDENTIFIER_GLOBAL_VALUE (mangled_name) == NULL_TREE)
- || (IDENTIFIER_GLOBAL_VALUE (mangled_name) == x), 378);
- SET_IDENTIFIER_NAMESPACE_VALUE (mangled_name, x);
- }
+ /* Bind the name for the entity. */
+ if (!(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)
+ && t != NULL_TREE)
+ && (TREE_CODE (x) == TYPE_DECL
+ || TREE_CODE (x) == VAR_DECL
+ || TREE_CODE (x) == NAMESPACE_DECL
+ || TREE_CODE (x) == CONST_DECL
+ || TREE_CODE (x) == TEMPLATE_DECL))
+ SET_IDENTIFIER_NAMESPACE_VALUE (name, x);
/* Don't forget if the function was used via an implicit decl. */
if (IDENTIFIER_IMPLICIT_DECL (name)
we cannot change DECL_ASSEMBLER_NAME until we have installed this
function in the namespace. */
if (libname)
- DECL_ASSEMBLER_NAME (decl) = get_identifier (libname);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (libname));
+ make_decl_rtl (decl, NULL);
/* Warn if a function in the namespace for users
is used without an occasion to consider it declared. */
DECL_ARTIFICIAL (fn) = 1;
TREE_NOTHROW (fn) = 1;
SET_OVERLOADED_OPERATOR_CODE (fn, operator_code);
+ DECL_LANGUAGE (fn) = lang_c;
return fn;
}
tree fn = build_library_fn_1 (name, operator_code, type);
TREE_NOTHROW (fn) = TYPE_NOTHROW_P (type);
DECL_CONTEXT (fn) = FROB_CONTEXT (current_namespace);
+ DECL_LANGUAGE (fn) = lang_cplusplus;
set_mangled_name_for_decl (fn);
return fn;
}
/* else we lose. We can only do this if we can use common,
which we can't if it has been initialized. */
- if (TREE_PUBLIC (decl))
- DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
- else
+ if (!TREE_PUBLIC (decl))
{
cp_warning_at ("sorry: semantics of inline function static data `%#D' are wrong (you'll wind up with multiple copies)", decl);
cp_warning_at (" you can work around this by removing the initializer", decl);
/* Set the DECL_ASSEMBLER_NAME for the variable. */
if (asmspec)
- DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
/* We don't create any RTL for local variables. */
if (DECL_FUNCTION_SCOPE_P (decl) && !TREE_STATIC (decl))
defer_p = 1;
}
- /* If we're deferring the variable, just make RTL. Do not actually
- emit the variable. */
- if (defer_p)
+ /* If we're deferring the variable, we only need to make RTL if
+ there's an ASMSPEC. Otherwise, we'll lazily create it later when
+ we need it. (There's no way to lazily create RTL for things that
+ have assembly specs because the information about the specifier
+ isn't stored in the tree, yet) */
+ if (defer_p && asmspec)
make_decl_rtl (decl, asmspec);
/* If we're not deferring, go ahead and assemble the variable. */
- else
+ else if (!defer_p)
rest_of_decl_compilation (decl, asmspec, toplev, at_eof);
}
/* This must override the asm specifier which was placed by
grokclassfn. Lay this out fresh. */
SET_DECL_RTL (TREE_TYPE (decl), NULL_RTX);
- DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (asmspec));
make_decl_rtl (decl, asmspec);
}
if (has_default_arg)
add_defarg_fn (decl);
- /* Plain overloading: will not be grok'd by grokclassfn. */
- if (! ctype && ! processing_template_decl
- && (! DECL_EXTERN_C_P (decl) || DECL_OVERLOADED_OPERATOR_P (decl))
- && ! DECL_USE_TEMPLATE (decl))
- set_mangled_name_for_decl (decl);
-
if (funcdef_flag)
/* Make the init_value nonzero so pushdecl knows this is not
tentative. error_mark_node is replaced later with the BLOCK. */
type = TREE_TYPE (type);
decl = build_lang_decl (VAR_DECL, declarator, type);
DECL_CONTEXT (decl) = basetype;
- /* DECL_ASSEMBLER_NAME is needed only for full-instantiated
- templates. */
- if (!uses_template_parms (decl))
- DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
}
else
{
context = DECL_CONTEXT (decl);
if (declarator && context && current_lang_name != lang_name_c)
- DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
+ /* We can't mangle lazily here because we don't have any
+ way to recover whether or not a variable was `extern
+ "C"' later. */
+ mangle_decl (decl);
}
if (in_namespace)
DECL_NAME (CLASSTYPE_TI_TEMPLATE (type))
= TYPE_IDENTIFIER (type);
- DECL_ASSEMBLER_NAME (decl) = mangle_type (type);
-
/* FIXME remangle member functions; member functions of a
type with external linkage have external linkage. */
}
if (attrs)
cplus_decl_attributes (decl1, NULL_TREE, attrs);
- /* We need to do this even if we aren't expanding yet so that
- assemble_external works. */
- make_decl_rtl (decl1, NULL);
-
/* Promote the value to int before returning it. */
if (C_PROMOTING_INTEGER_TYPE_P (restype))
restype = type_promotes_to (restype);
- /* If this fcn was already referenced via a block-scope `extern' decl
- (or an implicit decl), propagate certain information about the usage. */
- if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl1)))
- TREE_ADDRESSABLE (decl1) = 1;
-
if (DECL_RESULT (decl1) == NULL_TREE)
{
DECL_RESULT (decl1)
tree decl;
{
/* A missing noreturn is ok for the `main' function. */
- return MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl));
+ return DECL_MAIN_P (decl);
}
DECL_ARGUMENTS (function) = last_function_parms;
DECL_CONTEXT (function) = ctype;
+ if (flags == DTOR_FLAG)
+ DECL_DESTRUCTOR_P (function) = 1;
+
if (flags == DTOR_FLAG || DECL_CONSTRUCTOR_P (function))
maybe_retrofit_in_chrg (function);
if (flags == DTOR_FLAG)
{
DECL_DESTRUCTOR_P (function) = 1;
- set_mangled_name_for_decl (function);
TYPE_HAS_DESTRUCTOR (ctype) = 1;
}
- else
- set_mangled_name_for_decl (function);
}
/* Work on the expr used by alignof (this is only called by the parser). */
fndecls = OVL_NEXT (fndecls))
{
fndecl = OVL_CURRENT (fndecls);
- /* The DECL_ASSEMBLER_NAME for a TEMPLATE_DECL, or
- for a for member function of a template class, is
- not mangled, so the check below does not work
- correctly in that case. Since mangled destructor
- names do not include the type of the arguments,
- we can't use this short-cut for them, either.
- (It's not legal to declare arguments for a
- destructor, but some people try.) */
- if (!DECL_DESTRUCTOR_P (function)
- && (DECL_ASSEMBLER_NAME (function)
- != DECL_NAME (function))
- && (DECL_ASSEMBLER_NAME (fndecl)
- != DECL_NAME (fndecl))
- && (DECL_ASSEMBLER_NAME (function)
- == DECL_ASSEMBLER_NAME (fndecl)))
- return fndecl;
/* We cannot simply call decls_match because this
doesn't work for static member functions that are
tree asmspec_tree;
int flags;
{
- const char *asmspec = 0;
-
- if (asmspec_tree)
- asmspec = TREE_STRING_POINTER (asmspec_tree);
-
my_friendly_assert (TREE_PUBLIC (decl), 0);
DECL_CONTEXT (decl) = current_class_type;
decl of our TREE_CHAIN. Instead, we modify cp_finish_decl to do
the right thing, namely, to put this decl out straight away. */
/* current_class_type can be NULL_TREE in case of error. */
- if (!asmspec && current_class_type)
- {
- DECL_INITIAL (decl) = error_mark_node;
- DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
- }
+ if (!asmspec_tree && current_class_type)
+ DECL_INITIAL (decl) = error_mark_node;
+
if (! processing_template_decl)
{
if (!pending_statics)
if (CLASS_TYPE_P (TREE_TYPE (value)))
CLASSTYPE_GOT_SEMICOLON (TREE_TYPE (value)) = 1;
- /* Now that we've updated the context, we need to remangle the
- name for this TYPE_DECL. */
- DECL_ASSEMBLER_NAME (value) = DECL_NAME (value);
- if (!uses_template_parms (value))
- DECL_ASSEMBLER_NAME (value) = mangle_type (TREE_TYPE (value));
-
if (processing_template_decl)
value = push_template_decl (value);
/* This must override the asm specifier which was placed
by grokclassfn. Lay this out fresh. */
SET_DECL_RTL (value, NULL_RTX);
- DECL_ASSEMBLER_NAME (value) = get_identifier (asmspec);
+ SET_DECL_ASSEMBLER_NAME (value, get_identifier (asmspec));
}
cp_finish_decl (value, init, asmspec_tree, flags);
# endif
#endif
-#define GLOBAL_IORD_P(NODE) \
- ! strncmp (IDENTIFIER_POINTER(NODE), GLOBAL_THING, sizeof (GLOBAL_THING) - 1)
-
static void
dump_global_iord (t)
tree t;
{
- const char *name = IDENTIFIER_POINTER (t);
const char *p = NULL;
- if (name [sizeof (GLOBAL_THING) - 1] == 'I')
+ if (DECL_GLOBAL_CTOR_P (t))
p = "initializers";
- else if (name [sizeof (GLOBAL_THING) - 1] == 'D')
+ else if (DECL_GLOBAL_DTOR_P (t))
p = "destructors";
else
my_friendly_abort (352);
/* Fall through. */
case FUNCTION_DECL:
- if (GLOBAL_IORD_P (DECL_ASSEMBLER_NAME (t)))
- dump_global_iord (DECL_ASSEMBLER_NAME (t));
+ if (DECL_GLOBAL_CTOR_P (t) || DECL_GLOBAL_DTOR_P (t))
+ dump_global_iord (t);
else if (! DECL_LANG_SPECIFIC (t))
print_identifier (scratch_buffer, "<internal>");
else
if (TREE_PUBLIC (fn)
&& DECL_EXTERNAL (fn)
+ && DECL_NAMESPACE_SCOPE_P (fn)
&& DECL_EXTERN_C_P (fn))
/* OK */;
else
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
if (DECL_NAME (field) == CL_suffix)
{
- name = mangle_decl (field);
+ mangle_decl (field);
+ name = DECL_ASSEMBLER_NAME (field);
break;
}
if (!field)
if (TREE_CODE (decl) == TYPE_DECL)
write_type (TREE_TYPE (decl));
+ else if (/* The names of `extern "C"' functions are not mangled. */
+ (TREE_CODE (decl) == FUNCTION_DECL
+ /* If there's no DECL_LANG_SPECIFIC, it's a function built
+ by language-independent code, which never builds
+ functions with C++ linkage. */
+ && (!DECL_LANG_SPECIFIC (decl)
+ || DECL_EXTERN_C_FUNCTION_P (decl)))
+ /* The names of global variables aren't mangled either. */
+ || (TREE_CODE (decl) == VAR_DECL
+ && CP_DECL_CONTEXT (decl) == global_namespace))
+ write_string (IDENTIFIER_POINTER (DECL_NAME (decl)));
else
{
write_mangled_name (decl);
/* Create an identifier for the external mangled name of DECL. */
-tree
+void
mangle_decl (decl)
tree decl;
{
- return get_identifier (mangle_decl_string (decl));
+ tree id = get_identifier (mangle_decl_string (decl));
+
+ SET_DECL_ASSEMBLER_NAME (decl, id);
}
/* Generate the mangled representation of TYPE. */
/* There's no need to mangle the name of a template function. */
return;
- DECL_ASSEMBLER_NAME (decl) = mangle_decl (decl);
+ mangle_decl (decl);
}
\f
thunk = build_decl (FUNCTION_DECL, thunk_id, TREE_TYPE (func_decl));
DECL_LANG_SPECIFIC (thunk) = DECL_LANG_SPECIFIC (func_decl);
copy_lang_decl (func_decl);
+ SET_DECL_ASSEMBLER_NAME (thunk, thunk_id);
DECL_CONTEXT (thunk) = DECL_CONTEXT (func_decl);
TREE_READONLY (thunk) = TREE_READONLY (func_decl);
TREE_THIS_VOLATILE (thunk) = TREE_THIS_VOLATILE (func_decl);
DECL_DEFERRED_FN (thunk) = 0;
/* So that finish_file can write out any thunks that need to be: */
pushdecl_top_level (thunk);
+ SET_IDENTIFIER_GLOBAL_VALUE (thunk_id, thunk);
}
return thunk;
}
static void regenerate_decl_from_template PARAMS ((tree, tree));
static tree most_specialized PARAMS ((tree, tree, tree));
static tree most_specialized_class PARAMS ((tree, tree));
-static void set_mangled_name_for_template_decl PARAMS ((tree));
static int template_class_depth_real PARAMS ((tree, int));
static tree tsubst_aggr_type PARAMS ((tree, tree, int, tree, int));
static tree tsubst_decl PARAMS ((tree, tree, tree));
TREE_PRIVATE (decl) = TREE_PRIVATE (gen_tmpl);
TREE_PROTECTED (decl) = TREE_PROTECTED (gen_tmpl);
- /* Mangle the function name appropriately. Note that we do
- not mangle specializations of non-template member
- functions of template classes, e.g. with
-
- template <class T> struct S { void f(); }
-
- and given the specialization
-
- template <> void S<int>::f() {}
-
- we do not mangle S<int>::f() here. That's because it's
- just an ordinary member function and doesn't need special
- treatment. We do this here so that the ordinary,
- non-template, name-mangling algorithm will not be used
- later. */
- if (is_member_template (tmpl) || ctype == NULL_TREE)
- set_mangled_name_for_template_decl (decl);
-
if (is_friend && !have_def)
/* This is not really a declaration of a specialization.
It's just the name of an instantiation. But, it's not
is set up. */
if (TREE_CODE (t) != ENUMERAL_TYPE)
DECL_NAME (type_decl) = classtype_mangled_name (t);
- DECL_ASSEMBLER_NAME (type_decl) = DECL_NAME (type_decl);
if (!is_partial_instantiation)
{
- DECL_ASSEMBLER_NAME (type_decl) = mangle_decl (type_decl);
-
/* For backwards compatibility; code that uses
-fexternal-templates expects looking up a template to
instantiate it. I think DDD still relies on this.
= DECL_SAVED_TREE (DECL_TEMPLATE_RESULT (decl));
}
- /* The mangled name for the NEW_FRIEND is incorrect. The call to
- tsubst will have resulted in a call to
- set_mangled_name_for_template_decl. But, the function is not a
- template instantiation and should not be mangled like one.
- Therefore, we remangle the function name. We don't have to do
- this if the NEW_FRIEND is a template since
- set_mangled_name_for_template_decl doesn't do anything if the
- function declaration still uses template arguments. */
+ /* The mangled name for the NEW_FRIEND is incorrect. The function
+ is not a template instantiation and should not be mangled like
+ one. Therefore, we forget the mangling here; we'll recompute it
+ later if we need it. */
if (TREE_CODE (new_friend) != TEMPLATE_DECL)
{
- set_mangled_name_for_decl (new_friend);
SET_DECL_RTL (new_friend, NULL_RTX);
+ SET_DECL_ASSEMBLER_NAME (new_friend, NULL_TREE);
}
if (DECL_NAMESPACE_SCOPE_P (new_friend))
r = copy_decl (t);
DECL_USE_TEMPLATE (r) = 0;
TREE_TYPE (r) = type;
+ /* Clear out the mangled name and RTL for the instantiation. */
+ SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
+ SET_DECL_RTL (r, NULL_RTX);
DECL_CONTEXT (r) = ctx;
DECL_VIRTUAL_CONTEXT (r)
TREE_CHAIN (DECL_CLONED_FUNCTION (r)) = r;
}
- /* Set up the DECL_TEMPLATE_INFO for R and compute its mangled
- name. There's no need to do this in the special friend
- case mentioned above where GEN_TMPL is NULL. */
+ /* Set up the DECL_TEMPLATE_INFO for R. There's no need to do
+ this in the special friend case mentioned above where
+ GEN_TMPL is NULL. */
if (gen_tmpl)
{
DECL_TEMPLATE_INFO (r)
SET_DECL_IMPLICIT_INSTANTIATION (r);
register_specialization (r, gen_tmpl, argvec);
- /* Set the mangled name for R. */
- if (DECL_DESTRUCTOR_P (t))
- set_mangled_name_for_decl (r);
- else
- {
- /* Instantiations of template functions must be mangled
- specially, in order to conform to 14.5.5.1
- [temp.over.link]. */
- tree tmpl = DECL_TI_TEMPLATE (t);
-
- /* TMPL will be NULL if this is a specialization of a
- member function of a template class. */
- if (tmpl == NULL_TREE
- || (member && !is_member_template (tmpl)
- && !DECL_TEMPLATE_INFO (tmpl)))
- set_mangled_name_for_decl (r);
- else
- set_mangled_name_for_template_decl (r);
- }
-
- SET_DECL_RTL (r, NULL_RTX);
-
- /* Like grokfndecl. If we don't do this, pushdecl will
- mess up our TREE_CHAIN because it doesn't find a
- previous decl. Sigh. */
- if (member
- && ! uses_template_parms (r)
- && (IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r))
- == NULL_TREE))
- SET_IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (r), r);
-
/* We're not supposed to instantiate default arguments
until they are called, for a template. But, for a
declaration like:
TREE_TYPE (r) = type;
c_apply_type_quals_to_decl (CP_TYPE_QUALS (type), r);
DECL_CONTEXT (r) = ctx;
+ /* Clear out the mangled name and RTL for the instantiation. */
+ SET_DECL_ASSEMBLER_NAME (r, NULL_TREE);
+ SET_DECL_RTL (r, NULL_RTX);
/* Don't try to expand the initializer until someone tries to use
this variable; otherwise we run into circular dependencies. */
functions, this is not so. See tsubst_friend_function for
details. */
DECL_TI_TEMPLATE (new_decl) = DECL_TI_TEMPLATE (decl);
- DECL_ASSEMBLER_NAME (new_decl) = DECL_ASSEMBLER_NAME (decl);
+ COPY_DECL_ASSEMBLER_NAME (decl, new_decl);
COPY_DECL_RTL (decl, new_decl);
DECL_USE_TEMPLATE (new_decl) = DECL_USE_TEMPLATE (decl);
return fn_type;
}
-/* Set the DECL_ASSEMBLER_NAME for DECL, which is a FUNCTION_DECL that
- is either an instantiation or specialization of a template
- function. */
-
-static void
-set_mangled_name_for_template_decl (decl)
- tree decl;
-{
- my_friendly_assert (TREE_CODE (decl) == FUNCTION_DECL, 0);
- my_friendly_assert (DECL_TEMPLATE_INFO (decl) != NULL_TREE, 0);
-
- /* Under the new ABI, we don't need special machinery. */
- set_mangled_name_for_decl (decl);
-}
-
/* Return truthvalue if we're processing a template different from
the last one involved in diagnostics. */
int
TREE_PUBLIC (d) = 1;
if (flag_weak || !typeinfo_in_lib_p (d))
comdat_linkage (d);
- DECL_ASSEMBLER_NAME (d) = DECL_NAME (d);
+ SET_DECL_ASSEMBLER_NAME (d, name);
cp_finish_decl (d, NULL_TREE, NULL_TREE, 0);
pushdecl_top_level (d);
comdat_linkage (name_decl);
/* The new ABI specifies the external name of the string
containing the type's name. */
- DECL_ASSEMBLER_NAME (name_decl)
- = mangle_typeinfo_string_for_type (target);
+ SET_DECL_ASSEMBLER_NAME (name_decl,
+ mangle_typeinfo_string_for_type (target));
DECL_INITIAL (name_decl) = name_string;
cp_finish_decl (name_decl, name_string, NULL_TREE, 0);
pushdecl_top_level (name_decl);
if (flag_weak || !typeinfo_in_lib_p (target_type))
comdat_linkage (decl);
}
- DECL_ASSEMBLER_NAME (decl) = name;
+ SET_DECL_ASSEMBLER_NAME (decl, name);
DECL_INITIAL (decl) = init;
cp_finish_decl (decl, init, NULL_TREE, 0);
pushdecl_top_level (decl);
;
else if (DECL_NAME (field) == name)
{
- if ((TREE_CODE(field) == VAR_DECL || TREE_CODE(field) == CONST_DECL)
- && DECL_ASSEMBLER_NAME (field) != NULL)
+ if (TREE_CODE(field) == VAR_DECL
+ && (TREE_STATIC (field) || DECL_EXTERNAL (field)))
GNU_xref_ref(current_function_decl,
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (field)));
return field;
if (return_id != NULL_TREE)
{
if (DECL_NAME (decl) == NULL_TREE)
- {
- DECL_NAME (decl) = return_id;
- DECL_ASSEMBLER_NAME (decl) = return_id;
- }
+ DECL_NAME (decl) = return_id;
else
{
cp_error ("return identifier `%D' already in place", return_id);
make_lang_type_fn = cp_make_lang_type;
lang_unsave = cp_unsave;
lang_statement_code_p = cp_statement_code_p;
+ lang_set_decl_assembler_name = mangle_decl;
list_hash_table = htab_create (31, list_hash, list_hash_eq, NULL);
ggc_add_root (&list_hash_table, 1,
sizeof (list_hash_table),
{
/* This is the "mangled" name of the method.
It encodes the argument types. */
- const char *debug_name =
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+ const char *debug_name;
int show_arg_types = 0;
+ /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
+ include TEMPLATE_DECLs.) The debugger doesn't know what
+ to do with such entities anyhow. */
+ if (TREE_CODE (fndecl) != FUNCTION_DECL)
+ continue;
+
+ debug_name =
+ IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
+
CONTIN;
last = fndecl;
+Mon Mar 19 15:05:39 2001 Mark Mitchell <mark@codesourcery.com>
+
+ * com.c (builtin_function): Use SET_DECL_ASSEMBLER_NAME.
+
Wed Mar 14 09:29:27 2001 Mark Mitchell <mark@codesourcery.com>
* com.c (ffecom_member_phase_2): Use COPY_DECL_RTL,
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
if (library_name)
- DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
make_decl_rtl (decl, NULL_PTR);
pushdecl (decl);
DECL_BUILT_IN_CLASS (decl) = class;
ggc_mark_tree (DECL_RESULT_FLD (t));
ggc_mark_tree (DECL_INITIAL (t));
ggc_mark_tree (DECL_ABSTRACT_ORIGIN (t));
- ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
ggc_mark_tree (DECL_SECTION_NAME (t));
ggc_mark_tree (DECL_MACHINE_ATTRIBUTES (t));
if (DECL_RTL_SET_P (t))
ggc_mark_rtx (DECL_RTL (t));
ggc_mark_rtx (DECL_LIVE_RANGE_RTL (t));
ggc_mark_tree (DECL_VINDEX (t));
+ if (DECL_ASSEMBLER_NAME_SET_P (t))
+ ggc_mark_tree (DECL_ASSEMBLER_NAME (t));
lang_mark_tree (t);
break;
+2001-03-19 Mark Mitchell <mark@codesourcery.com>
+
+ * class.c (build_class_ref): Use SET_DECL_ASSEMBLER_NAME.
+ (layout_class): Likewise.
+ (layout_class_method): Likewise.
+ (emit_register_classes): Likewise.
+ * decl.c (builtin_function): Likewise.
+ (give_name_to_locals): Likewise.
+
2001-03-19 Per Bothner <per@bothner.com>
* jcf-parse.c (load_inner_classes): Check CLASS_LOADED_P
TREE_PUBLIC (decl) = 1;
DECL_IGNORED_P (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
- DECL_ASSEMBLER_NAME (decl) =
- java_mangle_class_field (&temporary_obstack, type);
+ SET_DECL_ASSEMBLER_NAME (decl,
+ java_mangle_class_field
+ (&temporary_obstack, type));
make_decl_rtl (decl, NULL);
pushdecl_top_level (decl);
if (is_compiled == 1)
if (FIELD_STATIC (field))
{
/* Set DECL_ASSEMBLER_NAME to something suitably mangled. */
- DECL_ASSEMBLER_NAME (field) =
- java_mangle_decl (&temporary_obstack, field);
+ SET_DECL_ASSEMBLER_NAME (field,
+ java_mangle_decl
+ (&temporary_obstack, field));
}
}
TREE_PUBLIC (method_decl) = 1;
/* This is a good occasion to mangle the method's name */
- DECL_ASSEMBLER_NAME (method_decl) =
- java_mangle_decl (&temporary_obstack, method_decl);
+ SET_DECL_ASSEMBLER_NAME (method_decl,
+ java_mangle_decl (&temporary_obstack,
+ method_decl));
/* We don't generate a RTL for the method if it's abstract, or if
it's an interface method that isn't clinit. */
if (! METHOD_ABSTRACT (method_decl)
tree t;
init_decl = build_decl (FUNCTION_DECL, init_name, init_type);
- DECL_ASSEMBLER_NAME (init_decl) = init_name;
+ SET_DECL_ASSEMBLER_NAME (init_decl, init_name);
TREE_STATIC (init_decl) = 1;
current_function_decl = init_decl;
DECL_RESULT (init_decl) = build_decl(RESULT_DECL, NULL_TREE, void_type_node);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
if (library_name)
- DECL_ASSEMBLER_NAME (decl) = get_identifier (library_name);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (library_name));
make_decl_rtl (decl, NULL_PTR);
pushdecl (decl);
DECL_BUILT_IN_CLASS (decl) = class;
{
tree decl = TREE_VEC_ELT (decl_map, slot);
DECL_NAME (decl) = name;
- DECL_ASSEMBLER_NAME (decl) = name;
+ SET_DECL_ASSEMBLER_NAME (decl, name);
if (TREE_CODE (decl) != PARM_DECL || TREE_TYPE (decl) != type)
warning ("bad type in parameter debug info");
}
sprintf (buffer, "ARG_%d", arg_i);
DECL_NAME (parm) = get_identifier (buffer);
}
- DECL_ASSEMBLER_NAME (parm) = DECL_NAME (parm);
+ SET_DECL_ASSEMBLER_NAME (parm, DECL_NAME (parm));
}
}
}
TREE_PUBLIC (fndecl) = 1;
#endif
- DECL_ASSEMBLER_NAME (fndecl) = fnname;
DECL_RESULT (fndecl) = build_decl (RESULT_DECL, NULL_TREE, void_type_node);
fndecl = pushdecl (fndecl);
+++ /dev/null
-// Test for proper mangling by setting up name clashes.
-
-#if (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
-#define NAME(OLD, NEW) OLD
-#else
-#define NAME(OLD, NEW) NEW
-#endif /* (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100) */
-
-class A { };
-typedef A A2;
-typedef int I;
-typedef void V;
-typedef I I2;
-
-void f (const A2&, int, const A2&, const A&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0T0, _Z1fRK1AiS1_S1_) = 0; // ERROR - name clash
-
-void f (int, long, int, I) { } // ERROR - name clash
-int NAME (f__Filii, _Z1filii) = 0; // ERROR - name clash
-
-void f (I, float, I, I2) { } // ERROR - name clash
-int NAME (f__Fifii, _Z1fifii) = 0; // ERROR - name clash
-
-void f (void*, float, void*, V*) { } // ERROR - name clash
-int NAME (f__FPvfT0T0, _Z1fPvfS_S_) = 0; // ERROR - name clash
-
-void f (wchar_t) { } // ERROR - name clash
-int NAME (f__Fw, _Z1fw) = 0; // ERROR - name clash
-
-void f(int, A, A2, A) { } // ERROR - name clash
-int NAME (f__FiG1AN21, _Z1fi1AS_S_) = 0; // ERROR - name clash
-
-void f(const A2&, const A2&, const A2&, const A2&,
- int&) { } // ERROR - name clash
-int NAME (f__FRC1AN30Ri, _Z1fRK1AS1_S1_S1_Ri) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&,
- int&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20Ri, _Z1fRK1AiS1_S1_S1_Ri) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&, int&, int&,
- int&) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20RiN25, _Z1fRK1AiS1_S1_S1_RiS2_S2_) = 0; // ERROR - name clash
-
-void f(const A2&, int, const A2&, const A2&, const A2&, int, int,
- int) { } // ERROR - name clash
-int NAME (f__FRC1AiT0N20iii, _Z1fRK1AiS1_S1_S1_iii) = 0; // ERROR - name clash
-
-void f(bool, bool) {} // ERROR - name clash
-int NAME (f__FbT0, _Z1fbb) = 0; // ERROR - name clash
-
-int
-main ()
-{
- return 0;
-}
-
+++ /dev/null
-// Test for overloaded operators in "C" linkage
-// Build don't link:
-
-extern "C" {
-typedef struct b
-{
- int a;
-} c;
-
-extern const c z;
-
-inline bool operator!=(const c& x, const c& y)
-{
- return x.a != y.a;
-}
-};
-
-void foo();
-
-void bar(c x)
-{
- if (x != z)
- foo();
-}
+++ /dev/null
-// Build don't link:
-// Origin: Mark Mitchell <mark@codesourcery.com>
-
-#if (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100)
-#define NAME(OLD, NEW) OLD
-#else
-#define NAME(OLD, NEW) NEW
-#endif /* (!defined (__GXX_ABI_VERSION) || __GXX_ABI_VERSION < 100) */
-
-static unsigned int strlen (const char*) {return 0;} // ERROR - previous declaration
-
-int NAME (strlen__FPCc, _Z6strlenPKc) = 0; // ERROR - duplicate declaration
/* If non-null, these are language-specific helper functions for
unsafe_for_reeval. Return negative to not handle some tree. */
int (*lang_unsafe_for_reeval) PARAMS ((tree));
+
+/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
+ that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
+ appropriate IDENTIFIER_NODE. Otherwise, set it to the
+ ERROR_MARK_NODE to ensure that the assembler does not talk about
+ it. */
+void (*lang_set_decl_assembler_name) PARAMS ((tree));
\f
tree global_trees[TI_MAX];
tree integer_types[itk_none];
\f
+/* Set the DECL_ASSEMBLER_NAME for DECL. */
+void
+set_decl_assembler_name (decl)
+ tree decl;
+{
+ /* The language-independent code should never use the
+ DECL_ASSEMBLER_NAME for lots of DECLs. Only FUNCTION_DECLs and
+ VAR_DECLs for variables with static storage duration need a real
+ DECL_ASSEMBLER_NAME. */
+ if (TREE_CODE (decl) == FUNCTION_DECL
+ || (TREE_CODE (decl) == VAR_DECL
+ && (TREE_STATIC (decl) || DECL_EXTERNAL (decl))))
+ /* By default, assume the name to use in assembly code is the
+ same as that used in the source language. (That's correct
+ for C, and GCC used to set DECL_ASSEMBLER_NAME to the same
+ value as DECL_NAME in build_decl, so this choice provides
+ backwards compatibility with existing front-ends. */
+ SET_DECL_ASSEMBLER_NAME (decl, DECL_NAME (decl));
+ else
+ /* Nobody should ever be asking for the DECL_ASSEMBLER_NAME of
+ these DECLs -- unless they're in language-dependent code, in
+ which case lang_set_decl_assembler_name should handle things. */
+ abort ();
+}
+\f
/* Init the principal obstacks. */
void
ggc_add_root (&type_hash_table, 1, sizeof type_hash_table, mark_type_hash);
ggc_add_tree_root (global_trees, TI_MAX);
ggc_add_tree_root (integer_types, itk_none);
+
+ /* Set lang_set_decl_set_assembler_name to a default value. */
+ lang_set_decl_assembler_name = set_decl_assembler_name;
}
void
as the type can suppress useless errors in the use of this variable. */
DECL_NAME (t) = name;
- DECL_ASSEMBLER_NAME (t) = name;
TREE_TYPE (t) = type;
if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
/* This is the name of the object as written by the user.
It is an IDENTIFIER_NODE. */
#define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
-/* This is the name of the object as the assembler will see it
- (but before any translations made by ASM_OUTPUT_LABELREF).
- Often this is the same as DECL_NAME.
- It is an IDENTIFIER_NODE. */
-#define DECL_ASSEMBLER_NAME(NODE) (DECL_CHECK (NODE)->decl.assembler_name)
+/* The name of the object as the assembler will see it (but before any
+ translations made by ASM_OUTPUT_LABELREF). Often this is the same
+ as DECL_NAME. It is an IDENTIFIER_NODE. */
+#define DECL_ASSEMBLER_NAME(NODE) \
+ ((DECL_ASSEMBLER_NAME_SET_P (NODE) \
+ ? (void) 0 \
+ : (*lang_set_decl_assembler_name) (NODE)), \
+ DECL_CHECK (NODE)->decl.assembler_name)
+/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been
+ set. If zero, the NODE might still have a DECL_ASSEMBLER_NAME --
+ it just hasn't been set yet. */
+#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
+ (DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
+/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
+#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
+ (DECL_CHECK (NODE)->decl.assembler_name = (NAME))
+/* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2. Note that if
+ DECL1's DECL_ASSEMBLER_NAME has not yet been set, using this macro
+ will not cause the DECL_ASSEMBLER_NAME of either DECL to be set.
+ In other words, the semantics of using this macro, are different
+ than saying:
+
+ SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
+
+ which will try to set the DECL_ASSEMBLER_NAME for DECL1. */
+#define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2) \
+ (DECL_ASSEMBLER_NAME_SET_P (DECL1) \
+ ? (void) SET_DECL_ASSEMBLER_NAME (DECL2, \
+ DECL_ASSEMBLER_NAME (DECL1)) \
+ : (void) 0)
+
/* Records the section name in a section attribute. Used to pass
the name from decl_attributes to make_function_rtl and make_decl_rtl. */
#define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
extern tree get_set_constructor_bytes PARAMS ((tree,
unsigned char *, int));
extern tree get_callee_fndecl PARAMS ((tree));
+extern void set_decl_assembler_name PARAMS ((tree));
\f
/* In stmt.c */
/* In c-common.c */
extern HOST_WIDE_INT lang_get_alias_set PARAMS ((tree));
+/* Set the DECL_ASSEMBLER_NAME for a node. If it is the sort of thing
+ that the assembler should talk about, set DECL_ASSEMBLER_NAME to an
+ appropriate IDENTIFIER_NODE. Otherwise, set it to the
+ ERROR_MARK_NODE to ensure that the assembler does not talk about
+ it. */
+extern void (*lang_set_decl_assembler_name) PARAMS ((tree));
+
struct obstack;
/* In tree.c */
if (name != new_name)
{
- DECL_ASSEMBLER_NAME (decl) = get_identifier (new_name);
+ SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
}
projects / gcc.git / commitdiff