1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/* Declarations and data types for RTL call insn generation.
Copyright (C) 2013-2019 Free Software Foundation, Inc.
This file is part of GCC.
GCC 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 3, or (at your option) any later
version.
GCC 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 GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#ifndef GCC_CALLS_H
#define GCC_CALLS_H
/* Describes a function argument.
Each argument conceptually has a gimple-level type. Usually this type
is available directly as a tree via the TYPE field, but when calling
libgcc support functions it might instead be inferred from a mode,
in which case the type isn't available directly.
This gimple-level type might go through promotion before being passed to
the target function. Depending on the context, the MODE field is either
the mode of the gimple-level type (whether explicitly given or not)
or the mode after promotion has been performed. */
class function_arg_info
{
public:
function_arg_info () : type (NULL_TREE), mode (VOIDmode), named (false) {}
/* Initialize an argument of mode MODE, either before or after promotion. */
function_arg_info (machine_mode mode, bool named)
: type (NULL_TREE), mode (mode), named (named)
{}
/* Initialize an unpromoted argument of type TYPE. */
function_arg_info (tree type, bool named)
: type (type), mode (TYPE_MODE (type)), named (named)
{}
/* Initialize an argument with explicit properties. */
function_arg_info (tree type, machine_mode mode, bool named)
: type (type), mode (mode), named (named)
{}
/* Return true if the gimple-level type is an aggregate. */
bool aggregate_type_p () const { return type && AGGREGATE_TYPE_P (type); }
/* Return the size of the gimple-level type, or -1 if the size is
variable or otherwise not representable as a poly_int64.
Use this function when MODE is the mode of the type before promotion,
or in any context if the target never promotes function arguments. */
poly_int64 type_size_in_bytes () const
{
if (type)
return int_size_in_bytes (type);
return GET_MODE_SIZE (mode);
}
/* Return the size of the argument after promotion, or -1 if the size
is variable or otherwise not representable as a poly_int64.
Use this function when MODE is the mode of the type after promotion. */
poly_int64 promoted_size_in_bytes () const
{
if (mode == BLKmode)
return int_size_in_bytes (type);
return GET_MODE_SIZE (mode);
}
/* The type of the argument, or null if not known (which is true for
libgcc support functions). */
tree type;
/* The mode of the argument. Depending on context, this might be
the mode of the argument type or the mode after promotion. */
machine_mode mode;
/* True if the argument is treated as a named argument, false if it is
treated as an unnamed variadic argument (i.e. one passed through
"..."). See also TARGET_STRICT_ARGUMENT_NAMING. */
unsigned int named : 1;
};
extern int flags_from_decl_or_type (const_tree);
extern int call_expr_flags (const_tree);
extern int setjmp_call_p (const_tree);
extern bool gimple_maybe_alloca_call_p (const gimple *);
extern bool gimple_alloca_call_p (const gimple *);
extern bool alloca_call_p (const_tree);
extern bool must_pass_in_stack_var_size (machine_mode, const_tree);
extern bool must_pass_in_stack_var_size_or_pad (machine_mode, const_tree);
extern bool must_pass_va_arg_in_stack (tree);
extern rtx prepare_call_address (tree, rtx, rtx, rtx *, int, int);
extern bool shift_return_value (machine_mode, bool, rtx);
extern rtx expand_call (tree, rtx, int);
extern void fixup_tail_calls (void);
extern bool pass_by_reference (CUMULATIVE_ARGS *, machine_mode,
tree, bool);
extern bool pass_va_arg_by_reference (tree);
extern bool reference_callee_copied (CUMULATIVE_ARGS *, machine_mode,
tree, bool);
extern void maybe_warn_alloc_args_overflow (tree, tree, tree[2], int[2]);
extern tree get_attr_nonstring_decl (tree, tree * = NULL);
extern void maybe_warn_nonstring_arg (tree, tree);
extern bool get_size_range (tree, tree[2], bool = false);
extern rtx rtx_for_static_chain (const_tree, bool);
#endif // GCC_CALLS_H
|