tree
current_nonlambda_function (void)
{
tree fn = current_function_decl;
while (fn && LAMBDA_FUNCTION_P (fn))
fn = decl_function_context (fn);
return fn;
}
tree
nonlambda_method_basetype (void)
{
tree fn, type;
if (!current_class_ref)
return NULL_TREE;
type = current_class_type;
if (!LAMBDA_TYPE_P (type))
return type;
/* Find the nearest enclosing non-lambda function. */
fn = TYPE_NAME (type);
do
fn = decl_function_context (fn);
while (fn && LAMBDA_FUNCTION_P (fn));
if (!fn || !DECL_NONSTATIC_MEMBER_FUNCTION_P (fn))
return NULL_TREE;
return TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
}
void
maybe_add_lambda_conv_op (tree type)
{
bool nested = (cfun != NULL);
bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
tree callop = lambda_function (type);
if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type)) != NULL_TREE)
return;
if (processing_template_decl)
return;
bool const generic_lambda_p
= (DECL_TEMPLATE_INFO (callop)
&& DECL_TEMPLATE_RESULT (DECL_TI_TEMPLATE (callop)) == callop);
if (!generic_lambda_p && DECL_INITIAL (callop) == NULL_TREE)
{
/* If the op() wasn't instantiated due to errors, give up. */
gcc_assert (errorcount || sorrycount);
return;
}
/* Non-template conversion operators are defined directly with build_call_a
and using DIRECT_ARGVEC for arguments (including 'this'). Templates are
deferred and the CALL is built in-place. In the case of a deduced return
call op, the decltype expression, DECLTYPE_CALL, used as a substitute for
the return type is also built in-place. The arguments of DECLTYPE_CALL in
the return expression may differ in flags from those in the body CALL. In
particular, parameter pack expansions are marked PACK_EXPANSION_LOCAL_P in
the body CALL, but not in DECLTYPE_CALL. */
vec<tree, va_gc> *direct_argvec = 0;
tree decltype_call = 0, call = 0;
tree fn_result = TREE_TYPE (TREE_TYPE (callop));
if (generic_lambda_p)
{
/* Prepare the dependent member call for the static member function
'_FUN' and, potentially, prepare another call to be used in a decltype
return expression for a deduced return call op to allow for simple
implementation of the conversion operator. */
tree instance = build_nop (type, null_pointer_node);
tree objfn = build_min (COMPONENT_REF, NULL_TREE,
instance, DECL_NAME (callop), NULL_TREE);
int nargs = list_length (DECL_ARGUMENTS (callop)) - 1;
call = prepare_op_call (objfn, nargs);
if (type_uses_auto (fn_result))
decltype_call = prepare_op_call (objfn, nargs);
}
else
{
direct_argvec = make_tree_vector ();
direct_argvec->quick_push (build1 (NOP_EXPR,
TREE_TYPE (DECL_ARGUMENTS (callop)),
null_pointer_node));
}
/* Copy CALLOP's argument list (as per 'copy_list') as FN_ARGS in order to
declare the static member function "_FUN" below. For each arg append to
DIRECT_ARGVEC (for the non-template case) or populate the pre-allocated
call args (for the template case). If a parameter pack is found, expand
it, flagging it as PACK_EXPANSION_LOCAL_P for the body call. */
tree fn_args = NULL_TREE;
{
int ix = 0;
tree src = DECL_CHAIN (DECL_ARGUMENTS (callop));
tree tgt;
while (src)
{
tree new_node = copy_node (src);
if (!fn_args)
fn_args = tgt = new_node;
else
{
TREE_CHAIN (tgt) = new_node;
tgt = new_node;
}
mark_exp_read (tgt);
if (generic_lambda_p)
{
if (DECL_PACK_P (tgt))
{
tree a = make_pack_expansion (tgt);
if (decltype_call)
CALL_EXPR_ARG (decltype_call, ix) = copy_node (a);
PACK_EXPANSION_LOCAL_P (a) = true;
CALL_EXPR_ARG (call, ix) = a;
}
else
{
tree a = convert_from_reference (tgt);
CALL_EXPR_ARG (call, ix) = a;
if (decltype_call)
CALL_EXPR_ARG (decltype_call, ix) = copy_node (a);
}
++ix;
}
else
vec_safe_push (direct_argvec, tgt);
src = TREE_CHAIN (src);
}
}
if (generic_lambda_p)
{
if (decltype_call)
{
++processing_template_decl;
fn_result = finish_decltype_type
(decltype_call, /*id_expression_or_member_access_p=*/false,
tf_warning_or_error);
--processing_template_decl;
}
}
else
call = build_call_a (callop,
direct_argvec->length (),
direct_argvec->address ());
CALL_FROM_THUNK_P (call) = 1;
tree stattype = build_function_type (fn_result, FUNCTION_ARG_CHAIN (callop));
/* First build up the conversion op. */
tree rettype = build_pointer_type (stattype);
tree name = mangle_conv_op_name_for_type (rettype);
tree thistype = cp_build_qualified_type (type, TYPE_QUAL_CONST);
tree fntype = build_method_type_directly (thistype, rettype, void_list_node);
tree convfn = build_lang_decl (FUNCTION_DECL, name, fntype);
tree fn = convfn;
DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
&& DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
SET_OVERLOADED_OPERATOR_CODE (fn, TYPE_EXPR);
grokclassfn (type, fn, NO_SPECIAL);
set_linkage_according_to_type (type, fn);
rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
DECL_IN_AGGR_P (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
DECL_NOT_REALLY_EXTERN (fn) = 1;
DECL_DECLARED_INLINE_P (fn) = 1;
DECL_ARGUMENTS (fn) = build_this_parm (fntype, TYPE_QUAL_CONST);
if (nested_def)
DECL_INTERFACE_KNOWN (fn) = 1;
if (generic_lambda_p)
fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
add_method (type, fn, NULL_TREE);
/* Generic thunk code fails for varargs; we'll complain in mark_used if
the conversion op is used. */
if (varargs_function_p (callop))
{
DECL_DELETED_FN (fn) = 1;
return;
}
/* Now build up the thunk to be returned. */
name = get_identifier ("_FUN");
tree statfn = build_lang_decl (FUNCTION_DECL, name, stattype);
fn = statfn;
DECL_SOURCE_LOCATION (fn) = DECL_SOURCE_LOCATION (callop);
if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn
&& DECL_ALIGN (fn) < 2 * BITS_PER_UNIT)
DECL_ALIGN (fn) = 2 * BITS_PER_UNIT;
grokclassfn (type, fn, NO_SPECIAL);
set_linkage_according_to_type (type, fn);
rest_of_decl_compilation (fn, toplevel_bindings_p (), at_eof);
DECL_IN_AGGR_P (fn) = 1;
DECL_ARTIFICIAL (fn) = 1;
DECL_NOT_REALLY_EXTERN (fn) = 1;
DECL_DECLARED_INLINE_P (fn) = 1;
DECL_STATIC_FUNCTION_P (fn) = 1;
DECL_ARGUMENTS (fn) = fn_args;
for (tree arg = fn_args; arg; arg = DECL_CHAIN (arg))
{
/* Avoid duplicate -Wshadow warnings. */
DECL_NAME (arg) = NULL_TREE;
DECL_CONTEXT (arg) = fn;
}
if (nested_def)
DECL_INTERFACE_KNOWN (fn) = 1;
if (generic_lambda_p)
fn = add_inherited_template_parms (fn, DECL_TI_TEMPLATE (callop));
add_method (type, fn, NULL_TREE);
if (nested)
push_function_context ();
else
/* Still increment function_depth so that we don't GC in the
middle of an expression. */
++function_depth;
/* Generate the body of the thunk. */
start_preparsed_function (statfn, NULL_TREE,
SF_PRE_PARSED | SF_INCLASS_INLINE);
if (DECL_ONE_ONLY (statfn))
{
/* Put the thunk in the same comdat group as the call op. */
cgraph_node::get_create (statfn)->add_to_same_comdat_group
(cgraph_node::get_create (callop));
}
tree body = begin_function_body ();
tree compound_stmt = begin_compound_stmt (0);
if (!generic_lambda_p)
{
set_flags_from_callee (call);
if (MAYBE_CLASS_TYPE_P (TREE_TYPE (call)))
call = build_cplus_new (TREE_TYPE (call), call, tf_warning_or_error);
}
call = convert_from_reference (call);
finish_return_stmt (call);
finish_compound_stmt (compound_stmt);
finish_function_body (body);
fn = finish_function (/*inline*/2);
if (!generic_lambda_p)
expand_or_defer_fn (fn);
/* Generate the body of the conversion op. */
start_preparsed_function (convfn, NULL_TREE,
SF_PRE_PARSED | SF_INCLASS_INLINE);
body = begin_function_body ();
compound_stmt = begin_compound_stmt (0);
/* decl_needed_p needs to see that it's used. */
TREE_USED (statfn) = 1;
finish_return_stmt (decay_conversion (statfn, tf_warning_or_error));
finish_compound_stmt (compound_stmt);
finish_function_body (body);
fn = finish_function (/*inline*/2);
if (!generic_lambda_p)
expand_or_defer_fn (fn);
if (nested)
pop_function_context ();
else
--function_depth;
}
tree
lambda_expr_this_capture (tree lambda, bool add_capture_p)
{
tree result;
tree this_capture = LAMBDA_EXPR_THIS_CAPTURE (lambda);
/* In unevaluated context this isn't an odr-use, so don't capture. */
if (cp_unevaluated_operand)
add_capture_p = false;
/* Try to default capture 'this' if we can. */
if (!this_capture
&& (!add_capture_p
|| LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lambda) != CPLD_NONE))
{
tree lambda_stack = NULL_TREE;
tree init = NULL_TREE;
/* If we are in a lambda function, we can move out until we hit:
1. a non-lambda function or NSDMI,
2. a lambda function capturing 'this', or
3. a non-default capturing lambda function. */
for (tree tlambda = lambda; ;)
{
lambda_stack = tree_cons (NULL_TREE,
tlambda,
lambda_stack);
if (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)
&& TREE_CODE (LAMBDA_EXPR_EXTRA_SCOPE (tlambda)) == FIELD_DECL)
{
/* In an NSDMI, we don't have a function to look up the decl in,
but the fake 'this' pointer that we're using for parsing is
in scope_chain. */
init = scope_chain->x_current_class_ptr;
gcc_checking_assert
(init && (TREE_TYPE (TREE_TYPE (init))
== current_nonlambda_class_type ()));
break;
}
tree closure_decl = TYPE_NAME (LAMBDA_EXPR_CLOSURE (tlambda));
tree containing_function = decl_function_context (closure_decl);
if (containing_function == NULL_TREE)
/* We ran out of scopes; there's no 'this' to capture. */
break;
if (!LAMBDA_FUNCTION_P (containing_function))
{
/* We found a non-lambda function. */
if (DECL_NONSTATIC_MEMBER_FUNCTION_P (containing_function))
/* First parameter is 'this'. */
init = DECL_ARGUMENTS (containing_function);
break;
}
tlambda
= CLASSTYPE_LAMBDA_EXPR (DECL_CONTEXT (containing_function));
if (LAMBDA_EXPR_THIS_CAPTURE (tlambda))
{
/* An outer lambda has already captured 'this'. */
init = LAMBDA_EXPR_THIS_CAPTURE (tlambda);
break;
}
if (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (tlambda) == CPLD_NONE)
/* An outer lambda won't let us capture 'this'. */
break;
}
if (init)
{
if (add_capture_p)
this_capture = add_default_capture (lambda_stack,
/*id=*/this_identifier,
init);
else
this_capture = init;
}
}
if (cp_unevaluated_operand)
result = this_capture;
else if (!this_capture)
{
if (add_capture_p)
{
error ("%<this%> was not captured for this lambda function");
result = error_mark_node;
}
else
result = NULL_TREE;
}
else
{
/* To make sure that current_class_ref is for the lambda. */
gcc_assert (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref))
== LAMBDA_EXPR_CLOSURE (lambda));
result = this_capture;
/* If 'this' is captured, each use of 'this' is transformed into an
access to the corresponding unnamed data member of the closure
type cast (_expr.cast_ 5.4) to the type of 'this'. [ The cast
ensures that the transformed expression is an rvalue. ] */
result = rvalue (result);
}
return result;
}
int
is_friend (tree type, tree supplicant)
{
int declp;
tree list;
tree context;
if (supplicant == NULL_TREE || type == NULL_TREE)
return 0;
declp = DECL_P (supplicant);
if (declp)
/* It's a function decl. */
{
tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
tree name = DECL_NAME (supplicant);
for (; list ; list = TREE_CHAIN (list))
{
if (name == FRIEND_NAME (list))
{
tree friends = FRIEND_DECLS (list);
for (; friends ; friends = TREE_CHAIN (friends))
{
tree this_friend = TREE_VALUE (friends);
if (this_friend == NULL_TREE)
continue;
if (supplicant == this_friend)
return 1;
if (is_specialization_of_friend (supplicant, this_friend))
return 1;
}
break;
}
}
}
else
/* It's a type. */
{
if (same_type_p (supplicant, type))
return 1;
list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
for (; list ; list = TREE_CHAIN (list))
{
tree t = TREE_VALUE (list);
if (TREE_CODE (t) == TEMPLATE_DECL ?
is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
same_type_p (supplicant, t))
return 1;
}
}
if (declp)
{
if (DECL_FUNCTION_MEMBER_P (supplicant))
context = DECL_CONTEXT (supplicant);
else
context = NULL_TREE;
}
else
{
if (TYPE_CLASS_SCOPE_P (supplicant))
/* Nested classes get the same access as their enclosing types, as
per DR 45 (this is a change from the standard). */
context = TYPE_CONTEXT (supplicant);
else
/* Local classes have the same access as the enclosing function. */
context = decl_function_context (TYPE_MAIN_DECL (supplicant));
}
/* A namespace is not friend to anybody. */
if (context && TREE_CODE (context) == NAMESPACE_DECL)
context = NULL_TREE;
if (context)
return is_friend (type, context);
return 0;
}
void
sdbout_symbol (tree decl, int local)
{
tree type = TREE_TYPE (decl);
tree context = NULL_TREE;
rtx value;
int regno = -1;
const char *name;
/* If we are called before sdbout_init is run, just save the symbol
for later. */
if (!sdbout_initialized)
{
preinit_symbols = tree_cons (0, decl, preinit_symbols);
return;
}
sdbout_one_type (type);
switch (TREE_CODE (decl))
{
case CONST_DECL:
/* Enum values are defined by defining the enum type. */
return;
case FUNCTION_DECL:
/* Don't mention a nested function under its parent. */
context = decl_function_context (decl);
if (context == current_function_decl)
return;
/* Check DECL_INITIAL to distinguish declarations from definitions.
Don't output debug info here for declarations; they will have
a DECL_INITIAL value of 0. */
if (! DECL_INITIAL (decl))
return;
if (!MEM_P (DECL_RTL (decl))
|| GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
return;
PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
break;
case TYPE_DECL:
/* Done with tagged types. */
if (DECL_NAME (decl) == 0)
return;
if (DECL_IGNORED_P (decl))
return;
/* Don't output intrinsic types. GAS chokes on SDB .def
statements that contain identifiers with embedded spaces
(eg "unsigned long"). */
if (DECL_IS_BUILTIN (decl))
return;
/* Output typedef name. */
if (template_name_p (DECL_NAME (decl)))
PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
else
PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
PUT_SDB_SCL (C_TPDEF);
break;
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by sdbout_reg_parms and sdbout_parms. */
gcc_unreachable ();
case VAR_DECL:
/* Don't mention a variable that is external.
Let the file that defines it describe it. */
if (DECL_EXTERNAL (decl))
return;
/* Ignore __FUNCTION__, etc. */
if (DECL_IGNORED_P (decl))
return;
/* If there was an error in the declaration, don't dump core
if there is no RTL associated with the variable doesn't
exist. */
if (!DECL_RTL_SET_P (decl))
return;
SET_DECL_RTL (decl,
eliminate_regs (DECL_RTL (decl), VOIDmode, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (crtl->uses_only_leaf_regs)
leaf_renumber_regs_insn (DECL_RTL (decl));
#endif
value = DECL_RTL (decl);
/* Don't mention a variable at all
if it was completely optimized into nothingness.
If DECL was from an inline function, then its rtl
is not identically the rtl that was used in this
particular compilation. */
if (REG_P (value))
{
regno = REGNO (value);
if (regno >= FIRST_PSEUDO_REGISTER)
return;
}
else if (GET_CODE (value) == SUBREG)
{
while (GET_CODE (value) == SUBREG)
value = SUBREG_REG (value);
if (REG_P (value))
{
if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
return;
}
regno = REGNO (alter_subreg (&value));
SET_DECL_RTL (decl, value);
}
/* Don't output anything if an auto variable
gets RTL that is static.
GAS version 2.2 can't handle such output. */
else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0))
&& ! TREE_STATIC (decl))
return;
/* Emit any structure, union, or enum type that has not been output.
This occurs for tag-less structs (et al) used to declare variables
within functions. */
if (TREE_CODE (type) == ENUMERAL_TYPE
|| TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
{
if (COMPLETE_TYPE_P (type) /* not a forward reference */
&& KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
sdbout_one_type (type);
}
/* Defer SDB information for top-level initialized variables! */
if (! local
&& MEM_P (value)
&& DECL_INITIAL (decl))
return;
/* C++ in 2.3 makes nameless symbols. That will be fixed later.
For now, avoid crashing. */
if (DECL_NAME (decl) == NULL_TREE)
return;
/* Record the name for, starting a symtab entry. */
if (local)
name = IDENTIFIER_POINTER (DECL_NAME (decl));
else
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
if (MEM_P (value)
&& GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
{
PUT_SDB_DEF (name);
if (TREE_PUBLIC (decl))
{
PUT_SDB_VAL (XEXP (value, 0));
PUT_SDB_SCL (C_EXT);
}
else
{
PUT_SDB_VAL (XEXP (value, 0));
PUT_SDB_SCL (C_STAT);
}
}
else if (regno >= 0)
{
PUT_SDB_DEF (name);
PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
PUT_SDB_SCL (C_REG);
}
else if (MEM_P (value)
&& (MEM_P (XEXP (value, 0))
|| (REG_P (XEXP (value, 0))
&& REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
/* If the value is indirect by memory or by a register
that isn't the frame pointer
then it means the object is variable-sized and address through
that register or stack slot. COFF has no way to represent this
so all we can do is output the variable as a pointer. */
{
PUT_SDB_DEF (name);
if (REG_P (XEXP (value, 0)))
{
PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
PUT_SDB_SCL (C_REG);
}
else
{
/* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
(CONST_INT...)))).
We want the value of that CONST_INT. */
/* Encore compiler hates a newline in a macro arg, it seems. */
PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
(XEXP (XEXP (value, 0), 0)));
PUT_SDB_SCL (C_AUTO);
}
/* Effectively do build_pointer_type, but don't cache this type,
since it might be temporary whereas the type it points to
might have been saved for inlining. */
/* Don't use REFERENCE_TYPE because dbx can't handle that. */
type = make_node (POINTER_TYPE);
TREE_TYPE (type) = TREE_TYPE (decl);
}
else if (MEM_P (value)
&& ((GET_CODE (XEXP (value, 0)) == PLUS
&& REG_P (XEXP (XEXP (value, 0), 0))
&& CONST_INT_P (XEXP (XEXP (value, 0), 1)))
/* This is for variables which are at offset zero from
the frame pointer. This happens on the Alpha.
Non-frame pointer registers are excluded above. */
|| (REG_P (XEXP (value, 0)))))
{
/* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
or (MEM (REG...)). We want the value of that CONST_INT
or zero. */
PUT_SDB_DEF (name);
PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
PUT_SDB_SCL (C_AUTO);
}
else
{
/* It is something we don't know how to represent for SDB. */
return;
}
break;
default:
break;
}
PUT_SDB_TYPE (plain_type (type));
PUT_SDB_ENDEF;
}
static int
avm2_function_regparm (tree type, tree decl)
{
tree attr;
/* APPLE LOCAL begin MERGE FIXME audit to ensure that it's ok
We had local_regparm but the FSF didn't and there didn't seem to
be a merge conflict some something is strange. These seem to be just
normal apple local changes. I asked Stuart about them in email. */
int regparm = avm2_regparm;
bool user_convention = false;
if (1)
{
attr = lookup_attribute ("regparm", TYPE_ATTRIBUTES (type));
if (attr)
{
regparm = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (attr)));
user_convention = true;
}
/* APPLE LOCAL begin regparmandstackparm */
if (lookup_attribute ("fastcall", TYPE_ATTRIBUTES (type))
|| lookup_attribute ("regparmandstackparmee", TYPE_ATTRIBUTES (type)))
/* APPLE LOCAL end regparmandstackparm */
{
regparm = 2;
user_convention = true;
}
/* Use register calling convention for local functions when possible. */
if (!user_convention && decl
&& flag_unit_at_a_time && !profile_flag)
{
struct cgraph_local_info *i = cgraph_local_info (decl);
if (i && i->local)
{
int local_regparm, globals = 0, regno;
/* Make sure no regparm register is taken by a global register
variable. */
for (local_regparm = 0; local_regparm < 3; local_regparm++)
if (global_regs[local_regparm])
break;
/* We can't use regparm(3) for nested functions as these use
static chain pointer in third argument. */
if (local_regparm == 3
/* APPLE LOCAL begin mainline */
&& (decl_function_context (decl))
/* APPLE LOCAL end mainline */
&& !DECL_NO_STATIC_CHAIN (decl))
local_regparm = 2;
/* If the function realigns its stackpointer, the
prologue will clobber %ecx. If we've already
generated code for the callee, the callee
DECL_STRUCT_FUNCTION is gone, so we fall back to
scanning the attributes for the self-realigning
property. */
if (false)
local_regparm = 2;
/* Each global register variable increases register preassure,
so the more global reg vars there are, the smaller regparm
optimization use, unless requested by the user explicitly. */
for (regno = 0; regno < 6; regno++)
if (global_regs[regno])
globals++;
local_regparm
= globals < local_regparm ? local_regparm - globals : 0;
if (local_regparm > regparm)
regparm = local_regparm;
}
}
}
/* APPLE LOCAL end MERGE FIXME audit to ensure that it's ok */
return regparm;
}
void
synthesize_method (tree fndecl)
{
bool nested = (current_function_decl != NULL_TREE);
tree context = decl_function_context (fndecl);
bool need_body = true;
tree stmt;
location_t save_input_location = input_location;
int error_count = errorcount;
int warning_count = warningcount;
/* Reset the source location, we might have been previously
deferred, and thus have saved where we were first needed. */
DECL_SOURCE_LOCATION (fndecl)
= DECL_SOURCE_LOCATION (TYPE_NAME (DECL_CONTEXT (fndecl)));
/* If we've been asked to synthesize a clone, just synthesize the
cloned function instead. Doing so will automatically fill in the
body for the clone. */
if (DECL_CLONED_FUNCTION_P (fndecl))
fndecl = DECL_CLONED_FUNCTION (fndecl);
/* We may be in the middle of deferred access check. Disable
it now. */
push_deferring_access_checks (dk_no_deferred);
if (! context)
push_to_top_level ();
else if (nested)
push_function_context_to (context);
input_location = DECL_SOURCE_LOCATION (fndecl);
start_preparsed_function (fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
stmt = begin_function_body ();
if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
{
do_build_assign_ref (fndecl);
need_body = false;
}
else if (DECL_CONSTRUCTOR_P (fndecl))
{
tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
if (arg_chain != void_list_node)
do_build_copy_constructor (fndecl);
else
finish_mem_initializers (NULL_TREE);
}
/* If we haven't yet generated the body of the function, just
generate an empty compound statement. */
if (need_body)
{
tree compound_stmt;
compound_stmt = begin_compound_stmt (BCS_FN_BODY);
finish_compound_stmt (compound_stmt);
}
finish_function_body (stmt);
expand_or_defer_fn (finish_function (0));
input_location = save_input_location;
if (! context)
pop_from_top_level ();
else if (nested)
pop_function_context_from (context);
pop_deferring_access_checks ();
if (error_count != errorcount || warning_count != warningcount)
inform ("%Hsynthesized method %qD first required here ",
&input_location, fndecl);
}
void
synthesize_method (tree fndecl)
{
bool nested = (current_function_decl != NULL_TREE);
tree context = decl_function_context (fndecl);
bool need_body = true;
tree stmt;
if (at_eof)
import_export_decl (fndecl);
/* If we've been asked to synthesize a clone, just synthesize the
cloned function instead. Doing so will automatically fill in the
body for the clone. */
if (DECL_CLONED_FUNCTION_P (fndecl))
{
synthesize_method (DECL_CLONED_FUNCTION (fndecl));
return;
}
/* We may be in the middle of deferred access check. Disable
it now. */
push_deferring_access_checks (dk_no_deferred);
if (! context)
push_to_top_level ();
else if (nested)
push_function_context_to (context);
/* Put the function definition at the position where it is needed,
rather than within the body of the class. That way, an error
during the generation of the implicit body points at the place
where the attempt to generate the function occurs, giving the
user a hint as to why we are attempting to generate the
function. */
DECL_SOURCE_LOCATION (fndecl) = input_location;
interface_unknown = 1;
start_function (NULL_TREE, fndecl, NULL_TREE, SF_DEFAULT | SF_PRE_PARSED);
clear_last_expr ();
stmt = begin_function_body ();
if (DECL_OVERLOADED_OPERATOR_P (fndecl) == NOP_EXPR)
{
do_build_assign_ref (fndecl);
need_body = false;
}
else if (DECL_CONSTRUCTOR_P (fndecl))
{
tree arg_chain = FUNCTION_FIRST_USER_PARMTYPE (fndecl);
if (arg_chain != void_list_node)
do_build_copy_constructor (fndecl);
else if (TYPE_NEEDS_CONSTRUCTING (current_class_type))
finish_mem_initializers (NULL_TREE);
}
/* If we haven't yet generated the body of the function, just
generate an empty compound statement. */
if (need_body)
{
tree compound_stmt;
compound_stmt = begin_compound_stmt (/*has_no_scope=*/false);
finish_compound_stmt (compound_stmt);
}
finish_function_body (stmt);
expand_or_defer_fn (finish_function (0));
extract_interface_info ();
if (! context)
pop_from_top_level ();
else if (nested)
pop_function_context_from (context);
pop_deferring_access_checks ();
}
