![[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 [GCC 2.x] / gcc|
Return to expr.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Definitions for code generation pass of GNU compiler.
2: Copyright (C) 1987, 1991 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: /* Macros to access the slots of a QUEUED rtx.
33: Here rather than in rtl.h because only the expansion pass
34: should ever encounter a QUEUED. */
35:
36: /* The variable for which an increment is queued. */
37: #define QUEUED_VAR(P) XEXP (P, 0)
38: /* If the increment has been emitted, this is the insn
39: that does the increment. It is zero before the increment is emitted. */
40: #define QUEUED_INSN(P) XEXP (P, 1)
41: /* If a pre-increment copy has been generated, this is the copy
42: (it is a temporary reg). Zero if no copy made yet. */
43: #define QUEUED_COPY(P) XEXP (P, 2)
44: /* This is the body to use for the insn to do the increment.
45: It is used to emit the increment. */
46: #define QUEUED_BODY(P) XEXP (P, 3)
47: /* Next QUEUED in the queue. */
48: #define QUEUED_NEXT(P) XEXP (P, 4)
49:
50: /* This is the 4th arg to `expand_expr'.
51: EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
52: EXPAND_INITIALIZER is similar but also record any labels on forced_labels.
53: EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
54: is a constant that is not a legitimate address. */
55: enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
56: EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER};
57:
58: /* List of labels that must never be deleted. */
59: extern rtx forced_labels;
60:
61: /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
62: So we can mark them all live at the end of the function, if stupid. */
63: extern rtx save_expr_regs;
64:
65: extern int current_function_calls_alloca;
66: extern int current_function_outgoing_args_size;
67:
68: /* This is the offset from the arg pointer to the place where the first
69: anonymous arg can be found, if there is one. */
70: extern rtx current_function_arg_offset_rtx;
71:
72: /* This is nonzero if the current function uses the constant pool. */
73: extern int current_function_uses_const_pool;
74:
75: /* This is nonzero if the current function uses pic_offset_table_rtx. */
76: extern int current_function_uses_pic_offset_table;
77:
78: /* The arg pointer hard register, or the pseudo into which it was copied. */
79: extern rtx current_function_internal_arg_pointer;
80:
81: /* Nonzero means stack pops must not be deferred, and deferred stack
82: pops must not be output. It is nonzero inside a function call,
83: inside a conditional expression, inside a statement expression,
84: and in other cases as well. */
85: extern int inhibit_defer_pop;
86:
87: /* Number of function calls seen so far in current function. */
88:
89: extern int function_call_count;
90:
91: /* RTX for stack slot that holds the current handler for nonlocal gotos.
92: Zero when function does not have nonlocal labels. */
93:
94: extern rtx nonlocal_goto_handler_slot;
95:
96: /* RTX for stack slot that holds the stack pointer value to restore
97: for a nonlocal goto.
98: Zero when function does not have nonlocal labels. */
99:
100: extern rtx nonlocal_goto_stack_level;
101:
102: /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
103: (labels to which there can be nonlocal gotos from nested functions)
104: in this function. */
105:
106: #ifdef TREE_CODE /* Don't lose if tree.h not included. */
107: extern tree nonlocal_labels;
108: #endif
109:
110: #define NO_DEFER_POP (inhibit_defer_pop += 1)
111: #define OK_DEFER_POP (inhibit_defer_pop -= 1)
112:
113: /* Number of units that we should eventually pop off the stack.
114: These are the arguments to function calls that have already returned. */
115: extern int pending_stack_adjust;
116:
117: /* A list of all cleanups which belong to the arguments of
118: function calls being expanded by expand_call. */
119: #ifdef TREE_CODE /* Don't lose if tree.h not included. */
120: extern tree cleanups_this_call;
121: #endif
122:
123: #ifdef TREE_CODE /* Don't lose if tree.h not included. */
124: /* Structure to record the size of a sequence of arguments
125: as the sum of a tree-expression and a constant. */
126:
127: struct args_size
128: {
129: int constant;
130: tree var;
131: };
132: #endif
133:
134: /* Add the value of the tree INC to the `struct args_size' TO. */
135:
136: #define ADD_PARM_SIZE(TO, INC) \
137: { tree inc = (INC); \
138: if (TREE_CODE (inc) == INTEGER_CST) \
139: (TO).constant += TREE_INT_CST_LOW (inc); \
140: else if ((TO).var == 0) \
141: (TO).var = inc; \
142: else \
143: (TO).var = size_binop (PLUS_EXPR, (TO).var, inc); }
144:
145: #define SUB_PARM_SIZE(TO, DEC) \
146: { tree dec = (DEC); \
147: if (TREE_CODE (dec) == INTEGER_CST) \
148: (TO).constant -= TREE_INT_CST_LOW (dec); \
149: else if ((TO).var == 0) \
150: (TO).var = size_binop (MINUS_EXPR, integer_zero_node, dec); \
151: else \
152: (TO).var = size_binop (MINUS_EXPR, (TO).var, dec); }
153:
154: /* Convert the implicit sum in a `struct args_size' into an rtx. */
155: #define ARGS_SIZE_RTX(SIZE) \
156: ((SIZE).var == 0 ? gen_rtx (CONST_INT, VOIDmode, (SIZE).constant) \
157: : expand_expr (size_binop (PLUS_EXPR, (SIZE).var, \
158: size_int ((SIZE).constant)), \
159: 0, VOIDmode, 0))
160:
161: /* Convert the implicit sum in a `struct args_size' into a tree. */
162: #define ARGS_SIZE_TREE(SIZE) \
163: ((SIZE).var == 0 ? size_int ((SIZE).constant) \
164: : size_binop (PLUS_EXPR, (SIZE).var, size_int ((SIZE).constant)))
165:
166: /* Supply a default definition for FUNCTION_ARG_PADDING:
167: usually pad upward, but pad short, non-BLKmode args downward on
168: big-endian machines. */
169:
170: enum direction {none, upward, downward}; /* Value has this type. */
171:
172: #ifndef FUNCTION_ARG_PADDING
173: #if BYTES_BIG_ENDIAN
174: #define FUNCTION_ARG_PADDING(MODE, TYPE) \
175: (((MODE) == BLKmode \
176: ? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
177: && int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \
178: : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
179: ? downward : upward)
180: #else
181: #define FUNCTION_ARG_PADDING(MODE, TYPE) upward
182: #endif
183: #endif
184:
185: /* Supply a default definition for FUNCTION_ARG_BOUNDARY. Normally, we let
186: FUNCTION_ARG_PADDING, which also pads the length, handle any needed
187: alignment. */
188:
189: #ifndef FUNCTION_ARG_BOUNDARY
190: #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) PARM_BOUNDARY
191: #endif
192:
193: /* Nonzero if we do not know how to pass TYPE solely in registers.
194: We cannot do so in the following cases:
195:
196: - if the type has variable size
197: - if the type is marked as addressable (it is required to be constructed
198: into the stack)
199: - if the padding and mode of the type is such that a copy into a register
200: would put it into the wrong part of the register
201: - when STRICT_ALIGNMENT and the type is BLKmode and is is not
202: aligned to a boundary corresponding to what can be loaded into a
203: register. */
204:
205: #define MUST_PASS_IN_STACK_BAD_ALIGN(MODE,TYPE) \
1.1.1.2 ! root 206: (STRICT_ALIGNMENT && MODE == BLKmode \
1.1 root 207: && TYPE_ALIGN (TYPE) < (BIGGEST_ALIGNMENT < BITS_PER_WORD \
208: ? BIGGEST_ALIGNMENT : BITS_PER_WORD))
209:
210: /* Which padding can't be supported depends on the byte endianness. */
211:
212: /* A value in a register is implicitly padded at the most significant end.
213: On a big-endian machine, that is the lower end in memory.
214: So a value padded in memory at the upper end can't go in a register.
215: For a little-endian machine, the reverse is true. */
216:
217: #if BYTES_BIG_ENDIAN
218: #define MUST_PASS_IN_STACK_BAD_PADDING upward
219: #else
220: #define MUST_PASS_IN_STACK_BAD_PADDING downward
221: #endif
222:
223: #define MUST_PASS_IN_STACK(MODE,TYPE) \
224: ((TYPE) != 0 \
225: && (TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST \
226: || TREE_ADDRESSABLE (TYPE) \
227: || ((MODE) == BLKmode \
228: && (FUNCTION_ARG_PADDING (MODE, TYPE) \
229: == MUST_PASS_IN_STACK_BAD_PADDING)) \
230: || MUST_PASS_IN_STACK_BAD_ALIGN (MODE, TYPE)))
231:
232: /* Nonzero if type TYPE should be returned in memory
233: (even though its mode is not BLKmode).
234: Most machines can use the following default definition. */
235:
236: #ifndef RETURN_IN_MEMORY
237: #define RETURN_IN_MEMORY(TYPE) 0
238: #endif
239:
240: /* Optabs are tables saying how to generate insn bodies
241: for various machine modes and numbers of operands.
242: Each optab applies to one operation.
243: For example, add_optab applies to addition.
244:
245: The insn_code slot is the enum insn_code that says how to
246: generate an insn for this operation on a particular machine mode.
247: It is CODE_FOR_nothing if there is no such insn on the target machine.
248:
249: The `lib_call' slot is the name of the library function that
250: can be used to perform the operation.
251:
252: A few optabs, such as move_optab and cmp_optab, are used
253: by special code. */
254:
255: /* Everything that uses expr.h needs to define enum insn_code
256: but we don't list it in the Makefile dependencies just for that. */
257: #include "insn-codes.h"
258:
259: typedef struct optab
260: {
261: enum rtx_code code;
262: struct {
263: enum insn_code insn_code;
264: rtx libfunc;
265: } handlers [NUM_MACHINE_MODES];
266: } * optab;
267:
268: /* Given an enum insn_code, access the function to construct
269: the body of that kind of insn. */
270: #ifdef FUNCTION_CONVERSION_BUG
271: /* Some compilers fail to convert a function properly to a
272: pointer-to-function when used as an argument.
273: So produce the pointer-to-function directly.
274: Luckily, these compilers seem to work properly when you
275: call the pointer-to-function. */
276: #define GEN_FCN(CODE) (insn_gen_function[(int) (CODE)])
277: #else
278: #define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)])
279: #endif
280:
281: extern rtx (*const insn_gen_function[]) ();
282:
283: extern optab add_optab;
284: extern optab sub_optab;
285: extern optab smul_optab; /* Signed multiply */
286: extern optab smul_widen_optab; /* Signed multiply with result
287: one machine mode wider than args */
288: extern optab umul_widen_optab;
289: extern optab sdiv_optab; /* Signed divide */
290: extern optab sdivmod_optab; /* Signed divide-and-remainder in one */
291: extern optab udiv_optab;
292: extern optab udivmod_optab;
293: extern optab smod_optab; /* Signed remainder */
294: extern optab umod_optab;
295: extern optab flodiv_optab; /* Optab for floating divide. */
296: extern optab ftrunc_optab; /* Convert float to integer in float fmt */
297: extern optab and_optab; /* Logical and */
298: extern optab ior_optab; /* Logical or */
299: extern optab xor_optab; /* Logical xor */
300: extern optab ashl_optab; /* Arithmetic shift left */
301: extern optab ashr_optab; /* Arithmetic shift right */
302: extern optab lshl_optab; /* Logical shift left */
303: extern optab lshr_optab; /* Logical shift right */
304: extern optab rotl_optab; /* Rotate left */
305: extern optab rotr_optab; /* Rotate right */
306: extern optab smin_optab; /* Signed minimum value */
307: extern optab smax_optab; /* Signed maximum value */
308: extern optab umin_optab; /* Unsigned minimum value */
309: extern optab umax_optab; /* Unsigned maximum value */
310:
311: extern optab mov_optab; /* Move instruction. */
312: extern optab movstrict_optab; /* Move, preserving high part of register. */
313:
314: extern optab cmp_optab; /* Compare insn; two operands. */
315: extern optab tst_optab; /* tst insn; compare one operand against 0 */
316:
317: /* Unary operations */
318: extern optab neg_optab; /* Negation */
319: extern optab abs_optab; /* Abs value */
320: extern optab one_cmpl_optab; /* Bitwise not */
321: extern optab ffs_optab; /* Find first bit set */
1.1.1.2 ! root 322: extern optab sqrt_optab; /* Square root */
1.1 root 323:
324: /* Passed to expand_binop and expand_unop to say which options to try to use
325: if the requested operation can't be open-coded on the requisite mode.
326: Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call.
327: Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode.
328: OPTAB_MUST_WIDEN says try widening and don't try anything else. */
329:
330: enum optab_methods
331: {
332: OPTAB_DIRECT,
333: OPTAB_LIB,
334: OPTAB_WIDEN,
335: OPTAB_LIB_WIDEN,
336: OPTAB_MUST_WIDEN
337: };
338:
339: /* SYMBOL_REF rtx's for the library functions that are called
340: implicitly and not via optabs. */
341:
342: extern rtx extendsfdf2_libfunc;
343: extern rtx truncdfsf2_libfunc;
344: extern rtx memcpy_libfunc;
345: extern rtx bcopy_libfunc;
346: extern rtx memcmp_libfunc;
347: extern rtx bcmp_libfunc;
348: extern rtx memset_libfunc;
349: extern rtx bzero_libfunc;
350: extern rtx eqsf2_libfunc;
351: extern rtx nesf2_libfunc;
352: extern rtx gtsf2_libfunc;
353: extern rtx gesf2_libfunc;
354: extern rtx ltsf2_libfunc;
355: extern rtx lesf2_libfunc;
356: extern rtx eqdf2_libfunc;
357: extern rtx nedf2_libfunc;
358: extern rtx gtdf2_libfunc;
359: extern rtx gedf2_libfunc;
360: extern rtx ltdf2_libfunc;
361: extern rtx ledf2_libfunc;
362: extern rtx floatdisf_libfunc;
363: extern rtx floatsisf_libfunc;
364: extern rtx floatdidf_libfunc;
365: extern rtx floatsidf_libfunc;
366: extern rtx fixsfsi_libfunc;
367: extern rtx fixsfdi_libfunc;
368: extern rtx fixdfsi_libfunc;
369: extern rtx fixdfdi_libfunc;
370: extern rtx fixunssfsi_libfunc;
371: extern rtx fixunssfdi_libfunc;
372: extern rtx fixunsdfsi_libfunc;
373: extern rtx fixunsdfdi_libfunc;
374:
375: typedef rtx (*rtxfun) ();
376:
377: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
378: gives the gen_function to make a branch to test that condition. */
379:
380: extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
381:
382: /* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
383: gives the insn code to make a store-condition insn
384: to test that condition. */
385:
386: extern enum insn_code setcc_gen_code[NUM_RTX_CODE];
387:
388: /* Expand a binary operation given optab and rtx operands. */
389: extern rtx expand_binop ();
390:
391: /* Expand a binary operation with both signed and unsigned forms. */
392: extern rtx sign_expand_binop ();
393:
394: /* Expand a unary arithmetic operation given optab rtx operand. */
395: extern rtx expand_unop ();
396:
397: /* Arguments MODE, RTX: return an rtx for the negation of that value.
398: May emit insns. */
399: extern rtx negate_rtx ();
400:
401: /* Expand a logical AND operation. */
402: extern rtx expand_and ();
403:
404: /* Emit a store-flag operation. */
405: extern rtx emit_store_flag ();
406:
407: /* Return the CODE_LABEL rtx for a LABEL_DECL, creating it if necessary. */
408: extern rtx label_rtx ();
409:
410: /* Given a JUMP_INSN, return a description of the test being made. */
411: extern rtx get_condition ();
412:
413: /* Return the INSN_CODE to use for an extend operation. */
414: extern enum insn_code can_extend_p ();
415:
416: /* Initialize the tables that control conversion between fixed and
417: floating values. */
418: extern void init_fixtab ();
419: extern void init_floattab ();
420:
421: /* Generate code for a FIX_EXPR. */
422: extern void expand_fix ();
423:
424: /* Generate code for a FLOAT_EXPR. */
425: extern void expand_float ();
426:
427: /* Create but don't emit one rtl instruction to add one rtx into another.
428: Modes must match; operands must meet the operation's predicates.
429: Likewise for subtraction and for just copying.
430: These do not call protect_from_queue; caller must do so. */
431: extern rtx gen_add2_insn ();
432: extern rtx gen_sub2_insn ();
433: extern rtx gen_move_insn ();
434:
435: /* Emit one rtl instruction to store zero in specified rtx. */
436: extern void emit_clr_insn ();
437:
438: /* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */
439: extern void emit_0_to_1_insn ();
440:
441: /* Emit one rtl insn to compare two rtx's. */
442: extern void emit_cmp_insn ();
443:
444: /* Generate rtl to compate two rtx's, will call emit_cmp_insn. */
445: extern rtx compare_from_rtx ();
446:
447: /* Emit some rtl insns to move data between rtx's, converting machine modes.
448: Both modes must be floating or both fixed. */
449: extern void convert_move ();
450:
451: /* Convert an rtx to specified machine mode and return the result. */
452: extern rtx convert_to_mode ();
453:
454: /* Emit code to push some arguments and call a library routine,
455: storing the value in a specified place. Calling sequence is
456: complicated. */
457: extern void emit_library_call ();
458:
459: /* Given an rtx that may include add and multiply operations,
460: generate them as insns and return a pseudo-reg containing the value.
461: Useful after calling expand_expr with 1 as sum_ok. */
462: extern rtx force_operand ();
463:
464: /* Return an rtx for the size in bytes of the value of an expr. */
465: extern rtx expr_size ();
466:
467: /* Return an rtx for the sum of an rtx and an integer. */
468: extern rtx plus_constant ();
469:
470: extern rtx lookup_static_chain ();
471:
472: /* Return an rtx like arg but sans any constant terms.
473: Returns the original rtx if it has no constant terms.
474: The constant terms are added and stored via a second arg. */
475: extern rtx eliminate_constant_term ();
476:
477: /* Convert arg to a valid memory address for specified machine mode,
478: by emitting insns to perform arithmetic if nec. */
479: extern rtx memory_address ();
480:
481: /* Like `memory_address' but pretent `flag_force_addr' is 0. */
482: extern rtx memory_address_noforce ();
483:
484: /* Return a memory reference like MEMREF, but with its mode changed
485: to MODE and its address changed to ADDR.
486: (VOIDmode means don't change the mode.
487: NULL for ADDR means don't change the address.) */
488: extern rtx change_address ();
489:
490: /* Return a memory reference like MEMREF, but which is known to have a
491: valid address. */
492:
493: extern rtx validize_mem ();
494:
495: /* Convert a stack slot address ADDR valid in function FNDECL
496: into an address valid in this function (using a static chain). */
497: extern rtx fix_lexical_addr ();
498:
499: /* Return the address of the trampoline for entering nested fn FUNCTION. */
500: extern rtx trampoline_address ();
501:
502: /* Assemble the static constant template for function entry trampolines. */
503: extern rtx assemble_trampoline_template ();
504:
505: /* Return 1 if two rtx's are equivalent in structure and elements. */
506: extern int rtx_equal_p ();
507:
508: /* Given rtx, return new rtx whose address won't be affected by
509: any side effects. It has been copied to a new temporary reg. */
510: extern rtx stabilize ();
511:
512: /* Given an rtx, copy all regs it refers to into new temps
513: and return a modified copy that refers to the new temps. */
514: extern rtx copy_all_regs ();
515:
516: /* Copy given rtx to a new temp reg and return that. */
517: extern rtx copy_to_reg ();
518:
519: /* Like copy_to_reg but always make the reg Pmode. */
520: extern rtx copy_addr_to_reg ();
521:
522: /* Like copy_to_reg but always make the reg the specified mode MODE. */
523: extern rtx copy_to_mode_reg ();
524:
525: /* Copy given rtx to given temp reg and return that. */
526: extern rtx copy_to_suggested_reg ();
527:
528: /* Copy a value to a register if it isn't already a register.
529: Args are mode (in case value is a constant) and the value. */
530: extern rtx force_reg ();
531:
532: /* Return given rtx, copied into a new temp reg if it was in memory. */
533: extern rtx force_not_mem ();
534:
535: /* Remove some bytes from the stack. An rtx says how many. */
536: extern void adjust_stack ();
537:
538: /* Add some bytes to the stack. An rtx says how many. */
539: extern void anti_adjust_stack ();
540:
541: /* Allocate some space on the stack dynamically and return its address. An rtx
542: says how many bytes. */
543: extern rtx allocate_dynamic_stack_space ();
544:
545: /* Emit code to copy function value to a new temp reg and return that reg. */
546: extern rtx function_value ();
547:
548: /* Return an rtx that refers to the value returned by a function
549: in its original home. This becomes invalid if any more code is emitted. */
550: extern rtx hard_function_value ();
551:
552: /* Return an rtx that refers to the value returned by a library call
553: in its original home. This becomes invalid if any more code is emitted. */
554: extern rtx hard_libcall_value ();
555:
556: /* Emit code to copy function value to a specified place. */
557: extern void copy_function_value ();
558:
559: /* Given an rtx, return an rtx for a value rounded up to a multiple
560: of STACK_BOUNDARY / BITS_PER_UNIT. */
561: extern rtx round_push ();
562:
563: /* Push a block of length SIZE (perhaps variable)
564: and return an rtx to address the beginning of the block. */
565: extern rtx push_block ();
566:
567: /* Generate code for computing expression EXP,
568: and storing the value into TARGET.
569: If SUGGEST_REG is nonzero, copy the value through a register
570: and return that register, if that is possible. */
571: extern rtx store_expr ();
572:
573: extern rtx prepare_call_address ();
574: extern rtx expand_call ();
575: extern void emit_call_1 ();
576:
577: extern void emit_block_move ();
578: extern void emit_push_insn ();
579: extern void use_regs ();
580: extern void move_block_to_reg ();
581:
582: extern rtx store_bit_field ();
583: extern rtx extract_bit_field ();
584: extern rtx expand_shift ();
585: extern rtx expand_mult ();
586: extern rtx expand_divmod ();
587: extern rtx expand_mult_add ();
588: extern rtx expand_stmt_expr ();
589: extern rtx emit_no_conflict_block ();
590: extern void emit_libcall_block ();
591:
592: extern void jumpifnot ();
593: extern void jumpif ();
594: extern void do_jump ();
595:
596: extern rtx assemble_static_space ();
597:
598: extern void locate_and_pad_parm ();
599:
600: extern rtx expand_inline_function ();
601:
602: /* Hook called by expand_expr for language-specific tree codes.
603: It is up to the language front end to install a hook
604: if it has any such codes that expand_expr needs to know about. */
605: extern rtx (*lang_expand_expr) ();
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.