]>
Commit | Line | Data |
---|---|---|
dbb0cd11 | 1 | /* Definitions for code generation pass of GNU compiler. |
711789cc | 2 | Copyright (C) 1987-2013 Free Software Foundation, Inc. |
dbb0cd11 | 3 | |
f12b58b3 | 4 | This file is part of GCC. |
dbb0cd11 | 5 | |
f12b58b3 | 6 | GCC is free software; you can redistribute it and/or modify it under |
7 | the terms of the GNU General Public License as published by the Free | |
8c4c00c1 | 8 | Software Foundation; either version 3, or (at your option) any later |
f12b58b3 | 9 | version. |
dbb0cd11 | 10 | |
f12b58b3 | 11 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
12 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 | for more details. | |
dbb0cd11 | 15 | |
16 | You should have received a copy of the GNU General Public License | |
8c4c00c1 | 17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
dbb0cd11 | 19 | |
4c74e6d9 | 20 | #ifndef GCC_EXPR_H |
21 | #define GCC_EXPR_H | |
22 | ||
23 | /* For inhibit_defer_pop */ | |
24 | #include "function.h" | |
25 | /* For XEXP, GEN_INT, rtx_code */ | |
26 | #include "rtl.h" | |
27 | /* For optimize_size */ | |
28 | #include "flags.h" | |
cc493011 | 29 | /* For host_integerp, tree_low_cst, fold_convert, size_binop, ssize_int, |
30 | TREE_CODE, TYPE_SIZE, int_size_in_bytes, */ | |
31 | #include "tree-core.h" | |
4c74e6d9 | 32 | /* For GET_MODE_BITSIZE, word_mode */ |
33 | #include "machmode.h" | |
34 | ||
dbb0cd11 | 35 | /* This is the 4th arg to `expand_expr'. |
a35a63ff | 36 | EXPAND_STACK_PARM means we are possibly expanding a call param onto |
6cf92966 | 37 | the stack. |
dbb0cd11 | 38 | EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. |
39 | EXPAND_INITIALIZER is similar but also record any labels on forced_labels. | |
40 | EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address | |
ab716090 | 41 | is a constant that is not a legitimate address. |
68b956ae | 42 | EXPAND_WRITE means we are only going to write to the resulting rtx. |
43 | EXPAND_MEMORY means we are interested in a memory result, even if | |
44 | the memory is constant and we could have propagated a constant value. */ | |
6cf92966 | 45 | enum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM, EXPAND_SUM, |
68b956ae | 46 | EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE, |
47 | EXPAND_MEMORY}; | |
dbb0cd11 | 48 | |
b49854c6 | 49 | /* Prevent the compiler from deferring stack pops. See |
50 | inhibit_defer_pop for more information. */ | |
51 | #define NO_DEFER_POP (inhibit_defer_pop += 1) | |
52 | ||
53 | /* Allow the compiler to defer stack pops. See inhibit_defer_pop for | |
54 | more information. */ | |
55 | #define OK_DEFER_POP (inhibit_defer_pop -= 1) | |
dbb0cd11 | 56 | \f |
241399f6 | 57 | enum direction {none, upward, downward}; |
58 | ||
dbb0cd11 | 59 | /* Structure to record the size of a sequence of arguments |
902de8ed | 60 | as the sum of a tree-expression and a constant. This structure is |
61 | also used to store offsets from the stack, which might be negative, | |
62 | so the variable part must be ssizetype, not sizetype. */ | |
dbb0cd11 | 63 | |
64 | struct args_size | |
65 | { | |
997d68fe | 66 | HOST_WIDE_INT constant; |
dbb0cd11 | 67 | tree var; |
68 | }; | |
241399f6 | 69 | |
70 | /* Package up various arg related fields of struct args for | |
71 | locate_and_pad_parm. */ | |
72 | struct locate_and_pad_arg_data | |
73 | { | |
74 | /* Size of this argument on the stack, rounded up for any padding it | |
75 | gets. If REG_PARM_STACK_SPACE is defined, then register parms are | |
76 | counted here, otherwise they aren't. */ | |
77 | struct args_size size; | |
78 | /* Offset of this argument from beginning of stack-args. */ | |
79 | struct args_size offset; | |
80 | /* Offset to the start of the stack slot. Different from OFFSET | |
81 | if this arg pads downward. */ | |
82 | struct args_size slot_offset; | |
83 | /* The amount that the stack pointer needs to be adjusted to | |
84 | force alignment for the next argument. */ | |
85 | struct args_size alignment_pad; | |
5f4cd670 | 86 | /* Which way we should pad this arg. */ |
87 | enum direction where_pad; | |
c5dc0c32 | 88 | /* slot_offset is at least this aligned. */ |
89 | unsigned int boundary; | |
241399f6 | 90 | }; |
dbb0cd11 | 91 | |
92 | /* Add the value of the tree INC to the `struct args_size' TO. */ | |
93 | ||
535664e3 | 94 | #define ADD_PARM_SIZE(TO, INC) \ |
95 | do { \ | |
96 | tree inc = (INC); \ | |
35ec552a | 97 | if (tree_fits_shwi_p (inc)) \ |
535664e3 | 98 | (TO).constant += tree_low_cst (inc, 0); \ |
99 | else if ((TO).var == 0) \ | |
100 | (TO).var = fold_convert (ssizetype, inc); \ | |
101 | else \ | |
102 | (TO).var = size_binop (PLUS_EXPR, (TO).var, \ | |
103 | fold_convert (ssizetype, inc)); \ | |
be92c27e | 104 | } while (0) |
105 | ||
535664e3 | 106 | #define SUB_PARM_SIZE(TO, DEC) \ |
107 | do { \ | |
108 | tree dec = (DEC); \ | |
35ec552a | 109 | if (tree_fits_shwi_p (dec)) \ |
535664e3 | 110 | (TO).constant -= tree_low_cst (dec, 0); \ |
111 | else if ((TO).var == 0) \ | |
112 | (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ | |
113 | fold_convert (ssizetype, dec)); \ | |
114 | else \ | |
115 | (TO).var = size_binop (MINUS_EXPR, (TO).var, \ | |
116 | fold_convert (ssizetype, dec)); \ | |
be92c27e | 117 | } while (0) |
dbb0cd11 | 118 | |
902de8ed | 119 | /* Convert the implicit sum in a `struct args_size' into a tree |
120 | of type ssizetype. */ | |
121 | #define ARGS_SIZE_TREE(SIZE) \ | |
122 | ((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ | |
535664e3 | 123 | : size_binop (PLUS_EXPR, fold_convert (ssizetype, (SIZE).var), \ |
4f520835 | 124 | ssize_int ((SIZE).constant))) |
902de8ed | 125 | |
dbb0cd11 | 126 | /* Convert the implicit sum in a `struct args_size' into an rtx. */ |
902de8ed | 127 | #define ARGS_SIZE_RTX(SIZE) \ |
128 | ((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ | |
8ec3c5c2 | 129 | : expand_normal (ARGS_SIZE_TREE (SIZE))) |
dbb0cd11 | 130 | |
dbb0cd11 | 131 | \f |
2c02962c | 132 | /* This structure is used to pass around information about exploded |
133 | unary, binary and trinary expressions between expand_expr_real_1 and | |
134 | friends. */ | |
135 | typedef struct separate_ops | |
136 | { | |
137 | enum tree_code code; | |
b7834994 | 138 | location_t location; |
2c02962c | 139 | tree type; |
140 | tree op0, op1, op2; | |
2c02962c | 141 | } *sepops; |
142 | \f | |
d8fc4d0b | 143 | /* Functions from optabs.c, commonly used, and without need for the optabs |
144 | tables: */ | |
dbb0cd11 | 145 | |
ad99e708 | 146 | /* Passed to expand_simple_binop and expand_binop to say which options |
147 | to try to use if the requested operation can't be open-coded on the | |
148 | requisite mode. Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using | |
149 | a library call. Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try | |
150 | using a wider mode. OPTAB_MUST_WIDEN says try widening and don't | |
151 | try anything else. */ | |
152 | ||
153 | enum optab_methods | |
154 | { | |
155 | OPTAB_DIRECT, | |
156 | OPTAB_LIB, | |
157 | OPTAB_WIDEN, | |
158 | OPTAB_LIB_WIDEN, | |
159 | OPTAB_MUST_WIDEN | |
160 | }; | |
161 | ||
162 | /* Generate code for a simple binary or unary operation. "Simple" in | |
163 | this case means "can be unambiguously described by a (mode, code) | |
164 | pair and mapped to a single optab." */ | |
35cb5232 | 165 | extern rtx expand_simple_binop (enum machine_mode, enum rtx_code, rtx, |
166 | rtx, rtx, int, enum optab_methods); | |
167 | extern rtx expand_simple_unop (enum machine_mode, enum rtx_code, rtx, rtx, | |
168 | int); | |
ad99e708 | 169 | |
170 | /* Report whether the machine description contains an insn which can | |
171 | perform the operation described by CODE and MODE. */ | |
35cb5232 | 172 | extern int have_insn_for (enum rtx_code, enum machine_mode); |
ad99e708 | 173 | |
ab6d34f7 | 174 | /* Emit code to make a call to a constant function or a library call. */ |
35cb5232 | 175 | extern void emit_libcall_block (rtx, rtx, rtx, rtx); |
dbb0cd11 | 176 | |
d8fc4d0b | 177 | /* Create but don't emit one rtl instruction to perform certain operations. |
178 | Modes must match; operands must meet the operation's predicates. | |
0a534ba7 | 179 | Likewise for subtraction and for just copying. */ |
35cb5232 | 180 | extern rtx gen_add2_insn (rtx, rtx); |
181 | extern rtx gen_add3_insn (rtx, rtx, rtx); | |
182 | extern rtx gen_sub2_insn (rtx, rtx); | |
183 | extern rtx gen_sub3_insn (rtx, rtx, rtx); | |
184 | extern rtx gen_move_insn (rtx, rtx); | |
185 | extern int have_add2_insn (rtx, rtx); | |
186 | extern int have_sub2_insn (rtx, rtx); | |
b5479824 | 187 | |
ff385626 | 188 | /* Emit a pair of rtl insns to compare two rtx's and to jump |
989c2a69 | 189 | to a label if the comparison is true. */ |
35cb5232 | 190 | extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, |
584abc98 | 191 | enum machine_mode, int, rtx, int prob=-1); |
989c2a69 | 192 | |
b5479824 | 193 | /* Generate code to indirectly jump to a location given in the rtx LOC. */ |
35cb5232 | 194 | extern void emit_indirect_jump (rtx); |
b5479824 | 195 | |
ea92ba80 | 196 | /* Generate a conditional trap instruction. */ |
197 | extern rtx gen_cond_trap (enum rtx_code, rtx, rtx, rtx); | |
198 | ||
4c74e6d9 | 199 | #include "insn-config.h" |
200 | ||
2e68a51e | 201 | #ifdef HAVE_conditional_move |
202 | /* Emit a conditional move operation. */ | |
35cb5232 | 203 | rtx emit_conditional_move (rtx, enum rtx_code, rtx, rtx, enum machine_mode, |
204 | rtx, rtx, enum machine_mode, int); | |
2e68a51e | 205 | |
6ef828f9 | 206 | /* Return nonzero if the conditional move is supported. */ |
35cb5232 | 207 | int can_conditionally_move_p (enum machine_mode mode); |
caca85bd | 208 | |
2e68a51e | 209 | #endif |
35cb5232 | 210 | rtx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, enum machine_mode, |
211 | rtx, rtx, enum machine_mode, int); | |
2e68a51e | 212 | |
b6a5fc45 | 213 | rtx expand_sync_operation (rtx, rtx, enum rtx_code); |
214 | rtx expand_sync_fetch_operation (rtx, rtx, enum rtx_code, bool, rtx); | |
7821cde1 | 215 | rtx expand_sync_lock_test_and_set (rtx, rtx, rtx); |
1cd6e20d | 216 | |
7821cde1 | 217 | rtx expand_atomic_exchange (rtx, rtx, rtx, enum memmodel); |
1cd6e20d | 218 | rtx expand_atomic_load (rtx, rtx, enum memmodel); |
8808bf16 | 219 | rtx expand_atomic_store (rtx, rtx, enum memmodel, bool); |
1cd6e20d | 220 | rtx expand_atomic_fetch_op (rtx, rtx, rtx, enum rtx_code, enum memmodel, |
221 | bool); | |
7821cde1 | 222 | rtx expand_atomic_test_and_set (rtx, rtx, enum memmodel); |
223 | rtx expand_atomic_clear (rtx, enum memmodel); | |
1cd6e20d | 224 | void expand_atomic_thread_fence (enum memmodel); |
225 | void expand_atomic_signal_fence (enum memmodel); | |
226 | ||
b5479824 | 227 | \f |
b2d92e37 | 228 | /* Functions from expmed.c: */ |
dbb0cd11 | 229 | |
b5479824 | 230 | /* Arguments MODE, RTX: return an rtx for the negation of that value. |
231 | May emit insns. */ | |
35cb5232 | 232 | extern rtx negate_rtx (enum machine_mode, rtx); |
dbb0cd11 | 233 | |
b5479824 | 234 | /* Expand a logical AND operation. */ |
35cb5232 | 235 | extern rtx expand_and (enum machine_mode, rtx, rtx, rtx); |
dbb0cd11 | 236 | |
b5479824 | 237 | /* Emit a store-flag operation. */ |
35cb5232 | 238 | extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, enum machine_mode, |
239 | int, int); | |
dbb0cd11 | 240 | |
9c4f6a53 | 241 | /* Like emit_store_flag, but always succeeds. */ |
35cb5232 | 242 | extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, |
243 | enum machine_mode, int, int); | |
127cb1cd | 244 | |
245 | /* Choose a minimal N + 1 bit approximation to 1/D that can be used to | |
246 | replace division by D, and put the least significant N bits of the result | |
247 | in *MULTIPLIER_PTR and return the most significant bit. */ | |
248 | extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int, | |
249 | int, unsigned HOST_WIDE_INT *, | |
250 | int *, int *); | |
b5479824 | 251 | \f |
53800dbe | 252 | /* Functions from builtins.c: */ |
aecda0d6 | 253 | extern rtx expand_builtin (tree, rtx, rtx, enum machine_mode, int); |
2e15d750 | 254 | extern tree std_build_builtin_va_list (void); |
5f57a8b1 | 255 | extern tree std_fn_abi_va_list (tree); |
256 | extern tree std_canonical_va_list_type (tree); | |
257 | ||
aecda0d6 | 258 | extern void std_expand_builtin_va_start (tree, rtx); |
aecda0d6 | 259 | extern rtx default_expand_builtin (tree, rtx, rtx, enum machine_mode, int); |
260 | extern void expand_builtin_setjmp_setup (rtx, rtx); | |
261 | extern void expand_builtin_setjmp_receiver (rtx); | |
aecda0d6 | 262 | extern rtx expand_builtin_saveregs (void); |
c22de3f0 | 263 | extern void expand_builtin_trap (void); |
09879952 | 264 | extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode); |
53800dbe | 265 | \f |
b5479824 | 266 | /* Functions from expr.c: */ |
fe2ef382 | 267 | |
48e1416a | 268 | /* This is run during target initialization to set up which modes can be |
6d8b68a3 | 269 | used directly in memory and to initialize the block move optab. */ |
270 | extern void init_expr_target (void); | |
b5479824 | 271 | |
272 | /* This is run at the start of compiling a function. */ | |
35cb5232 | 273 | extern void init_expr (void); |
b5479824 | 274 | |
dbb0cd11 | 275 | /* Emit some rtl insns to move data between rtx's, converting machine modes. |
276 | Both modes must be floating or both fixed. */ | |
35cb5232 | 277 | extern void convert_move (rtx, rtx, int); |
dbb0cd11 | 278 | |
279 | /* Convert an rtx to specified machine mode and return the result. */ | |
35cb5232 | 280 | extern rtx convert_to_mode (enum machine_mode, rtx, int); |
dbb0cd11 | 281 | |
48e657fd | 282 | /* Convert an rtx to MODE from OLDMODE and return the result. */ |
35cb5232 | 283 | extern rtx convert_modes (enum machine_mode, enum machine_mode, rtx, int); |
48e657fd | 284 | |
b2d92e37 | 285 | /* Emit code to move a block Y to a block X. */ |
0378dbdc | 286 | |
287 | enum block_op_methods | |
288 | { | |
289 | BLOCK_OP_NORMAL, | |
a35a63ff | 290 | BLOCK_OP_NO_LIBCALL, |
0b25db21 | 291 | BLOCK_OP_CALL_PARM, |
292 | /* Like BLOCK_OP_NORMAL, but the libcall can be tail call optimized. */ | |
293 | BLOCK_OP_TAILCALL | |
0378dbdc | 294 | }; |
295 | ||
d8f74faa | 296 | extern GTY(()) tree block_clear_fn; |
35cb5232 | 297 | extern void init_block_move_fn (const char *); |
298 | extern void init_block_clear_fn (const char *); | |
d459e0d8 | 299 | |
35cb5232 | 300 | extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods); |
ab608690 | 301 | extern rtx emit_block_move_via_libcall (rtx, rtx, rtx, bool); |
162719b3 | 302 | extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods, |
36d63243 | 303 | unsigned int, HOST_WIDE_INT, |
304 | unsigned HOST_WIDE_INT, | |
305 | unsigned HOST_WIDE_INT); | |
16c9337c | 306 | extern bool emit_storent_insn (rtx to, rtx from); |
b5479824 | 307 | |
308 | /* Copy all or part of a value X into registers starting at REGNO. | |
309 | The number of registers to be filled is NREGS. */ | |
35cb5232 | 310 | extern void move_block_to_reg (int, rtx, int, enum machine_mode); |
b5479824 | 311 | |
312 | /* Copy all or part of a BLKmode value X out of registers starting at REGNO. | |
313 | The number of registers to be filled is NREGS. */ | |
35cb5232 | 314 | extern void move_block_from_reg (int, rtx, int); |
b5479824 | 315 | |
b566e2e5 | 316 | /* Generate a non-consecutive group of registers represented by a PARALLEL. */ |
35cb5232 | 317 | extern rtx gen_group_rtx (rtx); |
b566e2e5 | 318 | |
2dbc68f6 | 319 | /* Load a BLKmode value into non-consecutive registers represented by a |
320 | PARALLEL. */ | |
5f4cd670 | 321 | extern void emit_group_load (rtx, rtx, tree, int); |
fe352cf1 | 322 | |
e2ff5c1b | 323 | /* Similarly, but load into new temporaries. */ |
324 | extern rtx emit_group_load_into_temps (rtx, rtx, tree, int); | |
325 | ||
b566e2e5 | 326 | /* Move a non-consecutive group of registers represented by a PARALLEL into |
327 | a non-consecutive group of registers represented by a PARALLEL. */ | |
35cb5232 | 328 | extern void emit_group_move (rtx, rtx); |
b566e2e5 | 329 | |
e2ff5c1b | 330 | /* Move a group of registers represented by a PARALLEL into pseudos. */ |
331 | extern rtx emit_group_move_into_temps (rtx); | |
332 | ||
2dbc68f6 | 333 | /* Store a BLKmode value from non-consecutive registers represented by a |
334 | PARALLEL. */ | |
5f4cd670 | 335 | extern void emit_group_store (rtx, rtx, tree, int); |
2dbc68f6 | 336 | |
933eb13a | 337 | extern rtx maybe_emit_group_store (rtx, tree); |
338 | ||
ab6d34f7 | 339 | /* Copy BLKmode object from a set of registers. */ |
7e91b548 | 340 | extern void copy_blkmode_from_reg (rtx, rtx, tree); |
25eb0f59 | 341 | |
b4eeceb9 | 342 | /* Mark REG as holding a parameter for the next CALL_INSN. |
343 | Mode is TYPE_MODE of the non-promoted parameter, or VOIDmode. */ | |
344 | extern void use_reg_mode (rtx *, rtx, enum machine_mode); | |
345 | ||
ee5ab2d1 | 346 | extern rtx copy_blkmode_to_reg (enum machine_mode, tree); |
347 | ||
14602aee | 348 | /* Mark REG as holding a parameter for the next CALL_INSN. */ |
b4eeceb9 | 349 | static inline void |
350 | use_reg (rtx *fusage, rtx reg) | |
351 | { | |
352 | use_reg_mode (fusage, reg, VOIDmode); | |
353 | } | |
fe352cf1 | 354 | |
14602aee | 355 | /* Mark NREGS consecutive regs, starting at REGNO, as holding parameters |
356 | for the next CALL_INSN. */ | |
35cb5232 | 357 | extern void use_regs (rtx *, int, int); |
fe352cf1 | 358 | |
2dbc68f6 | 359 | /* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ |
35cb5232 | 360 | extern void use_group_regs (rtx *, rtx); |
b5479824 | 361 | |
362 | /* Write zeros through the storage of OBJECT. | |
2a631e19 | 363 | If OBJECT has BLKmode, SIZE is its length in bytes. */ |
0b25db21 | 364 | extern rtx clear_storage (rtx, rtx, enum block_op_methods); |
162719b3 | 365 | extern rtx clear_storage_hints (rtx, rtx, enum block_op_methods, |
36d63243 | 366 | unsigned int, HOST_WIDE_INT, |
367 | unsigned HOST_WIDE_INT, | |
368 | unsigned HOST_WIDE_INT); | |
ab608690 | 369 | /* The same, but always output an library call. */ |
370 | rtx set_storage_via_libcall (rtx, rtx, rtx, bool); | |
b5479824 | 371 | |
7a3e5564 | 372 | /* Expand a setmem pattern; return true if successful. */ |
48e1416a | 373 | extern bool set_storage_via_setmem (rtx, rtx, rtx, unsigned int, |
36d63243 | 374 | unsigned int, HOST_WIDE_INT, |
375 | unsigned HOST_WIDE_INT, | |
376 | unsigned HOST_WIDE_INT); | |
7a3e5564 | 377 | |
8136e769 | 378 | extern unsigned HOST_WIDE_INT move_by_pieces_ninsns (unsigned HOST_WIDE_INT, |
379 | unsigned int, | |
380 | unsigned int); | |
381 | ||
6ef828f9 | 382 | /* Return nonzero if it is desirable to store LEN bytes generated by |
6840589f | 383 | CONSTFUN with several move instructions by store_by_pieces |
384 | function. CONSTFUNDATA is a pointer which will be passed as argument | |
385 | in every CONSTFUN call. | |
4b297e2e | 386 | ALIGN is maximum alignment we can assume. |
387 | MEMSETP is true if this is a real memset/bzero, not a copy | |
388 | of a const string. */ | |
35cb5232 | 389 | extern int can_store_by_pieces (unsigned HOST_WIDE_INT, |
390 | rtx (*) (void *, HOST_WIDE_INT, | |
391 | enum machine_mode), | |
4b297e2e | 392 | void *, unsigned int, bool); |
6840589f | 393 | |
394 | /* Generate several move instructions to store LEN bytes generated by | |
395 | CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a | |
396 | pointer which will be passed as argument in every CONSTFUN call. | |
9fe0e1b8 | 397 | ALIGN is maximum alignment we can assume. |
4b297e2e | 398 | MEMSETP is true if this is a real memset/bzero, not a copy. |
9fe0e1b8 | 399 | Returns TO + LEN. */ |
35cb5232 | 400 | extern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, |
401 | rtx (*) (void *, HOST_WIDE_INT, enum machine_mode), | |
4b297e2e | 402 | void *, unsigned int, bool, int); |
6840589f | 403 | |
b5479824 | 404 | /* Emit insns to set X from Y. */ |
35cb5232 | 405 | extern rtx emit_move_insn (rtx, rtx); |
b5479824 | 406 | |
407 | /* Emit insns to set X from Y, with no frills. */ | |
35cb5232 | 408 | extern rtx emit_move_insn_1 (rtx, rtx); |
b5479824 | 409 | |
64003036 | 410 | extern rtx emit_move_complex_push (enum machine_mode, rtx, rtx); |
411 | extern rtx emit_move_complex_parts (rtx, rtx); | |
412 | ||
b5479824 | 413 | /* Push a block of length SIZE (perhaps variable) |
414 | and return an rtx to address the beginning of the block. */ | |
35cb5232 | 415 | extern rtx push_block (rtx, int, int); |
b5479824 | 416 | |
b5479824 | 417 | /* Generate code to push something onto the stack, given its mode and type. */ |
35cb5232 | 418 | extern void emit_push_insn (rtx, enum machine_mode, tree, rtx, unsigned int, |
419 | int, rtx, int, rtx, rtx, int, rtx); | |
b5479824 | 420 | |
ab6d34f7 | 421 | /* Expand an assignment that stores the value of FROM into TO. */ |
5b5037b3 | 422 | extern void expand_assignment (tree, tree, bool); |
b5479824 | 423 | |
424 | /* Generate code for computing expression EXP, | |
425 | and storing the value into TARGET. | |
426 | If SUGGEST_REG is nonzero, copy the value through a register | |
427 | and return that register, if that is possible. */ | |
5b5037b3 | 428 | extern rtx store_expr (tree, rtx, int, bool); |
dbb0cd11 | 429 | |
430 | /* Given an rtx that may include add and multiply operations, | |
431 | generate them as insns and return a pseudo-reg containing the value. | |
432 | Useful after calling expand_expr with 1 as sum_ok. */ | |
35cb5232 | 433 | extern rtx force_operand (rtx, rtx); |
dbb0cd11 | 434 | |
16c9337c | 435 | /* Work horses for expand_expr. */ |
48e1416a | 436 | extern rtx expand_expr_real (tree, rtx, enum machine_mode, |
5135beeb | 437 | enum expand_modifier, rtx *); |
16c9337c | 438 | extern rtx expand_expr_real_1 (tree, rtx, enum machine_mode, |
439 | enum expand_modifier, rtx *); | |
440 | extern rtx expand_expr_real_2 (sepops, rtx, enum machine_mode, | |
441 | enum expand_modifier); | |
5135beeb | 442 | |
b5479824 | 443 | /* Generate code for computing expression EXP. |
444 | An rtx for the computed value is returned. The value is never null. | |
445 | In the case of a void EXP, const0_rtx is returned. */ | |
5135beeb | 446 | static inline rtx |
447 | expand_expr (tree exp, rtx target, enum machine_mode mode, | |
448 | enum expand_modifier modifier) | |
449 | { | |
0b87e81f | 450 | return expand_expr_real (exp, target, mode, modifier, NULL); |
5135beeb | 451 | } |
b5479824 | 452 | |
8ec3c5c2 | 453 | static inline rtx |
454 | expand_normal (tree exp) | |
455 | { | |
456 | return expand_expr_real (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL, NULL); | |
457 | } | |
458 | ||
b5479824 | 459 | /* At the start of a function, record that we have no previously-pushed |
460 | arguments waiting to be popped. */ | |
35cb5232 | 461 | extern void init_pending_stack_adjust (void); |
b5479824 | 462 | |
05ae776c | 463 | /* Discard any pending stack adjustment. */ |
464 | extern void discard_pending_stack_adjust (void); | |
465 | ||
b5479824 | 466 | /* When exiting from function, if safe, clear out any pending stack adjust |
467 | so the adjustment won't get done. */ | |
35cb5232 | 468 | extern void clear_pending_stack_adjust (void); |
b5479824 | 469 | |
470 | /* Pop any previously-pushed arguments that have not been popped yet. */ | |
35cb5232 | 471 | extern void do_pending_stack_adjust (void); |
b5479824 | 472 | |
53800dbe | 473 | /* Return the tree node and offset if a given argument corresponds to |
474 | a string constant. */ | |
35cb5232 | 475 | extern tree string_constant (tree, tree *); |
53800dbe | 476 | |
b5479824 | 477 | /* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ |
79ab74cc | 478 | extern void jumpifnot (tree, rtx, int); |
479 | extern void jumpifnot_1 (enum tree_code, tree, tree, rtx, int); | |
b5479824 | 480 | |
481 | /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ | |
79ab74cc | 482 | extern void jumpif (tree, rtx, int); |
483 | extern void jumpif_1 (enum tree_code, tree, tree, rtx, int); | |
b5479824 | 484 | |
485 | /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if | |
486 | the result is zero, or IF_TRUE_LABEL if the result is one. */ | |
79ab74cc | 487 | extern void do_jump (tree, rtx, rtx, int); |
488 | extern void do_jump_1 (enum tree_code, tree, tree, rtx, rtx, int); | |
b5479824 | 489 | |
35cb5232 | 490 | extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, |
79ab74cc | 491 | enum machine_mode, rtx, rtx, rtx, int); |
b5479824 | 492 | |
539a3a92 | 493 | /* Two different ways of generating switch statements. */ |
584abc98 | 494 | extern int try_casesi (tree, tree, tree, tree, rtx, rtx, rtx, int); |
495 | extern int try_tablejump (tree, tree, tree, tree, rtx, rtx, int); | |
539a3a92 | 496 | |
4c74e6d9 | 497 | /* Functions from alias.c */ |
498 | #include "alias.h" | |
4c74e6d9 | 499 | |
b5479824 | 500 | \f |
fe2ef382 | 501 | /* rtl.h and tree.h were included. */ |
502 | /* Return an rtx for the size in bytes of the value of an expr. */ | |
35cb5232 | 503 | extern rtx expr_size (tree); |
fe2ef382 | 504 | |
e7971c00 | 505 | /* Return a wide integer for the size in bytes of the value of EXP, or -1 |
506 | if the size can vary or is larger than an integer. */ | |
35cb5232 | 507 | extern HOST_WIDE_INT int_expr_size (tree); |
e7971c00 | 508 | |
fe2ef382 | 509 | /* Return an rtx that refers to the value returned by a function |
510 | in its original home. This becomes invalid if any more code is emitted. */ | |
fb80456a | 511 | extern rtx hard_function_value (const_tree, const_tree, const_tree, int); |
fe2ef382 | 512 | |
82c7907c | 513 | extern rtx prepare_call_address (tree, rtx, rtx, rtx *, int, int); |
fe2ef382 | 514 | |
05d18e8b | 515 | extern bool shift_return_value (enum machine_mode, bool, rtx); |
516 | ||
35cb5232 | 517 | extern rtx expand_call (tree, rtx, int); |
fe2ef382 | 518 | |
4ee9c684 | 519 | extern void fixup_tail_calls (void); |
520 | ||
5f4cd670 | 521 | #ifdef TREE_CODE |
f5ff0b21 | 522 | extern rtx expand_variable_shift (enum tree_code, enum machine_mode, |
523 | rtx, tree, rtx, int); | |
524 | extern rtx expand_shift (enum tree_code, enum machine_mode, rtx, int, rtx, | |
525 | int); | |
35cb5232 | 526 | extern rtx expand_divmod (int, enum tree_code, enum machine_mode, rtx, rtx, |
527 | rtx, int); | |
5f4cd670 | 528 | #endif |
529 | ||
2e090bf6 | 530 | extern void locate_and_pad_parm (enum machine_mode, tree, int, int, int, |
531 | tree, struct args_size *, | |
35cb5232 | 532 | struct locate_and_pad_arg_data *); |
f7c44134 | 533 | |
fe2ef382 | 534 | /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ |
35cb5232 | 535 | extern rtx label_rtx (tree); |
78a75ebd | 536 | |
537 | /* As label_rtx, but additionally the label is placed on the forced label | |
538 | list of its containing function (i.e. it is treated as reachable even | |
539 | if how is not obvious). */ | |
35cb5232 | 540 | extern rtx force_label_rtx (tree); |
fe2ef382 | 541 | |
dbb0cd11 | 542 | /* Return an rtx like arg but sans any constant terms. |
543 | Returns the original rtx if it has no constant terms. | |
544 | The constant terms are added and stored via a second arg. */ | |
35cb5232 | 545 | extern rtx eliminate_constant_term (rtx, rtx *); |
dbb0cd11 | 546 | |
bd1a81f7 | 547 | /* Convert arg to a valid memory address for specified machine mode that points |
548 | to a specific named address space, by emitting insns to perform arithmetic | |
549 | if necessary. */ | |
550 | extern rtx memory_address_addr_space (enum machine_mode, rtx, addr_space_t); | |
551 | ||
552 | /* Like memory_address_addr_space, except assume the memory address points to | |
553 | the generic named address space. */ | |
554 | #define memory_address(MODE,RTX) \ | |
555 | memory_address_addr_space ((MODE), (RTX), ADDR_SPACE_GENERIC) | |
dbb0cd11 | 556 | |
dbb0cd11 | 557 | /* Return a memory reference like MEMREF, but with its mode changed |
558 | to MODE and its address changed to ADDR. | |
559 | (VOIDmode means don't change the mode. | |
96216d37 | 560 | NULL for ADDR means don't change the address.) */ |
35cb5232 | 561 | extern rtx change_address (rtx, enum machine_mode, rtx); |
dbb0cd11 | 562 | |
e513d163 | 563 | /* Return a memory reference like MEMREF, but with its mode changed |
564 | to MODE and its address offset by OFFSET bytes. */ | |
96216d37 | 565 | #define adjust_address(MEMREF, MODE, OFFSET) \ |
226c6baf | 566 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 0, 0) |
e513d163 | 567 | |
e4e86ec5 | 568 | /* Likewise, but the reference is not required to be valid. */ |
96216d37 | 569 | #define adjust_address_nv(MEMREF, MODE, OFFSET) \ |
226c6baf | 570 | adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 0, 0) |
2d0fd66d | 571 | |
572 | /* Return a memory reference like MEMREF, but with its mode changed | |
573 | to MODE and its address offset by OFFSET bytes. Assume that it's | |
574 | for a bitfield and conservatively drop the underlying object if we | |
575 | cannot be sure to stay within its bounds. */ | |
576 | #define adjust_bitfield_address(MEMREF, MODE, OFFSET) \ | |
226c6baf | 577 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, 0) |
578 | ||
579 | /* As for adjust_bitfield_address, but specify that the width of | |
580 | BLKmode accesses is SIZE bytes. */ | |
581 | #define adjust_bitfield_address_size(MEMREF, MODE, OFFSET, SIZE) \ | |
582 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, SIZE) | |
2d0fd66d | 583 | |
584 | /* Likewise, but the reference is not required to be valid. */ | |
585 | #define adjust_bitfield_address_nv(MEMREF, MODE, OFFSET) \ | |
226c6baf | 586 | adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 1, 0) |
7e3791cb | 587 | |
588 | /* Return a memory reference like MEMREF, but with its mode changed | |
589 | to MODE and its address changed to ADDR, which is assumed to be | |
590 | increased by OFFSET bytes from MEMREF. */ | |
591 | #define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ | |
592 | adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) | |
593 | ||
594 | /* Likewise, but the reference is not required to be valid. */ | |
595 | #define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ | |
596 | adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) | |
96216d37 | 597 | |
2d0fd66d | 598 | extern rtx adjust_address_1 (rtx, enum machine_mode, HOST_WIDE_INT, int, int, |
226c6baf | 599 | int, HOST_WIDE_INT); |
35cb5232 | 600 | extern rtx adjust_automodify_address_1 (rtx, enum machine_mode, rtx, |
601 | HOST_WIDE_INT, int); | |
e4e86ec5 | 602 | |
fcdc122e | 603 | /* Return a memory reference like MEMREF, but whose address is changed by |
604 | adding OFFSET, an RTX, to it. POW2 is the highest power of two factor | |
605 | known to be in OFFSET (possibly 1). */ | |
35cb5232 | 606 | extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT); |
fcdc122e | 607 | |
4c74e6d9 | 608 | /* Definitions from emit-rtl.c */ |
609 | #include "emit-rtl.h" | |
e4e86ec5 | 610 | |
8259ab07 | 611 | /* Return a memory reference like MEMREF, but with its mode widened to |
612 | MODE and adjusted by OFFSET. */ | |
35cb5232 | 613 | extern rtx widen_memory_access (rtx, enum machine_mode, HOST_WIDE_INT); |
8259ab07 | 614 | |
dbb0cd11 | 615 | /* Return a memory reference like MEMREF, but which is known to have a |
616 | valid address. */ | |
35cb5232 | 617 | extern rtx validize_mem (rtx); |
dbb0cd11 | 618 | |
f2d0e9f1 | 619 | extern rtx use_anchored_address (rtx); |
620 | ||
f7c44134 | 621 | /* Given REF, a MEM, and T, either the type of X or the expression |
622 | corresponding to REF, set the memory attributes. OBJECTP is nonzero | |
623 | if we are making a new object of this type. */ | |
35cb5232 | 624 | extern void set_mem_attributes (rtx, tree, int); |
6f717f77 | 625 | |
626 | /* Similar, except that BITPOS has not yet been applied to REF, so if | |
627 | we alter MEM_OFFSET according to T then we should subtract BITPOS | |
628 | expecting that it'll be added back in later. */ | |
35cb5232 | 629 | extern void set_mem_attributes_minus_bitpos (rtx, tree, int, HOST_WIDE_INT); |
f7c44134 | 630 | |
ad0a178f | 631 | /* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN |
632 | bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or | |
633 | -1 if not known. */ | |
7cfdc2f0 | 634 | extern int get_mem_align_offset (rtx, unsigned int); |
ad0a178f | 635 | |
dbb0cd11 | 636 | /* Assemble the static constant template for function entry trampolines. */ |
35cb5232 | 637 | extern rtx assemble_trampoline_template (void); |
dbb0cd11 | 638 | |
dbb0cd11 | 639 | /* Copy given rtx to a new temp reg and return that. */ |
35cb5232 | 640 | extern rtx copy_to_reg (rtx); |
dbb0cd11 | 641 | |
642 | /* Like copy_to_reg but always make the reg Pmode. */ | |
35cb5232 | 643 | extern rtx copy_addr_to_reg (rtx); |
dbb0cd11 | 644 | |
645 | /* Like copy_to_reg but always make the reg the specified mode MODE. */ | |
35cb5232 | 646 | extern rtx copy_to_mode_reg (enum machine_mode, rtx); |
dbb0cd11 | 647 | |
648 | /* Copy given rtx to given temp reg and return that. */ | |
35cb5232 | 649 | extern rtx copy_to_suggested_reg (rtx, rtx, enum machine_mode); |
dbb0cd11 | 650 | |
651 | /* Copy a value to a register if it isn't already a register. | |
652 | Args are mode (in case value is a constant) and the value. */ | |
35cb5232 | 653 | extern rtx force_reg (enum machine_mode, rtx); |
dbb0cd11 | 654 | |
655 | /* Return given rtx, copied into a new temp reg if it was in memory. */ | |
35cb5232 | 656 | extern rtx force_not_mem (rtx); |
dbb0cd11 | 657 | |
3b2411a8 | 658 | /* Return mode and signedness to use when an argument or result in the |
659 | given mode is promoted. */ | |
660 | extern enum machine_mode promote_function_mode (const_tree, enum machine_mode, int *, | |
661 | const_tree, int); | |
662 | ||
663 | /* Return mode and signedness to use when an object in the given mode | |
664 | is promoted. */ | |
665 | extern enum machine_mode promote_mode (const_tree, enum machine_mode, int *); | |
666 | ||
42cc9be0 | 667 | /* Return mode and signedness to use when object is promoted. */ |
3b2411a8 | 668 | enum machine_mode promote_decl_mode (const_tree, int *); |
42cc9be0 | 669 | |
dbb0cd11 | 670 | /* Remove some bytes from the stack. An rtx says how many. */ |
35cb5232 | 671 | extern void adjust_stack (rtx); |
dbb0cd11 | 672 | |
673 | /* Add some bytes to the stack. An rtx says how many. */ | |
35cb5232 | 674 | extern void anti_adjust_stack (rtx); |
dbb0cd11 | 675 | |
d1b92264 | 676 | /* Add some bytes to the stack while probing it. An rtx says how many. */ |
677 | extern void anti_adjust_stack_and_probe (rtx, bool); | |
678 | ||
dbd6697a | 679 | /* This enum is used for the following two functions. */ |
680 | enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; | |
681 | ||
682 | /* Save the stack pointer at the specified level. */ | |
e9c97615 | 683 | extern void emit_stack_save (enum save_level, rtx *); |
dbd6697a | 684 | |
685 | /* Restore the stack pointer from a save area of the specified level. */ | |
e9c97615 | 686 | extern void emit_stack_restore (enum save_level, rtx); |
dbd6697a | 687 | |
4ee9c684 | 688 | /* Invoke emit_stack_save for the nonlocal_goto_save_area. */ |
689 | extern void update_nonlocal_goto_save_area (void); | |
690 | ||
990495a7 | 691 | /* Allocate some space on the stack dynamically and return its address. */ |
5be42b39 | 692 | extern rtx allocate_dynamic_stack_space (rtx, unsigned, unsigned, bool); |
dbb0cd11 | 693 | |
f164c08a | 694 | /* Emit one stack probe at ADDRESS, an address within the stack. */ |
695 | extern void emit_stack_probe (rtx); | |
696 | ||
ff385626 | 697 | /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. |
42982f3e | 698 | FIRST is a constant and size is a Pmode RTX. These are offsets from |
699 | the current stack pointer. STACK_GROWS_DOWNWARD says whether to add | |
700 | or subtract them from the stack pointer. */ | |
35cb5232 | 701 | extern void probe_stack_range (HOST_WIDE_INT, rtx); |
aa4e8f9e | 702 | |
dbb0cd11 | 703 | /* Return an rtx that refers to the value returned by a library call |
704 | in its original home. This becomes invalid if any more code is emitted. */ | |
578d1295 | 705 | extern rtx hard_libcall_value (enum machine_mode, rtx); |
dbb0cd11 | 706 | |
36122326 | 707 | extern void store_bit_field (rtx, unsigned HOST_WIDE_INT, |
4bb60ec7 | 708 | unsigned HOST_WIDE_INT, |
709 | unsigned HOST_WIDE_INT, | |
710 | unsigned HOST_WIDE_INT, | |
711 | enum machine_mode, rtx); | |
35cb5232 | 712 | extern rtx extract_bit_field (rtx, unsigned HOST_WIDE_INT, |
3f71db40 | 713 | unsigned HOST_WIDE_INT, int, rtx, |
1445ea5b | 714 | enum machine_mode, enum machine_mode); |
10d4de0e | 715 | extern rtx extract_low_bits (enum machine_mode, enum machine_mode, rtx); |
35cb5232 | 716 | extern rtx expand_mult (enum machine_mode, rtx, rtx, rtx, int); |
35cb5232 | 717 | extern rtx expand_mult_highpart_adjust (enum machine_mode, rtx, rtx, rtx, rtx, int); |
718 | ||
719 | extern rtx assemble_static_space (unsigned HOST_WIDE_INT); | |
1f1872fd | 720 | extern int safe_from_p (const_rtx, tree, int); |
3fcf767f | 721 | extern bool split_comparison (enum rtx_code, enum machine_mode, |
722 | enum rtx_code *, enum rtx_code *); | |
e41f0d80 | 723 | |
d8fc4d0b | 724 | /* Call this once to initialize the contents of the optabs |
725 | appropriately for the current target machine. */ | |
35cb5232 | 726 | extern void init_optabs (void); |
08c7d04b | 727 | extern void init_all_optabs (struct target_optabs *); |
d8fc4d0b | 728 | |
729 | /* Call this to initialize an optab function entry. */ | |
35cb5232 | 730 | extern rtx init_one_libfunc (const char *); |
979d3efc | 731 | extern rtx set_user_assembler_libfunc (const char *, const char *); |
d8fc4d0b | 732 | |
58d82cd0 | 733 | /* Build a decl for a libfunc named NAME. */ |
734 | extern tree build_libfunc_function (const char *); | |
735 | ||
736 | /* Get the personality libfunc for a function decl. */ | |
737 | rtx get_personality_function (tree); | |
738 | ||
af68b5a9 | 739 | |
740 | /* In stmt.c */ | |
741 | ||
742 | /* Expand a GIMPLE_SWITCH statement. */ | |
743 | extern void expand_case (gimple); | |
744 | ||
745 | /* Like expand_case but special-case for SJLJ exception dispatching. */ | |
f1f41a6c | 746 | extern void expand_sjlj_dispatch_table (rtx, vec<tree> ); |
af68b5a9 | 747 | |
4c74e6d9 | 748 | #endif /* GCC_EXPR_H */ |