]>
Commit | Line | Data |
---|---|---|
e53b6e56 | 1 | /* Exported functions from emit-rtl.cc |
a945c346 | 2 | Copyright (C) 2004-2024 Free Software Foundation, Inc. |
78528714 JQ |
3 | |
4 | This file is part of GCC. | |
5 | ||
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 | |
9dcd6f09 | 8 | Software Foundation; either version 3, or (at your option) any later |
78528714 JQ |
9 | version. |
10 | ||
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. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
17 | along with GCC; see the file COPYING3. If not see |
18 | <http://www.gnu.org/licenses/>. */ | |
78528714 JQ |
19 | |
20 | #ifndef GCC_EMIT_RTL_H | |
21 | #define GCC_EMIT_RTL_H | |
22 | ||
99b1c316 MS |
23 | class temp_slot; |
24 | typedef class temp_slot *temp_slot_p; | |
bd785b44 | 25 | class predefined_function_abi; |
73b75827 | 26 | namespace rtl_ssa { class function_info; } |
2bb8cb58 | 27 | |
16a16ec7 AM |
28 | /* Information mainlined about RTL representation of incoming arguments. */ |
29 | struct GTY(()) incoming_args { | |
30 | /* Number of bytes of args popped by function being compiled on its return. | |
31 | Zero if no bytes are to be popped. | |
32 | May affect compilation of return insn or of function epilogue. */ | |
eaa41a6d | 33 | poly_int64 pops_args; |
16a16ec7 AM |
34 | |
35 | /* If function's args have a fixed size, this is that size, in bytes. | |
36 | Otherwise, it is -1. | |
37 | May affect compilation of return insn or of function epilogue. */ | |
eaa41a6d | 38 | poly_int64 size; |
16a16ec7 AM |
39 | |
40 | /* # bytes the prologue should push and pretend that the caller pushed them. | |
41 | The prologue must do this, but only if parms can be passed in | |
42 | registers. */ | |
43 | int pretend_args_size; | |
44 | ||
45 | /* This is the offset from the arg pointer to the place where the first | |
46 | anonymous arg can be found, if there is one. */ | |
47 | rtx arg_offset_rtx; | |
48 | ||
49 | /* Quantities of various kinds of registers | |
50 | used for the current function's args. */ | |
51 | CUMULATIVE_ARGS info; | |
52 | ||
53 | /* The arg pointer hard register, or the pseudo into which it was copied. */ | |
54 | rtx internal_arg_pointer; | |
55 | }; | |
56 | ||
57 | ||
2bb8cb58 AM |
58 | /* Datastructures maintained for currently processed function in RTL form. */ |
59 | struct GTY(()) rtl_data { | |
8194c537 DM |
60 | void init_stack_alignment (); |
61 | ||
2bb8cb58 AM |
62 | struct expr_status expr; |
63 | struct emit_status emit; | |
64 | struct varasm_status varasm; | |
65 | struct incoming_args args; | |
66 | struct function_subsections subsections; | |
67 | struct rtl_eh eh; | |
68 | ||
bd785b44 RS |
69 | /* The ABI of the function, i.e. the interface it presents to its callers. |
70 | This is the ABI that should be queried to see which registers the | |
71 | function needs to save before it uses them. | |
72 | ||
73 | Other functions (including those called by this function) might use | |
74 | different ABIs. */ | |
75 | const predefined_function_abi *GTY((skip)) abi; | |
76 | ||
73b75827 RS |
77 | rtl_ssa::function_info *GTY((skip)) ssa; |
78 | ||
e53b6e56 | 79 | /* For function.cc */ |
2bb8cb58 AM |
80 | |
81 | /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is | |
82 | defined, the needed space is pushed by the prologue. */ | |
eaa41a6d | 83 | poly_int64 outgoing_args_size; |
2bb8cb58 AM |
84 | |
85 | /* If nonzero, an RTL expression for the location at which the current | |
86 | function returns its result. If the current function returns its | |
87 | result in a register, current_function_return_rtx will always be | |
88 | the hard register containing the result. */ | |
89 | rtx return_rtx; | |
2bb8cb58 AM |
90 | |
91 | /* Vector of initial-value pairs. Each pair consists of a pseudo | |
92 | register of approprite mode that stores the initial value a hard | |
93 | register REGNO, and that hard register itself. */ | |
94 | /* ??? This could be a VEC but there is currently no way to define an | |
95 | opaque VEC type. */ | |
96 | struct initial_value_struct *hard_reg_initial_vals; | |
97 | ||
98 | /* A variable living at the top of the frame that holds a known value. | |
99 | Used for detecting stack clobbers. */ | |
100 | tree stack_protect_guard; | |
101 | ||
a49a975f JJ |
102 | /* The __stack_chk_guard variable or expression holding the stack |
103 | protector canary value. */ | |
104 | tree stack_protect_guard_decl; | |
105 | ||
2bb8cb58 AM |
106 | /* List (chain of INSN_LIST) of labels heading the current handlers for |
107 | nonlocal gotos. */ | |
108 | rtx_insn_list *x_nonlocal_goto_handler_labels; | |
109 | ||
110 | /* Label that will go on function epilogue. | |
111 | Jumping to this label serves as a "return" instruction | |
112 | on machines which require execution of the epilogue on all returns. */ | |
113 | rtx_code_label *x_return_label; | |
114 | ||
115 | /* Label that will go on the end of function epilogue. | |
116 | Jumping to this label serves as a "naked return" instruction | |
117 | on machines which require execution of the epilogue on all returns. */ | |
118 | rtx_code_label *x_naked_return_label; | |
119 | ||
120 | /* List (chain of EXPR_LISTs) of all stack slots in this function. | |
121 | Made for the sake of unshare_all_rtl. */ | |
8c39f8ae | 122 | vec<rtx, va_gc> *x_stack_slot_list; |
2bb8cb58 AM |
123 | |
124 | /* List of empty areas in the stack frame. */ | |
99b1c316 | 125 | class frame_space *frame_space_list; |
2bb8cb58 AM |
126 | |
127 | /* Place after which to insert the tail_recursion_label if we need one. */ | |
128 | rtx_note *x_stack_check_probe_note; | |
129 | ||
130 | /* Location at which to save the argument pointer if it will need to be | |
131 | referenced. There are two cases where this is done: if nonlocal gotos | |
132 | exist, or if vars stored at an offset from the argument pointer will be | |
133 | needed by inner routines. */ | |
134 | rtx x_arg_pointer_save_area; | |
135 | ||
136 | /* Dynamic Realign Argument Pointer used for realigning stack. */ | |
137 | rtx drap_reg; | |
138 | ||
139 | /* Offset to end of allocated area of stack frame. | |
140 | If stack grows down, this is the address of the last stack slot allocated. | |
141 | If stack grows up, this is the address for the next slot. */ | |
eaa41a6d | 142 | poly_int64 x_frame_offset; |
2bb8cb58 | 143 | |
0d74ff2d RS |
144 | /* The function's FUNCTION_BEG note. */ |
145 | rtx_insn *x_function_beg_insn; | |
146 | ||
2bb8cb58 AM |
147 | /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ |
148 | rtx_insn *x_parm_birth_insn; | |
149 | ||
150 | /* List of all used temporaries allocated, by level. */ | |
151 | vec<temp_slot_p, va_gc> *x_used_temp_slots; | |
152 | ||
153 | /* List of available temp slots. */ | |
99b1c316 | 154 | class temp_slot *x_avail_temp_slots; |
2bb8cb58 AM |
155 | |
156 | /* Current nesting level for temporaries. */ | |
157 | int x_temp_slot_level; | |
158 | ||
159 | /* The largest alignment needed on the stack, including requirement | |
160 | for outgoing stack alignment. */ | |
161 | unsigned int stack_alignment_needed; | |
162 | ||
163 | /* Preferred alignment of the end of stack frame, which is preferred | |
164 | to call other functions. */ | |
165 | unsigned int preferred_stack_boundary; | |
166 | ||
167 | /* The minimum alignment of parameter stack. */ | |
168 | unsigned int parm_stack_boundary; | |
169 | ||
170 | /* The largest alignment of slot allocated on the stack. */ | |
171 | unsigned int max_used_stack_slot_alignment; | |
172 | ||
173 | /* The stack alignment estimated before reload, with consideration of | |
174 | following factors: | |
175 | 1. Alignment of local stack variables (max_used_stack_slot_alignment) | |
176 | 2. Alignment requirement to call other functions | |
177 | (preferred_stack_boundary) | |
178 | 3. Alignment of non-local stack variables but might be spilled in | |
179 | local stack. */ | |
180 | unsigned int stack_alignment_estimated; | |
181 | ||
6607bdd9 L |
182 | /* How many NOP insns to place at each function entry by default. */ |
183 | unsigned short patch_area_size; | |
184 | ||
185 | /* How far the real asm entry point is into this area. */ | |
186 | unsigned short patch_area_entry; | |
187 | ||
2bb8cb58 AM |
188 | /* For reorg. */ |
189 | ||
190 | /* Nonzero if function being compiled called builtin_return_addr or | |
191 | builtin_frame_address with nonzero count. */ | |
192 | bool accesses_prior_frames; | |
193 | ||
194 | /* Nonzero if the function calls __builtin_eh_return. */ | |
195 | bool calls_eh_return; | |
196 | ||
197 | /* Nonzero if function saves all registers, e.g. if it has a nonlocal | |
198 | label that can reach the exit block via non-exceptional paths. */ | |
199 | bool saves_all_registers; | |
200 | ||
201 | /* Nonzero if function being compiled has nonlocal gotos to parent | |
202 | function. */ | |
203 | bool has_nonlocal_goto; | |
204 | ||
205 | /* Nonzero if function being compiled has an asm statement. */ | |
206 | bool has_asm_statement; | |
207 | ||
208 | /* This bit is used by the exception handling logic. It is set if all | |
209 | calls (if any) are sibling calls. Such functions do not have to | |
210 | have EH tables generated, as they cannot throw. A call to such a | |
211 | function, however, should be treated as throwing if any of its callees | |
212 | can throw. */ | |
213 | bool all_throwers_are_sibcalls; | |
214 | ||
215 | /* Nonzero if stack limit checking should be enabled in the current | |
216 | function. */ | |
217 | bool limit_stack; | |
218 | ||
219 | /* Nonzero if profiling code should be generated. */ | |
220 | bool profile; | |
221 | ||
222 | /* Nonzero if the current function uses the constant pool. */ | |
223 | bool uses_const_pool; | |
224 | ||
225 | /* Nonzero if the current function uses pic_offset_table_rtx. */ | |
226 | bool uses_pic_offset_table; | |
227 | ||
228 | /* Nonzero if the current function needs an lsda for exception handling. */ | |
229 | bool uses_eh_lsda; | |
230 | ||
231 | /* Set when the tail call has been produced. */ | |
232 | bool tail_call_emit; | |
233 | ||
234 | /* Nonzero if code to initialize arg_pointer_save_area has been emitted. */ | |
235 | bool arg_pointer_save_area_init; | |
236 | ||
237 | /* Nonzero if current function must be given a frame pointer. | |
e53b6e56 | 238 | Set in reload1.cc or lra-eliminations.cc if anything is allocated |
2bb8cb58 AM |
239 | on the stack there. */ |
240 | bool frame_pointer_needed; | |
241 | ||
242 | /* When set, expand should optimize for speed. */ | |
243 | bool maybe_hot_insn_p; | |
244 | ||
245 | /* Nonzero if function stack realignment is needed. This flag may be | |
246 | set twice: before and after reload. It is set before reload wrt | |
247 | stack alignment estimation before reload. It will be changed after | |
248 | reload if by then criteria of stack realignment is different. | |
249 | The value set after reload is the accurate one and is finalized. */ | |
250 | bool stack_realign_needed; | |
251 | ||
252 | /* Nonzero if function stack realignment is tried. This flag is set | |
253 | only once before reload. It affects register elimination. This | |
254 | is used to generate DWARF debug info for stack variables. */ | |
255 | bool stack_realign_tried; | |
256 | ||
257 | /* Nonzero if function being compiled needs dynamic realigned | |
258 | argument pointer (drap) if stack needs realigning. */ | |
259 | bool need_drap; | |
260 | ||
261 | /* Nonzero if function stack realignment estimation is done, namely | |
262 | stack_realign_needed flag has been set before reload wrt estimated | |
263 | stack alignment info. */ | |
264 | bool stack_realign_processed; | |
265 | ||
266 | /* Nonzero if function stack realignment has been finalized, namely | |
267 | stack_realign_needed flag has been set and finalized after reload. */ | |
268 | bool stack_realign_finalized; | |
269 | ||
270 | /* True if dbr_schedule has already been called for this function. */ | |
271 | bool dbr_scheduled_p; | |
272 | ||
67914693 | 273 | /* True if current function cannot throw. Unlike |
2bb8cb58 AM |
274 | TREE_NOTHROW (current_function_decl) it is set even for overwritable |
275 | function where currently compiled version of it is nothrow. */ | |
276 | bool nothrow; | |
277 | ||
278 | /* True if we performed shrink-wrapping for the current function. */ | |
279 | bool shrink_wrapped; | |
280 | ||
20a6ece0 SB |
281 | /* True if we performed shrink-wrapping for separate components for |
282 | the current function. */ | |
283 | bool shrink_wrapped_separate; | |
284 | ||
2bb8cb58 AM |
285 | /* Nonzero if function being compiled doesn't modify the stack pointer |
286 | (ignoring the prologue and epilogue). This is only valid after | |
287 | pass_stack_ptr_mod has run. */ | |
288 | bool sp_is_unchanging; | |
289 | ||
453a20c6 L |
290 | /* True if the stack pointer is clobbered by asm statement. */ |
291 | bool sp_is_clobbered_by_asm; | |
292 | ||
2bb8cb58 AM |
293 | /* Nonzero if function being compiled doesn't contain any calls |
294 | (ignoring the prologue and epilogue). This is set prior to | |
55dabf65 | 295 | register allocation in IRA and is valid for the remaining |
2bb8cb58 AM |
296 | compiler passes. */ |
297 | bool is_leaf; | |
298 | ||
299 | /* Nonzero if the function being compiled is a leaf function which only | |
300 | uses leaf registers. This is valid after reload (specifically after | |
301 | sched2) and is useful only if the port defines LEAF_REGISTERS. */ | |
302 | bool uses_only_leaf_regs; | |
303 | ||
304 | /* Nonzero if the function being compiled has undergone hot/cold partitioning | |
305 | (under flag_reorder_blocks_and_partition) and has at least one cold | |
306 | block. */ | |
307 | bool has_bb_partition; | |
308 | ||
309 | /* Nonzero if the function being compiled has completed the bb reordering | |
310 | pass. */ | |
311 | bool bb_reorder_complete; | |
312 | ||
313 | /* Like regs_ever_live, but 1 if a reg is set or clobbered from an | |
314 | asm. Unlike regs_ever_live, elements of this array corresponding | |
315 | to eliminable regs (like the frame pointer) are set if an asm | |
316 | sets them. */ | |
317 | HARD_REG_SET asm_clobbers; | |
8cac4d85 | 318 | |
d10f3e90 | 319 | /* All hard registers that need to be zeroed at the return of the routine. */ |
320 | HARD_REG_SET must_be_zero_on_return; | |
321 | ||
8cac4d85 BS |
322 | /* The highest address seen during shorten_branches. */ |
323 | int max_insn_address; | |
2bb8cb58 AM |
324 | }; |
325 | ||
326 | #define return_label (crtl->x_return_label) | |
327 | #define naked_return_label (crtl->x_naked_return_label) | |
328 | #define stack_slot_list (crtl->x_stack_slot_list) | |
0d74ff2d | 329 | #define function_beg_insn (crtl->x_function_beg_insn) |
2bb8cb58 AM |
330 | #define parm_birth_insn (crtl->x_parm_birth_insn) |
331 | #define frame_offset (crtl->x_frame_offset) | |
332 | #define stack_check_probe_note (crtl->x_stack_check_probe_note) | |
333 | #define arg_pointer_save_area (crtl->x_arg_pointer_save_area) | |
334 | #define used_temp_slots (crtl->x_used_temp_slots) | |
335 | #define avail_temp_slots (crtl->x_avail_temp_slots) | |
336 | #define temp_slot_level (crtl->x_temp_slot_level) | |
337 | #define nonlocal_goto_handler_labels (crtl->x_nonlocal_goto_handler_labels) | |
338 | #define frame_pointer_needed (crtl->frame_pointer_needed) | |
339 | #define stack_realign_fp (crtl->stack_realign_needed && !crtl->need_drap) | |
340 | #define stack_realign_drap (crtl->stack_realign_needed && crtl->need_drap) | |
341 | ||
342 | extern GTY(()) struct rtl_data x_rtl; | |
343 | ||
344 | /* Accessor to RTL datastructures. We keep them statically allocated now since | |
345 | we never keep multiple functions. For threaded compiler we might however | |
346 | want to do differently. */ | |
347 | #define crtl (&x_rtl) | |
348 | ||
96b3c03f | 349 | /* Return whether two MEM_ATTRs are equal. */ |
99b1c316 | 350 | bool mem_attrs_eq_p (const class mem_attrs *, const class mem_attrs *); |
96b3c03f | 351 | |
78528714 | 352 | /* Set the alias set of MEM to SET. */ |
4862826d | 353 | extern void set_mem_alias_set (rtx, alias_set_type); |
78528714 JQ |
354 | |
355 | /* Set the alignment of MEM to ALIGN bits. */ | |
356 | extern void set_mem_align (rtx, unsigned int); | |
357 | ||
09e881c9 BE |
358 | /* Set the address space of MEM to ADDRSPACE. */ |
359 | extern void set_mem_addr_space (rtx, addr_space_t); | |
360 | ||
78528714 JQ |
361 | /* Set the expr for MEM to EXPR. */ |
362 | extern void set_mem_expr (rtx, tree); | |
363 | ||
364 | /* Set the offset for MEM to OFFSET. */ | |
d05d7551 | 365 | extern void set_mem_offset (rtx, poly_int64); |
527210c4 RS |
366 | |
367 | /* Clear the offset recorded for MEM. */ | |
368 | extern void clear_mem_offset (rtx); | |
78528714 JQ |
369 | |
370 | /* Set the size for MEM to SIZE. */ | |
d05d7551 | 371 | extern void set_mem_size (rtx, poly_int64); |
f5541398 RS |
372 | |
373 | /* Clear the size recorded for MEM. */ | |
374 | extern void clear_mem_size (rtx); | |
78528714 | 375 | |
f6129d66 RH |
376 | /* Set the attributes for MEM appropriate for a spill slot. */ |
377 | extern void set_mem_attrs_for_spill (rtx); | |
3d7e23f6 | 378 | extern tree get_spill_slot_decl (bool); |
f6129d66 | 379 | |
78528714 JQ |
380 | /* Return a memory reference like MEMREF, but with its address changed to |
381 | ADDR. The caller is asserting that the actual piece of memory pointed | |
382 | to is the same, just the form of the address is being changed, such as | |
383 | by putting something into a register. */ | |
23b33725 | 384 | extern rtx replace_equiv_address (rtx, rtx, bool = false); |
78528714 JQ |
385 | |
386 | /* Likewise, but the reference is not required to be valid. */ | |
23b33725 | 387 | extern rtx replace_equiv_address_nv (rtx, rtx, bool = false); |
78528714 | 388 | |
5936d944 JH |
389 | extern rtx gen_blockage (void); |
390 | extern rtvec gen_rtvec (int, ...); | |
391 | extern rtx copy_insn_1 (rtx); | |
392 | extern rtx copy_insn (rtx); | |
f8f0516e | 393 | extern rtx_insn *copy_delay_slot_insn (rtx_insn *); |
0c12fc9b | 394 | extern rtx gen_int_mode (poly_int64, machine_mode); |
a1950df3 | 395 | extern rtx_insn *emit_copy_of_insn_after (rtx_insn *, rtx_insn *); |
5936d944 JH |
396 | extern void set_reg_attrs_from_value (rtx, rtx); |
397 | extern void set_reg_attrs_for_parm (rtx, rtx); | |
398 | extern void set_reg_attrs_for_decl_rtl (tree t, rtx x); | |
ef4bddc2 | 399 | extern void adjust_reg_mode (rtx, machine_mode); |
3f4853a5 | 400 | extern bool mem_expr_equal_p (const_tree, const_tree); |
0c12fc9b | 401 | extern rtx gen_int_shift_amount (machine_mode, poly_int64); |
5936d944 | 402 | |
8930883e MK |
403 | extern bool need_atomic_barrier_p (enum memmodel, bool); |
404 | ||
614d5bd8 AM |
405 | /* Return the current sequence. */ |
406 | ||
cb3e0eac | 407 | inline struct sequence_stack * |
614d5bd8 AM |
408 | get_current_sequence (void) |
409 | { | |
410 | return &crtl->emit.seq; | |
411 | } | |
412 | ||
413 | /* Return the outermost sequence. */ | |
414 | ||
cb3e0eac | 415 | inline struct sequence_stack * |
614d5bd8 AM |
416 | get_topmost_sequence (void) |
417 | { | |
418 | struct sequence_stack *seq, *top; | |
419 | ||
420 | seq = get_current_sequence (); | |
421 | do | |
422 | { | |
423 | top = seq; | |
424 | seq = seq->next; | |
425 | } while (seq); | |
426 | return top; | |
427 | } | |
428 | ||
5936d944 JH |
429 | /* Return the first insn of the current sequence or current function. */ |
430 | ||
cb3e0eac | 431 | inline rtx_insn * |
5936d944 JH |
432 | get_insns (void) |
433 | { | |
614d5bd8 | 434 | return get_current_sequence ()->first; |
5936d944 JH |
435 | } |
436 | ||
437 | /* Specify a new insn as the first in the chain. */ | |
438 | ||
cb3e0eac | 439 | inline void |
fee3e72c | 440 | set_first_insn (rtx_insn *insn) |
5936d944 | 441 | { |
06795261 | 442 | gcc_checking_assert (!insn || !PREV_INSN (insn)); |
614d5bd8 | 443 | get_current_sequence ()->first = insn; |
5936d944 JH |
444 | } |
445 | ||
446 | /* Return the last insn emitted in current sequence or current function. */ | |
447 | ||
cb3e0eac | 448 | inline rtx_insn * |
5936d944 JH |
449 | get_last_insn (void) |
450 | { | |
614d5bd8 | 451 | return get_current_sequence ()->last; |
5936d944 JH |
452 | } |
453 | ||
454 | /* Specify a new insn as the last in the chain. */ | |
455 | ||
cb3e0eac | 456 | inline void |
fee3e72c | 457 | set_last_insn (rtx_insn *insn) |
5936d944 | 458 | { |
06795261 | 459 | gcc_checking_assert (!insn || !NEXT_INSN (insn)); |
614d5bd8 | 460 | get_current_sequence ()->last = insn; |
5936d944 JH |
461 | } |
462 | ||
463 | /* Return a number larger than any instruction's uid in this function. */ | |
464 | ||
cb3e0eac | 465 | inline int |
5936d944 JH |
466 | get_max_uid (void) |
467 | { | |
468 | return crtl->emit.x_cur_insn_uid; | |
469 | } | |
d8a2d370 | 470 | |
c0cc00c4 | 471 | extern bool valid_for_const_vector_p (machine_mode, rtx); |
59d06c05 RS |
472 | extern rtx gen_const_vec_duplicate (machine_mode, rtx); |
473 | extern rtx gen_vec_duplicate (machine_mode, rtx); | |
474 | ||
ef339d6e RS |
475 | extern rtx gen_const_vec_series (machine_mode, rtx, rtx); |
476 | extern rtx gen_vec_series (machine_mode, rtx, rtx); | |
477 | ||
d8a2d370 DN |
478 | extern void set_decl_incoming_rtl (tree, rtx, bool); |
479 | ||
36566b39 PK |
480 | /* Return a memory reference like MEMREF, but with its mode changed |
481 | to MODE and its address changed to ADDR. | |
482 | (VOIDmode means don't change the mode. | |
483 | NULL for ADDR means don't change the address.) */ | |
484 | extern rtx change_address (rtx, machine_mode, rtx); | |
485 | ||
486 | /* Return a memory reference like MEMREF, but with its mode changed | |
487 | to MODE and its address offset by OFFSET bytes. */ | |
488 | #define adjust_address(MEMREF, MODE, OFFSET) \ | |
489 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 0, 0) | |
490 | ||
491 | /* Likewise, but the reference is not required to be valid. */ | |
492 | #define adjust_address_nv(MEMREF, MODE, OFFSET) \ | |
493 | adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 0, 0) | |
494 | ||
495 | /* Return a memory reference like MEMREF, but with its mode changed | |
496 | to MODE and its address offset by OFFSET bytes. Assume that it's | |
497 | for a bitfield and conservatively drop the underlying object if we | |
498 | cannot be sure to stay within its bounds. */ | |
499 | #define adjust_bitfield_address(MEMREF, MODE, OFFSET) \ | |
500 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, 0) | |
501 | ||
502 | /* As for adjust_bitfield_address, but specify that the width of | |
503 | BLKmode accesses is SIZE bytes. */ | |
504 | #define adjust_bitfield_address_size(MEMREF, MODE, OFFSET, SIZE) \ | |
505 | adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1, 1, SIZE) | |
506 | ||
507 | /* Likewise, but the reference is not required to be valid. */ | |
508 | #define adjust_bitfield_address_nv(MEMREF, MODE, OFFSET) \ | |
509 | adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1, 1, 0) | |
510 | ||
511 | /* Return a memory reference like MEMREF, but with its mode changed | |
512 | to MODE and its address changed to ADDR, which is assumed to be | |
513 | increased by OFFSET bytes from MEMREF. */ | |
514 | #define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ | |
515 | adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) | |
516 | ||
517 | /* Likewise, but the reference is not required to be valid. */ | |
518 | #define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ | |
519 | adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) | |
520 | ||
d05d7551 RS |
521 | extern rtx adjust_address_1 (rtx, machine_mode, poly_int64, int, int, |
522 | int, poly_int64); | |
36566b39 | 523 | extern rtx adjust_automodify_address_1 (rtx, machine_mode, rtx, |
d05d7551 | 524 | poly_int64, int); |
36566b39 | 525 | |
bac33a52 AC |
526 | /* Class wrapping emit_autoinc which allows derived classes to control |
527 | how reload pseudos are created. */ | |
528 | struct address_reload_context | |
529 | { | |
530 | /* Can be overriden by derived classes. */ | |
531 | virtual rtx get_reload_reg () const { return gen_reg_rtx (Pmode); } | |
532 | ||
533 | /* Emit insns to reload VALUE into a new register. VALUE is an | |
534 | auto-increment or auto-decrement RTX whose operand is a register or | |
535 | memory location; so reloading involves incrementing that location. | |
536 | ||
537 | AMOUNT is the number to increment or decrement by (always | |
538 | positive and ignored for POST_MODIFY/PRE_MODIFY). | |
539 | ||
540 | Return a pseudo containing the result. */ | |
541 | rtx emit_autoinc (rtx value, poly_int64 amount); | |
542 | }; | |
543 | ||
544 | /* Return a memory reference like MEM, but with the address reloaded into a | |
545 | pseudo register. */ | |
546 | extern rtx force_reload_address (rtx mem); | |
547 | ||
36566b39 PK |
548 | /* Return a memory reference like MEMREF, but whose address is changed by |
549 | adding OFFSET, an RTX, to it. POW2 is the highest power of two factor | |
550 | known to be in OFFSET (possibly 1). */ | |
551 | extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT); | |
552 | ||
553 | /* Given REF, a MEM, and T, either the type of X or the expression | |
554 | corresponding to REF, set the memory attributes. OBJECTP is nonzero | |
555 | if we are making a new object of this type. */ | |
556 | extern void set_mem_attributes (rtx, tree, int); | |
557 | ||
558 | /* Similar, except that BITPOS has not yet been applied to REF, so if | |
559 | we alter MEM_OFFSET according to T then we should subtract BITPOS | |
560 | expecting that it'll be added back in later. */ | |
d05d7551 | 561 | extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64); |
36566b39 PK |
562 | |
563 | /* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN | |
564 | bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or | |
565 | -1 if not known. */ | |
566 | extern int get_mem_align_offset (rtx, unsigned int); | |
567 | ||
568 | /* Return a memory reference like MEMREF, but with its mode widened to | |
569 | MODE and adjusted by OFFSET. */ | |
d05d7551 | 570 | extern rtx widen_memory_access (rtx, machine_mode, poly_int64); |
36566b39 | 571 | |
51b86113 DM |
572 | extern void maybe_set_max_label_num (rtx_code_label *x); |
573 | ||
78528714 | 574 | #endif /* GCC_EMIT_RTL_H */ |