projects / unix-history / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add diclaimer of copyright to _osname() manual page.
[unix-history] / gnu / usr.bin / cc / common / expr.h
CommitLineData
9bf86ebb
PR		 1/* Definitions for code generation pass of GNU compiler.
2 Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc.
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
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
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) \
161((SIZE).var == 0 ? GEN_INT ((SIZE).constant) \
162 : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \
163 size_int ((SIZE).constant)), \
164 NULL_RTX, VOIDmode, 0))
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:
172 usually pad upward, but pad short args downward on
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
205 would put it into the wrong part of the register.
206
207 Which padding can't be supported depends on the byte endianness.
208
209 A value in a register is implicitly padded at the most significant end.
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 && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
226 && 0 == (int_size_in_bytes (TYPE) \
227 % (PARM_BOUNDARY / BITS_PER_UNIT))) \
228 && (FUNCTION_ARG_PADDING (MODE, TYPE) \
229 == MUST_PASS_IN_STACK_BAD_PADDING))))
230
231/* Nonzero if type TYPE should be returned in memory.
232 Most machines can use the following default definition. */
233
234#ifndef RETURN_IN_MEMORY
235#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode)
236#endif
237\f
238/* Optabs are tables saying how to generate insn bodies
239 for various machine modes and numbers of operands.
240 Each optab applies to one operation.
241 For example, add_optab applies to addition.
242
243 The insn_code slot is the enum insn_code that says how to
244 generate an insn for this operation on a particular machine mode.
245 It is CODE_FOR_nothing if there is no such insn on the target machine.
246
247 The `lib_call' slot is the name of the library function that
248 can be used to perform the operation.
249
250 A few optabs, such as move_optab and cmp_optab, are used
251 by special code. */
252
253/* Everything that uses expr.h needs to define enum insn_code
254 but we don't list it in the Makefile dependencies just for that. */
255#include "insn-codes.h"
256
257typedef struct optab
258{
259 enum rtx_code code;
260 struct {
261 enum insn_code insn_code;
262 rtx libfunc;
263 } handlers [NUM_MACHINE_MODES];
264} * optab;
265
266/* Given an enum insn_code, access the function to construct
267 the body of that kind of insn. */
268#ifdef FUNCTION_CONVERSION_BUG
269/* Some compilers fail to convert a function properly to a
270 pointer-to-function when used as an argument.
271 So produce the pointer-to-function directly.
272 Luckily, these compilers seem to work properly when you
273 call the pointer-to-function. */
274#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)])
275#else
276#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)])
277#endif
278
279extern rtx (*const insn_gen_function[]) ();
280
281extern optab add_optab;
282extern optab sub_optab;
283extern optab smul_optab; /* Signed and floating-point multiply */
284extern optab smul_widen_optab; /* Signed multiply with result
285 one machine mode wider than args */
286extern optab umul_widen_optab;
287extern optab sdiv_optab; /* Signed divide */
288extern optab sdivmod_optab; /* Signed divide-and-remainder in one */
289extern optab udiv_optab;
290extern optab udivmod_optab;
291extern optab smod_optab; /* Signed remainder */
292extern optab umod_optab;
293extern optab flodiv_optab; /* Optab for floating divide. */
294extern optab ftrunc_optab; /* Convert float to integer in float fmt */
295extern optab and_optab; /* Logical and */
296extern optab ior_optab; /* Logical or */
297extern optab xor_optab; /* Logical xor */
298extern optab ashl_optab; /* Arithmetic shift left */
299extern optab ashr_optab; /* Arithmetic shift right */
300extern optab lshl_optab; /* Logical shift left */
301extern optab lshr_optab; /* Logical shift right */
302extern optab rotl_optab; /* Rotate left */
303extern optab rotr_optab; /* Rotate right */
304extern optab smin_optab; /* Signed and floating-point minimum value */
305extern optab smax_optab; /* Signed and floating-point maximum value */
306extern optab umin_optab; /* Unsigned minimum value */
307extern optab umax_optab; /* Unsigned maximum value */
308
309extern optab mov_optab; /* Move instruction. */
310extern optab movstrict_optab; /* Move, preserving high part of register. */
311
312extern optab cmp_optab; /* Compare insn; two operands. */
313extern optab tst_optab; /* tst insn; compare one operand against 0 */
314
315/* Unary operations */
316extern optab neg_optab; /* Negation */
317extern optab abs_optab; /* Abs value */
318extern optab one_cmpl_optab; /* Bitwise not */
319extern optab ffs_optab; /* Find first bit set */
320extern optab sqrt_optab; /* Square root */
321extern optab sin_optab; /* Sine */
322extern optab cos_optab; /* Cosine */
323extern optab strlen_optab; /* String length */
324
325/* Tables of patterns for extending one integer mode to another. */
326extern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2];
327
328/* Tables of patterns for converting between fixed and floating point. */
329extern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
330extern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
331extern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
332
333/* Passed to expand_binop and expand_unop to say which options to try to use
334 if the requested operation can't be open-coded on the requisite mode.
335 Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call.
336 Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode.
337 OPTAB_MUST_WIDEN says try widening and don't try anything else. */
338
339enum optab_methods
340{
341 OPTAB_DIRECT,
342 OPTAB_LIB,
343 OPTAB_WIDEN,
344 OPTAB_LIB_WIDEN,
345 OPTAB_MUST_WIDEN
346};
347
348/* SYMBOL_REF rtx's for the library functions that are called
349 implicitly and not via optabs. */
350
351extern rtx extendsfdf2_libfunc;
352extern rtx extendsfxf2_libfunc;
353extern rtx extendsftf2_libfunc;
354extern rtx extenddfxf2_libfunc;
355extern rtx extenddftf2_libfunc;
356
357extern rtx truncdfsf2_libfunc;
358extern rtx truncxfsf2_libfunc;
359extern rtx trunctfsf2_libfunc;
360extern rtx truncxfdf2_libfunc;
361extern rtx trunctfdf2_libfunc;
362
363extern rtx memcpy_libfunc;
364extern rtx bcopy_libfunc;
365extern rtx memcmp_libfunc;
366extern rtx bcmp_libfunc;
367extern rtx memset_libfunc;
368extern rtx bzero_libfunc;
369
370extern rtx eqsf2_libfunc;
371extern rtx nesf2_libfunc;
372extern rtx gtsf2_libfunc;
373extern rtx gesf2_libfunc;
374extern rtx ltsf2_libfunc;
375extern rtx lesf2_libfunc;
376
377extern rtx eqdf2_libfunc;
378extern rtx nedf2_libfunc;
379extern rtx gtdf2_libfunc;
380extern rtx gedf2_libfunc;
381extern rtx ltdf2_libfunc;
382extern rtx ledf2_libfunc;
383
384extern rtx eqxf2_libfunc;
385extern rtx nexf2_libfunc;
386extern rtx gtxf2_libfunc;
387extern rtx gexf2_libfunc;
388extern rtx ltxf2_libfunc;
389extern rtx lexf2_libfunc;
390
391extern rtx eqtf2_libfunc;
392extern rtx netf2_libfunc;
393extern rtx gttf2_libfunc;
394extern rtx getf2_libfunc;
395extern rtx lttf2_libfunc;
396extern rtx letf2_libfunc;
397
398extern rtx floatsisf_libfunc;
399extern rtx floatdisf_libfunc;
400extern rtx floattisf_libfunc;
401
402extern rtx floatsidf_libfunc;
403extern rtx floatdidf_libfunc;
404extern rtx floattidf_libfunc;
405
406extern rtx floatsixf_libfunc;
407extern rtx floatdixf_libfunc;
408extern rtx floattixf_libfunc;
409
410extern rtx floatsitf_libfunc;
411extern rtx floatditf_libfunc;
412extern rtx floattitf_libfunc;
413
414extern rtx fixsfsi_libfunc;
415extern rtx fixsfdi_libfunc;
416extern rtx fixsfti_libfunc;
417
418extern rtx fixdfsi_libfunc;
419extern rtx fixdfdi_libfunc;
420extern rtx fixdfti_libfunc;
421
422extern rtx fixxfsi_libfunc;
423extern rtx fixxfdi_libfunc;
424extern rtx fixxfti_libfunc;
425
426extern rtx fixtfsi_libfunc;
427extern rtx fixtfdi_libfunc;
428extern rtx fixtfti_libfunc;
429
430extern rtx fixunssfsi_libfunc;
431extern rtx fixunssfdi_libfunc;
432extern rtx fixunssfti_libfunc;
433
434extern rtx fixunsdfsi_libfunc;
435extern rtx fixunsdfdi_libfunc;
436extern rtx fixunsdfti_libfunc;
437
438extern rtx fixunsxfsi_libfunc;
439extern rtx fixunsxfdi_libfunc;
440extern rtx fixunsxfti_libfunc;
441
442extern rtx fixunstfsi_libfunc;
443extern rtx fixunstfdi_libfunc;
444extern rtx fixunstfti_libfunc;
445\f
446typedef rtx (*rtxfun) ();
447
448/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
449 gives the gen_function to make a branch to test that condition. */
450
451extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
452
453/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
454 gives the insn code to make a store-condition insn
455 to test that condition. */
456
457extern enum insn_code setcc_gen_code[NUM_RTX_CODE];
458
459/* This array records the insn_code of insns to perform block moves. */
460extern enum insn_code movstr_optab[NUM_MACHINE_MODES];
461
462/* Define functions given in optabs.c. */
463
464/* Expand a binary operation given optab and rtx operands. */
465extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx,
466 int, enum optab_methods));
467
468/* Expand a binary operation with both signed and unsigned forms. */
469extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx,
470 rtx, rtx, int, enum optab_methods));
471
472/* Generate code to perform an operation on two operands with two results. */
473extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int));
474
475/* Expand a unary arithmetic operation given optab rtx operand. */
476extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int));
477
478/* Expand the complex absolute value operation. */
479extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int));
480
481/* Generate an instruction with a given INSN_CODE with an output and
482 an input. */
483extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code));
484
485/* Emit code to perform a series of operations on a multi-word quantity, one
486 word at a time. */
487extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx));
488
489/* Emit code to make a call to a constant function or a library call. */
490extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx));
491
492/* Emit one rtl instruction to store zero in specified rtx. */
493extern void emit_clr_insn PROTO((rtx));
494
495/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */
496extern void emit_0_to_1_insn PROTO((rtx));
497
498/* Emit one rtl insn to compare two rtx's. */
499extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx,
500 enum machine_mode, int, int));
501
502/* Nonzero if a compare of mode MODE can be done straightforwardly
503 (without splitting it into pieces). */
504extern int can_compare_p PROTO((enum machine_mode));
505
506/* Generate code to indirectly jump to a location given in the rtx LOC. */
507extern void emit_indirect_jump PROTO((rtx));
508
509/* Create but don't emit one rtl instruction to add one rtx into another.
510 Modes must match; operands must meet the operation's predicates.
511 Likewise for subtraction and for just copying.
512 These do not call protect_from_queue; caller must do so. */
513extern rtx gen_add2_insn PROTO((rtx, rtx));
514extern rtx gen_sub2_insn PROTO((rtx, rtx));
515extern rtx gen_move_insn PROTO((rtx, rtx));
516extern int have_add2_insn PROTO((enum machine_mode));
517extern int have_sub2_insn PROTO((enum machine_mode));
518
519/* Return the INSN_CODE to use for an extend operation. */
520extern enum insn_code can_extend_p PROTO((enum machine_mode,
521 enum machine_mode, int));
522
523/* Generate the body of an insn to extend Y (with mode MFROM)
524 into X (with mode MTO). Do zero-extension if UNSIGNEDP is nonzero. */
525extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode,
526 enum machine_mode, int));
527
528/* Initialize the tables that control conversion between fixed and
529 floating values. */
530extern void init_fixtab PROTO((void));
531extern void init_floattab PROTO((void));
532
533/* Generate code for a FLOAT_EXPR. */
534extern void expand_float PROTO((rtx, rtx, int));
535
536/* Generate code for a FIX_EXPR. */
537extern void expand_fix PROTO((rtx, rtx, int));
538
539/* Call this once to initialize the contents of the optabs
540 appropriately for the current target machine. */
541extern void init_optabs PROTO((void));
542\f
543/* Functions from expmed.c: */
544
545/* Arguments MODE, RTX: return an rtx for the negation of that value.
546 May emit insns. */
547extern rtx negate_rtx PROTO((enum machine_mode, rtx));
548
549/* Expand a logical AND operation. */
550extern rtx expand_and PROTO((rtx, rtx, rtx));
551
552/* Emit a store-flag operation. */
553extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx,
554 enum machine_mode, int, int));
555
556/* Functions from loop.c: */
557
558/* Given a JUMP_INSN, return a description of the test being made. */
559extern rtx get_condition PROTO((rtx, rtx *));
560\f
561/* Functions from expr.c: */
562
563/* This is run once per compilation to set up which modes can be used
564 directly in memory and to initialize the block move optab. */
565extern void init_expr_once PROTO((void));
566
567/* This is run at the start of compiling a function. */
568extern void init_expr PROTO((void));
569
570/* Use protect_from_queue to convert a QUEUED expression
571 into something that you can put immediately into an instruction. */
572extern rtx protect_from_queue PROTO((rtx, int));
573
574/* Perform all the pending incrementations. */
575extern void emit_queue PROTO((void));
576
577/* Emit some rtl insns to move data between rtx's, converting machine modes.
578 Both modes must be floating or both fixed. */
579extern void convert_move PROTO((rtx, rtx, int));
580
581/* Convert an rtx to specified machine mode and return the result. */
582extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int));
583
584/* Emit code to move a block Y to a block X. */
585extern void emit_block_move PROTO((rtx, rtx, rtx, int));
586
587/* Copy all or part of a value X into registers starting at REGNO.
588 The number of registers to be filled is NREGS. */
589extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode));
590
591/* Copy all or part of a BLKmode value X out of registers starting at REGNO.
592 The number of registers to be filled is NREGS. */
593extern void move_block_from_reg PROTO((int, rtx, int));
594
595/* Mark NREGS consecutive regs, starting at REGNO, as being live now. */
596extern void use_regs PROTO((int, int));
597
598/* Write zeros through the storage of OBJECT.
599 If OBJECT has BLKmode, SIZE is its length in bytes. */
600extern void clear_storage PROTO((rtx, int));
601
602/* Emit insns to set X from Y. */
603extern rtx emit_move_insn PROTO((rtx, rtx));
604
605/* Emit insns to set X from Y, with no frills. */
606extern rtx emit_move_insn_1 PROTO ((rtx, rtx));
607
608/* Push a block of length SIZE (perhaps variable)
609 and return an rtx to address the beginning of the block. */
610extern rtx push_block PROTO((rtx, int, int));
611
612/* Make an operand to push someting on the stack. */
613extern rtx gen_push_operand PROTO((void));
614
615#ifdef TREE_CODE
616/* Generate code to push something onto the stack, given its mode and type. */
617extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int,
618 int, rtx, int, rtx, rtx));
619
620/* Emit library call. These cannot have accurate prototypes since they have
621 a variable number of args. */
622extern void emit_library_call ();
623extern void emit_library_call_value ();
624
625/* Expand an assignment that stores the value of FROM into TO. */
626extern rtx expand_assignment PROTO((tree, tree, int, int));
627
628/* Generate code for computing expression EXP,
629 and storing the value into TARGET.
630 If SUGGEST_REG is nonzero, copy the value through a register
631 and return that register, if that is possible. */
632extern rtx store_expr PROTO((tree, rtx, int));
633#endif
634
635/* Given an rtx that may include add and multiply operations,
636 generate them as insns and return a pseudo-reg containing the value.
637 Useful after calling expand_expr with 1 as sum_ok. */
638extern rtx force_operand PROTO((rtx, rtx));
639
640#ifdef TREE_CODE
641/* Generate code for computing expression EXP.
642 An rtx for the computed value is returned. The value is never null.
643 In the case of a void EXP, const0_rtx is returned. */
644extern rtx expand_expr PROTO((tree, rtx, enum machine_mode,
645 enum expand_modifier));
646#endif
647
648/* At the start of a function, record that we have no previously-pushed
649 arguments waiting to be popped. */
650extern void init_pending_stack_adjust PROTO((void));
651
652/* When exiting from function, if safe, clear out any pending stack adjust
653 so the adjustment won't get done. */
654extern void clear_pending_stack_adjust PROTO((void));
655
656/* Pop any previously-pushed arguments that have not been popped yet. */
657extern void do_pending_stack_adjust PROTO((void));
658
659#ifdef TREE_CODE
660/* Expand all cleanups up to OLD_CLEANUPS. */
661extern void expand_cleanups_to PROTO((tree));
662
663/* Generate code to evaluate EXP and jump to LABEL if the value is zero. */
664extern void jumpifnot PROTO((tree, rtx));
665
666/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero. */
667extern void jumpif PROTO((tree, rtx));
668
669/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
670 the result is zero, or IF_TRUE_LABEL if the result is one. */
671extern void do_jump PROTO((tree, rtx, rtx));
672#endif
673
674/* Generate rtl to compare two rtx's, will call emit_cmp_insn. */
675extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int,
676 enum machine_mode, rtx, int));
677
678/* Generate a tablejump instruction (used for switch statements). */
679extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx));
680\f
681#ifdef TREE_CODE
682/* rtl.h and tree.h were included. */
683/* Return an rtx for the size in bytes of the value of an expr. */
684extern rtx expr_size PROTO((tree));
685
686extern rtx lookup_static_chain PROTO((tree));
687
688/* Convert a stack slot address ADDR valid in function FNDECL
689 into an address valid in this function (using a static chain). */
690extern rtx fix_lexical_addr PROTO((rtx, tree));
691
692/* Return the address of the trampoline for entering nested fn FUNCTION. */
693extern rtx trampoline_address PROTO((tree));
694
695/* Return an rtx that refers to the value returned by a function
696 in its original home. This becomes invalid if any more code is emitted. */
697extern rtx hard_function_value PROTO((tree, tree));
698
699extern rtx prepare_call_address PROTO((rtx, tree, rtx *));
700
701extern rtx expand_call PROTO((tree, rtx, int));
702
703extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int));
704extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int));
705extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *));
706extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx));
707/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */
708extern rtx label_rtx PROTO((tree));
709#endif
710
711/* Indicate how an input argument register was promoted. */
712extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *));
713
714/* Return an rtx like arg but sans any constant terms.
715 Returns the original rtx if it has no constant terms.
716 The constant terms are added and stored via a second arg. */
717extern rtx eliminate_constant_term PROTO((rtx, rtx *));
718
719/* Convert arg to a valid memory address for specified machine mode,
720 by emitting insns to perform arithmetic if nec. */
721extern rtx memory_address PROTO((enum machine_mode, rtx));
722
723/* Like `memory_address' but pretent `flag_force_addr' is 0. */
724extern rtx memory_address_noforce PROTO((enum machine_mode, rtx));
725
726/* Return a memory reference like MEMREF, but with its mode changed
727 to MODE and its address changed to ADDR.
728 (VOIDmode means don't change the mode.
729 NULL for ADDR means don't change the address.) */
730extern rtx change_address PROTO((rtx, enum machine_mode, rtx));
731
732/* Return a memory reference like MEMREF, but which is known to have a
733 valid address. */
734
735extern rtx validize_mem PROTO((rtx));
736
737/* Assemble the static constant template for function entry trampolines. */
738extern rtx assemble_trampoline_template PROTO((void));
739
740/* Return 1 if two rtx's are equivalent in structure and elements. */
741extern int rtx_equal_p PROTO((rtx, rtx));
742
743/* Given rtx, return new rtx whose address won't be affected by
744 any side effects. It has been copied to a new temporary reg. */
745extern rtx stabilize PROTO((rtx));
746
747/* Given an rtx, copy all regs it refers to into new temps
748 and return a modified copy that refers to the new temps. */
749extern rtx copy_all_regs PROTO((rtx));
750
751/* Copy given rtx to a new temp reg and return that. */
752extern rtx copy_to_reg PROTO((rtx));
753
754/* Like copy_to_reg but always make the reg Pmode. */
755extern rtx copy_addr_to_reg PROTO((rtx));
756
757/* Like copy_to_reg but always make the reg the specified mode MODE. */
758extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx));
759
760/* Copy given rtx to given temp reg and return that. */
761extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode));
762
763/* Copy a value to a register if it isn't already a register.
764 Args are mode (in case value is a constant) and the value. */
765extern rtx force_reg PROTO((enum machine_mode, rtx));
766
767/* Return given rtx, copied into a new temp reg if it was in memory. */
768extern rtx force_not_mem PROTO((rtx));
769
770/* Remove some bytes from the stack. An rtx says how many. */
771extern void adjust_stack PROTO((rtx));
772
773/* Add some bytes to the stack. An rtx says how many. */
774extern void anti_adjust_stack PROTO((rtx));
775
776/* This enum is used for the following two functions. */
777enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
778
779/* Save the stack pointer at the specified level. */
780extern void emit_stack_save PROTO((enum save_level, rtx *, rtx));
781
782/* Restore the stack pointer from a save area of the specified level. */
783extern void emit_stack_restore PROTO((enum save_level, rtx, rtx));
784
785/* Allocate some space on the stack dynamically and return its address. An rtx
786 says how many bytes. */
787extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int));
788
789/* Emit code to copy function value to a new temp reg and return that reg. */
790extern rtx function_value ();
791
792/* Return an rtx that refers to the value returned by a library call
793 in its original home. This becomes invalid if any more code is emitted. */
794extern rtx hard_libcall_value PROTO((enum machine_mode));
795
796/* Given an rtx, return an rtx for a value rounded up to a multiple
797 of STACK_BOUNDARY / BITS_PER_UNIT. */
798extern rtx round_push PROTO((rtx));
799
800extern void emit_block_move PROTO((rtx, rtx, rtx, int));
801
802extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int));
803extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int));
804extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int));
805extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int));
806
807extern rtx assemble_static_space PROTO((int));
808
809/* Hook called by expand_expr for language-specific tree codes.
810 It is up to the language front end to install a hook
811 if it has any such codes that expand_expr needs to know about. */
812extern rtx (*lang_expand_expr) ();
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.