diff options
Diffstat (limited to 'contrib/gcc/emit-rtl.c')
| -rw-r--r-- | contrib/gcc/emit-rtl.c | 3830 |
1 files changed, 0 insertions, 3830 deletions
diff --git a/contrib/gcc/emit-rtl.c b/contrib/gcc/emit-rtl.c deleted file mode 100644 index 36b030ae7b6b..000000000000 --- a/contrib/gcc/emit-rtl.c +++ /dev/null @@ -1,3830 +0,0 @@ -/* Emit RTL for the GNU C-Compiler expander. - Copyright (C) 1987, 88, 92-97, 1998, 1999 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 2, 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, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ - - -/* Middle-to-low level generation of rtx code and insns. - - This file contains the functions `gen_rtx', `gen_reg_rtx' - and `gen_label_rtx' that are the usual ways of creating rtl - expressions for most purposes. - - It also has the functions for creating insns and linking - them in the doubly-linked chain. - - The patterns of the insns are created by machine-dependent - routines in insn-emit.c, which is generated automatically from - the machine description. These routines use `gen_rtx' to make - the individual rtx's of the pattern; what is machine dependent - is the kind of rtx's they make and what arguments they use. */ - -#include "config.h" -#include "system.h" -#include "toplev.h" -#include "rtl.h" -#include "tree.h" -#include "flags.h" -#include "except.h" -#include "function.h" -#include "expr.h" -#include "regs.h" -#include "hard-reg-set.h" -#include "insn-config.h" -#include "recog.h" -#include "real.h" -#include "obstack.h" -#include "bitmap.h" - -/* Commonly used modes. */ - -enum machine_mode byte_mode; /* Mode whose width is BITS_PER_UNIT. */ -enum machine_mode word_mode; /* Mode whose width is BITS_PER_WORD. */ -enum machine_mode double_mode; /* Mode whose width is DOUBLE_TYPE_SIZE. */ -enum machine_mode ptr_mode; /* Mode whose width is POINTER_SIZE. */ - -/* This is reset to LAST_VIRTUAL_REGISTER + 1 at the start of each function. - After rtl generation, it is 1 plus the largest register number used. */ - -int reg_rtx_no = LAST_VIRTUAL_REGISTER + 1; - -/* This is *not* reset after each function. It gives each CODE_LABEL - in the entire compilation a unique label number. */ - -static int label_num = 1; - -/* Lowest label number in current function. */ - -static int first_label_num; - -/* Highest label number in current function. - Zero means use the value of label_num instead. - This is nonzero only when belatedly compiling an inline function. */ - -static int last_label_num; - -/* Value label_num had when set_new_first_and_last_label_number was called. - If label_num has not changed since then, last_label_num is valid. */ - -static int base_label_num; - -/* Nonzero means do not generate NOTEs for source line numbers. */ - -static int no_line_numbers; - -/* Commonly used rtx's, so that we only need space for one copy. - These are initialized once for the entire compilation. - All of these except perhaps the floating-point CONST_DOUBLEs - are unique; no other rtx-object will be equal to any of these. */ - -/* Avoid warnings by initializing the `fld' field. Since its a union, - bypass problems with KNR compilers by only doing so when __GNUC__. */ -#ifdef __GNUC__ -#define FLDI , {{0}} -#else -#define FLDI -#endif - -struct _global_rtl global_rtl = -{ - {PC, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* pc_rtx */ - {CC0, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* cc0_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* stack_pointer_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* frame_pointer_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* hard_frame_pointer_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* arg_pointer_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_incoming_args_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_stack_vars_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_stack_dynamic_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_outgoing_args_rtx */ - {REG, VOIDmode, 0, 0, 0, 0, 0, 0, 0, 0 FLDI }, /* virtual_cfa_rtx */ -}; - -/* We record floating-point CONST_DOUBLEs in each floating-point mode for - the values of 0, 1, and 2. For the integer entries and VOIDmode, we - record a copy of const[012]_rtx. */ - -rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE]; - -rtx const_true_rtx; - -REAL_VALUE_TYPE dconst0; -REAL_VALUE_TYPE dconst1; -REAL_VALUE_TYPE dconst2; -REAL_VALUE_TYPE dconstm1; - -/* All references to the following fixed hard registers go through - these unique rtl objects. On machines where the frame-pointer and - arg-pointer are the same register, they use the same unique object. - - After register allocation, other rtl objects which used to be pseudo-regs - may be clobbered to refer to the frame-pointer register. - But references that were originally to the frame-pointer can be - distinguished from the others because they contain frame_pointer_rtx. - - When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little - tricky: until register elimination has taken place hard_frame_pointer_rtx - should be used if it is being set, and frame_pointer_rtx otherwise. After - register elimination hard_frame_pointer_rtx should always be used. - On machines where the two registers are same (most) then these are the - same. - - In an inline procedure, the stack and frame pointer rtxs may not be - used for anything else. */ -rtx struct_value_rtx; /* (REG:Pmode STRUCT_VALUE_REGNUM) */ -rtx struct_value_incoming_rtx; /* (REG:Pmode STRUCT_VALUE_INCOMING_REGNUM) */ -rtx static_chain_rtx; /* (REG:Pmode STATIC_CHAIN_REGNUM) */ -rtx static_chain_incoming_rtx; /* (REG:Pmode STATIC_CHAIN_INCOMING_REGNUM) */ -rtx pic_offset_table_rtx; /* (REG:Pmode PIC_OFFSET_TABLE_REGNUM) */ - -/* This is used to implement __builtin_return_address for some machines. - See for instance the MIPS port. */ -rtx return_address_pointer_rtx; /* (REG:Pmode RETURN_ADDRESS_POINTER_REGNUM) */ - -/* We make one copy of (const_int C) where C is in - [- MAX_SAVED_CONST_INT, MAX_SAVED_CONST_INT] - to save space during the compilation and simplify comparisons of - integers. */ - -struct rtx_def const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1]; - -/* The ends of the doubly-linked chain of rtl for the current function. - Both are reset to null at the start of rtl generation for the function. - - start_sequence saves both of these on `sequence_stack' along with - `sequence_rtl_expr' and then starts a new, nested sequence of insns. */ - -static rtx first_insn = NULL; -static rtx last_insn = NULL; - -/* RTL_EXPR within which the current sequence will be placed. Use to - prevent reuse of any temporaries within the sequence until after the - RTL_EXPR is emitted. */ - -tree sequence_rtl_expr = NULL; - -/* INSN_UID for next insn emitted. - Reset to 1 for each function compiled. */ - -static int cur_insn_uid = 1; - -/* Line number and source file of the last line-number NOTE emitted. - This is used to avoid generating duplicates. */ - -static int last_linenum = 0; -static char *last_filename = 0; - -/* A vector indexed by pseudo reg number. The allocated length - of this vector is regno_pointer_flag_length. Since this - vector is needed during the expansion phase when the total - number of registers in the function is not yet known, - it is copied and made bigger when necessary. */ - -char *regno_pointer_flag; -int regno_pointer_flag_length; - -/* Indexed by pseudo register number, if nonzero gives the known alignment - for that pseudo (if regno_pointer_flag is set). - Allocated in parallel with regno_pointer_flag. */ -char *regno_pointer_align; - -/* Indexed by pseudo register number, gives the rtx for that pseudo. - Allocated in parallel with regno_pointer_flag. */ - -rtx *regno_reg_rtx; - -/* Stack of pending (incomplete) sequences saved by `start_sequence'. - Each element describes one pending sequence. - The main insn-chain is saved in the last element of the chain, - unless the chain is empty. */ - -struct sequence_stack *sequence_stack; - -/* start_sequence and gen_sequence can make a lot of rtx expressions which are - shortly thrown away. We use two mechanisms to prevent this waste: - - First, we keep a list of the expressions used to represent the sequence - stack in sequence_element_free_list. - - Second, for sizes up to 5 elements, we keep a SEQUENCE and its associated - rtvec for use by gen_sequence. One entry for each size is sufficient - because most cases are calls to gen_sequence followed by immediately - emitting the SEQUENCE. Reuse is safe since emitting a sequence is - destructive on the insn in it anyway and hence can't be redone. - - We do not bother to save this cached data over nested function calls. - Instead, we just reinitialize them. */ - -#define SEQUENCE_RESULT_SIZE 5 - -static struct sequence_stack *sequence_element_free_list; -static rtx sequence_result[SEQUENCE_RESULT_SIZE]; - -/* During RTL generation, we also keep a list of free INSN rtl codes. */ -static rtx free_insn; - -extern int rtx_equal_function_value_matters; - -/* Filename and line number of last line-number note, - whether we actually emitted it or not. */ -extern char *emit_filename; -extern int emit_lineno; - -static rtx make_jump_insn_raw PROTO((rtx)); -static rtx make_call_insn_raw PROTO((rtx)); -static rtx find_line_note PROTO((rtx)); - -rtx -gen_rtx_CONST_INT (mode, arg) - enum machine_mode mode; - HOST_WIDE_INT arg; -{ - if (arg >= - MAX_SAVED_CONST_INT && arg <= MAX_SAVED_CONST_INT) - return &const_int_rtx[arg + MAX_SAVED_CONST_INT]; - -#if STORE_FLAG_VALUE != 1 && STORE_FLAG_VALUE != -1 - if (const_true_rtx && arg == STORE_FLAG_VALUE) - return const_true_rtx; -#endif - - return gen_rtx_raw_CONST_INT (mode, arg); -} - -/* CONST_DOUBLEs needs special handling because its length is known - only at run-time. */ -rtx -gen_rtx_CONST_DOUBLE (mode, arg0, arg1, arg2) - enum machine_mode mode; - rtx arg0; - HOST_WIDE_INT arg1, arg2; -{ - rtx r = rtx_alloc (CONST_DOUBLE); - int i; - - PUT_MODE (r, mode); - XEXP (r, 0) = arg0; - XEXP (r, 1) = NULL_RTX; - XWINT (r, 2) = arg1; - XWINT (r, 3) = arg2; - - for (i = GET_RTX_LENGTH (CONST_DOUBLE) - 1; i > 3; --i) - XWINT (r, i) = 0; - - return r; -} - -rtx -gen_rtx_REG (mode, regno) - enum machine_mode mode; - int regno; -{ - /* In case the MD file explicitly references the frame pointer, have - all such references point to the same frame pointer. This is - used during frame pointer elimination to distinguish the explicit - references to these registers from pseudos that happened to be - assigned to them. - - If we have eliminated the frame pointer or arg pointer, we will - be using it as a normal register, for example as a spill - register. In such cases, we might be accessing it in a mode that - is not Pmode and therefore cannot use the pre-allocated rtx. - - Also don't do this when we are making new REGs in reload, since - we don't want to get confused with the real pointers. */ - - if (mode == Pmode && !reload_in_progress) - { - if (regno == FRAME_POINTER_REGNUM) - return frame_pointer_rtx; -#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM - if (regno == HARD_FRAME_POINTER_REGNUM) - return hard_frame_pointer_rtx; -#endif -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - if (regno == ARG_POINTER_REGNUM) - return arg_pointer_rtx; -#endif -#ifdef RETURN_ADDRESS_POINTER_REGNUM - if (regno == RETURN_ADDRESS_POINTER_REGNUM) - return return_address_pointer_rtx; -#endif - if (regno == STACK_POINTER_REGNUM) - return stack_pointer_rtx; - } - - return gen_rtx_raw_REG (mode, regno); -} - -rtx -gen_rtx_MEM (mode, addr) - enum machine_mode mode; - rtx addr; -{ - rtx rt = gen_rtx_raw_MEM (mode, addr); - - /* This field is not cleared by the mere allocation of the rtx, so - we clear it here. */ - MEM_ALIAS_SET (rt) = 0; - - return rt; -} - -/* rtx gen_rtx (code, mode, [element1, ..., elementn]) -** -** This routine generates an RTX of the size specified by -** <code>, which is an RTX code. The RTX structure is initialized -** from the arguments <element1> through <elementn>, which are -** interpreted according to the specific RTX type's format. The -** special machine mode associated with the rtx (if any) is specified -** in <mode>. -** -** gen_rtx can be invoked in a way which resembles the lisp-like -** rtx it will generate. For example, the following rtx structure: -** -** (plus:QI (mem:QI (reg:SI 1)) -** (mem:QI (plusw:SI (reg:SI 2) (reg:SI 3)))) -** -** ...would be generated by the following C code: -** -** gen_rtx (PLUS, QImode, -** gen_rtx (MEM, QImode, -** gen_rtx (REG, SImode, 1)), -** gen_rtx (MEM, QImode, -** gen_rtx (PLUS, SImode, -** gen_rtx (REG, SImode, 2), -** gen_rtx (REG, SImode, 3)))), -*/ - -/*VARARGS2*/ -rtx -gen_rtx VPROTO((enum rtx_code code, enum machine_mode mode, ...)) -{ -#ifndef ANSI_PROTOTYPES - enum rtx_code code; - enum machine_mode mode; -#endif - va_list p; - register int i; /* Array indices... */ - register char *fmt; /* Current rtx's format... */ - register rtx rt_val; /* RTX to return to caller... */ - - VA_START (p, mode); - -#ifndef ANSI_PROTOTYPES - code = va_arg (p, enum rtx_code); - mode = va_arg (p, enum machine_mode); -#endif - - switch (code) - { - case CONST_INT: - rt_val = gen_rtx_CONST_INT (mode, va_arg (p, HOST_WIDE_INT)); - break; - - case CONST_DOUBLE: - { - rtx arg0 = va_arg (p, rtx); - HOST_WIDE_INT arg1 = va_arg (p, HOST_WIDE_INT); - HOST_WIDE_INT arg2 = va_arg (p, HOST_WIDE_INT); - rt_val = gen_rtx_CONST_DOUBLE (mode, arg0, arg1, arg2); - } - break; - - case REG: - rt_val = gen_rtx_REG (mode, va_arg (p, int)); - break; - - case MEM: - rt_val = gen_rtx_MEM (mode, va_arg (p, rtx)); - break; - - default: - rt_val = rtx_alloc (code); /* Allocate the storage space. */ - rt_val->mode = mode; /* Store the machine mode... */ - - fmt = GET_RTX_FORMAT (code); /* Find the right format... */ - for (i = 0; i < GET_RTX_LENGTH (code); i++) - { - switch (*fmt++) - { - case '0': /* Unused field. */ - break; - - case 'i': /* An integer? */ - XINT (rt_val, i) = va_arg (p, int); - break; - - case 'w': /* A wide integer? */ - XWINT (rt_val, i) = va_arg (p, HOST_WIDE_INT); - break; - - case 's': /* A string? */ - XSTR (rt_val, i) = va_arg (p, char *); - break; - - case 'e': /* An expression? */ - case 'u': /* An insn? Same except when printing. */ - XEXP (rt_val, i) = va_arg (p, rtx); - break; - - case 'E': /* An RTX vector? */ - XVEC (rt_val, i) = va_arg (p, rtvec); - break; - - case 'b': /* A bitmap? */ - XBITMAP (rt_val, i) = va_arg (p, bitmap); - break; - - case 't': /* A tree? */ - XTREE (rt_val, i) = va_arg (p, tree); - break; - - default: - abort (); - } - } - break; - } - - va_end (p); - return rt_val; -} - -/* gen_rtvec (n, [rt1, ..., rtn]) -** -** This routine creates an rtvec and stores within it the -** pointers to rtx's which are its arguments. -*/ - -/*VARARGS1*/ -rtvec -gen_rtvec VPROTO((int n, ...)) -{ -#ifndef ANSI_PROTOTYPES - int n; -#endif - int i; - va_list p; - rtx *vector; - - VA_START (p, n); - -#ifndef ANSI_PROTOTYPES - n = va_arg (p, int); -#endif - - if (n == 0) - return NULL_RTVEC; /* Don't allocate an empty rtvec... */ - - vector = (rtx *) alloca (n * sizeof (rtx)); - - for (i = 0; i < n; i++) - vector[i] = va_arg (p, rtx); - va_end (p); - - return gen_rtvec_v (n, vector); -} - -rtvec -gen_rtvec_v (n, argp) - int n; - rtx *argp; -{ - register int i; - register rtvec rt_val; - - if (n == 0) - return NULL_RTVEC; /* Don't allocate an empty rtvec... */ - - rt_val = rtvec_alloc (n); /* Allocate an rtvec... */ - - for (i = 0; i < n; i++) - rt_val->elem[i].rtx = *argp++; - - return rt_val; -} - -rtvec -gen_rtvec_vv (n, argp) - int n; - rtunion *argp; -{ - register int i; - register rtvec rt_val; - - if (n == 0) - return NULL_RTVEC; /* Don't allocate an empty rtvec... */ - - rt_val = rtvec_alloc (n); /* Allocate an rtvec... */ - - for (i = 0; i < n; i++) - rt_val->elem[i].rtx = (argp++)->rtx; - - return rt_val; -} - -/* Generate a REG rtx for a new pseudo register of mode MODE. - This pseudo is assigned the next sequential register number. */ - -rtx -gen_reg_rtx (mode) - enum machine_mode mode; -{ - register rtx val; - - /* Don't let anything called after initial flow analysis create new - registers. */ - if (no_new_pseudos) - abort (); - - if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT - || GET_MODE_CLASS (mode) == MODE_COMPLEX_INT) - { - /* For complex modes, don't make a single pseudo. - Instead, make a CONCAT of two pseudos. - This allows noncontiguous allocation of the real and imaginary parts, - which makes much better code. Besides, allocating DCmode - pseudos overstrains reload on some machines like the 386. */ - rtx realpart, imagpart; - int size = GET_MODE_UNIT_SIZE (mode); - enum machine_mode partmode - = mode_for_size (size * BITS_PER_UNIT, - (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT - ? MODE_FLOAT : MODE_INT), - 0); - - realpart = gen_reg_rtx (partmode); - imagpart = gen_reg_rtx (partmode); - return gen_rtx_CONCAT (mode, realpart, imagpart); - } - - /* Make sure regno_pointer_flag and regno_reg_rtx are large - enough to have an element for this pseudo reg number. */ - - if (reg_rtx_no == regno_pointer_flag_length) - { - rtx *new1; - char *new = - (char *) savealloc (regno_pointer_flag_length * 2); - bcopy (regno_pointer_flag, new, regno_pointer_flag_length); - bzero (&new[regno_pointer_flag_length], regno_pointer_flag_length); - regno_pointer_flag = new; - - new = (char *) savealloc (regno_pointer_flag_length * 2); - bcopy (regno_pointer_align, new, regno_pointer_flag_length); - bzero (&new[regno_pointer_flag_length], regno_pointer_flag_length); - regno_pointer_align = new; - - new1 = (rtx *) savealloc (regno_pointer_flag_length * 2 * sizeof (rtx)); - bcopy ((char *) regno_reg_rtx, (char *) new1, - regno_pointer_flag_length * sizeof (rtx)); - bzero ((char *) &new1[regno_pointer_flag_length], - regno_pointer_flag_length * sizeof (rtx)); - regno_reg_rtx = new1; - - regno_pointer_flag_length *= 2; - } - - val = gen_rtx_raw_REG (mode, reg_rtx_no); - regno_reg_rtx[reg_rtx_no++] = val; - return val; -} - -/* Identify REG (which may be a CONCAT) as a user register. */ - -void -mark_user_reg (reg) - rtx reg; -{ - if (GET_CODE (reg) == CONCAT) - { - REG_USERVAR_P (XEXP (reg, 0)) = 1; - REG_USERVAR_P (XEXP (reg, 1)) = 1; - } - else if (GET_CODE (reg) == REG) - REG_USERVAR_P (reg) = 1; - else - abort (); -} - -/* Identify REG as a probable pointer register and show its alignment - as ALIGN, if nonzero. */ - -void -mark_reg_pointer (reg, align) - rtx reg; - int align; -{ - if (! REGNO_POINTER_FLAG (REGNO (reg))) - { - REGNO_POINTER_FLAG (REGNO (reg)) = 1; - - if (align) - REGNO_POINTER_ALIGN (REGNO (reg)) = align; - } - else if (align && align < REGNO_POINTER_ALIGN (REGNO (reg))) - /* We can no-longer be sure just how aligned this pointer is */ - REGNO_POINTER_ALIGN (REGNO (reg)) = align; -} - -/* Return 1 plus largest pseudo reg number used in the current function. */ - -int -max_reg_num () -{ - return reg_rtx_no; -} - -/* Return 1 + the largest label number used so far in the current function. */ - -int -max_label_num () -{ - if (last_label_num && label_num == base_label_num) - return last_label_num; - return label_num; -} - -/* Return first label number used in this function (if any were used). */ - -int -get_first_label_num () -{ - return first_label_num; -} - -/* Return a value representing some low-order bits of X, where the number - of low-order bits is given by MODE. Note that no conversion is done - between floating-point and fixed-point values, rather, the bit - representation is returned. - - This function handles the cases in common between gen_lowpart, below, - and two variants in cse.c and combine.c. These are the cases that can - be safely handled at all points in the compilation. - - If this is not a case we can handle, return 0. */ - -rtx -gen_lowpart_common (mode, x) - enum machine_mode mode; - register rtx x; -{ - int word = 0; - - if (GET_MODE (x) == mode) - return x; - - /* MODE must occupy no more words than the mode of X. */ - if (GET_MODE (x) != VOIDmode - && ((GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD - > ((GET_MODE_SIZE (GET_MODE (x)) + (UNITS_PER_WORD - 1)) - / UNITS_PER_WORD))) - return 0; - - if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD) - word = ((GET_MODE_SIZE (GET_MODE (x)) - - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD)) - / UNITS_PER_WORD); - - if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND) - && (GET_MODE_CLASS (mode) == MODE_INT - || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)) - { - /* If we are getting the low-order part of something that has been - sign- or zero-extended, we can either just use the object being - extended or make a narrower extension. If we want an even smaller - piece than the size of the object being extended, call ourselves - recursively. - - This case is used mostly by combine and cse. */ - - if (GET_MODE (XEXP (x, 0)) == mode) - return XEXP (x, 0); - else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (XEXP (x, 0)))) - return gen_lowpart_common (mode, XEXP (x, 0)); - else if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (x))) - return gen_rtx_fmt_e (GET_CODE (x), mode, XEXP (x, 0)); - } - else if (GET_CODE (x) == SUBREG - && (GET_MODE_SIZE (mode) <= UNITS_PER_WORD - || GET_MODE_SIZE (mode) == GET_MODE_UNIT_SIZE (GET_MODE (x)))) - return (GET_MODE (SUBREG_REG (x)) == mode && SUBREG_WORD (x) == 0 - ? SUBREG_REG (x) - : gen_rtx_SUBREG (mode, SUBREG_REG (x), SUBREG_WORD (x) + word)); - else if (GET_CODE (x) == REG) - { - /* Let the backend decide how many registers to skip. This is needed - in particular for Sparc64 where fp regs are smaller than a word. */ - /* ??? Note that subregs are now ambiguous, in that those against - pseudos are sized by the Word Size, while those against hard - regs are sized by the underlying register size. Better would be - to always interpret the subreg offset parameter as bytes or bits. */ - - if (WORDS_BIG_ENDIAN && REGNO (x) < FIRST_PSEUDO_REGISTER) - word = (HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)) - - HARD_REGNO_NREGS (REGNO (x), mode)); - - /* If the register is not valid for MODE, return 0. If we don't - do this, there is no way to fix up the resulting REG later. - But we do do this if the current REG is not valid for its - mode. This latter is a kludge, but is required due to the - way that parameters are passed on some machines, most - notably Sparc. */ - if (REGNO (x) < FIRST_PSEUDO_REGISTER - && ! HARD_REGNO_MODE_OK (REGNO (x) + word, mode) - && HARD_REGNO_MODE_OK (REGNO (x), GET_MODE (x))) - return 0; - else if (REGNO (x) < FIRST_PSEUDO_REGISTER - /* integrate.c can't handle parts of a return value register. */ - && (! REG_FUNCTION_VALUE_P (x) - || ! rtx_equal_function_value_matters) -#ifdef CLASS_CANNOT_CHANGE_SIZE - && ! (GET_MODE_SIZE (mode) != GET_MODE_SIZE (GET_MODE (x)) - && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_INT - && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_FLOAT - && (TEST_HARD_REG_BIT - (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], - REGNO (x)))) -#endif - /* We want to keep the stack, frame, and arg pointers - special. */ - && x != frame_pointer_rtx -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - && x != arg_pointer_rtx -#endif - && x != stack_pointer_rtx) - return gen_rtx_REG (mode, REGNO (x) + word); - else - return gen_rtx_SUBREG (mode, x, word); - } - /* If X is a CONST_INT or a CONST_DOUBLE, extract the appropriate bits - from the low-order part of the constant. */ - else if ((GET_MODE_CLASS (mode) == MODE_INT - || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT) - && GET_MODE (x) == VOIDmode - && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)) - { - /* If MODE is twice the host word size, X is already the desired - representation. Otherwise, if MODE is wider than a word, we can't - do this. If MODE is exactly a word, return just one CONST_INT. - If MODE is smaller than a word, clear the bits that don't belong - in our mode, unless they and our sign bit are all one. So we get - either a reasonable negative value or a reasonable unsigned value - for this mode. */ - - if (GET_MODE_BITSIZE (mode) >= 2 * HOST_BITS_PER_WIDE_INT) - return x; - else if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT) - return 0; - else if (GET_MODE_BITSIZE (mode) == HOST_BITS_PER_WIDE_INT) - return (GET_CODE (x) == CONST_INT ? x - : GEN_INT (CONST_DOUBLE_LOW (x))); - else - { - /* MODE must be narrower than HOST_BITS_PER_WIDE_INT. */ - int width = GET_MODE_BITSIZE (mode); - HOST_WIDE_INT val = (GET_CODE (x) == CONST_INT ? INTVAL (x) - : CONST_DOUBLE_LOW (x)); - - /* Sign extend to HOST_WIDE_INT. */ - val = val << (HOST_BITS_PER_WIDE_INT - width) >> (HOST_BITS_PER_WIDE_INT - width); - - return (GET_CODE (x) == CONST_INT && INTVAL (x) == val ? x - : GEN_INT (val)); - } - } - - /* If X is an integral constant but we want it in floating-point, it - must be the case that we have a union of an integer and a floating-point - value. If the machine-parameters allow it, simulate that union here - and return the result. The two-word and single-word cases are - different. */ - - else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == UNITS_PER_WORD - && GET_CODE (x) == CONST_INT - && sizeof (float) * HOST_BITS_PER_CHAR == HOST_BITS_PER_WIDE_INT) -#ifdef REAL_ARITHMETIC - { - REAL_VALUE_TYPE r; - HOST_WIDE_INT i; - - i = INTVAL (x); - r = REAL_VALUE_FROM_TARGET_SINGLE (i); - return CONST_DOUBLE_FROM_REAL_VALUE (r, mode); - } -#else - { - union {HOST_WIDE_INT i; float d; } u; - - u.i = INTVAL (x); - return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode); - } -#endif - else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD - && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE) - && GET_MODE (x) == VOIDmode - && (sizeof (double) * HOST_BITS_PER_CHAR - == 2 * HOST_BITS_PER_WIDE_INT)) -#ifdef REAL_ARITHMETIC - { - REAL_VALUE_TYPE r; - HOST_WIDE_INT i[2]; - HOST_WIDE_INT low, high; - - if (GET_CODE (x) == CONST_INT) - low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1); - else - low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x); - - /* REAL_VALUE_TARGET_DOUBLE takes the addressing order of the - target machine. */ - if (WORDS_BIG_ENDIAN) - i[0] = high, i[1] = low; - else - i[0] = low, i[1] = high; - - r = REAL_VALUE_FROM_TARGET_DOUBLE (i); - return CONST_DOUBLE_FROM_REAL_VALUE (r, mode); - } -#else - { - union {HOST_WIDE_INT i[2]; double d; } u; - HOST_WIDE_INT low, high; - - if (GET_CODE (x) == CONST_INT) - low = INTVAL (x), high = low >> (HOST_BITS_PER_WIDE_INT -1); - else - low = CONST_DOUBLE_LOW (x), high = CONST_DOUBLE_HIGH (x); - -#ifdef HOST_WORDS_BIG_ENDIAN - u.i[0] = high, u.i[1] = low; -#else - u.i[0] = low, u.i[1] = high; -#endif - - return CONST_DOUBLE_FROM_REAL_VALUE (u.d, mode); - } -#endif - - /* We need an extra case for machines where HOST_BITS_PER_WIDE_INT is the - same as sizeof (double) or when sizeof (float) is larger than the - size of a word on the target machine. */ -#ifdef REAL_ARITHMETIC - else if (mode == SFmode && GET_CODE (x) == CONST_INT) - { - REAL_VALUE_TYPE r; - HOST_WIDE_INT i; - - i = INTVAL (x); - r = REAL_VALUE_FROM_TARGET_SINGLE (i); - return CONST_DOUBLE_FROM_REAL_VALUE (r, mode); - } - else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == UNITS_PER_WORD - && GET_CODE (x) == CONST_INT - && (sizeof (double) * HOST_BITS_PER_CHAR - == HOST_BITS_PER_WIDE_INT)) - { - REAL_VALUE_TYPE r; - HOST_WIDE_INT i; - - i = INTVAL (x); - r = REAL_VALUE_FROM_TARGET_DOUBLE (&i); - return CONST_DOUBLE_FROM_REAL_VALUE (r, mode); - } -#endif - - /* Similarly, if this is converting a floating-point value into a - single-word integer. Only do this is the host and target parameters are - compatible. */ - - else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && (GET_MODE_CLASS (mode) == MODE_INT - || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT) - && GET_CODE (x) == CONST_DOUBLE - && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT - && GET_MODE_BITSIZE (mode) == BITS_PER_WORD) - return operand_subword (x, word, 0, GET_MODE (x)); - - /* Similarly, if this is converting a floating-point value into a - two-word integer, we can do this one word at a time and make an - integer. Only do this is the host and target parameters are - compatible. */ - - else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && (GET_MODE_CLASS (mode) == MODE_INT - || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT) - && GET_CODE (x) == CONST_DOUBLE - && GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT - && GET_MODE_BITSIZE (mode) == 2 * BITS_PER_WORD) - { - rtx lowpart - = operand_subword (x, word + WORDS_BIG_ENDIAN, 0, GET_MODE (x)); - rtx highpart - = operand_subword (x, word + ! WORDS_BIG_ENDIAN, 0, GET_MODE (x)); - - if (lowpart && GET_CODE (lowpart) == CONST_INT - && highpart && GET_CODE (highpart) == CONST_INT) - return immed_double_const (INTVAL (lowpart), INTVAL (highpart), mode); - } - - /* Otherwise, we can't do this. */ - return 0; -} - -/* Return the real part (which has mode MODE) of a complex value X. - This always comes at the low address in memory. */ - -rtx -gen_realpart (mode, x) - enum machine_mode mode; - register rtx x; -{ - if (GET_CODE (x) == CONCAT && GET_MODE (XEXP (x, 0)) == mode) - return XEXP (x, 0); - else if (WORDS_BIG_ENDIAN - && GET_MODE_BITSIZE (mode) < BITS_PER_WORD - && REG_P (x) - && REGNO (x) < FIRST_PSEUDO_REGISTER) - fatal ("Unable to access real part of complex value in a hard register on this target"); - else if (WORDS_BIG_ENDIAN) - return gen_highpart (mode, x); - else - return gen_lowpart (mode, x); -} - -/* Return the imaginary part (which has mode MODE) of a complex value X. - This always comes at the high address in memory. */ - -rtx -gen_imagpart (mode, x) - enum machine_mode mode; - register rtx x; -{ - if (GET_CODE (x) == CONCAT && GET_MODE (XEXP (x, 0)) == mode) - return XEXP (x, 1); - else if (WORDS_BIG_ENDIAN) - return gen_lowpart (mode, x); - else if (!WORDS_BIG_ENDIAN - && GET_MODE_BITSIZE (mode) < BITS_PER_WORD - && REG_P (x) - && REGNO (x) < FIRST_PSEUDO_REGISTER) - fatal ("Unable to access imaginary part of complex value in a hard register on this target"); - else - return gen_highpart (mode, x); -} - -/* Return 1 iff X, assumed to be a SUBREG, - refers to the real part of the complex value in its containing reg. - Complex values are always stored with the real part in the first word, - regardless of WORDS_BIG_ENDIAN. */ - -int -subreg_realpart_p (x) - rtx x; -{ - if (GET_CODE (x) != SUBREG) - abort (); - - return SUBREG_WORD (x) * UNITS_PER_WORD < GET_MODE_UNIT_SIZE (GET_MODE (SUBREG_REG (x))); -} - -/* Assuming that X is an rtx (e.g., MEM, REG or SUBREG) for a value, - return an rtx (MEM, SUBREG, or CONST_INT) that refers to the - least-significant part of X. - MODE specifies how big a part of X to return; - it usually should not be larger than a word. - If X is a MEM whose address is a QUEUED, the value may be so also. */ - -rtx -gen_lowpart (mode, x) - enum machine_mode mode; - register rtx x; -{ - rtx result = gen_lowpart_common (mode, x); - - if (result) - return result; - else if (GET_CODE (x) == REG) - { - /* Must be a hard reg that's not valid in MODE. */ - result = gen_lowpart_common (mode, copy_to_reg (x)); - if (result == 0) - abort (); - return result; - } - else if (GET_CODE (x) == MEM) - { - /* The only additional case we can do is MEM. */ - register int offset = 0; - if (WORDS_BIG_ENDIAN) - offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD) - - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD)); - - if (BYTES_BIG_ENDIAN) - /* Adjust the address so that the address-after-the-data - is unchanged. */ - offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)) - - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))); - - return change_address (x, mode, plus_constant (XEXP (x, 0), offset)); - } - else if (GET_CODE (x) == ADDRESSOF) - return gen_lowpart (mode, force_reg (GET_MODE (x), x)); - else - abort (); -} - -/* Like `gen_lowpart', but refer to the most significant part. - This is used to access the imaginary part of a complex number. */ - -rtx -gen_highpart (mode, x) - enum machine_mode mode; - register rtx x; -{ - /* This case loses if X is a subreg. To catch bugs early, - complain if an invalid MODE is used even in other cases. */ - if (GET_MODE_SIZE (mode) > UNITS_PER_WORD - && GET_MODE_SIZE (mode) != GET_MODE_UNIT_SIZE (GET_MODE (x))) - abort (); - if (GET_CODE (x) == CONST_DOUBLE -#if !(TARGET_FLOAT_FORMAT != HOST_FLOAT_FORMAT || defined (REAL_IS_NOT_DOUBLE)) - && GET_MODE_CLASS (GET_MODE (x)) != MODE_FLOAT -#endif - ) - return GEN_INT (CONST_DOUBLE_HIGH (x) & GET_MODE_MASK (mode)); - else if (GET_CODE (x) == CONST_INT) - { - if (HOST_BITS_PER_WIDE_INT <= BITS_PER_WORD) - return const0_rtx; - return GEN_INT (INTVAL (x) >> (HOST_BITS_PER_WIDE_INT - BITS_PER_WORD)); - } - else if (GET_CODE (x) == MEM) - { - register int offset = 0; - if (! WORDS_BIG_ENDIAN) - offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD) - - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD)); - - if (! BYTES_BIG_ENDIAN - && GET_MODE_SIZE (mode) < UNITS_PER_WORD) - offset -= (GET_MODE_SIZE (mode) - - MIN (UNITS_PER_WORD, - GET_MODE_SIZE (GET_MODE (x)))); - - return change_address (x, mode, plus_constant (XEXP (x, 0), offset)); - } - else if (GET_CODE (x) == SUBREG) - { - /* The only time this should occur is when we are looking at a - multi-word item with a SUBREG whose mode is the same as that of the - item. It isn't clear what we would do if it wasn't. */ - if (SUBREG_WORD (x) != 0) - abort (); - return gen_highpart (mode, SUBREG_REG (x)); - } - else if (GET_CODE (x) == REG) - { - int word; - - /* Let the backend decide how many registers to skip. This is needed - in particular for sparc64 where fp regs are smaller than a word. */ - /* ??? Note that subregs are now ambiguous, in that those against - pseudos are sized by the word size, while those against hard - regs are sized by the underlying register size. Better would be - to always interpret the subreg offset parameter as bytes or bits. */ - - if (WORDS_BIG_ENDIAN) - word = 0; - else if (REGNO (x) < FIRST_PSEUDO_REGISTER) - word = (HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)) - - HARD_REGNO_NREGS (REGNO (x), mode)); - else - word = ((GET_MODE_SIZE (GET_MODE (x)) - - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD)) - / UNITS_PER_WORD); - - if (REGNO (x) < FIRST_PSEUDO_REGISTER - /* integrate.c can't handle parts of a return value register. */ - && (! REG_FUNCTION_VALUE_P (x) - || ! rtx_equal_function_value_matters) - /* We want to keep the stack, frame, and arg pointers special. */ - && x != frame_pointer_rtx -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - && x != arg_pointer_rtx -#endif - && x != stack_pointer_rtx) - return gen_rtx_REG (mode, REGNO (x) + word); - else - return gen_rtx_SUBREG (mode, x, word); - } - else - abort (); -} - -/* Return 1 iff X, assumed to be a SUBREG, - refers to the least significant part of its containing reg. - If X is not a SUBREG, always return 1 (it is its own low part!). */ - -int -subreg_lowpart_p (x) - rtx x; -{ - if (GET_CODE (x) != SUBREG) - return 1; - else if (GET_MODE (SUBREG_REG (x)) == VOIDmode) - return 0; - - if (WORDS_BIG_ENDIAN - && GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) > UNITS_PER_WORD) - return (SUBREG_WORD (x) - == ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) - - MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)) - / UNITS_PER_WORD)); - - return SUBREG_WORD (x) == 0; -} - -/* Return subword I of operand OP. - The word number, I, is interpreted as the word number starting at the - low-order address. Word 0 is the low-order word if not WORDS_BIG_ENDIAN, - otherwise it is the high-order word. - - If we cannot extract the required word, we return zero. Otherwise, an - rtx corresponding to the requested word will be returned. - - VALIDATE_ADDRESS is nonzero if the address should be validated. Before - reload has completed, a valid address will always be returned. After - reload, if a valid address cannot be returned, we return zero. - - If VALIDATE_ADDRESS is zero, we simply form the required address; validating - it is the responsibility of the caller. - - MODE is the mode of OP in case it is a CONST_INT. */ - -rtx -operand_subword (op, i, validate_address, mode) - rtx op; - int i; - int validate_address; - enum machine_mode mode; -{ - HOST_WIDE_INT val; - int size_ratio = HOST_BITS_PER_WIDE_INT / BITS_PER_WORD; - int bits_per_word = BITS_PER_WORD; - - if (mode == VOIDmode) - mode = GET_MODE (op); - - if (mode == VOIDmode) - abort (); - - /* If OP is narrower than a word, fail. */ - if (mode != BLKmode - && (GET_MODE_SIZE (mode) < UNITS_PER_WORD)) - return 0; - - /* If we want a word outside OP, return zero. */ - if (mode != BLKmode - && (i + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode)) - return const0_rtx; - - /* If OP is already an integer word, return it. */ - if (GET_MODE_CLASS (mode) == MODE_INT - && GET_MODE_SIZE (mode) == UNITS_PER_WORD) - return op; - - /* If OP is a REG or SUBREG, we can handle it very simply. */ - if (GET_CODE (op) == REG) - { - /* ??? There is a potential problem with this code. It does not - properly handle extractions of a subword from a hard register - that is larger than word_mode. Presumably the check for - HARD_REGNO_MODE_OK catches these most of these cases. */ - - /* If OP is a hard register, but OP + I is not a hard register, - then extracting a subword is impossible. - - For example, consider if OP is the last hard register and it is - larger than word_mode. If we wanted word N (for N > 0) because a - part of that hard register was known to contain a useful value, - then OP + I would refer to a pseudo, not the hard register we - actually wanted. */ - if (REGNO (op) < FIRST_PSEUDO_REGISTER - && REGNO (op) + i >= FIRST_PSEUDO_REGISTER) - return 0; - - /* If the register is not valid for MODE, return 0. Note we - have to check both OP and OP + I since they may refer to - different parts of the register file. - - Consider if OP refers to the last 96bit FP register and we want - subword 3 because that subword is known to contain a value we - needed. */ - if (REGNO (op) < FIRST_PSEUDO_REGISTER - && (! HARD_REGNO_MODE_OK (REGNO (op), word_mode) - || ! HARD_REGNO_MODE_OK (REGNO (op) + i, word_mode))) - return 0; - else if (REGNO (op) >= FIRST_PSEUDO_REGISTER - || (REG_FUNCTION_VALUE_P (op) - && rtx_equal_function_value_matters) - /* We want to keep the stack, frame, and arg pointers - special. */ - || op == frame_pointer_rtx -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - || op == arg_pointer_rtx -#endif - || op == stack_pointer_rtx) - return gen_rtx_SUBREG (word_mode, op, i); - else - return gen_rtx_REG (word_mode, REGNO (op) + i); - } - else if (GET_CODE (op) == SUBREG) - return gen_rtx_SUBREG (word_mode, SUBREG_REG (op), i + SUBREG_WORD (op)); - else if (GET_CODE (op) == CONCAT) - { - int partwords = GET_MODE_UNIT_SIZE (GET_MODE (op)) / UNITS_PER_WORD; - if (i < partwords) - return operand_subword (XEXP (op, 0), i, validate_address, mode); - return operand_subword (XEXP (op, 1), i - partwords, - validate_address, mode); - } - - /* Form a new MEM at the requested address. */ - if (GET_CODE (op) == MEM) - { - rtx addr = plus_constant (XEXP (op, 0), i * UNITS_PER_WORD); - rtx new; - - if (validate_address) - { - if (reload_completed) - { - if (! strict_memory_address_p (word_mode, addr)) - return 0; - } - else - addr = memory_address (word_mode, addr); - } - - new = gen_rtx_MEM (word_mode, addr); - - MEM_COPY_ATTRIBUTES (new, op); - RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op); - - return new; - } - - /* The only remaining cases are when OP is a constant. If the host and - target floating formats are the same, handling two-word floating - constants are easy. Note that REAL_VALUE_TO_TARGET_{SINGLE,DOUBLE} - are defined as returning one or two 32 bit values, respectively, - and not values of BITS_PER_WORD bits. */ -#ifdef REAL_ARITHMETIC -/* The output is some bits, the width of the target machine's word. - A wider-word host can surely hold them in a CONST_INT. A narrower-word - host can't. */ - if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_BITSIZE (mode) == 64 - && GET_CODE (op) == CONST_DOUBLE) - { - long k[2]; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_DOUBLE (rv, k); - - /* We handle 32-bit and >= 64-bit words here. Note that the order in - which the words are written depends on the word endianness. - ??? This is a potential portability problem and should - be fixed at some point. - - We must excercise caution with the sign bit. By definition there - are 32 significant bits in K; there may be more in a HOST_WIDE_INT. - Consider a host with a 32-bit long and a 64-bit HOST_WIDE_INT. - So we explicitly mask and sign-extend as necessary. */ - if (BITS_PER_WORD == 32) - { - val = k[i]; - val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; - return GEN_INT (val); - } -#if HOST_BITS_PER_WIDE_INT >= 64 - else if (BITS_PER_WORD >= 64 && i == 0) - { - val = k[! WORDS_BIG_ENDIAN]; - val = (((val & 0xffffffff) ^ 0x80000000) - 0x80000000) << 32; - val |= (HOST_WIDE_INT) k[WORDS_BIG_ENDIAN] & 0xffffffff; - return GEN_INT (val); - } -#endif - else if (BITS_PER_WORD == 16) - { - val = k[i >> 1]; - if ((i & 1) == !WORDS_BIG_ENDIAN) - val >>= 16; - val &= 0xffff; - return GEN_INT (val); - } - else - abort (); - } - else if (HOST_BITS_PER_WIDE_INT >= BITS_PER_WORD - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_BITSIZE (mode) > 64 - && GET_CODE (op) == CONST_DOUBLE) - { - long k[4]; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k); - - if (BITS_PER_WORD == 32) - { - val = k[i]; - val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; - return GEN_INT (val); - } - else - abort (); - } -#else /* no REAL_ARITHMETIC */ - if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == 2 * UNITS_PER_WORD - && GET_CODE (op) == CONST_DOUBLE) - { - /* The constant is stored in the host's word-ordering, - but we want to access it in the target's word-ordering. Some - compilers don't like a conditional inside macro args, so we have two - copies of the return. */ -#ifdef HOST_WORDS_BIG_ENDIAN - return GEN_INT (i == WORDS_BIG_ENDIAN - ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op)); -#else - return GEN_INT (i != WORDS_BIG_ENDIAN - ? CONST_DOUBLE_HIGH (op) : CONST_DOUBLE_LOW (op)); -#endif - } -#endif /* no REAL_ARITHMETIC */ - - /* Single word float is a little harder, since single- and double-word - values often do not have the same high-order bits. We have already - verified that we want the only defined word of the single-word value. */ -#ifdef REAL_ARITHMETIC - if (GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_BITSIZE (mode) == 32 - && GET_CODE (op) == CONST_DOUBLE) - { - long l; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, op); - REAL_VALUE_TO_TARGET_SINGLE (rv, l); - - /* Sign extend from known 32-bit value to HOST_WIDE_INT. */ - val = l; - val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000; - - if (BITS_PER_WORD == 16) - { - if ((i & 1) == !WORDS_BIG_ENDIAN) - val >>= 16; - val &= 0xffff; - } - - return GEN_INT (val); - } -#else - if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && sizeof (float) * 8 == HOST_BITS_PER_WIDE_INT - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == UNITS_PER_WORD - && GET_CODE (op) == CONST_DOUBLE) - { - double d; - union {float f; HOST_WIDE_INT i; } u; - - REAL_VALUE_FROM_CONST_DOUBLE (d, op); - - u.f = d; - return GEN_INT (u.i); - } - if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT - && HOST_BITS_PER_WIDE_INT == BITS_PER_WORD) - || flag_pretend_float) - && sizeof (double) * 8 == HOST_BITS_PER_WIDE_INT - && GET_MODE_CLASS (mode) == MODE_FLOAT - && GET_MODE_SIZE (mode) == UNITS_PER_WORD - && GET_CODE (op) == CONST_DOUBLE) - { - double d; - union {double d; HOST_WIDE_INT i; } u; - - REAL_VALUE_FROM_CONST_DOUBLE (d, op); - - u.d = d; - return GEN_INT (u.i); - } -#endif /* no REAL_ARITHMETIC */ - - /* The only remaining cases that we can handle are integers. - Convert to proper endianness now since these cases need it. - At this point, i == 0 means the low-order word. - - We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT - in general. However, if OP is (const_int 0), we can just return - it for any word. */ - - if (op == const0_rtx) - return op; - - if (GET_MODE_CLASS (mode) != MODE_INT - || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE) - || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT) - return 0; - - if (WORDS_BIG_ENDIAN) - i = GET_MODE_SIZE (mode) / UNITS_PER_WORD - 1 - i; - - /* Find out which word on the host machine this value is in and get - it from the constant. */ - val = (i / size_ratio == 0 - ? (GET_CODE (op) == CONST_INT ? INTVAL (op) : CONST_DOUBLE_LOW (op)) - : (GET_CODE (op) == CONST_INT - ? (INTVAL (op) < 0 ? ~0 : 0) : CONST_DOUBLE_HIGH (op))); - - /* Get the value we want into the low bits of val. */ - if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT) - val = ((val >> ((i % size_ratio) * BITS_PER_WORD))); - - /* Clear the bits that don't belong in our mode, unless they and our sign - bit are all one. So we get either a reasonable negative value or a - reasonable unsigned value for this mode. */ - if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT - && ((val & ((HOST_WIDE_INT) (-1) << (bits_per_word - 1))) - != ((HOST_WIDE_INT) (-1) << (bits_per_word - 1)))) - val &= ((HOST_WIDE_INT) 1 << bits_per_word) - 1; - - /* If this would be an entire word for the target, but is not for - the host, then sign-extend on the host so that the number will look - the same way on the host that it would on the target. - - For example, when building a 64 bit alpha hosted 32 bit sparc - targeted compiler, then we want the 32 bit unsigned value -1 to be - represented as a 64 bit value -1, and not as 0x00000000ffffffff. - The later confuses the sparc backend. */ - - if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT - && (val & ((HOST_WIDE_INT) 1 << (bits_per_word - 1)))) - val |= ((HOST_WIDE_INT) (-1) << bits_per_word); - - return GEN_INT (val); -} - -/* Similar to `operand_subword', but never return 0. If we can't extract - the required subword, put OP into a register and try again. If that fails, - abort. We always validate the address in this case. It is not valid - to call this function after reload; it is mostly meant for RTL - generation. - - MODE is the mode of OP, in case it is CONST_INT. */ - -rtx -operand_subword_force (op, i, mode) - rtx op; - int i; - enum machine_mode mode; -{ - rtx result = operand_subword (op, i, 1, mode); - - if (result) - return result; - - if (mode != BLKmode && mode != VOIDmode) - { - /* If this is a register which can not be accessed by words, copy it - to a pseudo register. */ - if (GET_CODE (op) == REG) - op = copy_to_reg (op); - else - op = force_reg (mode, op); - } - - result = operand_subword (op, i, 1, mode); - if (result == 0) - abort (); - - return result; -} - -/* Given a compare instruction, swap the operands. - A test instruction is changed into a compare of 0 against the operand. */ - -void -reverse_comparison (insn) - rtx insn; -{ - rtx body = PATTERN (insn); - rtx comp; - - if (GET_CODE (body) == SET) - comp = SET_SRC (body); - else - comp = SET_SRC (XVECEXP (body, 0, 0)); - - if (GET_CODE (comp) == COMPARE) - { - rtx op0 = XEXP (comp, 0); - rtx op1 = XEXP (comp, 1); - XEXP (comp, 0) = op1; - XEXP (comp, 1) = op0; - } - else - { - rtx new = gen_rtx_COMPARE (VOIDmode, CONST0_RTX (GET_MODE (comp)), comp); - if (GET_CODE (body) == SET) - SET_SRC (body) = new; - else - SET_SRC (XVECEXP (body, 0, 0)) = new; - } -} - -/* 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 (memref, mode, addr) - rtx memref; - enum machine_mode mode; - rtx addr; -{ - rtx new; - - if (GET_CODE (memref) != MEM) - abort (); - if (mode == VOIDmode) - mode = GET_MODE (memref); - if (addr == 0) - addr = XEXP (memref, 0); - - /* If reload is in progress or has completed, ADDR must be valid. - Otherwise, we can call memory_address to make it valid. */ - if (reload_completed || reload_in_progress) - { - if (! memory_address_p (mode, addr)) - abort (); - } - else - addr = memory_address (mode, addr); - - if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref)) - return memref; - - new = gen_rtx_MEM (mode, addr); - RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (memref); - MEM_COPY_ATTRIBUTES (new, memref); - return new; -} - -/* Return a newly created CODE_LABEL rtx with a unique label number. */ - -rtx -gen_label_rtx () -{ - register rtx label; - - label = gen_rtx_CODE_LABEL (VOIDmode, 0, NULL_RTX, - NULL_RTX, label_num++, NULL_PTR); - - LABEL_NUSES (label) = 0; - return label; -} - -/* For procedure integration. */ - -/* Return a newly created INLINE_HEADER rtx. Should allocate this - from a permanent obstack when the opportunity arises. */ - -rtx -gen_inline_header_rtx (first_insn, first_parm_insn, first_labelno, - last_labelno, max_parm_regnum, max_regnum, args_size, - pops_args, stack_slots, forced_labels, function_flags, - outgoing_args_size, original_arg_vector, - original_decl_initial, regno_rtx, regno_flag, - regno_align, parm_reg_stack_loc) - rtx first_insn, first_parm_insn; - int first_labelno, last_labelno, max_parm_regnum, max_regnum, args_size; - int pops_args; - rtx stack_slots; - rtx forced_labels; - int function_flags; - int outgoing_args_size; - rtvec original_arg_vector; - rtx original_decl_initial; - rtvec regno_rtx; - char *regno_flag; - char *regno_align; - rtvec parm_reg_stack_loc; -{ - rtx header = gen_rtx_INLINE_HEADER (VOIDmode, - cur_insn_uid++, NULL_RTX, - first_insn, first_parm_insn, - first_labelno, last_labelno, - max_parm_regnum, max_regnum, args_size, - pops_args, stack_slots, forced_labels, - function_flags, outgoing_args_size, - original_arg_vector, - original_decl_initial, - regno_rtx, regno_flag, regno_align, - parm_reg_stack_loc); - return header; -} - -/* Install new pointers to the first and last insns in the chain. - Also, set cur_insn_uid to one higher than the last in use. - Used for an inline-procedure after copying the insn chain. */ - -void -set_new_first_and_last_insn (first, last) - rtx first, last; -{ - rtx insn; - - first_insn = first; - last_insn = last; - cur_insn_uid = 0; - - for (insn = first; insn; insn = NEXT_INSN (insn)) - cur_insn_uid = MAX (cur_insn_uid, INSN_UID (insn)); - - cur_insn_uid++; -} - -/* Set the range of label numbers found in the current function. - This is used when belatedly compiling an inline function. */ - -void -set_new_first_and_last_label_num (first, last) - int first, last; -{ - base_label_num = label_num; - first_label_num = first; - last_label_num = last; -} - -/* Save all variables describing the current status into the structure *P. - This is used before starting a nested function. */ - -void -save_emit_status (p) - struct function *p; -{ - p->reg_rtx_no = reg_rtx_no; - p->first_label_num = first_label_num; - p->first_insn = first_insn; - p->last_insn = last_insn; - p->sequence_rtl_expr = sequence_rtl_expr; - p->sequence_stack = sequence_stack; - p->cur_insn_uid = cur_insn_uid; - p->last_linenum = last_linenum; - p->last_filename = last_filename; - p->regno_pointer_flag = regno_pointer_flag; - p->regno_pointer_align = regno_pointer_align; - p->regno_pointer_flag_length = regno_pointer_flag_length; - p->regno_reg_rtx = regno_reg_rtx; -} - -/* Restore all variables describing the current status from the structure *P. - This is used after a nested function. */ - -void -restore_emit_status (p) - struct function *p; -{ - int i; - - reg_rtx_no = p->reg_rtx_no; - first_label_num = p->first_label_num; - last_label_num = 0; - first_insn = p->first_insn; - last_insn = p->last_insn; - sequence_rtl_expr = p->sequence_rtl_expr; - sequence_stack = p->sequence_stack; - cur_insn_uid = p->cur_insn_uid; - last_linenum = p->last_linenum; - last_filename = p->last_filename; - regno_pointer_flag = p->regno_pointer_flag; - regno_pointer_align = p->regno_pointer_align; - regno_pointer_flag_length = p->regno_pointer_flag_length; - regno_reg_rtx = p->regno_reg_rtx; - - /* Clear our cache of rtx expressions for start_sequence and - gen_sequence. */ - sequence_element_free_list = 0; - for (i = 0; i < SEQUENCE_RESULT_SIZE; i++) - sequence_result[i] = 0; - - free_insn = 0; -} - -/* Go through all the RTL insn bodies and copy any invalid shared structure. - It does not work to do this twice, because the mark bits set here - are not cleared afterwards. */ - -void -unshare_all_rtl (insn) - register rtx insn; -{ - for (; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN) - { - PATTERN (insn) = copy_rtx_if_shared (PATTERN (insn)); - REG_NOTES (insn) = copy_rtx_if_shared (REG_NOTES (insn)); - LOG_LINKS (insn) = copy_rtx_if_shared (LOG_LINKS (insn)); - } - - /* Make sure the addresses of stack slots found outside the insn chain - (such as, in DECL_RTL of a variable) are not shared - with the insn chain. - - This special care is necessary when the stack slot MEM does not - actually appear in the insn chain. If it does appear, its address - is unshared from all else at that point. */ - - copy_rtx_if_shared (stack_slot_list); -} - -/* Mark ORIG as in use, and return a copy of it if it was already in use. - Recursively does the same for subexpressions. */ - -rtx -copy_rtx_if_shared (orig) - rtx orig; -{ - register rtx x = orig; - register int i; - register enum rtx_code code; - register char *format_ptr; - int copied = 0; - - if (x == 0) - return 0; - - code = GET_CODE (x); - - /* These types may be freely shared. */ - - switch (code) - { - case REG: - case QUEUED: - case CONST_INT: - case CONST_DOUBLE: - case SYMBOL_REF: - case CODE_LABEL: - case PC: - case CC0: - case SCRATCH: - /* SCRATCH must be shared because they represent distinct values. */ - return x; - - case CONST: - /* CONST can be shared if it contains a SYMBOL_REF. If it contains - a LABEL_REF, it isn't sharable. */ - if (GET_CODE (XEXP (x, 0)) == PLUS - && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF - && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT) - return x; - break; - - case INSN: - case JUMP_INSN: - case CALL_INSN: - case NOTE: - case BARRIER: - /* The chain of insns is not being copied. */ - return x; - - case MEM: - /* A MEM is allowed to be shared if its address is constant - or is a constant plus one of the special registers. */ - if (CONSTANT_ADDRESS_P (XEXP (x, 0)) - || XEXP (x, 0) == virtual_stack_vars_rtx - || XEXP (x, 0) == virtual_incoming_args_rtx) - return x; - - if (GET_CODE (XEXP (x, 0)) == PLUS - && (XEXP (XEXP (x, 0), 0) == virtual_stack_vars_rtx - || XEXP (XEXP (x, 0), 0) == virtual_incoming_args_rtx) - && CONSTANT_ADDRESS_P (XEXP (XEXP (x, 0), 1))) - { - /* This MEM can appear in more than one place, - but its address better not be shared with anything else. */ - if (! x->used) - XEXP (x, 0) = copy_rtx_if_shared (XEXP (x, 0)); - x->used = 1; - return x; - } - break; - - default: - break; - } - - /* This rtx may not be shared. If it has already been seen, - replace it with a copy of itself. */ - - if (x->used) - { - register rtx copy; - - copy = rtx_alloc (code); - bcopy ((char *) x, (char *) copy, - (sizeof (*copy) - sizeof (copy->fld) - + sizeof (copy->fld[0]) * GET_RTX_LENGTH (code))); - x = copy; - copied = 1; - } - x->used = 1; - - /* Now scan the subexpressions recursively. - We can store any replaced subexpressions directly into X - since we know X is not shared! Any vectors in X - must be copied if X was copied. */ - - format_ptr = GET_RTX_FORMAT (code); - - for (i = 0; i < GET_RTX_LENGTH (code); i++) - { - switch (*format_ptr++) - { - case 'e': - XEXP (x, i) = copy_rtx_if_shared (XEXP (x, i)); - break; - - case 'E': - if (XVEC (x, i) != NULL) - { - register int j; - int len = XVECLEN (x, i); - - if (copied && len > 0) - XVEC (x, i) = gen_rtvec_vv (len, XVEC (x, i)->elem); - for (j = 0; j < len; j++) - XVECEXP (x, i, j) = copy_rtx_if_shared (XVECEXP (x, i, j)); - } - break; - } - } - return x; -} - -/* Clear all the USED bits in X to allow copy_rtx_if_shared to be used - to look for shared sub-parts. */ - -void -reset_used_flags (x) - rtx x; -{ - register int i, j; - register enum rtx_code code; - register char *format_ptr; - - if (x == 0) - return; - - code = GET_CODE (x); - - /* These types may be freely shared so we needn't do any resetting - for them. */ - - switch (code) - { - case REG: - case QUEUED: - case CONST_INT: - case CONST_DOUBLE: - case SYMBOL_REF: - case CODE_LABEL: - case PC: - case CC0: - return; - - case INSN: - case JUMP_INSN: - case CALL_INSN: - case NOTE: - case LABEL_REF: - case BARRIER: - /* The chain of insns is not being copied. */ - return; - - default: - break; - } - - x->used = 0; - - format_ptr = GET_RTX_FORMAT (code); - for (i = 0; i < GET_RTX_LENGTH (code); i++) - { - switch (*format_ptr++) - { - case 'e': - reset_used_flags (XEXP (x, i)); - break; - - case 'E': - for (j = 0; j < XVECLEN (x, i); j++) - reset_used_flags (XVECEXP (x, i, j)); - break; - } - } -} - -/* Copy X if necessary so that it won't be altered by changes in OTHER. - Return X or the rtx for the pseudo reg the value of X was copied into. - OTHER must be valid as a SET_DEST. */ - -rtx -make_safe_from (x, other) - rtx x, other; -{ - while (1) - switch (GET_CODE (other)) - { - case SUBREG: - other = SUBREG_REG (other); - break; - case STRICT_LOW_PART: - case SIGN_EXTEND: - case ZERO_EXTEND: - other = XEXP (other, 0); - break; - default: - goto done; - } - done: - if ((GET_CODE (other) == MEM - && ! CONSTANT_P (x) - && GET_CODE (x) != REG - && GET_CODE (x) != SUBREG) - || (GET_CODE (other) == REG - && (REGNO (other) < FIRST_PSEUDO_REGISTER - || reg_mentioned_p (other, x)))) - { - rtx temp = gen_reg_rtx (GET_MODE (x)); - emit_move_insn (temp, x); - return temp; - } - return x; -} - -/* Emission of insns (adding them to the doubly-linked list). */ - -/* Return the first insn of the current sequence or current function. */ - -rtx -get_insns () -{ - return first_insn; -} - -/* Return the last insn emitted in current sequence or current function. */ - -rtx -get_last_insn () -{ - return last_insn; -} - -/* Specify a new insn as the last in the chain. */ - -void -set_last_insn (insn) - rtx insn; -{ - if (NEXT_INSN (insn) != 0) - abort (); - last_insn = insn; -} - -/* Return the last insn emitted, even if it is in a sequence now pushed. */ - -rtx -get_last_insn_anywhere () -{ - struct sequence_stack *stack; - if (last_insn) - return last_insn; - for (stack = sequence_stack; stack; stack = stack->next) - if (stack->last != 0) - return stack->last; - return 0; -} - -/* Return a number larger than any instruction's uid in this function. */ - -int -get_max_uid () -{ - return cur_insn_uid; -} - -/* Return the next insn. If it is a SEQUENCE, return the first insn - of the sequence. */ - -rtx -next_insn (insn) - rtx insn; -{ - if (insn) - { - insn = NEXT_INSN (insn); - if (insn && GET_CODE (insn) == INSN - && GET_CODE (PATTERN (insn)) == SEQUENCE) - insn = XVECEXP (PATTERN (insn), 0, 0); - } - - return insn; -} - -/* Return the previous insn. If it is a SEQUENCE, return the last insn - of the sequence. */ - -rtx -previous_insn (insn) - rtx insn; -{ - if (insn) - { - insn = PREV_INSN (insn); - if (insn && GET_CODE (insn) == INSN - && GET_CODE (PATTERN (insn)) == SEQUENCE) - insn = XVECEXP (PATTERN (insn), 0, XVECLEN (PATTERN (insn), 0) - 1); - } - - return insn; -} - -/* Return the next insn after INSN that is not a NOTE. This routine does not - look inside SEQUENCEs. */ - -rtx -next_nonnote_insn (insn) - rtx insn; -{ - while (insn) - { - insn = NEXT_INSN (insn); - if (insn == 0 || GET_CODE (insn) != NOTE) - break; - } - - return insn; -} - -/* Return the previous insn before INSN that is not a NOTE. This routine does - not look inside SEQUENCEs. */ - -rtx -prev_nonnote_insn (insn) - rtx insn; -{ - while (insn) - { - insn = PREV_INSN (insn); - if (insn == 0 || GET_CODE (insn) != NOTE) - break; - } - - return insn; -} - -/* Return the next INSN, CALL_INSN or JUMP_INSN after INSN; - or 0, if there is none. This routine does not look inside - SEQUENCEs. */ - -rtx -next_real_insn (insn) - rtx insn; -{ - while (insn) - { - insn = NEXT_INSN (insn); - if (insn == 0 || GET_CODE (insn) == INSN - || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN) - break; - } - - return insn; -} - -/* Return the last INSN, CALL_INSN or JUMP_INSN before INSN; - or 0, if there is none. This routine does not look inside - SEQUENCEs. */ - -rtx -prev_real_insn (insn) - rtx insn; -{ - while (insn) - { - insn = PREV_INSN (insn); - if (insn == 0 || GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN - || GET_CODE (insn) == JUMP_INSN) - break; - } - - return insn; -} - -/* Find the next insn after INSN that really does something. This routine - does not look inside SEQUENCEs. Until reload has completed, this is the - same as next_real_insn. */ - -rtx -next_active_insn (insn) - rtx insn; -{ - while (insn) - { - insn = NEXT_INSN (insn); - if (insn == 0 - || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN - || (GET_CODE (insn) == INSN - && (! reload_completed - || (GET_CODE (PATTERN (insn)) != USE - && GET_CODE (PATTERN (insn)) != CLOBBER)))) - break; - } - - return insn; -} - -/* Find the last insn before INSN that really does something. This routine - does not look inside SEQUENCEs. Until reload has completed, this is the - same as prev_real_insn. */ - -rtx -prev_active_insn (insn) - rtx insn; -{ - while (insn) - { - insn = PREV_INSN (insn); - if (insn == 0 - || GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == JUMP_INSN - || (GET_CODE (insn) == INSN - && (! reload_completed - || (GET_CODE (PATTERN (insn)) != USE - && GET_CODE (PATTERN (insn)) != CLOBBER)))) - break; - } - - return insn; -} - -/* Return the next CODE_LABEL after the insn INSN, or 0 if there is none. */ - -rtx -next_label (insn) - rtx insn; -{ - while (insn) - { - insn = NEXT_INSN (insn); - if (insn == 0 || GET_CODE (insn) == CODE_LABEL) - break; - } - - return insn; -} - -/* Return the last CODE_LABEL before the insn INSN, or 0 if there is none. */ - -rtx -prev_label (insn) - rtx insn; -{ - while (insn) - { - insn = PREV_INSN (insn); - if (insn == 0 || GET_CODE (insn) == CODE_LABEL) - break; - } - - return insn; -} - -#ifdef HAVE_cc0 -/* INSN uses CC0 and is being moved into a delay slot. Set up REG_CC_SETTER - and REG_CC_USER notes so we can find it. */ - -void -link_cc0_insns (insn) - rtx insn; -{ - rtx user = next_nonnote_insn (insn); - - if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE) - user = XVECEXP (PATTERN (user), 0, 0); - - REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn, REG_NOTES (user)); - REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn)); -} - -/* Return the next insn that uses CC0 after INSN, which is assumed to - set it. This is the inverse of prev_cc0_setter (i.e., prev_cc0_setter - applied to the result of this function should yield INSN). - - Normally, this is simply the next insn. However, if a REG_CC_USER note - is present, it contains the insn that uses CC0. - - Return 0 if we can't find the insn. */ - -rtx -next_cc0_user (insn) - rtx insn; -{ - rtx note = find_reg_note (insn, REG_CC_USER, NULL_RTX); - - if (note) - return XEXP (note, 0); - - insn = next_nonnote_insn (insn); - if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE) - insn = XVECEXP (PATTERN (insn), 0, 0); - - if (insn && GET_RTX_CLASS (GET_CODE (insn)) == 'i' - && reg_mentioned_p (cc0_rtx, PATTERN (insn))) - return insn; - - return 0; -} - -/* Find the insn that set CC0 for INSN. Unless INSN has a REG_CC_SETTER - note, it is the previous insn. */ - -rtx -prev_cc0_setter (insn) - rtx insn; -{ - rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX); - - if (note) - return XEXP (note, 0); - - insn = prev_nonnote_insn (insn); - if (! sets_cc0_p (PATTERN (insn))) - abort (); - - return insn; -} -#endif - -/* Try splitting insns that can be split for better scheduling. - PAT is the pattern which might split. - TRIAL is the insn providing PAT. - LAST is non-zero if we should return the last insn of the sequence produced. - - If this routine succeeds in splitting, it returns the first or last - replacement insn depending on the value of LAST. Otherwise, it - returns TRIAL. If the insn to be returned can be split, it will be. */ - -rtx -try_split (pat, trial, last) - rtx pat, trial; - int last; -{ - rtx before = PREV_INSN (trial); - rtx after = NEXT_INSN (trial); - rtx seq = split_insns (pat, trial); - int has_barrier = 0; - rtx tem; - - /* If we are splitting a JUMP_INSN, it might be followed by a BARRIER. - We may need to handle this specially. */ - if (after && GET_CODE (after) == BARRIER) - { - has_barrier = 1; - after = NEXT_INSN (after); - } - - if (seq) - { - /* SEQ can either be a SEQUENCE or the pattern of a single insn. - The latter case will normally arise only when being done so that - it, in turn, will be split (SFmode on the 29k is an example). */ - if (GET_CODE (seq) == SEQUENCE) - { - /* If we are splitting a JUMP_INSN, look for the JUMP_INSN in - SEQ and copy our JUMP_LABEL to it. If JUMP_LABEL is non-zero, - increment the usage count so we don't delete the label. */ - int i; - - if (GET_CODE (trial) == JUMP_INSN) - for (i = XVECLEN (seq, 0) - 1; i >= 0; i--) - if (GET_CODE (XVECEXP (seq, 0, i)) == JUMP_INSN) - { - JUMP_LABEL (XVECEXP (seq, 0, i)) = JUMP_LABEL (trial); - - if (JUMP_LABEL (trial)) - LABEL_NUSES (JUMP_LABEL (trial))++; - } - - tem = emit_insn_after (seq, before); - - delete_insn (trial); - if (has_barrier) - emit_barrier_after (tem); - - /* Recursively call try_split for each new insn created; by the - time control returns here that insn will be fully split, so - set LAST and continue from the insn after the one returned. - We can't use next_active_insn here since AFTER may be a note. - Ignore deleted insns, which can be occur if not optimizing. */ - for (tem = NEXT_INSN (before); tem != after; - tem = NEXT_INSN (tem)) - if (! INSN_DELETED_P (tem) - && GET_RTX_CLASS (GET_CODE (tem)) == 'i') - tem = try_split (PATTERN (tem), tem, 1); - } - /* Avoid infinite loop if the result matches the original pattern. */ - else if (rtx_equal_p (seq, pat)) - return trial; - else - { - PATTERN (trial) = seq; - INSN_CODE (trial) = -1; - try_split (seq, trial, last); - } - - /* Return either the first or the last insn, depending on which was - requested. */ - return last ? prev_active_insn (after) : next_active_insn (before); - } - - return trial; -} - -/* Make and return an INSN rtx, initializing all its slots. - Store PATTERN in the pattern slots. */ - -rtx -make_insn_raw (pattern) - rtx pattern; -{ - register rtx insn; - - /* If in RTL generation phase, see if FREE_INSN can be used. */ - if (free_insn != 0 && rtx_equal_function_value_matters) - { - insn = free_insn; - free_insn = NEXT_INSN (free_insn); - PUT_CODE (insn, INSN); - } - else - insn = rtx_alloc (INSN); - - INSN_UID (insn) = cur_insn_uid++; - PATTERN (insn) = pattern; - INSN_CODE (insn) = -1; - LOG_LINKS (insn) = NULL; - REG_NOTES (insn) = NULL; - - return insn; -} - -/* Like `make_insn' but make a JUMP_INSN instead of an insn. */ - -static rtx -make_jump_insn_raw (pattern) - rtx pattern; -{ - register rtx insn; - - insn = rtx_alloc (JUMP_INSN); - INSN_UID (insn) = cur_insn_uid++; - - PATTERN (insn) = pattern; - INSN_CODE (insn) = -1; - LOG_LINKS (insn) = NULL; - REG_NOTES (insn) = NULL; - JUMP_LABEL (insn) = NULL; - - return insn; -} - -/* Like `make_insn' but make a CALL_INSN instead of an insn. */ - -static rtx -make_call_insn_raw (pattern) - rtx pattern; -{ - register rtx insn; - - insn = rtx_alloc (CALL_INSN); - INSN_UID (insn) = cur_insn_uid++; - - PATTERN (insn) = pattern; - INSN_CODE (insn) = -1; - LOG_LINKS (insn) = NULL; - REG_NOTES (insn) = NULL; - CALL_INSN_FUNCTION_USAGE (insn) = NULL; - - return insn; -} - -/* Add INSN to the end of the doubly-linked list. - INSN may be an INSN, JUMP_INSN, CALL_INSN, CODE_LABEL, BARRIER or NOTE. */ - -void -add_insn (insn) - register rtx insn; -{ - PREV_INSN (insn) = last_insn; - NEXT_INSN (insn) = 0; - - if (NULL != last_insn) - NEXT_INSN (last_insn) = insn; - - if (NULL == first_insn) - first_insn = insn; - - last_insn = insn; -} - -/* Add INSN into the doubly-linked list after insn AFTER. This and - the next should be the only functions called to insert an insn once - delay slots have been filled since only they know how to update a - SEQUENCE. */ - -void -add_insn_after (insn, after) - rtx insn, after; -{ - rtx next = NEXT_INSN (after); - - if (optimize && INSN_DELETED_P (after)) - abort (); - - NEXT_INSN (insn) = next; - PREV_INSN (insn) = after; - - if (next) - { - PREV_INSN (next) = insn; - if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE) - PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = insn; - } - else if (last_insn == after) - last_insn = insn; - else - { - struct sequence_stack *stack = sequence_stack; - /* Scan all pending sequences too. */ - for (; stack; stack = stack->next) - if (after == stack->last) - { - stack->last = insn; - break; - } - - if (stack == 0) - abort (); - } - - NEXT_INSN (after) = insn; - if (GET_CODE (after) == INSN && GET_CODE (PATTERN (after)) == SEQUENCE) - { - rtx sequence = PATTERN (after); - NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn; - } -} - -/* Add INSN into the doubly-linked list before insn BEFORE. This and - the previous should be the only functions called to insert an insn once - delay slots have been filled since only they know how to update a - SEQUENCE. */ - -void -add_insn_before (insn, before) - rtx insn, before; -{ - rtx prev = PREV_INSN (before); - - if (optimize && INSN_DELETED_P (before)) - abort (); - - PREV_INSN (insn) = prev; - NEXT_INSN (insn) = before; - - if (prev) - { - NEXT_INSN (prev) = insn; - if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE) - { - rtx sequence = PATTERN (prev); - NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn; - } - } - else if (first_insn == before) - first_insn = insn; - else - { - struct sequence_stack *stack = sequence_stack; - /* Scan all pending sequences too. */ - for (; stack; stack = stack->next) - if (before == stack->first) - { - stack->first = insn; - break; - } - - if (stack == 0) - abort (); - } - - PREV_INSN (before) = insn; - if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE) - PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn; -} - -/* Remove an insn from its doubly-linked list. This function knows how - to handle sequences. */ -void -remove_insn (insn) - rtx insn; -{ - rtx next = NEXT_INSN (insn); - rtx prev = PREV_INSN (insn); - if (prev) - { - NEXT_INSN (prev) = next; - if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE) - { - rtx sequence = PATTERN (prev); - NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = next; - } - } - else if (first_insn == insn) - first_insn = next; - else - { - struct sequence_stack *stack = sequence_stack; - /* Scan all pending sequences too. */ - for (; stack; stack = stack->next) - if (insn == stack->first) - { - stack->first = next; - break; - } - - if (stack == 0) - abort (); - } - - if (next) - { - PREV_INSN (next) = prev; - if (GET_CODE (next) == INSN && GET_CODE (PATTERN (next)) == SEQUENCE) - PREV_INSN (XVECEXP (PATTERN (next), 0, 0)) = prev; - } - else if (last_insn == insn) - last_insn = prev; - else - { - struct sequence_stack *stack = sequence_stack; - /* Scan all pending sequences too. */ - for (; stack; stack = stack->next) - if (insn == stack->last) - { - stack->last = prev; - break; - } - - if (stack == 0) - abort (); - } -} - -/* Delete all insns made since FROM. - FROM becomes the new last instruction. */ - -void -delete_insns_since (from) - rtx from; -{ - if (from == 0) - first_insn = 0; - else - NEXT_INSN (from) = 0; - last_insn = from; -} - -/* This function is deprecated, please use sequences instead. - - Move a consecutive bunch of insns to a different place in the chain. - The insns to be moved are those between FROM and TO. - They are moved to a new position after the insn AFTER. - AFTER must not be FROM or TO or any insn in between. - - This function does not know about SEQUENCEs and hence should not be - called after delay-slot filling has been done. */ - -void -reorder_insns (from, to, after) - rtx from, to, after; -{ - /* Splice this bunch out of where it is now. */ - if (PREV_INSN (from)) - NEXT_INSN (PREV_INSN (from)) = NEXT_INSN (to); - if (NEXT_INSN (to)) - PREV_INSN (NEXT_INSN (to)) = PREV_INSN (from); - if (last_insn == to) - last_insn = PREV_INSN (from); - if (first_insn == from) - first_insn = NEXT_INSN (to); - - /* Make the new neighbors point to it and it to them. */ - if (NEXT_INSN (after)) - PREV_INSN (NEXT_INSN (after)) = to; - - NEXT_INSN (to) = NEXT_INSN (after); - PREV_INSN (from) = after; - NEXT_INSN (after) = from; - if (after == last_insn) - last_insn = to; -} - -/* Return the line note insn preceding INSN. */ - -static rtx -find_line_note (insn) - rtx insn; -{ - if (no_line_numbers) - return 0; - - for (; insn; insn = PREV_INSN (insn)) - if (GET_CODE (insn) == NOTE - && NOTE_LINE_NUMBER (insn) >= 0) - break; - - return insn; -} - -/* Like reorder_insns, but inserts line notes to preserve the line numbers - of the moved insns when debugging. This may insert a note between AFTER - and FROM, and another one after TO. */ - -void -reorder_insns_with_line_notes (from, to, after) - rtx from, to, after; -{ - rtx from_line = find_line_note (from); - rtx after_line = find_line_note (after); - - reorder_insns (from, to, after); - - if (from_line == after_line) - return; - - if (from_line) - emit_line_note_after (NOTE_SOURCE_FILE (from_line), - NOTE_LINE_NUMBER (from_line), - after); - if (after_line) - emit_line_note_after (NOTE_SOURCE_FILE (after_line), - NOTE_LINE_NUMBER (after_line), - to); -} - -/* Emit an insn of given code and pattern - at a specified place within the doubly-linked list. */ - -/* Make an instruction with body PATTERN - and output it before the instruction BEFORE. */ - -rtx -emit_insn_before (pattern, before) - register rtx pattern, before; -{ - register rtx insn = before; - - if (GET_CODE (pattern) == SEQUENCE) - { - register int i; - - for (i = 0; i < XVECLEN (pattern, 0); i++) - { - insn = XVECEXP (pattern, 0, i); - add_insn_before (insn, before); - } - if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE) - sequence_result[XVECLEN (pattern, 0)] = pattern; - } - else - { - insn = make_insn_raw (pattern); - add_insn_before (insn, before); - } - - return insn; -} - -/* Make an instruction with body PATTERN and code JUMP_INSN - and output it before the instruction BEFORE. */ - -rtx -emit_jump_insn_before (pattern, before) - register rtx pattern, before; -{ - register rtx insn; - - if (GET_CODE (pattern) == SEQUENCE) - insn = emit_insn_before (pattern, before); - else - { - insn = make_jump_insn_raw (pattern); - add_insn_before (insn, before); - } - - return insn; -} - -/* Make an instruction with body PATTERN and code CALL_INSN - and output it before the instruction BEFORE. */ - -rtx -emit_call_insn_before (pattern, before) - register rtx pattern, before; -{ - register rtx insn; - - if (GET_CODE (pattern) == SEQUENCE) - insn = emit_insn_before (pattern, before); - else - { - insn = make_call_insn_raw (pattern); - add_insn_before (insn, before); - PUT_CODE (insn, CALL_INSN); - } - - return insn; -} - -/* Make an insn of code BARRIER - and output it before the insn BEFORE. */ - -rtx -emit_barrier_before (before) - register rtx before; -{ - register rtx insn = rtx_alloc (BARRIER); - - INSN_UID (insn) = cur_insn_uid++; - - add_insn_before (insn, before); - return insn; -} - -/* Emit the label LABEL before the insn BEFORE. */ - -rtx -emit_label_before (label, before) - rtx label, before; -{ - /* This can be called twice for the same label as a result of the - confusion that follows a syntax error! So make it harmless. */ - if (INSN_UID (label) == 0) - { - INSN_UID (label) = cur_insn_uid++; - add_insn_before (label, before); - } - - return label; -} - -/* Emit a note of subtype SUBTYPE before the insn BEFORE. */ - -rtx -emit_note_before (subtype, before) - int subtype; - rtx before; -{ - register rtx note = rtx_alloc (NOTE); - INSN_UID (note) = cur_insn_uid++; - NOTE_SOURCE_FILE (note) = 0; - NOTE_LINE_NUMBER (note) = subtype; - - add_insn_before (note, before); - return note; -} - -/* Make an insn of code INSN with body PATTERN - and output it after the insn AFTER. */ - -rtx -emit_insn_after (pattern, after) - register rtx pattern, after; -{ - register rtx insn = after; - - if (GET_CODE (pattern) == SEQUENCE) - { - register int i; - - for (i = 0; i < XVECLEN (pattern, 0); i++) - { - insn = XVECEXP (pattern, 0, i); - add_insn_after (insn, after); - after = insn; - } - if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE) - sequence_result[XVECLEN (pattern, 0)] = pattern; - } - else - { - insn = make_insn_raw (pattern); - add_insn_after (insn, after); - } - - return insn; -} - -/* Similar to emit_insn_after, except that line notes are to be inserted so - as to act as if this insn were at FROM. */ - -void -emit_insn_after_with_line_notes (pattern, after, from) - rtx pattern, after, from; -{ - rtx from_line = find_line_note (from); - rtx after_line = find_line_note (after); - rtx insn = emit_insn_after (pattern, after); - - if (from_line) - emit_line_note_after (NOTE_SOURCE_FILE (from_line), - NOTE_LINE_NUMBER (from_line), - after); - - if (after_line) - emit_line_note_after (NOTE_SOURCE_FILE (after_line), - NOTE_LINE_NUMBER (after_line), - insn); -} - -/* Make an insn of code JUMP_INSN with body PATTERN - and output it after the insn AFTER. */ - -rtx -emit_jump_insn_after (pattern, after) - register rtx pattern, after; -{ - register rtx insn; - - if (GET_CODE (pattern) == SEQUENCE) - insn = emit_insn_after (pattern, after); - else - { - insn = make_jump_insn_raw (pattern); - add_insn_after (insn, after); - } - - return insn; -} - -/* Make an insn of code BARRIER - and output it after the insn AFTER. */ - -rtx -emit_barrier_after (after) - register rtx after; -{ - register rtx insn = rtx_alloc (BARRIER); - - INSN_UID (insn) = cur_insn_uid++; - - add_insn_after (insn, after); - return insn; -} - -/* Emit the label LABEL after the insn AFTER. */ - -rtx -emit_label_after (label, after) - rtx label, after; -{ - /* This can be called twice for the same label - as a result of the confusion that follows a syntax error! - So make it harmless. */ - if (INSN_UID (label) == 0) - { - INSN_UID (label) = cur_insn_uid++; - add_insn_after (label, after); - } - - return label; -} - -/* Emit a note of subtype SUBTYPE after the insn AFTER. */ - -rtx -emit_note_after (subtype, after) - int subtype; - rtx after; -{ - register rtx note = rtx_alloc (NOTE); - INSN_UID (note) = cur_insn_uid++; - NOTE_SOURCE_FILE (note) = 0; - NOTE_LINE_NUMBER (note) = subtype; - add_insn_after (note, after); - return note; -} - -/* Emit a line note for FILE and LINE after the insn AFTER. */ - -rtx -emit_line_note_after (file, line, after) - char *file; - int line; - rtx after; -{ - register rtx note; - - if (no_line_numbers && line > 0) - { - cur_insn_uid++; - return 0; - } - - note = rtx_alloc (NOTE); - INSN_UID (note) = cur_insn_uid++; - NOTE_SOURCE_FILE (note) = file; - NOTE_LINE_NUMBER (note) = line; - add_insn_after (note, after); - return note; -} - -/* Make an insn of code INSN with pattern PATTERN - and add it to the end of the doubly-linked list. - If PATTERN is a SEQUENCE, take the elements of it - and emit an insn for each element. - - Returns the last insn emitted. */ - -rtx -emit_insn (pattern) - rtx pattern; -{ - rtx insn = last_insn; - - if (GET_CODE (pattern) == SEQUENCE) - { - register int i; - - for (i = 0; i < XVECLEN (pattern, 0); i++) - { - insn = XVECEXP (pattern, 0, i); - add_insn (insn); - } - if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE) - sequence_result[XVECLEN (pattern, 0)] = pattern; - } - else - { - insn = make_insn_raw (pattern); - add_insn (insn); - } - - return insn; -} - -/* Emit the insns in a chain starting with INSN. - Return the last insn emitted. */ - -rtx -emit_insns (insn) - rtx insn; -{ - rtx last = 0; - - while (insn) - { - rtx next = NEXT_INSN (insn); - add_insn (insn); - last = insn; - insn = next; - } - - return last; -} - -/* Emit the insns in a chain starting with INSN and place them in front of - the insn BEFORE. Return the last insn emitted. */ - -rtx -emit_insns_before (insn, before) - rtx insn; - rtx before; -{ - rtx last = 0; - - while (insn) - { - rtx next = NEXT_INSN (insn); - add_insn_before (insn, before); - last = insn; - insn = next; - } - - return last; -} - -/* Emit the insns in a chain starting with FIRST and place them in back of - the insn AFTER. Return the last insn emitted. */ - -rtx -emit_insns_after (first, after) - register rtx first; - register rtx after; -{ - register rtx last; - register rtx after_after; - - if (!after) - abort (); - - if (!first) - return first; - - for (last = first; NEXT_INSN (last); last = NEXT_INSN (last)) - continue; - - after_after = NEXT_INSN (after); - - NEXT_INSN (after) = first; - PREV_INSN (first) = after; - NEXT_INSN (last) = after_after; - if (after_after) - PREV_INSN (after_after) = last; - - if (after == last_insn) - last_insn = last; - return last; -} - -/* Make an insn of code JUMP_INSN with pattern PATTERN - and add it to the end of the doubly-linked list. */ - -rtx -emit_jump_insn (pattern) - rtx pattern; -{ - if (GET_CODE (pattern) == SEQUENCE) - return emit_insn (pattern); - else - { - register rtx insn = make_jump_insn_raw (pattern); - add_insn (insn); - return insn; - } -} - -/* Make an insn of code CALL_INSN with pattern PATTERN - and add it to the end of the doubly-linked list. */ - -rtx -emit_call_insn (pattern) - rtx pattern; -{ - if (GET_CODE (pattern) == SEQUENCE) - return emit_insn (pattern); - else - { - register rtx insn = make_call_insn_raw (pattern); - add_insn (insn); - PUT_CODE (insn, CALL_INSN); - return insn; - } -} - -/* Add the label LABEL to the end of the doubly-linked list. */ - -rtx -emit_label (label) - rtx label; -{ - /* This can be called twice for the same label - as a result of the confusion that follows a syntax error! - So make it harmless. */ - if (INSN_UID (label) == 0) - { - INSN_UID (label) = cur_insn_uid++; - add_insn (label); - } - return label; -} - -/* Make an insn of code BARRIER - and add it to the end of the doubly-linked list. */ - -rtx -emit_barrier () -{ - register rtx barrier = rtx_alloc (BARRIER); - INSN_UID (barrier) = cur_insn_uid++; - add_insn (barrier); - return barrier; -} - -/* Make an insn of code NOTE - with data-fields specified by FILE and LINE - and add it to the end of the doubly-linked list, - but only if line-numbers are desired for debugging info. */ - -rtx -emit_line_note (file, line) - char *file; - int line; -{ - emit_filename = file; - emit_lineno = line; - -#if 0 - if (no_line_numbers) - return 0; -#endif - - return emit_note (file, line); -} - -/* Make an insn of code NOTE - with data-fields specified by FILE and LINE - and add it to the end of the doubly-linked list. - If it is a line-number NOTE, omit it if it matches the previous one. */ - -rtx -emit_note (file, line) - char *file; - int line; -{ - register rtx note; - - if (line > 0) - { - if (file && last_filename && !strcmp (file, last_filename) - && line == last_linenum) - return 0; - last_filename = file; - last_linenum = line; - } - - if (no_line_numbers && line > 0) - { - cur_insn_uid++; - return 0; - } - - note = rtx_alloc (NOTE); - INSN_UID (note) = cur_insn_uid++; - NOTE_SOURCE_FILE (note) = file; - NOTE_LINE_NUMBER (note) = line; - add_insn (note); - return note; -} - -/* Emit a NOTE, and don't omit it even if LINE is the previous note. */ - -rtx -emit_line_note_force (file, line) - char *file; - int line; -{ - last_linenum = -1; - return emit_line_note (file, line); -} - -/* Cause next statement to emit a line note even if the line number - has not changed. This is used at the beginning of a function. */ - -void -force_next_line_note () -{ - last_linenum = -1; -} - -/* Place a note of KIND on insn INSN with DATUM as the datum. If a - note of this type already exists, remove it first. */ - -void -set_unique_reg_note (insn, kind, datum) - rtx insn; - enum reg_note kind; - rtx datum; -{ - rtx note = find_reg_note (insn, kind, NULL_RTX); - - /* First remove the note if there already is one. */ - if (note) - remove_note (insn, note); - - REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn)); -} - -/* Return an indication of which type of insn should have X as a body. - The value is CODE_LABEL, INSN, CALL_INSN or JUMP_INSN. */ - -enum rtx_code -classify_insn (x) - rtx x; -{ - if (GET_CODE (x) == CODE_LABEL) - return CODE_LABEL; - if (GET_CODE (x) == CALL) - return CALL_INSN; - if (GET_CODE (x) == RETURN) - return JUMP_INSN; - if (GET_CODE (x) == SET) - { - if (SET_DEST (x) == pc_rtx) - return JUMP_INSN; - else if (GET_CODE (SET_SRC (x)) == CALL) - return CALL_INSN; - else - return INSN; - } - if (GET_CODE (x) == PARALLEL) - { - register int j; - for (j = XVECLEN (x, 0) - 1; j >= 0; j--) - if (GET_CODE (XVECEXP (x, 0, j)) == CALL) - return CALL_INSN; - else if (GET_CODE (XVECEXP (x, 0, j)) == SET - && SET_DEST (XVECEXP (x, 0, j)) == pc_rtx) - return JUMP_INSN; - else if (GET_CODE (XVECEXP (x, 0, j)) == SET - && GET_CODE (SET_SRC (XVECEXP (x, 0, j))) == CALL) - return CALL_INSN; - } - return INSN; -} - -/* Emit the rtl pattern X as an appropriate kind of insn. - If X is a label, it is simply added into the insn chain. */ - -rtx -emit (x) - rtx x; -{ - enum rtx_code code = classify_insn (x); - - if (code == CODE_LABEL) - return emit_label (x); - else if (code == INSN) - return emit_insn (x); - else if (code == JUMP_INSN) - { - register rtx insn = emit_jump_insn (x); - if (simplejump_p (insn) || GET_CODE (x) == RETURN) - return emit_barrier (); - return insn; - } - else if (code == CALL_INSN) - return emit_call_insn (x); - else - abort (); -} - -/* Begin emitting insns to a sequence which can be packaged in an - RTL_EXPR. If this sequence will contain something that might cause - the compiler to pop arguments to function calls (because those - pops have previously been deferred; see INHIBIT_DEFER_POP for more - details), use do_pending_stack_adjust before calling this function. - That will ensure that the deferred pops are not accidentally - emitted in the middel of this sequence. */ - -void -start_sequence () -{ - struct sequence_stack *tem; - - if (sequence_element_free_list) - { - /* Reuse a previously-saved struct sequence_stack. */ - tem = sequence_element_free_list; - sequence_element_free_list = tem->next; - } - else - tem = (struct sequence_stack *) permalloc (sizeof (struct sequence_stack)); - - tem->next = sequence_stack; - tem->first = first_insn; - tem->last = last_insn; - tem->sequence_rtl_expr = sequence_rtl_expr; - - sequence_stack = tem; - - first_insn = 0; - last_insn = 0; -} - -/* Similarly, but indicate that this sequence will be placed in T, an - RTL_EXPR. See the documentation for start_sequence for more - information about how to use this function. */ - -void -start_sequence_for_rtl_expr (t) - tree t; -{ - start_sequence (); - - sequence_rtl_expr = t; -} - -/* Set up the insn chain starting with FIRST as the current sequence, - saving the previously current one. See the documentation for - start_sequence for more information about how to use this function. */ - -void -push_to_sequence (first) - rtx first; -{ - rtx last; - - start_sequence (); - - for (last = first; last && NEXT_INSN (last); last = NEXT_INSN (last)); - - first_insn = first; - last_insn = last; -} - -/* Set up the outer-level insn chain - as the current sequence, saving the previously current one. */ - -void -push_topmost_sequence () -{ - struct sequence_stack *stack, *top = NULL; - - start_sequence (); - - for (stack = sequence_stack; stack; stack = stack->next) - top = stack; - - first_insn = top->first; - last_insn = top->last; - sequence_rtl_expr = top->sequence_rtl_expr; -} - -/* After emitting to the outer-level insn chain, update the outer-level - insn chain, and restore the previous saved state. */ - -void -pop_topmost_sequence () -{ - struct sequence_stack *stack, *top = NULL; - - for (stack = sequence_stack; stack; stack = stack->next) - top = stack; - - top->first = first_insn; - top->last = last_insn; - /* ??? Why don't we save sequence_rtl_expr here? */ - - end_sequence (); -} - -/* After emitting to a sequence, restore previous saved state. - - To get the contents of the sequence just made, you must call - `gen_sequence' *before* calling here. - - If the compiler might have deferred popping arguments while - generating this sequence, and this sequence will not be immediately - inserted into the instruction stream, use do_pending_stack_adjust - before calling gen_sequence. That will ensure that the deferred - pops are inserted into this sequence, and not into some random - location in the instruction stream. See INHIBIT_DEFER_POP for more - information about deferred popping of arguments. */ - -void -end_sequence () -{ - struct sequence_stack *tem = sequence_stack; - - first_insn = tem->first; - last_insn = tem->last; - sequence_rtl_expr = tem->sequence_rtl_expr; - sequence_stack = tem->next; - - tem->next = sequence_element_free_list; - sequence_element_free_list = tem; -} - -/* Return 1 if currently emitting into a sequence. */ - -int -in_sequence_p () -{ - return sequence_stack != 0; -} - -/* Generate a SEQUENCE rtx containing the insns already emitted - to the current sequence. - - This is how the gen_... function from a DEFINE_EXPAND - constructs the SEQUENCE that it returns. */ - -rtx -gen_sequence () -{ - rtx result; - rtx tem; - int i; - int len; - - /* Count the insns in the chain. */ - len = 0; - for (tem = first_insn; tem; tem = NEXT_INSN (tem)) - len++; - - /* If only one insn, return its pattern rather than a SEQUENCE. - (Now that we cache SEQUENCE expressions, it isn't worth special-casing - the case of an empty list.) */ - if (len == 1 - && ! RTX_FRAME_RELATED_P (first_insn) - && (GET_CODE (first_insn) == INSN - || GET_CODE (first_insn) == JUMP_INSN - /* Don't discard the call usage field. */ - || (GET_CODE (first_insn) == CALL_INSN - && CALL_INSN_FUNCTION_USAGE (first_insn) == NULL_RTX))) - { - NEXT_INSN (first_insn) = free_insn; - free_insn = first_insn; - return PATTERN (first_insn); - } - - /* Put them in a vector. See if we already have a SEQUENCE of the - appropriate length around. */ - if (len < SEQUENCE_RESULT_SIZE && (result = sequence_result[len]) != 0) - sequence_result[len] = 0; - else - { - /* Ensure that this rtl goes in saveable_obstack, since we may - cache it. */ - push_obstacks_nochange (); - rtl_in_saveable_obstack (); - result = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (len)); - pop_obstacks (); - } - - for (i = 0, tem = first_insn; tem; tem = NEXT_INSN (tem), i++) - XVECEXP (result, 0, i) = tem; - - return result; -} - -/* Put the various virtual registers into REGNO_REG_RTX. */ - -void -init_virtual_regs () -{ - regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM] = virtual_incoming_args_rtx; - regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM] = virtual_stack_vars_rtx; - regno_reg_rtx[VIRTUAL_STACK_DYNAMIC_REGNUM] = virtual_stack_dynamic_rtx; - regno_reg_rtx[VIRTUAL_OUTGOING_ARGS_REGNUM] = virtual_outgoing_args_rtx; - regno_reg_rtx[VIRTUAL_CFA_REGNUM] = virtual_cfa_rtx; -} - -/* Initialize data structures and variables in this file - before generating rtl for each function. */ - -void -init_emit () -{ - int i; - - first_insn = NULL; - last_insn = NULL; - sequence_rtl_expr = NULL; - cur_insn_uid = 1; - reg_rtx_no = LAST_VIRTUAL_REGISTER + 1; - last_linenum = 0; - last_filename = 0; - first_label_num = label_num; - last_label_num = 0; - sequence_stack = NULL; - - /* Clear the start_sequence/gen_sequence cache. */ - sequence_element_free_list = 0; - for (i = 0; i < SEQUENCE_RESULT_SIZE; i++) - sequence_result[i] = 0; - free_insn = 0; - - /* Init the tables that describe all the pseudo regs. */ - - regno_pointer_flag_length = LAST_VIRTUAL_REGISTER + 101; - - regno_pointer_flag - = (char *) savealloc (regno_pointer_flag_length); - bzero (regno_pointer_flag, regno_pointer_flag_length); - - regno_pointer_align - = (char *) savealloc (regno_pointer_flag_length); - bzero (regno_pointer_align, regno_pointer_flag_length); - - regno_reg_rtx - = (rtx *) savealloc (regno_pointer_flag_length * sizeof (rtx)); - bzero ((char *) regno_reg_rtx, regno_pointer_flag_length * sizeof (rtx)); - - /* Put copies of all the virtual register rtx into regno_reg_rtx. */ - init_virtual_regs (); - - /* Indicate that the virtual registers and stack locations are - all pointers. */ - REGNO_POINTER_FLAG (STACK_POINTER_REGNUM) = 1; - REGNO_POINTER_FLAG (FRAME_POINTER_REGNUM) = 1; - REGNO_POINTER_FLAG (HARD_FRAME_POINTER_REGNUM) = 1; - REGNO_POINTER_FLAG (ARG_POINTER_REGNUM) = 1; - - REGNO_POINTER_FLAG (VIRTUAL_INCOMING_ARGS_REGNUM) = 1; - REGNO_POINTER_FLAG (VIRTUAL_STACK_VARS_REGNUM) = 1; - REGNO_POINTER_FLAG (VIRTUAL_STACK_DYNAMIC_REGNUM) = 1; - REGNO_POINTER_FLAG (VIRTUAL_OUTGOING_ARGS_REGNUM) = 1; - REGNO_POINTER_FLAG (VIRTUAL_CFA_REGNUM) = 1; - -#ifdef STACK_BOUNDARY - REGNO_POINTER_ALIGN (STACK_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (FRAME_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) - = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (ARG_POINTER_REGNUM) = STACK_BOUNDARY / BITS_PER_UNIT; - - REGNO_POINTER_ALIGN (VIRTUAL_INCOMING_ARGS_REGNUM) - = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (VIRTUAL_STACK_VARS_REGNUM) - = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (VIRTUAL_STACK_DYNAMIC_REGNUM) - = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (VIRTUAL_OUTGOING_ARGS_REGNUM) - = STACK_BOUNDARY / BITS_PER_UNIT; - REGNO_POINTER_ALIGN (VIRTUAL_CFA_REGNUM) = UNITS_PER_WORD; -#endif - -#ifdef INIT_EXPANDERS - INIT_EXPANDERS; -#endif -} - -/* Create some permanent unique rtl objects shared between all functions. - LINE_NUMBERS is nonzero if line numbers are to be generated. */ - -void -init_emit_once (line_numbers) - int line_numbers; -{ - int i; - enum machine_mode mode; - enum machine_mode double_mode; - - no_line_numbers = ! line_numbers; - - sequence_stack = NULL; - - /* Compute the word and byte modes. */ - - byte_mode = VOIDmode; - word_mode = VOIDmode; - double_mode = VOIDmode; - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - { - if (GET_MODE_BITSIZE (mode) == BITS_PER_UNIT - && byte_mode == VOIDmode) - byte_mode = mode; - - if (GET_MODE_BITSIZE (mode) == BITS_PER_WORD - && word_mode == VOIDmode) - word_mode = mode; - } - -#ifndef DOUBLE_TYPE_SIZE -#define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) -#endif - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - { - if (GET_MODE_BITSIZE (mode) == DOUBLE_TYPE_SIZE - && double_mode == VOIDmode) - double_mode = mode; - } - - ptr_mode = mode_for_size (POINTER_SIZE, GET_MODE_CLASS (Pmode), 0); - - /* Create the unique rtx's for certain rtx codes and operand values. */ - - for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++) - { - PUT_CODE (&const_int_rtx[i + MAX_SAVED_CONST_INT], CONST_INT); - PUT_MODE (&const_int_rtx[i + MAX_SAVED_CONST_INT], VOIDmode); - INTVAL (&const_int_rtx[i + MAX_SAVED_CONST_INT]) = i; - } - - if (STORE_FLAG_VALUE >= - MAX_SAVED_CONST_INT - && STORE_FLAG_VALUE <= MAX_SAVED_CONST_INT) - const_true_rtx = &const_int_rtx[STORE_FLAG_VALUE + MAX_SAVED_CONST_INT]; - else - const_true_rtx = gen_rtx_CONST_INT (VOIDmode, STORE_FLAG_VALUE); - - dconst0 = REAL_VALUE_ATOF ("0", double_mode); - dconst1 = REAL_VALUE_ATOF ("1", double_mode); - dconst2 = REAL_VALUE_ATOF ("2", double_mode); - dconstm1 = REAL_VALUE_ATOF ("-1", double_mode); - - for (i = 0; i <= 2; i++) - { - for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - { - rtx tem = rtx_alloc (CONST_DOUBLE); - union real_extract u; - - bzero ((char *) &u, sizeof u); /* Zero any holes in a structure. */ - u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2; - - bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u); - CONST_DOUBLE_MEM (tem) = cc0_rtx; - PUT_MODE (tem, mode); - - const_tiny_rtx[i][(int) mode] = tem; - } - - const_tiny_rtx[i][(int) VOIDmode] = GEN_INT (i); - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - const_tiny_rtx[i][(int) mode] = GEN_INT (i); - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_PARTIAL_INT); - mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - const_tiny_rtx[i][(int) mode] = GEN_INT (i); - } - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_CC); mode != VOIDmode; - mode = GET_MODE_WIDER_MODE (mode)) - const_tiny_rtx[0][(int) mode] = const0_rtx; - - - /* Assign register numbers to the globally defined register rtx. - This must be done at runtime because the register number field - is in a union and some compilers can't initialize unions. */ - - REGNO (stack_pointer_rtx) = STACK_POINTER_REGNUM; - PUT_MODE (stack_pointer_rtx, Pmode); - REGNO (frame_pointer_rtx) = FRAME_POINTER_REGNUM; - PUT_MODE (frame_pointer_rtx, Pmode); -#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM - REGNO (hard_frame_pointer_rtx) = HARD_FRAME_POINTER_REGNUM; - PUT_MODE (hard_frame_pointer_rtx, Pmode); -#endif -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - REGNO (arg_pointer_rtx) = ARG_POINTER_REGNUM; - PUT_MODE (arg_pointer_rtx, Pmode); -#endif - - REGNO (virtual_incoming_args_rtx) = VIRTUAL_INCOMING_ARGS_REGNUM; - PUT_MODE (virtual_incoming_args_rtx, Pmode); - REGNO (virtual_stack_vars_rtx) = VIRTUAL_STACK_VARS_REGNUM; - PUT_MODE (virtual_stack_vars_rtx, Pmode); - REGNO (virtual_stack_dynamic_rtx) = VIRTUAL_STACK_DYNAMIC_REGNUM; - PUT_MODE (virtual_stack_dynamic_rtx, Pmode); - REGNO (virtual_outgoing_args_rtx) = VIRTUAL_OUTGOING_ARGS_REGNUM; - PUT_MODE (virtual_outgoing_args_rtx, Pmode); - REGNO (virtual_cfa_rtx) = VIRTUAL_CFA_REGNUM; - PUT_MODE (virtual_cfa_rtx, Pmode); - -#ifdef RETURN_ADDRESS_POINTER_REGNUM - return_address_pointer_rtx - = gen_rtx_raw_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM); -#endif - -#ifdef STRUCT_VALUE - struct_value_rtx = STRUCT_VALUE; -#else - struct_value_rtx = gen_rtx_REG (Pmode, STRUCT_VALUE_REGNUM); -#endif - -#ifdef STRUCT_VALUE_INCOMING - struct_value_incoming_rtx = STRUCT_VALUE_INCOMING; -#else -#ifdef STRUCT_VALUE_INCOMING_REGNUM - struct_value_incoming_rtx - = gen_rtx_REG (Pmode, STRUCT_VALUE_INCOMING_REGNUM); -#else - struct_value_incoming_rtx = struct_value_rtx; -#endif -#endif - -#ifdef STATIC_CHAIN_REGNUM - static_chain_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM); - -#ifdef STATIC_CHAIN_INCOMING_REGNUM - if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM) - static_chain_incoming_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM); - else -#endif - static_chain_incoming_rtx = static_chain_rtx; -#endif - -#ifdef STATIC_CHAIN - static_chain_rtx = STATIC_CHAIN; - -#ifdef STATIC_CHAIN_INCOMING - static_chain_incoming_rtx = STATIC_CHAIN_INCOMING; -#else - static_chain_incoming_rtx = static_chain_rtx; -#endif -#endif - -#ifdef PIC_OFFSET_TABLE_REGNUM - pic_offset_table_rtx = gen_rtx_REG (Pmode, PIC_OFFSET_TABLE_REGNUM); -#endif - -#ifdef INIT_EXPANDERS - /* This is to initialize save_machine_status and restore_machine_status before - the first call to push_function_context_to. This is needed by the Chill - front end which calls push_function_context_to before the first cal to - init_function_start. */ - INIT_EXPANDERS; -#endif -} - -/* Query and clear/ restore no_line_numbers. This is used by the - switch / case handling in stmt.c to give proper line numbers in - warnings about unreachable code. */ - -int -force_line_numbers () -{ - int old = no_line_numbers; - - no_line_numbers = 0; - if (old) - force_next_line_note (); - return old; -} - -void -restore_line_number_status (old_value) - int old_value; -{ - no_line_numbers = old_value; -} |