464 lines
15 KiB
C
464 lines
15 KiB
C
|
/* Definitions for code generation pass of GNU compiler.
|
|||
|
Copyright (C) 1987 Free Software Foundation, Inc.
|
|||
|
|
|||
|
This file is part of GNU CC.
|
|||
|
|
|||
|
GNU CC is free software; you can redistribute it and/or modify
|
|||
|
it under the terms of the GNU General Public License as published by
|
|||
|
the Free Software Foundation; either version 1, or (at your option)
|
|||
|
any later version.
|
|||
|
|
|||
|
GNU CC is distributed in the hope that it will be useful,
|
|||
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|||
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|||
|
GNU General Public License for more details.
|
|||
|
|
|||
|
You should have received a copy of the GNU General Public License
|
|||
|
along with GNU CC; see the file COPYING. If not, write to
|
|||
|
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
|
|
|||
|
|
|||
|
#ifndef __STDC__
|
|||
|
#ifndef const
|
|||
|
#define const
|
|||
|
#endif
|
|||
|
#endif
|
|||
|
|
|||
|
/* Macros to access the slots of a QUEUED rtx.
|
|||
|
Here rather than in rtl.h because only the expansion pass
|
|||
|
should ever encounter a QUEUED. */
|
|||
|
|
|||
|
/* The variable for which an increment is queued. */
|
|||
|
#define QUEUED_VAR(P) XEXP (P, 0)
|
|||
|
/* If the increment has been emitted, this is the insn
|
|||
|
that does the increment. It is zero before the increment is emitted. */
|
|||
|
#define QUEUED_INSN(P) XEXP (P, 1)
|
|||
|
/* If a pre-increment copy has been generated, this is the copy
|
|||
|
(it is a temporary reg). Zero if no copy made yet. */
|
|||
|
#define QUEUED_COPY(P) XEXP (P, 2)
|
|||
|
/* This is the body to use for the insn to do the increment.
|
|||
|
It is used to emit the increment. */
|
|||
|
#define QUEUED_BODY(P) XEXP (P, 3)
|
|||
|
/* Next QUEUED in the queue. */
|
|||
|
#define QUEUED_NEXT(P) XEXP (P, 4)
|
|||
|
|
|||
|
/* This is the 4th arg to `expand_expr'.
|
|||
|
EXPAND_SUM means it is ok to return a PLUS rtx or MULT rtx.
|
|||
|
EXPAND_CONST_ADDRESS means it is ok to return a MEM whose address
|
|||
|
is a constant that is not a legitimate address.
|
|||
|
EXPAND_INTO_STACK means that if a temporary value needs to be
|
|||
|
created, it should be done so that it lasts the life of
|
|||
|
the call. This can be implemented either by returning
|
|||
|
a pointer to a slot which is actually allocated on the stack,
|
|||
|
or by returning a temporary in the callers frame. */
|
|||
|
enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, EXPAND_CONST_ADDRESS,
|
|||
|
EXPAND_INTO_STACK};
|
|||
|
|
|||
|
/* If this is nonzero, we do not bother generating VOLATILE
|
|||
|
around volatile memory references, and we are willing to
|
|||
|
output indirect addresses. If cse is to follow, we reject
|
|||
|
indirect addresses so a useful potential cse is generated;
|
|||
|
if it is used only once, instruction combination will produce
|
|||
|
the same indirect address eventually. */
|
|||
|
extern int cse_not_expected;
|
|||
|
|
|||
|
/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
|
|||
|
So we can mark them all live at the end of the function, if stupid. */
|
|||
|
extern rtx save_expr_regs;
|
|||
|
|
|||
|
extern int current_function_calls_alloca;
|
|||
|
|
|||
|
/* Nonzero means stack pops must not be deferred, and deferred stack
|
|||
|
pops must not be output. It is nonzero inside a function call,
|
|||
|
inside a conditional expression, inside a statement expression,
|
|||
|
and in other cases as well. */
|
|||
|
extern int inhibit_defer_pop;
|
|||
|
|
|||
|
/* Number of function calls seen so far in current function. */
|
|||
|
|
|||
|
extern int function_call_count;
|
|||
|
|
|||
|
/* RTX for stack slot that holds the current handler for nonlocal gotos.
|
|||
|
Zero when function does not have nonlocal labels. */
|
|||
|
|
|||
|
extern rtx nonlocal_goto_handler_slot;
|
|||
|
|
|||
|
/* RTX for stack slot that holds the stack pointer value to restore
|
|||
|
for a nonlocal goto.
|
|||
|
Zero when function does not have nonlocal labels. */
|
|||
|
|
|||
|
extern rtx nonlocal_goto_stack_level;
|
|||
|
|
|||
|
/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
|
|||
|
(labels to which there can be nonlocal gotos from nested functions)
|
|||
|
in this function. */
|
|||
|
|
|||
|
#ifdef TREE_CODE /* Don't lose if tree.h not included. */
|
|||
|
extern tree nonlocal_labels;
|
|||
|
#endif
|
|||
|
|
|||
|
#define NO_DEFER_POP (inhibit_defer_pop += 1)
|
|||
|
#define OK_DEFER_POP (inhibit_defer_pop -= 1)
|
|||
|
|
|||
|
/* Number of units that we should eventually pop off the stack.
|
|||
|
These are the arguments to function calls that have already returned. */
|
|||
|
extern int pending_stack_adjust;
|
|||
|
|
|||
|
/* A list of all cleanups which belong to the arguments of
|
|||
|
function calls being expanded by expand_call. */
|
|||
|
#ifdef TREE_CODE /* Don't lose if tree.h not included. */
|
|||
|
extern tree cleanups_this_call;
|
|||
|
#endif
|
|||
|
|
|||
|
/* Sequence of insns which must be emitted *prior* to calling
|
|||
|
__builtin_saveregs. */
|
|||
|
rtx save_from_saveregs;
|
|||
|
|
|||
|
#ifdef TREE_CODE /* Don't lose if tree.h not included. */
|
|||
|
/* Structure to record the size of a sequence of arguments
|
|||
|
as the sum of a tree-expression and a constant. */
|
|||
|
|
|||
|
struct args_size
|
|||
|
{
|
|||
|
int constant;
|
|||
|
tree var;
|
|||
|
};
|
|||
|
#endif
|
|||
|
|
|||
|
/* Add the value of the tree INC to the `struct args_size' TO. */
|
|||
|
|
|||
|
#define ADD_PARM_SIZE(TO, INC) \
|
|||
|
{ tree inc = (INC); \
|
|||
|
if (TREE_CODE (inc) == INTEGER_CST) \
|
|||
|
(TO).constant += TREE_INT_CST_LOW (inc); \
|
|||
|
else if ((TO).var == 0) \
|
|||
|
(TO).var = inc; \
|
|||
|
else \
|
|||
|
(TO).var = genop (PLUS_EXPR, (TO).var, inc); }
|
|||
|
|
|||
|
#define SUB_PARM_SIZE(TO, DEC) \
|
|||
|
{ tree dec = (DEC); \
|
|||
|
if (TREE_CODE (dec) == INTEGER_CST) \
|
|||
|
(TO).constant -= TREE_INT_CST_LOW (dec); \
|
|||
|
else if ((TO).var == 0) \
|
|||
|
(TO).var = genop (MINUS_EXPR, integer_zero_node, dec); \
|
|||
|
else \
|
|||
|
(TO).var = genop (MINUS_EXPR, (TO).var, dec); }
|
|||
|
|
|||
|
/* Convert the implicit sum in a `struct args_size' into an rtx. */
|
|||
|
#define ARGS_SIZE_RTX(SIZE) \
|
|||
|
((SIZE).var == 0 ? gen_rtx (CONST_INT, VOIDmode, (SIZE).constant) \
|
|||
|
: plus_constant (expand_expr ((SIZE).var, 0, VOIDmode, 0), \
|
|||
|
(SIZE).constant))
|
|||
|
|
|||
|
/* Supply a default definition for FUNCTION_ARG_PADDING:
|
|||
|
usually pad upward, but pad short args downward on big-endian machines. */
|
|||
|
|
|||
|
enum direction {none, upward, downward}; /* Value has this type. */
|
|||
|
|
|||
|
#ifndef FUNCTION_ARG_PADDING
|
|||
|
#ifdef BYTES_BIG_ENDIAN
|
|||
|
#define FUNCTION_ARG_PADDING(mode, size) \
|
|||
|
(((mode) == BLKmode \
|
|||
|
? (GET_CODE (size) == CONST_INT \
|
|||
|
&& INTVAL (size) < PARM_BOUNDARY / BITS_PER_UNIT) \
|
|||
|
: GET_MODE_BITSIZE (mode) < PARM_BOUNDARY) \
|
|||
|
? downward : upward)
|
|||
|
#else
|
|||
|
#define FUNCTION_ARG_PADDING(mode, size) upward
|
|||
|
#endif
|
|||
|
#endif
|
|||
|
|
|||
|
/* Nonzero if type TYPE should be returned in memory
|
|||
|
(even though its mode is not BLKmode).
|
|||
|
Most machines can use the following default definition. */
|
|||
|
|
|||
|
#ifndef RETURN_IN_MEMORY
|
|||
|
#define RETURN_IN_MEMORY(type) 0
|
|||
|
#endif
|
|||
|
|
|||
|
/* Optabs are tables saying how to generate insn bodies
|
|||
|
for various machine modes and numbers of operands.
|
|||
|
Each optab applies to one operation.
|
|||
|
For example, add_optab applies to addition.
|
|||
|
|
|||
|
The insn_code slot is the enum insn_code that says how to
|
|||
|
generate an insn for this operation on a particular machine mode.
|
|||
|
It is CODE_FOR_nothing if there is no such insn on the target machine.
|
|||
|
|
|||
|
The `lib_call' slot is the name of the library function that
|
|||
|
can be used to perform the operation.
|
|||
|
|
|||
|
A few optabs, such as move_optab and cmp_optab, are used
|
|||
|
by special code. */
|
|||
|
|
|||
|
/* Everything that uses expr.h needs to define enum insn_code
|
|||
|
but we don't list it in the Makefile dependencies just for that. */
|
|||
|
#include "insn-codes.h"
|
|||
|
|
|||
|
typedef struct optab
|
|||
|
{
|
|||
|
enum rtx_code code;
|
|||
|
struct {
|
|||
|
enum insn_code insn_code;
|
|||
|
char *lib_call;
|
|||
|
} handlers [NUM_MACHINE_MODES];
|
|||
|
} * optab;
|
|||
|
|
|||
|
/* Given an enum insn_code, access the function to construct
|
|||
|
the body of that kind of insn. */
|
|||
|
#define GEN_FCN(CODE) (*insn_gen_function[(int) (CODE)])
|
|||
|
extern rtx (*const insn_gen_function[]) ();
|
|||
|
|
|||
|
extern optab add_optab;
|
|||
|
extern optab sub_optab;
|
|||
|
extern optab smul_optab; /* Signed multiply */
|
|||
|
extern optab smul_widen_optab; /* Signed multiply with result
|
|||
|
one machine mode wider than args */
|
|||
|
extern optab umul_widen_optab;
|
|||
|
extern optab sdiv_optab; /* Signed divide */
|
|||
|
extern optab sdivmod_optab; /* Signed divide-and-remainder in one */
|
|||
|
extern optab udiv_optab;
|
|||
|
extern optab udivmod_optab;
|
|||
|
extern optab smod_optab; /* Signed remainder */
|
|||
|
extern optab umod_optab;
|
|||
|
extern optab flodiv_optab; /* Optab for floating divide. */
|
|||
|
extern optab ftrunc_optab; /* Convert float to integer in float fmt */
|
|||
|
extern optab and_optab; /* Logical and */
|
|||
|
extern optab ior_optab; /* Logical or */
|
|||
|
extern optab xor_optab; /* Logical xor */
|
|||
|
extern optab ashl_optab; /* Arithmetic shift left */
|
|||
|
extern optab ashr_optab; /* Arithmetic shift right */
|
|||
|
extern optab lshl_optab; /* Logical shift left */
|
|||
|
extern optab lshr_optab; /* Logical shift right */
|
|||
|
extern optab rotl_optab; /* Rotate left */
|
|||
|
extern optab rotr_optab; /* Rotate right */
|
|||
|
|
|||
|
extern optab mov_optab; /* Move instruction. */
|
|||
|
extern optab movstrict_optab; /* Move, preserving high part of register. */
|
|||
|
|
|||
|
extern optab cmp_optab; /* Compare insn; two operands. */
|
|||
|
extern optab tst_optab; /* tst insn; compare one operand against 0 */
|
|||
|
|
|||
|
/* Unary operations */
|
|||
|
extern optab neg_optab; /* Negation */
|
|||
|
extern optab abs_optab; /* Abs value */
|
|||
|
extern optab one_cmpl_optab; /* Bitwise not */
|
|||
|
extern optab ffs_optab; /* Find first bit set */
|
|||
|
|
|||
|
/* Passed to expand_binop and expand_unop to say which options to try to use
|
|||
|
if the requested operation can't be open-coded on the requisite mode.
|
|||
|
Either OPTAB_LIB or OPTAB_LIB_WIDEN says try using a library call.
|
|||
|
Either OPTAB_WIDEN or OPTAB_LIB_WIDEN says try using a wider mode.
|
|||
|
OPTAB_MUST_WIDEN says try widening and don't try anything else. */
|
|||
|
|
|||
|
enum optab_methods
|
|||
|
{
|
|||
|
OPTAB_DIRECT,
|
|||
|
OPTAB_LIB,
|
|||
|
OPTAB_WIDEN,
|
|||
|
OPTAB_LIB_WIDEN,
|
|||
|
OPTAB_MUST_WIDEN,
|
|||
|
};
|
|||
|
|
|||
|
typedef rtx (*rtxfun) ();
|
|||
|
|
|||
|
/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
|
|||
|
gives the gen_function to make a branch to test that condition. */
|
|||
|
|
|||
|
extern rtxfun bcc_gen_fctn[NUM_RTX_CODE];
|
|||
|
|
|||
|
/* Indexed by the rtx-code for a conditional (eg. EQ, LT,...)
|
|||
|
gives the gen_function to make a store-condition insn
|
|||
|
to test that condition. */
|
|||
|
|
|||
|
extern rtxfun setcc_gen_fctn[NUM_RTX_CODE];
|
|||
|
|
|||
|
/* Expand a binary operation given optab and rtx operands. */
|
|||
|
rtx expand_binop ();
|
|||
|
|
|||
|
/* Expand a binary operation with both signed and unsigned forms. */
|
|||
|
rtx sign_expand_binop ();
|
|||
|
|
|||
|
/* Expand a unary arithmetic operation given optab rtx operand. */
|
|||
|
rtx expand_unop ();
|
|||
|
|
|||
|
/* Arguments MODE, RTX: return an rtx for the negation of that value.
|
|||
|
May emit insns. */
|
|||
|
rtx negate_rtx ();
|
|||
|
|
|||
|
/* Initialize the tables that control conversion between fixed and
|
|||
|
floating values. */
|
|||
|
void init_fixtab ();
|
|||
|
void init_floattab ();
|
|||
|
|
|||
|
/* Generate code for a FIX_EXPR. */
|
|||
|
void expand_fix ();
|
|||
|
|
|||
|
/* Generate code for a FLOAT_EXPR. */
|
|||
|
void expand_float ();
|
|||
|
|
|||
|
/* Create but don't emit one rtl instruction to add one rtx into another.
|
|||
|
Modes must match.
|
|||
|
Likewise for subtraction and for just copying.
|
|||
|
These do not call protect_from_queue; caller must do so. */
|
|||
|
rtx gen_add2_insn ();
|
|||
|
rtx gen_sub2_insn ();
|
|||
|
rtx gen_move_insn ();
|
|||
|
|
|||
|
/* Emit one rtl instruction to store zero in specified rtx. */
|
|||
|
void emit_clr_insn ();
|
|||
|
|
|||
|
/* Emit one rtl insn to store 1 in specified rtx assuming it contains 0. */
|
|||
|
void emit_0_to_1_insn ();
|
|||
|
|
|||
|
/* Emit one rtl insn to compare two rtx's. */
|
|||
|
void emit_cmp_insn ();
|
|||
|
|
|||
|
/* Emit some rtl insns to move data between rtx's, converting machine modes.
|
|||
|
Both modes must be floating or both fixed. */
|
|||
|
void convert_move ();
|
|||
|
|
|||
|
/* Convert an rtx to specified machine mode and return the result. */
|
|||
|
rtx convert_to_mode ();
|
|||
|
|
|||
|
/* Emit code to push some arguments and call a library routine,
|
|||
|
storing the value in a specified place. Calling sequence is
|
|||
|
complicated. */
|
|||
|
void emit_library_call ();
|
|||
|
|
|||
|
/* Given an rtx that may include add and multiply operations,
|
|||
|
generate them as insns and return a pseudo-reg containing the value.
|
|||
|
Useful after calling expand_expr with 1 as sum_ok. */
|
|||
|
rtx force_operand ();
|
|||
|
|
|||
|
/* Return an rtx for the size in bytes of the value of an expr. */
|
|||
|
rtx expr_size ();
|
|||
|
|
|||
|
/* Return an rtx for the sum of an rtx and an integer. */
|
|||
|
rtx plus_constant ();
|
|||
|
|
|||
|
rtx lookup_static_chain ();
|
|||
|
|
|||
|
/* Return an rtx like arg but sans any constant terms.
|
|||
|
Returns the original rtx if it has no constant terms.
|
|||
|
The constant terms are added and stored via a second arg. */
|
|||
|
rtx eliminate_constant_term ();
|
|||
|
|
|||
|
/* Convert arg to a valid memory address for specified machine mode,
|
|||
|
by emitting insns to perform arithmetic if nec. */
|
|||
|
rtx memory_address ();
|
|||
|
|
|||
|
/* Like `memory_address' but pretent `flag_force_addr' is 0. */
|
|||
|
rtx memory_address_noforce ();
|
|||
|
|
|||
|
/* Return a memory reference like MEMREF, but with its mode changed
|
|||
|
to MODE and its address changed to ADDR.
|
|||
|
(VOIDmode means don't change the mode.
|
|||
|
NULL for ADDR means don't change the address.) */
|
|||
|
rtx change_address ();
|
|||
|
|
|||
|
#if 0
|
|||
|
/* Convert a stack slot address ADDR valid in function FNDECL
|
|||
|
into an address valid in this function (using a static chain). */
|
|||
|
rtx fix_lexical_addr ();
|
|||
|
|
|||
|
/* Return the address of the trampoline for entering nested fn FUNCTION. */
|
|||
|
rtx trampoline_address ();
|
|||
|
|
|||
|
/* Assemble the static constant template for function entry trampolines. */
|
|||
|
rtx assemble_trampoline_template ();
|
|||
|
#endif
|
|||
|
|
|||
|
/* Return 1 if two rtx's are equivalent in structure and elements. */
|
|||
|
int rtx_equal_p ();
|
|||
|
|
|||
|
/* Given rtx, return new rtx whose address won't be affected by
|
|||
|
any side effects. It has been copied to a new temporary reg. */
|
|||
|
rtx stabilize ();
|
|||
|
|
|||
|
/* Given an rtx, copy all regs it refers to into new temps
|
|||
|
and return a modified copy that refers to the new temps. */
|
|||
|
rtx copy_all_regs ();
|
|||
|
|
|||
|
/* Copy given rtx to a new temp reg and return that. */
|
|||
|
rtx copy_to_reg ();
|
|||
|
|
|||
|
/* Like copy_to_reg but always make the reg Pmode. */
|
|||
|
rtx copy_addr_to_reg ();
|
|||
|
|
|||
|
/* Like copy_to_reg but always make the reg the specified mode MODE. */
|
|||
|
rtx copy_to_mode_reg ();
|
|||
|
|
|||
|
/* Copy given rtx to given temp reg and return that. */
|
|||
|
rtx copy_to_suggested_reg ();
|
|||
|
|
|||
|
/* Copy a value to a register if it isn't already a register.
|
|||
|
Args are mode (in case value is a constant) and the value. */
|
|||
|
rtx force_reg ();
|
|||
|
|
|||
|
/* Return given rtx, copied into a new temp reg if it was in memory. */
|
|||
|
rtx force_not_mem ();
|
|||
|
|
|||
|
/* Remove some bytes from the stack. An rtx says how many. */
|
|||
|
void adjust_stack ();
|
|||
|
|
|||
|
/* Add some bytes to the stack. An rtx says how many. */
|
|||
|
void anti_adjust_stack ();
|
|||
|
|
|||
|
/* Emit code to copy function value to a new temp reg and return that reg. */
|
|||
|
rtx function_value ();
|
|||
|
|
|||
|
/* Return an rtx that refers to the value returned by a function
|
|||
|
in its original home. This becomes invalid if any more code is emitted. */
|
|||
|
rtx hard_function_value ();
|
|||
|
|
|||
|
/* Return an rtx that refers to the value returned by a library call
|
|||
|
in its original home. This becomes invalid if any more code is emitted. */
|
|||
|
rtx hard_libcall_value ();
|
|||
|
|
|||
|
/* Emit code to copy function value to a specified place. */
|
|||
|
void copy_function_value ();
|
|||
|
|
|||
|
/* Given an rtx, return an rtx for a value rounded up to a multiple
|
|||
|
of STACK_BOUNDARY / BITS_PER_UNIT. */
|
|||
|
rtx round_push ();
|
|||
|
|
|||
|
/* Push a block of length SIZE (perhaps variable)
|
|||
|
and return an rtx to address the beginning of the block. */
|
|||
|
rtx push_block ();
|
|||
|
|
|||
|
/* Generate code for computing expression EXP,
|
|||
|
and storing the value into TARGET.
|
|||
|
If SUGGEST_REG is nonzero, copy the value through a register
|
|||
|
and return that register, if that is possible. */
|
|||
|
rtx store_expr ();
|
|||
|
|
|||
|
rtx prepare_call_address ();
|
|||
|
rtx expand_call ();
|
|||
|
void emit_call_1 ();
|
|||
|
|
|||
|
void emit_block_move ();
|
|||
|
void emit_push_insn ();
|
|||
|
void use_regs ();
|
|||
|
void move_block_to_reg ();
|
|||
|
|
|||
|
rtx store_bit_field ();
|
|||
|
rtx extract_bit_field ();
|
|||
|
rtx expand_shift ();
|
|||
|
rtx expand_mult ();
|
|||
|
rtx expand_divmod ();
|
|||
|
rtx expand_mult_add ();
|
|||
|
rtx get_structure_value_addr ();
|
|||
|
rtx expand_stmt_expr ();
|
|||
|
rtx emit_no_conflict_block ();
|
|||
|
|
|||
|
void jumpifnot ();
|
|||
|
void jumpif ();
|
|||
|
void do_jump ();
|
|||
|
|
|||
|
rtx assemble_static_space ();
|
|||
|
|
|||
|
/* Needed for old compiler. */
|
|||
|
rtx expand_bit_and ();
|