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