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