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

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