Mercurial > hg > CbC > CbC_gcc
annotate gcc/expr.h @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 12 Feb 2010 23:39:51 +0900 |
| parents | a06113de4d67 |
| children | b7f97abdc517 |
| rev | line source |
|---|---|
| 0 | 1 /* Definitions for code generation pass of GNU compiler. |
| 2 Copyright (C) 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, | |
| 3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 | |
| 4 Free Software Foundation, Inc. | |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify it under | |
| 9 the terms of the GNU General Public License as published by the Free | |
| 10 Software Foundation; either version 3, or (at your option) any later | |
| 11 version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 #ifndef GCC_EXPR_H | |
| 23 #define GCC_EXPR_H | |
| 24 | |
| 25 /* For inhibit_defer_pop */ | |
| 26 #include "function.h" | |
| 27 /* For XEXP, GEN_INT, rtx_code */ | |
| 28 #include "rtl.h" | |
| 29 /* For optimize_size */ | |
| 30 #include "flags.h" | |
| 31 /* For host_integerp, tree_low_cst, fold_convert, size_binop, ssize_int, | |
| 32 TREE_CODE, TYPE_SIZE, int_size_in_bytes, */ | |
| 33 #include "tree.h" | |
| 34 /* For GET_MODE_BITSIZE, word_mode */ | |
| 35 #include "machmode.h" | |
| 36 | |
| 37 /* The default branch cost is 1. */ | |
| 38 #ifndef BRANCH_COST | |
| 39 #define BRANCH_COST(speed_p, predictable_p) 1 | |
| 40 #endif | |
| 41 | |
| 42 /* This is the 4th arg to `expand_expr'. | |
| 43 EXPAND_STACK_PARM means we are possibly expanding a call param onto | |
| 44 the stack. | |
| 45 EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx. | |
| 46 EXPAND_INITIALIZER is similar but also record any labels on forced_labels. | |
| 47 EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address | |
| 48 is a constant that is not a legitimate address. | |
| 49 EXPAND_WRITE means we are only going to write to the resulting rtx. | |
| 50 EXPAND_MEMORY means we are interested in a memory result, even if | |
| 51 the memory is constant and we could have propagated a constant value. */ | |
| 52 enum expand_modifier {EXPAND_NORMAL = 0, EXPAND_STACK_PARM, EXPAND_SUM, | |
| 53 EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER, EXPAND_WRITE, | |
| 54 EXPAND_MEMORY}; | |
| 55 | |
| 56 /* Prevent the compiler from deferring stack pops. See | |
| 57 inhibit_defer_pop for more information. */ | |
| 58 #define NO_DEFER_POP (inhibit_defer_pop += 1) | |
| 59 | |
| 60 /* Allow the compiler to defer stack pops. See inhibit_defer_pop for | |
| 61 more information. */ | |
| 62 #define OK_DEFER_POP (inhibit_defer_pop -= 1) | |
| 63 | |
| 64 /* If a memory-to-memory move would take MOVE_RATIO or more simple | |
| 65 move-instruction sequences, we will do a movmem or libcall instead. */ | |
| 66 | |
| 67 #ifndef MOVE_RATIO | |
| 68 #if defined (HAVE_movmemqi) || defined (HAVE_movmemhi) || defined (HAVE_movmemsi) || defined (HAVE_movmemdi) || defined (HAVE_movmemti) | |
| 69 #define MOVE_RATIO(speed) 2 | |
| 70 #else | |
| 71 /* If we are optimizing for space (-Os), cut down the default move ratio. */ | |
| 72 #define MOVE_RATIO(speed) ((speed) ? 15 : 3) | |
| 73 #endif | |
| 74 #endif | |
| 75 | |
| 76 /* If a clear memory operation would take CLEAR_RATIO or more simple | |
| 77 move-instruction sequences, we will do a setmem or libcall instead. */ | |
| 78 | |
| 79 #ifndef CLEAR_RATIO | |
| 80 #if defined (HAVE_setmemqi) || defined (HAVE_setmemhi) || defined (HAVE_setmemsi) || defined (HAVE_setmemdi) || defined (HAVE_setmemti) | |
| 81 #define CLEAR_RATIO(speed) 2 | |
| 82 #else | |
| 83 /* If we are optimizing for space, cut down the default clear ratio. */ | |
| 84 #define CLEAR_RATIO(speed) ((speed) ? 15 :3) | |
| 85 #endif | |
| 86 #endif | |
| 87 | |
| 88 /* If a memory set (to value other than zero) operation would take | |
| 89 SET_RATIO or more simple move-instruction sequences, we will do a movmem | |
| 90 or libcall instead. */ | |
| 91 #ifndef SET_RATIO | |
| 92 #define SET_RATIO(speed) MOVE_RATIO(speed) | |
| 93 #endif | |
| 94 | |
| 95 enum direction {none, upward, downward}; | |
| 96 | |
| 97 /* Structure to record the size of a sequence of arguments | |
| 98 as the sum of a tree-expression and a constant. This structure is | |
| 99 also used to store offsets from the stack, which might be negative, | |
| 100 so the variable part must be ssizetype, not sizetype. */ | |
| 101 | |
| 102 struct args_size | |
| 103 { | |
| 104 HOST_WIDE_INT constant; | |
| 105 tree var; | |
| 106 }; | |
| 107 | |
| 108 /* Package up various arg related fields of struct args for | |
| 109 locate_and_pad_parm. */ | |
| 110 struct locate_and_pad_arg_data | |
| 111 { | |
| 112 /* Size of this argument on the stack, rounded up for any padding it | |
| 113 gets. If REG_PARM_STACK_SPACE is defined, then register parms are | |
| 114 counted here, otherwise they aren't. */ | |
| 115 struct args_size size; | |
| 116 /* Offset of this argument from beginning of stack-args. */ | |
| 117 struct args_size offset; | |
| 118 /* Offset to the start of the stack slot. Different from OFFSET | |
| 119 if this arg pads downward. */ | |
| 120 struct args_size slot_offset; | |
| 121 /* The amount that the stack pointer needs to be adjusted to | |
| 122 force alignment for the next argument. */ | |
| 123 struct args_size alignment_pad; | |
| 124 /* Which way we should pad this arg. */ | |
| 125 enum direction where_pad; | |
| 126 /* slot_offset is at least this aligned. */ | |
| 127 unsigned int boundary; | |
| 128 }; | |
| 129 | |
| 130 /* Add the value of the tree INC to the `struct args_size' TO. */ | |
| 131 | |
| 132 #define ADD_PARM_SIZE(TO, INC) \ | |
| 133 do { \ | |
| 134 tree inc = (INC); \ | |
| 135 if (host_integerp (inc, 0)) \ | |
| 136 (TO).constant += tree_low_cst (inc, 0); \ | |
| 137 else if ((TO).var == 0) \ | |
| 138 (TO).var = fold_convert (ssizetype, inc); \ | |
| 139 else \ | |
| 140 (TO).var = size_binop (PLUS_EXPR, (TO).var, \ | |
| 141 fold_convert (ssizetype, inc)); \ | |
| 142 } while (0) | |
| 143 | |
| 144 #define SUB_PARM_SIZE(TO, DEC) \ | |
| 145 do { \ | |
| 146 tree dec = (DEC); \ | |
| 147 if (host_integerp (dec, 0)) \ | |
| 148 (TO).constant -= tree_low_cst (dec, 0); \ | |
| 149 else if ((TO).var == 0) \ | |
| 150 (TO).var = size_binop (MINUS_EXPR, ssize_int (0), \ | |
| 151 fold_convert (ssizetype, dec)); \ | |
| 152 else \ | |
| 153 (TO).var = size_binop (MINUS_EXPR, (TO).var, \ | |
| 154 fold_convert (ssizetype, dec)); \ | |
| 155 } while (0) | |
| 156 | |
| 157 /* Convert the implicit sum in a `struct args_size' into a tree | |
| 158 of type ssizetype. */ | |
| 159 #define ARGS_SIZE_TREE(SIZE) \ | |
| 160 ((SIZE).var == 0 ? ssize_int ((SIZE).constant) \ | |
| 161 : size_binop (PLUS_EXPR, fold_convert (ssizetype, (SIZE).var), \ | |
| 162 ssize_int ((SIZE).constant))) | |
| 163 | |
| 164 /* Convert the implicit sum in a `struct args_size' into an rtx. */ | |
| 165 #define ARGS_SIZE_RTX(SIZE) \ | |
| 166 ((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \ | |
| 167 : expand_normal (ARGS_SIZE_TREE (SIZE))) | |
| 168 | |
| 169 /* Supply a default definition for FUNCTION_ARG_PADDING: | |
| 170 usually pad upward, but pad short args downward on | |
| 171 big-endian machines. */ | |
| 172 | |
| 173 #define DEFAULT_FUNCTION_ARG_PADDING(MODE, TYPE) \ | |
| 174 (! BYTES_BIG_ENDIAN \ | |
| 175 ? upward \ | |
| 176 : (((MODE) == BLKmode \ | |
| 177 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \ | |
| 178 && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \ | |
| 179 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \ | |
| 180 ? downward : upward)) | |
| 181 | |
| 182 #ifndef FUNCTION_ARG_PADDING | |
| 183 #define FUNCTION_ARG_PADDING(MODE, TYPE) \ | |
| 184 DEFAULT_FUNCTION_ARG_PADDING ((MODE), (TYPE)) | |
| 185 #endif | |
| 186 | |
| 187 /* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let | |
| 188 FUNCTION_ARG_PADDING, which also pads the length, handle any needed | |
| 189 alignment. */ | |
| 190 | |
| 191 #ifndef FUNCTION_ARG_BOUNDARY | |
| 192 #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY | |
| 193 #endif | |
| 194 | |
| 195 /* Supply a default definition of STACK_SAVEAREA_MODE for emit_stack_save. | |
| 196 Normally move_insn, so Pmode stack pointer. */ | |
| 197 | |
| 198 #ifndef STACK_SAVEAREA_MODE | |
| 199 #define STACK_SAVEAREA_MODE(LEVEL) Pmode | |
| 200 #endif | |
| 201 | |
| 202 /* Supply a default definition of STACK_SIZE_MODE for | |
| 203 allocate_dynamic_stack_space. Normally PLUS/MINUS, so word_mode. */ | |
| 204 | |
| 205 #ifndef STACK_SIZE_MODE | |
| 206 #define STACK_SIZE_MODE word_mode | |
| 207 #endif | |
| 208 | |
| 209 /* Provide default values for the macros controlling stack checking. */ | |
| 210 | |
| 211 /* The default is neither full builtin stack checking... */ | |
| 212 #ifndef STACK_CHECK_BUILTIN | |
| 213 #define STACK_CHECK_BUILTIN 0 | |
| 214 #endif | |
| 215 | |
| 216 /* ...nor static builtin stack checking. */ | |
| 217 #ifndef STACK_CHECK_STATIC_BUILTIN | |
| 218 #define STACK_CHECK_STATIC_BUILTIN 0 | |
| 219 #endif | |
| 220 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
221 /* The default interval is one page (4096 bytes). */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
222 #ifndef STACK_CHECK_PROBE_INTERVAL_EXP |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
223 #define STACK_CHECK_PROBE_INTERVAL_EXP 12 |
| 0 | 224 #endif |
| 225 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
226 /* The default is not to move the stack pointer. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
227 #ifndef STACK_CHECK_MOVING_SP |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
228 #define STACK_CHECK_MOVING_SP 0 |
| 0 | 229 #endif |
| 230 | |
| 231 /* This is a kludge to try to capture the discrepancy between the old | |
| 232 mechanism (generic stack checking) and the new mechanism (static | |
| 233 builtin stack checking). STACK_CHECK_PROTECT needs to be bumped | |
| 234 for the latter because part of the protection area is effectively | |
| 235 included in STACK_CHECK_MAX_FRAME_SIZE for the former. */ | |
| 236 #ifdef STACK_CHECK_PROTECT | |
| 237 #define STACK_OLD_CHECK_PROTECT STACK_CHECK_PROTECT | |
| 238 #else | |
| 239 #define STACK_OLD_CHECK_PROTECT \ | |
| 240 (USING_SJLJ_EXCEPTIONS ? 75 * UNITS_PER_WORD : 8 * 1024) | |
| 241 #endif | |
| 242 | |
| 243 /* Minimum amount of stack required to recover from an anticipated stack | |
| 244 overflow detection. The default value conveys an estimate of the amount | |
| 245 of stack required to propagate an exception. */ | |
| 246 #ifndef STACK_CHECK_PROTECT | |
| 247 #define STACK_CHECK_PROTECT \ | |
| 248 (USING_SJLJ_EXCEPTIONS ? 75 * UNITS_PER_WORD : 12 * 1024) | |
| 249 #endif | |
| 250 | |
| 251 /* Make the maximum frame size be the largest we can and still only need | |
| 252 one probe per function. */ | |
| 253 #ifndef STACK_CHECK_MAX_FRAME_SIZE | |
| 254 #define STACK_CHECK_MAX_FRAME_SIZE \ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
255 ((1 << STACK_CHECK_PROBE_INTERVAL_EXP) - UNITS_PER_WORD) |
| 0 | 256 #endif |
| 257 | |
| 258 /* This is arbitrary, but should be large enough everywhere. */ | |
| 259 #ifndef STACK_CHECK_FIXED_FRAME_SIZE | |
| 260 #define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD) | |
| 261 #endif | |
| 262 | |
| 263 /* Provide a reasonable default for the maximum size of an object to | |
| 264 allocate in the fixed frame. We may need to be able to make this | |
| 265 controllable by the user at some point. */ | |
| 266 #ifndef STACK_CHECK_MAX_VAR_SIZE | |
| 267 #define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100) | |
| 268 #endif | |
| 269 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
270 /* This structure is used to pass around information about exploded |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
271 unary, binary and trinary expressions between expand_expr_real_1 and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
272 friends. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
273 typedef struct separate_ops |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
274 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
275 enum tree_code code; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
276 tree type; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
277 tree op0, op1, op2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
278 location_t location; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
279 } *sepops; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
280 |
| 0 | 281 /* Functions from optabs.c, commonly used, and without need for the optabs |
| 282 tables: */ | |
| 283 | |
| 284 /* Passed to expand_simple_binop and expand_binop to say which options | |
| 285 to try to use if the requested operation can't be open-coded on the | |
| 286 requisite mode. Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using | |
| 287 a library call. Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try | |
| 288 using a wider mode. OPTAB_MUST_WIDEN says try widening and don't | |
| 289 try anything else. */ | |
| 290 | |
| 291 enum optab_methods | |
| 292 { | |
| 293 OPTAB_DIRECT, | |
| 294 OPTAB_LIB, | |
| 295 OPTAB_WIDEN, | |
| 296 OPTAB_LIB_WIDEN, | |
| 297 OPTAB_MUST_WIDEN | |
| 298 }; | |
| 299 | |
| 300 /* Generate code for a simple binary or unary operation. "Simple" in | |
| 301 this case means "can be unambiguously described by a (mode, code) | |
| 302 pair and mapped to a single optab." */ | |
| 303 extern rtx expand_simple_binop (enum machine_mode, enum rtx_code, rtx, | |
| 304 rtx, rtx, int, enum optab_methods); | |
| 305 extern rtx expand_simple_unop (enum machine_mode, enum rtx_code, rtx, rtx, | |
| 306 int); | |
| 307 | |
| 308 /* Report whether the machine description contains an insn which can | |
| 309 perform the operation described by CODE and MODE. */ | |
| 310 extern int have_insn_for (enum rtx_code, enum machine_mode); | |
| 311 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
312 extern rtx prepare_operand (int, rtx, int, enum machine_mode, enum machine_mode, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
313 int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
314 |
| 0 | 315 /* Emit code to make a call to a constant function or a library call. */ |
| 316 extern void emit_libcall_block (rtx, rtx, rtx, rtx); | |
| 317 | |
| 318 /* Create but don't emit one rtl instruction to perform certain operations. | |
| 319 Modes must match; operands must meet the operation's predicates. | |
| 320 Likewise for subtraction and for just copying. */ | |
| 321 extern rtx gen_add2_insn (rtx, rtx); | |
| 322 extern rtx gen_add3_insn (rtx, rtx, rtx); | |
| 323 extern rtx gen_sub2_insn (rtx, rtx); | |
| 324 extern rtx gen_sub3_insn (rtx, rtx, rtx); | |
| 325 extern rtx gen_move_insn (rtx, rtx); | |
| 326 extern int have_add2_insn (rtx, rtx); | |
| 327 extern int have_sub2_insn (rtx, rtx); | |
| 328 | |
| 329 /* Emit a pair of rtl insns to compare two rtx's and to jump | |
| 330 to a label if the comparison is true. */ | |
| 331 extern void emit_cmp_and_jump_insns (rtx, rtx, enum rtx_code, rtx, | |
| 332 enum machine_mode, int, rtx); | |
| 333 | |
| 334 /* Generate code to indirectly jump to a location given in the rtx LOC. */ | |
| 335 extern void emit_indirect_jump (rtx); | |
| 336 | |
| 337 /* Generate a conditional trap instruction. */ | |
| 338 extern rtx gen_cond_trap (enum rtx_code, rtx, rtx, rtx); | |
| 339 | |
| 340 #include "insn-config.h" | |
| 341 | |
| 342 #ifdef HAVE_conditional_move | |
| 343 /* Emit a conditional move operation. */ | |
| 344 rtx emit_conditional_move (rtx, enum rtx_code, rtx, rtx, enum machine_mode, | |
| 345 rtx, rtx, enum machine_mode, int); | |
| 346 | |
| 347 /* Return nonzero if the conditional move is supported. */ | |
| 348 int can_conditionally_move_p (enum machine_mode mode); | |
| 349 | |
| 350 #endif | |
| 351 rtx emit_conditional_add (rtx, enum rtx_code, rtx, rtx, enum machine_mode, | |
| 352 rtx, rtx, enum machine_mode, int); | |
| 353 | |
| 354 rtx expand_val_compare_and_swap (rtx, rtx, rtx, rtx); | |
| 355 rtx expand_bool_compare_and_swap (rtx, rtx, rtx, rtx); | |
| 356 rtx expand_sync_operation (rtx, rtx, enum rtx_code); | |
| 357 rtx expand_sync_fetch_operation (rtx, rtx, enum rtx_code, bool, rtx); | |
| 358 rtx expand_sync_lock_test_and_set (rtx, rtx, rtx); | |
| 359 | |
| 360 /* Functions from expmed.c: */ | |
| 361 | |
| 362 /* Arguments MODE, RTX: return an rtx for the negation of that value. | |
| 363 May emit insns. */ | |
| 364 extern rtx negate_rtx (enum machine_mode, rtx); | |
| 365 | |
| 366 /* Expand a logical AND operation. */ | |
| 367 extern rtx expand_and (enum machine_mode, rtx, rtx, rtx); | |
| 368 | |
| 369 /* Emit a store-flag operation. */ | |
| 370 extern rtx emit_store_flag (rtx, enum rtx_code, rtx, rtx, enum machine_mode, | |
| 371 int, int); | |
| 372 | |
| 373 /* Like emit_store_flag, but always succeeds. */ | |
| 374 extern rtx emit_store_flag_force (rtx, enum rtx_code, rtx, rtx, | |
| 375 enum machine_mode, int, int); | |
| 376 | |
| 377 /* Functions from builtins.c: */ | |
| 378 extern rtx expand_builtin (tree, rtx, rtx, enum machine_mode, int); | |
| 379 extern tree std_build_builtin_va_list (void); | |
| 380 extern tree std_fn_abi_va_list (tree); | |
| 381 extern tree std_canonical_va_list_type (tree); | |
| 382 | |
| 383 extern void std_expand_builtin_va_start (tree, rtx); | |
| 384 extern rtx default_expand_builtin (tree, rtx, rtx, enum machine_mode, int); | |
| 385 extern void expand_builtin_setjmp_setup (rtx, rtx); | |
| 386 extern void expand_builtin_setjmp_receiver (rtx); | |
| 387 extern rtx expand_builtin_saveregs (void); | |
| 388 extern void expand_builtin_trap (void); | |
| 389 extern rtx builtin_strncpy_read_str (void *, HOST_WIDE_INT, enum machine_mode); | |
| 390 | |
| 391 /* Functions from expr.c: */ | |
| 392 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
393 /* This is run during target initialization to set up which modes can be |
| 0 | 394 used directly in memory and to initialize the block move optab. */ |
| 395 extern void init_expr_target (void); | |
| 396 | |
| 397 /* This is run at the start of compiling a function. */ | |
| 398 extern void init_expr (void); | |
| 399 | |
| 400 /* Emit some rtl insns to move data between rtx's, converting machine modes. | |
| 401 Both modes must be floating or both fixed. */ | |
| 402 extern void convert_move (rtx, rtx, int); | |
| 403 | |
| 404 /* Convert an rtx to specified machine mode and return the result. */ | |
| 405 extern rtx convert_to_mode (enum machine_mode, rtx, int); | |
| 406 | |
| 407 /* Convert an rtx to MODE from OLDMODE and return the result. */ | |
| 408 extern rtx convert_modes (enum machine_mode, enum machine_mode, rtx, int); | |
| 409 | |
| 410 /* Emit code to move a block Y to a block X. */ | |
| 411 | |
| 412 enum block_op_methods | |
| 413 { | |
| 414 BLOCK_OP_NORMAL, | |
| 415 BLOCK_OP_NO_LIBCALL, | |
| 416 BLOCK_OP_CALL_PARM, | |
| 417 /* Like BLOCK_OP_NORMAL, but the libcall can be tail call optimized. */ | |
| 418 BLOCK_OP_TAILCALL | |
| 419 }; | |
| 420 | |
| 421 extern GTY(()) tree block_clear_fn; | |
| 422 extern void init_block_move_fn (const char *); | |
| 423 extern void init_block_clear_fn (const char *); | |
| 424 | |
| 425 extern rtx emit_block_move (rtx, rtx, rtx, enum block_op_methods); | |
| 426 extern rtx emit_block_move_via_libcall (rtx, rtx, rtx, bool); | |
| 427 extern rtx emit_block_move_hints (rtx, rtx, rtx, enum block_op_methods, | |
| 428 unsigned int, HOST_WIDE_INT); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 extern bool emit_storent_insn (rtx to, rtx from); |
| 0 | 430 |
| 431 /* Copy all or part of a value X into registers starting at REGNO. | |
| 432 The number of registers to be filled is NREGS. */ | |
| 433 extern void move_block_to_reg (int, rtx, int, enum machine_mode); | |
| 434 | |
| 435 /* Copy all or part of a BLKmode value X out of registers starting at REGNO. | |
| 436 The number of registers to be filled is NREGS. */ | |
| 437 extern void move_block_from_reg (int, rtx, int); | |
| 438 | |
| 439 /* Generate a non-consecutive group of registers represented by a PARALLEL. */ | |
| 440 extern rtx gen_group_rtx (rtx); | |
| 441 | |
| 442 /* Load a BLKmode value into non-consecutive registers represented by a | |
| 443 PARALLEL. */ | |
| 444 extern void emit_group_load (rtx, rtx, tree, int); | |
| 445 | |
| 446 /* Similarly, but load into new temporaries. */ | |
| 447 extern rtx emit_group_load_into_temps (rtx, rtx, tree, int); | |
| 448 | |
| 449 /* Move a non-consecutive group of registers represented by a PARALLEL into | |
| 450 a non-consecutive group of registers represented by a PARALLEL. */ | |
| 451 extern void emit_group_move (rtx, rtx); | |
| 452 | |
| 453 /* Move a group of registers represented by a PARALLEL into pseudos. */ | |
| 454 extern rtx emit_group_move_into_temps (rtx); | |
| 455 | |
| 456 /* Store a BLKmode value from non-consecutive registers represented by a | |
| 457 PARALLEL. */ | |
| 458 extern void emit_group_store (rtx, rtx, tree, int); | |
| 459 | |
| 460 /* Copy BLKmode object from a set of registers. */ | |
| 461 extern rtx copy_blkmode_from_reg (rtx, rtx, tree); | |
| 462 | |
| 463 /* Mark REG as holding a parameter for the next CALL_INSN. */ | |
| 464 extern void use_reg (rtx *, rtx); | |
| 465 | |
| 466 /* Mark NREGS consecutive regs, starting at REGNO, as holding parameters | |
| 467 for the next CALL_INSN. */ | |
| 468 extern void use_regs (rtx *, int, int); | |
| 469 | |
| 470 /* Mark a PARALLEL as holding a parameter for the next CALL_INSN. */ | |
| 471 extern void use_group_regs (rtx *, rtx); | |
| 472 | |
| 473 /* Write zeros through the storage of OBJECT. | |
| 474 If OBJECT has BLKmode, SIZE is its length in bytes. */ | |
| 475 extern rtx clear_storage (rtx, rtx, enum block_op_methods); | |
| 476 extern rtx clear_storage_hints (rtx, rtx, enum block_op_methods, | |
| 477 unsigned int, HOST_WIDE_INT); | |
| 478 /* The same, but always output an library call. */ | |
| 479 rtx set_storage_via_libcall (rtx, rtx, rtx, bool); | |
| 480 | |
| 481 /* Expand a setmem pattern; return true if successful. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
482 extern bool set_storage_via_setmem (rtx, rtx, rtx, unsigned int, |
| 0 | 483 unsigned int, HOST_WIDE_INT); |
| 484 | |
| 485 /* Determine whether the LEN bytes can be moved by using several move | |
| 486 instructions. Return nonzero if a call to move_by_pieces should | |
| 487 succeed. */ | |
| 488 extern int can_move_by_pieces (unsigned HOST_WIDE_INT, unsigned int); | |
| 489 | |
| 490 /* Return nonzero if it is desirable to store LEN bytes generated by | |
| 491 CONSTFUN with several move instructions by store_by_pieces | |
| 492 function. CONSTFUNDATA is a pointer which will be passed as argument | |
| 493 in every CONSTFUN call. | |
| 494 ALIGN is maximum alignment we can assume. | |
| 495 MEMSETP is true if this is a real memset/bzero, not a copy | |
| 496 of a const string. */ | |
| 497 extern int can_store_by_pieces (unsigned HOST_WIDE_INT, | |
| 498 rtx (*) (void *, HOST_WIDE_INT, | |
| 499 enum machine_mode), | |
| 500 void *, unsigned int, bool); | |
| 501 | |
| 502 /* Generate several move instructions to store LEN bytes generated by | |
| 503 CONSTFUN to block TO. (A MEM rtx with BLKmode). CONSTFUNDATA is a | |
| 504 pointer which will be passed as argument in every CONSTFUN call. | |
| 505 ALIGN is maximum alignment we can assume. | |
| 506 MEMSETP is true if this is a real memset/bzero, not a copy. | |
| 507 Returns TO + LEN. */ | |
| 508 extern rtx store_by_pieces (rtx, unsigned HOST_WIDE_INT, | |
| 509 rtx (*) (void *, HOST_WIDE_INT, enum machine_mode), | |
| 510 void *, unsigned int, bool, int); | |
| 511 | |
| 512 /* Emit insns to set X from Y. */ | |
| 513 extern rtx emit_move_insn (rtx, rtx); | |
| 514 | |
| 515 /* Emit insns to set X from Y, with no frills. */ | |
| 516 extern rtx emit_move_insn_1 (rtx, rtx); | |
| 517 | |
| 518 extern rtx emit_move_complex_push (enum machine_mode, rtx, rtx); | |
| 519 extern rtx emit_move_complex_parts (rtx, rtx); | |
| 520 | |
| 521 /* Push a block of length SIZE (perhaps variable) | |
| 522 and return an rtx to address the beginning of the block. */ | |
| 523 extern rtx push_block (rtx, int, int); | |
| 524 | |
| 525 /* Generate code to push something onto the stack, given its mode and type. */ | |
| 526 extern void emit_push_insn (rtx, enum machine_mode, tree, rtx, unsigned int, | |
| 527 int, rtx, int, rtx, rtx, int, rtx); | |
| 528 | |
| 529 /* Expand an assignment that stores the value of FROM into TO. */ | |
| 530 extern void expand_assignment (tree, tree, bool); | |
| 531 | |
| 532 /* Generate code for computing expression EXP, | |
| 533 and storing the value into TARGET. | |
| 534 If SUGGEST_REG is nonzero, copy the value through a register | |
| 535 and return that register, if that is possible. */ | |
| 536 extern rtx store_expr (tree, rtx, int, bool); | |
| 537 | |
| 538 /* Given an rtx that may include add and multiply operations, | |
| 539 generate them as insns and return a pseudo-reg containing the value. | |
| 540 Useful after calling expand_expr with 1 as sum_ok. */ | |
| 541 extern rtx force_operand (rtx, rtx); | |
| 542 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
543 /* Work horses for expand_expr. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
544 extern rtx expand_expr_real (tree, rtx, enum machine_mode, |
| 0 | 545 enum expand_modifier, rtx *); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
546 extern rtx expand_expr_real_1 (tree, rtx, enum machine_mode, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
547 enum expand_modifier, rtx *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
548 extern rtx expand_expr_real_2 (sepops, rtx, enum machine_mode, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
549 enum expand_modifier); |
| 0 | 550 |
| 551 /* Generate code for computing expression EXP. | |
| 552 An rtx for the computed value is returned. The value is never null. | |
| 553 In the case of a void EXP, const0_rtx is returned. */ | |
| 554 static inline rtx | |
| 555 expand_expr (tree exp, rtx target, enum machine_mode mode, | |
| 556 enum expand_modifier modifier) | |
| 557 { | |
| 558 return expand_expr_real (exp, target, mode, modifier, NULL); | |
| 559 } | |
| 560 | |
| 561 static inline rtx | |
| 562 expand_normal (tree exp) | |
| 563 { | |
| 564 return expand_expr_real (exp, NULL_RTX, VOIDmode, EXPAND_NORMAL, NULL); | |
| 565 } | |
| 566 | |
| 567 /* At the start of a function, record that we have no previously-pushed | |
| 568 arguments waiting to be popped. */ | |
| 569 extern void init_pending_stack_adjust (void); | |
| 570 | |
| 571 /* Discard any pending stack adjustment. */ | |
| 572 extern void discard_pending_stack_adjust (void); | |
| 573 | |
| 574 /* When exiting from function, if safe, clear out any pending stack adjust | |
| 575 so the adjustment won't get done. */ | |
| 576 extern void clear_pending_stack_adjust (void); | |
| 577 | |
| 578 /* Pop any previously-pushed arguments that have not been popped yet. */ | |
| 579 extern void do_pending_stack_adjust (void); | |
| 580 | |
| 581 /* Return the tree node and offset if a given argument corresponds to | |
| 582 a string constant. */ | |
| 583 extern tree string_constant (tree, tree *); | |
| 584 | |
| 585 /* Generate code to evaluate EXP and jump to LABEL if the value is zero. */ | |
| 586 extern void jumpifnot (tree, rtx); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
587 extern void jumpifnot_1 (enum tree_code, tree, tree, rtx); |
| 0 | 588 |
| 589 /* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */ | |
| 590 extern void jumpif (tree, rtx); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
591 extern void jumpif_1 (enum tree_code, tree, tree, rtx); |
| 0 | 592 |
| 593 /* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if | |
| 594 the result is zero, or IF_TRUE_LABEL if the result is one. */ | |
| 595 extern void do_jump (tree, rtx, rtx); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
596 extern void do_jump_1 (enum tree_code, tree, tree, rtx, rtx); |
| 0 | 597 |
| 598 extern void do_compare_rtx_and_jump (rtx, rtx, enum rtx_code, int, | |
| 599 enum machine_mode, rtx, rtx, rtx); | |
| 600 | |
| 601 /* Two different ways of generating switch statements. */ | |
| 602 extern int try_casesi (tree, tree, tree, tree, rtx, rtx, rtx); | |
| 603 extern int try_tablejump (tree, tree, tree, tree, rtx, rtx); | |
| 604 | |
| 605 /* Functions from alias.c */ | |
| 606 #include "alias.h" | |
| 607 | |
| 608 | |
| 609 /* rtl.h and tree.h were included. */ | |
| 610 /* Return an rtx for the size in bytes of the value of an expr. */ | |
| 611 extern rtx expr_size (tree); | |
| 612 | |
| 613 /* Return a wide integer for the size in bytes of the value of EXP, or -1 | |
| 614 if the size can vary or is larger than an integer. */ | |
| 615 extern HOST_WIDE_INT int_expr_size (tree); | |
| 616 | |
| 617 /* Return an rtx that refers to the value returned by a function | |
| 618 in its original home. This becomes invalid if any more code is emitted. */ | |
| 619 extern rtx hard_function_value (const_tree, const_tree, const_tree, int); | |
| 620 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
621 extern rtx prepare_call_address (tree, rtx, rtx, rtx *, int, int); |
| 0 | 622 |
| 623 extern bool shift_return_value (enum machine_mode, bool, rtx); | |
| 624 | |
| 625 extern rtx expand_call (tree, rtx, int); | |
| 626 | |
| 627 extern void fixup_tail_calls (void); | |
| 628 | |
| 629 #ifdef TREE_CODE | |
| 630 extern rtx expand_shift (enum tree_code, enum machine_mode, rtx, tree, rtx, | |
| 631 int); | |
| 632 extern rtx expand_divmod (int, enum tree_code, enum machine_mode, rtx, rtx, | |
| 633 rtx, int); | |
| 634 #endif | |
| 635 | |
| 636 extern void locate_and_pad_parm (enum machine_mode, tree, int, int, tree, | |
| 637 struct args_size *, | |
| 638 struct locate_and_pad_arg_data *); | |
| 639 | |
| 640 /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */ | |
| 641 extern rtx label_rtx (tree); | |
| 642 | |
| 643 /* As label_rtx, but additionally the label is placed on the forced label | |
| 644 list of its containing function (i.e. it is treated as reachable even | |
| 645 if how is not obvious). */ | |
| 646 extern rtx force_label_rtx (tree); | |
| 647 | |
| 648 /* Return an rtx like arg but sans any constant terms. | |
| 649 Returns the original rtx if it has no constant terms. | |
| 650 The constant terms are added and stored via a second arg. */ | |
| 651 extern rtx eliminate_constant_term (rtx, rtx *); | |
| 652 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
653 /* Convert arg to a valid memory address for specified machine mode that points |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
654 to a specific named address space, by emitting insns to perform arithmetic |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
655 if necessary. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
656 extern rtx memory_address_addr_space (enum machine_mode, 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
|
657 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
658 /* Like memory_address_addr_space, except assume the memory address points to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
659 the generic named address space. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
660 #define memory_address(MODE,RTX) \ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
661 memory_address_addr_space ((MODE), (RTX), ADDR_SPACE_GENERIC) |
| 0 | 662 |
| 663 /* Return a memory reference like MEMREF, but with its mode changed | |
| 664 to MODE and its address changed to ADDR. | |
| 665 (VOIDmode means don't change the mode. | |
| 666 NULL for ADDR means don't change the address.) */ | |
| 667 extern rtx change_address (rtx, enum machine_mode, rtx); | |
| 668 | |
| 669 /* Return a memory reference like MEMREF, but with its mode changed | |
| 670 to MODE and its address offset by OFFSET bytes. */ | |
| 671 #define adjust_address(MEMREF, MODE, OFFSET) \ | |
| 672 adjust_address_1 (MEMREF, MODE, OFFSET, 1, 1) | |
| 673 | |
| 674 /* Likewise, but the reference is not required to be valid. */ | |
| 675 #define adjust_address_nv(MEMREF, MODE, OFFSET) \ | |
| 676 adjust_address_1 (MEMREF, MODE, OFFSET, 0, 1) | |
| 677 | |
| 678 /* Return a memory reference like MEMREF, but with its mode changed | |
| 679 to MODE and its address changed to ADDR, which is assumed to be | |
| 680 increased by OFFSET bytes from MEMREF. */ | |
| 681 #define adjust_automodify_address(MEMREF, MODE, ADDR, OFFSET) \ | |
| 682 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 1) | |
| 683 | |
| 684 /* Likewise, but the reference is not required to be valid. */ | |
| 685 #define adjust_automodify_address_nv(MEMREF, MODE, ADDR, OFFSET) \ | |
| 686 adjust_automodify_address_1 (MEMREF, MODE, ADDR, OFFSET, 0) | |
| 687 | |
| 688 extern rtx adjust_address_1 (rtx, enum machine_mode, HOST_WIDE_INT, int, int); | |
| 689 extern rtx adjust_automodify_address_1 (rtx, enum machine_mode, rtx, | |
| 690 HOST_WIDE_INT, int); | |
| 691 | |
| 692 /* Return a memory reference like MEMREF, but whose address is changed by | |
| 693 adding OFFSET, an RTX, to it. POW2 is the highest power of two factor | |
| 694 known to be in OFFSET (possibly 1). */ | |
| 695 extern rtx offset_address (rtx, rtx, unsigned HOST_WIDE_INT); | |
| 696 | |
| 697 /* Definitions from emit-rtl.c */ | |
| 698 #include "emit-rtl.h" | |
| 699 | |
| 700 /* Return a memory reference like MEMREF, but with its mode widened to | |
| 701 MODE and adjusted by OFFSET. */ | |
| 702 extern rtx widen_memory_access (rtx, enum machine_mode, HOST_WIDE_INT); | |
| 703 | |
| 704 /* Return a memory reference like MEMREF, but which is known to have a | |
| 705 valid address. */ | |
| 706 extern rtx validize_mem (rtx); | |
| 707 | |
| 708 extern rtx use_anchored_address (rtx); | |
| 709 | |
| 710 /* Given REF, a MEM, and T, either the type of X or the expression | |
| 711 corresponding to REF, set the memory attributes. OBJECTP is nonzero | |
| 712 if we are making a new object of this type. */ | |
| 713 extern void set_mem_attributes (rtx, tree, int); | |
| 714 | |
| 715 /* Similar, except that BITPOS has not yet been applied to REF, so if | |
| 716 we alter MEM_OFFSET according to T then we should subtract BITPOS | |
| 717 expecting that it'll be added back in later. */ | |
| 718 extern void set_mem_attributes_minus_bitpos (rtx, tree, int, HOST_WIDE_INT); | |
| 719 | |
| 720 /* Return OFFSET if XEXP (MEM, 0) - OFFSET is known to be ALIGN | |
| 721 bits aligned for 0 <= OFFSET < ALIGN / BITS_PER_UNIT, or | |
| 722 -1 if not known. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
723 extern int get_mem_align_offset (rtx, unsigned int); |
| 0 | 724 |
| 725 /* Assemble the static constant template for function entry trampolines. */ | |
| 726 extern rtx assemble_trampoline_template (void); | |
| 727 | |
| 728 /* Copy given rtx to a new temp reg and return that. */ | |
| 729 extern rtx copy_to_reg (rtx); | |
| 730 | |
| 731 /* Like copy_to_reg but always make the reg Pmode. */ | |
| 732 extern rtx copy_addr_to_reg (rtx); | |
| 733 | |
| 734 /* Like copy_to_reg but always make the reg the specified mode MODE. */ | |
| 735 extern rtx copy_to_mode_reg (enum machine_mode, rtx); | |
| 736 | |
| 737 /* Copy given rtx to given temp reg and return that. */ | |
| 738 extern rtx copy_to_suggested_reg (rtx, rtx, enum machine_mode); | |
| 739 | |
| 740 /* Copy a value to a register if it isn't already a register. | |
| 741 Args are mode (in case value is a constant) and the value. */ | |
| 742 extern rtx force_reg (enum machine_mode, rtx); | |
| 743 | |
| 744 /* Return given rtx, copied into a new temp reg if it was in memory. */ | |
| 745 extern rtx force_not_mem (rtx); | |
| 746 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
747 /* Return mode and signedness to use when an argument or result in the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
748 given mode is promoted. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
749 extern enum machine_mode promote_function_mode (const_tree, enum machine_mode, int *, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
750 const_tree, int); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
751 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
752 /* Return mode and signedness to use when an object in the given mode |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
753 is promoted. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
754 extern enum machine_mode promote_mode (const_tree, enum machine_mode, int *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
755 |
| 0 | 756 /* Return mode and signedness to use when object is promoted. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
757 enum machine_mode promote_decl_mode (const_tree, int *); |
| 0 | 758 |
| 759 /* Remove some bytes from the stack. An rtx says how many. */ | |
| 760 extern void adjust_stack (rtx); | |
| 761 | |
| 762 /* Add some bytes to the stack. An rtx says how many. */ | |
| 763 extern void anti_adjust_stack (rtx); | |
| 764 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
765 /* Add some bytes to the stack while probing it. An rtx says how many. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
766 extern void anti_adjust_stack_and_probe (rtx, bool); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
767 |
| 0 | 768 /* This enum is used for the following two functions. */ |
| 769 enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL}; | |
| 770 | |
| 771 /* Save the stack pointer at the specified level. */ | |
| 772 extern void emit_stack_save (enum save_level, rtx *, rtx); | |
| 773 | |
| 774 /* Restore the stack pointer from a save area of the specified level. */ | |
| 775 extern void emit_stack_restore (enum save_level, rtx, rtx); | |
| 776 | |
| 777 /* Invoke emit_stack_save for the nonlocal_goto_save_area. */ | |
| 778 extern void update_nonlocal_goto_save_area (void); | |
| 779 | |
| 780 /* Allocate some space on the stack dynamically and return its address. An rtx | |
| 781 says how many bytes. */ | |
| 782 extern rtx allocate_dynamic_stack_space (rtx, rtx, int); | |
| 783 | |
| 784 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
785 FIRST is a constant and size is a Pmode RTX. These are offsets from |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
786 the current stack pointer. STACK_GROWS_DOWNWARD says whether to add |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
787 or subtract them from the stack pointer. */ |
| 0 | 788 extern void probe_stack_range (HOST_WIDE_INT, rtx); |
| 789 | |
| 790 /* Return an rtx that refers to the value returned by a library call | |
| 791 in its original home. This becomes invalid if any more code is emitted. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
792 extern rtx hard_libcall_value (enum machine_mode, rtx); |
| 0 | 793 |
| 794 /* Return the mode desired by operand N of a particular bitfield | |
| 795 insert/extract insn, or MAX_MACHINE_MODE if no such insn is | |
| 796 available. */ | |
| 797 | |
| 798 enum extraction_pattern { EP_insv, EP_extv, EP_extzv }; | |
| 799 extern enum machine_mode | |
| 800 mode_for_extraction (enum extraction_pattern, int); | |
| 801 | |
| 802 extern void store_bit_field (rtx, unsigned HOST_WIDE_INT, | |
| 803 unsigned HOST_WIDE_INT, enum machine_mode, rtx); | |
| 804 extern rtx extract_bit_field (rtx, unsigned HOST_WIDE_INT, | |
| 805 unsigned HOST_WIDE_INT, int, rtx, | |
| 806 enum machine_mode, enum machine_mode); | |
| 807 extern rtx extract_low_bits (enum machine_mode, enum machine_mode, rtx); | |
| 808 extern rtx expand_mult (enum machine_mode, rtx, rtx, rtx, int); | |
| 809 extern rtx expand_mult_highpart_adjust (enum machine_mode, rtx, rtx, rtx, rtx, int); | |
| 810 | |
| 811 extern rtx assemble_static_space (unsigned HOST_WIDE_INT); | |
| 812 extern int safe_from_p (const_rtx, tree, int); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
813 extern bool split_comparison (enum rtx_code, enum machine_mode, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
814 enum rtx_code *, enum rtx_code *); |
| 0 | 815 |
| 816 /* Call this once to initialize the contents of the optabs | |
| 817 appropriately for the current target machine. */ | |
| 818 extern void init_optabs (void); | |
| 819 extern void init_all_optabs (void); | |
| 820 | |
| 821 /* Call this to initialize an optab function entry. */ | |
| 822 extern rtx init_one_libfunc (const char *); | |
| 823 extern rtx set_user_assembler_libfunc (const char *, const char *); | |
| 824 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
825 /* Build a decl for a libfunc named NAME. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
826 extern tree build_libfunc_function (const char *); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
827 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
828 /* Get the personality libfunc for a function decl. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
829 rtx get_personality_function (tree); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
830 |
| 0 | 831 extern int vector_mode_valid_p (enum machine_mode); |
| 832 | |
| 833 #endif /* GCC_EXPR_H */ |