Branch data Line data Source code
1 : : /* Exported functions from emit-rtl.cc
2 : : Copyright (C) 2004-2025 Free Software Foundation, Inc.
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
8 : : Software Foundation; either version 3, or (at your option) any later
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
17 : : along with GCC; see the file COPYING3. If not see
18 : : <http://www.gnu.org/licenses/>. */
19 : :
20 : : #ifndef GCC_EMIT_RTL_H
21 : : #define GCC_EMIT_RTL_H
22 : :
23 : : class temp_slot;
24 : : typedef class temp_slot *temp_slot_p;
25 : : class predefined_function_abi;
26 : : namespace rtl_ssa { class function_info; }
27 : :
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. */
33 : : poly_int64 pops_args;
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. */
38 : : poly_int64 size;
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 : :
58 : : /* Datastructures maintained for currently processed function in RTL form. */
59 : : struct GTY(()) rtl_data {
60 : : void init_stack_alignment ();
61 : :
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 : :
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 : :
77 : : rtl_ssa::function_info *GTY((skip)) ssa;
78 : :
79 : : /* For function.cc */
80 : :
81 : : /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is
82 : : defined, the needed space is pushed by the prologue. */
83 : : poly_int64 outgoing_args_size;
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;
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 : :
102 : : /* The __stack_chk_guard variable or expression holding the stack
103 : : protector canary value. */
104 : : tree stack_protect_guard_decl;
105 : :
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. */
122 : : vec<rtx, va_gc> *x_stack_slot_list;
123 : :
124 : : /* List of empty areas in the stack frame. */
125 : : class frame_space *frame_space_list;
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. */
142 : : poly_int64 x_frame_offset;
143 : :
144 : : /* The function's FUNCTION_BEG note. */
145 : : rtx_insn *x_function_beg_insn;
146 : :
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. */
154 : : class temp_slot *x_avail_temp_slots;
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 : :
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 : :
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.
238 : : Set in reload1.cc or lra-eliminations.cc if anything is allocated
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 : :
273 : : /* True if current function cannot throw. Unlike
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 : :
281 : : /* True if we performed shrink-wrapping for separate components for
282 : : the current function. */
283 : : bool shrink_wrapped_separate;
284 : :
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 : :
290 : : /* True if the stack pointer is clobbered by asm statement. */
291 : : bool sp_is_clobbered_by_asm;
292 : :
293 : : /* Nonzero if function being compiled doesn't contain any calls
294 : : (ignoring the prologue and epilogue). This is set prior to
295 : : register allocation in IRA and is valid for the remaining
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;
318 : :
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 : :
322 : : /* The highest address seen during shorten_branches. */
323 : : int max_insn_address;
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)
329 : : #define function_beg_insn (crtl->x_function_beg_insn)
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 : :
349 : : /* Return whether two MEM_ATTRs are equal. */
350 : : bool mem_attrs_eq_p (const class mem_attrs *, const class mem_attrs *);
351 : :
352 : : /* Set the alias set of MEM to SET. */
353 : : extern void set_mem_alias_set (rtx, alias_set_type);
354 : :
355 : : /* Set the alignment of MEM to ALIGN bits. */
356 : : extern void set_mem_align (rtx, unsigned int);
357 : :
358 : : /* Set the address space of MEM to ADDRSPACE. */
359 : : extern void set_mem_addr_space (rtx, addr_space_t);
360 : :
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. */
365 : : extern void set_mem_offset (rtx, poly_int64);
366 : :
367 : : /* Clear the offset recorded for MEM. */
368 : : extern void clear_mem_offset (rtx);
369 : :
370 : : /* Set the size for MEM to SIZE. */
371 : : extern void set_mem_size (rtx, poly_int64);
372 : :
373 : : /* Clear the size recorded for MEM. */
374 : : extern void clear_mem_size (rtx);
375 : :
376 : : /* Set the attributes for MEM appropriate for a spill slot. */
377 : : extern void set_mem_attrs_for_spill (rtx);
378 : : extern tree get_spill_slot_decl (bool);
379 : :
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. */
384 : : extern rtx replace_equiv_address (rtx, rtx, bool = false);
385 : :
386 : : /* Likewise, but the reference is not required to be valid. */
387 : : extern rtx replace_equiv_address_nv (rtx, rtx, bool = false);
388 : :
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);
393 : : extern rtx_insn *copy_delay_slot_insn (rtx_insn *);
394 : : extern rtx gen_int_mode (poly_int64, machine_mode);
395 : : extern rtx_insn *emit_copy_of_insn_after (rtx_insn *, rtx_insn *);
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);
399 : : extern void adjust_reg_mode (rtx, machine_mode);
400 : : extern bool mem_expr_equal_p (const_tree, const_tree);
401 : : extern rtx gen_int_shift_amount (machine_mode, poly_int64);
402 : :
403 : : extern bool need_atomic_barrier_p (enum memmodel, bool);
404 : :
405 : : /* Return the current sequence. */
406 : :
407 : : inline struct sequence_stack *
408 : 950 : get_current_sequence (void)
409 : : {
410 : 0 : return &crtl->emit.seq;
411 : : }
412 : :
413 : : /* Return the outermost sequence. */
414 : :
415 : : inline struct sequence_stack *
416 : 950 : get_topmost_sequence (void)
417 : : {
418 : 950 : struct sequence_stack *seq, *top;
419 : :
420 : 950 : seq = get_current_sequence ();
421 : 1900 : do
422 : : {
423 : 1900 : top = seq;
424 : 1900 : seq = seq->next;
425 : 1900 : } while (seq);
426 : 950 : return top;
427 : : }
428 : :
429 : : /* Return the first insn of the current sequence or current function. */
430 : :
431 : : inline rtx_insn *
432 : 1138713525 : get_insns (void)
433 : : {
434 : 957224007 : return get_current_sequence ()->first;
435 : : }
436 : :
437 : : /* Specify a new insn as the first in the chain. */
438 : :
439 : : inline void
440 : 534784562 : set_first_insn (rtx_insn *insn)
441 : : {
442 : 663575856 : gcc_checking_assert (!insn || !PREV_INSN (insn));
443 : 6518308 : get_current_sequence ()->first = insn;
444 : 4992197 : }
445 : :
446 : : /* Return the last insn emitted in current sequence or current function. */
447 : :
448 : : inline rtx_insn *
449 : 1196299297 : get_last_insn (void)
450 : : {
451 : 1016223203 : return get_current_sequence ()->last;
452 : : }
453 : :
454 : : /* Specify a new insn as the last in the chain. */
455 : :
456 : : inline void
457 : 759099606 : set_last_insn (rtx_insn *insn)
458 : : {
459 : 1112328122 : gcc_checking_assert (!insn || !NEXT_INSN (insn));
460 : 5486128 : get_current_sequence ()->last = insn;
461 : 577453063 : }
462 : :
463 : : /* Return a number larger than any instruction's uid in this function. */
464 : :
465 : : inline int
466 : 665830583 : get_max_uid (void)
467 : : {
468 : 664222720 : return crtl->emit.x_cur_insn_uid;
469 : : }
470 : :
471 : : extern bool valid_for_const_vector_p (machine_mode, rtx);
472 : : extern rtx gen_const_vec_duplicate (machine_mode, rtx);
473 : : extern rtx gen_vec_duplicate (machine_mode, rtx);
474 : :
475 : : extern rtx gen_const_vec_series (machine_mode, rtx, rtx);
476 : : extern rtx gen_vec_series (machine_mode, rtx, rtx);
477 : :
478 : : extern void set_decl_incoming_rtl (tree, rtx, bool);
479 : :
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 : :
521 : : extern rtx adjust_address_1 (rtx, machine_mode, poly_int64, int, int,
522 : : int, poly_int64);
523 : : extern rtx adjust_automodify_address_1 (rtx, machine_mode, rtx,
524 : : poly_int64, int);
525 : :
526 : : /* Class wrapping emit_autoinc which allows derived classes to control
527 : : how reload pseudos are created. */
528 : 0 : struct address_reload_context
529 : : {
530 : : /* Can be overriden by derived classes. */
531 : 0 : 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 : :
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. */
561 : : extern void set_mem_attributes_minus_bitpos (rtx, tree, int, poly_int64);
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. */
570 : : extern rtx widen_memory_access (rtx, machine_mode, poly_int64);
571 : :
572 : : extern void maybe_set_max_label_num (rtx_code_label *x);
573 : :
574 : : #endif /* GCC_EMIT_RTL_H */
|
