source: trunk/third/gcc/expr.h @ 11288

Revision 11288, 34.3 KB checked in by ghudson, 26 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r11287, which included commits to RCS files with non-trunk default branches.
Line 
1/* Definitions for code generation pass of GNU compiler.
2   Copyright (C) 1987, 91-97, 1998 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, 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA.  */
20
21/* The default branch cost is 1.  */
22#ifndef BRANCH_COST
23#define BRANCH_COST 1
24#endif
25
26/* Macros to access the slots of a QUEUED rtx.
27   Here rather than in rtl.h because only the expansion pass
28   should ever encounter a QUEUED.  */
29
30/* The variable for which an increment is queued.  */
31#define QUEUED_VAR(P) XEXP (P, 0)
32/* If the increment has been emitted, this is the insn
33   that does the increment.  It is zero before the increment is emitted.  */
34#define QUEUED_INSN(P) XEXP (P, 1)
35/* If a pre-increment copy has been generated, this is the copy
36   (it is a temporary reg).  Zero if no copy made yet.  */
37#define QUEUED_COPY(P) XEXP (P, 2)
38/* This is the body to use for the insn to do the increment.
39   It is used to emit the increment.  */
40#define QUEUED_BODY(P) XEXP (P, 3)
41/* Next QUEUED in the queue.  */
42#define QUEUED_NEXT(P) XEXP (P, 4)
43
44/* This is the 4th arg to `expand_expr'.
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_MEMORY_USE_* are explained below.  */
50enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
51                      EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER,
52                      EXPAND_MEMORY_USE_WO, EXPAND_MEMORY_USE_RW,
53                      EXPAND_MEMORY_USE_BAD, EXPAND_MEMORY_USE_DONT};
54
55/* Argument for chkr_* functions.
56   MEMORY_USE_RO: the pointer reads memory.
57   MEMORY_USE_WO: the pointer writes to memory.
58   MEMORY_USE_RW: the pointer modifies memory (ie it reads and writes). An
59                  example is (*ptr)++
60   MEMORY_USE_BAD: use this if you don't know the behavior of the pointer, or
61                   if you know there are no pointers.  Using an INDIRECT_REF
62                   with MEMORY_USE_BAD will abort.
63   MEMORY_USE_TW: just test for writing, without update.  Special.
64   MEMORY_USE_DONT: the memory is neither read nor written.  This is used by
65                   '->' and '.'.  */
66enum memory_use_mode {MEMORY_USE_BAD = 0, MEMORY_USE_RO = 1,
67                      MEMORY_USE_WO = 2, MEMORY_USE_RW = 3,
68                      MEMORY_USE_TW = 6, MEMORY_USE_DONT = 99};
69
70/* List of labels that must never be deleted.  */
71extern rtx forced_labels;
72
73/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
74   So we can mark them all live at the end of the function, if stupid.  */
75extern rtx save_expr_regs;
76
77extern int current_function_calls_alloca;
78extern int current_function_outgoing_args_size;
79
80/* This is the offset from the arg pointer to the place where the first
81   anonymous arg can be found, if there is one.  */
82extern rtx current_function_arg_offset_rtx;
83
84/* This is nonzero if the current function uses the constant pool.  */
85extern int current_function_uses_const_pool;
86
87/* This is nonzero if the current function uses pic_offset_table_rtx.  */
88extern int current_function_uses_pic_offset_table;
89
90/* The arg pointer hard register, or the pseudo into which it was copied.  */
91extern rtx current_function_internal_arg_pointer;
92
93/* Nonzero means stack pops must not be deferred, and deferred stack
94   pops must not be output.  It is nonzero inside a function call,
95   inside a conditional expression, inside a statement expression,
96   and in other cases as well.  */
97extern int inhibit_defer_pop;
98
99/* Number of function calls seen so far in current function.  */
100
101extern int function_call_count;
102
103/* RTX for stack slot that holds the current handler for nonlocal gotos.
104   Zero when function does not have nonlocal labels.  */
105
106extern rtx nonlocal_goto_handler_slot;
107
108/* RTX for stack slot that holds the stack pointer value to restore
109   for a nonlocal goto.
110   Zero when function does not have nonlocal labels.  */
111
112extern rtx nonlocal_goto_stack_level;
113
114/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
115   (labels to which there can be nonlocal gotos from nested functions)
116   in this function.  */
117
118#ifdef TREE_CODE   /* Don't lose if tree.h not included.  */
119extern tree nonlocal_labels;
120#endif
121
122#define NO_DEFER_POP (inhibit_defer_pop += 1)
123#define OK_DEFER_POP (inhibit_defer_pop -= 1)
124
125/* Number of units that we should eventually pop off the stack.
126   These are the arguments to function calls that have already returned.  */
127extern int pending_stack_adjust;
128
129/* When temporaries are created by TARGET_EXPRs, they are created at
130   this level of temp_slot_level, so that they can remain allocated
131   until no longer needed.  CLEANUP_POINT_EXPRs define the lifetime
132   of TARGET_EXPRs.  */
133extern int target_temp_slot_level;
134
135#ifdef TREE_CODE /* Don't lose if tree.h not included.  */
136/* Structure to record the size of a sequence of arguments
137   as the sum of a tree-expression and a constant.  */
138
139struct args_size
140{
141  HOST_WIDE_INT constant;
142  tree var;
143};
144#endif
145
146/* Add the value of the tree INC to the `struct args_size' TO.  */
147
148#define ADD_PARM_SIZE(TO, INC)  \
149{ tree inc = (INC);                             \
150  if (TREE_CODE (inc) == INTEGER_CST)           \
151    (TO).constant += TREE_INT_CST_LOW (inc);    \
152  else if ((TO).var == 0)                       \
153    (TO).var = inc;                             \
154  else                                          \
155    (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); }
156
157#define SUB_PARM_SIZE(TO, DEC)  \
158{ tree dec = (DEC);                             \
159  if (TREE_CODE (dec) == INTEGER_CST)           \
160    (TO).constant -= TREE_INT_CST_LOW (dec);    \
161  else if ((TO).var == 0)                       \
162    (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \
163  else                                          \
164    (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
165
166/* Convert the implicit sum in a `struct args_size' into an rtx.  */
167#define ARGS_SIZE_RTX(SIZE)                                             \
168((SIZE).var == 0 ? GEN_INT ((SIZE).constant)    \
169 : expand_expr (size_binop (PLUS_EXPR, (SIZE).var,                      \
170                            size_int ((SIZE).constant)),                \
171                NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD))
172
173/* Convert the implicit sum in a `struct args_size' into a tree.  */
174#define ARGS_SIZE_TREE(SIZE)                                            \
175((SIZE).var == 0 ? size_int ((SIZE).constant)                           \
176 : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant)))
177
178/* Supply a default definition for FUNCTION_ARG_PADDING:
179   usually pad upward, but pad short args downward on
180   big-endian machines.  */
181
182enum direction {none, upward, downward};  /* Value has this type.  */
183
184#ifndef FUNCTION_ARG_PADDING
185#define FUNCTION_ARG_PADDING(MODE, TYPE)                                \
186  (! BYTES_BIG_ENDIAN                                                   \
187   ? upward                                                             \
188   : (((MODE) == BLKmode                                                \
189       ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST         \
190          && int_size_in_bytes (TYPE) < (PARM_BOUNDARY / BITS_PER_UNIT)) \
191       : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY)                       \
192      ? downward : upward))
193#endif
194
195/* Supply a default definition for FUNCTION_ARG_BOUNDARY.  Normally, we let
196   FUNCTION_ARG_PADDING, which also pads the length, handle any needed
197   alignment.  */
198 
199#ifndef FUNCTION_ARG_BOUNDARY
200#define FUNCTION_ARG_BOUNDARY(MODE, TYPE)       PARM_BOUNDARY
201#endif
202
203/* Nonzero if we do not know how to pass TYPE solely in registers.
204   We cannot do so in the following cases:
205
206   - if the type has variable size
207   - if the type is marked as addressable (it is required to be constructed
208     into the stack)
209   - if the padding and mode of the type is such that a copy into a register
210     would put it into the wrong part of the register.
211
212   Which padding can't be supported depends on the byte endianness.
213
214   A value in a register is implicitly padded at the most significant end.
215   On a big-endian machine, that is the lower end in memory.
216   So a value padded in memory at the upper end can't go in a register.
217   For a little-endian machine, the reverse is true.  */
218
219#define MUST_PASS_IN_STACK(MODE,TYPE)                   \
220  ((TYPE) != 0                                          \
221   && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST      \
222       || TREE_ADDRESSABLE (TYPE)                       \
223       || ((MODE) == BLKmode                            \
224           && ! ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
225                 && 0 == (int_size_in_bytes (TYPE)      \
226                          % (PARM_BOUNDARY / BITS_PER_UNIT))) \
227           && (FUNCTION_ARG_PADDING (MODE, TYPE)        \
228               == (BYTES_BIG_ENDIAN ? upward : downward)))))
229
230/* Nonzero if type TYPE should be returned in memory.
231   Most machines can use the following default definition.  */
232
233#ifndef RETURN_IN_MEMORY
234#define RETURN_IN_MEMORY(TYPE) (TYPE_MODE (TYPE) == BLKmode)
235#endif
236
237/* Provide default values for the macros controlling stack checking.  */
238
239#ifndef STACK_CHECK_BUILTIN
240#define STACK_CHECK_BUILTIN 0
241#endif
242
243/* The default interval is one page.  */
244#ifndef STACK_CHECK_PROBE_INTERVAL
245#define STACK_CHECK_PROBE_INTERVAL 4096
246#endif
247
248/* The default is to do a store into the stack.  */
249#ifndef STACK_CHECK_PROBE_LOAD
250#define STACK_CHECK_PROBE_LOAD 0
251#endif
252
253/* This value is arbitrary, but should be sufficient for most machines.  */
254#ifndef STACK_CHECK_PROTECT
255#define STACK_CHECK_PROTECT (75 * UNITS_PER_WORD)
256#endif
257
258/* Make the maximum frame size be the largest we can and still only need
259   one probe per function.  */
260#ifndef STACK_CHECK_MAX_FRAME_SIZE
261#define STACK_CHECK_MAX_FRAME_SIZE \
262  (STACK_CHECK_PROBE_INTERVAL - UNITS_PER_WORD)
263#endif
264
265/* This is arbitrary, but should be large enough everywhere.  */
266#ifndef STACK_CHECK_FIXED_FRAME_SIZE
267#define STACK_CHECK_FIXED_FRAME_SIZE (4 * UNITS_PER_WORD)
268#endif
269
270/* Provide a reasonable default for the maximum size of an object to
271   allocate in the fixed frame.  We may need to be able to make this
272   controllable by the user at some point.  */
273#ifndef STACK_CHECK_MAX_VAR_SIZE
274#define STACK_CHECK_MAX_VAR_SIZE (STACK_CHECK_MAX_FRAME_SIZE / 100)
275#endif
276
277/* Optabs are tables saying how to generate insn bodies
278   for various machine modes and numbers of operands.
279   Each optab applies to one operation.
280   For example, add_optab applies to addition.
281
282   The insn_code slot is the enum insn_code that says how to
283   generate an insn for this operation on a particular machine mode.
284   It is CODE_FOR_nothing if there is no such insn on the target machine.
285
286   The `lib_call' slot is the name of the library function that
287   can be used to perform the operation.
288
289   A few optabs, such as move_optab and cmp_optab, are used
290   by special code.  */
291
292/* Everything that uses expr.h needs to define enum insn_code
293   but we don't list it in the Makefile dependencies just for that.  */
294#include "insn-codes.h"
295
296typedef struct optab
297{
298  enum rtx_code code;
299  struct {
300    enum insn_code insn_code;
301    rtx libfunc;
302  } handlers [NUM_MACHINE_MODES];
303} * optab;
304
305/* Given an enum insn_code, access the function to construct
306   the body of that kind of insn.  */
307#ifdef FUNCTION_CONVERSION_BUG
308/* Some compilers fail to convert a function properly to a
309   pointer-to-function when used as an argument.
310   So produce the pointer-to-function directly.
311   Luckily, these compilers seem to work properly when you
312   call the pointer-to-function.  */
313#define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)])
314#else
315#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)])
316#endif
317
318extern rtx (*const insn_gen_function[]) ();
319
320extern optab add_optab;
321extern optab sub_optab;
322extern optab smul_optab;        /* Signed and floating-point multiply */
323extern optab smul_highpart_optab; /* Signed multiply, return high word */
324extern optab umul_highpart_optab;
325extern optab smul_widen_optab;  /* Signed multiply with result
326                                   one machine mode wider than args */
327extern optab umul_widen_optab;
328extern optab sdiv_optab;        /* Signed divide */
329extern optab sdivmod_optab;     /* Signed divide-and-remainder in one */
330extern optab udiv_optab;
331extern optab udivmod_optab;
332extern optab smod_optab;        /* Signed remainder */
333extern optab umod_optab;
334extern optab flodiv_optab;      /* Optab for floating divide. */
335extern optab ftrunc_optab;      /* Convert float to integer in float fmt */
336extern optab and_optab;         /* Logical and */
337extern optab ior_optab;         /* Logical or */
338extern optab xor_optab;         /* Logical xor */
339extern optab ashl_optab;        /* Arithmetic shift left */
340extern optab ashr_optab;        /* Arithmetic shift right */
341extern optab lshr_optab;        /* Logical shift right */
342extern optab rotl_optab;        /* Rotate left */
343extern optab rotr_optab;        /* Rotate right */
344extern optab smin_optab;        /* Signed and floating-point minimum value */
345extern optab smax_optab;        /* Signed and floating-point maximum value */
346extern optab umin_optab;        /* Unsigned minimum value */
347extern optab umax_optab;        /* Unsigned maximum value */
348
349extern optab mov_optab;         /* Move instruction.  */
350extern optab movstrict_optab;   /* Move, preserving high part of register.  */
351
352extern optab cmp_optab;         /* Compare insn; two operands.  */
353extern optab tst_optab;         /* tst insn; compare one operand against 0 */
354
355/* Unary operations */
356extern optab neg_optab;         /* Negation */
357extern optab abs_optab;         /* Abs value */
358extern optab one_cmpl_optab;    /* Bitwise not */
359extern optab ffs_optab;         /* Find first bit set */
360extern optab sqrt_optab;        /* Square root */
361extern optab sin_optab;         /* Sine */
362extern optab cos_optab;         /* Cosine */
363extern optab strlen_optab;      /* String length */
364
365/* Tables of patterns for extending one integer mode to another.  */
366extern enum insn_code extendtab[MAX_MACHINE_MODE][MAX_MACHINE_MODE][2];
367
368/* Tables of patterns for converting between fixed and floating point. */
369extern enum insn_code fixtab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
370extern enum insn_code fixtrunctab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
371extern enum insn_code floattab[NUM_MACHINE_MODES][NUM_MACHINE_MODES][2];
372
373/* Contains the optab used for each rtx code.  */
374extern optab code_to_optab[NUM_RTX_CODE + 1];
375
376/* Passed to expand_binop and expand_unop to say which options to try to use
377   if the requested operation can't be open-coded on the requisite mode.
378   Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call.
379   Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode.
380   OPTAB_MUST_WIDEN says try widening and don't try anything else.  */
381
382enum optab_methods
383{
384  OPTAB_DIRECT,
385  OPTAB_LIB,
386  OPTAB_WIDEN,
387  OPTAB_LIB_WIDEN,
388  OPTAB_MUST_WIDEN
389};
390
391/* SYMBOL_REF rtx's for the library functions that are called
392   implicitly and not via optabs.  */
393
394extern rtx extendsfdf2_libfunc;
395extern rtx extendsfxf2_libfunc;
396extern rtx extendsftf2_libfunc;
397extern rtx extenddfxf2_libfunc;
398extern rtx extenddftf2_libfunc;
399
400extern rtx truncdfsf2_libfunc;
401extern rtx truncxfsf2_libfunc;
402extern rtx trunctfsf2_libfunc;
403extern rtx truncxfdf2_libfunc;
404extern rtx trunctfdf2_libfunc;
405
406extern rtx memcpy_libfunc;
407extern rtx bcopy_libfunc;
408extern rtx memcmp_libfunc;
409extern rtx bcmp_libfunc;
410extern rtx memset_libfunc;
411extern rtx bzero_libfunc;
412
413extern rtx throw_libfunc;
414extern rtx sjthrow_libfunc;
415extern rtx sjpopnthrow_libfunc;
416extern rtx terminate_libfunc;
417extern rtx setjmp_libfunc;
418extern rtx longjmp_libfunc;
419
420extern rtx eqhf2_libfunc;
421extern rtx nehf2_libfunc;
422extern rtx gthf2_libfunc;
423extern rtx gehf2_libfunc;
424extern rtx lthf2_libfunc;
425extern rtx lehf2_libfunc;
426
427extern rtx eqsf2_libfunc;
428extern rtx nesf2_libfunc;
429extern rtx gtsf2_libfunc;
430extern rtx gesf2_libfunc;
431extern rtx ltsf2_libfunc;
432extern rtx lesf2_libfunc;
433
434extern rtx eqdf2_libfunc;
435extern rtx nedf2_libfunc;
436extern rtx gtdf2_libfunc;
437extern rtx gedf2_libfunc;
438extern rtx ltdf2_libfunc;
439extern rtx ledf2_libfunc;
440
441extern rtx eqxf2_libfunc;
442extern rtx nexf2_libfunc;
443extern rtx gtxf2_libfunc;
444extern rtx gexf2_libfunc;
445extern rtx ltxf2_libfunc;
446extern rtx lexf2_libfunc;
447
448extern rtx eqtf2_libfunc;
449extern rtx netf2_libfunc;
450extern rtx gttf2_libfunc;
451extern rtx getf2_libfunc;
452extern rtx lttf2_libfunc;
453extern rtx letf2_libfunc;
454
455extern rtx floatsisf_libfunc;
456extern rtx floatdisf_libfunc;
457extern rtx floattisf_libfunc;
458
459extern rtx floatsidf_libfunc;
460extern rtx floatdidf_libfunc;
461extern rtx floattidf_libfunc;
462
463extern rtx floatsixf_libfunc;
464extern rtx floatdixf_libfunc;
465extern rtx floattixf_libfunc;
466
467extern rtx floatsitf_libfunc;
468extern rtx floatditf_libfunc;
469extern rtx floattitf_libfunc;
470
471extern rtx fixsfsi_libfunc;
472extern rtx fixsfdi_libfunc;
473extern rtx fixsfti_libfunc;
474
475extern rtx fixdfsi_libfunc;
476extern rtx fixdfdi_libfunc;
477extern rtx fixdfti_libfunc;
478
479extern rtx fixxfsi_libfunc;
480extern rtx fixxfdi_libfunc;
481extern rtx fixxfti_libfunc;
482
483extern rtx fixtfsi_libfunc;
484extern rtx fixtfdi_libfunc;
485extern rtx fixtfti_libfunc;
486
487extern rtx fixunssfsi_libfunc;
488extern rtx fixunssfdi_libfunc;
489extern rtx fixunssfti_libfunc;
490
491extern rtx fixunsdfsi_libfunc;
492extern rtx fixunsdfdi_libfunc;
493extern rtx fixunsdfti_libfunc;
494
495extern rtx fixunsxfsi_libfunc;
496extern rtx fixunsxfdi_libfunc;
497extern rtx fixunsxfti_libfunc;
498
499extern rtx fixunstfsi_libfunc;
500extern rtx fixunstfdi_libfunc;
501extern rtx fixunstfti_libfunc;
502
503/* For check-memory-usage.  */
504extern rtx chkr_check_addr_libfunc;
505extern rtx chkr_set_right_libfunc;
506extern rtx chkr_copy_bitmap_libfunc;
507extern rtx chkr_check_exec_libfunc;
508extern rtx chkr_check_str_libfunc;
509
510typedef rtx (*rtxfun) ();
511
512/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
513   gives the gen_function to make a branch to test that condition.  */
514
515extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
516
517/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
518   gives the insn code to make a store-condition insn
519   to test that condition.  */
520
521extern enum insn_code setcc_gen_code[NUM_RTX_CODE];
522
523#ifdef HAVE_conditional_move
524/* Indexed by the the machine mode, gives the insn code to make a conditional
525   move insn.  */
526
527extern enum insn_code movcc_gen_code[NUM_MACHINE_MODES];
528#endif
529
530/* This array records the insn_code of insns to perform block moves.  */
531extern enum insn_code movstr_optab[NUM_MACHINE_MODES];
532
533/* This array records the insn_code of insns to perform block clears.  */
534extern enum insn_code clrstr_optab[NUM_MACHINE_MODES];
535
536/* Define functions given in optabs.c.  */
537
538/* Expand a binary operation given optab and rtx operands.  */
539extern rtx expand_binop PROTO((enum machine_mode, optab, rtx, rtx, rtx,
540                               int, enum optab_methods));
541
542/* Expand a binary operation with both signed and unsigned forms.  */
543extern rtx sign_expand_binop PROTO((enum machine_mode, optab, optab, rtx,
544                                    rtx, rtx, int, enum optab_methods));
545
546/* Generate code to perform an operation on two operands with two results.  */
547extern int expand_twoval_binop PROTO((optab, rtx, rtx, rtx, rtx, int));
548
549/* Expand a unary arithmetic operation given optab rtx operand.  */
550extern rtx expand_unop PROTO((enum machine_mode, optab, rtx, rtx, int));
551
552/* Expand the absolute value operation.  */
553extern rtx expand_abs PROTO((enum machine_mode, rtx, rtx, int, int));
554
555/* Expand the complex absolute value operation.  */
556extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int));
557
558/* Generate an instruction with a given INSN_CODE with an output and
559   an input.  */
560extern void emit_unop_insn PROTO((int, rtx, rtx, enum rtx_code));
561
562/* Emit code to perform a series of operations on a multi-word quantity, one
563   word at a time.  */
564extern rtx emit_no_conflict_block PROTO((rtx, rtx, rtx, rtx, rtx));
565
566/* Emit code to make a call to a constant function or a library call. */
567extern void emit_libcall_block PROTO((rtx, rtx, rtx, rtx));
568
569/* Emit one rtl instruction to store zero in specified rtx.  */
570extern void emit_clr_insn PROTO((rtx));
571
572/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0.  */
573extern void emit_0_to_1_insn PROTO((rtx));
574
575/* Emit one rtl insn to compare two rtx's.  */
576extern void emit_cmp_insn PROTO((rtx, rtx, enum rtx_code, rtx,
577                                 enum machine_mode, int, int));
578
579/* Nonzero if a compare of mode MODE can be done straightforwardly
580   (without splitting it into pieces).  */
581extern int can_compare_p PROTO((enum machine_mode));
582
583/* Emit a library call comparison between floating point X and Y.
584   COMPARISON is the rtl operator to compare with (EQ, NE, GT, etc.).  */
585extern void emit_float_lib_cmp PROTO((rtx, rtx, enum rtx_code));
586
587/* Generate code to indirectly jump to a location given in the rtx LOC.  */
588extern void emit_indirect_jump PROTO((rtx));
589
590#ifdef HAVE_conditional_move
591/* Emit a conditional move operation.  */
592rtx emit_conditional_move PROTO((rtx, enum rtx_code, rtx, rtx,
593                                 enum machine_mode, rtx, rtx,
594                                 enum machine_mode, int));
595
596/* Return non-zero if the conditional move is supported.  */
597int can_conditionally_move_p PROTO((enum machine_mode mode));
598#endif
599
600/* Create but don't emit one rtl instruction to add one rtx into another.
601   Modes must match; operands must meet the operation's predicates.
602   Likewise for subtraction and for just copying.
603   These do not call protect_from_queue; caller must do so.  */
604extern rtx gen_add2_insn PROTO((rtx, rtx));
605extern rtx gen_sub2_insn PROTO((rtx, rtx));
606extern rtx gen_move_insn PROTO((rtx, rtx));
607extern int have_add2_insn PROTO((enum machine_mode));
608extern int have_sub2_insn PROTO((enum machine_mode));
609
610/* Return the INSN_CODE to use for an extend operation.  */
611extern enum insn_code can_extend_p PROTO((enum machine_mode,
612                                          enum machine_mode, int));
613
614/* Generate the body of an insn to extend Y (with mode MFROM)
615   into X (with mode MTO).  Do zero-extension if UNSIGNEDP is nonzero.  */
616extern rtx gen_extend_insn PROTO((rtx, rtx, enum machine_mode,
617                                  enum machine_mode, int));
618
619/* Initialize the tables that control conversion between fixed and
620   floating values.  */
621extern void init_fixtab PROTO((void));
622extern void init_floattab PROTO((void));
623
624/* Generate code for a FLOAT_EXPR.  */
625extern void expand_float PROTO((rtx, rtx, int));
626
627/* Generate code for a FIX_EXPR.  */
628extern void expand_fix PROTO((rtx, rtx, int));
629
630/* Call this once to initialize the contents of the optabs
631   appropriately for the current target machine.  */
632extern void init_optabs PROTO((void));
633
634/* Functions from expmed.c:  */
635
636/* Arguments MODE, RTX: return an rtx for the negation of that value.
637   May emit insns.  */
638extern rtx negate_rtx PROTO((enum machine_mode, rtx));
639
640/* Expand a logical AND operation.  */
641extern rtx expand_and PROTO((rtx, rtx, rtx));
642
643/* Emit a store-flag operation.  */
644extern rtx emit_store_flag PROTO((rtx, enum rtx_code, rtx, rtx,
645                                  enum machine_mode, int, int));
646
647/* Like emit_store_flag, but always succeeds.  */
648extern rtx emit_store_flag_force PROTO((rtx, enum rtx_code, rtx, rtx,
649                                        enum machine_mode, int, int));
650
651/* Functions from loop.c:  */
652
653/* Given a JUMP_INSN, return a description of the test being made.  */
654extern rtx get_condition PROTO((rtx, rtx *));
655
656/* Functions from expr.c:  */
657
658/* This is run once per compilation to set up which modes can be used
659   directly in memory and to initialize the block move optab.  */
660extern void init_expr_once PROTO((void));
661
662/* This is run at the start of compiling a function.  */
663extern void init_expr PROTO((void));
664
665/* Use protect_from_queue to convert a QUEUED expression
666   into something that you can put immediately into an instruction.  */
667extern rtx protect_from_queue PROTO((rtx, int));
668
669/* Perform all the pending incrementations.  */
670extern void emit_queue PROTO((void));
671
672/* Emit some rtl insns to move data between rtx's, converting machine modes.
673   Both modes must be floating or both fixed.  */
674extern void convert_move PROTO((rtx, rtx, int));
675
676/* Convert an rtx to specified machine mode and return the result.  */
677extern rtx convert_to_mode PROTO((enum machine_mode, rtx, int));
678
679/* Convert an rtx to MODE from OLDMODE and return the result.  */
680extern rtx convert_modes PROTO((enum machine_mode, enum machine_mode, rtx, int));
681
682/* Emit code to move a block Y to a block X.  */
683extern rtx emit_block_move PROTO((rtx, rtx, rtx, int));
684
685/* Copy all or part of a value X into registers starting at REGNO.
686   The number of registers to be filled is NREGS.  */
687extern void move_block_to_reg PROTO((int, rtx, int, enum machine_mode));
688
689/* Copy all or part of a BLKmode value X out of registers starting at REGNO.
690   The number of registers to be filled is NREGS.  */
691extern void move_block_from_reg PROTO((int, rtx, int, int));
692
693/* Load a BLKmode value into non-consecutive registers represented by a
694   PARALLEL.  */
695extern void emit_group_load PROTO((rtx, rtx));
696/* Store a BLKmode value from non-consecutive registers represented by a
697   PARALLEL.  */
698extern void emit_group_store PROTO((rtx, rtx));
699
700/* Mark REG as holding a parameter for the next CALL_INSN.  */
701extern void use_reg PROTO((rtx *, rtx));
702/* Mark NREGS consecutive regs, starting at REGNO, as holding parameters
703   for the next CALL_INSN.  */
704extern void use_regs PROTO((rtx *, int, int));
705/* Mark a PARALLEL as holding a parameter for the next CALL_INSN.  */
706extern void use_group_regs PROTO((rtx *, rtx));
707
708/* Write zeros through the storage of OBJECT.
709   If OBJECT has BLKmode, SIZE is its length in bytes and ALIGN is its
710   alignment.  */
711extern rtx clear_storage PROTO((rtx, rtx, int));
712
713/* Emit insns to set X from Y.  */
714extern rtx emit_move_insn PROTO((rtx, rtx));
715
716/* Emit insns to set X from Y, with no frills.  */
717extern rtx emit_move_insn_1 PROTO ((rtx, rtx));
718
719/* Push a block of length SIZE (perhaps variable)
720   and return an rtx to address the beginning of the block.  */
721extern rtx push_block PROTO((rtx, int, int));
722
723/* Make an operand to push something on the stack.  */
724extern rtx gen_push_operand PROTO((void));
725
726#ifdef TREE_CODE
727/* Generate code to push something onto the stack, given its mode and type.  */
728extern void emit_push_insn PROTO((rtx, enum machine_mode, tree, rtx, int,
729                                  int, rtx, int, rtx, rtx));
730
731/* Emit library call.  */
732extern void emit_library_call PVPROTO((rtx orgfun, int no_queue,
733  enum machine_mode outmode, int nargs, ...));
734extern rtx emit_library_call_value PVPROTO((rtx orgfun, rtx value, int no_queue,
735  enum machine_mode outmode, int nargs, ...));
736
737/* Expand an assignment that stores the value of FROM into TO. */
738extern rtx expand_assignment PROTO((tree, tree, int, int));
739
740/* Generate code for computing expression EXP,
741   and storing the value into TARGET.
742   If SUGGEST_REG is nonzero, copy the value through a register
743   and return that register, if that is possible.  */
744extern rtx store_expr PROTO((tree, rtx, int));
745#endif
746
747/* Given an rtx that may include add and multiply operations,
748   generate them as insns and return a pseudo-reg containing the value.
749   Useful after calling expand_expr with 1 as sum_ok.  */
750extern rtx force_operand PROTO((rtx, rtx));
751
752extern rtx expand_builtin_setjmp PROTO((rtx, rtx));
753
754#ifdef TREE_CODE
755/* Generate code for computing expression EXP.
756   An rtx for the computed value is returned.  The value is never null.
757   In the case of a void EXP, const0_rtx is returned.  */
758extern rtx expand_expr PROTO((tree, rtx, enum machine_mode,
759                              enum expand_modifier));
760#endif
761
762/* At the start of a function, record that we have no previously-pushed
763   arguments waiting to be popped.  */
764extern void init_pending_stack_adjust PROTO((void));
765
766/* When exiting from function, if safe, clear out any pending stack adjust
767   so the adjustment won't get done.  */
768extern void clear_pending_stack_adjust PROTO((void));
769
770/* Pop any previously-pushed arguments that have not been popped yet.  */
771extern void do_pending_stack_adjust PROTO((void));
772
773#ifdef TREE_CODE
774/* Generate code to evaluate EXP and jump to LABEL if the value is zero.  */
775extern void jumpifnot PROTO((tree, rtx));
776
777/* Generate code to evaluate EXP and jump to LABEL if the value is nonzero.  */
778extern void jumpif PROTO((tree, rtx));
779
780/* Generate code to evaluate EXP and jump to IF_FALSE_LABEL if
781   the result is zero, or IF_TRUE_LABEL if the result is one.  */
782extern void do_jump PROTO((tree, rtx, rtx));
783#endif
784
785/* Generate rtl to compare two rtx's, will call emit_cmp_insn.  */
786extern rtx compare_from_rtx PROTO((rtx, rtx, enum rtx_code, int,
787                                   enum machine_mode, rtx, int));
788
789/* Generate a tablejump instruction (used for switch statements).  */
790extern void do_tablejump PROTO((rtx, enum machine_mode, rtx, rtx, rtx));
791
792#ifdef TREE_CODE
793/* rtl.h and tree.h were included.  */
794/* Return an rtx for the size in bytes of the value of an expr.  */
795extern rtx expr_size PROTO((tree));
796
797extern rtx lookup_static_chain PROTO((tree));
798
799/* Convert a stack slot address ADDR valid in function FNDECL
800   into an address valid in this function (using a static chain).  */
801extern rtx fix_lexical_addr PROTO((rtx, tree));
802
803/* Return the address of the trampoline for entering nested fn FUNCTION.  */
804extern rtx trampoline_address PROTO((tree));
805
806/* Return an rtx that refers to the value returned by a function
807   in its original home.  This becomes invalid if any more code is emitted.  */
808extern rtx hard_function_value PROTO((tree, tree));
809
810extern rtx prepare_call_address PROTO((rtx, tree, rtx *, int));
811
812extern rtx expand_call PROTO((tree, rtx, int));
813
814extern rtx expand_shift PROTO((enum tree_code, enum machine_mode, rtx, tree, rtx, int));
815extern rtx expand_divmod PROTO((int, enum tree_code, enum machine_mode, rtx, rtx, rtx, int));
816extern void locate_and_pad_parm PROTO((enum machine_mode, tree, int, tree, struct args_size *, struct args_size *, struct args_size *));
817extern rtx expand_inline_function PROTO((tree, tree, rtx, int, tree, rtx));
818/* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary.  */
819extern rtx label_rtx PROTO((tree));
820#endif
821
822/* Indicate how an input argument register was promoted.  */
823extern rtx promoted_input_arg PROTO((int, enum machine_mode *, int *));
824
825/* Return an rtx like arg but sans any constant terms.
826   Returns the original rtx if it has no constant terms.
827   The constant terms are added and stored via a second arg.  */
828extern rtx eliminate_constant_term PROTO((rtx, rtx *));
829
830/* Convert arg to a valid memory address for specified machine mode,
831   by emitting insns to perform arithmetic if nec.  */
832extern rtx memory_address PROTO((enum machine_mode, rtx));
833
834/* Like `memory_address' but pretent `flag_force_addr' is 0.  */
835extern rtx memory_address_noforce PROTO((enum machine_mode, rtx));
836
837/* Return a memory reference like MEMREF, but with its mode changed
838   to MODE and its address changed to ADDR.
839   (VOIDmode means don't change the mode.
840   NULL for ADDR means don't change the address.)  */
841extern rtx change_address PROTO((rtx, enum machine_mode, rtx));
842
843/* Return a memory reference like MEMREF, but which is known to have a
844   valid address.  */
845
846extern rtx validize_mem PROTO((rtx));
847
848/* Assemble the static constant template for function entry trampolines.  */
849extern rtx assemble_trampoline_template PROTO((void));
850
851/* Return 1 if two rtx's are equivalent in structure and elements.  */
852extern int rtx_equal_p PROTO((rtx, rtx));
853
854/* Given rtx, return new rtx whose address won't be affected by
855   any side effects.  It has been copied to a new temporary reg.  */
856extern rtx stabilize PROTO((rtx));
857
858/* Given an rtx, copy all regs it refers to into new temps
859   and return a modified copy that refers to the new temps.  */
860extern rtx copy_all_regs PROTO((rtx));
861
862/* Copy given rtx to a new temp reg and return that.  */
863extern rtx copy_to_reg PROTO((rtx));
864
865/* Like copy_to_reg but always make the reg Pmode.  */
866extern rtx copy_addr_to_reg PROTO((rtx));
867
868/* Like copy_to_reg but always make the reg the specified mode MODE.  */
869extern rtx copy_to_mode_reg PROTO((enum machine_mode, rtx));
870
871/* Copy given rtx to given temp reg and return that.  */
872extern rtx copy_to_suggested_reg PROTO((rtx, rtx, enum machine_mode));
873
874/* Copy a value to a register if it isn't already a register.
875   Args are mode (in case value is a constant) and the value.  */
876extern rtx force_reg PROTO((enum machine_mode, rtx));
877
878/* Return given rtx, copied into a new temp reg if it was in memory.  */
879extern rtx force_not_mem PROTO((rtx));
880
881#ifdef TREE_CODE
882/* Return mode and signedness to use when object is promoted.  */
883extern enum machine_mode promote_mode PROTO((tree, enum machine_mode,
884                                             int *, int));
885#endif
886
887/* Remove some bytes from the stack.  An rtx says how many.  */
888extern void adjust_stack PROTO((rtx));
889
890/* Add some bytes to the stack.  An rtx says how many.  */
891extern void anti_adjust_stack PROTO((rtx));
892
893/* This enum is used for the following two functions.  */
894enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
895
896/* Save the stack pointer at the specified level.  */
897extern void emit_stack_save PROTO((enum save_level, rtx *, rtx));
898
899/* Restore the stack pointer from a save area of the specified level.  */
900extern void emit_stack_restore PROTO((enum save_level, rtx, rtx));
901
902/* Allocate some space on the stack dynamically and return its address.  An rtx
903   says how many bytes.  */
904extern rtx allocate_dynamic_stack_space PROTO((rtx, rtx, int));
905
906/* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
907   FIRST is a constant and size is a Pmode RTX.  These are offsets from the
908   current stack pointer.  STACK_GROWS_DOWNWARD says whether to add or
909   subtract from the stack.  If SIZE is constant, this is done
910   with a fixed number of probes.  Otherwise, we must make a loop.  */
911extern void probe_stack_range PROTO((HOST_WIDE_INT, rtx));
912
913/* Return an rtx that refers to the value returned by a library call
914   in its original home.  This becomes invalid if any more code is emitted.  */
915extern rtx hard_libcall_value PROTO((enum machine_mode));
916
917/* Given an rtx, return an rtx for a value rounded up to a multiple
918   of STACK_BOUNDARY / BITS_PER_UNIT.  */
919extern rtx round_push PROTO((rtx));
920
921extern rtx store_bit_field PROTO((rtx, int, int, enum machine_mode, rtx, int, int));
922extern rtx extract_bit_field PROTO((rtx, int, int, int, rtx, enum machine_mode, enum machine_mode, int, int));
923extern rtx expand_mult PROTO((enum machine_mode, rtx, rtx, rtx, int));
924extern rtx expand_mult_add PROTO((rtx, rtx, rtx, rtx,enum machine_mode, int));
925extern rtx expand_mult_highpart_adjust PROTO((enum machine_mode, rtx, rtx, rtx, rtx, int));
926
927extern rtx assemble_static_space PROTO((int));
928
929/* Hook called by expand_expr for language-specific tree codes.
930   It is up to the language front end to install a hook
931   if it has any such codes that expand_expr needs to know about.  */
932extern rtx (*lang_expand_expr) ();
933
934#ifdef TREE_CODE
935/* Build bytecode call descriptor for function SUBR. */
936extern rtx bc_build_calldesc PROTO((tree));
937
938/* Emit a type code to be used by the runtime support in handling
939   parameter passing.   The type code consists of the machine mode
940   plus the minimal alignment shifted left 8 bits.  */
941extern tree bc_runtime_type_code PROTO((tree));
942#endif
Note: See TracBrowser for help on using the repository browser.