]> gcc.gnu.org Git - gcc.git/blame - gcc/expr.h
git://gcc.gnu.org / gcc.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* (RETURN_IN_MEMORY): Handle BLKmode values.
[gcc.git] / gcc / expr.h
CommitLineData
e8bbfc4e 1/* Definitions for code generation pass of GNU compiler.
12e74c9e 2 Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc.
e8bbfc4e
RK		 3
4This file is part of GNU CC.
5
6GNU CC is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU CC is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU CC; see the file COPYING. If not, write to
18the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20
21#ifndef __STDC__
22#ifndef const
23#define const
24#endif
25#endif
26
27/* The default branch cost is 1. */
28#ifndef BRANCH_COST
29#define BRANCH_COST 1
30#endif
31
601ce03b
RK		 32/* The default is that we do not promote the mode of an object. */
33#ifndef PROMOTE_MODE
34#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE)
35#endif
36
e8bbfc4e
RK		 37/* Macros to access the slots of a QUEUED rtx.
38 Here rather than in rtl.h because only the expansion pass
39 should ever encounter a QUEUED. */
40
41/* The variable for which an increment is queued. */
42#define QUEUED_VAR(P) XEXP (P, 0)
43/* If the increment has been emitted, this is the insn
44 that does the increment. It is zero before the increment is emitted. */
45#define QUEUED_INSN(P) XEXP (P, 1)
46/* If a pre-increment copy has been generated, this is the copy
47 (it is a temporary reg). Zero if no copy made yet. */
48#define QUEUED_COPY(P) XEXP (P, 2)
49/* This is the body to use for the insn to do the increment.
50 It is used to emit the increment. */
51#define QUEUED_BODY(P) XEXP (P, 3)
52/* Next QUEUED in the queue. */
53#define QUEUED_NEXT(P) XEXP (P, 4)
54
55/* This is the 4th arg to `expand_expr'.
56 EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
57 EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
58 EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
59 is a constant that is not a legitimate address. */
60enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
61 EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER};
62
63/* List of labels that must never be deleted. */
64extern rtx forced_labels;
65
66/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
67 So we can mark them all live at the end of the function, if stupid. */
68extern rtx save_expr_regs;
69
70extern int current_function_calls_alloca;
71extern int current_function_outgoing_args_size;
72
73/* This is the offset from the arg pointer to the place where the first
74 anonymous arg can be found, if there is one. */
75extern rtx current_function_arg_offset_rtx;
76
77/* This is nonzero if the current function uses the constant pool. */
78extern int current_function_uses_const_pool;
79
80/* This is nonzero if the current function uses pic_offset_table_rtx. */
81extern int current_function_uses_pic_offset_table;
82
83/* The arg pointer hard register, or the pseudo into which it was copied. */
84extern rtx current_function_internal_arg_pointer;
85
86/* Nonzero means stack pops must not be deferred, and deferred stack
87 pops must not be output. It is nonzero inside a function call,
88 inside a conditional expression, inside a statement expression,
89 and in other cases as well. */
90extern int inhibit_defer_pop;
91
92/* Number of function calls seen so far in current function. */
93
94extern int function_call_count;
95
96/* RTX for stack slot that holds the current handler for nonlocal gotos.
97 Zero when function does not have nonlocal labels. */
98
99extern rtx nonlocal_goto_handler_slot;
100
101/* RTX for stack slot that holds the stack pointer value to restore
102 for a nonlocal goto.
103 Zero when function does not have nonlocal labels. */
104
105extern rtx nonlocal_goto_stack_level;
106
107/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
108 (labels to which there can be nonlocal gotos from nested functions)
109 in this function. */
110
111#ifdef TREE_CODE /* Don't lose if tree.h not included. */
112extern tree nonlocal_labels;
113#endif
114
115#define NO_DEFER_POP (inhibit_defer_pop += 1)
116#define OK_DEFER_POP (inhibit_defer_pop -= 1)
117
118/* Number of units that we should eventually pop off the stack.
119 These are the arguments to function calls that have already returned. */
120extern int pending_stack_adjust;
121
122/* A list of all cleanups which belong to the arguments of
123 function calls being expanded by expand_call. */
124#ifdef TREE_CODE /* Don't lose if tree.h not included. */
125extern tree cleanups_this_call;
126#endif
127\f
128#ifdef TREE_CODE /* Don't lose if tree.h not included. */
129/* Structure to record the size of a sequence of arguments
130 as the sum of a tree-expression and a constant. */
131
132struct args_size
133{
134 int constant;
135 tree var;
136};
137#endif
138
139/* Add the value of the tree INC to the `struct args_size' TO. */
140
141#define ADD_PARM_SIZE(TO, INC) \
142{ tree inc = (INC); \
143 if (TREE_CODE (inc) == INTEGER_CST) \
144 (TO).constant += TREE_INT_CST_LOW (inc); \
145 else if ((TO).var == 0) \
146 (TO).var = inc; \
147 else \
148 (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); }
149
150#define SUB_PARM_SIZE(TO, DEC) \
151{ tree dec = (DEC); \
152 if (TREE_CODE (dec) == INTEGER_CST) \
153 (TO).constant -= TREE_INT_CST_LOW (dec); \
154 else if ((TO).var == 0) \
155 (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \
156 else \
157 (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
158
159/* Convert the implicit sum in a `struct args_size' into an rtx. */
160#define ARGS_SIZE_RTX(SIZE) \
3245eea0 161((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \
e8bbfc4e
RK		 162 : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \
163 size_int ((SIZE).constant)), \
3245eea0 164 NULL_RTX, VOIDmode, 0))
e8bbfc4e
RK		 165
166/* Convert the implicit sum in a `struct args_size' into a tree. */
167#define ARGS_SIZE_TREE(SIZE) \
168((SIZE).var == 0 ? size_int ((SIZE).constant) \
169 : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant)))
170
171/* Supply a default definition for FUNCTION_ARG_PADDING:
355b2097 172 usually pad upward, but pad short args downward on
e8bbfc4e
RK		 173 big-endian machines. */
174
175enum direction {none, upward, downward}; /* Value has this type. */
176
177#ifndef FUNCTION_ARG_PADDING
178#if BYTES_BIG_ENDIAN
179#define FUNCTION_ARG_PADDING(MODE, TYPE) \
180 (((MODE) == BLKmode \
181 ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
182 && int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \
183 : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
184 ? downward : upward)
185#else
186#define FUNCTION_ARG_PADDING(MODE, TYPE) upward
187#endif
188#endif
189
190/* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let
191 FUNCTION_ARG_PADDING, which also pads the length, handle any needed
192 alignment. */
193
194#ifndef FUNCTION_ARG_BOUNDARY
195#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY
196#endif
197
198/* Nonzero if we do not know how to pass TYPE solely in registers.
199 We cannot do so in the following cases:
200
201 - if the type has variable size
202 - if the type is marked as addressable (it is required to be constructed
203 into the stack)
204 - if the padding and mode of the type is such that a copy into a register
e7cf2d7e
RK		 205 would put it into the wrong part of the register.
206
207/* Which padding can't be supported depends on the byte endianness.
e8bbfc4e 208
e7cf2d7e 209 A value in a register is implicitly padded at the most significant end.
e8bbfc4e
RK		 210 On a big-endian machine, that is the lower end in memory.
211 So a value padded in memory at the upper end can't go in a register.
212 For a little-endian machine, the reverse is true. */
213
214#if BYTES_BIG_ENDIAN
215#define MUST_PASS_IN_STACK_BAD_PADDING upward
216#else
217#define MUST_PASS_IN_STACK_BAD_PADDING downward
218#endif
219
220#define MUST_PASS_IN_STACK(MODE,TYPE) \
221 ((TYPE) != 0 \
222 && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \
223 || TREE_ADDRESSABLE (TYPE) \
224 || ((MODE) == BLKmode \
225 && (FUNCTION_ARG_PADDING (MODE, TYPE) \
e7cf2d7e 226 == MUST_PASS_IN_STACK_BAD_PADDING))))
e8bbfc4e 227
e14fa9c4 228/* Nonzero if type TYPE should be returned in memory.
e8bbfc4e
RK		 229 Most machines can use the following default definition. */
230
231#ifndef RETURN_IN_MEMORY
e14fa9c4 232#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode)
e8bbfc4e
RK		 233#endif
234\f
235/* Optabs are tables saying how to generate insn bodies
236 for various machine modes and numbers of operands.
237 Each optab applies to one operation.
238 For example, add_optab applies to addition.
239
240 The insn_code slot is the enum insn_code that says how to
241 generate an insn for this operation on a particular machine mode.
242 It is CODE_FOR_nothing if there is no such insn on the target machine.
243
244 The `lib_call' slot is the name of the library function that
245 can be used to perform the operation.
246
247 A few optabs, such as move_optab and cmp_optab, are used
248 by special code. */
249
250/* Everything that uses expr.h needs to define enum insn_code
251 but we don't list it in the Makefile dependencies just for that. */
252#include "insn-codes.h"
253
254typedef struct optab
255{
256 enum rtx_code code;
257 struct {
258 enum insn_code insn_code;
259 rtx libfunc;
260 } handlers [NUM_MACHINE_MODES];
261} * optab;
262
263/* Given an enum insn_code, access the function to construct
264 the body of that kind of insn. */
265#ifdef FUNCTION_CONVERSION_BUG
266/* Some compilers fail to convert a function properly to a
267 pointer-to-function when used as an argument.
268 So produce the pointer-to-function directly.
269 Luckily, these compilers seem to work properly when you
270 call the pointer-to-function. */
271#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)])
272#else
273#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)])
274#endif
275
276extern rtx (*const insn_gen_function[]) ();
277
278extern optab add_optab;
279extern optab sub_optab;
8cbe2917 280extern optab smul_optab; /* Signed and floating-point multiply */
e8bbfc4e
RK		 281extern optab smul_widen_optab; /* Signed multiply with result
282 one machine mode wider than args */
283extern optab umul_widen_optab;
284extern optab sdiv_optab; /* Signed divide */
285extern optab sdivmod_optab; /* Signed divide-and-remainder in one */
286extern optab udiv_optab;
287extern optab udivmod_optab;
288extern optab smod_optab; /* Signed remainder */
289extern optab umod_optab;
290extern optab flodiv_optab; /* Optab for floating divide. */
291extern optab ftrunc_optab; /* Convert float to integer in float fmt */
292extern optab and_optab; /* Logical and */
293extern optab ior_optab; /* Logical or */
294extern optab xor_optab; /* Logical xor */
295extern optab ashl_optab; /* Arithmetic shift left */
296extern optab ashr_optab; /* Arithmetic shift right */
297extern optab lshl_optab; /* Logical shift left */
298extern optab lshr_optab; /* Logical shift right */
299extern optab rotl_optab; /* Rotate left */
300extern optab rotr_optab; /* Rotate right */
8cbe2917
TW		 301extern optab smin_optab; /* Signed and floating-point minimum value */
302extern optab smax_optab; /* Signed and floating-point maximum value */
e8bbfc4e
RK		 303extern optab umin_optab; /* Unsigned minimum value */
304extern optab umax_optab; /* Unsigned maximum value */
305
306extern optab mov_optab; /* Move instruction. */
307extern optab movstrict_optab; /* Move, preserving high part of register. */
308
309extern optab cmp_optab; /* Compare insn; two operands. */
310extern optab tst_optab; /* tst insn; compare one operand against 0 */
311
312/* Unary operations */
313extern optab neg_optab; /* Negation */
314extern optab abs_optab; /* Abs value */
315extern optab one_cmpl_optab; /* Bitwise not */
316extern optab ffs_optab; /* Find first bit set */
07fe1625 317extern optab sqrt_optab; /* Square root */
d70326a5
JVA		 318extern optab sin_optab; /* Sine */
319extern optab cos_optab; /* Cosine */
b91c3756 320extern optab strlen_optab; /* String length */
e8bbfc4e
RK		 321
322/* Passed to expand_binop and expand_unop to say which options to try to use
323 if the requested operation can't be open-coded on the requisite mode.
324 Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call.
325 Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode.
326 OPTAB_MUST_WIDEN says try widening and don't try anything else. */
327
328enum optab_methods
329{
330 OPTAB_DIRECT,
331 OPTAB_LIB,
332 OPTAB_WIDEN,
333 OPTAB_LIB_WIDEN,
334 OPTAB_MUST_WIDEN
335};
336
337/* SYMBOL_REF rtx's for the library functions that are called
338 implicitly and not via optabs. */
339
340extern rtx extendsfdf2_libfunc;
b092b471
JW		 341extern rtx extendsfxf2_libfunc;
342extern rtx extendsftf2_libfunc;
343extern rtx extenddfxf2_libfunc;
344extern rtx extenddftf2_libfunc;
345
e8bbfc4e 346extern rtx truncdfsf2_libfunc;
b092b471
JW		 347extern rtx truncxfsf2_libfunc;
348extern rtx trunctfsf2_libfunc;
349extern rtx truncxfdf2_libfunc;
350extern rtx trunctfdf2_libfunc;
351
e8bbfc4e
RK		 352extern rtx memcpy_libfunc;
353extern rtx bcopy_libfunc;
354extern rtx memcmp_libfunc;
355extern rtx bcmp_libfunc;
356extern rtx memset_libfunc;
357extern rtx bzero_libfunc;
b092b471 358
e8bbfc4e
RK		 359extern rtx eqsf2_libfunc;
360extern rtx nesf2_libfunc;
361extern rtx gtsf2_libfunc;
362extern rtx gesf2_libfunc;
363extern rtx ltsf2_libfunc;
364extern rtx lesf2_libfunc;
b092b471 365
e8bbfc4e
RK		 366extern rtx eqdf2_libfunc;
367extern rtx nedf2_libfunc;
368extern rtx gtdf2_libfunc;
369extern rtx gedf2_libfunc;
370extern rtx ltdf2_libfunc;
371extern rtx ledf2_libfunc;
b092b471
JW		 372
373extern rtx eqxf2_libfunc;
374extern rtx nexf2_libfunc;
375extern rtx gtxf2_libfunc;
376extern rtx gexf2_libfunc;
377extern rtx ltxf2_libfunc;
378extern rtx lexf2_libfunc;
379
380extern rtx eqtf2_libfunc;
381extern rtx netf2_libfunc;
382extern rtx gttf2_libfunc;
383extern rtx getf2_libfunc;
384extern rtx lttf2_libfunc;
385extern rtx letf2_libfunc;
386
e8bbfc4e 387extern rtx floatsisf_libfunc;
b092b471
JW		 388extern rtx floatdisf_libfunc;
389extern rtx floattisf_libfunc;
390
e8bbfc4e 391extern rtx floatsidf_libfunc;
b092b471
JW		 392extern rtx floatdidf_libfunc;
393extern rtx floattidf_libfunc;
394
395extern rtx floatsixf_libfunc;
396extern rtx floatdixf_libfunc;
397extern rtx floattixf_libfunc;
398
399extern rtx floatsitf_libfunc;
400extern rtx floatditf_libfunc;
401extern rtx floattitf_libfunc;
402
e8bbfc4e
RK		 403extern rtx fixsfsi_libfunc;
404extern rtx fixsfdi_libfunc;
b092b471
JW		 405extern rtx fixsfti_libfunc;
406
e8bbfc4e
RK		 407extern rtx fixdfsi_libfunc;
408extern rtx fixdfdi_libfunc;
b092b471
JW		 409extern rtx fixdfti_libfunc;
410
411extern rtx fixxfsi_libfunc;
412extern rtx fixxfdi_libfunc;
413extern rtx fixxfti_libfunc;
414
415extern rtx fixtfsi_libfunc;
416extern rtx fixtfdi_libfunc;
417extern rtx fixtfti_libfunc;
418
e8bbfc4e
RK		 419extern rtx fixunssfsi_libfunc;
420extern rtx fixunssfdi_libfunc;
b092b471
JW		 421extern rtx fixunssfti_libfunc;
422
e8bbfc4e
RK		 423extern rtx fixunsdfsi_libfunc;
424extern rtx fixunsdfdi_libfunc;
b092b471
JW		 425extern rtx fixunsdfti_libfunc;
426
427extern rtx fixunsxfsi_libfunc;
428extern rtx fixunsxfdi_libfunc;
429extern rtx fixunsxfti_libfunc;
430
431extern rtx fixunstfsi_libfunc;
432extern rtx fixunstfdi_libfunc;
433extern rtx fixunstfti_libfunc;
e8bbfc4e
RK		 434\f
435typedef rtx (*rtxfun) ();
436
437/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
438 gives the gen_function to make a branch to test that condition. */
439
440extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
441
442/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
443 gives the insn code to make a store-condition insn
444 to test that condition. */
445
446extern enum insn_code setcc_gen_code[NUM_RTX_CODE];
447
12e74c9e
RK		 448/* Define functions given in optabs.c. */
449
e8bbfc4e 450/* Expand a binary operation given optab and rtx operands. */
12e74c9e
RK		 451extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx,
452 int, enum optab_methods));
e8bbfc4e
RK		 453
454/* Expand a binary operation with both signed and unsigned forms. */
12e74c9e
RK		 455extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx,
456 rtx, rtx, int, enum optab_methods));
457
458/* Generate code to perform an operation on two operands with two results. */
459extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int));
e8bbfc4e
RK		 460
461/* Expand a unary arithmetic operation given optab rtx operand. */
cb411bd6 462extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int));
e8bbfc4e 463
bf15a311 464/* Expand the complex absolute value operation. */
cb411bd6 465extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int));
bf15a311 466
12e74c9e
RK		 467/* Generate an instruction with a given INSN_CODE with an output and
468 an input. */
469extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code));
e8bbfc4e 470
12e74c9e
RK		 471/* Emit code to perform a series of operations on a multi-word quantity, one
472 word at a time. */
473extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx));
e8bbfc4e 474
12e74c9e
RK		 475/* Emit code to make a call to a constant function or a library call. */
476extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx));
e8bbfc4e 477
12e74c9e
RK		 478/* Emit one rtl instruction to store zero in specified rtx. */
479extern void emit_clr_insn PROTO((rtx));
e8bbfc4e 480
12e74c9e
RK		 481/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */
482extern void emit_0_to_1_insn PROTO((rtx));
483
484/* Emit one rtl insn to compare two rtx's. */
485extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx,
486 enum machine_mode, int, int));
487
488/* Nonzero if a compare of mode MODE can be done straightforwardly
489 (without splitting it into pieces). */
490extern int can_compare_p PROTO((enum machine_mode));
491
492/* Generate code to indirectly jump to a location given in the rtx LOC. */
493extern void emit_indirect_jump PROTO((rtx));
494
495/* Create but don't emit one rtl instruction to add one rtx into another.
496 Modes must match; operands must meet the operation's predicates.
497 Likewise for subtraction and for just copying.
498 These do not call protect_from_queue; caller must do so. */
499extern rtx gen_add2_insn PROTO((rtx, rtx));
500extern rtx gen_sub2_insn PROTO((rtx, rtx));
501extern rtx gen_move_insn PROTO((rtx, rtx));
502extern int have_add2_insn PROTO((enum machine_mode));
503extern int have_sub2_insn PROTO((enum machine_mode));
e8bbfc4e
RK		 504
505/* Return the INSN_CODE to use for an extend operation. */
12e74c9e
RK		 506extern enum insn_code can_extend_p PROTO((enum machine_mode,
507 enum machine_mode, int));
508
509/* Generate the body of an insn to extend Y (with mode MFROM)
510 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */
511extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode,
512 enum machine_mode, int));
e8bbfc4e
RK		 513
514/* Initialize the tables that control conversion between fixed and
515 floating values. */
cb411bd6
RS		 516extern void init_fixtab PROTO((void));
517extern void init_floattab PROTO((void));
e8bbfc4e 518
12e74c9e
RK		 519/* Generate code for a FLOAT_EXPR. */
520extern void expand_float PROTO((rtx, rtx, int));
521
e8bbfc4e 522/* Generate code for a FIX_EXPR. */
cb411bd6 523extern void expand_fix PROTO((rtx, rtx, int));
e8bbfc4e 524
12e74c9e
RK		 525/* Call this once to initialize the contents of the optabs
526 appropriately for the current target machine. */
527extern void init_optabs PROTO((void));
528\f
529/* Functions from expmed.c: (/
e8bbfc4e 530
12e74c9e
RK		 531/* Arguments MODE, RTX: return an rtx for the negation of that value.
532 May emit insns. */
533extern rtx negate_rtx PROTO((enum machine_mode, rtx));
e8bbfc4e 534
12e74c9e
RK		 535/* Expand a logical AND operation. */
536extern rtx expand_and PROTO((rtx, rtx, rtx));
e8bbfc4e 537
12e74c9e
RK		 538/* Emit a store-flag operation. */
539extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx,
540 enum machine_mode, int, int));
e8bbfc4e 541
12e74c9e 542/* Functions from loop.c: */
e8bbfc4e 543
12e74c9e
RK		 544/* Given a JUMP_INSN, return a description of the test being made. */
545extern rtx get_condition PROTO((rtx, rtx *));
546\f
547/* Functions from expr.c: */
cb411bd6 548
12e74c9e
RK		 549/* This is run once per compilation to set up which modes can be used
550 directly in memory and to initialize the block move optab. */
551extern void init_expr_once PROTO((void));
552
553/* This is run at the start of compiling a function. */
554extern void init_expr PROTO((void));
555
556/* Use protect_from_queue to convert a QUEUED expression
557 into something that you can put immediately into an instruction. */
558extern rtx protect_from_queue PROTO((rtx, int));
559
560/* Perform all the pending incrementations. */
561extern void emit_queue PROTO((void));
b4cb4994 562
e8bbfc4e
RK		 563/* Emit some rtl insns to move data between rtx's, converting machine modes.
564 Both modes must be floating or both fixed. */
cb411bd6 565extern void convert_move PROTO((rtx, rtx, int));
e8bbfc4e
RK		 566
567/* Convert an rtx to specified machine mode and return the result. */
cb411bd6 568extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int));
e8bbfc4e 569
12e74c9e
RK		 570/* Emit code to move a block Y to a block X.
571extern void emit_block_move PROTO((rtx, rtx, rtx, int));
572
573/* Copy all or part of a value X into registers starting at REGNO.
574 The number of registers to be filled is NREGS. */
575extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode));
576
577/* Copy all or part of a BLKmode value X out of registers starting at REGNO.
578 The number of registers to be filled is NREGS. */
579extern void move_block_from_reg PROTO((int, rtx, int));
580
581/* Mark NREGS consecutive regs, starting at REGNO, as being live now. */
582extern void use_regs PROTO((int, int));
583
584/* Write zeros through the storage of OBJECT.
585 If OBJECT has BLKmode, SIZE is its length in bytes. */
586extern void clear_storage PROTO((rtx, int));
587
588/* Emit insns to set X from Y. */
589extern rtx emit_move_insn PROTO((rtx, rtx));
590
591/* Emit insns to set X from Y, with no frills. */
592extern rtx emit_move_insn_1 PROTO ((rtx, rtx));
593
594/* Push a block of length SIZE (perhaps variable)
595 and return an rtx to address the beginning of the block. */
596extern rtx push_block PROTO((rtx, int, int));
597
598/* Make an operand to push someting on the stack. */
599extern rtx gen_push_operand PROTO((void));
600
601#ifdef TREE_CODE
602/* Generate code to push something onto the stack, given its mode and type. */
603extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int,
604 int, rtx, int, rtx, rtx));
605
606/* Emit library call. These cannot have accurate prototypes since they have
607 a variable number of args. */
e8bbfc4e 608extern void emit_library_call ();
12e74c9e
RK		 609extern void emit_library_call_value ();
610
611/* Expand an assignment that stores the value of FROM into TO. */
612extern rtx expand_assignment PROTO((tree, tree, int, int));
613
614/* Generate code for computing expression EXP,
615 and storing the value into TARGET.
616 If SUGGEST_REG is nonzero, copy the value through a register
617 and return that register, if that is possible. */
618extern rtx store_expr PROTO((tree, rtx, int));
619#endif
e8bbfc4e
RK		 620
621/* Given an rtx that may include add and multiply operations,
622 generate them as insns and return a pseudo-reg containing the value.
623 Useful after calling expand_expr with 1 as sum_ok. */
cb411bd6 624extern rtx force_operand PROTO((rtx, rtx));
e8bbfc4e 625
12e74c9e
RK		 626#ifdef TREE_CODE
627/* Generate code for computing expression EXP.
628 An rtx for the computed value is returned. The value is never null.
629 In the case of a void EXP, const0_rtx is returned. */
630extern rtx expand_expr PROTO((tree, rtx, enum machine_mode,
631 enum expand_modifier));
632#endif
633
634/* At the start of a function, record that we have no previously-pushed
635 arguments waiting to be popped. */
636extern void init_pending_stack_adjust PROTO((void));
637
638/* When exiting from function, if safe, clear out any pending stack adjust
639 so the adjustment won't get done. */
640extern void clear_pending_stack_adjust PROTO((void));
641
642/* Pop any previously-pushed arguments that have not been popped yet. */
643extern void do_pending_stack_adjust PROTO((void));
644
645#ifdef TREE_CODE
646/* Expand all cleanups up to OLD_CLEANUPS. */
647extern void expand_cleanups_to PROTO((tree));
648
649/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */
650extern void jumpifnot PROTO((tree, rtx));
651
652/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
653extern void jumpif PROTO((tree, rtx));
654
655/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
656 the result is zero, or IF_TRUE_LABEL if the result is one. */
657extern void do_jump PROTO((tree, rtx, rtx));
658#endif
659
660/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */
661extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int,
662 enum machine_mode, rtx, int));
663
664/* Generate a tablejump instruction (used for switch statements). */
665extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx));
666\f
cb411bd6
RS		 667#ifdef TREE_CODE
668/* rtl.h and tree.h were included. */
669/* Return an rtx for the size in bytes of the value of an expr. */
670extern rtx expr_size PROTO((tree));
671
672extern rtx lookup_static_chain PROTO((tree));
673
674/* Convert a stack slot address ADDR valid in function FNDECL
675 into an address valid in this function (using a static chain). */
676extern rtx fix_lexical_addr PROTO((rtx, tree));
677
678/* Return the address of the trampoline for entering nested fn FUNCTION. */
679extern rtx trampoline_address PROTO((tree));
680
681/* Return an rtx that refers to the value returned by a function
682 in its original home. This becomes invalid if any more code is emitted. */
683extern rtx hard_function_value PROTO((tree, tree));
684
cb411bd6
RS		 685
686extern rtx prepare_call_address PROTO((rtx, tree, rtx*));
687
688extern rtx expand_call PROTO((tree, rtx, int));
689extern void emit_call_1 PROTO((rtx, tree, int, int, rtx, rtx, int, rtx, int));
690
cb411bd6
RS		 691extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int));
692extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int));
cb411bd6
RS		 693extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *));
694extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx));
695/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */
696extern rtx label_rtx PROTO((tree));
697#else
e8bbfc4e
RK		 698/* Return an rtx for the size in bytes of the value of an expr. */
699extern rtx expr_size ();
700
e8bbfc4e
RK		 701extern rtx lookup_static_chain ();
702
cb411bd6
RS		 703/* Convert a stack slot address ADDR valid in function FNDECL
704 into an address valid in this function (using a static chain). */
705extern rtx fix_lexical_addr ();
706
707/* Return the address of the trampoline for entering nested fn FUNCTION. */
708extern rtx trampoline_address ();
709
710/* Return an rtx that refers to the value returned by a function
711 in its original home. This becomes invalid if any more code is emitted. */
712extern rtx hard_function_value ();
713
cb411bd6
RS		 714extern rtx prepare_call_address ();
715extern rtx expand_call ();
716extern void emit_call_1 ();
cb411bd6
RS		 717extern rtx expand_shift ();
718extern rtx expand_divmod ();
cb411bd6
RS		 719extern void locate_and_pad_parm ();
720extern rtx expand_inline_function ();
721
722/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */
723extern rtx label_rtx ();
724#endif
725
626043cf
RK		 726/* Indicate how an input argument register was promoted. */
727extern rtx promoted_input_arg ();
728
e8bbfc4e
RK		 729/* Return an rtx like arg but sans any constant terms.
730 Returns the original rtx if it has no constant terms.
731 The constant terms are added and stored via a second arg. */
cb411bd6 732extern rtx eliminate_constant_term PROTO((rtx, rtx *));
e8bbfc4e
RK		 733
734/* Convert arg to a valid memory address for specified machine mode,
735 by emitting insns to perform arithmetic if nec. */
cb411bd6 736extern rtx memory_address PROTO((enum machine_mode, rtx));
e8bbfc4e
RK		 737
738/* Like `memory_address' but pretent `flag_force_addr' is 0. */
cb411bd6 739extern rtx memory_address_noforce PROTO((enum machine_mode, rtx));
e8bbfc4e
RK		 740
741/* Return a memory reference like MEMREF, but with its mode changed
742 to MODE and its address changed to ADDR.
743 (VOIDmode means don't change the mode.
744 NULL for ADDR means don't change the address.) */
cb411bd6 745extern rtx change_address PROTO((rtx, enum machine_mode, rtx));
e8bbfc4e
RK		 746
747/* Return a memory reference like MEMREF, but which is known to have a
748 valid address. */
749
cb411bd6 750extern rtx validize_mem PROTO((rtx));
e8bbfc4e
RK		 751
752/* Convert a stack slot address ADDR valid in function FNDECL
753 into an address valid in this function (using a static chain). */
754extern rtx fix_lexical_addr ();
755
e8bbfc4e 756/* Assemble the static constant template for function entry trampolines. */
cb411bd6 757extern rtx assemble_trampoline_template PROTO((void));
e8bbfc4e
RK		 758
759/* Return 1 if two rtx's are equivalent in structure and elements. */
cb411bd6 760extern int rtx_equal_p PROTO((rtx, rtx));
e8bbfc4e
RK		 761
762/* Given rtx, return new rtx whose address won't be affected by
763 any side effects. It has been copied to a new temporary reg. */
cb411bd6 764extern rtx stabilize PROTO((rtx));
e8bbfc4e
RK		 765
766/* Given an rtx, copy all regs it refers to into new temps
767 and return a modified copy that refers to the new temps. */
cb411bd6 768extern rtx copy_all_regs PROTO((rtx));
e8bbfc4e
RK		 769
770/* Copy given rtx to a new temp reg and return that. */
cb411bd6 771extern rtx copy_to_reg PROTO((rtx));
e8bbfc4e
RK		 772
773/* Like copy_to_reg but always make the reg Pmode. */
cb411bd6 774extern rtx copy_addr_to_reg PROTO((rtx));
e8bbfc4e
RK		 775
776/* Like copy_to_reg but always make the reg the specified mode MODE. */
cb411bd6 777extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx));
e8bbfc4e
RK		 778
779/* Copy given rtx to given temp reg and return that. */
cb411bd6 780extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode));
e8bbfc4e
RK		 781
782/* Copy a value to a register if it isn't already a register.
783 Args are mode (in case value is a constant) and the value. */
cb411bd6 784extern rtx force_reg PROTO((enum machine_mode, rtx));
e8bbfc4e
RK		 785
786/* Return given rtx, copied into a new temp reg if it was in memory. */
cb411bd6 787extern rtx force_not_mem PROTO((rtx));
e8bbfc4e
RK		 788
789/* Remove some bytes from the stack. An rtx says how many. */
cb411bd6 790extern void adjust_stack PROTO((rtx));
e8bbfc4e
RK		 791
792/* Add some bytes to the stack. An rtx says how many. */
cb411bd6 793extern void anti_adjust_stack PROTO((rtx));
e8bbfc4e 794
59257ff7
RK		 795/* This enum is used for the following two functions. */
796enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
797
798/* Save the stack pointer at the specified level. */
cb411bd6 799extern void emit_stack_save PROTO((enum save_level, rtx *, rtx));
59257ff7
RK		 800
801/* Restore the stack pointer from a save area of the specified level. */
cb411bd6 802extern void emit_stack_restore PROTO((enum save_level, rtx, rtx));
59257ff7 803
e8bbfc4e
RK		 804/* Allocate some space on the stack dynamically and return its address. An rtx
805 says how many bytes. */
cb411bd6 806extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int));
e8bbfc4e
RK		 807
808/* Emit code to copy function value to a new temp reg and return that reg. */
809extern rtx function_value ();
810
e8bbfc4e
RK		 811/* Return an rtx that refers to the value returned by a library call
812 in its original home. This becomes invalid if any more code is emitted. */
cb411bd6 813extern rtx hard_libcall_value PROTO((enum machine_mode));
e8bbfc4e
RK		 814
815/* Emit code to copy function value to a specified place. */
816extern void copy_function_value ();
817
818/* Given an rtx, return an rtx for a value rounded up to a multiple
819 of STACK_BOUNDARY / BITS_PER_UNIT. */
cb411bd6 820extern rtx round_push PROTO((rtx));
e8bbfc4e 821
cb411bd6 822extern void emit_block_move PROTO((rtx, rtx, rtx, int));
e8bbfc4e 823
cb411bd6
RS		 824extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int));
825extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int));
826extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int));
827extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int));
e8bbfc4e 828extern rtx expand_stmt_expr ();
e8bbfc4e 829
cb411bd6 830extern rtx assemble_static_space PROTO((int));
e8bbfc4e
RK		 831
832/* Hook called by expand_expr for language-specific tree codes.
833 It is up to the language front end to install a hook
834 if it has any such codes that expand_expr needs to know about. */
835extern rtx (*lang_expand_expr) ();
GNU Compiler Collection
This page took 0.188968 seconds and 5 git commands to generate.