diff options
Diffstat (limited to 'gcc')
| -rwxr-xr-x | gcc/dwarf2out_020422.c | 9925 | ||||
| -rwxr-xr-x | gcc/function.BAK | 6650 | ||||
| -rwxr-xr-x | gcc/function_990206.c | 6578 | ||||
| -rwxr-xr-x | gcc/rtl_020422.c | 935 | ||||
| -rwxr-xr-x | gcc/rtl_020422.h | 1569 | ||||
| -rwxr-xr-x | gcc/unroll_991002.c | 4045 |
6 files changed, 0 insertions, 29702 deletions
diff --git a/gcc/dwarf2out_020422.c b/gcc/dwarf2out_020422.c deleted file mode 100755 index 64a4968..0000000 --- a/gcc/dwarf2out_020422.c +++ /dev/null @@ -1,9925 +0,0 @@ -/* Output Dwarf2 format symbol table information from the GNU C compiler. - Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 2001, 2002 - Free Software Foundation, Inc. - Contributed by Gary Funck (gary@intrepid.com). - Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com). - Extensively modified by Jason Merrill (jason@cygnus.com). - -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. */ - -/* The first part of this file deals with the DWARF 2 frame unwind - information, which is also used by the GCC efficient exception handling - mechanism. The second part, controlled only by an #ifdef - DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging - information. */ - -#include "config.h" -#include "system.h" -#include "defaults.h" -#include "tree.h" -#include "flags.h" -#include "rtl.h" -#include "hard-reg-set.h" -#include "regs.h" -#include "insn-config.h" -#include "reload.h" -#include "output.h" -#include "expr.h" -#include "except.h" -#include "dwarf2.h" -#include "dwarf2out.h" -#include "toplev.h" -#include "dyn-string.h" - -/* We cannot use <assert.h> in GCC source, since that would include - GCC's assert.h, which may not be compatible with the host compiler. */ -#undef assert -#ifdef NDEBUG -# define assert(e) -#else -# define assert(e) do { if (! (e)) abort (); } while (0) -#endif - -/* Decide whether we want to emit frame unwind information for the current - translation unit. */ - -int -dwarf2out_do_frame () -{ - return (write_symbols == DWARF2_DEBUG -#ifdef DWARF2_FRAME_INFO - || DWARF2_FRAME_INFO -#endif -#ifdef DWARF2_UNWIND_INFO - || (flag_exceptions && ! exceptions_via_longjmp) -#endif - ); -} - -#if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO) - -#ifndef __GNUC__ -#define inline -#endif - -/* How to start an assembler comment. */ -#ifndef ASM_COMMENT_START -#define ASM_COMMENT_START ";#" -#endif - -typedef struct dw_cfi_struct *dw_cfi_ref; -typedef struct dw_fde_struct *dw_fde_ref; -typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref; - -/* Call frames are described using a sequence of Call Frame - Information instructions. The register number, offset - and address fields are provided as possible operands; - their use is selected by the opcode field. */ - -typedef union dw_cfi_oprnd_struct -{ - unsigned long dw_cfi_reg_num; - long int dw_cfi_offset; - char *dw_cfi_addr; -} -dw_cfi_oprnd; - -typedef struct dw_cfi_struct -{ - dw_cfi_ref dw_cfi_next; - enum dwarf_call_frame_info dw_cfi_opc; - dw_cfi_oprnd dw_cfi_oprnd1; - dw_cfi_oprnd dw_cfi_oprnd2; -} -dw_cfi_node; - -/* All call frame descriptions (FDE's) in the GCC generated DWARF - refer to a single Common Information Entry (CIE), defined at - the beginning of the .debug_frame section. This used of a single - CIE obviates the need to keep track of multiple CIE's - in the DWARF generation routines below. */ - -typedef struct dw_fde_struct -{ - char *dw_fde_begin; - char *dw_fde_current_label; - char *dw_fde_end; - dw_cfi_ref dw_fde_cfi; -} -dw_fde_node; - -/* Maximum size (in bytes) of an artificially generated label. */ -#define MAX_ARTIFICIAL_LABEL_BYTES 30 - -/* Make sure we know the sizes of the various types dwarf can describe. These - are only defaults. If the sizes are different for your target, you should - override these values by defining the appropriate symbols in your tm.h - file. */ - -#ifndef CHAR_TYPE_SIZE -#define CHAR_TYPE_SIZE BITS_PER_UNIT -#endif -#ifndef PTR_SIZE -#define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT) -#endif - -/* The size in bytes of a DWARF field indicating an offset or length - relative to a debug info section, specified to be 4 bytes in the DWARF-2 - specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */ - -#ifndef DWARF_OFFSET_SIZE -#define DWARF_OFFSET_SIZE 4 -#endif - -#define DWARF_VERSION 2 - -/* Round SIZE up to the nearest BOUNDARY. */ -#define DWARF_ROUND(SIZE,BOUNDARY) \ - (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1)) - -/* Offsets recorded in opcodes are a multiple of this alignment factor. */ -#ifdef STACK_GROWS_DOWNWARD -#define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD) -#else -#define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD -#endif - -/* A pointer to the base of a table that contains frame description - information for each routine. */ -static dw_fde_ref fde_table; - -/* Number of elements currently allocated for fde_table. */ -static unsigned fde_table_allocated; - -/* Number of elements in fde_table currently in use. */ -static unsigned fde_table_in_use; - -/* Size (in elements) of increments by which we may expand the - fde_table. */ -#define FDE_TABLE_INCREMENT 256 - -/* A list of call frame insns for the CIE. */ -static dw_cfi_ref cie_cfi_head; - -/* The number of the current function definition for which debugging - information is being generated. These numbers range from 1 up to the - maximum number of function definitions contained within the current - compilation unit. These numbers are used to create unique label id's - unique to each function definition. */ -static unsigned current_funcdef_number = 0; - -/* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram - attribute that accelerates the lookup of the FDE associated - with the subprogram. This variable holds the table index of the FDE - associated with the current function (body) definition. */ -static unsigned current_funcdef_fde; - -/* Forward declarations for functions defined in this file. */ - -static char *stripattributes PROTO((char *)); -static char *dwarf_cfi_name PROTO((unsigned)); -static dw_cfi_ref new_cfi PROTO((void)); -static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref)); -static unsigned long size_of_uleb128 PROTO((unsigned long)); -static unsigned long size_of_sleb128 PROTO((long)); -static void output_uleb128 PROTO((unsigned long)); -static void output_sleb128 PROTO((long)); -static void add_fde_cfi PROTO((char *, dw_cfi_ref)); -static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *, - long *)); -static void lookup_cfa PROTO((unsigned long *, long *)); -static void reg_save PROTO((char *, unsigned, unsigned, - long)); -static void initial_return_save PROTO((rtx)); -static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref)); -static void output_call_frame_info PROTO((int)); -static unsigned reg_number PROTO((rtx)); -static void dwarf2out_stack_adjust PROTO((rtx)); - -/* Definitions of defaults for assembler-dependent names of various - pseudo-ops and section names. - Theses may be overridden in the tm.h file (if necessary) for a particular - assembler. */ - -#ifdef OBJECT_FORMAT_ELF -#ifndef UNALIGNED_SHORT_ASM_OP -#define UNALIGNED_SHORT_ASM_OP ".2byte" -#endif -#ifndef UNALIGNED_INT_ASM_OP -#define UNALIGNED_INT_ASM_OP ".4byte" -#endif -#ifndef UNALIGNED_DOUBLE_INT_ASM_OP -#define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte" -#endif -#endif /* OBJECT_FORMAT_ELF */ - -#ifndef ASM_BYTE_OP -#define ASM_BYTE_OP ".byte" -#endif - -/* Data and reference forms for relocatable data. */ -#define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4) -#define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4) - -/* Pseudo-op for defining a new section. */ -#ifndef SECTION_ASM_OP -#define SECTION_ASM_OP ".section" -#endif - -/* The default format used by the ASM_OUTPUT_SECTION macro (see below) to - print the SECTION_ASM_OP and the section name. The default here works for - almost all svr4 assemblers, except for the sparc, where the section name - must be enclosed in double quotes. (See sparcv4.h). */ -#ifndef SECTION_FORMAT -#ifdef PUSHSECTION_FORMAT -#define SECTION_FORMAT PUSHSECTION_FORMAT -#else -#define SECTION_FORMAT "\t%s\t%s\n" -#endif -#endif - -#ifndef FRAME_SECTION -#define FRAME_SECTION ".debug_frame" -#endif - -#ifndef FUNC_BEGIN_LABEL -#define FUNC_BEGIN_LABEL "LFB" -#endif -#ifndef FUNC_END_LABEL -#define FUNC_END_LABEL "LFE" -#endif -#define CIE_AFTER_SIZE_LABEL "LSCIE" -#define CIE_END_LABEL "LECIE" -#define CIE_LENGTH_LABEL "LLCIE" -#define FDE_AFTER_SIZE_LABEL "LSFDE" -#define FDE_END_LABEL "LEFDE" -#define FDE_LENGTH_LABEL "LLFDE" - -/* Definitions of defaults for various types of primitive assembly language - output operations. These may be overridden from within the tm.h file, - but typically, that is unnecessary. */ - -#ifndef ASM_OUTPUT_SECTION -#define ASM_OUTPUT_SECTION(FILE, SECTION) \ - fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA1 -#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA1 -#define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifdef UNALIGNED_INT_ASM_OP - -#ifndef UNALIGNED_OFFSET_ASM_OP -#define UNALIGNED_OFFSET_ASM_OP \ - (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP) -#endif - -#ifndef UNALIGNED_WORD_ASM_OP -#define UNALIGNED_WORD_ASM_OP \ - (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA2 -#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA4 -#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA -#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA -#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR -#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_CONST -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ - do { \ - fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ - output_addr_const ((FILE), (RTX)); \ - fputc ('\n', (FILE)); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET4 -#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET -#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ - do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA2 -#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA4 -#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA -#define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \ - (unsigned long) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_DATA -#define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \ - (unsigned long) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA8 -#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \ - do { \ - if (WORDS_BIG_ENDIAN) \ - { \ - fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\ - fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\ - } \ - else \ - { \ - fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \ - fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \ - } \ - } while (0) -#endif - -#else /* UNALIGNED_INT_ASM_OP */ - -/* We don't have unaligned support, let's hope the normal output works for - .debug_frame. */ - -#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1) - -#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) - -#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) - -#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (HImode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - 2, 1) - -#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (SImode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - 4, 1) - -#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (Pmode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - PTR_SIZE, 1) - -#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ - ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2) - -#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ - assemble_integer (GEN_INT (VALUE), 4, 1) - -#endif /* UNALIGNED_INT_ASM_OP */ - -#ifdef SET_ASM_OP -#ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL -#define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \ - do { \ - fprintf (FILE, "\t%s\t", SET_ASM_OP); \ - assemble_name (FILE, SY); \ - fputc (',', FILE); \ - assemble_name (FILE, HI); \ - fputc ('-', FILE); \ - assemble_name (FILE, LO); \ - } while (0) -#endif -#endif /* SET_ASM_OP */ - -/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing - newline is produced. When flag_debug_asm is asserted, we add commentary - at the end of the line, so we must avoid output of a newline here. */ -#ifndef ASM_OUTPUT_DWARF_STRING -#define ASM_OUTPUT_DWARF_STRING(FILE,P) \ - do { \ - register int slen = strlen(P); \ - register char *p = (P); \ - register int i; \ - fprintf (FILE, "\t.ascii \""); \ - for (i = 0; i < slen; i++) \ - { \ - register int c = p[i]; \ - if (c == '\"' || c == '\\') \ - putc ('\\', FILE); \ - if (c >= ' ' && c < 0177) \ - putc (c, FILE); \ - else \ - { \ - fprintf (FILE, "\\%o", c); \ - } \ - } \ - fprintf (FILE, "\\0\""); \ - } \ - while (0) -#endif - -/* The DWARF 2 CFA column which tracks the return address. Normally this - is the column for PC, or the first column after all of the hard - registers. */ -#ifndef DWARF_FRAME_RETURN_COLUMN -#ifdef PC_REGNUM -#define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM) -#else -#define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER -#endif -#endif - -/* The mapping from gcc register number to DWARF 2 CFA column number. By - default, we just provide columns for all registers. */ -#ifndef DWARF_FRAME_REGNUM -#define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG) -#endif - -/* Hook used by __throw. */ - -rtx -expand_builtin_dwarf_fp_regnum () -{ - return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM)); -} - -/* The offset from the incoming value of %sp to the top of the stack frame - for the current function. */ -#ifndef INCOMING_FRAME_SP_OFFSET -#define INCOMING_FRAME_SP_OFFSET 0 -#endif - -/* Return a pointer to a copy of the section string name S with all - attributes stripped off, and an asterisk prepended (for assemble_name). */ - -static inline char * -stripattributes (s) - char *s; -{ - char *stripped = xmalloc (strlen (s) + 2); - char *p = stripped; - - *p++ = '*'; - - while (*s && *s != ',') - *p++ = *s++; - - *p = '\0'; - return stripped; -} - -/* Return the register number described by a given RTL node. */ - -static unsigned -reg_number (rtl) - register rtx rtl; -{ - register unsigned regno = REGNO (rtl); - - if (regno >= FIRST_PSEUDO_REGISTER) - { - warning ("internal regno botch: regno = %d\n", regno); - regno = 0; - } - - regno = DBX_REGISTER_NUMBER (regno); - return regno; -} - -struct reg_size_range -{ - int beg; - int end; - int size; -}; - -/* Given a register number in REG_TREE, return an rtx for its size in bytes. - We do this in kind of a roundabout way, by building up a list of - register size ranges and seeing where our register falls in one of those - ranges. We need to do it this way because REG_TREE is not a constant, - and the target macros were not designed to make this task easy. */ - -rtx -expand_builtin_dwarf_reg_size (reg_tree, target) - tree reg_tree; - rtx target; -{ - enum machine_mode mode; - int size; - struct reg_size_range ranges[5]; - tree t, t2; - - int i = 0; - int n_ranges = 0; - int last_size = -1; - - for (; i < FIRST_PSEUDO_REGISTER; ++i) - { - /* The return address is out of order on the MIPS, and we don't use - copy_reg for it anyway, so we don't care here how large it is. */ - if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN) - continue; - - mode = reg_raw_mode[i]; - - /* CCmode is arbitrarily given a size of 4 bytes. It is more useful - to use the same size as word_mode, since that reduces the number - of ranges we need. It should not matter, since the result should - never be used for a condition code register anyways. */ - if (GET_MODE_CLASS (mode) == MODE_CC) - mode = word_mode; - - size = GET_MODE_SIZE (mode); - - /* If this register is not valid in the specified mode and - we have a previous size, use that for the size of this - register to avoid making junk tiny ranges. */ - if (! HARD_REGNO_MODE_OK (i, mode) && last_size != -1) - size = last_size; - - if (size != last_size) - { - ranges[n_ranges].beg = i; - ranges[n_ranges].size = last_size = size; - ++n_ranges; - if (n_ranges >= 5) - abort (); - } - ranges[n_ranges-1].end = i; - } - - /* The usual case: fp regs surrounded by general regs. */ - if (n_ranges == 3 && ranges[0].size == ranges[2].size) - { - if ((DWARF_FRAME_REGNUM (ranges[1].end) - - DWARF_FRAME_REGNUM (ranges[1].beg)) - != ranges[1].end - ranges[1].beg) - abort (); - t = fold (build (GE_EXPR, integer_type_node, reg_tree, - build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0))); - t2 = fold (build (LE_EXPR, integer_type_node, reg_tree, - build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0))); - t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2)); - t = fold (build (COND_EXPR, integer_type_node, t, - build_int_2 (ranges[1].size, 0), - build_int_2 (ranges[0].size, 0))); - } - else - { - /* Initialize last_end to be larger than any possible - DWARF_FRAME_REGNUM. */ - int last_end = 0x7fffffff; - --n_ranges; - t = build_int_2 (ranges[n_ranges].size, 0); - do - { - int beg = DWARF_FRAME_REGNUM (ranges[n_ranges].beg); - int end = DWARF_FRAME_REGNUM (ranges[n_ranges].end); - if (beg < 0) - continue; - if (end >= last_end) - abort (); - last_end = end; - if (end - beg != ranges[n_ranges].end - ranges[n_ranges].beg) - abort (); - t2 = fold (build (LE_EXPR, integer_type_node, reg_tree, - build_int_2 (end, 0))); - t = fold (build (COND_EXPR, integer_type_node, t2, - build_int_2 (ranges[n_ranges].size, 0), t)); - } - while (--n_ranges >= 0); - } - return expand_expr (t, target, Pmode, 0); -} - -/* Convert a DWARF call frame info. operation to its string name */ - -static char * -dwarf_cfi_name (cfi_opc) - register unsigned cfi_opc; -{ - switch (cfi_opc) - { - case DW_CFA_advance_loc: - return "DW_CFA_advance_loc"; - case DW_CFA_offset: - return "DW_CFA_offset"; - case DW_CFA_restore: - return "DW_CFA_restore"; - case DW_CFA_nop: - return "DW_CFA_nop"; - case DW_CFA_set_loc: - return "DW_CFA_set_loc"; - case DW_CFA_advance_loc1: - return "DW_CFA_advance_loc1"; - case DW_CFA_advance_loc2: - return "DW_CFA_advance_loc2"; - case DW_CFA_advance_loc4: - return "DW_CFA_advance_loc4"; - case DW_CFA_offset_extended: - return "DW_CFA_offset_extended"; - case DW_CFA_restore_extended: - return "DW_CFA_restore_extended"; - case DW_CFA_undefined: - return "DW_CFA_undefined"; - case DW_CFA_same_value: - return "DW_CFA_same_value"; - case DW_CFA_register: - return "DW_CFA_register"; - case DW_CFA_remember_state: - return "DW_CFA_remember_state"; - case DW_CFA_restore_state: - return "DW_CFA_restore_state"; - case DW_CFA_def_cfa: - return "DW_CFA_def_cfa"; - case DW_CFA_def_cfa_register: - return "DW_CFA_def_cfa_register"; - case DW_CFA_def_cfa_offset: - return "DW_CFA_def_cfa_offset"; - - /* SGI/MIPS specific */ - case DW_CFA_MIPS_advance_loc8: - return "DW_CFA_MIPS_advance_loc8"; - - /* GNU extensions */ - case DW_CFA_GNU_window_save: - return "DW_CFA_GNU_window_save"; - case DW_CFA_GNU_args_size: - return "DW_CFA_GNU_args_size"; - - default: - return "DW_CFA_<unknown>"; - } -} - -/* Return a pointer to a newly allocated Call Frame Instruction. */ - -static inline dw_cfi_ref -new_cfi () -{ - register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node)); - - cfi->dw_cfi_next = NULL; - cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0; - cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0; - - return cfi; -} - -/* Add a Call Frame Instruction to list of instructions. */ - -static inline void -add_cfi (list_head, cfi) - register dw_cfi_ref *list_head; - register dw_cfi_ref cfi; -{ - register dw_cfi_ref *p; - - /* Find the end of the chain. */ - for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next) - ; - - *p = cfi; -} - -/* Generate a new label for the CFI info to refer to. */ - -char * -dwarf2out_cfi_label () -{ - static char label[20]; - static unsigned long label_num = 0; - - ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++); - ASM_OUTPUT_LABEL (asm_out_file, label); - - return label; -} - -/* Add CFI to the current fde at the PC value indicated by LABEL if specified, - or to the CIE if LABEL is NULL. */ - -static void -add_fde_cfi (label, cfi) - register char *label; - register dw_cfi_ref cfi; -{ - if (label) - { - register dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; - - if (*label == 0) - label = dwarf2out_cfi_label (); - - if (fde->dw_fde_current_label == NULL - || strcmp (label, fde->dw_fde_current_label) != 0) - { - register dw_cfi_ref xcfi; - - fde->dw_fde_current_label = label = xstrdup (label); - - /* Set the location counter to the new label. */ - xcfi = new_cfi (); - xcfi->dw_cfi_opc = DW_CFA_advance_loc4; - xcfi->dw_cfi_oprnd1.dw_cfi_addr = label; - add_cfi (&fde->dw_fde_cfi, xcfi); - } - - add_cfi (&fde->dw_fde_cfi, cfi); - } - - else - add_cfi (&cie_cfi_head, cfi); -} - -/* Subroutine of lookup_cfa. */ - -static inline void -lookup_cfa_1 (cfi, regp, offsetp) - register dw_cfi_ref cfi; - register unsigned long *regp; - register long *offsetp; -{ - switch (cfi->dw_cfi_opc) - { - case DW_CFA_def_cfa_offset: - *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset; - break; - case DW_CFA_def_cfa_register: - *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; - break; - case DW_CFA_def_cfa: - *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num; - *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset; - break; - default: - break; - } -} - -/* Find the previous value for the CFA. */ - -static void -lookup_cfa (regp, offsetp) - register unsigned long *regp; - register long *offsetp; -{ - register dw_cfi_ref cfi; - - *regp = (unsigned long) -1; - *offsetp = 0; - - for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next) - lookup_cfa_1 (cfi, regp, offsetp); - - if (fde_table_in_use) - { - register dw_fde_ref fde = &fde_table[fde_table_in_use - 1]; - for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next) - lookup_cfa_1 (cfi, regp, offsetp); - } -} - -/* The current rule for calculating the DWARF2 canonical frame address. */ -static unsigned long cfa_reg; -static long cfa_offset; - -/* The register used for saving registers to the stack, and its offset - from the CFA. */ -static unsigned cfa_store_reg; -static long cfa_store_offset; - -/* The running total of the size of arguments pushed onto the stack. */ -static long args_size; - -/* The last args_size we actually output. */ -static long old_args_size; - -/* Entry point to update the canonical frame address (CFA). - LABEL is passed to add_fde_cfi. The value of CFA is now to be - calculated from REG+OFFSET. */ - -void -dwarf2out_def_cfa (label, reg, offset) - register char *label; - register unsigned reg; - register long offset; -{ - register dw_cfi_ref cfi; - unsigned long old_reg; - long old_offset; - - cfa_reg = reg; - cfa_offset = offset; - if (cfa_store_reg == reg) - cfa_store_offset = offset; - - reg = DWARF_FRAME_REGNUM (reg); - lookup_cfa (&old_reg, &old_offset); - - if (reg == old_reg && offset == old_offset) - return; - - cfi = new_cfi (); - - if (reg == old_reg) - { - cfi->dw_cfi_opc = DW_CFA_def_cfa_offset; - cfi->dw_cfi_oprnd1.dw_cfi_offset = offset; - } - -#ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */ - else if (offset == old_offset && old_reg != (unsigned long) -1) - { - cfi->dw_cfi_opc = DW_CFA_def_cfa_register; - cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; - } -#endif - - else - { - cfi->dw_cfi_opc = DW_CFA_def_cfa; - cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; - cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; - } - - add_fde_cfi (label, cfi); -} - -/* Add the CFI for saving a register. REG is the CFA column number. - LABEL is passed to add_fde_cfi. - If SREG is -1, the register is saved at OFFSET from the CFA; - otherwise it is saved in SREG. */ - -static void -reg_save (label, reg, sreg, offset) - register char * label; - register unsigned reg; - register unsigned sreg; - register long offset; -{ - register dw_cfi_ref cfi = new_cfi (); - - cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg; - - /* The following comparison is correct. -1 is used to indicate that - the value isn't a register number. */ - if (sreg == (unsigned int) -1) - { - if (reg & ~0x3f) - /* The register number won't fit in 6 bits, so we have to use - the long form. */ - cfi->dw_cfi_opc = DW_CFA_offset_extended; - else - cfi->dw_cfi_opc = DW_CFA_offset; - - offset /= DWARF_CIE_DATA_ALIGNMENT; - if (offset < 0) - abort (); - cfi->dw_cfi_oprnd2.dw_cfi_offset = offset; - } - else - { - cfi->dw_cfi_opc = DW_CFA_register; - cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg; - } - - add_fde_cfi (label, cfi); -} - -/* Add the CFI for saving a register window. LABEL is passed to reg_save. - This CFI tells the unwinder that it needs to restore the window registers - from the previous frame's window save area. - - ??? Perhaps we should note in the CIE where windows are saved (instead of - assuming 0(cfa)) and what registers are in the window. */ - -void -dwarf2out_window_save (label) - register char * label; -{ - register dw_cfi_ref cfi = new_cfi (); - cfi->dw_cfi_opc = DW_CFA_GNU_window_save; - add_fde_cfi (label, cfi); -} - -/* Add a CFI to update the running total of the size of arguments - pushed onto the stack. */ - -void -dwarf2out_args_size (label, size) - char *label; - long size; -{ - register dw_cfi_ref cfi; - - if (size == old_args_size) - return; - old_args_size = size; - - cfi = new_cfi (); - cfi->dw_cfi_opc = DW_CFA_GNU_args_size; - cfi->dw_cfi_oprnd1.dw_cfi_offset = size; - add_fde_cfi (label, cfi); -} - -/* Entry point for saving a register to the stack. REG is the GCC register - number. LABEL and OFFSET are passed to reg_save. */ - -void -dwarf2out_reg_save (label, reg, offset) - register char * label; - register unsigned reg; - register long offset; -{ - reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset); -} - -/* Entry point for saving the return address in the stack. - LABEL and OFFSET are passed to reg_save. */ - -void -dwarf2out_return_save (label, offset) - register char * label; - register long offset; -{ - reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset); -} - -/* Entry point for saving the return address in a register. - LABEL and SREG are passed to reg_save. */ - -void -dwarf2out_return_reg (label, sreg) - register char * label; - register unsigned sreg; -{ - reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0); -} - -/* Record the initial position of the return address. RTL is - INCOMING_RETURN_ADDR_RTX. */ - -static void -initial_return_save (rtl) - register rtx rtl; -{ - unsigned int reg = (unsigned int) -1; - long offset = 0; - - switch (GET_CODE (rtl)) - { - case REG: - /* RA is in a register. */ - reg = reg_number (rtl); - break; - case MEM: - /* RA is on the stack. */ - rtl = XEXP (rtl, 0); - switch (GET_CODE (rtl)) - { - case REG: - if (REGNO (rtl) != STACK_POINTER_REGNUM) - abort (); - offset = 0; - break; - case PLUS: - if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) - abort (); - offset = INTVAL (XEXP (rtl, 1)); - break; - case MINUS: - if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM) - abort (); - offset = -INTVAL (XEXP (rtl, 1)); - break; - default: - abort (); - } - break; - case PLUS: - /* The return address is at some offset from any value we can - actually load. For instance, on the SPARC it is in %i7+8. Just - ignore the offset for now; it doesn't matter for unwinding frames. */ - if (GET_CODE (XEXP (rtl, 1)) != CONST_INT) - abort (); - initial_return_save (XEXP (rtl, 0)); - return; - default: - abort (); - } - - reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset); -} - -/* Check INSN to see if it looks like a push or a stack adjustment, and - make a note of it if it does. EH uses this information to find out how - much extra space it needs to pop off the stack. */ - -static void -dwarf2out_stack_adjust (insn) - rtx insn; -{ - long offset; - char *label; - - if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN) - { - /* Extract the size of the args from the CALL rtx itself. */ - - insn = PATTERN (insn); - if (GET_CODE (insn) == PARALLEL) - insn = XVECEXP (insn, 0, 0); - if (GET_CODE (insn) == SET) - insn = SET_SRC (insn); - assert (GET_CODE (insn) == CALL); - dwarf2out_args_size ("", INTVAL (XEXP (insn, 1))); - return; - } - - /* If only calls can throw, and we have a frame pointer, - save up adjustments until we see the CALL_INSN. */ - else if (! asynchronous_exceptions - && cfa_reg != STACK_POINTER_REGNUM) - return; - - if (GET_CODE (insn) == BARRIER) - { - /* When we see a BARRIER, we know to reset args_size to 0. Usually - the compiler will have already emitted a stack adjustment, but - doesn't bother for calls to noreturn functions. */ -#ifdef STACK_GROWS_DOWNWARD - offset = -args_size; -#else - offset = args_size; -#endif - } - else if (GET_CODE (PATTERN (insn)) == SET) - { - rtx src, dest; - enum rtx_code code; - - insn = PATTERN (insn); - src = SET_SRC (insn); - dest = SET_DEST (insn); - - if (dest == stack_pointer_rtx) - { - /* (set (reg sp) (plus (reg sp) (const_int))) */ - code = GET_CODE (src); - if (! (code == PLUS || code == MINUS) - || XEXP (src, 0) != stack_pointer_rtx - || GET_CODE (XEXP (src, 1)) != CONST_INT) - return; - - offset = INTVAL (XEXP (src, 1)); - } - else if (GET_CODE (dest) == MEM) - { - /* (set (mem (pre_dec (reg sp))) (foo)) */ - src = XEXP (dest, 0); - code = GET_CODE (src); - - if (! (code == PRE_DEC || code == PRE_INC) - || XEXP (src, 0) != stack_pointer_rtx) - return; - - offset = GET_MODE_SIZE (GET_MODE (dest)); - } - else - return; - - if (code == PLUS || code == PRE_INC) - offset = -offset; - } - else - return; - - if (offset == 0) - return; - - if (cfa_reg == STACK_POINTER_REGNUM) - cfa_offset += offset; - -#ifndef STACK_GROWS_DOWNWARD - offset = -offset; -#endif - args_size += offset; - if (args_size < 0) - args_size = 0; - - label = dwarf2out_cfi_label (); - dwarf2out_def_cfa (label, cfa_reg, cfa_offset); - dwarf2out_args_size (label, args_size); -} - -/* Record call frame debugging information for INSN, which either - sets SP or FP (adjusting how we calculate the frame address) or saves a - register to the stack. If INSN is NULL_RTX, initialize our state. */ - -void -dwarf2out_frame_debug (insn) - rtx insn; -{ - char *label; - rtx src, dest; - long offset; - - /* A temporary register used in adjusting SP or setting up the store_reg. */ - static unsigned cfa_temp_reg; - static long cfa_temp_value; - - if (insn == NULL_RTX) - { - /* Set up state for generating call frame debug info. */ - lookup_cfa (&cfa_reg, &cfa_offset); - if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)) - abort (); - cfa_reg = STACK_POINTER_REGNUM; - cfa_store_reg = cfa_reg; - cfa_store_offset = cfa_offset; - cfa_temp_reg = -1; - cfa_temp_value = 0; - return; - } - - if (! RTX_FRAME_RELATED_P (insn)) - { - dwarf2out_stack_adjust (insn); - return; - } - - label = dwarf2out_cfi_label (); - - src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX); - if (src) - insn = XEXP (src, 0); - else - insn = PATTERN (insn); - - /* Assume that in a PARALLEL prologue insn, only the first elt is - significant. Currently this is true. */ - if (GET_CODE (insn) == PARALLEL) - insn = XVECEXP (insn, 0, 0); - if (GET_CODE (insn) != SET) - abort (); - - src = SET_SRC (insn); - dest = SET_DEST (insn); - - switch (GET_CODE (dest)) - { - case REG: - /* Update the CFA rule wrt SP or FP. Make sure src is - relative to the current CFA register. */ - switch (GET_CODE (src)) - { - /* Setting FP from SP. */ - case REG: - if (cfa_reg != (unsigned) REGNO (src)) - abort (); - if (REGNO (dest) != STACK_POINTER_REGNUM - && !(frame_pointer_needed - && REGNO (dest) == HARD_FRAME_POINTER_REGNUM)) - abort (); - cfa_reg = REGNO (dest); - break; - - case PLUS: - case MINUS: - if (dest == stack_pointer_rtx) - { - /* Adjusting SP. */ - switch (GET_CODE (XEXP (src, 1))) - { - case CONST_INT: - offset = INTVAL (XEXP (src, 1)); - break; - case REG: - if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg) - abort (); - offset = cfa_temp_value; - break; - default: - abort (); - } - - if (XEXP (src, 0) == hard_frame_pointer_rtx) - { - /* Restoring SP from FP in the epilogue. */ - if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM) - abort (); - cfa_reg = STACK_POINTER_REGNUM; - } - else if (XEXP (src, 0) != stack_pointer_rtx) - abort (); - - if (GET_CODE (src) == PLUS) - offset = -offset; - if (cfa_reg == STACK_POINTER_REGNUM) - cfa_offset += offset; - if (cfa_store_reg == STACK_POINTER_REGNUM) - cfa_store_offset += offset; - } - else if (dest == hard_frame_pointer_rtx) - { - /* Either setting the FP from an offset of the SP, - or adjusting the FP */ - if (! frame_pointer_needed - || REGNO (dest) != HARD_FRAME_POINTER_REGNUM) - abort (); - - if (XEXP (src, 0) == stack_pointer_rtx - && GET_CODE (XEXP (src, 1)) == CONST_INT) - { - if (cfa_reg != STACK_POINTER_REGNUM) - abort (); - offset = INTVAL (XEXP (src, 1)); - if (GET_CODE (src) == PLUS) - offset = -offset; - cfa_offset += offset; - cfa_reg = HARD_FRAME_POINTER_REGNUM; - } - else if (XEXP (src, 0) == hard_frame_pointer_rtx - && GET_CODE (XEXP (src, 1)) == CONST_INT) - { - if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM) - abort (); - offset = INTVAL (XEXP (src, 1)); - if (GET_CODE (src) == PLUS) - offset = -offset; - cfa_offset += offset; - } - - else - abort(); - } - else - { - if (GET_CODE (src) != PLUS - || XEXP (src, 1) != stack_pointer_rtx) - abort (); - if (GET_CODE (XEXP (src, 0)) != REG - || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg) - abort (); - if (cfa_reg != STACK_POINTER_REGNUM) - abort (); - cfa_store_reg = REGNO (dest); - cfa_store_offset = cfa_offset - cfa_temp_value; - } - break; - - case CONST_INT: - cfa_temp_reg = REGNO (dest); - cfa_temp_value = INTVAL (src); - break; - - case IOR: - if (GET_CODE (XEXP (src, 0)) != REG - || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg - || (unsigned) REGNO (dest) != cfa_temp_reg - || GET_CODE (XEXP (src, 1)) != CONST_INT) - abort (); - cfa_temp_value |= INTVAL (XEXP (src, 1)); - break; - - default: - abort (); - } - dwarf2out_def_cfa (label, cfa_reg, cfa_offset); - break; - - case MEM: - /* Saving a register to the stack. Make sure dest is relative to the - CFA register. */ - if (GET_CODE (src) != REG) - abort (); - switch (GET_CODE (XEXP (dest, 0))) - { - /* With a push. */ - case PRE_INC: - case PRE_DEC: - offset = GET_MODE_SIZE (GET_MODE (dest)); - if (GET_CODE (XEXP (dest, 0)) == PRE_INC) - offset = -offset; - - if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM - || cfa_store_reg != STACK_POINTER_REGNUM) - abort (); - cfa_store_offset += offset; - if (cfa_reg == STACK_POINTER_REGNUM) - cfa_offset = cfa_store_offset; - - offset = -cfa_store_offset; - break; - - /* With an offset. */ - case PLUS: - case MINUS: - offset = INTVAL (XEXP (XEXP (dest, 0), 1)); - if (GET_CODE (src) == MINUS) - offset = -offset; - - if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0))) - abort (); - offset -= cfa_store_offset; - break; - - /* Without an offset. */ - case REG: - if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0))) - abort(); - offset = -cfa_store_offset; - break; - - default: - abort (); - } - dwarf2out_def_cfa (label, cfa_reg, cfa_offset); - dwarf2out_reg_save (label, REGNO (src), offset); - break; - - default: - abort (); - } -} - -/* Return the size of an unsigned LEB128 quantity. */ - -static inline unsigned long -size_of_uleb128 (value) - register unsigned long value; -{ - register unsigned long size = 0; - register unsigned byte; - - do - { - byte = (value & 0x7f); - value >>= 7; - size += 1; - } - while (value != 0); - - return size; -} - -/* Return the size of a signed LEB128 quantity. */ - -static inline unsigned long -size_of_sleb128 (value) - register long value; -{ - register unsigned long size = 0; - register unsigned byte; - - do - { - byte = (value & 0x7f); - value >>= 7; - size += 1; - } - while (!(((value == 0) && ((byte & 0x40) == 0)) - || ((value == -1) && ((byte & 0x40) != 0)))); - - return size; -} - -/* Output an unsigned LEB128 quantity. */ - -static void -output_uleb128 (value) - register unsigned long value; -{ - unsigned long save_value = value; - - fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP); - do - { - register unsigned byte = (value & 0x7f); - value >>= 7; - if (value != 0) - /* More bytes to follow. */ - byte |= 0x80; - - fprintf (asm_out_file, "0x%x", byte); - if (value != 0) - fprintf (asm_out_file, ","); - } - while (value != 0); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value); -} - -/* Output an signed LEB128 quantity. */ - -static void -output_sleb128 (value) - register long value; -{ - register int more; - register unsigned byte; - long save_value = value; - - fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP); - do - { - byte = (value & 0x7f); - /* arithmetic shift */ - value >>= 7; - more = !((((value == 0) && ((byte & 0x40) == 0)) - || ((value == -1) && ((byte & 0x40) != 0)))); - if (more) - byte |= 0x80; - - fprintf (asm_out_file, "0x%x", byte); - if (more) - fprintf (asm_out_file, ","); - } - - while (more); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value); -} - -/* Output a Call Frame Information opcode and its operand(s). */ - -static void -output_cfi (cfi, fde) - register dw_cfi_ref cfi; - register dw_fde_ref fde; -{ - if (cfi->dw_cfi_opc == DW_CFA_advance_loc) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); - } - - else if (cfi->dw_cfi_opc == DW_CFA_offset) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); - fputc ('\n', asm_out_file); - } - else if (cfi->dw_cfi_opc == DW_CFA_restore) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - - fputc ('\n', asm_out_file); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, - dwarf_cfi_name (cfi->dw_cfi_opc)); - - fputc ('\n', asm_out_file); - switch (cfi->dw_cfi_opc) - { - case DW_CFA_set_loc: - ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr); - fputc ('\n', asm_out_file); - break; - case DW_CFA_advance_loc1: - ASM_OUTPUT_DWARF_DELTA1 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); - fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; - break; - case DW_CFA_advance_loc2: - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); - fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; - break; - case DW_CFA_advance_loc4: - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); - fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; - break; -#ifdef MIPS_DEBUGGING_INFO - case DW_CFA_MIPS_advance_loc8: - /* TODO: not currently implemented. */ - abort (); - break; -#endif - case DW_CFA_offset_extended: - case DW_CFA_def_cfa: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); - fputc ('\n', asm_out_file); - break; - case DW_CFA_restore_extended: - case DW_CFA_undefined: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - break; - case DW_CFA_same_value: - case DW_CFA_def_cfa_register: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - break; - case DW_CFA_register: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - break; - case DW_CFA_def_cfa_offset: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); - break; - case DW_CFA_GNU_window_save: - break; - case DW_CFA_GNU_args_size: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); - break; - default: - break; - } - } -} - -#if !defined (EH_FRAME_SECTION) -#if defined (EH_FRAME_SECTION_ASM_OP) -#define EH_FRAME_SECTION() eh_frame_section(); -#else -#if defined (ASM_OUTPUT_SECTION_NAME) -#define EH_FRAME_SECTION() \ - do { \ - named_section (NULL_TREE, ".eh_frame", 0); \ - } while (0) -#endif -#endif -#endif - -/* If we aren't using crtstuff to run ctors, don't use it for EH. */ -#if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP) -#undef EH_FRAME_SECTION -#endif - -/* Output the call frame information used to used to record information - that relates to calculating the frame pointer, and records the - location of saved registers. */ - -static void -output_call_frame_info (for_eh) - int for_eh; -{ - register unsigned long i; - register dw_fde_ref fde; - register dw_cfi_ref cfi; - char l1[20], l2[20]; -#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL - char ld[20]; -#endif - - /* Do we want to include a pointer to the exception table? */ - int eh_ptr = for_eh && exception_table_p (); - - fputc ('\n', asm_out_file); - - /* We're going to be generating comments, so turn on app. */ - if (flag_debug_asm) - app_enable (); - - if (for_eh) - { -#ifdef EH_FRAME_SECTION - EH_FRAME_SECTION (); -#else - tree label = get_file_function_name ('F'); - - force_data_section (); - ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); - ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); - ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label)); -#endif - assemble_label ("__FRAME_BEGIN__"); - } - else - ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION); - - /* Output the CIE. */ - ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh); - ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); -#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL - ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh); - if (for_eh) - ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); - else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); -#else - if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); - else - ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); -#endif - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Common Information Entry", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_LABEL (asm_out_file, l1); - - if (for_eh) - /* Now that the CIE pointer is PC-relative for EH, - use 0 to identify the CIE. */ - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); - else - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - if (! for_eh && DWARF_OFFSET_SIZE == 8) - { - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); - fputc ('\n', asm_out_file); - } - - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - if (eh_ptr) - { - /* The CIE contains a pointer to the exception region info for the - frame. Make the augmentation string three bytes (including the - trailing null) so the pointer is 4-byte aligned. The Solaris ld - can't handle unaligned relocs. */ - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh"); - fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, "eh", 3); - } - fputc ('\n', asm_out_file); - - ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__"); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s pointer to exception region info", - ASM_COMMENT_START); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Augmentation (none)", - ASM_COMMENT_START); - } - - fputc ('\n', asm_out_file); - output_uleb128 (1); - if (flag_debug_asm) - fprintf (asm_out_file, " (CIE Code Alignment Factor)"); - - fputc ('\n', asm_out_file); - output_sleb128 (DWARF_CIE_DATA_ALIGNMENT); - if (flag_debug_asm) - fprintf (asm_out_file, " (CIE Data Alignment Factor)"); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - - for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) - output_cfi (cfi, NULL); - - /* Pad the CIE out to an address sized boundary. */ - ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); - ASM_OUTPUT_LABEL (asm_out_file, l2); -#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL - ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START); - fputc ('\n', asm_out_file); -#endif - - /* Loop through all of the FDE's. */ - for (i = 0; i < fde_table_in_use; ++i) - { - fde = &fde_table[i]; - - ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2); - ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2); -#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL - ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2); - if (for_eh) - ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); - else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); -#else - if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); - else - ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); -#endif - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START); - fputc ('\n', asm_out_file); - ASM_OUTPUT_LABEL (asm_out_file, l1); - - /* ??? This always emits a 4 byte offset when for_eh is true, but it - emits a target dependent sized offset when for_eh is not true. - This inconsistency may confuse gdb. The only case where we need a - non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI - compatibility if we emit a 4 byte offset. We need a 4 byte offset - though in order to be compatible with the dwarf_fde struct in frame.c. - If the for_eh case is changed, then the struct in frame.c has - to be adjusted appropriately. */ - if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__"); - else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, - fde->dw_fde_end, fde->dw_fde_begin); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - - /* Loop through the Call Frame Instructions associated with - this FDE. */ - fde->dw_fde_current_label = fde->dw_fde_begin; - for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next) - output_cfi (cfi, fde); - - /* Pad the FDE out to an address sized boundary. */ - ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE)); - ASM_OUTPUT_LABEL (asm_out_file, l2); -#ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL - ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START); - fputc ('\n', asm_out_file); -#endif - } -#ifndef EH_FRAME_SECTION - if (for_eh) - { - /* Emit terminating zero for table. */ - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); - fputc ('\n', asm_out_file); - } -#endif -#ifdef MIPS_DEBUGGING_INFO - /* Work around Irix 6 assembler bug whereby labels at the end of a section - get a value of 0. Putting .align 0 after the label fixes it. */ - ASM_OUTPUT_ALIGN (asm_out_file, 0); -#endif - - /* Turn off app to make assembly quicker. */ - if (flag_debug_asm) - app_disable (); -} - -/* Output a marker (i.e. a label) for the beginning of a function, before - the prologue. */ - -void -dwarf2out_begin_prologue () -{ - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - register dw_fde_ref fde; - - ++current_funcdef_number; - - function_section (current_function_decl); - ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL, - current_funcdef_number); - ASM_OUTPUT_LABEL (asm_out_file, label); - - /* Expand the fde table if necessary. */ - if (fde_table_in_use == fde_table_allocated) - { - fde_table_allocated += FDE_TABLE_INCREMENT; - fde_table - = (dw_fde_ref) xrealloc (fde_table, - fde_table_allocated * sizeof (dw_fde_node)); - } - - /* Record the FDE associated with this function. */ - current_funcdef_fde = fde_table_in_use; - - /* Add the new FDE at the end of the fde_table. */ - fde = &fde_table[fde_table_in_use++]; - fde->dw_fde_begin = xstrdup (label); - fde->dw_fde_current_label = NULL; - fde->dw_fde_end = NULL; - fde->dw_fde_cfi = NULL; - - args_size = old_args_size = 0; -} - -/* Output a marker (i.e. a label) for the absolute end of the generated code - for a function definition. This gets called *after* the epilogue code has - been generated. */ - -void -dwarf2out_end_epilogue () -{ - dw_fde_ref fde; - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - - /* Output a label to mark the endpoint of the code generated for this - function. */ - ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number); - ASM_OUTPUT_LABEL (asm_out_file, label); - fde = &fde_table[fde_table_in_use - 1]; - fde->dw_fde_end = xstrdup (label); -} - -void -dwarf2out_frame_init () -{ - /* Allocate the initial hunk of the fde_table. */ - fde_table - = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); - zero_memory ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node)); - fde_table_allocated = FDE_TABLE_INCREMENT; - fde_table_in_use = 0; - - /* Generate the CFA instructions common to all FDE's. Do it now for the - sake of lookup_cfa. */ - -#ifdef DWARF2_UNWIND_INFO - /* On entry, the Canonical Frame Address is at SP. */ - dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET); - initial_return_save (INCOMING_RETURN_ADDR_RTX); -#endif -} - -void -dwarf2out_frame_finish () -{ - /* Output call frame information. */ -#ifdef MIPS_DEBUGGING_INFO - if (write_symbols == DWARF2_DEBUG) - output_call_frame_info (0); - if (flag_exceptions && ! exceptions_via_longjmp) - output_call_frame_info (1); -#else - if (write_symbols == DWARF2_DEBUG - || (flag_exceptions && ! exceptions_via_longjmp)) - output_call_frame_info (1); -#endif -} - -#endif /* .debug_frame support */ - -/* And now, the support for symbolic debugging information. */ -#ifdef DWARF2_DEBUGGING_INFO - -extern char *getpwd PROTO((void)); - -/* NOTE: In the comments in this file, many references are made to - "Debugging Information Entries". This term is abbreviated as `DIE' - throughout the remainder of this file. */ - -/* An internal representation of the DWARF output is built, and then - walked to generate the DWARF debugging info. The walk of the internal - representation is done after the entire program has been compiled. - The types below are used to describe the internal representation. */ - -/* Each DIE may have a series of attribute/value pairs. Values - can take on several forms. The forms that are used in this - implementation are listed below. */ - -typedef enum -{ - dw_val_class_addr, - dw_val_class_loc, - dw_val_class_const, - dw_val_class_unsigned_const, - dw_val_class_long_long, - dw_val_class_float, - dw_val_class_flag, - dw_val_class_die_ref, - dw_val_class_fde_ref, - dw_val_class_lbl_id, - dw_val_class_section_offset, - dw_val_class_str -} -dw_val_class; - -/* Various DIE's use offsets relative to the beginning of the - .debug_info section to refer to each other. */ - -typedef long int dw_offset; - -/* Define typedefs here to avoid circular dependencies. */ - -typedef struct die_struct *dw_die_ref; -typedef struct dw_attr_struct *dw_attr_ref; -typedef struct dw_val_struct *dw_val_ref; -typedef struct dw_line_info_struct *dw_line_info_ref; -typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref; -typedef struct dw_loc_descr_struct *dw_loc_descr_ref; -typedef struct pubname_struct *pubname_ref; -typedef dw_die_ref *arange_ref; - -/* Describe a double word constant value. */ - -typedef struct dw_long_long_struct -{ - unsigned long hi; - unsigned long low; -} -dw_long_long_const; - -/* Describe a floating point constant value. */ - -typedef struct dw_fp_struct -{ - long *array; - unsigned length; -} -dw_float_const; - -/* Each entry in the line_info_table maintains the file and - line number associated with the label generated for that - entry. The label gives the PC value associated with - the line number entry. */ - -typedef struct dw_line_info_struct -{ - unsigned long dw_file_num; - unsigned long dw_line_num; -} -dw_line_info_entry; - -/* Line information for functions in separate sections; each one gets its - own sequence. */ -typedef struct dw_separate_line_info_struct -{ - unsigned long dw_file_num; - unsigned long dw_line_num; - unsigned long function; -} -dw_separate_line_info_entry; - -/* The dw_val_node describes an attribute's value, as it is - represented internally. */ - -typedef struct dw_val_struct -{ - dw_val_class val_class; - union - { - rtx val_addr; - dw_loc_descr_ref val_loc; - long int val_int; - long unsigned val_unsigned; - dw_long_long_const val_long_long; - dw_float_const val_float; - dw_die_ref val_die_ref; - unsigned val_fde_index; - char *val_str; - char *val_lbl_id; - char *val_section; - unsigned char val_flag; - } - v; -} -dw_val_node; - -/* Locations in memory are described using a sequence of stack machine - operations. */ - -typedef struct dw_loc_descr_struct -{ - dw_loc_descr_ref dw_loc_next; - enum dwarf_location_atom dw_loc_opc; - dw_val_node dw_loc_oprnd1; - dw_val_node dw_loc_oprnd2; -} -dw_loc_descr_node; - -/* Each DIE attribute has a field specifying the attribute kind, - a link to the next attribute in the chain, and an attribute value. - Attributes are typically linked below the DIE they modify. */ - -typedef struct dw_attr_struct -{ - enum dwarf_attribute dw_attr; - dw_attr_ref dw_attr_next; - dw_val_node dw_attr_val; -} -dw_attr_node; - -/* The Debugging Information Entry (DIE) structure */ - -typedef struct die_struct -{ - enum dwarf_tag die_tag; - dw_attr_ref die_attr; - dw_attr_ref die_attr_last; - dw_die_ref die_parent; - dw_die_ref die_child; - dw_die_ref die_child_last; - dw_die_ref die_sib; - dw_offset die_offset; - unsigned long die_abbrev; -} -die_node; - -/* The pubname structure */ - -typedef struct pubname_struct -{ - dw_die_ref die; - char * name; -} -pubname_entry; - -/* The limbo die list structure. */ -typedef struct limbo_die_struct -{ - dw_die_ref die; - struct limbo_die_struct *next; -} -limbo_die_node; - -/* How to start an assembler comment. */ -#ifndef ASM_COMMENT_START -#define ASM_COMMENT_START ";#" -#endif - -/* Define a macro which returns non-zero for a TYPE_DECL which was - implicitly generated for a tagged type. - - Note that unlike the gcc front end (which generates a NULL named - TYPE_DECL node for each complete tagged type, each array type, and - each function type node created) the g++ front end generates a - _named_ TYPE_DECL node for each tagged type node created. - These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to - generate a DW_TAG_typedef DIE for them. */ - -#define TYPE_DECL_IS_STUB(decl) \ - (DECL_NAME (decl) == NULL_TREE \ - || (DECL_ARTIFICIAL (decl) \ - && is_tagged_type (TREE_TYPE (decl)) \ - && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \ - /* This is necessary for stub decls that \ - appear in nested inline functions. */ \ - || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \ - && (decl_ultimate_origin (decl) \ - == TYPE_STUB_DECL (TREE_TYPE (decl))))))) - -/* Information concerning the compilation unit's programming - language, and compiler version. */ - -extern int flag_traditional; -extern char *version_string; -extern char *language_string; - -/* Fixed size portion of the DWARF compilation unit header. */ -#define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3) - -/* Fixed size portion of debugging line information prolog. */ -#define DWARF_LINE_PROLOG_HEADER_SIZE 5 - -/* Fixed size portion of public names info. */ -#define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2) - -/* Fixed size portion of the address range info. */ -#define DWARF_ARANGES_HEADER_SIZE \ - (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE) - -/* Define the architecture-dependent minimum instruction length (in bytes). - In this implementation of DWARF, this field is used for information - purposes only. Since GCC generates assembly language, we have - no a priori knowledge of how many instruction bytes are generated - for each source line, and therefore can use only the DW_LNE_set_address - and DW_LNS_fixed_advance_pc line information commands. */ - -#ifndef DWARF_LINE_MIN_INSTR_LENGTH -#define DWARF_LINE_MIN_INSTR_LENGTH 4 -#endif - -/* Minimum line offset in a special line info. opcode. - This value was chosen to give a reasonable range of values. */ -#define DWARF_LINE_BASE -10 - -/* First special line opcde - leave room for the standard opcodes. */ -#define DWARF_LINE_OPCODE_BASE 10 - -/* Range of line offsets in a special line info. opcode. */ -#define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1) - -/* Flag that indicates the initial value of the is_stmt_start flag. - In the present implementation, we do not mark any lines as - the beginning of a source statement, because that information - is not made available by the GCC front-end. */ -#define DWARF_LINE_DEFAULT_IS_STMT_START 1 - -/* This location is used by calc_die_sizes() to keep track - the offset of each DIE within the .debug_info section. */ -static unsigned long next_die_offset; - -/* Record the root of the DIE's built for the current compilation unit. */ -static dw_die_ref comp_unit_die; - -/* A list of DIEs with a NULL parent waiting to be relocated. */ -static limbo_die_node *limbo_die_list = 0; - -/* Pointer to an array of filenames referenced by this compilation unit. */ -static char **file_table; - -/* Total number of entries in the table (i.e. array) pointed to by - `file_table'. This is the *total* and includes both used and unused - slots. */ -static unsigned file_table_allocated; - -/* Number of entries in the file_table which are actually in use. */ -static unsigned file_table_in_use; - -/* Size (in elements) of increments by which we may expand the filename - table. */ -#define FILE_TABLE_INCREMENT 64 - -/* Local pointer to the name of the main input file. Initialized in - dwarf2out_init. */ -static char *primary_filename; - -/* For Dwarf output, we must assign lexical-blocks id numbers in the order in - which their beginnings are encountered. We output Dwarf debugging info - that refers to the beginnings and ends of the ranges of code for each - lexical block. The labels themselves are generated in final.c, which - assigns numbers to the blocks in the same way. */ -static unsigned next_block_number = 2; - -/* A pointer to the base of a table of references to DIE's that describe - declarations. The table is indexed by DECL_UID() which is a unique - number identifying each decl. */ -static dw_die_ref *decl_die_table; - -/* Number of elements currently allocated for the decl_die_table. */ -static unsigned decl_die_table_allocated; - -/* Number of elements in decl_die_table currently in use. */ -static unsigned decl_die_table_in_use; - -/* Size (in elements) of increments by which we may expand the - decl_die_table. */ -#define DECL_DIE_TABLE_INCREMENT 256 - -/* Structure used for the decl_scope table. scope is the current declaration - scope, and previous is the entry that is the parent of this scope. This - is usually but not always the immediately preceeding entry. */ - -typedef struct decl_scope_struct -{ - tree scope; - int previous; -} -decl_scope_node; - -/* A pointer to the base of a table of references to declaration - scopes. This table is a display which tracks the nesting - of declaration scopes at the current scope and containing - scopes. This table is used to find the proper place to - define type declaration DIE's. */ -static decl_scope_node *decl_scope_table; - -/* Number of elements currently allocated for the decl_scope_table. */ -static int decl_scope_table_allocated; - -/* Current level of nesting of declaration scopes. */ -static int decl_scope_depth; - -/* Size (in elements) of increments by which we may expand the - decl_scope_table. */ -#define DECL_SCOPE_TABLE_INCREMENT 64 - -/* A pointer to the base of a list of references to DIE's that - are uniquely identified by their tag, presence/absence of - children DIE's, and list of attribute/value pairs. */ -static dw_die_ref *abbrev_die_table; - -/* Number of elements currently allocated for abbrev_die_table. */ -static unsigned abbrev_die_table_allocated; - -/* Number of elements in type_die_table currently in use. */ -static unsigned abbrev_die_table_in_use; - -/* Size (in elements) of increments by which we may expand the - abbrev_die_table. */ -#define ABBREV_DIE_TABLE_INCREMENT 256 - -/* A pointer to the base of a table that contains line information - for each source code line in .text in the compilation unit. */ -static dw_line_info_ref line_info_table; - -/* Number of elements currently allocated for line_info_table. */ -static unsigned line_info_table_allocated; - -/* Number of elements in separate_line_info_table currently in use. */ -static unsigned separate_line_info_table_in_use; - -/* A pointer to the base of a table that contains line information - for each source code line outside of .text in the compilation unit. */ -static dw_separate_line_info_ref separate_line_info_table; - -/* Number of elements currently allocated for separate_line_info_table. */ -static unsigned separate_line_info_table_allocated; - -/* Number of elements in line_info_table currently in use. */ -static unsigned line_info_table_in_use; - -/* Size (in elements) of increments by which we may expand the - line_info_table. */ -#define LINE_INFO_TABLE_INCREMENT 1024 - -/* A pointer to the base of a table that contains a list of publicly - accessible names. */ -static pubname_ref pubname_table; - -/* Number of elements currently allocated for pubname_table. */ -static unsigned pubname_table_allocated; - -/* Number of elements in pubname_table currently in use. */ -static unsigned pubname_table_in_use; - -/* Size (in elements) of increments by which we may expand the - pubname_table. */ -#define PUBNAME_TABLE_INCREMENT 64 - -/* A pointer to the base of a table that contains a list of publicly - accessible names. */ -static arange_ref arange_table; - -/* Number of elements currently allocated for arange_table. */ -static unsigned arange_table_allocated; - -/* Number of elements in arange_table currently in use. */ -static unsigned arange_table_in_use; - -/* Size (in elements) of increments by which we may expand the - arange_table. */ -#define ARANGE_TABLE_INCREMENT 64 - -/* A pointer to the base of a list of pending types which we haven't - generated DIEs for yet, but which we will have to come back to - later on. */ - -static tree *pending_types_list; - -/* Number of elements currently allocated for the pending_types_list. */ -static unsigned pending_types_allocated; - -/* Number of elements of pending_types_list currently in use. */ -static unsigned pending_types; - -/* Size (in elements) of increments by which we may expand the pending - types list. Actually, a single hunk of space of this size should - be enough for most typical programs. */ -#define PENDING_TYPES_INCREMENT 64 - -/* Record whether the function being analyzed contains inlined functions. */ -static int current_function_has_inlines; -#if 0 && defined (MIPS_DEBUGGING_INFO) -static int comp_unit_has_inlines; -#endif - -/* A pointer to the ..._DECL node which we have most recently been working - on. We keep this around just in case something about it looks screwy and - we want to tell the user what the source coordinates for the actual - declaration are. */ -static tree dwarf_last_decl; - -/* Forward declarations for functions defined in this file. */ - -static void addr_const_to_string PROTO((dyn_string_t, rtx)); -static int is_pseudo_reg PROTO((rtx)); -static tree type_main_variant PROTO((tree)); -static int is_tagged_type PROTO((tree)); -static char *dwarf_tag_name PROTO((unsigned)); -static char *dwarf_attr_name PROTO((unsigned)); -static char *dwarf_form_name PROTO((unsigned)); -static char *dwarf_stack_op_name PROTO((unsigned)); -#if 0 -static char *dwarf_type_encoding_name PROTO((unsigned)); -#endif -static tree decl_ultimate_origin PROTO((tree)); -static tree block_ultimate_origin PROTO((tree)); -static tree decl_class_context PROTO((tree)); -static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref)); -static void add_AT_flag PROTO((dw_die_ref, - enum dwarf_attribute, - unsigned)); -static void add_AT_int PROTO((dw_die_ref, - enum dwarf_attribute, long)); -static void add_AT_unsigned PROTO((dw_die_ref, - enum dwarf_attribute, - unsigned long)); -static void add_AT_long_long PROTO((dw_die_ref, - enum dwarf_attribute, - unsigned long, unsigned long)); -static void add_AT_float PROTO((dw_die_ref, - enum dwarf_attribute, - unsigned, long *)); -static void add_AT_string PROTO((dw_die_ref, - enum dwarf_attribute, char *)); -static void add_AT_die_ref PROTO((dw_die_ref, - enum dwarf_attribute, - dw_die_ref)); -static void add_AT_fde_ref PROTO((dw_die_ref, - enum dwarf_attribute, - unsigned)); -static void add_AT_loc PROTO((dw_die_ref, - enum dwarf_attribute, - dw_loc_descr_ref)); -static void add_AT_addr PROTO((dw_die_ref, - enum dwarf_attribute, rtx)); -static void add_AT_lbl_id PROTO((dw_die_ref, - enum dwarf_attribute, char *)); -static void add_AT_section_offset PROTO((dw_die_ref, - enum dwarf_attribute, char *)); -static int is_extern_subr_die PROTO((dw_die_ref)); -static dw_attr_ref get_AT PROTO((dw_die_ref, - enum dwarf_attribute)); -static char *get_AT_low_pc PROTO((dw_die_ref)); -static char *get_AT_hi_pc PROTO((dw_die_ref)); -static char *get_AT_string PROTO((dw_die_ref, - enum dwarf_attribute)); -static int get_AT_flag PROTO((dw_die_ref, - enum dwarf_attribute)); -static unsigned get_AT_unsigned PROTO((dw_die_ref, - enum dwarf_attribute)); -static int is_c_family PROTO((void)); -static int is_fortran PROTO((void)); -static void remove_AT PROTO((dw_die_ref, - enum dwarf_attribute)); -static void remove_children PROTO((dw_die_ref)); -static void add_child_die PROTO((dw_die_ref, dw_die_ref)); -static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref)); -static dw_die_ref lookup_type_die PROTO((tree)); -static void equate_type_number_to_die PROTO((tree, dw_die_ref)); -static dw_die_ref lookup_decl_die PROTO((tree)); -static void equate_decl_number_to_die PROTO((tree, dw_die_ref)); -static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom, - unsigned long, unsigned long)); -static void add_loc_descr PROTO((dw_loc_descr_ref *, - dw_loc_descr_ref)); -static void print_spaces PROTO((FILE *)); -static void print_die PROTO((dw_die_ref, FILE *)); -static void print_dwarf_line_table PROTO((FILE *)); -static void add_sibling_attributes PROTO((dw_die_ref)); -static void build_abbrev_table PROTO((dw_die_ref)); -static unsigned long size_of_string PROTO((char *)); -static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref)); -static unsigned long size_of_locs PROTO((dw_loc_descr_ref)); -static int constant_size PROTO((long unsigned)); -static unsigned long size_of_die PROTO((dw_die_ref)); -static void calc_die_sizes PROTO((dw_die_ref)); -static unsigned long size_of_line_prolog PROTO((void)); -static unsigned long size_of_line_info PROTO((void)); -static unsigned long size_of_pubnames PROTO((void)); -static unsigned long size_of_aranges PROTO((void)); -static enum dwarf_form value_format PROTO((dw_val_ref)); -static void output_value_format PROTO((dw_val_ref)); -static void output_abbrev_section PROTO((void)); -static void output_loc_operands PROTO((dw_loc_descr_ref)); -static unsigned long sibling_offset PROTO((dw_die_ref)); -static void output_die PROTO((dw_die_ref)); -static void output_compilation_unit_header PROTO((void)); -static char *dwarf2_name PROTO((tree, int)); -static void add_pubname PROTO((tree, dw_die_ref)); -static void output_pubnames PROTO((void)); -static void add_arange PROTO((tree, dw_die_ref)); -static void output_aranges PROTO((void)); -static void output_line_info PROTO((void)); -static int is_body_block PROTO((tree)); -static dw_die_ref base_type_die PROTO((tree)); -static tree root_type PROTO((tree)); -static int is_base_type PROTO((tree)); -static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref)); -static int type_is_enum PROTO((tree)); -static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx)); -static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long)); -static int is_based_loc PROTO((rtx)); -static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx)); -static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx)); -static dw_loc_descr_ref loc_descriptor PROTO((rtx)); -static unsigned ceiling PROTO((unsigned, unsigned)); -static tree field_type PROTO((tree)); -static unsigned simple_type_align_in_bits PROTO((tree)); -static unsigned simple_type_size_in_bits PROTO((tree)); -static unsigned field_byte_offset PROTO((tree)); -static void add_AT_location_description PROTO((dw_die_ref, - enum dwarf_attribute, rtx)); -static void add_data_member_location_attribute PROTO((dw_die_ref, tree)); -static void add_const_value_attribute PROTO((dw_die_ref, rtx)); -static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree)); -static void add_name_attribute PROTO((dw_die_ref, char *)); -static void add_bound_info PROTO((dw_die_ref, - enum dwarf_attribute, tree)); -static void add_subscript_info PROTO((dw_die_ref, tree)); -static void add_byte_size_attribute PROTO((dw_die_ref, tree)); -static void add_bit_offset_attribute PROTO((dw_die_ref, tree)); -static void add_bit_size_attribute PROTO((dw_die_ref, tree)); -static void add_prototyped_attribute PROTO((dw_die_ref, tree)); -static void add_abstract_origin_attribute PROTO((dw_die_ref, tree)); -static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree)); -static void add_src_coords_attributes PROTO((dw_die_ref, tree)); -static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree)); -static void push_decl_scope PROTO((tree)); -static dw_die_ref scope_die_for PROTO((tree, dw_die_ref)); -static void pop_decl_scope PROTO((void)); -static void add_type_attribute PROTO((dw_die_ref, tree, int, int, - dw_die_ref)); -static char *type_tag PROTO((tree)); -static tree member_declared_type PROTO((tree)); -#if 0 -static char *decl_start_label PROTO((tree)); -#endif -static void gen_array_type_die PROTO((tree, dw_die_ref)); -static void gen_set_type_die PROTO((tree, dw_die_ref)); -#if 0 -static void gen_entry_point_die PROTO((tree, dw_die_ref)); -#endif -static void pend_type PROTO((tree)); -static void output_pending_types_for_scope PROTO((dw_die_ref)); -static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref)); -static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref)); -static void gen_inlined_union_type_die PROTO((tree, dw_die_ref)); -static void gen_enumeration_type_die PROTO((tree, dw_die_ref)); -static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref)); -static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref)); -static void gen_formal_types_die PROTO((tree, dw_die_ref)); -static void gen_subprogram_die PROTO((tree, dw_die_ref)); -static void gen_variable_die PROTO((tree, dw_die_ref)); -static void gen_label_die PROTO((tree, dw_die_ref)); -static void gen_lexical_block_die PROTO((tree, dw_die_ref, int)); -static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int)); -static void gen_field_die PROTO((tree, dw_die_ref)); -static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref)); -static void gen_compile_unit_die PROTO((char *)); -static void gen_string_type_die PROTO((tree, dw_die_ref)); -static void gen_inheritance_die PROTO((tree, dw_die_ref)); -static void gen_member_die PROTO((tree, dw_die_ref)); -static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref)); -static void gen_subroutine_type_die PROTO((tree, dw_die_ref)); -static void gen_typedef_die PROTO((tree, dw_die_ref)); -static void gen_type_die PROTO((tree, dw_die_ref)); -static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref)); -static void gen_block_die PROTO((tree, dw_die_ref, int)); -static void decls_for_scope PROTO((tree, dw_die_ref, int)); -static int is_redundant_typedef PROTO((tree)); -static void gen_decl_die PROTO((tree, dw_die_ref)); -static unsigned lookup_filename PROTO((char *)); -static rtx save_rtx PROTO((rtx)); - -/* Section names used to hold DWARF debugging information. */ -#ifndef DEBUG_INFO_SECTION -#define DEBUG_INFO_SECTION ".debug_info" -#endif -#ifndef ABBREV_SECTION -#define ABBREV_SECTION ".debug_abbrev" -#endif -#ifndef ARANGES_SECTION -#define ARANGES_SECTION ".debug_aranges" -#endif -#ifndef DW_MACINFO_SECTION -#define DW_MACINFO_SECTION ".debug_macinfo" -#endif -#ifndef DEBUG_LINE_SECTION -#define DEBUG_LINE_SECTION ".debug_line" -#endif -#ifndef LOC_SECTION -#define LOC_SECTION ".debug_loc" -#endif -#ifndef PUBNAMES_SECTION -#define PUBNAMES_SECTION ".debug_pubnames" -#endif -#ifndef STR_SECTION -#define STR_SECTION ".debug_str" -#endif - -/* Standard ELF section names for compiled code and data. */ -#ifndef TEXT_SECTION -#define TEXT_SECTION ".text" -#endif -#ifndef DATA_SECTION -#define DATA_SECTION ".data" -#endif -#ifndef BSS_SECTION -#define BSS_SECTION ".bss" -#endif - - -/* Definitions of defaults for formats and names of various special - (artificial) labels which may be generated within this file (when the -g - options is used and DWARF_DEBUGGING_INFO is in effect. - If necessary, these may be overridden from within the tm.h file, but - typically, overriding these defaults is unnecessary. */ - -static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; - -#ifndef TEXT_END_LABEL -#define TEXT_END_LABEL "Letext" -#endif -#ifndef DATA_END_LABEL -#define DATA_END_LABEL "Ledata" -#endif -#ifndef BSS_END_LABEL -#define BSS_END_LABEL "Lebss" -#endif -#ifndef INSN_LABEL_FMT -#define INSN_LABEL_FMT "LI%u_" -#endif -#ifndef BLOCK_BEGIN_LABEL -#define BLOCK_BEGIN_LABEL "LBB" -#endif -#ifndef BLOCK_END_LABEL -#define BLOCK_END_LABEL "LBE" -#endif -#ifndef BODY_BEGIN_LABEL -#define BODY_BEGIN_LABEL "Lbb" -#endif -#ifndef BODY_END_LABEL -#define BODY_END_LABEL "Lbe" -#endif -#ifndef LINE_CODE_LABEL -#define LINE_CODE_LABEL "LM" -#endif -#ifndef SEPARATE_LINE_CODE_LABEL -#define SEPARATE_LINE_CODE_LABEL "LSM" -#endif - -/* Convert a reference to the assembler name of a C-level name. This - macro has the same effect as ASM_OUTPUT_LABELREF, but copies to - a string rather than writing to a file. */ -#ifndef ASM_NAME_TO_STRING -#define ASM_NAME_TO_STRING(STR, NAME) \ - do { \ - if ((NAME)[0] == '*') \ - dyn_string_append (STR, NAME + 1); \ - else \ - { \ - dyn_string_append (STR, user_label_prefix); \ - dyn_string_append (STR, NAME); \ - } \ - } \ - while (0) -#endif - -/* Convert an integer constant expression into assembler syntax. Addition - and subtraction are the only arithmetic that may appear in these - expressions. This is an adaptation of output_addr_const in final.c. - Here, the target of the conversion is a string buffer. We can't use - output_addr_const directly, because it writes to a file. */ - -static void -addr_const_to_string (str, x) - dyn_string_t str; - rtx x; -{ - char buf1[256]; - -restart: - switch (GET_CODE (x)) - { - case PC: - if (flag_pic) - dyn_string_append (str, ","); - else - abort (); - break; - - case SYMBOL_REF: - ASM_NAME_TO_STRING (str, XSTR (x, 0)); - break; - - case LABEL_REF: - ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0))); - ASM_NAME_TO_STRING (str, buf1); - break; - - case CODE_LABEL: - ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x)); - ASM_NAME_TO_STRING (str, buf1); - break; - - case CONST_INT: - sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x)); - dyn_string_append (str, buf1); - break; - - case CONST: - /* This used to output parentheses around the expression, but that does - not work on the 386 (either ATT or BSD assembler). */ - addr_const_to_string (str, XEXP (x, 0)); - break; - - case CONST_DOUBLE: - if (GET_MODE (x) == VOIDmode) - { - /* We can use %d if the number is one word and positive. */ - if (CONST_DOUBLE_HIGH (x)) - sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX, - CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x)); - else if (CONST_DOUBLE_LOW (x) < 0) - sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x)); - else - sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, - CONST_DOUBLE_LOW (x)); - dyn_string_append (str, buf1); - } - else - /* We can't handle floating point constants; PRINT_OPERAND must - handle them. */ - output_operand_lossage ("floating constant misused"); - break; - - case PLUS: - /* Some assemblers need integer constants to appear last (eg masm). */ - if (GET_CODE (XEXP (x, 0)) == CONST_INT) - { - addr_const_to_string (str, XEXP (x, 1)); - if (INTVAL (XEXP (x, 0)) >= 0) - dyn_string_append (str, "+"); - - addr_const_to_string (str, XEXP (x, 0)); - } - else - { - addr_const_to_string (str, XEXP (x, 0)); - if (INTVAL (XEXP (x, 1)) >= 0) - dyn_string_append (str, "+"); - - addr_const_to_string (str, XEXP (x, 1)); - } - break; - - case MINUS: - /* Avoid outputting things like x-x or x+5-x, since some assemblers - can't handle that. */ - x = simplify_subtraction (x); - if (GET_CODE (x) != MINUS) - goto restart; - - addr_const_to_string (str, XEXP (x, 0)); - dyn_string_append (str, "-"); - if (GET_CODE (XEXP (x, 1)) == CONST_INT - && INTVAL (XEXP (x, 1)) < 0) - { - dyn_string_append (str, ASM_OPEN_PAREN); - addr_const_to_string (str, XEXP (x, 1)); - dyn_string_append (str, ASM_CLOSE_PAREN); - } - else - addr_const_to_string (str, XEXP (x, 1)); - break; - - case ZERO_EXTEND: - case SIGN_EXTEND: - addr_const_to_string (str, XEXP (x, 0)); - break; - - default: - output_operand_lossage ("invalid expression as operand"); - } -} - -/* Return an rtx like ORIG which lives forever. That means making a - copy on the permanent_obstack. */ - -static rtx -save_rtx (orig) - register rtx orig; -{ - push_obstacks_nochange (); - end_temporary_allocation (); - orig = really_copy_rtx (orig); - pop_obstacks (); - - return orig; -} - -/* Test if rtl node points to a pseudo register. */ - -static inline int -is_pseudo_reg (rtl) - register rtx rtl; -{ - return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)) - || ((GET_CODE (rtl) == SUBREG) - && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER))); -} - -/* Return a reference to a type, with its const and volatile qualifiers - removed. */ - -static inline tree -type_main_variant (type) - register tree type; -{ - type = TYPE_MAIN_VARIANT (type); - - /* There really should be only one main variant among any group of variants - of a given type (and all of the MAIN_VARIANT values for all members of - the group should point to that one type) but sometimes the C front-end - messes this up for array types, so we work around that bug here. */ - - if (TREE_CODE (type) == ARRAY_TYPE) - while (type != TYPE_MAIN_VARIANT (type)) - type = TYPE_MAIN_VARIANT (type); - - return type; -} - -/* Return non-zero if the given type node represents a tagged type. */ - -static inline int -is_tagged_type (type) - register tree type; -{ - register enum tree_code code = TREE_CODE (type); - - return (code == RECORD_TYPE || code == UNION_TYPE - || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE); -} - -/* Convert a DIE tag into its string name. */ - -static char * -dwarf_tag_name (tag) - register unsigned tag; -{ - switch (tag) - { - case DW_TAG_padding: - return "DW_TAG_padding"; - case DW_TAG_array_type: - return "DW_TAG_array_type"; - case DW_TAG_class_type: - return "DW_TAG_class_type"; - case DW_TAG_entry_point: - return "DW_TAG_entry_point"; - case DW_TAG_enumeration_type: - return "DW_TAG_enumeration_type"; - case DW_TAG_formal_parameter: - return "DW_TAG_formal_parameter"; - case DW_TAG_imported_declaration: - return "DW_TAG_imported_declaration"; - case DW_TAG_label: - return "DW_TAG_label"; - case DW_TAG_lexical_block: - return "DW_TAG_lexical_block"; - case DW_TAG_member: - return "DW_TAG_member"; - case DW_TAG_pointer_type: - return "DW_TAG_pointer_type"; - case DW_TAG_reference_type: - return "DW_TAG_reference_type"; - case DW_TAG_compile_unit: - return "DW_TAG_compile_unit"; - case DW_TAG_string_type: - return "DW_TAG_string_type"; - case DW_TAG_structure_type: - return "DW_TAG_structure_type"; - case DW_TAG_subroutine_type: - return "DW_TAG_subroutine_type"; - case DW_TAG_typedef: - return "DW_TAG_typedef"; - case DW_TAG_union_type: - return "DW_TAG_union_type"; - case DW_TAG_unspecified_parameters: - return "DW_TAG_unspecified_parameters"; - case DW_TAG_variant: - return "DW_TAG_variant"; - case DW_TAG_common_block: - return "DW_TAG_common_block"; - case DW_TAG_common_inclusion: - return "DW_TAG_common_inclusion"; - case DW_TAG_inheritance: - return "DW_TAG_inheritance"; - case DW_TAG_inlined_subroutine: - return "DW_TAG_inlined_subroutine"; - case DW_TAG_module: - return "DW_TAG_module"; - case DW_TAG_ptr_to_member_type: - return "DW_TAG_ptr_to_member_type"; - case DW_TAG_set_type: - return "DW_TAG_set_type"; - case DW_TAG_subrange_type: - return "DW_TAG_subrange_type"; - case DW_TAG_with_stmt: - return "DW_TAG_with_stmt"; - case DW_TAG_access_declaration: - return "DW_TAG_access_declaration"; - case DW_TAG_base_type: - return "DW_TAG_base_type"; - case DW_TAG_catch_block: - return "DW_TAG_catch_block"; - case DW_TAG_const_type: - return "DW_TAG_const_type"; - case DW_TAG_constant: - return "DW_TAG_constant"; - case DW_TAG_enumerator: - return "DW_TAG_enumerator"; - case DW_TAG_file_type: - return "DW_TAG_file_type"; - case DW_TAG_friend: - return "DW_TAG_friend"; - case DW_TAG_namelist: - return "DW_TAG_namelist"; - case DW_TAG_namelist_item: - return "DW_TAG_namelist_item"; - case DW_TAG_packed_type: - return "DW_TAG_packed_type"; - case DW_TAG_subprogram: - return "DW_TAG_subprogram"; - case DW_TAG_template_type_param: - return "DW_TAG_template_type_param"; - case DW_TAG_template_value_param: - return "DW_TAG_template_value_param"; - case DW_TAG_thrown_type: - return "DW_TAG_thrown_type"; - case DW_TAG_try_block: - return "DW_TAG_try_block"; - case DW_TAG_variant_part: - return "DW_TAG_variant_part"; - case DW_TAG_variable: - return "DW_TAG_variable"; - case DW_TAG_volatile_type: - return "DW_TAG_volatile_type"; - case DW_TAG_MIPS_loop: - return "DW_TAG_MIPS_loop"; - case DW_TAG_format_label: - return "DW_TAG_format_label"; - case DW_TAG_function_template: - return "DW_TAG_function_template"; - case DW_TAG_class_template: - return "DW_TAG_class_template"; - default: - return "DW_TAG_<unknown>"; - } -} - -/* Convert a DWARF attribute code into its string name. */ - -static char * -dwarf_attr_name (attr) - register unsigned attr; -{ - switch (attr) - { - case DW_AT_sibling: - return "DW_AT_sibling"; - case DW_AT_location: - return "DW_AT_location"; - case DW_AT_name: - return "DW_AT_name"; - case DW_AT_ordering: - return "DW_AT_ordering"; - case DW_AT_subscr_data: - return "DW_AT_subscr_data"; - case DW_AT_byte_size: - return "DW_AT_byte_size"; - case DW_AT_bit_offset: - return "DW_AT_bit_offset"; - case DW_AT_bit_size: - return "DW_AT_bit_size"; - case DW_AT_element_list: - return "DW_AT_element_list"; - case DW_AT_stmt_list: - return "DW_AT_stmt_list"; - case DW_AT_low_pc: - return "DW_AT_low_pc"; - case DW_AT_high_pc: - return "DW_AT_high_pc"; - case DW_AT_language: - return "DW_AT_language"; - case DW_AT_member: - return "DW_AT_member"; - case DW_AT_discr: - return "DW_AT_discr"; - case DW_AT_discr_value: - return "DW_AT_discr_value"; - case DW_AT_visibility: - return "DW_AT_visibility"; - case DW_AT_import: - return "DW_AT_import"; - case DW_AT_string_length: - return "DW_AT_string_length"; - case DW_AT_common_reference: - return "DW_AT_common_reference"; - case DW_AT_comp_dir: - return "DW_AT_comp_dir"; - case DW_AT_const_value: - return "DW_AT_const_value"; - case DW_AT_containing_type: - return "DW_AT_containing_type"; - case DW_AT_default_value: - return "DW_AT_default_value"; - case DW_AT_inline: - return "DW_AT_inline"; - case DW_AT_is_optional: - return "DW_AT_is_optional"; - case DW_AT_lower_bound: - return "DW_AT_lower_bound"; - case DW_AT_producer: - return "DW_AT_producer"; - case DW_AT_prototyped: - return "DW_AT_prototyped"; - case DW_AT_return_addr: - return "DW_AT_return_addr"; - case DW_AT_start_scope: - return "DW_AT_start_scope"; - case DW_AT_stride_size: - return "DW_AT_stride_size"; - case DW_AT_upper_bound: - return "DW_AT_upper_bound"; - case DW_AT_abstract_origin: - return "DW_AT_abstract_origin"; - case DW_AT_accessibility: - return "DW_AT_accessibility"; - case DW_AT_address_class: - return "DW_AT_address_class"; - case DW_AT_artificial: - return "DW_AT_artificial"; - case DW_AT_base_types: - return "DW_AT_base_types"; - case DW_AT_calling_convention: - return "DW_AT_calling_convention"; - case DW_AT_count: - return "DW_AT_count"; - case DW_AT_data_member_location: - return "DW_AT_data_member_location"; - case DW_AT_decl_column: - return "DW_AT_decl_column"; - case DW_AT_decl_file: - return "DW_AT_decl_file"; - case DW_AT_decl_line: - return "DW_AT_decl_line"; - case DW_AT_declaration: - return "DW_AT_declaration"; - case DW_AT_discr_list: - return "DW_AT_discr_list"; - case DW_AT_encoding: - return "DW_AT_encoding"; - case DW_AT_external: - return "DW_AT_external"; - case DW_AT_frame_base: - return "DW_AT_frame_base"; - case DW_AT_friend: - return "DW_AT_friend"; - case DW_AT_identifier_case: - return "DW_AT_identifier_case"; - case DW_AT_macro_info: - return "DW_AT_macro_info"; - case DW_AT_namelist_items: - return "DW_AT_namelist_items"; - case DW_AT_priority: - return "DW_AT_priority"; - case DW_AT_segment: - return "DW_AT_segment"; - case DW_AT_specification: - return "DW_AT_specification"; - case DW_AT_static_link: - return "DW_AT_static_link"; - case DW_AT_type: - return "DW_AT_type"; - case DW_AT_use_location: - return "DW_AT_use_location"; - case DW_AT_variable_parameter: - return "DW_AT_variable_parameter"; - case DW_AT_virtuality: - return "DW_AT_virtuality"; - case DW_AT_vtable_elem_location: - return "DW_AT_vtable_elem_location"; - - case DW_AT_MIPS_fde: - return "DW_AT_MIPS_fde"; - case DW_AT_MIPS_loop_begin: - return "DW_AT_MIPS_loop_begin"; - case DW_AT_MIPS_tail_loop_begin: - return "DW_AT_MIPS_tail_loop_begin"; - case DW_AT_MIPS_epilog_begin: - return "DW_AT_MIPS_epilog_begin"; - case DW_AT_MIPS_loop_unroll_factor: - return "DW_AT_MIPS_loop_unroll_factor"; - case DW_AT_MIPS_software_pipeline_depth: - return "DW_AT_MIPS_software_pipeline_depth"; - case DW_AT_MIPS_linkage_name: - return "DW_AT_MIPS_linkage_name"; - case DW_AT_MIPS_stride: - return "DW_AT_MIPS_stride"; - case DW_AT_MIPS_abstract_name: - return "DW_AT_MIPS_abstract_name"; - case DW_AT_MIPS_clone_origin: - return "DW_AT_MIPS_clone_origin"; - case DW_AT_MIPS_has_inlines: - return "DW_AT_MIPS_has_inlines"; - - case DW_AT_sf_names: - return "DW_AT_sf_names"; - case DW_AT_src_info: - return "DW_AT_src_info"; - case DW_AT_mac_info: - return "DW_AT_mac_info"; - case DW_AT_src_coords: - return "DW_AT_src_coords"; - case DW_AT_body_begin: - return "DW_AT_body_begin"; - case DW_AT_body_end: - return "DW_AT_body_end"; - default: - return "DW_AT_<unknown>"; - } -} - -/* Convert a DWARF value form code into its string name. */ - -static char * -dwarf_form_name (form) - register unsigned form; -{ - switch (form) - { - case DW_FORM_addr: - return "DW_FORM_addr"; - case DW_FORM_block2: - return "DW_FORM_block2"; - case DW_FORM_block4: - return "DW_FORM_block4"; - case DW_FORM_data2: - return "DW_FORM_data2"; - case DW_FORM_data4: - return "DW_FORM_data4"; - case DW_FORM_data8: - return "DW_FORM_data8"; - case DW_FORM_string: - return "DW_FORM_string"; - case DW_FORM_block: - return "DW_FORM_block"; - case DW_FORM_block1: - return "DW_FORM_block1"; - case DW_FORM_data1: - return "DW_FORM_data1"; - case DW_FORM_flag: - return "DW_FORM_flag"; - case DW_FORM_sdata: - return "DW_FORM_sdata"; - case DW_FORM_strp: - return "DW_FORM_strp"; - case DW_FORM_udata: - return "DW_FORM_udata"; - case DW_FORM_ref_addr: - return "DW_FORM_ref_addr"; - case DW_FORM_ref1: - return "DW_FORM_ref1"; - case DW_FORM_ref2: - return "DW_FORM_ref2"; - case DW_FORM_ref4: - return "DW_FORM_ref4"; - case DW_FORM_ref8: - return "DW_FORM_ref8"; - case DW_FORM_ref_udata: - return "DW_FORM_ref_udata"; - case DW_FORM_indirect: - return "DW_FORM_indirect"; - default: - return "DW_FORM_<unknown>"; - } -} - -/* Convert a DWARF stack opcode into its string name. */ - -static char * -dwarf_stack_op_name (op) - register unsigned op; -{ - switch (op) - { - case DW_OP_addr: - return "DW_OP_addr"; - case DW_OP_deref: - return "DW_OP_deref"; - case DW_OP_const1u: - return "DW_OP_const1u"; - case DW_OP_const1s: - return "DW_OP_const1s"; - case DW_OP_const2u: - return "DW_OP_const2u"; - case DW_OP_const2s: - return "DW_OP_const2s"; - case DW_OP_const4u: - return "DW_OP_const4u"; - case DW_OP_const4s: - return "DW_OP_const4s"; - case DW_OP_const8u: - return "DW_OP_const8u"; - case DW_OP_const8s: - return "DW_OP_const8s"; - case DW_OP_constu: - return "DW_OP_constu"; - case DW_OP_consts: - return "DW_OP_consts"; - case DW_OP_dup: - return "DW_OP_dup"; - case DW_OP_drop: - return "DW_OP_drop"; - case DW_OP_over: - return "DW_OP_over"; - case DW_OP_pick: - return "DW_OP_pick"; - case DW_OP_swap: - return "DW_OP_swap"; - case DW_OP_rot: - return "DW_OP_rot"; - case DW_OP_xderef: - return "DW_OP_xderef"; - case DW_OP_abs: - return "DW_OP_abs"; - case DW_OP_and: - return "DW_OP_and"; - case DW_OP_div: - return "DW_OP_div"; - case DW_OP_minus: - return "DW_OP_minus"; - case DW_OP_mod: - return "DW_OP_mod"; - case DW_OP_mul: - return "DW_OP_mul"; - case DW_OP_neg: - return "DW_OP_neg"; - case DW_OP_not: - return "DW_OP_not"; - case DW_OP_or: - return "DW_OP_or"; - case DW_OP_plus: - return "DW_OP_plus"; - case DW_OP_plus_uconst: - return "DW_OP_plus_uconst"; - case DW_OP_shl: - return "DW_OP_shl"; - case DW_OP_shr: - return "DW_OP_shr"; - case DW_OP_shra: - return "DW_OP_shra"; - case DW_OP_xor: - return "DW_OP_xor"; - case DW_OP_bra: - return "DW_OP_bra"; - case DW_OP_eq: - return "DW_OP_eq"; - case DW_OP_ge: - return "DW_OP_ge"; - case DW_OP_gt: - return "DW_OP_gt"; - case DW_OP_le: - return "DW_OP_le"; - case DW_OP_lt: - return "DW_OP_lt"; - case DW_OP_ne: - return "DW_OP_ne"; - case DW_OP_skip: - return "DW_OP_skip"; - case DW_OP_lit0: - return "DW_OP_lit0"; - case DW_OP_lit1: - return "DW_OP_lit1"; - case DW_OP_lit2: - return "DW_OP_lit2"; - case DW_OP_lit3: - return "DW_OP_lit3"; - case DW_OP_lit4: - return "DW_OP_lit4"; - case DW_OP_lit5: - return "DW_OP_lit5"; - case DW_OP_lit6: - return "DW_OP_lit6"; - case DW_OP_lit7: - return "DW_OP_lit7"; - case DW_OP_lit8: - return "DW_OP_lit8"; - case DW_OP_lit9: - return "DW_OP_lit9"; - case DW_OP_lit10: - return "DW_OP_lit10"; - case DW_OP_lit11: - return "DW_OP_lit11"; - case DW_OP_lit12: - return "DW_OP_lit12"; - case DW_OP_lit13: - return "DW_OP_lit13"; - case DW_OP_lit14: - return "DW_OP_lit14"; - case DW_OP_lit15: - return "DW_OP_lit15"; - case DW_OP_lit16: - return "DW_OP_lit16"; - case DW_OP_lit17: - return "DW_OP_lit17"; - case DW_OP_lit18: - return "DW_OP_lit18"; - case DW_OP_lit19: - return "DW_OP_lit19"; - case DW_OP_lit20: - return "DW_OP_lit20"; - case DW_OP_lit21: - return "DW_OP_lit21"; - case DW_OP_lit22: - return "DW_OP_lit22"; - case DW_OP_lit23: - return "DW_OP_lit23"; - case DW_OP_lit24: - return "DW_OP_lit24"; - case DW_OP_lit25: - return "DW_OP_lit25"; - case DW_OP_lit26: - return "DW_OP_lit26"; - case DW_OP_lit27: - return "DW_OP_lit27"; - case DW_OP_lit28: - return "DW_OP_lit28"; - case DW_OP_lit29: - return "DW_OP_lit29"; - case DW_OP_lit30: - return "DW_OP_lit30"; - case DW_OP_lit31: - return "DW_OP_lit31"; - case DW_OP_reg0: - return "DW_OP_reg0"; - case DW_OP_reg1: - return "DW_OP_reg1"; - case DW_OP_reg2: - return "DW_OP_reg2"; - case DW_OP_reg3: - return "DW_OP_reg3"; - case DW_OP_reg4: - return "DW_OP_reg4"; - case DW_OP_reg5: - return "DW_OP_reg5"; - case DW_OP_reg6: - return "DW_OP_reg6"; - case DW_OP_reg7: - return "DW_OP_reg7"; - case DW_OP_reg8: - return "DW_OP_reg8"; - case DW_OP_reg9: - return "DW_OP_reg9"; - case DW_OP_reg10: - return "DW_OP_reg10"; - case DW_OP_reg11: - return "DW_OP_reg11"; - case DW_OP_reg12: - return "DW_OP_reg12"; - case DW_OP_reg13: - return "DW_OP_reg13"; - case DW_OP_reg14: - return "DW_OP_reg14"; - case DW_OP_reg15: - return "DW_OP_reg15"; - case DW_OP_reg16: - return "DW_OP_reg16"; - case DW_OP_reg17: - return "DW_OP_reg17"; - case DW_OP_reg18: - return "DW_OP_reg18"; - case DW_OP_reg19: - return "DW_OP_reg19"; - case DW_OP_reg20: - return "DW_OP_reg20"; - case DW_OP_reg21: - return "DW_OP_reg21"; - case DW_OP_reg22: - return "DW_OP_reg22"; - case DW_OP_reg23: - return "DW_OP_reg23"; - case DW_OP_reg24: - return "DW_OP_reg24"; - case DW_OP_reg25: - return "DW_OP_reg25"; - case DW_OP_reg26: - return "DW_OP_reg26"; - case DW_OP_reg27: - return "DW_OP_reg27"; - case DW_OP_reg28: - return "DW_OP_reg28"; - case DW_OP_reg29: - return "DW_OP_reg29"; - case DW_OP_reg30: - return "DW_OP_reg30"; - case DW_OP_reg31: - return "DW_OP_reg31"; - case DW_OP_breg0: - return "DW_OP_breg0"; - case DW_OP_breg1: - return "DW_OP_breg1"; - case DW_OP_breg2: - return "DW_OP_breg2"; - case DW_OP_breg3: - return "DW_OP_breg3"; - case DW_OP_breg4: - return "DW_OP_breg4"; - case DW_OP_breg5: - return "DW_OP_breg5"; - case DW_OP_breg6: - return "DW_OP_breg6"; - case DW_OP_breg7: - return "DW_OP_breg7"; - case DW_OP_breg8: - return "DW_OP_breg8"; - case DW_OP_breg9: - return "DW_OP_breg9"; - case DW_OP_breg10: - return "DW_OP_breg10"; - case DW_OP_breg11: - return "DW_OP_breg11"; - case DW_OP_breg12: - return "DW_OP_breg12"; - case DW_OP_breg13: - return "DW_OP_breg13"; - case DW_OP_breg14: - return "DW_OP_breg14"; - case DW_OP_breg15: - return "DW_OP_breg15"; - case DW_OP_breg16: - return "DW_OP_breg16"; - case DW_OP_breg17: - return "DW_OP_breg17"; - case DW_OP_breg18: - return "DW_OP_breg18"; - case DW_OP_breg19: - return "DW_OP_breg19"; - case DW_OP_breg20: - return "DW_OP_breg20"; - case DW_OP_breg21: - return "DW_OP_breg21"; - case DW_OP_breg22: - return "DW_OP_breg22"; - case DW_OP_breg23: - return "DW_OP_breg23"; - case DW_OP_breg24: - return "DW_OP_breg24"; - case DW_OP_breg25: - return "DW_OP_breg25"; - case DW_OP_breg26: - return "DW_OP_breg26"; - case DW_OP_breg27: - return "DW_OP_breg27"; - case DW_OP_breg28: - return "DW_OP_breg28"; - case DW_OP_breg29: - return "DW_OP_breg29"; - case DW_OP_breg30: - return "DW_OP_breg30"; - case DW_OP_breg31: - return "DW_OP_breg31"; - case DW_OP_regx: - return "DW_OP_regx"; - case DW_OP_fbreg: - return "DW_OP_fbreg"; - case DW_OP_bregx: - return "DW_OP_bregx"; - case DW_OP_piece: - return "DW_OP_piece"; - case DW_OP_deref_size: - return "DW_OP_deref_size"; - case DW_OP_xderef_size: - return "DW_OP_xderef_size"; - case DW_OP_nop: - return "DW_OP_nop"; - default: - return "OP_<unknown>"; - } -} - -/* Convert a DWARF type code into its string name. */ - -#if 0 -static char * -dwarf_type_encoding_name (enc) - register unsigned enc; -{ - switch (enc) - { - case DW_ATE_address: - return "DW_ATE_address"; - case DW_ATE_boolean: - return "DW_ATE_boolean"; - case DW_ATE_complex_float: - return "DW_ATE_complex_float"; - case DW_ATE_float: - return "DW_ATE_float"; - case DW_ATE_signed: - return "DW_ATE_signed"; - case DW_ATE_signed_char: - return "DW_ATE_signed_char"; - case DW_ATE_unsigned: - return "DW_ATE_unsigned"; - case DW_ATE_unsigned_char: - return "DW_ATE_unsigned_char"; - default: - return "DW_ATE_<unknown>"; - } -} -#endif - -/* Determine the "ultimate origin" of a decl. The decl may be an inlined - instance of an inlined instance of a decl which is local to an inline - function, so we have to trace all of the way back through the origin chain - to find out what sort of node actually served as the original seed for the - given block. */ - -static tree -decl_ultimate_origin (decl) - register tree decl; -{ -#ifdef ENABLE_CHECKING - if (DECL_FROM_INLINE (DECL_ORIGIN (decl))) - /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the - most distant ancestor, this should never happen. */ - abort (); -#endif - - return DECL_ABSTRACT_ORIGIN (decl); -} - -/* Determine the "ultimate origin" of a block. The block may be an inlined - instance of an inlined instance of a block which is local to an inline - function, so we have to trace all of the way back through the origin chain - to find out what sort of node actually served as the original seed for the - given block. */ - -static tree -block_ultimate_origin (block) - register tree block; -{ - register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); - - if (immediate_origin == NULL_TREE) - return NULL_TREE; - else - { - register tree ret_val; - register tree lookahead = immediate_origin; - - do - { - ret_val = lookahead; - lookahead = (TREE_CODE (ret_val) == BLOCK) - ? BLOCK_ABSTRACT_ORIGIN (ret_val) - : NULL; - } - while (lookahead != NULL && lookahead != ret_val); - - return ret_val; - } -} - -/* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT - of a virtual function may refer to a base class, so we check the 'this' - parameter. */ - -static tree -decl_class_context (decl) - tree decl; -{ - tree context = NULL_TREE; - - if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl)) - context = DECL_CONTEXT (decl); - else - context = TYPE_MAIN_VARIANT - (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); - - if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't') - context = NULL_TREE; - - return context; -} - -/* Add an attribute/value pair to a DIE */ - -static inline void -add_dwarf_attr (die, attr) - register dw_die_ref die; - register dw_attr_ref attr; -{ - if (die != NULL && attr != NULL) - { - if (die->die_attr == NULL) - { - die->die_attr = attr; - die->die_attr_last = attr; - } - else - { - die->die_attr_last->dw_attr_next = attr; - die->die_attr_last = attr; - } - } -} - -/* Add a flag value attribute to a DIE. */ - -static inline void -add_AT_flag (die, attr_kind, flag) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register unsigned flag; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_flag; - attr->dw_attr_val.v.val_flag = flag; - add_dwarf_attr (die, attr); -} - -/* Add a signed integer attribute value to a DIE. */ - -static inline void -add_AT_int (die, attr_kind, int_val) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register long int int_val; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_const; - attr->dw_attr_val.v.val_int = int_val; - add_dwarf_attr (die, attr); -} - -/* Add an unsigned integer attribute value to a DIE. */ - -static inline void -add_AT_unsigned (die, attr_kind, unsigned_val) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register unsigned long unsigned_val; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_unsigned_const; - attr->dw_attr_val.v.val_unsigned = unsigned_val; - add_dwarf_attr (die, attr); -} - -/* Add an unsigned double integer attribute value to a DIE. */ - -static inline void -add_AT_long_long (die, attr_kind, val_hi, val_low) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register unsigned long val_hi; - register unsigned long val_low; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_long_long; - attr->dw_attr_val.v.val_long_long.hi = val_hi; - attr->dw_attr_val.v.val_long_long.low = val_low; - add_dwarf_attr (die, attr); -} - -/* Add a floating point attribute value to a DIE and return it. */ - -static inline void -add_AT_float (die, attr_kind, length, array) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register unsigned length; - register long *array; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_float; - attr->dw_attr_val.v.val_float.length = length; - attr->dw_attr_val.v.val_float.array = array; - add_dwarf_attr (die, attr); -} - -/* Add a string attribute value to a DIE. */ - -static inline void -add_AT_string (die, attr_kind, str) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register char *str; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_str; - attr->dw_attr_val.v.val_str = xstrdup (str); - add_dwarf_attr (die, attr); -} - -/* Add a DIE reference attribute value to a DIE. */ - -static inline void -add_AT_die_ref (die, attr_kind, targ_die) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register dw_die_ref targ_die; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_die_ref; - attr->dw_attr_val.v.val_die_ref = targ_die; - add_dwarf_attr (die, attr); -} - -/* Add an FDE reference attribute value to a DIE. */ - -static inline void -add_AT_fde_ref (die, attr_kind, targ_fde) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register unsigned targ_fde; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_fde_ref; - attr->dw_attr_val.v.val_fde_index = targ_fde; - add_dwarf_attr (die, attr); -} - -/* Add a location description attribute value to a DIE. */ - -static inline void -add_AT_loc (die, attr_kind, loc) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register dw_loc_descr_ref loc; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_loc; - attr->dw_attr_val.v.val_loc = loc; - add_dwarf_attr (die, attr); -} - -/* Add an address constant attribute value to a DIE. */ - -static inline void -add_AT_addr (die, attr_kind, addr) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - rtx addr; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_addr; - attr->dw_attr_val.v.val_addr = addr; - add_dwarf_attr (die, attr); -} - -/* Add a label identifier attribute value to a DIE. */ - -static inline void -add_AT_lbl_id (die, attr_kind, lbl_id) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register char *lbl_id; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_lbl_id; - attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id); - add_dwarf_attr (die, attr); -} - -/* Add a section offset attribute value to a DIE. */ - -static inline void -add_AT_section_offset (die, attr_kind, section) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; - register char *section; -{ - register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - - attr->dw_attr_next = NULL; - attr->dw_attr = attr_kind; - attr->dw_attr_val.val_class = dw_val_class_section_offset; - attr->dw_attr_val.v.val_section = section; - add_dwarf_attr (die, attr); - -} - -/* Test if die refers to an external subroutine. */ - -static inline int -is_extern_subr_die (die) - register dw_die_ref die; -{ - register dw_attr_ref a; - register int is_subr = FALSE; - register int is_extern = FALSE; - - if (die != NULL && die->die_tag == DW_TAG_subprogram) - { - is_subr = TRUE; - for (a = die->die_attr; a != NULL; a = a->dw_attr_next) - { - if (a->dw_attr == DW_AT_external - && a->dw_attr_val.val_class == dw_val_class_flag - && a->dw_attr_val.v.val_flag != 0) - { - is_extern = TRUE; - break; - } - } - } - - return is_subr && is_extern; -} - -/* Get the attribute of type attr_kind. */ - -static inline dw_attr_ref -get_AT (die, attr_kind) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; -{ - register dw_attr_ref a; - register dw_die_ref spec = NULL; - - if (die != NULL) - { - for (a = die->die_attr; a != NULL; a = a->dw_attr_next) - { - if (a->dw_attr == attr_kind) - return a; - - if (a->dw_attr == DW_AT_specification - || a->dw_attr == DW_AT_abstract_origin) - spec = a->dw_attr_val.v.val_die_ref; - } - - if (spec) - return get_AT (spec, attr_kind); - } - - return NULL; -} - -/* Return the "low pc" attribute value, typically associated with - a subprogram DIE. Return null if the "low pc" attribute is - either not prsent, or if it cannot be represented as an - assembler label identifier. */ - -static inline char * -get_AT_low_pc (die) - register dw_die_ref die; -{ - register dw_attr_ref a = get_AT (die, DW_AT_low_pc); - - if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id) - return a->dw_attr_val.v.val_lbl_id; - - return NULL; -} - -/* Return the "high pc" attribute value, typically associated with - a subprogram DIE. Return null if the "high pc" attribute is - either not prsent, or if it cannot be represented as an - assembler label identifier. */ - -static inline char * -get_AT_hi_pc (die) - register dw_die_ref die; -{ - register dw_attr_ref a = get_AT (die, DW_AT_high_pc); - - if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id) - return a->dw_attr_val.v.val_lbl_id; - - return NULL; -} - -/* Return the value of the string attribute designated by ATTR_KIND, or - NULL if it is not present. */ - -static inline char * -get_AT_string (die, attr_kind) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; -{ - register dw_attr_ref a = get_AT (die, attr_kind); - - if (a && a->dw_attr_val.val_class == dw_val_class_str) - return a->dw_attr_val.v.val_str; - - return NULL; -} - -/* Return the value of the flag attribute designated by ATTR_KIND, or -1 - if it is not present. */ - -static inline int -get_AT_flag (die, attr_kind) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; -{ - register dw_attr_ref a = get_AT (die, attr_kind); - - if (a && a->dw_attr_val.val_class == dw_val_class_flag) - return a->dw_attr_val.v.val_flag; - - return -1; -} - -/* Return the value of the unsigned attribute designated by ATTR_KIND, or 0 - if it is not present. */ - -static inline unsigned -get_AT_unsigned (die, attr_kind) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; -{ - register dw_attr_ref a = get_AT (die, attr_kind); - - if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const) - return a->dw_attr_val.v.val_unsigned; - - return 0; -} - -static inline int -is_c_family () -{ - register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language); - - return (lang == DW_LANG_C || lang == DW_LANG_C89 - || lang == DW_LANG_C_plus_plus); -} - -static inline int -is_fortran () -{ - register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language); - - return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90); -} - -/* Remove the specified attribute if present. */ - -static inline void -remove_AT (die, attr_kind) - register dw_die_ref die; - register enum dwarf_attribute attr_kind; -{ - register dw_attr_ref a; - register dw_attr_ref removed = NULL;; - - if (die != NULL) - { - if (die->die_attr->dw_attr == attr_kind) - { - removed = die->die_attr; - if (die->die_attr_last == die->die_attr) - die->die_attr_last = NULL; - - die->die_attr = die->die_attr->dw_attr_next; - } - - else - for (a = die->die_attr; a->dw_attr_next != NULL; - a = a->dw_attr_next) - if (a->dw_attr_next->dw_attr == attr_kind) - { - removed = a->dw_attr_next; - if (die->die_attr_last == a->dw_attr_next) - die->die_attr_last = a; - - a->dw_attr_next = a->dw_attr_next->dw_attr_next; - break; - } - - if (removed != 0) - free (removed); - } -} - -/* Discard the children of this DIE. */ - -static inline void -remove_children (die) - register dw_die_ref die; -{ - register dw_die_ref child_die = die->die_child; - - die->die_child = NULL; - die->die_child_last = NULL; - - while (child_die != NULL) - { - register dw_die_ref tmp_die = child_die; - register dw_attr_ref a; - - child_die = child_die->die_sib; - - for (a = tmp_die->die_attr; a != NULL; ) - { - register dw_attr_ref tmp_a = a; - - a = a->dw_attr_next; - free (tmp_a); - } - - free (tmp_die); - } -} - -/* Add a child DIE below its parent. */ - -static inline void -add_child_die (die, child_die) - register dw_die_ref die; - register dw_die_ref child_die; -{ - if (die != NULL && child_die != NULL) - { - if (die == child_die) - abort (); - child_die->die_parent = die; - child_die->die_sib = NULL; - - if (die->die_child == NULL) - { - die->die_child = child_die; - die->die_child_last = child_die; - } - else - { - die->die_child_last->die_sib = child_die; - die->die_child_last = child_die; - } - } -} - -/* Return a pointer to a newly created DIE node. */ - -static inline dw_die_ref -new_die (tag_value, parent_die) - register enum dwarf_tag tag_value; - register dw_die_ref parent_die; -{ - register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node)); - - die->die_tag = tag_value; - die->die_abbrev = 0; - die->die_offset = 0; - die->die_child = NULL; - die->die_parent = NULL; - die->die_sib = NULL; - die->die_child_last = NULL; - die->die_attr = NULL; - die->die_attr_last = NULL; - - if (parent_die != NULL) - add_child_die (parent_die, die); - else - { - limbo_die_node *limbo_node; - - limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node)); - limbo_node->die = die; - limbo_node->next = limbo_die_list; - limbo_die_list = limbo_node; - } - - return die; -} - -/* Return the DIE associated with the given type specifier. */ - -static inline dw_die_ref -lookup_type_die (type) - register tree type; -{ - return (dw_die_ref) TYPE_SYMTAB_POINTER (type); -} - -/* Equate a DIE to a given type specifier. */ - -static void -equate_type_number_to_die (type, type_die) - register tree type; - register dw_die_ref type_die; -{ - TYPE_SYMTAB_POINTER (type) = (char *) type_die; -} - -/* Return the DIE associated with a given declaration. */ - -static inline dw_die_ref -lookup_decl_die (decl) - register tree decl; -{ - register unsigned decl_id = DECL_UID (decl); - - return (decl_id < decl_die_table_in_use - ? decl_die_table[decl_id] : NULL); -} - -/* Equate a DIE to a particular declaration. */ - -static void -equate_decl_number_to_die (decl, decl_die) - register tree decl; - register dw_die_ref decl_die; -{ - register unsigned decl_id = DECL_UID (decl); - register unsigned num_allocated; - - if (decl_id >= decl_die_table_allocated) - { - num_allocated - = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1) - / DECL_DIE_TABLE_INCREMENT) - * DECL_DIE_TABLE_INCREMENT; - - decl_die_table - = (dw_die_ref *) xrealloc (decl_die_table, - sizeof (dw_die_ref) * num_allocated); - - zero_memory ((char *) &decl_die_table[decl_die_table_allocated], - (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref)); - decl_die_table_allocated = num_allocated; - } - - if (decl_id >= decl_die_table_in_use) - decl_die_table_in_use = (decl_id + 1); - - decl_die_table[decl_id] = decl_die; -} - -/* Return a pointer to a newly allocated location description. Location - descriptions are simple expression terms that can be strung - together to form more complicated location (address) descriptions. */ - -static inline dw_loc_descr_ref -new_loc_descr (op, oprnd1, oprnd2) - register enum dwarf_location_atom op; - register unsigned long oprnd1; - register unsigned long oprnd2; -{ - register dw_loc_descr_ref descr - = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node)); - - descr->dw_loc_next = NULL; - descr->dw_loc_opc = op; - descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const; - descr->dw_loc_oprnd1.v.val_unsigned = oprnd1; - descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const; - descr->dw_loc_oprnd2.v.val_unsigned = oprnd2; - - return descr; -} - -/* Add a location description term to a location description expression. */ - -static inline void -add_loc_descr (list_head, descr) - register dw_loc_descr_ref *list_head; - register dw_loc_descr_ref descr; -{ - register dw_loc_descr_ref *d; - - /* Find the end of the chain. */ - for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next) - ; - - *d = descr; -} - -/* Keep track of the number of spaces used to indent the - output of the debugging routines that print the structure of - the DIE internal representation. */ -static int print_indent; - -/* Indent the line the number of spaces given by print_indent. */ - -static inline void -print_spaces (outfile) - FILE *outfile; -{ - fprintf (outfile, "%*s", print_indent, ""); -} - -/* Print the information associated with a given DIE, and its children. - This routine is a debugging aid only. */ - -static void -print_die (die, outfile) - dw_die_ref die; - FILE *outfile; -{ - register dw_attr_ref a; - register dw_die_ref c; - - print_spaces (outfile); - fprintf (outfile, "DIE %4lu: %s\n", - die->die_offset, dwarf_tag_name (die->die_tag)); - print_spaces (outfile); - fprintf (outfile, " abbrev id: %lu", die->die_abbrev); - fprintf (outfile, " offset: %lu\n", die->die_offset); - - for (a = die->die_attr; a != NULL; a = a->dw_attr_next) - { - print_spaces (outfile); - fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr)); - - switch (a->dw_attr_val.val_class) - { - case dw_val_class_addr: - fprintf (outfile, "address"); - break; - case dw_val_class_loc: - fprintf (outfile, "location descriptor"); - break; - case dw_val_class_const: - fprintf (outfile, "%ld", a->dw_attr_val.v.val_int); - break; - case dw_val_class_unsigned_const: - fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned); - break; - case dw_val_class_long_long: - fprintf (outfile, "constant (%lu,%lu)", - a->dw_attr_val.v.val_long_long.hi, - a->dw_attr_val.v.val_long_long.low); - break; - case dw_val_class_float: - fprintf (outfile, "floating-point constant"); - break; - case dw_val_class_flag: - fprintf (outfile, "%u", a->dw_attr_val.v.val_flag); - break; - case dw_val_class_die_ref: - if (a->dw_attr_val.v.val_die_ref != NULL) - fprintf (outfile, "die -> %lu", - a->dw_attr_val.v.val_die_ref->die_offset); - else - fprintf (outfile, "die -> <null>"); - break; - case dw_val_class_lbl_id: - fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id); - break; - case dw_val_class_section_offset: - fprintf (outfile, "section: %s", a->dw_attr_val.v.val_section); - break; - case dw_val_class_str: - if (a->dw_attr_val.v.val_str != NULL) - fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str); - else - fprintf (outfile, "<null>"); - break; - default: - break; - } - - fprintf (outfile, "\n"); - } - - if (die->die_child != NULL) - { - print_indent += 4; - for (c = die->die_child; c != NULL; c = c->die_sib) - print_die (c, outfile); - - print_indent -= 4; - } -} - -/* Print the contents of the source code line number correspondence table. - This routine is a debugging aid only. */ - -static void -print_dwarf_line_table (outfile) - FILE *outfile; -{ - register unsigned i; - register dw_line_info_ref line_info; - - fprintf (outfile, "\n\nDWARF source line information\n"); - for (i = 1; i < line_info_table_in_use; ++i) - { - line_info = &line_info_table[i]; - fprintf (outfile, "%5d: ", i); - fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]); - fprintf (outfile, "%6ld", line_info->dw_line_num); - fprintf (outfile, "\n"); - } - - fprintf (outfile, "\n\n"); -} - -/* Print the information collected for a given DIE. */ - -void -debug_dwarf_die (die) - dw_die_ref die; -{ - print_die (die, stderr); -} - -/* Print all DWARF information collected for the compilation unit. - This routine is a debugging aid only. */ - -void -debug_dwarf () -{ - print_indent = 0; - print_die (comp_unit_die, stderr); - print_dwarf_line_table (stderr); -} - -/* Traverse the DIE, and add a sibling attribute if it may have the - effect of speeding up access to siblings. To save some space, - avoid generating sibling attributes for DIE's without children. */ - -static void -add_sibling_attributes(die) - register dw_die_ref die; -{ - register dw_die_ref c; - register dw_attr_ref attr; - if (die != comp_unit_die && die->die_child != NULL) - { - attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node)); - attr->dw_attr_next = NULL; - attr->dw_attr = DW_AT_sibling; - attr->dw_attr_val.val_class = dw_val_class_die_ref; - attr->dw_attr_val.v.val_die_ref = die->die_sib; - - /* Add the sibling link to the front of the attribute list. */ - attr->dw_attr_next = die->die_attr; - if (die->die_attr == NULL) - die->die_attr_last = attr; - - die->die_attr = attr; - } - - for (c = die->die_child; c != NULL; c = c->die_sib) - add_sibling_attributes (c); -} - -/* The format of each DIE (and its attribute value pairs) - is encoded in an abbreviation table. This routine builds the - abbreviation table and assigns a unique abbreviation id for - each abbreviation entry. The children of each die are visited - recursively. */ - -static void -build_abbrev_table (die) - register dw_die_ref die; -{ - register unsigned long abbrev_id; - register unsigned long n_alloc; - register dw_die_ref c; - register dw_attr_ref d_attr, a_attr; - for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) - { - register dw_die_ref abbrev = abbrev_die_table[abbrev_id]; - - if (abbrev->die_tag == die->die_tag) - { - if ((abbrev->die_child != NULL) == (die->die_child != NULL)) - { - a_attr = abbrev->die_attr; - d_attr = die->die_attr; - - while (a_attr != NULL && d_attr != NULL) - { - if ((a_attr->dw_attr != d_attr->dw_attr) - || (value_format (&a_attr->dw_attr_val) - != value_format (&d_attr->dw_attr_val))) - break; - - a_attr = a_attr->dw_attr_next; - d_attr = d_attr->dw_attr_next; - } - - if (a_attr == NULL && d_attr == NULL) - break; - } - } - } - - if (abbrev_id >= abbrev_die_table_in_use) - { - if (abbrev_die_table_in_use >= abbrev_die_table_allocated) - { - n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT; - abbrev_die_table - = (dw_die_ref *) xrealloc (abbrev_die_table, - sizeof (dw_die_ref) * n_alloc); - - zero_memory ((char *) &abbrev_die_table[abbrev_die_table_allocated], - (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref)); - abbrev_die_table_allocated = n_alloc; - } - - ++abbrev_die_table_in_use; - abbrev_die_table[abbrev_id] = die; - } - - die->die_abbrev = abbrev_id; - for (c = die->die_child; c != NULL; c = c->die_sib) - build_abbrev_table (c); -} - -/* Return the size of a string, including the null byte. - - This used to treat backslashes as escapes, and hence they were not included - in the count. However, that conflicts with what ASM_OUTPUT_ASCII does, - which treats a backslash as a backslash, escaping it if necessary, and hence - we must include them in the count. */ - -static unsigned long -size_of_string (str) - register char *str; -{ - return strlen (str) + 1; -} - -/* Return the size of a location descriptor. */ - -static unsigned long -size_of_loc_descr (loc) - register dw_loc_descr_ref loc; -{ - register unsigned long size = 1; - - switch (loc->dw_loc_opc) - { - case DW_OP_addr: - size += PTR_SIZE; - break; - case DW_OP_const1u: - case DW_OP_const1s: - size += 1; - break; - case DW_OP_const2u: - case DW_OP_const2s: - size += 2; - break; - case DW_OP_const4u: - case DW_OP_const4s: - size += 4; - break; - case DW_OP_const8u: - case DW_OP_const8s: - size += 8; - break; - case DW_OP_constu: - size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); - break; - case DW_OP_consts: - size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); - break; - case DW_OP_pick: - size += 1; - break; - case DW_OP_plus_uconst: - size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); - break; - case DW_OP_skip: - case DW_OP_bra: - size += 2; - break; - case DW_OP_breg0: - case DW_OP_breg1: - case DW_OP_breg2: - case DW_OP_breg3: - case DW_OP_breg4: - case DW_OP_breg5: - case DW_OP_breg6: - case DW_OP_breg7: - case DW_OP_breg8: - case DW_OP_breg9: - case DW_OP_breg10: - case DW_OP_breg11: - case DW_OP_breg12: - case DW_OP_breg13: - case DW_OP_breg14: - case DW_OP_breg15: - case DW_OP_breg16: - case DW_OP_breg17: - case DW_OP_breg18: - case DW_OP_breg19: - case DW_OP_breg20: - case DW_OP_breg21: - case DW_OP_breg22: - case DW_OP_breg23: - case DW_OP_breg24: - case DW_OP_breg25: - case DW_OP_breg26: - case DW_OP_breg27: - case DW_OP_breg28: - case DW_OP_breg29: - case DW_OP_breg30: - case DW_OP_breg31: - size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); - break; - case DW_OP_regx: - size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); - break; - case DW_OP_fbreg: - size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int); - break; - case DW_OP_bregx: - size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); - size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int); - break; - case DW_OP_piece: - size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned); - break; - case DW_OP_deref_size: - case DW_OP_xderef_size: - size += 1; - break; - default: - break; - } - - return size; -} - -/* Return the size of a series of location descriptors. */ - -static unsigned long -size_of_locs (loc) - register dw_loc_descr_ref loc; -{ - register unsigned long size = 0; - - for (; loc != NULL; loc = loc->dw_loc_next) - size += size_of_loc_descr (loc); - - return size; -} - -/* Return the power-of-two number of bytes necessary to represent VALUE. */ - -static int -constant_size (value) - long unsigned value; -{ - int log; - - if (value == 0) - log = 0; - else - log = floor_log2 (value); - - log = log / 8; - log = 1 << (floor_log2 (log) + 1); - - return log; -} - -/* Return the size of a DIE, as it is represented in the - .debug_info section. */ - -static unsigned long -size_of_die (die) - register dw_die_ref die; -{ - register unsigned long size = 0; - register dw_attr_ref a; - - size += size_of_uleb128 (die->die_abbrev); - for (a = die->die_attr; a != NULL; a = a->dw_attr_next) - { - switch (a->dw_attr_val.val_class) - { - case dw_val_class_addr: - size += PTR_SIZE; - break; - case dw_val_class_loc: - { - register unsigned long lsize - = size_of_locs (a->dw_attr_val.v.val_loc); - - /* Block length. */ - size += constant_size (lsize); - size += lsize; - } - break; - case dw_val_class_const: - size += 4; - break; - case dw_val_class_unsigned_const: - size += constant_size (a->dw_attr_val.v.val_unsigned); - break; - case dw_val_class_long_long: - size += 1 + 8; /* block */ - break; - case dw_val_class_float: - size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */ - break; - case dw_val_class_flag: - size += 1; - break; - case dw_val_class_die_ref: - size += DWARF_OFFSET_SIZE; - break; - case dw_val_class_fde_ref: - size += DWARF_OFFSET_SIZE; - break; - case dw_val_class_lbl_id: - size += PTR_SIZE; - break; - case dw_val_class_section_offset: - size += DWARF_OFFSET_SIZE; - break; - case dw_val_class_str: - size += size_of_string (a->dw_attr_val.v.val_str); - break; - default: - abort (); - } - } - - return size; -} - -/* Size the debugging information associated with a given DIE. - Visits the DIE's children recursively. Updates the global - variable next_die_offset, on each time through. Uses the - current value of next_die_offset to update the die_offset - field in each DIE. */ - -static void -calc_die_sizes (die) - dw_die_ref die; -{ - register dw_die_ref c; - die->die_offset = next_die_offset; - next_die_offset += size_of_die (die); - - for (c = die->die_child; c != NULL; c = c->die_sib) - calc_die_sizes (c); - - if (die->die_child != NULL) - /* Count the null byte used to terminate sibling lists. */ - next_die_offset += 1; -} - -/* Return the size of the line information prolog generated for the - compilation unit. */ - -static unsigned long -size_of_line_prolog () -{ - register unsigned long size; - register unsigned long ft_index; - - size = DWARF_LINE_PROLOG_HEADER_SIZE; - - /* Count the size of the table giving number of args for each - standard opcode. */ - size += DWARF_LINE_OPCODE_BASE - 1; - - /* Include directory table is empty (at present). Count only the - null byte used to terminate the table. */ - size += 1; - - for (ft_index = 1; ft_index < file_table_in_use; ++ft_index) - { - /* File name entry. */ - size += size_of_string (file_table[ft_index]); - - /* Include directory index. */ - size += size_of_uleb128 (0); - - /* Modification time. */ - size += size_of_uleb128 (0); - - /* File length in bytes. */ - size += size_of_uleb128 (0); - } - - /* Count the file table terminator. */ - size += 1; - return size; -} - -/* Return the size of the line information generated for this - compilation unit. */ - -static unsigned long -size_of_line_info () -{ - register unsigned long size; - register unsigned long lt_index; - register unsigned long current_line; - register long line_offset; - register long line_delta; - register unsigned long current_file; - register unsigned long function; - unsigned long size_of_set_address; - - /* Size of a DW_LNE_set_address instruction. */ - size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE; - - /* Version number. */ - size = 2; - - /* Prolog length specifier. */ - size += DWARF_OFFSET_SIZE; - - /* Prolog. */ - size += size_of_line_prolog (); - - /* Set address register instruction. */ - size += size_of_set_address; - - current_file = 1; - current_line = 1; - for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) - { - register dw_line_info_ref line_info; - - /* Advance pc instruction. */ - /* ??? See the DW_LNS_advance_pc comment in output_line_info. */ - if (0) - size += 1 + 2; - else - size += size_of_set_address; - - line_info = &line_info_table[lt_index]; - if (line_info->dw_file_num != current_file) - { - /* Set file number instruction. */ - size += 1; - current_file = line_info->dw_file_num; - size += size_of_uleb128 (current_file); - } - - if (line_info->dw_line_num != current_line) - { - line_offset = line_info->dw_line_num - current_line; - line_delta = line_offset - DWARF_LINE_BASE; - current_line = line_info->dw_line_num; - if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) - /* 1-byte special line number instruction. */ - size += 1; - else - { - /* Advance line instruction. */ - size += 1; - size += size_of_sleb128 (line_offset); - /* Generate line entry instruction. */ - size += 1; - } - } - } - - /* Advance pc instruction. */ - if (0) - size += 1 + 2; - else - size += size_of_set_address; - - /* End of line number info. marker. */ - size += 1 + size_of_uleb128 (1) + 1; - - function = 0; - current_file = 1; - current_line = 1; - for (lt_index = 0; lt_index < separate_line_info_table_in_use; ) - { - register dw_separate_line_info_ref line_info - = &separate_line_info_table[lt_index]; - if (function != line_info->function) - { - function = line_info->function; - /* Set address register instruction. */ - size += size_of_set_address; - } - else - { - /* Advance pc instruction. */ - if (0) - size += 1 + 2; - else - size += size_of_set_address; - } - - if (line_info->dw_file_num != current_file) - { - /* Set file number instruction. */ - size += 1; - current_file = line_info->dw_file_num; - size += size_of_uleb128 (current_file); - } - - if (line_info->dw_line_num != current_line) - { - line_offset = line_info->dw_line_num - current_line; - line_delta = line_offset - DWARF_LINE_BASE; - current_line = line_info->dw_line_num; - if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) - /* 1-byte special line number instruction. */ - size += 1; - else - { - /* Advance line instruction. */ - size += 1; - size += size_of_sleb128 (line_offset); - - /* Generate line entry instruction. */ - size += 1; - } - } - - ++lt_index; - - /* If we're done with a function, end its sequence. */ - if (lt_index == separate_line_info_table_in_use - || separate_line_info_table[lt_index].function != function) - { - current_file = 1; - current_line = 1; - - /* Advance pc instruction. */ - if (0) - size += 1 + 2; - else - size += size_of_set_address; - - /* End of line number info. marker. */ - size += 1 + size_of_uleb128 (1) + 1; - } - } - - return size; -} - -/* Return the size of the .debug_pubnames table generated for the - compilation unit. */ - -static unsigned long -size_of_pubnames () -{ - register unsigned long size; - register unsigned i; - - size = DWARF_PUBNAMES_HEADER_SIZE; - for (i = 0; i < pubname_table_in_use; ++i) - { - register pubname_ref p = &pubname_table[i]; - size += DWARF_OFFSET_SIZE + size_of_string (p->name); - } - - size += DWARF_OFFSET_SIZE; - return size; -} - -/* Return the size of the information in the .debug_aranges section. */ - -static unsigned long -size_of_aranges () -{ - register unsigned long size; - - size = DWARF_ARANGES_HEADER_SIZE; - - /* Count the address/length pair for this compilation unit. */ - size += 2 * PTR_SIZE; - size += 2 * PTR_SIZE * arange_table_in_use; - - /* Count the two zero words used to terminated the address range table. */ - size += 2 * PTR_SIZE; - return size; -} - -/* Select the encoding of an attribute value. */ - -static enum dwarf_form -value_format (v) - dw_val_ref v; -{ - switch (v->val_class) - { - case dw_val_class_addr: - return DW_FORM_addr; - case dw_val_class_loc: - switch (constant_size (size_of_locs (v->v.val_loc))) - { - case 1: - return DW_FORM_block1; - case 2: - return DW_FORM_block2; - default: - abort (); - } - case dw_val_class_const: - return DW_FORM_data4; - case dw_val_class_unsigned_const: - switch (constant_size (v->v.val_unsigned)) - { - case 1: - return DW_FORM_data1; - case 2: - return DW_FORM_data2; - case 4: - return DW_FORM_data4; - case 8: - return DW_FORM_data8; - default: - abort (); - } - case dw_val_class_long_long: - return DW_FORM_block1; - case dw_val_class_float: - return DW_FORM_block1; - case dw_val_class_flag: - return DW_FORM_flag; - case dw_val_class_die_ref: - return DW_FORM_ref; - case dw_val_class_fde_ref: - return DW_FORM_data; - case dw_val_class_lbl_id: - return DW_FORM_addr; - case dw_val_class_section_offset: - return DW_FORM_data; - case dw_val_class_str: - return DW_FORM_string; - default: - abort (); - } -} - -/* Output the encoding of an attribute value. */ - -static void -output_value_format (v) - dw_val_ref v; -{ - enum dwarf_form form = value_format (v); - - output_uleb128 (form); - if (flag_debug_asm) - fprintf (asm_out_file, " (%s)", dwarf_form_name (form)); - - fputc ('\n', asm_out_file); -} - -/* Output the .debug_abbrev section which defines the DIE abbreviation - table. */ - -static void -output_abbrev_section () -{ - unsigned long abbrev_id; - - dw_attr_ref a_attr; - for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id) - { - register dw_die_ref abbrev = abbrev_die_table[abbrev_id]; - - output_uleb128 (abbrev_id); - if (flag_debug_asm) - fprintf (asm_out_file, " (abbrev code)"); - - fputc ('\n', asm_out_file); - output_uleb128 (abbrev->die_tag); - if (flag_debug_asm) - fprintf (asm_out_file, " (TAG: %s)", - dwarf_tag_name (abbrev->die_tag)); - - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP, - abbrev->die_child != NULL ? DW_children_yes : DW_children_no); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, - (abbrev->die_child != NULL - ? "DW_children_yes" : "DW_children_no")); - - fputc ('\n', asm_out_file); - - for (a_attr = abbrev->die_attr; a_attr != NULL; - a_attr = a_attr->dw_attr_next) - { - output_uleb128 (a_attr->dw_attr); - if (flag_debug_asm) - fprintf (asm_out_file, " (%s)", - dwarf_attr_name (a_attr->dw_attr)); - - fputc ('\n', asm_out_file); - output_value_format (&a_attr->dw_attr_val); - } - - fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP); - } -} - -/* Output location description stack opcode's operands (if any). */ - -static void -output_loc_operands (loc) - register dw_loc_descr_ref loc; -{ - register dw_val_ref val1 = &loc->dw_loc_oprnd1; - register dw_val_ref val2 = &loc->dw_loc_oprnd2; - - switch (loc->dw_loc_opc) - { - case DW_OP_addr: - ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr); - fputc ('\n', asm_out_file); - break; - case DW_OP_const1u: - case DW_OP_const1s: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); - fputc ('\n', asm_out_file); - break; - case DW_OP_const2u: - case DW_OP_const2s: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_const4u: - case DW_OP_const4s: - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_const8u: - case DW_OP_const8s: - abort (); - fputc ('\n', asm_out_file); - break; - case DW_OP_constu: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - break; - case DW_OP_consts: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_pick: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_plus_uconst: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - break; - case DW_OP_skip: - case DW_OP_bra: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_breg0: - case DW_OP_breg1: - case DW_OP_breg2: - case DW_OP_breg3: - case DW_OP_breg4: - case DW_OP_breg5: - case DW_OP_breg6: - case DW_OP_breg7: - case DW_OP_breg8: - case DW_OP_breg9: - case DW_OP_breg10: - case DW_OP_breg11: - case DW_OP_breg12: - case DW_OP_breg13: - case DW_OP_breg14: - case DW_OP_breg15: - case DW_OP_breg16: - case DW_OP_breg17: - case DW_OP_breg18: - case DW_OP_breg19: - case DW_OP_breg20: - case DW_OP_breg21: - case DW_OP_breg22: - case DW_OP_breg23: - case DW_OP_breg24: - case DW_OP_breg25: - case DW_OP_breg26: - case DW_OP_breg27: - case DW_OP_breg28: - case DW_OP_breg29: - case DW_OP_breg30: - case DW_OP_breg31: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_regx: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - break; - case DW_OP_fbreg: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_bregx: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - output_sleb128 (val2->v.val_int); - fputc ('\n', asm_out_file); - break; - case DW_OP_piece: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - break; - case DW_OP_deref_size: - case DW_OP_xderef_size: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); - fputc ('\n', asm_out_file); - break; - default: - break; - } -} - -/* Compute the offset of a sibling. */ - -static unsigned long -sibling_offset (die) - dw_die_ref die; -{ - unsigned long offset; - - if (die->die_child_last == NULL) - offset = die->die_offset + size_of_die (die); - else - offset = sibling_offset (die->die_child_last) + 1; - - return offset; -} - -/* Output the DIE and its attributes. Called recursively to generate - the definitions of each child DIE. */ - -static void -output_die (die) - register dw_die_ref die; -{ - register dw_attr_ref a; - register dw_die_ref c; - register unsigned long ref_offset; - register unsigned long size; - register dw_loc_descr_ref loc; - - output_uleb128 (die->die_abbrev); - if (flag_debug_asm) - fprintf (asm_out_file, " (DIE (0x%lx) %s)", - die->die_offset, dwarf_tag_name (die->die_tag)); - - fputc ('\n', asm_out_file); - - for (a = die->die_attr; a != NULL; a = a->dw_attr_next) - { - switch (a->dw_attr_val.val_class) - { - case dw_val_class_addr: - ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, - a->dw_attr_val.v.val_addr); - break; - - case dw_val_class_loc: - size = size_of_locs (a->dw_attr_val.v.val_loc); - - /* Output the block length for this list of location operations. */ - switch (constant_size (size)) - { - case 1: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size); - break; - case 2: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size); - break; - default: - abort (); - } - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - for (loc = a->dw_attr_val.v.val_loc; loc != NULL; - loc = loc->dw_loc_next) - { - /* Output the opcode. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, - dwarf_stack_op_name (loc->dw_loc_opc)); - - fputc ('\n', asm_out_file); - - /* Output the operand(s) (if any). */ - output_loc_operands (loc); - } - break; - - case dw_val_class_const: - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int); - break; - - case dw_val_class_unsigned_const: - switch (constant_size (a->dw_attr_val.v.val_unsigned)) - { - case 1: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - a->dw_attr_val.v.val_unsigned); - break; - case 2: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, - a->dw_attr_val.v.val_unsigned); - break; - case 4: - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, - a->dw_attr_val.v.val_unsigned); - break; - case 8: - ASM_OUTPUT_DWARF_DATA8 (asm_out_file, - a->dw_attr_val.v.val_long_long.hi, - a->dw_attr_val.v.val_long_long.low); - break; - default: - abort (); - } - break; - - case dw_val_class_long_long: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA8 (asm_out_file, - a->dw_attr_val.v.val_long_long.hi, - a->dw_attr_val.v.val_long_long.low); - - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s long long constant", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - break; - - case dw_val_class_float: - { - register unsigned int i; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - a->dw_attr_val.v.val_float.length * 4); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i) - { - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, - a->dw_attr_val.v.val_float.array[i]); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s fp constant word %u", - ASM_COMMENT_START, i); - - fputc ('\n', asm_out_file); - } - break; - } - - case dw_val_class_flag: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag); - break; - - case dw_val_class_die_ref: - if (a->dw_attr_val.v.val_die_ref != NULL) - ref_offset = a->dw_attr_val.v.val_die_ref->die_offset; - else if (a->dw_attr == DW_AT_sibling) - ref_offset = sibling_offset(die); - else - abort (); - - ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset); - break; - - case dw_val_class_fde_ref: - { - char l1[20]; - ASM_GENERATE_INTERNAL_LABEL - (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1); - fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE); - } - break; - - case dw_val_class_lbl_id: - ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id); - break; - - case dw_val_class_section_offset: - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, - stripattributes - (a->dw_attr_val.v.val_section)); - break; - - case dw_val_class_str: - if (flag_debug_asm) - ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str); - else - ASM_OUTPUT_ASCII (asm_out_file, - a->dw_attr_val.v.val_str, - (int) strlen (a->dw_attr_val.v.val_str) + 1); - break; - - default: - abort (); - } - - if (a->dw_attr_val.val_class != dw_val_class_loc - && a->dw_attr_val.val_class != dw_val_class_long_long - && a->dw_attr_val.val_class != dw_val_class_float) - { - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - } - } - - for (c = die->die_child; c != NULL; c = c->die_sib) - output_die (c); - - if (die->die_child != NULL) - { - /* Add null byte to terminate sibling list. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx", - ASM_COMMENT_START, die->die_offset); - - fputc ('\n', asm_out_file); - } -} - -/* Output the compilation unit that appears at the beginning of the - .debug_info section, and precedes the DIE descriptions. */ - -static void -output_compilation_unit_header () -{ - ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (ABBREV_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); -} - -/* The DWARF2 pubname for a nested thingy looks like "A::f". The output - of decl_printable_name for C++ looks like "A::f(int)". Let's drop the - argument list, and maybe the scope. */ - -static char * -dwarf2_name (decl, scope) - tree decl; - int scope; -{ - return (*decl_printable_name) (decl, scope ? 1 : 0); -} - -/* Add a new entry to .debug_pubnames if appropriate. */ - -static void -add_pubname (decl, die) - tree decl; - dw_die_ref die; -{ - pubname_ref p; - - if (! TREE_PUBLIC (decl)) - return; - - if (pubname_table_in_use == pubname_table_allocated) - { - pubname_table_allocated += PUBNAME_TABLE_INCREMENT; - pubname_table = (pubname_ref) xrealloc - (pubname_table, pubname_table_allocated * sizeof (pubname_entry)); - } - - p = &pubname_table[pubname_table_in_use++]; - p->die = die; - - p->name = xstrdup (dwarf2_name (decl, 1)); -} - -/* Output the public names table used to speed up access to externally - visible names. For now, only generate entries for externally - visible procedures. */ - -static void -output_pubnames () -{ - register unsigned i; - register unsigned long pubnames_length = size_of_pubnames (); - - ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Public Names Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - for (i = 0; i < pubname_table_in_use; ++i) - { - register pubname_ref pub = &pubname_table[i]; - - ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name); - fprintf (asm_out_file, "%s external name", ASM_COMMENT_START); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, pub->name, - (int) strlen (pub->name) + 1); - } - - fputc ('\n', asm_out_file); - } - - ASM_OUTPUT_DWARF_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); -} - -/* Add a new entry to .debug_aranges if appropriate. */ - -static void -add_arange (decl, die) - tree decl; - dw_die_ref die; -{ - if (! DECL_SECTION_NAME (decl)) - return; - - if (arange_table_in_use == arange_table_allocated) - { - arange_table_allocated += ARANGE_TABLE_INCREMENT; - arange_table - = (arange_ref) xrealloc (arange_table, - arange_table_allocated * sizeof (dw_die_ref)); - } - - arange_table[arange_table_in_use++] = die; -} - -/* Output the information that goes into the .debug_aranges table. - Namely, define the beginning and ending address range of the - text section generated for this compilation unit. */ - -static void -output_aranges () -{ - register unsigned i; - register unsigned long aranges_length = size_of_aranges (); - - ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Address Ranges Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Size of Segment Descriptor", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4); - if (PTR_SIZE == 8) - fprintf (asm_out_file, ",0,0"); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Pad to %d byte boundary", - ASM_COMMENT_START, 2 * PTR_SIZE); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, stripattributes (TEXT_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, - stripattributes (TEXT_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - for (i = 0; i < arange_table_in_use; ++i) - { - dw_die_ref a = arange_table[i]; - - if (a->die_tag == DW_TAG_subprogram) - ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a)); - else - { - char *name = get_AT_string (a, DW_AT_MIPS_linkage_name); - if (! name) - name = get_AT_string (a, DW_AT_name); - - ASM_OUTPUT_DWARF_ADDR (asm_out_file, name); - } - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - if (a->die_tag == DW_TAG_subprogram) - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a), - get_AT_low_pc (a)); - else - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, - get_AT_unsigned (a, DW_AT_byte_size)); - - if (flag_debug_asm) - fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - } - - /* Output the terminator words. */ - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); -} - -/* Output the source line number correspondence information. This - information goes into the .debug_line section. - - If the format of this data changes, then the function size_of_line_info - must also be adjusted the same way. */ - -static void -output_line_info () -{ - char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; - char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; - register unsigned opc; - register unsigned n_op_args; - register unsigned long ft_index; - register unsigned long lt_index; - register unsigned long current_line; - register long line_offset; - register long line_delta; - register unsigned long current_file; - register unsigned long function; - - ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ()); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Source Line Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ()); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Minimum Instruction Length", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Default is_stmt_start flag", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc) - { - switch (opc) - { - case DW_LNS_advance_pc: - case DW_LNS_advance_line: - case DW_LNS_set_file: - case DW_LNS_set_column: - case DW_LNS_fixed_advance_pc: - n_op_args = 1; - break; - default: - n_op_args = 0; - break; - } - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args", - ASM_COMMENT_START, opc, n_op_args); - fputc ('\n', asm_out_file); - } - - if (flag_debug_asm) - fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START); - - /* Include directory table is empty, at present */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - fputc ('\n', asm_out_file); - if (flag_debug_asm) - fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START); - - for (ft_index = 1; ft_index < file_table_in_use; ++ft_index) - { - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]); - fprintf (asm_out_file, "%s File Entry: 0x%lx", - ASM_COMMENT_START, ft_index); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, - file_table[ft_index], - (int) strlen (file_table[ft_index]) + 1); - } - - fputc ('\n', asm_out_file); - - /* Include directory index */ - output_uleb128 (0); - fputc ('\n', asm_out_file); - - /* Modification time */ - output_uleb128 (0); - fputc ('\n', asm_out_file); - - /* File length in bytes */ - output_uleb128 (0); - fputc ('\n', asm_out_file); - } - - /* Terminate the file name table */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - fputc ('\n', asm_out_file); - - /* Set the address register to the first location in the text section */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, stripattributes (TEXT_SECTION)); - fputc ('\n', asm_out_file); - - /* Generate the line number to PC correspondence table, encoded as - a series of state machine operations. */ - current_file = 1; - current_line = 1; - strcpy (prev_line_label, stripattributes (TEXT_SECTION)); - for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index) - { - register dw_line_info_ref line_info; - - /* Emit debug info for the address of the current line, choosing - the encoding that uses the least amount of space. */ - /* ??? Unfortunately, we have little choice here currently, and must - always use the most general form. Gcc does not know the address - delta itself, so we can't use DW_LNS_advance_pc. There are no known - dwarf2 aware assemblers at this time, so we can't use any special - pseudo ops that would allow the assembler to optimally encode this for - us. Many ports do have length attributes which will give an upper - bound on the address range. We could perhaps use length attributes - to determine when it is safe to use DW_LNS_fixed_advance_pc. */ - ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); - if (0) - { - /* This can handle deltas up to 0xffff. This takes 3 bytes. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label); - fputc ('\n', asm_out_file); - } - else - { - /* This can handle any delta. This takes 4+PTR_SIZE bytes. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); - } - strcpy (prev_line_label, line_label); - - /* Emit debug info for the source file of the current line, if - different from the previous line. */ - line_info = &line_info_table[lt_index]; - if (line_info->dw_file_num != current_file) - { - current_file = line_info->dw_file_num; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (current_file); - if (flag_debug_asm) - fprintf (asm_out_file, " (\"%s\")", file_table[current_file]); - - fputc ('\n', asm_out_file); - } - - /* Emit debug info for the current line number, choosing the encoding - that uses the least amount of space. */ - line_offset = line_info->dw_line_num - current_line; - line_delta = line_offset - DWARF_LINE_BASE; - current_line = line_info->dw_line_num; - if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) - { - /* This can handle deltas from -10 to 234, using the current - definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This - takes 1 byte. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - DWARF_LINE_OPCODE_BASE + line_delta); - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s line %ld", ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - } - else - { - /* This can handle any delta. This takes at least 4 bytes, depending - on the value being encoded. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s advance to line %ld", - ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - output_sleb128 (line_offset); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - fputc ('\n', asm_out_file); - } - } - - /* Emit debug info for the address of the end of the function. */ - if (0) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label); - fputc ('\n', asm_out_file); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label); - fputc ('\n', asm_out_file); - } - - /* Output the marker for the end of the line number info. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); - fputc ('\n', asm_out_file); - - function = 0; - current_file = 1; - current_line = 1; - for (lt_index = 0; lt_index < separate_line_info_table_in_use; ) - { - register dw_separate_line_info_ref line_info - = &separate_line_info_table[lt_index]; - - /* Emit debug info for the address of the current line. If this is - a new function, or the first line of a function, then we need - to handle it differently. */ - ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL, - lt_index); - if (function != line_info->function) - { - function = line_info->function; - - /* Set the address register to the first line in the function */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); - } - else - { - /* ??? See the DW_LNS_advance_pc comment above. */ - if (0) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, - prev_line_label); - fputc ('\n', asm_out_file); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); - } - } - strcpy (prev_line_label, line_label); - - /* Emit debug info for the source file of the current line, if - different from the previous line. */ - if (line_info->dw_file_num != current_file) - { - current_file = line_info->dw_file_num; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (current_file); - if (flag_debug_asm) - fprintf (asm_out_file, " (\"%s\")", file_table[current_file]); - - fputc ('\n', asm_out_file); - } - - /* Emit debug info for the current line number, choosing the encoding - that uses the least amount of space. */ - if (line_info->dw_line_num != current_line) - { - line_offset = line_info->dw_line_num - current_line; - line_delta = line_offset - DWARF_LINE_BASE; - current_line = line_info->dw_line_num; - if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - DWARF_LINE_OPCODE_BASE + line_delta); - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s line %ld", ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s advance to line %ld", - ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - output_sleb128 (line_offset); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - fputc ('\n', asm_out_file); - } - } - - ++lt_index; - - /* If we're done with a function, end its sequence. */ - if (lt_index == separate_line_info_table_in_use - || separate_line_info_table[lt_index].function != function) - { - current_file = 1; - current_line = 1; - - /* Emit debug info for the address of the end of the function. */ - ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); - if (0) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, - prev_line_label); - fputc ('\n', asm_out_file); - } - else - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + PTR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); - } - - /* Output the marker for the end of this sequence. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); - fputc ('\n', asm_out_file); - } - } -} - -/* Given a pointer to a BLOCK node return non-zero if (and only if) the node - in question represents the outermost pair of curly braces (i.e. the "body - block") of a function or method. - - For any BLOCK node representing a "body block" of a function or method, the - BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which - represents the outermost (function) scope for the function or method (i.e. - the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of - *that* node in turn will point to the relevant FUNCTION_DECL node. */ - -static inline int -is_body_block (stmt) - register tree stmt; -{ - if (TREE_CODE (stmt) == BLOCK) - { - register tree parent = BLOCK_SUPERCONTEXT (stmt); - - if (TREE_CODE (parent) == BLOCK) - { - register tree grandparent = BLOCK_SUPERCONTEXT (parent); - - if (TREE_CODE (grandparent) == FUNCTION_DECL) - return 1; - } - } - - return 0; -} - -/* Given a pointer to a tree node for some base type, return a pointer to - a DIE that describes the given type. - - This routine must only be called for GCC type nodes that correspond to - Dwarf base (fundamental) types. */ - -static dw_die_ref -base_type_die (type) - register tree type; -{ - register dw_die_ref base_type_result; - register char *type_name; - register enum dwarf_type encoding; - register tree name = TYPE_NAME (type); - - if (TREE_CODE (type) == ERROR_MARK - || TREE_CODE (type) == VOID_TYPE) - return 0; - - if (TREE_CODE (name) == TYPE_DECL) - name = DECL_NAME (name); - type_name = IDENTIFIER_POINTER (name); - - switch (TREE_CODE (type)) - { - case INTEGER_TYPE: - /* Carefully distinguish the C character types, without messing - up if the language is not C. Note that we check only for the names - that contain spaces; other names might occur by coincidence in other - languages. */ - if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE - && (type == char_type_node - || ! strcmp (type_name, "signed char") - || ! strcmp (type_name, "unsigned char")))) - { - if (TREE_UNSIGNED (type)) - encoding = DW_ATE_unsigned; - else - encoding = DW_ATE_signed; - break; - } - /* else fall through */ - - case CHAR_TYPE: - /* GNU Pascal/Ada CHAR type. Not used in C. */ - if (TREE_UNSIGNED (type)) - encoding = DW_ATE_unsigned_char; - else - encoding = DW_ATE_signed_char; - break; - - case REAL_TYPE: - encoding = DW_ATE_float; - break; - - case COMPLEX_TYPE: - encoding = DW_ATE_complex_float; - break; - - case BOOLEAN_TYPE: - /* GNU FORTRAN/Ada/C++ BOOLEAN type. */ - encoding = DW_ATE_boolean; - break; - - default: - abort (); /* No other TREE_CODEs are Dwarf fundamental types. */ - } - - base_type_result = new_die (DW_TAG_base_type, comp_unit_die); - add_AT_string (base_type_result, DW_AT_name, type_name); - add_AT_unsigned (base_type_result, DW_AT_byte_size, - int_size_in_bytes (type)); - add_AT_unsigned (base_type_result, DW_AT_encoding, encoding); - - return base_type_result; -} - -/* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to - the Dwarf "root" type for the given input type. The Dwarf "root" type of - a given type is generally the same as the given type, except that if the - given type is a pointer or reference type, then the root type of the given - type is the root type of the "basis" type for the pointer or reference - type. (This definition of the "root" type is recursive.) Also, the root - type of a `const' qualified type or a `volatile' qualified type is the - root type of the given type without the qualifiers. */ - -static tree -root_type (type) - register tree type; -{ - if (TREE_CODE (type) == ERROR_MARK) - return error_mark_node; - - switch (TREE_CODE (type)) - { - case ERROR_MARK: - return error_mark_node; - - case POINTER_TYPE: - case REFERENCE_TYPE: - return type_main_variant (root_type (TREE_TYPE (type))); - - default: - return type_main_variant (type); - } -} - -/* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the - given input type is a Dwarf "fundamental" type. Otherwise return null. */ - -static inline int -is_base_type (type) - register tree type; -{ - switch (TREE_CODE (type)) - { - case ERROR_MARK: - case VOID_TYPE: - case INTEGER_TYPE: - case REAL_TYPE: - case COMPLEX_TYPE: - case BOOLEAN_TYPE: - case CHAR_TYPE: - return 1; - - case SET_TYPE: - case ARRAY_TYPE: - case RECORD_TYPE: - case UNION_TYPE: - case QUAL_UNION_TYPE: - case ENUMERAL_TYPE: - case FUNCTION_TYPE: - case METHOD_TYPE: - case POINTER_TYPE: - case REFERENCE_TYPE: - case FILE_TYPE: - case OFFSET_TYPE: - case LANG_TYPE: - return 0; - - default: - abort (); - } - - return 0; -} - -/* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging - entry that chains various modifiers in front of the given type. */ - -static dw_die_ref -modified_type_die (type, is_const_type, is_volatile_type, context_die) - register tree type; - register int is_const_type; - register int is_volatile_type; - register dw_die_ref context_die; -{ - register enum tree_code code = TREE_CODE (type); - register dw_die_ref mod_type_die = NULL; - register dw_die_ref sub_die = NULL; - register tree item_type = NULL; - - if (code != ERROR_MARK) - { - type = build_type_variant (type, is_const_type, is_volatile_type); - - mod_type_die = lookup_type_die (type); - if (mod_type_die) - return mod_type_die; - - /* Handle C typedef types. */ - if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL - && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) - { - tree dtype = TREE_TYPE (TYPE_NAME (type)); - if (type == dtype) - { - /* For a named type, use the typedef. */ - gen_type_die (type, context_die); - mod_type_die = lookup_type_die (type); - } - - else if (is_const_type < TYPE_READONLY (dtype) - || is_volatile_type < TYPE_VOLATILE (dtype)) - /* cv-unqualified version of named type. Just use the unnamed - type to which it refers. */ - mod_type_die - = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), - is_const_type, is_volatile_type, - context_die); - /* Else cv-qualified version of named type; fall through. */ - } - - if (mod_type_die) - /* OK */; - else if (is_const_type) - { - mod_type_die = new_die (DW_TAG_const_type, comp_unit_die); - sub_die = modified_type_die (type, 0, is_volatile_type, context_die); - } - else if (is_volatile_type) - { - mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die); - sub_die = modified_type_die (type, 0, 0, context_die); - } - else if (code == POINTER_TYPE) - { - mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die); - add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); -#if 0 - add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); -#endif - item_type = TREE_TYPE (type); - } - else if (code == REFERENCE_TYPE) - { - mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die); - add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); -#if 0 - add_AT_unsigned (mod_type_die, DW_AT_address_class, 0); -#endif - item_type = TREE_TYPE (type); - } - else if (is_base_type (type)) - mod_type_die = base_type_die (type); - else - { - gen_type_die (type, context_die); - - /* We have to get the type_main_variant here (and pass that to the - `lookup_type_die' routine) because the ..._TYPE node we have - might simply be a *copy* of some original type node (where the - copy was created to help us keep track of typedef names) and - that copy might have a different TYPE_UID from the original - ..._TYPE node. */ - mod_type_die = lookup_type_die (type_main_variant (type)); - if (mod_type_die == NULL) - abort (); - } - } - - equate_type_number_to_die (type, mod_type_die); - if (item_type) - /* We must do this after the equate_type_number_to_die call, in case - this is a recursive type. This ensures that the modified_type_die - recursion will terminate even if the type is recursive. Recursive - types are possible in Ada. */ - sub_die = modified_type_die (item_type, - TYPE_READONLY (item_type), - TYPE_VOLATILE (item_type), - context_die); - - if (sub_die != NULL) - add_AT_die_ref (mod_type_die, DW_AT_type, sub_die); - - return mod_type_die; -} - -/* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is - an enumerated type. */ - -static inline int -type_is_enum (type) - register tree type; -{ - return TREE_CODE (type) == ENUMERAL_TYPE; -} - -/* Return a location descriptor that designates a machine register. */ - -static dw_loc_descr_ref -reg_loc_descriptor (rtl) - register rtx rtl; -{ - register dw_loc_descr_ref loc_result = NULL; - register unsigned reg = reg_number (rtl); - - if (reg <= 31) - loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0); - else - loc_result = new_loc_descr (DW_OP_regx, reg, 0); - - return loc_result; -} - -/* Return a location descriptor that designates a base+offset location. */ - -static dw_loc_descr_ref -based_loc_descr (reg, offset) - unsigned reg; - long int offset; -{ - register dw_loc_descr_ref loc_result; - /* For the "frame base", we use the frame pointer or stack pointer - registers, since the RTL for local variables is relative to one of - them. */ - register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed - ? HARD_FRAME_POINTER_REGNUM - : STACK_POINTER_REGNUM); - - if (reg == fp_reg) - loc_result = new_loc_descr (DW_OP_fbreg, offset, 0); - else if (reg <= 31) - loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0); - else - loc_result = new_loc_descr (DW_OP_bregx, reg, offset); - - return loc_result; -} - -/* Return true if this RTL expression describes a base+offset calculation. */ - -static inline int -is_based_loc (rtl) - register rtx rtl; -{ - return (GET_CODE (rtl) == PLUS - && ((GET_CODE (XEXP (rtl, 0)) == REG - && GET_CODE (XEXP (rtl, 1)) == CONST_INT))); -} - -/* The following routine converts the RTL for a variable or parameter - (resident in memory) into an equivalent Dwarf representation of a - mechanism for getting the address of that same variable onto the top of a - hypothetical "address evaluation" stack. - - When creating memory location descriptors, we are effectively transforming - the RTL for a memory-resident object into its Dwarf postfix expression - equivalent. This routine recursively descends an RTL tree, turning - it into Dwarf postfix code as it goes. */ - -static dw_loc_descr_ref -mem_loc_descriptor (rtl) - register rtx rtl; -{ - dw_loc_descr_ref mem_loc_result = NULL; - /* Note that for a dynamically sized array, the location we will generate a - description of here will be the lowest numbered location which is - actually within the array. That's *not* necessarily the same as the - zeroth element of the array. */ - - switch (GET_CODE (rtl)) - { - case SUBREG: - /* The case of a subreg may arise when we have a local (register) - variable or a formal (register) parameter which doesn't quite fill - up an entire register. For now, just assume that it is - legitimate to make the Dwarf info refer to the whole register which - contains the given subreg. */ - rtl = XEXP (rtl, 0); - - /* ... fall through ... */ - - case REG: - /* Whenever a register number forms a part of the description of the - method for calculating the (dynamic) address of a memory resident - object, DWARF rules require the register number be referred to as - a "base register". This distinction is not based in any way upon - what category of register the hardware believes the given register - belongs to. This is strictly DWARF terminology we're dealing with - here. Note that in cases where the location of a memory-resident - data object could be expressed as: OP_ADD (OP_BASEREG (basereg), - OP_CONST (0)) the actual DWARF location descriptor that we generate - may just be OP_BASEREG (basereg). This may look deceptively like - the object in question was allocated to a register (rather than in - memory) so DWARF consumers need to be aware of the subtle - distinction between OP_REG and OP_BASEREG. */ - mem_loc_result = based_loc_descr (reg_number (rtl), 0); - break; - - case MEM: - mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0)); - add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0)); - break; - - case CONST: - case LABEL_REF: - case SYMBOL_REF: - mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0); - mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr; - mem_loc_result->dw_loc_oprnd1.v.val_addr = save_rtx (rtl); - break; - - case PLUS: - if (is_based_loc (rtl)) - mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)), - INTVAL (XEXP (rtl, 1))); - else - { - add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0))); - add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1))); - add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0)); - } - break; - - case MULT: - /* If a pseudo-reg is optimized away, it is possible for it to - be replaced with a MEM containing a multiply. */ - add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0))); - add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1))); - add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0)); - break; - - case CONST_INT: - mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0); - break; - - default: - abort (); - } - - return mem_loc_result; -} - -/* Return a descriptor that describes the concatenation of two locations. - This is typically a complex variable. */ - -static dw_loc_descr_ref -concat_loc_descriptor (x0, x1) - register rtx x0, x1; -{ - dw_loc_descr_ref cc_loc_result = NULL; - - if (!is_pseudo_reg (x0) - && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0)))) - add_loc_descr (&cc_loc_result, loc_descriptor (x0)); - add_loc_descr (&cc_loc_result, - new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0)); - - if (!is_pseudo_reg (x1) - && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0)))) - add_loc_descr (&cc_loc_result, loc_descriptor (x1)); - add_loc_descr (&cc_loc_result, - new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0)); - - return cc_loc_result; -} - -/* Output a proper Dwarf location descriptor for a variable or parameter - which is either allocated in a register or in a memory location. For a - register, we just generate an OP_REG and the register number. For a - memory location we provide a Dwarf postfix expression describing how to - generate the (dynamic) address of the object onto the address stack. */ - -static dw_loc_descr_ref -loc_descriptor (rtl) - register rtx rtl; -{ - dw_loc_descr_ref loc_result = NULL; - switch (GET_CODE (rtl)) - { - case SUBREG: - /* The case of a subreg may arise when we have a local (register) - variable or a formal (register) parameter which doesn't quite fill - up an entire register. For now, just assume that it is - legitimate to make the Dwarf info refer to the whole register which - contains the given subreg. */ - rtl = XEXP (rtl, 0); - - /* ... fall through ... */ - - case REG: - loc_result = reg_loc_descriptor (rtl); - break; - - case MEM: - loc_result = mem_loc_descriptor (XEXP (rtl, 0)); - break; - - case CONCAT: - loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1)); - break; - - default: - abort (); - } - - return loc_result; -} - -/* Given an unsigned value, round it up to the lowest multiple of `boundary' - which is not less than the value itself. */ - -static inline unsigned -ceiling (value, boundary) - register unsigned value; - register unsigned boundary; -{ - return (((value + boundary - 1) / boundary) * boundary); -} - -/* Given a pointer to what is assumed to be a FIELD_DECL node, return a - pointer to the declared type for the relevant field variable, or return - `integer_type_node' if the given node turns out to be an - ERROR_MARK node. */ - -static inline tree -field_type (decl) - register tree decl; -{ - register tree type; - - if (TREE_CODE (decl) == ERROR_MARK) - return integer_type_node; - - type = DECL_BIT_FIELD_TYPE (decl); - if (type == NULL_TREE) - type = TREE_TYPE (decl); - - return type; -} - -/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE - node, return the alignment in bits for the type, or else return - BITS_PER_WORD if the node actually turns out to be an - ERROR_MARK node. */ - -static inline unsigned -simple_type_align_in_bits (type) - register tree type; -{ - return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD; -} - -/* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE - node, return the size in bits for the type if it is a constant, or else - return the alignment for the type if the type's size is not constant, or - else return BITS_PER_WORD if the type actually turns out to be an - ERROR_MARK node. */ - -static inline unsigned -simple_type_size_in_bits (type) - register tree type; -{ - if (TREE_CODE (type) == ERROR_MARK) - return BITS_PER_WORD; - else - { - register tree type_size_tree = TYPE_SIZE (type); - - if (TREE_CODE (type_size_tree) != INTEGER_CST) - return TYPE_ALIGN (type); - - return (unsigned) TREE_INT_CST_LOW (type_size_tree); - } -} - -/* Given a pointer to what is assumed to be a FIELD_DECL node, compute and - return the byte offset of the lowest addressed byte of the "containing - object" for the given FIELD_DECL, or return 0 if we are unable to - determine what that offset is, either because the argument turns out to - be a pointer to an ERROR_MARK node, or because the offset is actually - variable. (We can't handle the latter case just yet). */ - -static unsigned -field_byte_offset (decl) - register tree decl; -{ - register unsigned type_align_in_bytes; - register unsigned type_align_in_bits; - register unsigned type_size_in_bits; - register unsigned object_offset_in_align_units; - register unsigned object_offset_in_bits; - register unsigned object_offset_in_bytes; - register tree type; - register tree bitpos_tree; - register tree field_size_tree; - register unsigned bitpos_int; - register unsigned deepest_bitpos; - register unsigned field_size_in_bits; - - if (TREE_CODE (decl) == ERROR_MARK) - return 0; - - if (TREE_CODE (decl) != FIELD_DECL) - abort (); - - type = field_type (decl); - - bitpos_tree = DECL_FIELD_BITPOS (decl); - field_size_tree = DECL_SIZE (decl); - - /* We cannot yet cope with fields whose positions or sizes are variable, so - for now, when we see such things, we simply return 0. Someday, we may - be able to handle such cases, but it will be damn difficult. */ - if (TREE_CODE (bitpos_tree) != INTEGER_CST) - return 0; - bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); - - if (TREE_CODE (field_size_tree) != INTEGER_CST) - return 0; - - field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree); - type_size_in_bits = simple_type_size_in_bits (type); - type_align_in_bits = simple_type_align_in_bits (type); - type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT; - - /* Note that the GCC front-end doesn't make any attempt to keep track of - the starting bit offset (relative to the start of the containing - structure type) of the hypothetical "containing object" for a bit- - field. Thus, when computing the byte offset value for the start of the - "containing object" of a bit-field, we must deduce this information on - our own. This can be rather tricky to do in some cases. For example, - handling the following structure type definition when compiling for an - i386/i486 target (which only aligns long long's to 32-bit boundaries) - can be very tricky: - - struct S { int field1; long long field2:31; }; - - Fortunately, there is a simple rule-of-thumb which can be - used in such cases. When compiling for an i386/i486, GCC will allocate - 8 bytes for the structure shown above. It decides to do this based upon - one simple rule for bit-field allocation. Quite simply, GCC allocates - each "containing object" for each bit-field at the first (i.e. lowest - addressed) legitimate alignment boundary (based upon the required - minimum alignment for the declared type of the field) which it can - possibly use, subject to the condition that there is still enough - available space remaining in the containing object (when allocated at - the selected point) to fully accommodate all of the bits of the - bit-field itself. This simple rule makes it obvious why GCC allocates - 8 bytes for each object of the structure type shown above. When looking - for a place to allocate the "containing object" for `field2', the - compiler simply tries to allocate a 64-bit "containing object" at each - successive 32-bit boundary (starting at zero) until it finds a place to - allocate that 64- bit field such that at least 31 contiguous (and - previously unallocated) bits remain within that selected 64 bit field. - (As it turns out, for the example above, the compiler finds that it is - OK to allocate the "containing object" 64-bit field at bit-offset zero - within the structure type.) Here we attempt to work backwards from the - limited set of facts we're given, and we try to deduce from those facts, - where GCC must have believed that the containing object started (within - the structure type). The value we deduce is then used (by the callers of - this routine) to generate DW_AT_location and DW_AT_bit_offset attributes - for fields (both bit-fields and, in the case of DW_AT_location, regular - fields as well). */ - - /* Figure out the bit-distance from the start of the structure to the - "deepest" bit of the bit-field. */ - deepest_bitpos = bitpos_int + field_size_in_bits; - - /* This is the tricky part. Use some fancy footwork to deduce where the - lowest addressed bit of the containing object must be. */ - object_offset_in_bits - = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits; - - /* Compute the offset of the containing object in "alignment units". */ - object_offset_in_align_units = object_offset_in_bits / type_align_in_bits; - - /* Compute the offset of the containing object in bytes. */ - object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes; - - return object_offset_in_bytes; -} - -/* The following routines define various Dwarf attributes and any data - associated with them. */ - -/* Add a location description attribute value to a DIE. - - This emits location attributes suitable for whole variables and - whole parameters. Note that the location attributes for struct fields are - generated by the routine `data_member_location_attribute' below. */ - -static void -add_AT_location_description (die, attr_kind, rtl) - dw_die_ref die; - enum dwarf_attribute attr_kind; - register rtx rtl; -{ - /* Handle a special case. If we are about to output a location descriptor - for a variable or parameter which has been optimized out of existence, - don't do that. A variable which has been optimized out - of existence will have a DECL_RTL value which denotes a pseudo-reg. - Currently, in some rare cases, variables can have DECL_RTL values which - look like (MEM (REG pseudo-reg#)). These cases are due to bugs - elsewhere in the compiler. We treat such cases as if the variable(s) in - question had been optimized out of existence. */ - - if (is_pseudo_reg (rtl) - || (GET_CODE (rtl) == MEM - && is_pseudo_reg (XEXP (rtl, 0))) - || (GET_CODE (rtl) == CONCAT - && is_pseudo_reg (XEXP (rtl, 0)) - && is_pseudo_reg (XEXP (rtl, 1)))) - return; - - add_AT_loc (die, attr_kind, loc_descriptor (rtl)); -} - -/* Attach the specialized form of location attribute used for data - members of struct and union types. In the special case of a - FIELD_DECL node which represents a bit-field, the "offset" part - of this special location descriptor must indicate the distance - in bytes from the lowest-addressed byte of the containing struct - or union type to the lowest-addressed byte of the "containing - object" for the bit-field. (See the `field_byte_offset' function - above).. For any given bit-field, the "containing object" is a - hypothetical object (of some integral or enum type) within which - the given bit-field lives. The type of this hypothetical - "containing object" is always the same as the declared type of - the individual bit-field itself (for GCC anyway... the DWARF - spec doesn't actually mandate this). Note that it is the size - (in bytes) of the hypothetical "containing object" which will - be given in the DW_AT_byte_size attribute for this bit-field. - (See the `byte_size_attribute' function below.) It is also used - when calculating the value of the DW_AT_bit_offset attribute. - (See the `bit_offset_attribute' function below). */ - -static void -add_data_member_location_attribute (die, decl) - register dw_die_ref die; - register tree decl; -{ - register unsigned long offset; - register dw_loc_descr_ref loc_descr; - register enum dwarf_location_atom op; - - if (TREE_CODE (decl) == TREE_VEC) - offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl)); - else - offset = field_byte_offset (decl); - - /* The DWARF2 standard says that we should assume that the structure address - is already on the stack, so we can specify a structure field address - by using DW_OP_plus_uconst. */ - -#ifdef MIPS_DEBUGGING_INFO - /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator - correctly. It works only if we leave the offset on the stack. */ - op = DW_OP_constu; -#else - op = DW_OP_plus_uconst; -#endif - - loc_descr = new_loc_descr (op, offset, 0); - add_AT_loc (die, DW_AT_data_member_location, loc_descr); -} - -/* Attach an DW_AT_const_value attribute for a variable or a parameter which - does not have a "location" either in memory or in a register. These - things can arise in GNU C when a constant is passed as an actual parameter - to an inlined function. They can also arise in C++ where declared - constants do not necessarily get memory "homes". */ - -static void -add_const_value_attribute (die, rtl) - register dw_die_ref die; - register rtx rtl; -{ - switch (GET_CODE (rtl)) - { - case CONST_INT: - /* Note that a CONST_INT rtx could represent either an integer or a - floating-point constant. A CONST_INT is used whenever the constant - will fit into a single word. In all such cases, the original mode - of the constant value is wiped out, and the CONST_INT rtx is - assigned VOIDmode. */ - add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl)); - break; - - case CONST_DOUBLE: - /* Note that a CONST_DOUBLE rtx could represent either an integer or a - floating-point constant. A CONST_DOUBLE is used whenever the - constant requires more than one word in order to be adequately - represented. We output CONST_DOUBLEs as blocks. */ - { - register enum machine_mode mode = GET_MODE (rtl); - - if (GET_MODE_CLASS (mode) == MODE_FLOAT) - { - register unsigned length = GET_MODE_SIZE (mode) / sizeof (long); - long array[4]; - REAL_VALUE_TYPE rv; - - REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl); - switch (mode) - { - case SFmode: - REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]); - break; - - case DFmode: - REAL_VALUE_TO_TARGET_DOUBLE (rv, array); - break; - - case XFmode: - case TFmode: - REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array); - break; - - default: - abort (); - } - - add_AT_float (die, DW_AT_const_value, length, array); - } - else - add_AT_long_long (die, DW_AT_const_value, - CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); - } - break; - - case CONST_STRING: - add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0)); - break; - - case SYMBOL_REF: - case LABEL_REF: - case CONST: - add_AT_addr (die, DW_AT_const_value, save_rtx (rtl)); - break; - - case PLUS: - /* In cases where an inlined instance of an inline function is passed - the address of an `auto' variable (which is local to the caller) we - can get a situation where the DECL_RTL of the artificial local - variable (for the inlining) which acts as a stand-in for the - corresponding formal parameter (of the inline function) will look - like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not - exactly a compile-time constant expression, but it isn't the address - of the (artificial) local variable either. Rather, it represents the - *value* which the artificial local variable always has during its - lifetime. We currently have no way to represent such quasi-constant - values in Dwarf, so for now we just punt and generate nothing. */ - break; - - default: - /* No other kinds of rtx should be possible here. */ - abort (); - } - -} - -/* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value - data attribute for a variable or a parameter. We generate the - DW_AT_const_value attribute only in those cases where the given variable - or parameter does not have a true "location" either in memory or in a - register. This can happen (for example) when a constant is passed as an - actual argument in a call to an inline function. (It's possible that - these things can crop up in other ways also.) Note that one type of - constant value which can be passed into an inlined function is a constant - pointer. This can happen for example if an actual argument in an inlined - function call evaluates to a compile-time constant address. */ - -static void -add_location_or_const_value_attribute (die, decl) - register dw_die_ref die; - register tree decl; -{ - register rtx rtl; - register tree declared_type; - register tree passed_type; - - if (TREE_CODE (decl) == ERROR_MARK) - return; - - if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL) - abort (); - - /* Here we have to decide where we are going to say the parameter "lives" - (as far as the debugger is concerned). We only have a couple of - choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL. - - DECL_RTL normally indicates where the parameter lives during most of the - activation of the function. If optimization is enabled however, this - could be either NULL or else a pseudo-reg. Both of those cases indicate - that the parameter doesn't really live anywhere (as far as the code - generation parts of GCC are concerned) during most of the function's - activation. That will happen (for example) if the parameter is never - referenced within the function. - - We could just generate a location descriptor here for all non-NULL - non-pseudo values of DECL_RTL and ignore all of the rest, but we can be - a little nicer than that if we also consider DECL_INCOMING_RTL in cases - where DECL_RTL is NULL or is a pseudo-reg. - - Note however that we can only get away with using DECL_INCOMING_RTL as - a backup substitute for DECL_RTL in certain limited cases. In cases - where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl), - we can be sure that the parameter was passed using the same type as it is - declared to have within the function, and that its DECL_INCOMING_RTL - points us to a place where a value of that type is passed. - - In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different, - we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL - because in these cases DECL_INCOMING_RTL points us to a value of some - type which is *different* from the type of the parameter itself. Thus, - if we tried to use DECL_INCOMING_RTL to generate a location attribute in - such cases, the debugger would end up (for example) trying to fetch a - `float' from a place which actually contains the first part of a - `double'. That would lead to really incorrect and confusing - output at debug-time. - - So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL - in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There - are a couple of exceptions however. On little-endian machines we can - get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is - not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is - an integral type that is smaller than TREE_TYPE (decl). These cases arise - when (on a little-endian machine) a non-prototyped function has a - parameter declared to be of type `short' or `char'. In such cases, - TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will - be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the - passed `int' value. If the debugger then uses that address to fetch - a `short' or a `char' (on a little-endian machine) the result will be - the correct data, so we allow for such exceptional cases below. - - Note that our goal here is to describe the place where the given formal - parameter lives during most of the function's activation (i.e. between - the end of the prologue and the start of the epilogue). We'll do that - as best as we can. Note however that if the given formal parameter is - modified sometime during the execution of the function, then a stack - backtrace (at debug-time) will show the function as having been - called with the *new* value rather than the value which was - originally passed in. This happens rarely enough that it is not - a major problem, but it *is* a problem, and I'd like to fix it. - - A future version of dwarf2out.c may generate two additional - attributes for any given DW_TAG_formal_parameter DIE which will - describe the "passed type" and the "passed location" for the - given formal parameter in addition to the attributes we now - generate to indicate the "declared type" and the "active - location" for each parameter. This additional set of attributes - could be used by debuggers for stack backtraces. Separately, note - that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be - NULL also. This happens (for example) for inlined-instances of - inline function formal parameters which are never referenced. - This really shouldn't be happening. All PARM_DECL nodes should - get valid non-NULL DECL_INCOMING_RTL values, but integrate.c - doesn't currently generate these values for inlined instances of - inline function parameters, so when we see such cases, we are - just out-of-luck for the time being (until integrate.c - gets fixed). */ - - /* Use DECL_RTL as the "location" unless we find something better. */ - rtl = DECL_RTL (decl); - - if (TREE_CODE (decl) == PARM_DECL) - { - if (rtl == NULL_RTX || is_pseudo_reg (rtl)) - { - declared_type = type_main_variant (TREE_TYPE (decl)); - passed_type = type_main_variant (DECL_ARG_TYPE (decl)); - - /* This decl represents a formal parameter which was optimized out. - Note that DECL_INCOMING_RTL may be NULL in here, but we handle - all* cases where (rtl == NULL_RTX) just below. */ - if (declared_type == passed_type) - rtl = DECL_INCOMING_RTL (decl); - else if (! BYTES_BIG_ENDIAN - && TREE_CODE (declared_type) == INTEGER_TYPE - && TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type)) - rtl = DECL_INCOMING_RTL (decl); - } - } - - if (rtl == NULL_RTX) - return; - - rtl = eliminate_regs (rtl, 0, NULL_RTX); -#ifdef LEAF_REG_REMAP - if (leaf_function) - leaf_renumber_regs_insn (rtl); -#endif - - switch (GET_CODE (rtl)) - { - case ADDRESSOF: - /* The address of a variable that was optimized away; don't emit - anything. */ - break; - - case CONST_INT: - case CONST_DOUBLE: - case CONST_STRING: - case SYMBOL_REF: - case LABEL_REF: - case CONST: - case PLUS: - /* DECL_RTL could be (plus (reg ...) (const_int ...)) */ - add_const_value_attribute (die, rtl); - break; - - case MEM: - case REG: - case SUBREG: - case CONCAT: - add_AT_location_description (die, DW_AT_location, rtl); - break; - - default: - abort (); - } -} - -/* Generate an DW_AT_name attribute given some string value to be included as - the value of the attribute. */ - -static inline void -add_name_attribute (die, name_string) - register dw_die_ref die; - register char *name_string; -{ - if (name_string != NULL && *name_string != 0) - add_AT_string (die, DW_AT_name, name_string); -} - -/* Given a tree node describing an array bound (either lower or upper) output - a representation for that bound. */ - -static void -add_bound_info (subrange_die, bound_attr, bound) - register dw_die_ref subrange_die; - register enum dwarf_attribute bound_attr; - register tree bound; -{ - register unsigned bound_value = 0; - - /* If this is an Ada unconstrained array type, then don't emit any debug - info because the array bounds are unknown. They are parameterized when - the type is instantiated. */ - if (contains_placeholder_p (bound)) - return; - - switch (TREE_CODE (bound)) - { - case ERROR_MARK: - return; - - /* All fixed-bounds are represented by INTEGER_CST nodes. */ - case INTEGER_CST: - bound_value = TREE_INT_CST_LOW (bound); - if (bound_attr == DW_AT_lower_bound - && ((is_c_family () && bound_value == 0) - || (is_fortran () && bound_value == 1))) - /* use the default */; - else - add_AT_unsigned (subrange_die, bound_attr, bound_value); - break; - - case CONVERT_EXPR: - case NOP_EXPR: - case NON_LVALUE_EXPR: - add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0)); - break; - - case SAVE_EXPR: - /* If optimization is turned on, the SAVE_EXPRs that describe how to - access the upper bound values may be bogus. If they refer to a - register, they may only describe how to get at these values at the - points in the generated code right after they have just been - computed. Worse yet, in the typical case, the upper bound values - will not even *be* computed in the optimized code (though the - number of elements will), so these SAVE_EXPRs are entirely - bogus. In order to compensate for this fact, we check here to see - if optimization is enabled, and if so, we don't add an attribute - for the (unknown and unknowable) upper bound. This should not - cause too much trouble for existing (stupid?) debuggers because - they have to deal with empty upper bounds location descriptions - anyway in order to be able to deal with incomplete array types. - Of course an intelligent debugger (GDB?) should be able to - comprehend that a missing upper bound specification in a array - type used for a storage class `auto' local array variable - indicates that the upper bound is both unknown (at compile- time) - and unknowable (at run-time) due to optimization. - - We assume that a MEM rtx is safe because gcc wouldn't put the - value there unless it was going to be used repeatedly in the - function, i.e. for cleanups. */ - if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM) - { - register dw_die_ref ctx = lookup_decl_die (current_function_decl); - register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx); - register rtx loc = SAVE_EXPR_RTL (bound); - - /* If the RTL for the SAVE_EXPR is memory, handle the case where - it references an outer function's frame. */ - - if (GET_CODE (loc) == MEM) - { - rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound); - - if (XEXP (loc, 0) != new_addr) - loc = gen_rtx (MEM, GET_MODE (loc), new_addr); - } - - add_AT_flag (decl_die, DW_AT_artificial, 1); - add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx); - add_AT_location_description (decl_die, DW_AT_location, loc); - add_AT_die_ref (subrange_die, bound_attr, decl_die); - } - - /* Else leave out the attribute. */ - break; - - case MAX_EXPR: - case VAR_DECL: - case COMPONENT_REF: - /* ??? These types of bounds can be created by the Ada front end, - and it isn't clear how to emit debug info for them. */ - break; - - default: - abort (); - } -} - -/* Note that the block of subscript information for an array type also - includes information about the element type of type given array type. */ - -static void -add_subscript_info (type_die, type) - register dw_die_ref type_die; - register tree type; -{ -#ifndef MIPS_DEBUGGING_INFO - register unsigned dimension_number; -#endif - register tree lower, upper; - register dw_die_ref subrange_die; - - /* The GNU compilers represent multidimensional array types as sequences of - one dimensional array types whose element types are themselves array - types. Here we squish that down, so that each multidimensional array - type gets only one array_type DIE in the Dwarf debugging info. The draft - Dwarf specification say that we are allowed to do this kind of - compression in C (because there is no difference between an array or - arrays and a multidimensional array in C) but for other source languages - (e.g. Ada) we probably shouldn't do this. */ - - /* ??? The SGI dwarf reader fails for multidimensional arrays with a - const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. - We work around this by disabling this feature. See also - gen_array_type_die. */ -#ifndef MIPS_DEBUGGING_INFO - for (dimension_number = 0; - TREE_CODE (type) == ARRAY_TYPE; - type = TREE_TYPE (type), dimension_number++) - { -#endif - register tree domain = TYPE_DOMAIN (type); - - /* Arrays come in three flavors: Unspecified bounds, fixed bounds, - and (in GNU C only) variable bounds. Handle all three forms - here. */ - subrange_die = new_die (DW_TAG_subrange_type, type_die); - if (domain) - { - /* We have an array type with specified bounds. */ - lower = TYPE_MIN_VALUE (domain); - upper = TYPE_MAX_VALUE (domain); - - /* define the index type. */ - if (TREE_TYPE (domain)) - { - /* ??? This is probably an Ada unnamed subrange type. Ignore the - TREE_TYPE field. We can't emit debug info for this - because it is an unnamed integral type. */ - if (TREE_CODE (domain) == INTEGER_TYPE - && TYPE_NAME (domain) == NULL_TREE - && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE - && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE) - ; - else - add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0, - type_die); - } - - /* ??? If upper is NULL, the array has unspecified length, - but it does have a lower bound. This happens with Fortran - dimension arr(N:*) - Since the debugger is definitely going to need to know N - to produce useful results, go ahead and output the lower - bound solo, and hope the debugger can cope. */ - - add_bound_info (subrange_die, DW_AT_lower_bound, lower); - if (upper) - add_bound_info (subrange_die, DW_AT_upper_bound, upper); - } - else - /* We have an array type with an unspecified length. The DWARF-2 - spec does not say how to handle this; let's just leave out the - bounds. */ - {;} - - -#ifndef MIPS_DEBUGGING_INFO - } -#endif -} - -static void -add_byte_size_attribute (die, tree_node) - dw_die_ref die; - register tree tree_node; -{ - register unsigned size; - - switch (TREE_CODE (tree_node)) - { - case ERROR_MARK: - size = 0; - break; - case ENUMERAL_TYPE: - case RECORD_TYPE: - case UNION_TYPE: - case QUAL_UNION_TYPE: - size = int_size_in_bytes (tree_node); - break; - case FIELD_DECL: - /* For a data member of a struct or union, the DW_AT_byte_size is - generally given as the number of bytes normally allocated for an - object of the *declared* type of the member itself. This is true - even for bit-fields. */ - size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT; - break; - default: - abort (); - } - - /* Note that `size' might be -1 when we get to this point. If it is, that - indicates that the byte size of the entity in question is variable. We - have no good way of expressing this fact in Dwarf at the present time, - so just let the -1 pass on through. */ - - add_AT_unsigned (die, DW_AT_byte_size, size); -} - -/* For a FIELD_DECL node which represents a bit-field, output an attribute - which specifies the distance in bits from the highest order bit of the - "containing object" for the bit-field to the highest order bit of the - bit-field itself. - - For any given bit-field, the "containing object" is a hypothetical - object (of some integral or enum type) within which the given bit-field - lives. The type of this hypothetical "containing object" is always the - same as the declared type of the individual bit-field itself. The - determination of the exact location of the "containing object" for a - bit-field is rather complicated. It's handled by the - `field_byte_offset' function (above). - - Note that it is the size (in bytes) of the hypothetical "containing object" - which will be given in the DW_AT_byte_size attribute for this bit-field. - (See `byte_size_attribute' above). */ - -static inline void -add_bit_offset_attribute (die, decl) - register dw_die_ref die; - register tree decl; -{ - register unsigned object_offset_in_bytes = field_byte_offset (decl); - register tree type = DECL_BIT_FIELD_TYPE (decl); - register tree bitpos_tree = DECL_FIELD_BITPOS (decl); - register unsigned bitpos_int; - register unsigned highest_order_object_bit_offset; - register unsigned highest_order_field_bit_offset; - register unsigned bit_offset; - - /* Must be a field and a bit field. */ - if (!type - || TREE_CODE (decl) != FIELD_DECL) - abort (); - - /* We can't yet handle bit-fields whose offsets are variable, so if we - encounter such things, just return without generating any attribute - whatsoever. */ - if (TREE_CODE (bitpos_tree) != INTEGER_CST) - return; - - bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree); - - /* Note that the bit offset is always the distance (in bits) from the - highest-order bit of the "containing object" to the highest-order bit of - the bit-field itself. Since the "high-order end" of any object or field - is different on big-endian and little-endian machines, the computation - below must take account of these differences. */ - highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT; - highest_order_field_bit_offset = bitpos_int; - - if (! BYTES_BIG_ENDIAN) - { - highest_order_field_bit_offset - += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)); - - highest_order_object_bit_offset += simple_type_size_in_bits (type); - } - - bit_offset - = (! BYTES_BIG_ENDIAN - ? highest_order_object_bit_offset - highest_order_field_bit_offset - : highest_order_field_bit_offset - highest_order_object_bit_offset); - - add_AT_unsigned (die, DW_AT_bit_offset, bit_offset); -} - -/* For a FIELD_DECL node which represents a bit field, output an attribute - which specifies the length in bits of the given field. */ - -static inline void -add_bit_size_attribute (die, decl) - register dw_die_ref die; - register tree decl; -{ - /* Must be a field and a bit field. */ - if (TREE_CODE (decl) != FIELD_DECL - || ! DECL_BIT_FIELD_TYPE (decl)) - abort (); - add_AT_unsigned (die, DW_AT_bit_size, - (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl))); -} - -/* If the compiled language is ANSI C, then add a 'prototyped' - attribute, if arg types are given for the parameters of a function. */ - -static inline void -add_prototyped_attribute (die, func_type) - register dw_die_ref die; - register tree func_type; -{ - if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89 - && TYPE_ARG_TYPES (func_type) != NULL) - add_AT_flag (die, DW_AT_prototyped, 1); -} - - -/* Add an 'abstract_origin' attribute below a given DIE. The DIE is found - by looking in either the type declaration or object declaration - equate table. */ - -static inline void -add_abstract_origin_attribute (die, origin) - register dw_die_ref die; - register tree origin; -{ - dw_die_ref origin_die = NULL; - if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd') - origin_die = lookup_decl_die (origin); - else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't') - origin_die = lookup_type_die (origin); - - add_AT_die_ref (die, DW_AT_abstract_origin, origin_die); -} - -/* We do not currently support the pure_virtual attribute. */ - -static inline void -add_pure_or_virtual_attribute (die, func_decl) - register dw_die_ref die; - register tree func_decl; -{ - if (DECL_VINDEX (func_decl)) - { - add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); - add_AT_loc (die, DW_AT_vtable_elem_location, - new_loc_descr (DW_OP_constu, - TREE_INT_CST_LOW (DECL_VINDEX (func_decl)), - 0)); - - /* GNU extension: Record what type this method came from originally. */ - if (debug_info_level > DINFO_LEVEL_TERSE) - add_AT_die_ref (die, DW_AT_containing_type, - lookup_type_die (DECL_CONTEXT (func_decl))); - } -} - -/* Add source coordinate attributes for the given decl. */ - -static void -add_src_coords_attributes (die, decl) - register dw_die_ref die; - register tree decl; -{ - register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl)); - - add_AT_unsigned (die, DW_AT_decl_file, file_index); - add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); -} - -/* Add an DW_AT_name attribute and source coordinate attribute for the - given decl, but only if it actually has a name. */ - -static void -add_name_and_src_coords_attributes (die, decl) - register dw_die_ref die; - register tree decl; -{ - register tree decl_name; - - decl_name = DECL_NAME (decl); - if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL) - { - add_name_attribute (die, dwarf2_name (decl, 0)); - add_src_coords_attributes (die, decl); - if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL) - && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)) - add_AT_string (die, DW_AT_MIPS_linkage_name, - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))); - } -} - -/* Push a new declaration scope. */ - -static void -push_decl_scope (scope) - tree scope; -{ - tree containing_scope; - int i; - - /* Make room in the decl_scope_table, if necessary. */ - if (decl_scope_table_allocated == decl_scope_depth) - { - decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT; - decl_scope_table - = (decl_scope_node *) xrealloc (decl_scope_table, - (decl_scope_table_allocated - * sizeof (decl_scope_node))); - } - - decl_scope_table[decl_scope_depth].scope = scope; - - /* Sometimes, while recursively emitting subtypes within a class type, - we end up recuring on a subtype at a higher level then the current - subtype. In such a case, we need to search the decl_scope_table to - find the parent of this subtype. */ - - if (AGGREGATE_TYPE_P (scope)) - containing_scope = TYPE_CONTEXT (scope); - else - containing_scope = NULL_TREE; - - /* The normal case. */ - if (decl_scope_depth == 0 - || containing_scope == NULL_TREE - /* Ignore namespaces for the moment. */ - || TREE_CODE (containing_scope) == NAMESPACE_DECL - || containing_scope == decl_scope_table[decl_scope_depth - 1].scope) - decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1; - else - { - /* We need to search for the containing_scope. */ - for (i = 0; i < decl_scope_depth; i++) - if (decl_scope_table[i].scope == containing_scope) - break; - - if (i == decl_scope_depth) - abort (); - else - decl_scope_table[decl_scope_depth].previous = i; - } - - decl_scope_depth++; -} - -/* Return the DIE for the scope that immediately contains this declaration. */ - -static dw_die_ref -scope_die_for (t, context_die) - register tree t; - register dw_die_ref context_die; -{ - register dw_die_ref scope_die = NULL; - register tree containing_scope; - register int i; - - /* Walk back up the declaration tree looking for a place to define - this type. */ - if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') - containing_scope = TYPE_CONTEXT (t); - else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t)) - containing_scope = decl_class_context (t); - else - containing_scope = DECL_CONTEXT (t); - - /* Ignore namespaces for the moment. */ - if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL) - containing_scope = NULL_TREE; - - /* Ignore function type "scopes" from the C frontend. They mean that - a tagged type is local to a parmlist of a function declarator, but - that isn't useful to DWARF. */ - if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE) - containing_scope = NULL_TREE; - - /* Function-local tags and functions get stuck in limbo until they are - fixed up by decls_for_scope. */ - if (context_die == NULL && containing_scope != NULL_TREE - && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t))) - return NULL; - - if (containing_scope == NULL_TREE) - scope_die = comp_unit_die; - else - { - for (i = decl_scope_depth - 1, scope_die = context_die; - i >= 0 && decl_scope_table[i].scope != containing_scope; - (scope_die = scope_die->die_parent, - i = decl_scope_table[i].previous)) - ; - - /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor - does it try to handle types defined by TYPE_DECLs. Such types - thus have an incorrect TYPE_CONTEXT, which points to the block - they were originally defined in, instead of the current block - created by function inlining. We try to detect that here and - work around it. */ - - if (i < 0 && scope_die == comp_unit_die - && TREE_CODE (containing_scope) == BLOCK - && is_tagged_type (t) - && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope) - == containing_scope)) - { - scope_die = context_die; - /* Since the checks below are no longer applicable. */ - i = 0; - } - - if (i < 0) - { - if (scope_die != comp_unit_die - || TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't') - abort (); - if (debug_info_level > DINFO_LEVEL_TERSE - && !TREE_ASM_WRITTEN (containing_scope)) - abort (); - } - } - - return scope_die; -} - -/* Pop a declaration scope. */ -static inline void -pop_decl_scope () -{ - if (decl_scope_depth <= 0) - abort (); - --decl_scope_depth; -} - -/* Many forms of DIEs require a "type description" attribute. This - routine locates the proper "type descriptor" die for the type given - by 'type', and adds an DW_AT_type attribute below the given die. */ - -static void -add_type_attribute (object_die, type, decl_const, decl_volatile, context_die) - register dw_die_ref object_die; - register tree type; - register int decl_const; - register int decl_volatile; - register dw_die_ref context_die; -{ - register enum tree_code code = TREE_CODE (type); - register dw_die_ref type_die = NULL; - - /* ??? If this type is an unnamed subrange type of an integral or - floating-point type, use the inner type. This is because we have no - support for unnamed types in base_type_die. This can happen if this is - an Ada subrange type. Correct solution is emit a subrange type die. */ - if ((code == INTEGER_TYPE || code == REAL_TYPE) - && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0) - type = TREE_TYPE (type), code = TREE_CODE (type); - - if (code == ERROR_MARK) - return; - - /* Handle a special case. For functions whose return type is void, we - generate *no* type attribute. (Note that no object may have type - `void', so this only applies to function return types). */ - if (code == VOID_TYPE) - return; - - type_die = modified_type_die (type, - decl_const || TYPE_READONLY (type), - decl_volatile || TYPE_VOLATILE (type), - context_die); - if (type_die != NULL) - add_AT_die_ref (object_die, DW_AT_type, type_die); -} - -/* Given a tree pointer to a struct, class, union, or enum type node, return - a pointer to the (string) tag name for the given type, or zero if the type - was declared without a tag. */ - -static char * -type_tag (type) - register tree type; -{ - register char *name = 0; - - if (TYPE_NAME (type) != 0) - { - register tree t = 0; - - /* Find the IDENTIFIER_NODE for the type name. */ - if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) - t = TYPE_NAME (type); - - /* The g++ front end makes the TYPE_NAME of *each* tagged type point to - a TYPE_DECL node, regardless of whether or not a `typedef' was - involved. */ - else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL - && ! DECL_IGNORED_P (TYPE_NAME (type))) - t = DECL_NAME (TYPE_NAME (type)); - - /* Now get the name as a string, or invent one. */ - if (t != 0) - name = IDENTIFIER_POINTER (t); - } - - return (name == 0 || *name == '\0') ? 0 : name; -} - -/* Return the type associated with a data member, make a special check - for bit field types. */ - -static inline tree -member_declared_type (member) - register tree member; -{ - return (DECL_BIT_FIELD_TYPE (member) - ? DECL_BIT_FIELD_TYPE (member) - : TREE_TYPE (member)); -} - -/* Get the decl's label, as described by its RTL. This may be different - from the DECL_NAME name used in the source file. */ - -#if 0 -static char * -decl_start_label (decl) - register tree decl; -{ - rtx x; - char *fnname; - x = DECL_RTL (decl); - if (GET_CODE (x) != MEM) - abort (); - - x = XEXP (x, 0); - if (GET_CODE (x) != SYMBOL_REF) - abort (); - - fnname = XSTR (x, 0); - return fnname; -} -#endif - -/* These routines generate the internal representation of the DIE's for - the compilation unit. Debugging information is collected by walking - the declaration trees passed in from dwarf2out_decl(). */ - -static void -gen_array_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref scope_die = scope_die_for (type, context_die); - register dw_die_ref array_die; - register tree element_type; - - /* ??? The SGI dwarf reader fails for array of array of enum types unless - the inner array type comes before the outer array type. Thus we must - call gen_type_die before we call new_die. See below also. */ -#ifdef MIPS_DEBUGGING_INFO - gen_type_die (TREE_TYPE (type), context_die); -#endif - - array_die = new_die (DW_TAG_array_type, scope_die); - -#if 0 - /* We default the array ordering. SDB will probably do - the right things even if DW_AT_ordering is not present. It's not even - an issue until we start to get into multidimensional arrays anyway. If - SDB is ever caught doing the Wrong Thing for multi-dimensional arrays, - then we'll have to put the DW_AT_ordering attribute back in. (But if - and when we find out that we need to put these in, we will only do so - for multidimensional arrays. */ - add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major); -#endif - -#ifdef MIPS_DEBUGGING_INFO - /* The SGI compilers handle arrays of unknown bound by setting - AT_declaration and not emitting any subrange DIEs. */ - if (! TYPE_DOMAIN (type)) - add_AT_unsigned (array_die, DW_AT_declaration, 1); - else -#endif - add_subscript_info (array_die, type); - - equate_type_number_to_die (type, array_die); - - /* Add representation of the type of the elements of this array type. */ - element_type = TREE_TYPE (type); - - /* ??? The SGI dwarf reader fails for multidimensional arrays with a - const enum type. E.g. const enum machine_mode insn_operand_mode[2][10]. - We work around this by disabling this feature. See also - add_subscript_info. */ -#ifndef MIPS_DEBUGGING_INFO - while (TREE_CODE (element_type) == ARRAY_TYPE) - element_type = TREE_TYPE (element_type); - - gen_type_die (element_type, context_die); -#endif - - add_type_attribute (array_die, element_type, 0, 0, context_die); -} - -static void -gen_set_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die - = new_die (DW_TAG_set_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, type_die); - add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die); -} - -#if 0 -static void -gen_entry_point_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register tree origin = decl_ultimate_origin (decl); - register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die); - if (origin != NULL) - add_abstract_origin_attribute (decl_die, origin); - else - { - add_name_and_src_coords_attributes (decl_die, decl); - add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)), - 0, 0, context_die); - } - - if (DECL_ABSTRACT (decl)) - equate_decl_number_to_die (decl, decl_die); - else - add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl)); -} -#endif - -/* Remember a type in the pending_types_list. */ - -static void -pend_type (type) - register tree type; -{ - if (pending_types == pending_types_allocated) - { - pending_types_allocated += PENDING_TYPES_INCREMENT; - pending_types_list - = (tree *) xrealloc (pending_types_list, - sizeof (tree) * pending_types_allocated); - } - - pending_types_list[pending_types++] = type; -} - -/* Output any pending types (from the pending_types list) which we can output - now (taking into account the scope that we are working on now). - - For each type output, remove the given type from the pending_types_list - *before* we try to output it. */ - -static void -output_pending_types_for_scope (context_die) - register dw_die_ref context_die; -{ - register tree type; - - while (pending_types) - { - --pending_types; - type = pending_types_list[pending_types]; - gen_type_die (type, context_die); - if (!TREE_ASM_WRITTEN (type)) - abort (); - } -} - -/* Generate a DIE to represent an inlined instance of an enumeration type. */ - -static void -gen_inlined_enumeration_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die = new_die (DW_TAG_enumeration_type, - scope_die_for (type, context_die)); - - if (!TREE_ASM_WRITTEN (type)) - abort (); - add_abstract_origin_attribute (type_die, type); -} - -/* Generate a DIE to represent an inlined instance of a structure type. */ - -static void -gen_inlined_structure_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die = new_die (DW_TAG_structure_type, - scope_die_for (type, context_die)); - - if (!TREE_ASM_WRITTEN (type)) - abort (); - add_abstract_origin_attribute (type_die, type); -} - -/* Generate a DIE to represent an inlined instance of a union type. */ - -static void -gen_inlined_union_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die = new_die (DW_TAG_union_type, - scope_die_for (type, context_die)); - - if (!TREE_ASM_WRITTEN (type)) - abort (); - add_abstract_origin_attribute (type_die, type); -} - -/* Generate a DIE to represent an enumeration type. Note that these DIEs - include all of the information about the enumeration values also. Each - enumerated type name/value is listed as a child of the enumerated type - DIE. */ - -static void -gen_enumeration_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die = lookup_type_die (type); - - if (type_die == NULL) - { - type_die = new_die (DW_TAG_enumeration_type, - scope_die_for (type, context_die)); - equate_type_number_to_die (type, type_die); - add_name_attribute (type_die, type_tag (type)); - } - else if (! TYPE_SIZE (type)) - return; - else - remove_AT (type_die, DW_AT_declaration); - - /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the - given enum type is incomplete, do not generate the DW_AT_byte_size - attribute or the DW_AT_element_list attribute. */ - if (TYPE_SIZE (type)) - { - register tree link; - - TREE_ASM_WRITTEN (type) = 1; - add_byte_size_attribute (type_die, type); - if (TYPE_STUB_DECL (type) != NULL_TREE) - add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); - - /* If the first reference to this type was as the return type of an - inline function, then it may not have a parent. Fix this now. */ - if (type_die->die_parent == NULL) - add_child_die (scope_die_for (type, context_die), type_die); - - for (link = TYPE_FIELDS (type); - link != NULL; link = TREE_CHAIN (link)) - { - register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die); - - add_name_attribute (enum_die, - IDENTIFIER_POINTER (TREE_PURPOSE (link))); - add_AT_unsigned (enum_die, DW_AT_const_value, - (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link))); - } - } - else - add_AT_flag (type_die, DW_AT_declaration, 1); -} - - -/* Generate a DIE to represent either a real live formal parameter decl or to - represent just the type of some formal parameter position in some function - type. - - Note that this routine is a bit unusual because its argument may be a - ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which - represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE - node. If it's the former then this function is being called to output a - DIE to represent a formal parameter object (or some inlining thereof). If - it's the latter, then this function is only being called to output a - DW_TAG_formal_parameter DIE to stand as a placeholder for some formal - argument type of some subprogram type. */ - -static dw_die_ref -gen_formal_parameter_die (node, context_die) - register tree node; - register dw_die_ref context_die; -{ - register dw_die_ref parm_die - = new_die (DW_TAG_formal_parameter, context_die); - register tree origin; - - switch (TREE_CODE_CLASS (TREE_CODE (node))) - { - case 'd': - origin = decl_ultimate_origin (node); - if (origin != NULL) - add_abstract_origin_attribute (parm_die, origin); - else - { - add_name_and_src_coords_attributes (parm_die, node); - add_type_attribute (parm_die, TREE_TYPE (node), - TREE_READONLY (node), - TREE_THIS_VOLATILE (node), - context_die); - if (DECL_ARTIFICIAL (node)) - add_AT_flag (parm_die, DW_AT_artificial, 1); - } - - equate_decl_number_to_die (node, parm_die); - if (! DECL_ABSTRACT (node)) - add_location_or_const_value_attribute (parm_die, node); - - break; - - case 't': - /* We were called with some kind of a ..._TYPE node. */ - add_type_attribute (parm_die, node, 0, 0, context_die); - break; - - default: - abort (); - } - - return parm_die; -} - -/* Generate a special type of DIE used as a stand-in for a trailing ellipsis - at the end of an (ANSI prototyped) formal parameters list. */ - -static void -gen_unspecified_parameters_die (decl_or_type, context_die) - register tree decl_or_type; - register dw_die_ref context_die; -{ - new_die (DW_TAG_unspecified_parameters, context_die); -} - -/* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a - DW_TAG_unspecified_parameters DIE) to represent the types of the formal - parameters as specified in some function type specification (except for - those which appear as part of a function *definition*). - - Note we must be careful here to output all of the parameter DIEs before* - we output any DIEs needed to represent the types of the formal parameters. - This keeps svr4 SDB happy because it (incorrectly) thinks that the first - non-parameter DIE it sees ends the formal parameter list. */ - -static void -gen_formal_types_die (function_or_method_type, context_die) - register tree function_or_method_type; - register dw_die_ref context_die; -{ - register tree link; - register tree formal_type = NULL; - register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type); - -#if 0 - /* In the case where we are generating a formal types list for a C++ - non-static member function type, skip over the first thing on the - TYPE_ARG_TYPES list because it only represents the type of the hidden - `this pointer'. The debugger should be able to figure out (without - being explicitly told) that this non-static member function type takes a - `this pointer' and should be able to figure what the type of that hidden - parameter is from the DW_AT_member attribute of the parent - DW_TAG_subroutine_type DIE. */ - if (TREE_CODE (function_or_method_type) == METHOD_TYPE) - first_parm_type = TREE_CHAIN (first_parm_type); -#endif - - /* Make our first pass over the list of formal parameter types and output a - DW_TAG_formal_parameter DIE for each one. */ - for (link = first_parm_type; link; link = TREE_CHAIN (link)) - { - register dw_die_ref parm_die; - - formal_type = TREE_VALUE (link); - if (formal_type == void_type_node) - break; - - /* Output a (nameless) DIE to represent the formal parameter itself. */ - parm_die = gen_formal_parameter_die (formal_type, context_die); - if (TREE_CODE (function_or_method_type) == METHOD_TYPE - && link == first_parm_type) - add_AT_flag (parm_die, DW_AT_artificial, 1); - } - - /* If this function type has an ellipsis, add a - DW_TAG_unspecified_parameters DIE to the end of the parameter list. */ - if (formal_type != void_type_node) - gen_unspecified_parameters_die (function_or_method_type, context_die); - - /* Make our second (and final) pass over the list of formal parameter types - and output DIEs to represent those types (as necessary). */ - for (link = TYPE_ARG_TYPES (function_or_method_type); - link; - link = TREE_CHAIN (link)) - { - formal_type = TREE_VALUE (link); - if (formal_type == void_type_node) - break; - - gen_type_die (formal_type, context_die); - } -} - -/* Generate a DIE to represent a declared function (either file-scope or - block-local). */ - -static void -gen_subprogram_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - char label_id[MAX_ARTIFICIAL_LABEL_BYTES]; - register tree origin = decl_ultimate_origin (decl); - register dw_die_ref subr_die; - register rtx fp_reg; - register tree fn_arg_types; - register tree outer_scope; - register dw_die_ref old_die = lookup_decl_die (decl); - register int declaration - = (current_function_decl != decl - || (context_die - && (context_die->die_tag == DW_TAG_structure_type - || context_die->die_tag == DW_TAG_union_type))); - - if (origin != NULL) - { - subr_die = new_die (DW_TAG_subprogram, context_die); - add_abstract_origin_attribute (subr_die, origin); - } - else if (old_die && DECL_ABSTRACT (decl) - && get_AT_unsigned (old_die, DW_AT_inline)) - { - /* This must be a redefinition of an extern inline function. - We can just reuse the old die here. */ - subr_die = old_die; - - /* Clear out the inlined attribute and parm types. */ - remove_AT (subr_die, DW_AT_inline); - remove_children (subr_die); - } - else if (old_die) - { - register unsigned file_index - = lookup_filename (DECL_SOURCE_FILE (decl)); - - if (get_AT_flag (old_die, DW_AT_declaration) != 1) - { - /* ??? This can happen if there is a bug in the program, for - instance, if it has duplicate function definitions. Ideally, - we should detect this case and ignore it. For now, if we have - already reported an error, any error at all, then assume that - we got here because of a input error, not a dwarf2 bug. */ - extern int errorcount; - if (errorcount) - return; - abort (); - } - - /* If the definition comes from the same place as the declaration, - maybe use the old DIE. We always want the DIE for this function - that has the *_pc attributes to be under comp_unit_die so the - debugger can find it. For inlines, that is the concrete instance, - so we can use the old DIE here. For non-inline methods, we want a - specification DIE at toplevel, so we need a new DIE. For local - class methods, this does not apply. */ - if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die - || context_die == NULL) - && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index - && (get_AT_unsigned (old_die, DW_AT_decl_line) - == DECL_SOURCE_LINE (decl))) - { - subr_die = old_die; - - /* Clear out the declaration attribute and the parm types. */ - remove_AT (subr_die, DW_AT_declaration); - remove_children (subr_die); - } - else - { - subr_die = new_die (DW_TAG_subprogram, context_die); - add_AT_die_ref (subr_die, DW_AT_specification, old_die); - if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) - add_AT_unsigned (subr_die, DW_AT_decl_file, file_index); - if (get_AT_unsigned (old_die, DW_AT_decl_line) - != DECL_SOURCE_LINE (decl)) - add_AT_unsigned - (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl)); - } - } - else - { - register dw_die_ref scope_die; - - if (DECL_CONTEXT (decl)) - scope_die = scope_die_for (decl, context_die); - else - /* Don't put block extern declarations under comp_unit_die. */ - scope_die = context_die; - - subr_die = new_die (DW_TAG_subprogram, scope_die); - - if (TREE_PUBLIC (decl)) - add_AT_flag (subr_die, DW_AT_external, 1); - - add_name_and_src_coords_attributes (subr_die, decl); - if (debug_info_level > DINFO_LEVEL_TERSE) - { - register tree type = TREE_TYPE (decl); - - add_prototyped_attribute (subr_die, type); - add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die); - } - - add_pure_or_virtual_attribute (subr_die, decl); - if (DECL_ARTIFICIAL (decl)) - add_AT_flag (subr_die, DW_AT_artificial, 1); - if (TREE_PROTECTED (decl)) - add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected); - else if (TREE_PRIVATE (decl)) - add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private); - } - - if (declaration) - { - add_AT_flag (subr_die, DW_AT_declaration, 1); - - /* The first time we see a member function, it is in the context of - the class to which it belongs. We make sure of this by emitting - the class first. The next time is the definition, which is - handled above. The two may come from the same source text. */ - if (DECL_CONTEXT (decl)) - equate_decl_number_to_die (decl, subr_die); - } - else if (DECL_ABSTRACT (decl)) - { - /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions, - but not for extern inline functions. We can't get this completely - correct because information about whether the function was declared - inline is not saved anywhere. */ - if (DECL_DEFER_OUTPUT (decl)) - { - if (DECL_INLINE (decl)) - add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined); - else - add_AT_unsigned (subr_die, DW_AT_inline, - DW_INL_declared_not_inlined); - } - else if (DECL_INLINE (decl)) - add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined); - else - abort (); - - equate_decl_number_to_die (decl, subr_die); - } - else if (!DECL_EXTERNAL (decl)) - { - if (origin == NULL_TREE) - equate_decl_number_to_die (decl, subr_die); - - ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL, - current_funcdef_number); - add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id); - ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL, - current_funcdef_number); - add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id); - - add_pubname (decl, subr_die); - add_arange (decl, subr_die); - -#ifdef MIPS_DEBUGGING_INFO - /* Add a reference to the FDE for this routine. */ - add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde); -#endif - - /* Define the "frame base" location for this routine. We use the - frame pointer or stack pointer registers, since the RTL for local - variables is relative to one of them. */ - fp_reg - = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx; - add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg)); - -#if 0 - /* ??? This fails for nested inline functions, because context_display - is not part of the state saved/restored for inline functions. */ - if (current_function_needs_context) - add_AT_location_description (subr_die, DW_AT_static_link, - lookup_static_chain (decl)); -#endif - } - - /* Now output descriptions of the arguments for this function. This gets - (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list - for a FUNCTION_DECL doesn't indicate cases where there was a trailing - `...' at the end of the formal parameter list. In order to find out if - there was a trailing ellipsis or not, we must instead look at the type - associated with the FUNCTION_DECL. This will be a node of type - FUNCTION_TYPE. If the chain of type nodes hanging off of this - FUNCTION_TYPE node ends with a void_type_node then there should *not* be - an ellipsis at the end. */ - push_decl_scope (decl); - - /* In the case where we are describing a mere function declaration, all we - need to do here (and all we *can* do here) is to describe the *types* of - its formal parameters. */ - if (debug_info_level <= DINFO_LEVEL_TERSE) - ; - else if (declaration) - gen_formal_types_die (TREE_TYPE (decl), subr_die); - else - { - /* Generate DIEs to represent all known formal parameters */ - register tree arg_decls = DECL_ARGUMENTS (decl); - register tree parm; - - /* When generating DIEs, generate the unspecified_parameters DIE - instead if we come across the arg "__builtin_va_alist" */ - for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) - if (TREE_CODE (parm) == PARM_DECL) - { - if (DECL_NAME (parm) - && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), - "__builtin_va_alist")) - gen_unspecified_parameters_die (parm, subr_die); - else - gen_decl_die (parm, subr_die); - } - - /* Decide whether we need a unspecified_parameters DIE at the end. - There are 2 more cases to do this for: 1) the ansi ... declaration - - this is detectable when the end of the arg list is not a - void_type_node 2) an unprototyped function declaration (not a - definition). This just means that we have no info about the - parameters at all. */ - fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); - if (fn_arg_types != NULL) - { - /* this is the prototyped case, check for ... */ - if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) - gen_unspecified_parameters_die (decl, subr_die); - } - else if (DECL_INITIAL (decl) == NULL_TREE) - gen_unspecified_parameters_die (decl, subr_die); - } - - /* Output Dwarf info for all of the stuff within the body of the function - (if it has one - it may be just a declaration). */ - outer_scope = DECL_INITIAL (decl); - - /* Note that here, `outer_scope' is a pointer to the outermost BLOCK - node created to represent a function. This outermost BLOCK actually - represents the outermost binding contour for the function, i.e. the - contour in which the function's formal parameters and labels get - declared. Curiously, it appears that the front end doesn't actually - put the PARM_DECL nodes for the current function onto the BLOCK_VARS - list for this outer scope. (They are strung off of the DECL_ARGUMENTS - list for the function instead.) The BLOCK_VARS list for the - `outer_scope' does provide us with a list of the LABEL_DECL nodes for - the function however, and we output DWARF info for those in - decls_for_scope. Just within the `outer_scope' there will be a BLOCK - node representing the function's outermost pair of curly braces, and - any blocks used for the base and member initializers of a C++ - constructor function. */ - if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK) - { - current_function_has_inlines = 0; - decls_for_scope (outer_scope, subr_die, 0); - -#if 0 && defined (MIPS_DEBUGGING_INFO) - if (current_function_has_inlines) - { - add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1); - if (! comp_unit_has_inlines) - { - add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1); - comp_unit_has_inlines = 1; - } - } -#endif - } - - pop_decl_scope (); -} - -/* Generate a DIE to represent a declared data object. */ - -static void -gen_variable_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register tree origin = decl_ultimate_origin (decl); - register dw_die_ref var_die = new_die (DW_TAG_variable, context_die); - - dw_die_ref old_die = lookup_decl_die (decl); - int declaration - = (DECL_EXTERNAL (decl) - || current_function_decl != decl_function_context (decl) - || context_die->die_tag == DW_TAG_structure_type - || context_die->die_tag == DW_TAG_union_type); - - if (origin != NULL) - add_abstract_origin_attribute (var_die, origin); - /* Loop unrolling can create multiple blocks that refer to the same - static variable, so we must test for the DW_AT_declaration flag. */ - /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to - copy decls and set the DECL_ABSTRACT flag on them instead of - sharing them. */ - else if (old_die && TREE_STATIC (decl) - && get_AT_flag (old_die, DW_AT_declaration) == 1) - { - /* ??? This is an instantiation of a C++ class level static. */ - add_AT_die_ref (var_die, DW_AT_specification, old_die); - if (DECL_NAME (decl)) - { - register unsigned file_index - = lookup_filename (DECL_SOURCE_FILE (decl)); - - if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index) - add_AT_unsigned (var_die, DW_AT_decl_file, file_index); - - if (get_AT_unsigned (old_die, DW_AT_decl_line) - != DECL_SOURCE_LINE (decl)) - - add_AT_unsigned (var_die, DW_AT_decl_line, - DECL_SOURCE_LINE (decl)); - } - } - else - { - add_name_and_src_coords_attributes (var_die, decl); - add_type_attribute (var_die, TREE_TYPE (decl), - TREE_READONLY (decl), - TREE_THIS_VOLATILE (decl), context_die); - - if (TREE_PUBLIC (decl)) - add_AT_flag (var_die, DW_AT_external, 1); - - if (DECL_ARTIFICIAL (decl)) - add_AT_flag (var_die, DW_AT_artificial, 1); - - if (TREE_PROTECTED (decl)) - add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected); - - else if (TREE_PRIVATE (decl)) - add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private); - } - - if (declaration) - add_AT_flag (var_die, DW_AT_declaration, 1); - - if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl)) - equate_decl_number_to_die (decl, var_die); - - if (! declaration && ! DECL_ABSTRACT (decl)) - { - equate_decl_number_to_die (decl, var_die); - add_location_or_const_value_attribute (var_die, decl); - add_pubname (decl, var_die); - } -} - -/* Generate a DIE to represent a label identifier. */ - -static void -gen_label_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register tree origin = decl_ultimate_origin (decl); - register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die); - register rtx insn; - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - char label2[MAX_ARTIFICIAL_LABEL_BYTES]; - - if (origin != NULL) - add_abstract_origin_attribute (lbl_die, origin); - else - add_name_and_src_coords_attributes (lbl_die, decl); - - if (DECL_ABSTRACT (decl)) - equate_decl_number_to_die (decl, lbl_die); - else - { - insn = DECL_RTL (decl); - if (GET_CODE (insn) == CODE_LABEL) - { - /* When optimization is enabled (via -O) some parts of the compiler - (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which - represent source-level labels which were explicitly declared by - the user. This really shouldn't be happening though, so catch - it if it ever does happen. */ - if (INSN_DELETED_P (insn)) - abort (); - - sprintf (label2, INSN_LABEL_FMT, current_funcdef_number); - ASM_GENERATE_INTERNAL_LABEL (label, label2, - (unsigned) INSN_UID (insn)); - add_AT_lbl_id (lbl_die, DW_AT_low_pc, label); - } - } -} - -/* Generate a DIE for a lexical block. */ - -static void -gen_lexical_block_die (stmt, context_die, depth) - register tree stmt; - register dw_die_ref context_die; - int depth; -{ - register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die); - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - - if (! BLOCK_ABSTRACT (stmt)) - { - ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, - next_block_number); - add_AT_lbl_id (stmt_die, DW_AT_low_pc, label); - ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number); - add_AT_lbl_id (stmt_die, DW_AT_high_pc, label); - } - - push_decl_scope (stmt); - decls_for_scope (stmt, stmt_die, depth); - pop_decl_scope (); -} - -/* Generate a DIE for an inlined subprogram. */ - -static void -gen_inlined_subroutine_die (stmt, context_die, depth) - register tree stmt; - register dw_die_ref context_die; - int depth; -{ - if (! BLOCK_ABSTRACT (stmt)) - { - register dw_die_ref subr_die - = new_die (DW_TAG_inlined_subroutine, context_die); - register tree decl = block_ultimate_origin (stmt); - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - - add_abstract_origin_attribute (subr_die, decl); - ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL, - next_block_number); - add_AT_lbl_id (subr_die, DW_AT_low_pc, label); - ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number); - add_AT_lbl_id (subr_die, DW_AT_high_pc, label); - push_decl_scope (decl); - decls_for_scope (stmt, subr_die, depth); - pop_decl_scope (); - current_function_has_inlines = 1; - } -} - -/* Generate a DIE for a field in a record, or structure. */ - -static void -gen_field_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register dw_die_ref decl_die = new_die (DW_TAG_member, context_die); - - add_name_and_src_coords_attributes (decl_die, decl); - add_type_attribute (decl_die, member_declared_type (decl), - TREE_READONLY (decl), TREE_THIS_VOLATILE (decl), - context_die); - - /* If this is a bit field... */ - if (DECL_BIT_FIELD_TYPE (decl)) - { - add_byte_size_attribute (decl_die, decl); - add_bit_size_attribute (decl_die, decl); - add_bit_offset_attribute (decl_die, decl); - } - - if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE) - add_data_member_location_attribute (decl_die, decl); - - if (DECL_ARTIFICIAL (decl)) - add_AT_flag (decl_die, DW_AT_artificial, 1); - - if (TREE_PROTECTED (decl)) - add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected); - - else if (TREE_PRIVATE (decl)) - add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private); -} - -#if 0 -/* Don't generate either pointer_type DIEs or reference_type DIEs here. - Use modified_type_die instead. - We keep this code here just in case these types of DIEs may be needed to - represent certain things in other languages (e.g. Pascal) someday. */ -static void -gen_pointer_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref ptr_die - = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, ptr_die); - add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); - add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); -} - -/* Don't generate either pointer_type DIEs or reference_type DIEs here. - Use modified_type_die instead. - We keep this code here just in case these types of DIEs may be needed to - represent certain things in other languages (e.g. Pascal) someday. */ -static void -gen_reference_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref ref_die - = new_die (DW_TAG_reference_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, ref_die); - add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die); - add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE); -} -#endif - -/* Generate a DIE for a pointer to a member type. */ -static void -gen_ptr_to_mbr_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref ptr_die - = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, ptr_die); - add_AT_die_ref (ptr_die, DW_AT_containing_type, - lookup_type_die (TYPE_OFFSET_BASETYPE (type))); - add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die); -} - -/* Generate the DIE for the compilation unit. */ - -static void -gen_compile_unit_die (main_input_filename) - register char *main_input_filename; -{ - char producer[250]; - char *wd = getpwd (); - - comp_unit_die = new_die (DW_TAG_compile_unit, NULL); - add_name_attribute (comp_unit_die, main_input_filename); - - if (wd != NULL) - add_AT_string (comp_unit_die, DW_AT_comp_dir, wd); - - sprintf (producer, "%s %s", language_string, version_string); - -#ifdef MIPS_DEBUGGING_INFO - /* The MIPS/SGI compilers place the 'cc' command line options in the producer - string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do - not appear in the producer string, the debugger reaches the conclusion - that the object file is stripped and has no debugging information. - To get the MIPS/SGI debugger to believe that there is debugging - information in the object file, we add a -g to the producer string. */ - if (debug_info_level > DINFO_LEVEL_TERSE) - strcat (producer, " -g"); -#endif - - add_AT_string (comp_unit_die, DW_AT_producer, producer); - - if (strcmp (language_string, "GNU C++") == 0) - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus); - - else if (strcmp (language_string, "GNU Ada") == 0) - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83); - - else if (strcmp (language_string, "GNU F77") == 0) - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77); - - else if (strcmp (language_string, "GNU Pascal") == 0) - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83); - - else if (flag_traditional) - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C); - - else - add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89); - -#if 0 /* unimplemented */ - if (debug_info_level >= DINFO_LEVEL_VERBOSE) - add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0); -#endif -} - -/* Generate a DIE for a string type. */ - -static void -gen_string_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die - = new_die (DW_TAG_string_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, type_die); - - /* Fudge the string length attribute for now. */ - - /* TODO: add string length info. - string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type))); - bound_representation (upper_bound, 0, 'u'); */ -} - -/* Generate the DIE for a base class. */ - -static void -gen_inheritance_die (binfo, context_die) - register tree binfo; - register dw_die_ref context_die; -{ - dw_die_ref die = new_die (DW_TAG_inheritance, context_die); - - add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die); - add_data_member_location_attribute (die, binfo); - - if (TREE_VIA_VIRTUAL (binfo)) - add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual); - if (TREE_VIA_PUBLIC (binfo)) - add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public); - else if (TREE_VIA_PROTECTED (binfo)) - add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected); -} - -/* Generate a DIE for a class member. */ - -static void -gen_member_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register tree member; - - /* If this is not an incomplete type, output descriptions of each of its - members. Note that as we output the DIEs necessary to represent the - members of this record or union type, we will also be trying to output - DIEs to represent the *types* of those members. However the `type' - function (above) will specifically avoid generating type DIEs for member - types *within* the list of member DIEs for this (containing) type execpt - for those types (of members) which are explicitly marked as also being - members of this (containing) type themselves. The g++ front- end can - force any given type to be treated as a member of some other - (containing) type by setting the TYPE_CONTEXT of the given (member) type - to point to the TREE node representing the appropriate (containing) - type. */ - - /* First output info about the base classes. */ - if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type)) - { - register tree bases = TYPE_BINFO_BASETYPES (type); - register int n_bases = TREE_VEC_LENGTH (bases); - register int i; - - for (i = 0; i < n_bases; i++) - gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die); - } - - /* Now output info about the data members and type members. */ - for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member)) - gen_decl_die (member, context_die); - - /* Now output info about the function members (if any). */ - for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member)) - gen_decl_die (member, context_die); -} - -/* Generate a DIE for a structure or union type. */ - -static void -gen_struct_or_union_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register dw_die_ref type_die = lookup_type_die (type); - register dw_die_ref scope_die = 0; - register int nested = 0; - - if (type_die && ! TYPE_SIZE (type)) - return; - - if (TYPE_CONTEXT (type) != NULL_TREE - && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))) - nested = 1; - - scope_die = scope_die_for (type, context_die); - - if (! type_die || (nested && scope_die == comp_unit_die)) - /* First occurrence of type or toplevel definition of nested class. */ - { - register dw_die_ref old_die = type_die; - - type_die = new_die (TREE_CODE (type) == RECORD_TYPE - ? DW_TAG_structure_type : DW_TAG_union_type, - scope_die); - equate_type_number_to_die (type, type_die); - add_name_attribute (type_die, type_tag (type)); - if (old_die) - add_AT_die_ref (type_die, DW_AT_specification, old_die); - } - else - remove_AT (type_die, DW_AT_declaration); - - /* If we're not in the right context to be defining this type, defer to - avoid tricky recursion. */ - if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die) - { - add_AT_flag (type_die, DW_AT_declaration, 1); - pend_type (type); - } - /* If this type has been completed, then give it a byte_size attribute and - then give a list of members. */ - else if (TYPE_SIZE (type)) - { - /* Prevent infinite recursion in cases where the type of some member of - this type is expressed in terms of this type itself. */ - TREE_ASM_WRITTEN (type) = 1; - add_byte_size_attribute (type_die, type); - if (TYPE_STUB_DECL (type) != NULL_TREE) - add_src_coords_attributes (type_die, TYPE_STUB_DECL (type)); - - /* If the first reference to this type was as the return type of an - inline function, then it may not have a parent. Fix this now. */ - if (type_die->die_parent == NULL) - add_child_die (scope_die, type_die); - - push_decl_scope (type); - gen_member_die (type, type_die); - pop_decl_scope (); - - /* GNU extension: Record what type our vtable lives in. */ - if (TYPE_VFIELD (type)) - { - tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type)); - - gen_type_die (vtype, context_die); - add_AT_die_ref (type_die, DW_AT_containing_type, - lookup_type_die (vtype)); - } - } - else - add_AT_flag (type_die, DW_AT_declaration, 1); -} - -/* Generate a DIE for a subroutine _type_. */ - -static void -gen_subroutine_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - register tree return_type = TREE_TYPE (type); - register dw_die_ref subr_die - = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die)); - - equate_type_number_to_die (type, subr_die); - add_prototyped_attribute (subr_die, type); - add_type_attribute (subr_die, return_type, 0, 0, context_die); - gen_formal_types_die (type, subr_die); -} - -/* Generate a DIE for a type definition */ - -static void -gen_typedef_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register dw_die_ref type_die; - register tree origin; - - if (TREE_ASM_WRITTEN (decl)) - return; - TREE_ASM_WRITTEN (decl) = 1; - - type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die)); - origin = decl_ultimate_origin (decl); - if (origin != NULL) - add_abstract_origin_attribute (type_die, origin); - else - { - register tree type; - add_name_and_src_coords_attributes (type_die, decl); - if (DECL_ORIGINAL_TYPE (decl)) - { - type = DECL_ORIGINAL_TYPE (decl); - equate_type_number_to_die (TREE_TYPE (decl), type_die); - } - else - type = TREE_TYPE (decl); - add_type_attribute (type_die, type, TREE_READONLY (decl), - TREE_THIS_VOLATILE (decl), context_die); - } - - if (DECL_ABSTRACT (decl)) - equate_decl_number_to_die (decl, type_die); -} - -/* Generate a type description DIE. */ - -static void -gen_type_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - if (type == NULL_TREE || type == error_mark_node) - return; - - /* We are going to output a DIE to represent the unqualified version of - this type (i.e. without any const or volatile qualifiers) so get the - main variant (i.e. the unqualified version) of this type now. */ - type = type_main_variant (type); - - if (TREE_ASM_WRITTEN (type)) - return; - - if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL - && DECL_ORIGINAL_TYPE (TYPE_NAME (type))) - { - TREE_ASM_WRITTEN (type) = 1; - gen_decl_die (TYPE_NAME (type), context_die); - return; - } - - switch (TREE_CODE (type)) - { - case ERROR_MARK: - break; - - case POINTER_TYPE: - case REFERENCE_TYPE: - /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This - ensures that the gen_type_die recursion will terminate even if the - type is recursive. Recursive types are possible in Ada. */ - /* ??? We could perhaps do this for all types before the switch - statement. */ - TREE_ASM_WRITTEN (type) = 1; - - /* For these types, all that is required is that we output a DIE (or a - set of DIEs) to represent the "basis" type. */ - gen_type_die (TREE_TYPE (type), context_die); - break; - - case OFFSET_TYPE: - /* This code is used for C++ pointer-to-data-member types. - Output a description of the relevant class type. */ - gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die); - - /* Output a description of the type of the object pointed to. */ - gen_type_die (TREE_TYPE (type), context_die); - - /* Now output a DIE to represent this pointer-to-data-member type - itself. */ - gen_ptr_to_mbr_type_die (type, context_die); - break; - - case SET_TYPE: - gen_type_die (TYPE_DOMAIN (type), context_die); - gen_set_type_die (type, context_die); - break; - - case FILE_TYPE: - gen_type_die (TREE_TYPE (type), context_die); - abort (); /* No way to represent these in Dwarf yet! */ - break; - - case FUNCTION_TYPE: - /* Force out return type (in case it wasn't forced out already). */ - gen_type_die (TREE_TYPE (type), context_die); - gen_subroutine_type_die (type, context_die); - break; - - case METHOD_TYPE: - /* Force out return type (in case it wasn't forced out already). */ - gen_type_die (TREE_TYPE (type), context_die); - gen_subroutine_type_die (type, context_die); - break; - - case ARRAY_TYPE: - if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE) - { - gen_type_die (TREE_TYPE (type), context_die); - gen_string_type_die (type, context_die); - } - else - gen_array_type_die (type, context_die); - break; - - case ENUMERAL_TYPE: - case RECORD_TYPE: - case UNION_TYPE: - case QUAL_UNION_TYPE: - /* If this is a nested type whose containing class hasn't been - written out yet, writing it out will cover this one, too. */ - if (TYPE_CONTEXT (type) - && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) - && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) - { - gen_type_die (TYPE_CONTEXT (type), context_die); - - if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) - return; - - /* If that failed, attach ourselves to the stub. */ - push_decl_scope (TYPE_CONTEXT (type)); - context_die = lookup_type_die (TYPE_CONTEXT (type)); - } - - if (TREE_CODE (type) == ENUMERAL_TYPE) - gen_enumeration_type_die (type, context_die); - else - gen_struct_or_union_type_die (type, context_die); - - if (TYPE_CONTEXT (type) - && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)) - && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type))) - pop_decl_scope (); - - /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix - it up if it is ever completed. gen_*_type_die will set it for us - when appropriate. */ - return; - - case VOID_TYPE: - case INTEGER_TYPE: - case REAL_TYPE: - case COMPLEX_TYPE: - case BOOLEAN_TYPE: - case CHAR_TYPE: - /* No DIEs needed for fundamental types. */ - break; - - case LANG_TYPE: - /* No Dwarf representation currently defined. */ - break; - - default: - abort (); - } - - TREE_ASM_WRITTEN (type) = 1; -} - -/* Generate a DIE for a tagged type instantiation. */ - -static void -gen_tagged_type_instantiation_die (type, context_die) - register tree type; - register dw_die_ref context_die; -{ - if (type == NULL_TREE || type == error_mark_node) - return; - - /* We are going to output a DIE to represent the unqualified version of - this type (i.e. without any const or volatile qualifiers) so make sure - that we have the main variant (i.e. the unqualified version) of this - type now. */ - if (type != type_main_variant (type) - || !TREE_ASM_WRITTEN (type)) - abort (); - - switch (TREE_CODE (type)) - { - case ERROR_MARK: - break; - - case ENUMERAL_TYPE: - gen_inlined_enumeration_type_die (type, context_die); - break; - - case RECORD_TYPE: - gen_inlined_structure_type_die (type, context_die); - break; - - case UNION_TYPE: - case QUAL_UNION_TYPE: - gen_inlined_union_type_die (type, context_die); - break; - - default: - abort (); - } -} - -/* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the - things which are local to the given block. */ - -static void -gen_block_die (stmt, context_die, depth) - register tree stmt; - register dw_die_ref context_die; - int depth; -{ - register int must_output_die = 0; - register tree origin; - register tree decl; - register enum tree_code origin_code; - - /* Ignore blocks never really used to make RTL. */ - - if (stmt == NULL_TREE || !TREE_USED (stmt)) - return; - - /* Determine the "ultimate origin" of this block. This block may be an - inlined instance of an inlined instance of inline function, so we have - to trace all of the way back through the origin chain to find out what - sort of node actually served as the original seed for the creation of - the current block. */ - origin = block_ultimate_origin (stmt); - origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK; - - /* Determine if we need to output any Dwarf DIEs at all to represent this - block. */ - if (origin_code == FUNCTION_DECL) - /* The outer scopes for inlinings *must* always be represented. We - generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */ - must_output_die = 1; - else - { - /* In the case where the current block represents an inlining of the - "body block" of an inline function, we must *NOT* output any DIE for - this block because we have already output a DIE to represent the - whole inlined function scope and the "body block" of any function - doesn't really represent a different scope according to ANSI C - rules. So we check here to make sure that this block does not - represent a "body block inlining" before trying to set the - `must_output_die' flag. */ - if (! is_body_block (origin ? origin : stmt)) - { - /* Determine if this block directly contains any "significant" - local declarations which we will need to output DIEs for. */ - if (debug_info_level > DINFO_LEVEL_TERSE) - /* We are not in terse mode so *any* local declaration counts - as being a "significant" one. */ - must_output_die = (BLOCK_VARS (stmt) != NULL); - else - /* We are in terse mode, so only local (nested) function - definitions count as "significant" local declarations. */ - for (decl = BLOCK_VARS (stmt); - decl != NULL; decl = TREE_CHAIN (decl)) - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_INITIAL (decl)) - { - must_output_die = 1; - break; - } - } - } - - /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block - DIE for any block which contains no significant local declarations at - all. Rather, in such cases we just call `decls_for_scope' so that any - needed Dwarf info for any sub-blocks will get properly generated. Note - that in terse mode, our definition of what constitutes a "significant" - local declaration gets restricted to include only inlined function - instances and local (nested) function definitions. */ - if (must_output_die) - { - if (origin_code == FUNCTION_DECL) - gen_inlined_subroutine_die (stmt, context_die, depth); - else - gen_lexical_block_die (stmt, context_die, depth); - } - else - decls_for_scope (stmt, context_die, depth); -} - -/* Generate all of the decls declared within a given scope and (recursively) - all of its sub-blocks. */ - -static void -decls_for_scope (stmt, context_die, depth) - register tree stmt; - register dw_die_ref context_die; - int depth; -{ - register tree decl; - register tree subblocks; - - /* Ignore blocks never really used to make RTL. */ - if (stmt == NULL_TREE || ! TREE_USED (stmt)) - return; - - if (!BLOCK_ABSTRACT (stmt) && depth > 0) - next_block_number++; - - /* Output the DIEs to represent all of the data objects and typedefs - declared directly within this block but not within any nested - sub-blocks. Also, nested function and tag DIEs have been - generated with a parent of NULL; fix that up now. */ - for (decl = BLOCK_VARS (stmt); - decl != NULL; decl = TREE_CHAIN (decl)) - { - register dw_die_ref die; - - if (TREE_CODE (decl) == FUNCTION_DECL) - die = lookup_decl_die (decl); - else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)) - die = lookup_type_die (TREE_TYPE (decl)); - else - die = NULL; - - if (die != NULL && die->die_parent == NULL) - add_child_die (context_die, die); - else - gen_decl_die (decl, context_die); - } - - /* Output the DIEs to represent all sub-blocks (and the items declared - therein) of this block. */ - for (subblocks = BLOCK_SUBBLOCKS (stmt); - subblocks != NULL; - subblocks = BLOCK_CHAIN (subblocks)) - gen_block_die (subblocks, context_die, depth + 1); -} - -/* Is this a typedef we can avoid emitting? */ - -static inline int -is_redundant_typedef (decl) - register tree decl; -{ - if (TYPE_DECL_IS_STUB (decl)) - return 1; - - if (DECL_ARTIFICIAL (decl) - && DECL_CONTEXT (decl) - && is_tagged_type (DECL_CONTEXT (decl)) - && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL - && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl)))) - /* Also ignore the artificial member typedef for the class name. */ - return 1; - - return 0; -} - -/* Generate Dwarf debug information for a decl described by DECL. */ - -static void -gen_decl_die (decl, context_die) - register tree decl; - register dw_die_ref context_die; -{ - register tree origin; - - /* Make a note of the decl node we are going to be working on. We may need - to give the user the source coordinates of where it appeared in case we - notice (later on) that something about it looks screwy. */ - dwarf_last_decl = decl; - - if (TREE_CODE (decl) == ERROR_MARK) - return; - - /* If this ..._DECL node is marked to be ignored, then ignore it. But don't - ignore a function definition, since that would screw up our count of - blocks, and that in turn will completely screw up the labels we will - reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for - subsequent blocks). */ - if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL) - return; - - switch (TREE_CODE (decl)) - { - case CONST_DECL: - /* The individual enumerators of an enum type get output when we output - the Dwarf representation of the relevant enum type itself. */ - break; - - case FUNCTION_DECL: - /* Don't output any DIEs to represent mere function declarations, - unless they are class members or explicit block externs. */ - if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE - && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl))) - break; - - if (debug_info_level > DINFO_LEVEL_TERSE) - { - /* Before we describe the FUNCTION_DECL itself, make sure that we - have described its return type. */ - gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die); - - /* And its containing type. */ - origin = decl_class_context (decl); - if (origin != NULL_TREE) - gen_type_die (origin, context_die); - - /* And its virtual context. */ - if (DECL_VINDEX (decl) != NULL_TREE) - gen_type_die (DECL_CONTEXT (decl), context_die); - } - - /* Now output a DIE to represent the function itself. */ - gen_subprogram_die (decl, context_die); - break; - - case TYPE_DECL: - /* If we are in terse mode, don't generate any DIEs to represent any - actual typedefs. */ - if (debug_info_level <= DINFO_LEVEL_TERSE) - break; - - /* In the special case of a TYPE_DECL node representing the - declaration of some type tag, if the given TYPE_DECL is marked as - having been instantiated from some other (original) TYPE_DECL node - (e.g. one which was generated within the original definition of an - inline function) we have to generate a special (abbreviated) - DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type - DIE here. */ - if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE) - { - gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die); - break; - } - - if (is_redundant_typedef (decl)) - gen_type_die (TREE_TYPE (decl), context_die); - else - /* Output a DIE to represent the typedef itself. */ - gen_typedef_die (decl, context_die); - break; - - case LABEL_DECL: - if (debug_info_level >= DINFO_LEVEL_NORMAL) - gen_label_die (decl, context_die); - break; - - case VAR_DECL: - /* If we are in terse mode, don't generate any DIEs to represent any - variable declarations or definitions. */ - if (debug_info_level <= DINFO_LEVEL_TERSE) - break; - - /* Output any DIEs that are needed to specify the type of this data - object. */ - gen_type_die (TREE_TYPE (decl), context_die); - - /* And its containing type. */ - origin = decl_class_context (decl); - if (origin != NULL_TREE) - gen_type_die (origin, context_die); - - /* Now output the DIE to represent the data object itself. This gets - complicated because of the possibility that the VAR_DECL really - represents an inlined instance of a formal parameter for an inline - function. */ - origin = decl_ultimate_origin (decl); - if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL) - gen_formal_parameter_die (decl, context_die); - else - gen_variable_die (decl, context_die); - break; - - case FIELD_DECL: - /* Ignore the nameless fields that are used to skip bits, but - handle C++ anonymous unions. */ - if (DECL_NAME (decl) != NULL_TREE - || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE) - { - gen_type_die (member_declared_type (decl), context_die); - gen_field_die (decl, context_die); - } - break; - - case PARM_DECL: - gen_type_die (TREE_TYPE (decl), context_die); - gen_formal_parameter_die (decl, context_die); - break; - - default: - abort (); - } -} - -/* Write the debugging output for DECL. */ - -void -dwarf2out_decl (decl) - register tree decl; -{ - register dw_die_ref context_die = comp_unit_die; - - if (TREE_CODE (decl) == ERROR_MARK) - return; - - /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta - hope that the node in question doesn't represent a function definition. - If it does, then totally ignoring it is bound to screw up our count of - blocks, and that in turn will completely screw up the labels we will - reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for - subsequent blocks). (It's too bad that BLOCK nodes don't carry their - own sequence numbers with them!) */ - if (DECL_IGNORED_P (decl)) - { - if (TREE_CODE (decl) == FUNCTION_DECL - && DECL_INITIAL (decl) != NULL) - abort (); - - return; - } - - switch (TREE_CODE (decl)) - { - case FUNCTION_DECL: - /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a - builtin function. Explicit programmer-supplied declarations of - these same functions should NOT be ignored however. */ - if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl)) - return; - - /* What we would really like to do here is to filter out all mere - file-scope declarations of file-scope functions which are never - referenced later within this translation unit (and keep all of ones - that *are* referenced later on) but we aren't clairvoyant, so we have - no idea which functions will be referenced in the future (i.e. later - on within the current translation unit). So here we just ignore all - file-scope function declarations which are not also definitions. If - and when the debugger needs to know something about these functions, - it wil have to hunt around and find the DWARF information associated - with the definition of the function. Note that we can't just check - `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent - definitions and which ones represent mere declarations. We have to - check `DECL_INITIAL' instead. That's because the C front-end - supports some weird semantics for "extern inline" function - definitions. These can get inlined within the current translation - unit (an thus, we need to generate DWARF info for their abstract - instances so that the DWARF info for the concrete inlined instances - can have something to refer to) but the compiler never generates any - out-of-lines instances of such things (despite the fact that they - *are* definitions). The important point is that the C front-end - marks these "extern inline" functions as DECL_EXTERNAL, but we need - to generate DWARF for them anyway. Note that the C++ front-end also - plays some similar games for inline function definitions appearing - within include files which also contain - `#pragma interface' pragmas. */ - if (DECL_INITIAL (decl) == NULL_TREE) - return; - - /* If we're a nested function, initially use a parent of NULL; if we're - a plain function, this will be fixed up in decls_for_scope. If - we're a method, it will be ignored, since we already have a DIE. */ - if (decl_function_context (decl)) - context_die = NULL; - - break; - - case VAR_DECL: - /* Ignore this VAR_DECL if it refers to a file-scope extern data object - declaration and if the declaration was never even referenced from - within this entire compilation unit. We suppress these DIEs in - order to save space in the .debug section (by eliminating entries - which are probably useless). Note that we must not suppress - block-local extern declarations (whether used or not) because that - would screw-up the debugger's name lookup mechanism and cause it to - miss things which really ought to be in scope at a given point. */ - if (DECL_EXTERNAL (decl) && !TREE_USED (decl)) - return; - - /* If we are in terse mode, don't generate any DIEs to represent any - variable declarations or definitions. */ - if (debug_info_level <= DINFO_LEVEL_TERSE) - return; - break; - - case TYPE_DECL: - /* Don't bother trying to generate any DIEs to represent any of the - normal built-in types for the language we are compiling. */ - if (DECL_SOURCE_LINE (decl) == 0) - { - /* OK, we need to generate one for `bool' so GDB knows what type - comparisons have. */ - if ((get_AT_unsigned (comp_unit_die, DW_AT_language) - == DW_LANG_C_plus_plus) - && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE) - modified_type_die (TREE_TYPE (decl), 0, 0, NULL); - - return; - } - - /* If we are in terse mode, don't generate any DIEs for types. */ - if (debug_info_level <= DINFO_LEVEL_TERSE) - return; - - /* If we're a function-scope tag, initially use a parent of NULL; - this will be fixed up in decls_for_scope. */ - if (decl_function_context (decl)) - context_die = NULL; - - break; - - default: - return; - } - - gen_decl_die (decl, context_die); - output_pending_types_for_scope (comp_unit_die); -} - -/* Output a marker (i.e. a label) for the beginning of the generated code for - a lexical block. */ - -void -dwarf2out_begin_block (blocknum) - register unsigned blocknum; -{ - function_section (current_function_decl); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum); -} - -/* Output a marker (i.e. a label) for the end of the generated code for a - lexical block. */ - -void -dwarf2out_end_block (blocknum) - register unsigned blocknum; -{ - function_section (current_function_decl); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum); -} - -/* Output a marker (i.e. a label) at a point in the assembly code which - corresponds to a given source level label. */ - -void -dwarf2out_label (insn) - register rtx insn; -{ - char label[MAX_ARTIFICIAL_LABEL_BYTES]; - - if (debug_info_level >= DINFO_LEVEL_NORMAL) - { - function_section (current_function_decl); - sprintf (label, INSN_LABEL_FMT, current_funcdef_number); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label, - (unsigned) INSN_UID (insn)); - } -} - -/* Lookup a filename (in the list of filenames that we know about here in - dwarf2out.c) and return its "index". The index of each (known) filename is - just a unique number which is associated with only that one filename. - We need such numbers for the sake of generating labels - (in the .debug_sfnames section) and references to those - files numbers (in the .debug_srcinfo and.debug_macinfo sections). - If the filename given as an argument is not found in our current list, - add it to the list and assign it the next available unique index number. - In order to speed up searches, we remember the index of the filename - was looked up last. This handles the majority of all searches. */ - -static unsigned -lookup_filename (file_name) - char *file_name; -{ - static unsigned last_file_lookup_index = 0; - register unsigned i; - - /* Check to see if the file name that was searched on the previous call - matches this file name. If so, return the index. */ - if (last_file_lookup_index != 0) - if (strcmp (file_name, file_table[last_file_lookup_index]) == 0) - return last_file_lookup_index; - - /* Didn't match the previous lookup, search the table */ - for (i = 1; i < file_table_in_use; ++i) - if (strcmp (file_name, file_table[i]) == 0) - { - last_file_lookup_index = i; - return i; - } - - /* Prepare to add a new table entry by making sure there is enough space in - the table to do so. If not, expand the current table. */ - if (file_table_in_use == file_table_allocated) - { - file_table_allocated += FILE_TABLE_INCREMENT; - file_table - = (char **) xrealloc (file_table, - file_table_allocated * sizeof (char *)); - } - - /* Add the new entry to the end of the filename table. */ - file_table[file_table_in_use] = xstrdup (file_name); - last_file_lookup_index = file_table_in_use++; - - return last_file_lookup_index; -} - -/* Output a label to mark the beginning of a source code line entry - and record information relating to this source line, in - 'line_info_table' for later output of the .debug_line section. */ - -void -dwarf2out_line (filename, line) - register char *filename; - register unsigned line; -{ - if (debug_info_level >= DINFO_LEVEL_NORMAL) - { - function_section (current_function_decl); - - if (DECL_SECTION_NAME (current_function_decl)) - { - register dw_separate_line_info_ref line_info; - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL, - separate_line_info_table_in_use); - fputc ('\n', asm_out_file); - - /* expand the line info table if necessary */ - if (separate_line_info_table_in_use - == separate_line_info_table_allocated) - { - separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; - separate_line_info_table - = (dw_separate_line_info_ref) - xrealloc (separate_line_info_table, - separate_line_info_table_allocated - * sizeof (dw_separate_line_info_entry)); - } - - /* Add the new entry at the end of the line_info_table. */ - line_info - = &separate_line_info_table[separate_line_info_table_in_use++]; - line_info->dw_file_num = lookup_filename (filename); - line_info->dw_line_num = line; - line_info->function = current_funcdef_number; - } - else - { - register dw_line_info_ref line_info; - - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL, - line_info_table_in_use); - fputc ('\n', asm_out_file); - - /* Expand the line info table if necessary. */ - if (line_info_table_in_use == line_info_table_allocated) - { - line_info_table_allocated += LINE_INFO_TABLE_INCREMENT; - line_info_table - = (dw_line_info_ref) - xrealloc (line_info_table, - (line_info_table_allocated - * sizeof (dw_line_info_entry))); - } - - /* Add the new entry at the end of the line_info_table. */ - line_info = &line_info_table[line_info_table_in_use++]; - line_info->dw_file_num = lookup_filename (filename); - line_info->dw_line_num = line; - } - } -} - -/* Record the beginning of a new source file, for later output - of the .debug_macinfo section. At present, unimplemented. */ - -void -dwarf2out_start_source_file (filename) - register char *filename ATTRIBUTE_UNUSED; -{ -} - -/* Record the end of a source file, for later output - of the .debug_macinfo section. At present, unimplemented. */ - -void -dwarf2out_end_source_file () -{ -} - -/* Called from check_newline in c-parse.y. The `buffer' parameter contains - the tail part of the directive line, i.e. the part which is past the - initial whitespace, #, whitespace, directive-name, whitespace part. */ - -void -dwarf2out_define (lineno, buffer) - register unsigned lineno; - register char *buffer; -{ - static int initialized = 0; - if (!initialized) - { - dwarf2out_start_source_file (primary_filename); - initialized = 1; - } -} - -/* Called from check_newline in c-parse.y. The `buffer' parameter contains - the tail part of the directive line, i.e. the part which is past the - initial whitespace, #, whitespace, directive-name, whitespace part. */ - -void -dwarf2out_undef (lineno, buffer) - register unsigned lineno ATTRIBUTE_UNUSED; - register char *buffer ATTRIBUTE_UNUSED; -{ -} - -/* Set up for Dwarf output at the start of compilation. */ - -void -dwarf2out_init (asm_out_file, main_input_filename) - register FILE *asm_out_file; - register char *main_input_filename; -{ - /* Remember the name of the primary input file. */ - primary_filename = main_input_filename; - - /* Allocate the initial hunk of the file_table. */ - file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *)); - zero_memory ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *)); - file_table_allocated = FILE_TABLE_INCREMENT; - - /* Skip the first entry - file numbers begin at 1. */ - file_table_in_use = 1; - - /* Allocate the initial hunk of the decl_die_table. */ - decl_die_table - = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); - zero_memory ((char *) decl_die_table, - DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); - decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT; - decl_die_table_in_use = 0; - - /* Allocate the initial hunk of the decl_scope_table. */ - decl_scope_table - = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT - * sizeof (decl_scope_node)); - zero_memory ((char *) decl_scope_table, - DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node)); - decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT; - decl_scope_depth = 0; - - /* Allocate the initial hunk of the abbrev_die_table. */ - abbrev_die_table - = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT - * sizeof (dw_die_ref)); - zero_memory ((char *) abbrev_die_table, - ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref)); - abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT; - /* Zero-th entry is allocated, but unused */ - abbrev_die_table_in_use = 1; - - /* Allocate the initial hunk of the line_info_table. */ - line_info_table - = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT - * sizeof (dw_line_info_entry)); - zero_memory ((char *) line_info_table, - LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry)); - line_info_table_allocated = LINE_INFO_TABLE_INCREMENT; - /* Zero-th entry is allocated, but unused */ - line_info_table_in_use = 1; - - /* Generate the initial DIE for the .debug section. Note that the (string) - value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE - will (typically) be a relative pathname and that this pathname should be - taken as being relative to the directory from which the compiler was - invoked when the given (base) source file was compiled. */ - gen_compile_unit_die (main_input_filename); - - ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0); -} - -/* Output stuff that dwarf requires at the end of every file, - and generate the DWARF-2 debugging info. */ - -void -dwarf2out_finish () -{ - limbo_die_node *node, *next_node; - dw_die_ref die; - dw_attr_ref a; - - /* Traverse the limbo die list, and add parent/child links. The only - dies without parents that should be here are concrete instances of - inline functions, and the comp_unit_die. We can ignore the comp_unit_die. - For concrete instances, we can get the parent die from the abstract - instance. */ - for (node = limbo_die_list; node; node = next_node) - { - next_node = node->next; - die = node->die; - - if (die->die_parent == NULL) - { - a = get_AT (die, DW_AT_abstract_origin); - if (a) - add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die); - else if (die == comp_unit_die) - ; - else - abort (); - } - free (node); - } - - /* Traverse the DIE tree and add sibling attributes to those DIE's - that have children. */ - add_sibling_attributes (comp_unit_die); - - /* Output a terminator label for the .text section. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0); - -#if 0 - /* Output a terminator label for the .data section. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0); - - /* Output a terminator label for the .bss section. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0); -#endif - - /* Output the source line correspondence table. */ - if (line_info_table_in_use > 1 || separate_line_info_table_in_use) - { - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION); - output_line_info (); - - /* We can only use the low/high_pc attributes if all of the code - was in .text. */ - if (separate_line_info_table_in_use == 0) - { - add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, - stripattributes (TEXT_SECTION)); - add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label); - } - - add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, DEBUG_LINE_SECTION); - } - - /* Output the abbreviation table. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION); - build_abbrev_table (comp_unit_die); - output_abbrev_section (); - - /* Initialize the beginning DIE offset - and calculate sizes/offsets. */ - next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE; - calc_die_sizes (comp_unit_die); - - /* Output debugging information. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION); - output_compilation_unit_header (); - output_die (comp_unit_die); - - if (pubname_table_in_use) - { - /* Output public names table. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION); - output_pubnames (); - } - - if (fde_table_in_use) - { - /* Output the address range information. */ - fputc ('\n', asm_out_file); - ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION); - output_aranges (); - } -} -#endif /* DWARF2_DEBUGGING_INFO */ diff --git a/gcc/function.BAK b/gcc/function.BAK deleted file mode 100755 index 3c99619..0000000 --- a/gcc/function.BAK +++ /dev/null @@ -1,6650 +0,0 @@ -/* Expands front end tree to back end RTL for GNU C-Compiler
- Copyright (C) 1987, 88, 89, 91-98, 1999, 2000 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. */
-
-
-/* This file handles the generation of rtl code from tree structure
- at the level of the function as a whole.
- It creates the rtl expressions for parameters and auto variables
- and has full responsibility for allocating stack slots.
-
- `expand_function_start' is called at the beginning of a function,
- before the function body is parsed, and `expand_function_end' is
- called after parsing the body.
-
- Call `assign_stack_local' to allocate a stack slot for a local variable.
- This is usually done during the RTL generation for the function body,
- but it can also be done in the reload pass when a pseudo-register does
- not get a hard register.
-
- Call `put_var_into_stack' when you learn, belatedly, that a variable
- previously given a pseudo-register must in fact go in the stack.
- This function changes the DECL_RTL to be a stack slot instead of a reg
- then scans all the RTL instructions so far generated to correct them. */
-
-#include "config.h"
-#include "system.h"
-#include "rtl.h"
-#include "tree.h"
-#include "flags.h"
-#include "except.h"
-#include "function.h"
-#include "insn-flags.h"
-#include "expr.h"
-#include "insn-codes.h"
-#include "regs.h"
-#include "hard-reg-set.h"
-#include "insn-config.h"
-#include "recog.h"
-#include "output.h"
-#include "basic-block.h"
-#include "obstack.h"
-#include "toplev.h"
-
-#if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
-#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
-#endif
-
-#ifndef TRAMPOLINE_ALIGNMENT
-#define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
-#endif
-
-/* Some systems use __main in a way incompatible with its use in gcc, in these
- cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
- give the same symbol without quotes for an alternative entry point. You
- must define both, or neither. */
-#ifndef NAME__MAIN
-#define NAME__MAIN "__main"
-#define SYMBOL__MAIN __main
-#endif
-
-/* Round a value to the lowest integer less than it that is a multiple of
- the required alignment. Avoid using division in case the value is
- negative. Assume the alignment is a power of two. */
-#define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
-
-/* Similar, but round to the next highest integer that meets the
- alignment. */
-#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
-
-/* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
- during rtl generation. If they are different register numbers, this is
- always true. It may also be true if
- FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
- generation. See fix_lexical_addr for details. */
-
-#if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
-#define NEED_SEPARATE_AP
-#endif
-
-/* Number of bytes of args popped by function being compiled on its return.
- Zero if no bytes are to be popped.
- May affect compilation of return insn or of function epilogue. */
-
-int current_function_pops_args;
-
-/* Nonzero if function being compiled needs to be given an address
- where the value should be stored. */
-
-int current_function_returns_struct;
-
-/* Nonzero if function being compiled needs to
- return the address of where it has put a structure value. */
-
-int current_function_returns_pcc_struct;
-
-/* Nonzero if function being compiled needs to be passed a static chain. */
-
-int current_function_needs_context;
-
-/* Nonzero if function being compiled can call setjmp. */
-
-int current_function_calls_setjmp;
-
-/* Nonzero if function being compiled can call longjmp. */
-
-int current_function_calls_longjmp;
-
-/* Nonzero if function being compiled receives nonlocal gotos
- from nested functions. */
-
-int current_function_has_nonlocal_label;
-
-/* Nonzero if function being compiled has nonlocal gotos to parent
- function. */
-
-int current_function_has_nonlocal_goto;
-
-/* Nonzero if this function has a computed goto.
-
- It is computed during find_basic_blocks or during stupid life
- analysis. */
-
-int current_function_has_computed_jump;
-
-/* Nonzero if function being compiled contains nested functions. */
-
-int current_function_contains_functions;
-
-/* Nonzero if function being compiled doesn't modify the stack pointer
- (ignoring the prologue and epilogue). This is only valid after
- life_analysis has run. */
-
-int current_function_sp_is_unchanging;
-
-/* Nonzero if the current function is a thunk (a lightweight function that
- just adjusts one of its arguments and forwards to another function), so
- we should try to cut corners where we can. */
-int current_function_is_thunk;
-
-/* Nonzero if function being compiled can call alloca,
- either as a subroutine or builtin. */
-
-int current_function_calls_alloca;
-
-/* Nonzero if the current function returns a pointer type */
-
-int current_function_returns_pointer;
-
-/* If some insns can be deferred to the delay slots of the epilogue, the
- delay list for them is recorded here. */
-
-rtx current_function_epilogue_delay_list;
-
-/* If function's args have a fixed size, this is that size, in bytes.
- Otherwise, it is -1.
- May affect compilation of return insn or of function epilogue. */
-
-int current_function_args_size;
-
-/* # bytes the prologue should push and pretend that the caller pushed them.
- The prologue must do this, but only if parms can be passed in registers. */
-
-int current_function_pretend_args_size;
-
-/* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is
- defined, the needed space is pushed by the prologue. */
-
-int current_function_outgoing_args_size;
-
-/* This is the offset from the arg pointer to the place where the first
- anonymous arg can be found, if there is one. */
-
-rtx current_function_arg_offset_rtx;
-
-/* Nonzero if current function uses varargs.h or equivalent.
- Zero for functions that use stdarg.h. */
-
-int current_function_varargs;
-
-/* Nonzero if current function uses stdarg.h or equivalent.
- Zero for functions that use varargs.h. */
-
-int current_function_stdarg;
-
-/* Quantities of various kinds of registers
- used for the current function's args. */
-
-CUMULATIVE_ARGS current_function_args_info;
-
-/* Name of function now being compiled. */
-
-char *current_function_name;
-
-/* If non-zero, an RTL expression for the location at which the current
- function returns its result. If the current function returns its
- result in a register, current_function_return_rtx will always be
- the hard register containing the result. */
-
-rtx current_function_return_rtx;
-
-/* Nonzero if the current function uses the constant pool. */
-
-int current_function_uses_const_pool;
-
-/* Nonzero if the current function uses pic_offset_table_rtx. */
-int current_function_uses_pic_offset_table;
-
-/* The arg pointer hard register, or the pseudo into which it was copied. */
-rtx current_function_internal_arg_pointer;
-
-/* CYGNUS LOCAL -- Branch Prediction */
-/* The current function uses __builtin_expect for branch prediction. */
-int current_function_uses_expect;
-
-/* The current function is currently expanding the first argument to
- __builtin_expect. */
-int current_function_processing_expect;
-/* END CYGNUS LOCAL -- Branch Prediction */
-
-/* Language-specific reason why the current function cannot be made inline. */
-char *current_function_cannot_inline;
-
-/* Nonzero if instrumentation calls for function entry and exit should be
- generated. */
-int current_function_instrument_entry_exit;
-
-/* Nonzero if memory access checking be enabled in the current function. */
-int current_function_check_memory_usage;
-
-/* The FUNCTION_DECL for an inline function currently being expanded. */
-tree inline_function_decl;
-
-/* Number of function calls seen so far in current function. */
-
-int function_call_count;
-
-/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
- (labels to which there can be nonlocal gotos from nested functions)
- in this function. */
-
-tree nonlocal_labels;
-
-/* List (chain of EXPR_LIST) of stack slots that hold the current handlers
- for nonlocal gotos. There is one for every nonlocal label in the function;
- this list matches the one in nonlocal_labels.
- Zero when function does not have nonlocal labels. */
-
-rtx nonlocal_goto_handler_slots;
-
-/* RTX for stack slot that holds the stack pointer value to restore
- for a nonlocal goto.
- Zero when function does not have nonlocal labels. */
-
-rtx nonlocal_goto_stack_level;
-
-/* Label that will go on parm cleanup code, if any.
- Jumping to this label runs cleanup code for parameters, if
- such code must be run. Following this code is the logical return label. */
-
-rtx cleanup_label;
-
-/* Label that will go on function epilogue.
- Jumping to this label serves as a "return" instruction
- on machines which require execution of the epilogue on all returns. */
-
-rtx return_label;
-
-/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
- So we can mark them all live at the end of the function, if nonopt. */
-rtx save_expr_regs;
-
-/* List (chain of EXPR_LISTs) of all stack slots in this function.
- Made for the sake of unshare_all_rtl. */
-rtx stack_slot_list;
-
-/* Chain of all RTL_EXPRs that have insns in them. */
-tree rtl_expr_chain;
-
-/* Label to jump back to for tail recursion, or 0 if we have
- not yet needed one for this function. */
-rtx tail_recursion_label;
-
-/* Place after which to insert the tail_recursion_label if we need one. */
-rtx tail_recursion_reentry;
-
-/* Location at which to save the argument pointer if it will need to be
- referenced. There are two cases where this is done: if nonlocal gotos
- exist, or if vars stored at an offset from the argument pointer will be
- needed by inner routines. */
-
-rtx arg_pointer_save_area;
-
-/* Offset to end of allocated area of stack frame.
- If stack grows down, this is the address of the last stack slot allocated.
- If stack grows up, this is the address for the next slot. */
-HOST_WIDE_INT frame_offset;
-
-/* List (chain of TREE_LISTs) of static chains for containing functions.
- Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx
- in an RTL_EXPR in the TREE_VALUE. */
-static tree context_display;
-
-/* List (chain of TREE_LISTs) of trampolines for nested functions.
- The trampoline sets up the static chain and jumps to the function.
- We supply the trampoline's address when the function's address is requested.
-
- Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx
- in an RTL_EXPR in the TREE_VALUE. */
-static tree trampoline_list;
-
-/* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */
-static rtx parm_birth_insn;
-
-#if 0
-/* Nonzero if a stack slot has been generated whose address is not
- actually valid. It means that the generated rtl must all be scanned
- to detect and correct the invalid addresses where they occur. */
-static int invalid_stack_slot;
-#endif
-
-/* Last insn of those whose job was to put parms into their nominal homes. */
-static rtx last_parm_insn;
-
-/* 1 + last pseudo register number possibly used for loading a copy
- of a parameter of this function. */
-int max_parm_reg;
-
-/* Vector indexed by REGNO, containing location on stack in which
- to put the parm which is nominally in pseudo register REGNO,
- if we discover that that parm must go in the stack. The highest
- element in this vector is one less than MAX_PARM_REG, above. */
-rtx *parm_reg_stack_loc;
-
-/* Nonzero once virtual register instantiation has been done.
- assign_stack_local uses frame_pointer_rtx when this is nonzero. */
-static int virtuals_instantiated;
-
-/* These variables hold pointers to functions to
- save and restore machine-specific data,
- in push_function_context and pop_function_context. */
-void (*save_machine_status) PROTO((struct function *));
-void (*restore_machine_status) PROTO((struct function *));
-
-/* Nonzero if we need to distinguish between the return value of this function
- and the return value of a function called by this function. This helps
- integrate.c */
-
-extern int rtx_equal_function_value_matters;
-extern tree sequence_rtl_expr;
-
-/* In order to evaluate some expressions, such as function calls returning
- structures in memory, we need to temporarily allocate stack locations.
- We record each allocated temporary in the following structure.
-
- Associated with each temporary slot is a nesting level. When we pop up
- one level, all temporaries associated with the previous level are freed.
- Normally, all temporaries are freed after the execution of the statement
- in which they were created. However, if we are inside a ({...}) grouping,
- the result may be in a temporary and hence must be preserved. If the
- result could be in a temporary, we preserve it if we can determine which
- one it is in. If we cannot determine which temporary may contain the
- result, all temporaries are preserved. A temporary is preserved by
- pretending it was allocated at the previous nesting level.
-
- Automatic variables are also assigned temporary slots, at the nesting
- level where they are defined. They are marked a "kept" so that
- free_temp_slots will not free them. */
-
-struct temp_slot
-{
- /* Points to next temporary slot. */
- struct temp_slot *next;
- /* The rtx to used to reference the slot. */
- rtx slot;
- /* The rtx used to represent the address if not the address of the
- slot above. May be an EXPR_LIST if multiple addresses exist. */
- rtx address;
- /* The size, in units, of the slot. */
- HOST_WIDE_INT size;
- /* The value of `sequence_rtl_expr' when this temporary is allocated. */
- tree rtl_expr;
- /* Non-zero if this temporary is currently in use. */
- char in_use;
- /* Non-zero if this temporary has its address taken. */
- char addr_taken;
- /* Nesting level at which this slot is being used. */
- int level;
- /* Non-zero if this should survive a call to free_temp_slots. */
- int keep;
- /* The offset of the slot from the frame_pointer, including extra space
- for alignment. This info is for combine_temp_slots. */
- HOST_WIDE_INT base_offset;
- /* The size of the slot, including extra space for alignment. This
- info is for combine_temp_slots. */
- HOST_WIDE_INT full_size;
-};
-
-/* List of all temporaries allocated, both available and in use. */
-
-struct temp_slot *temp_slots;
-
-/* Current nesting level for temporaries. */
-
-int temp_slot_level;
-
-/* Current nesting level for variables in a block. */
-
-int var_temp_slot_level;
-
-/* When temporaries are created by TARGET_EXPRs, they are created at
- this level of temp_slot_level, so that they can remain allocated
- until no longer needed. CLEANUP_POINT_EXPRs define the lifetime
- of TARGET_EXPRs. */
-int target_temp_slot_level;
-
-/* This structure is used to record MEMs or pseudos used to replace VAR, any
- SUBREGs of VAR, and any MEMs containing VAR as an address. We need to
- maintain this list in case two operands of an insn were required to match;
- in that case we must ensure we use the same replacement. */
-
-struct fixup_replacement
-{
- rtx old;
- rtx new;
- struct fixup_replacement *next;
-};
-
-/* Forward declarations. */
-
-static rtx assign_outer_stack_local PROTO ((enum machine_mode, HOST_WIDE_INT,
- int, struct function *));
-static struct temp_slot *find_temp_slot_from_address PROTO((rtx));
-static void put_reg_into_stack PROTO((struct function *, rtx, tree,
- enum machine_mode, enum machine_mode,
- int, int, int));
-static void fixup_var_refs PROTO((rtx, enum machine_mode, int));
-static struct fixup_replacement
- *find_fixup_replacement PROTO((struct fixup_replacement **, rtx));
-static void fixup_var_refs_insns PROTO((rtx, enum machine_mode, int,
- rtx, int));
-static void fixup_var_refs_1 PROTO((rtx, enum machine_mode, rtx *, rtx,
- struct fixup_replacement **));
-static rtx fixup_memory_subreg PROTO((rtx, rtx, int));
-static rtx walk_fixup_memory_subreg PROTO((rtx, rtx, int));
-static rtx fixup_stack_1 PROTO((rtx, rtx));
-static void optimize_bit_field PROTO((rtx, rtx, rtx *));
-static void instantiate_decls PROTO((tree, int));
-static void instantiate_decls_1 PROTO((tree, int));
-static void instantiate_decl PROTO((rtx, int, int));
-static int instantiate_virtual_regs_1 PROTO((rtx *, rtx, int));
-static void delete_handlers PROTO((void));
-static void pad_to_arg_alignment PROTO((struct args_size *, int));
-#ifndef ARGS_GROW_DOWNWARD
-static void pad_below PROTO((struct args_size *, enum machine_mode,
- tree));
-#endif
-#ifdef ARGS_GROW_DOWNWARD
-static tree round_down PROTO((tree, int));
-#endif
-static rtx round_trampoline_addr PROTO((rtx));
-static tree blocks_nreverse PROTO((tree));
-static int all_blocks PROTO((tree, tree *));
-#if defined (HAVE_prologue) || defined (HAVE_epilogue)
-static int *record_insns PROTO((rtx));
-static int contains PROTO((rtx, int *));
-#endif /* HAVE_prologue || HAVE_epilogue */
-static void put_addressof_into_stack PROTO((rtx));
-static void purge_addressof_1 PROTO((rtx *, rtx, int, int));
-
-/* Pointer to chain of `struct function' for containing functions. */
-struct function *outer_function_chain;
-
-/* Given a function decl for a containing function,
- return the `struct function' for it. */
-
-struct function *
-find_function_data (decl)
- tree decl;
-{
- struct function *p;
-
- for (p = outer_function_chain; p; p = p->next)
- if (p->decl == decl)
- return p;
-
- abort ();
-}
-
-/* Save the current context for compilation of a nested function.
- This is called from language-specific code.
- The caller is responsible for saving any language-specific status,
- since this function knows only about language-independent variables. */
-
-void
-push_function_context_to (context)
- tree context;
-{
- struct function *p = (struct function *) xmalloc (sizeof (struct function));
-
- p->next = outer_function_chain;
- outer_function_chain = p;
-
- p->name = current_function_name;
- p->decl = current_function_decl;
- p->pops_args = current_function_pops_args;
- p->returns_struct = current_function_returns_struct;
- p->returns_pcc_struct = current_function_returns_pcc_struct;
- p->returns_pointer = current_function_returns_pointer;
- p->needs_context = current_function_needs_context;
- p->calls_setjmp = current_function_calls_setjmp;
- p->calls_longjmp = current_function_calls_longjmp;
- p->calls_alloca = current_function_calls_alloca;
- p->has_nonlocal_label = current_function_has_nonlocal_label;
- p->has_nonlocal_goto = current_function_has_nonlocal_goto;
- p->contains_functions = current_function_contains_functions;
- p->is_thunk = current_function_is_thunk;
- p->args_size = current_function_args_size;
- p->pretend_args_size = current_function_pretend_args_size;
- p->arg_offset_rtx = current_function_arg_offset_rtx;
- p->varargs = current_function_varargs;
- p->stdarg = current_function_stdarg;
- p->uses_const_pool = current_function_uses_const_pool;
- p->uses_pic_offset_table = current_function_uses_pic_offset_table;
- p->internal_arg_pointer = current_function_internal_arg_pointer;
- p->cannot_inline = current_function_cannot_inline;
- p->max_parm_reg = max_parm_reg;
- p->parm_reg_stack_loc = parm_reg_stack_loc;
- p->outgoing_args_size = current_function_outgoing_args_size;
- p->return_rtx = current_function_return_rtx;
- p->nonlocal_goto_handler_slots = nonlocal_goto_handler_slots;
- p->nonlocal_goto_stack_level = nonlocal_goto_stack_level;
- p->nonlocal_labels = nonlocal_labels;
- p->cleanup_label = cleanup_label;
- p->return_label = return_label;
- p->save_expr_regs = save_expr_regs;
- p->stack_slot_list = stack_slot_list;
- p->parm_birth_insn = parm_birth_insn;
- p->frame_offset = frame_offset;
- p->tail_recursion_label = tail_recursion_label;
- p->tail_recursion_reentry = tail_recursion_reentry;
- p->arg_pointer_save_area = arg_pointer_save_area;
- p->rtl_expr_chain = rtl_expr_chain;
- p->last_parm_insn = last_parm_insn;
- p->context_display = context_display;
- p->trampoline_list = trampoline_list;
- p->function_call_count = function_call_count;
- p->temp_slots = temp_slots;
- p->temp_slot_level = temp_slot_level;
- p->target_temp_slot_level = target_temp_slot_level;
- p->var_temp_slot_level = var_temp_slot_level;
- p->fixup_var_refs_queue = 0;
- p->epilogue_delay_list = current_function_epilogue_delay_list;
- p->args_info = current_function_args_info;
- p->check_memory_usage = current_function_check_memory_usage;
- p->instrument_entry_exit = current_function_instrument_entry_exit;
- /* CYGNUS LOCAL -- Branch Prediction */
- p->uses_expect = current_function_uses_expect;
- /* END CYGNUS LOCAL -- Branch Prediction */
-
- save_tree_status (p, context);
- save_storage_status (p);
- save_emit_status (p);
- save_expr_status (p);
- save_stmt_status (p);
- save_varasm_status (p, context);
- if (save_machine_status)
- (*save_machine_status) (p);
-}
-
-void
-push_function_context ()
-{
- push_function_context_to (current_function_decl);
-}
-
-/* Restore the last saved context, at the end of a nested function.
- This function is called from language-specific code. */
-
-void
-pop_function_context_from (context)
- tree context;
-{
- struct function *p = outer_function_chain;
- struct var_refs_queue *queue;
-
- outer_function_chain = p->next;
-
- current_function_contains_functions
- = p->contains_functions || p->inline_obstacks
- || context == current_function_decl;
- current_function_name = p->name;
- current_function_decl = p->decl;
- current_function_pops_args = p->pops_args;
- current_function_returns_struct = p->returns_struct;
- current_function_returns_pcc_struct = p->returns_pcc_struct;
- current_function_returns_pointer = p->returns_pointer;
- current_function_needs_context = p->needs_context;
- current_function_calls_setjmp = p->calls_setjmp;
- current_function_calls_longjmp = p->calls_longjmp;
- current_function_calls_alloca = p->calls_alloca;
- current_function_has_nonlocal_label = p->has_nonlocal_label;
- current_function_has_nonlocal_goto = p->has_nonlocal_goto;
- current_function_is_thunk = p->is_thunk;
- current_function_args_size = p->args_size;
- current_function_pretend_args_size = p->pretend_args_size;
- current_function_arg_offset_rtx = p->arg_offset_rtx;
- current_function_varargs = p->varargs;
- current_function_stdarg = p->stdarg;
- current_function_uses_const_pool = p->uses_const_pool;
- current_function_uses_pic_offset_table = p->uses_pic_offset_table;
- current_function_internal_arg_pointer = p->internal_arg_pointer;
- current_function_cannot_inline = p->cannot_inline;
- max_parm_reg = p->max_parm_reg;
- parm_reg_stack_loc = p->parm_reg_stack_loc;
- current_function_outgoing_args_size = p->outgoing_args_size;
- current_function_return_rtx = p->return_rtx;
- nonlocal_goto_handler_slots = p->nonlocal_goto_handler_slots;
- nonlocal_goto_stack_level = p->nonlocal_goto_stack_level;
- nonlocal_labels = p->nonlocal_labels;
- cleanup_label = p->cleanup_label;
- return_label = p->return_label;
- save_expr_regs = p->save_expr_regs;
- stack_slot_list = p->stack_slot_list;
- parm_birth_insn = p->parm_birth_insn;
- frame_offset = p->frame_offset;
- tail_recursion_label = p->tail_recursion_label;
- tail_recursion_reentry = p->tail_recursion_reentry;
- arg_pointer_save_area = p->arg_pointer_save_area;
- rtl_expr_chain = p->rtl_expr_chain;
- last_parm_insn = p->last_parm_insn;
- context_display = p->context_display;
- trampoline_list = p->trampoline_list;
- function_call_count = p->function_call_count;
- temp_slots = p->temp_slots;
- temp_slot_level = p->temp_slot_level;
- target_temp_slot_level = p->target_temp_slot_level;
- var_temp_slot_level = p->var_temp_slot_level;
- current_function_epilogue_delay_list = p->epilogue_delay_list;
- reg_renumber = 0;
- current_function_args_info = p->args_info;
- current_function_check_memory_usage = p->check_memory_usage;
- current_function_instrument_entry_exit = p->instrument_entry_exit;
- /* CYGNUS LOCAL -- Branch Prediction */
- current_function_uses_expect = p->uses_expect;
- /* END CYGNUS LOCAL -- Branch Prediction */
-
- restore_tree_status (p, context);
- restore_storage_status (p);
- restore_expr_status (p);
- restore_emit_status (p);
- restore_stmt_status (p);
- restore_varasm_status (p);
-
- if (restore_machine_status)
- (*restore_machine_status) (p);
-
- /* Finish doing put_var_into_stack for any of our variables
- which became addressable during the nested function. */
- for (queue = p->fixup_var_refs_queue; queue; queue = queue->next)
- fixup_var_refs (queue->modified, queue->promoted_mode, queue->unsignedp);
-
- free (p);
-
- /* Reset variables that have known state during rtx generation. */
- rtx_equal_function_value_matters = 1;
- virtuals_instantiated = 0;
-}
-
-void pop_function_context ()
-{
- pop_function_context_from (current_function_decl);
-}
-
-/* Allocate fixed slots in the stack frame of the current function. */
-
-/* Return size needed for stack frame based on slots so far allocated.
- This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY;
- the caller may have to do that. */
-
-HOST_WIDE_INT
-get_frame_size ()
-{
-#ifdef FRAME_GROWS_DOWNWARD
- return -frame_offset;
-#else
- return frame_offset;
-#endif
-}
-
-/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
- with machine mode MODE.
-
- ALIGN controls the amount of alignment for the address of the slot:
- 0 means according to MODE,
- -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
- positive specifies alignment boundary in bits.
-
- We do not round to stack_boundary here. */
-
-rtx
-assign_stack_local (mode, size, align)
- enum machine_mode mode;
- HOST_WIDE_INT size;
- int align;
-{
- register rtx x, addr;
- int bigend_correction = 0;
- int alignment;
-
- if (align == 0)
- {
- alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
- if (mode == BLKmode)
- alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
- }
- else if (align == -1)
- {
- alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
- size = CEIL_ROUND (size, alignment);
- }
- else
- alignment = align / BITS_PER_UNIT;
-
- /* Round frame offset to that alignment.
- We must be careful here, since FRAME_OFFSET might be negative and
- division with a negative dividend isn't as well defined as we might
- like. So we instead assume that ALIGNMENT is a power of two and
- use logical operations which are unambiguous. */
-#ifdef FRAME_GROWS_DOWNWARD
- frame_offset = FLOOR_ROUND (frame_offset, alignment);
-#else
- frame_offset = CEIL_ROUND (frame_offset, alignment);
-#endif
-
- /* On a big-endian machine, if we are allocating more space than we will use,
- use the least significant bytes of those that are allocated. */
- if (BYTES_BIG_ENDIAN && mode != BLKmode)
- bigend_correction = size - GET_MODE_SIZE (mode);
-
-#ifdef FRAME_GROWS_DOWNWARD
- frame_offset -= size;
-#endif
-
- /* If we have already instantiated virtual registers, return the actual
- address relative to the frame pointer. */
- if (virtuals_instantiated)
- addr = plus_constant (frame_pointer_rtx,
- (frame_offset + bigend_correction
- + STARTING_FRAME_OFFSET));
- else
- addr = plus_constant (virtual_stack_vars_rtx,
- frame_offset + bigend_correction);
-
-#ifndef FRAME_GROWS_DOWNWARD
- frame_offset += size;
-#endif
-
- x = gen_rtx_MEM (mode, addr);
-
- stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, x, stack_slot_list);
-
- return x;
-}
-
-/* Assign a stack slot in a containing function.
- First three arguments are same as in preceding function.
- The last argument specifies the function to allocate in. */
-
-static rtx
-assign_outer_stack_local (mode, size, align, function)
- enum machine_mode mode;
- HOST_WIDE_INT size;
- int align;
- struct function *function;
-{
- register rtx x, addr;
- int bigend_correction = 0;
- int alignment;
-
- /* Allocate in the memory associated with the function in whose frame
- we are assigning. */
- push_obstacks (function->function_obstack,
- function->function_maybepermanent_obstack);
-
- if (align == 0)
- {
- alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
- if (mode == BLKmode)
- alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
- }
- else if (align == -1)
- {
- alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
- size = CEIL_ROUND (size, alignment);
- }
- else
- alignment = align / BITS_PER_UNIT;
-
- /* Round frame offset to that alignment. */
-#ifdef FRAME_GROWS_DOWNWARD
- function->frame_offset = FLOOR_ROUND (function->frame_offset, alignment);
-#else
- function->frame_offset = CEIL_ROUND (function->frame_offset, alignment);
-#endif
-
- /* On a big-endian machine, if we are allocating more space than we will use,
- use the least significant bytes of those that are allocated. */
- if (BYTES_BIG_ENDIAN && mode != BLKmode)
- bigend_correction = size - GET_MODE_SIZE (mode);
-
-#ifdef FRAME_GROWS_DOWNWARD
- function->frame_offset -= size;
-#endif
- addr = plus_constant (virtual_stack_vars_rtx,
- function->frame_offset + bigend_correction);
-#ifndef FRAME_GROWS_DOWNWARD
- function->frame_offset += size;
-#endif
-
- x = gen_rtx_MEM (mode, addr);
-
- function->stack_slot_list
- = gen_rtx_EXPR_LIST (VOIDmode, x, function->stack_slot_list);
-
- pop_obstacks ();
-
- return x;
-}
-
-/* Allocate a temporary stack slot and record it for possible later
- reuse.
-
- MODE is the machine mode to be given to the returned rtx.
-
- SIZE is the size in units of the space required. We do no rounding here
- since assign_stack_local will do any required rounding.
-
- KEEP is 1 if this slot is to be retained after a call to
- free_temp_slots. Automatic variables for a block are allocated
- with this flag. KEEP is 2 if we allocate a longer term temporary,
- whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3
- if we are to allocate something at an inner level to be treated as
- a variable in the block (e.g., a SAVE_EXPR). */
-
-rtx
-assign_stack_temp (mode, size, keep)
- enum machine_mode mode;
- HOST_WIDE_INT size;
- int keep;
-{
- struct temp_slot *p, *best_p = 0;
-
- /* If SIZE is -1 it means that somebody tried to allocate a temporary
- of a variable size. */
- if (size == -1)
- abort ();
-
- /* First try to find an available, already-allocated temporary that is the
- exact size we require. */
- for (p = temp_slots; p; p = p->next)
- if (p->size == size && GET_MODE (p->slot) == mode && ! p->in_use)
- break;
-
- /* If we didn't find, one, try one that is larger than what we want. We
- find the smallest such. */
- if (p == 0)
- for (p = temp_slots; p; p = p->next)
- if (p->size > size && GET_MODE (p->slot) == mode && ! p->in_use
- && (best_p == 0 || best_p->size > p->size))
- best_p = p;
-
- /* Make our best, if any, the one to use. */
- if (best_p)
- {
- /* If there are enough aligned bytes left over, make them into a new
- temp_slot so that the extra bytes don't get wasted. Do this only
- for BLKmode slots, so that we can be sure of the alignment. */
- if (GET_MODE (best_p->slot) == BLKmode)
- {
- int alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
- HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment);
-
- if (best_p->size - rounded_size >= alignment)
- {
- p = (struct temp_slot *) oballoc (sizeof (struct temp_slot));
- p->in_use = p->addr_taken = 0;
- p->size = best_p->size - rounded_size;
- p->base_offset = best_p->base_offset + rounded_size;
- p->full_size = best_p->full_size - rounded_size;
- p->slot = gen_rtx_MEM (BLKmode,
- plus_constant (XEXP (best_p->slot, 0),
- rounded_size));
- p->address = 0;
- p->rtl_expr = 0;
- p->next = temp_slots;
- temp_slots = p;
-
- stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot,
- stack_slot_list);
-
- best_p->size = rounded_size;
- best_p->full_size = rounded_size;
- }
- }
-
- p = best_p;
- }
-
- /* If we still didn't find one, make a new temporary. */
- if (p == 0)
- {
- HOST_WIDE_INT frame_offset_old = frame_offset;
-
- p = (struct temp_slot *) oballoc (sizeof (struct temp_slot));
-
- /* If the temp slot mode doesn't indicate the alignment,
- use the largest possible, so no one will be disappointed. */
- p->slot = assign_stack_local (mode, size, mode == BLKmode ? -1 : 0);
-
- /* The following slot size computation is necessary because we don't
- know the actual size of the temporary slot until assign_stack_local
- has performed all the frame alignment and size rounding for the
- requested temporary. Note that extra space added for alignment
- can be either above or below this stack slot depending on which
- way the frame grows. We include the extra space if and only if it
- is above this slot. */
-#ifdef FRAME_GROWS_DOWNWARD
- p->size = frame_offset_old - frame_offset;
-#else
- p->size = size;
-#endif
-
- /* Now define the fields used by combine_temp_slots. */
-#ifdef FRAME_GROWS_DOWNWARD
- p->base_offset = frame_offset;
- p->full_size = frame_offset_old - frame_offset;
-#else
- p->base_offset = frame_offset_old;
- p->full_size = frame_offset - frame_offset_old;
-#endif
- p->address = 0;
- p->next = temp_slots;
- temp_slots = p;
- }
-
- p->in_use = 1;
- p->addr_taken = 0;
- p->rtl_expr = sequence_rtl_expr;
-
- if (keep == 2)
- {
- p->level = target_temp_slot_level;
- p->keep = 0;
- }
- else if (keep == 3)
- {
- p->level = var_temp_slot_level;
- p->keep = 0;
- }
- else
- {
- p->level = temp_slot_level;
- p->keep = keep;
- }
-
- /* We may be reusing an old slot, so clear any MEM flags that may have been
- set from before. */
- RTX_UNCHANGING_P (p->slot) = 0;
- MEM_IN_STRUCT_P (p->slot) = 0;
- MEM_SCALAR_P (p->slot) = 0;
- MEM_ALIAS_SET (p->slot) = 0;
- return p->slot;
-}
-
-/* Assign a temporary of given TYPE.
- KEEP is as for assign_stack_temp.
- MEMORY_REQUIRED is 1 if the result must be addressable stack memory;
- it is 0 if a register is OK.
- DONT_PROMOTE is 1 if we should not promote values in register
- to wider modes. */
-
-rtx
-assign_temp (type, keep, memory_required, dont_promote)
- tree type;
- int keep;
- int memory_required;
- int dont_promote;
-{
- enum machine_mode mode = TYPE_MODE (type);
- int unsignedp = TREE_UNSIGNED (type);
-
- if (mode == BLKmode || memory_required)
- {
- HOST_WIDE_INT size = int_size_in_bytes (type);
- rtx tmp;
-
- /* Unfortunately, we don't yet know how to allocate variable-sized
- temporaries. However, sometimes we have a fixed upper limit on
- the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that
- instead. This is the case for Chill variable-sized strings. */
- if (size == -1 && TREE_CODE (type) == ARRAY_TYPE
- && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE
- && TREE_CODE (TYPE_ARRAY_MAX_SIZE (type)) == INTEGER_CST)
- size = TREE_INT_CST_LOW (TYPE_ARRAY_MAX_SIZE (type));
-
- tmp = assign_stack_temp (mode, size, keep);
- MEM_SET_IN_STRUCT_P (tmp, AGGREGATE_TYPE_P (type));
- return tmp;
- }
-
-#ifndef PROMOTE_FOR_CALL_ONLY
- if (! dont_promote)
- mode = promote_mode (type, mode, &unsignedp, 0);
-#endif
-
- return gen_reg_rtx (mode);
-}
-
-/* Combine temporary stack slots which are adjacent on the stack.
-
- This allows for better use of already allocated stack space. This is only
- done for BLKmode slots because we can be sure that we won't have alignment
- problems in this case. */
-
-void
-combine_temp_slots ()
-{
- struct temp_slot *p, *q;
- struct temp_slot *prev_p, *prev_q;
- int num_slots;
-
- /* If there are a lot of temp slots, don't do anything unless
- high levels of optimizaton. */
- if (! flag_expensive_optimizations)
- for (p = temp_slots, num_slots = 0; p; p = p->next, num_slots++)
- if (num_slots > 100 || (num_slots > 10 && optimize == 0))
- return;
-
- for (p = temp_slots, prev_p = 0; p; p = prev_p ? prev_p->next : temp_slots)
- {
- int delete_p = 0;
-
- if (! p->in_use && GET_MODE (p->slot) == BLKmode)
- for (q = p->next, prev_q = p; q; q = prev_q->next)
- {
- int delete_q = 0;
- if (! q->in_use && GET_MODE (q->slot) == BLKmode)
- {
- if (p->base_offset + p->full_size == q->base_offset)
- {
- /* Q comes after P; combine Q into P. */
- p->size += q->size;
- p->full_size += q->full_size;
- delete_q = 1;
- }
- else if (q->base_offset + q->full_size == p->base_offset)
- {
- /* P comes after Q; combine P into Q. */
- q->size += p->size;
- q->full_size += p->full_size;
- delete_p = 1;
- break;
- }
- }
- /* Either delete Q or advance past it. */
- if (delete_q)
- prev_q->next = q->next;
- else
- prev_q = q;
- }
- /* Either delete P or advance past it. */
- if (delete_p)
- {
- if (prev_p)
- prev_p->next = p->next;
- else
- temp_slots = p->next;
- }
- else
- prev_p = p;
- }
-}
-
-/* Find the temp slot corresponding to the object at address X. */
-
-static struct temp_slot *
-find_temp_slot_from_address (x)
- rtx x;
-{
- struct temp_slot *p;
- rtx next;
-
- for (p = temp_slots; p; p = p->next)
- {
- if (! p->in_use)
- continue;
-
- else if (XEXP (p->slot, 0) == x
- || p->address == x
- || (GET_CODE (x) == PLUS
- && XEXP (x, 0) == virtual_stack_vars_rtx
- && GET_CODE (XEXP (x, 1)) == CONST_INT
- && INTVAL (XEXP (x, 1)) >= p->base_offset
- && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size))
- return p;
-
- else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST)
- for (next = p->address; next; next = XEXP (next, 1))
- if (XEXP (next, 0) == x)
- return p;
- }
-
- return 0;
-}
-
-/* Indicate that NEW is an alternate way of referring to the temp slot
- that previously was known by OLD. */
-
-void
-update_temp_slot_address (old, new)
- rtx old, new;
-{
- struct temp_slot *p = find_temp_slot_from_address (old);
-
- /* If none, return. Else add NEW as an alias. */
- if (p == 0)
- return;
- else if (p->address == 0)
- p->address = new;
- else
- {
- if (GET_CODE (p->address) != EXPR_LIST)
- p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX);
-
- p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address);
- }
-}
-
-/* If X could be a reference to a temporary slot, mark the fact that its
- address was taken. */
-
-void
-mark_temp_addr_taken (x)
- rtx x;
-{
- struct temp_slot *p;
-
- if (x == 0)
- return;
-
- /* If X is not in memory or is at a constant address, it cannot be in
- a temporary slot. */
- if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))
- return;
-
- p = find_temp_slot_from_address (XEXP (x, 0));
- if (p != 0)
- p->addr_taken = 1;
-}
-
-/* If X could be a reference to a temporary slot, mark that slot as
- belonging to the to one level higher than the current level. If X
- matched one of our slots, just mark that one. Otherwise, we can't
- easily predict which it is, so upgrade all of them. Kept slots
- need not be touched.
-
- This is called when an ({...}) construct occurs and a statement
- returns a value in memory. */
-
-void
-preserve_temp_slots (x)
- rtx x;
-{
- struct temp_slot *p = 0;
-
- /* If there is no result, we still might have some objects whose address
- were taken, so we need to make sure they stay around. */
- if (x == 0)
- {
- for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && p->addr_taken)
- p->level--;
-
- return;
- }
-
- /* If X is a register that is being used as a pointer, see if we have
- a temporary slot we know it points to. To be consistent with
- the code below, we really should preserve all non-kept slots
- if we can't find a match, but that seems to be much too costly. */
- if (GET_CODE (x) == REG && REGNO_POINTER_FLAG (REGNO (x)))
- p = find_temp_slot_from_address (x);
-
- /* If X is not in memory or is at a constant address, it cannot be in
- a temporary slot, but it can contain something whose address was
- taken. */
- if (p == 0 && (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))))
- {
- for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && p->addr_taken)
- p->level--;
-
- return;
- }
-
- /* First see if we can find a match. */
- if (p == 0)
- p = find_temp_slot_from_address (XEXP (x, 0));
-
- if (p != 0)
- {
- /* Move everything at our level whose address was taken to our new
- level in case we used its address. */
- struct temp_slot *q;
-
- if (p->level == temp_slot_level)
- {
- for (q = temp_slots; q; q = q->next)
- if (q != p && q->addr_taken && q->level == p->level)
- q->level--;
-
- p->level--;
- p->addr_taken = 0;
- }
- return;
- }
-
- /* Otherwise, preserve all non-kept slots at this level. */
- for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && ! p->keep)
- p->level--;
-}
-
-/* X is the result of an RTL_EXPR. If it is a temporary slot associated
- with that RTL_EXPR, promote it into a temporary slot at the present
- level so it will not be freed when we free slots made in the
- RTL_EXPR. */
-
-void
-preserve_rtl_expr_result (x)
- rtx x;
-{
- struct temp_slot *p;
-
- /* If X is not in memory or is at a constant address, it cannot be in
- a temporary slot. */
- if (x == 0 || GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))
- return;
-
- /* If we can find a match, move it to our level unless it is already at
- an upper level. */
- p = find_temp_slot_from_address (XEXP (x, 0));
- if (p != 0)
- {
- p->level = MIN (p->level, temp_slot_level);
- p->rtl_expr = 0;
- }
-
- return;
-}
-
-/* Free all temporaries used so far. This is normally called at the end
- of generating code for a statement. Don't free any temporaries
- currently in use for an RTL_EXPR that hasn't yet been emitted.
- We could eventually do better than this since it can be reused while
- generating the same RTL_EXPR, but this is complex and probably not
- worthwhile. */
-
-void
-free_temp_slots ()
-{
- struct temp_slot *p;
-
- for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && ! p->keep
- && p->rtl_expr == 0)
- p->in_use = 0;
-
- combine_temp_slots ();
-}
-
-/* Free all temporary slots used in T, an RTL_EXPR node. */
-
-void
-free_temps_for_rtl_expr (t)
- tree t;
-{
- struct temp_slot *p;
-
- for (p = temp_slots; p; p = p->next)
- if (p->rtl_expr == t)
- p->in_use = 0;
-
- combine_temp_slots ();
-}
-
-/* Mark all temporaries ever allocated in this function as not suitable
- for reuse until the current level is exited. */
-
-void
-mark_all_temps_used ()
-{
- struct temp_slot *p;
-
- for (p = temp_slots; p; p = p->next)
- {
- p->in_use = p->keep = 1;
- p->level = MIN (p->level, temp_slot_level);
- }
-}
-
-/* Push deeper into the nesting level for stack temporaries. */
-
-void
-push_temp_slots ()
-{
- temp_slot_level++;
-}
-
-/* Likewise, but save the new level as the place to allocate variables
- for blocks. */
-
-void
-push_temp_slots_for_block ()
-{
- push_temp_slots ();
-
- var_temp_slot_level = temp_slot_level;
-}
-
-/* Likewise, but save the new level as the place to allocate temporaries
- for TARGET_EXPRs. */
-
-void
-push_temp_slots_for_target ()
-{
- push_temp_slots ();
-
- target_temp_slot_level = temp_slot_level;
-}
-
-/* Set and get the value of target_temp_slot_level. The only
- permitted use of these functions is to save and restore this value. */
-
-int
-get_target_temp_slot_level ()
-{
- return target_temp_slot_level;
-}
-
-void
-set_target_temp_slot_level (level)
- int level;
-{
- target_temp_slot_level = level;
-}
-
-/* Pop a temporary nesting level. All slots in use in the current level
- are freed. */
-
-void
-pop_temp_slots ()
-{
- struct temp_slot *p;
-
- for (p = temp_slots; p; p = p->next)
- if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0)
- p->in_use = 0;
-
- combine_temp_slots ();
-
- temp_slot_level--;
-}
-
-/* Initialize temporary slots. */
-
-void
-init_temp_slots ()
-{
- /* We have not allocated any temporaries yet. */
- temp_slots = 0;
- temp_slot_level = 0;
- var_temp_slot_level = 0;
- target_temp_slot_level = 0;
-}
-
-/* Retroactively move an auto variable from a register to a stack slot.
- This is done when an address-reference to the variable is seen. */
-
-void
-put_var_into_stack (decl)
- tree decl;
-{
- register rtx reg;
- enum machine_mode promoted_mode, decl_mode;
- struct function *function = 0;
- tree context;
- int can_use_addressof;
-
- context = decl_function_context (decl);
-
- /* Get the current rtl used for this object and its original mode. */
- reg = TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl) : DECL_RTL (decl);
-
- /* No need to do anything if decl has no rtx yet
- since in that case caller is setting TREE_ADDRESSABLE
- and a stack slot will be assigned when the rtl is made. */
- if (reg == 0)
- return;
-
- /* Get the declared mode for this object. */
- decl_mode = (TREE_CODE (decl) == SAVE_EXPR ? TYPE_MODE (TREE_TYPE (decl))
- : DECL_MODE (decl));
- /* Get the mode it's actually stored in. */
- promoted_mode = GET_MODE (reg);
-
- /* If this variable comes from an outer function,
- find that function's saved context. */
- if (context != current_function_decl && context != inline_function_decl)
- for (function = outer_function_chain; function; function = function->next)
- if (function->decl == context)
- break;
-
- /* If this is a variable-size object with a pseudo to address it,
- put that pseudo into the stack, if the var is nonlocal. */
- if (DECL_NONLOCAL (decl)
- && GET_CODE (reg) == MEM
- && GET_CODE (XEXP (reg, 0)) == REG
- && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER)
- {
- reg = XEXP (reg, 0);
- decl_mode = promoted_mode = GET_MODE (reg);
- }
-
- can_use_addressof
- = (function == 0
- && optimize > 0
- /* FIXME make it work for promoted modes too */
- && decl_mode == promoted_mode
-#ifdef NON_SAVING_SETJMP
- && ! (NON_SAVING_SETJMP && current_function_calls_setjmp)
-#endif
- );
-
- /* If we can't use ADDRESSOF, make sure we see through one we already
- generated. */
- if (! can_use_addressof && GET_CODE (reg) == MEM
- && GET_CODE (XEXP (reg, 0)) == ADDRESSOF)
- reg = XEXP (XEXP (reg, 0), 0);
-
- /* Now we should have a value that resides in one or more pseudo regs. */
-
- if (GET_CODE (reg) == REG)
- {
- /* If this variable lives in the current function and we don't need
- to put things in the stack for the sake of setjmp, try to keep it
- in a register until we know we actually need the address. */
- if (can_use_addressof)
- gen_mem_addressof (reg, decl);
- else
- put_reg_into_stack (function, reg, TREE_TYPE (decl),
- promoted_mode, decl_mode,
- TREE_SIDE_EFFECTS (decl), 0,
- TREE_USED (decl)
- || DECL_INITIAL (decl) != 0);
- }
- else if (GET_CODE (reg) == CONCAT)
- {
- /* A CONCAT contains two pseudos; put them both in the stack.
- We do it so they end up consecutive. */
- enum machine_mode part_mode = GET_MODE (XEXP (reg, 0));
- tree part_type = TREE_TYPE (TREE_TYPE (decl));
-#ifdef FRAME_GROWS_DOWNWARD
- /* Since part 0 should have a lower address, do it second. */
- put_reg_into_stack (function, XEXP (reg, 1), part_type, part_mode,
- part_mode, TREE_SIDE_EFFECTS (decl), 0,
- TREE_USED (decl) || DECL_INITIAL (decl) != 0);
- put_reg_into_stack (function, XEXP (reg, 0), part_type, part_mode,
- part_mode, TREE_SIDE_EFFECTS (decl), 0,
- TREE_USED (decl) || DECL_INITIAL (decl) != 0);
-#else
- put_reg_into_stack (function, XEXP (reg, 0), part_type, part_mode,
- part_mode, TREE_SIDE_EFFECTS (decl), 0,
- TREE_USED (decl) || DECL_INITIAL (decl) != 0);
- put_reg_into_stack (function, XEXP (reg, 1), part_type, part_mode,
- part_mode, TREE_SIDE_EFFECTS (decl), 0,
- TREE_USED (decl) || DECL_INITIAL (decl) != 0);
-#endif
-
- /* Change the CONCAT into a combined MEM for both parts. */
- PUT_CODE (reg, MEM);
- MEM_VOLATILE_P (reg) = MEM_VOLATILE_P (XEXP (reg, 0));
- MEM_ALIAS_SET (reg) = get_alias_set (decl);
-
- /* The two parts are in memory order already.
- Use the lower parts address as ours. */
- XEXP (reg, 0) = XEXP (XEXP (reg, 0), 0);
- /* Prevent sharing of rtl that might lose. */
- if (GET_CODE (XEXP (reg, 0)) == PLUS)
- XEXP (reg, 0) = copy_rtx (XEXP (reg, 0));
- }
- else
- return;
-
- if (current_function_check_memory_usage)
- emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
- XEXP (reg, 0), ptr_mode,
- GEN_INT (GET_MODE_SIZE (GET_MODE (reg))),
- TYPE_MODE (sizetype),
- GEN_INT (MEMORY_USE_RW),
- TYPE_MODE (integer_type_node));
-}
-
-/* Subroutine of put_var_into_stack. This puts a single pseudo reg REG
- into the stack frame of FUNCTION (0 means the current function).
- DECL_MODE is the machine mode of the user-level data type.
- PROMOTED_MODE is the machine mode of the register.
- VOLATILE_P is nonzero if this is for a "volatile" decl.
- USED_P is nonzero if this reg might have already been used in an insn. */
-
-static void
-put_reg_into_stack (function, reg, type, promoted_mode, decl_mode, volatile_p,
- original_regno, used_p)
- struct function *function;
- rtx reg;
- tree type;
- enum machine_mode promoted_mode, decl_mode;
- int volatile_p;
- int original_regno;
- int used_p;
-{
- rtx new = 0;
- int regno = original_regno;
-
- if (regno == 0)
- regno = REGNO (reg);
-
- if (function)
- {
- if (regno < function->max_parm_reg)
- new = function->parm_reg_stack_loc[regno];
- if (new == 0)
- new = assign_outer_stack_local (decl_mode, GET_MODE_SIZE (decl_mode),
- 0, function);
- }
- else
- {
- if (regno < max_parm_reg)
- new = parm_reg_stack_loc[regno];
- if (new == 0)
- new = assign_stack_local (decl_mode, GET_MODE_SIZE (decl_mode), 0);
- }
-
- PUT_MODE (reg, decl_mode);
- XEXP (reg, 0) = XEXP (new, 0);
- /* `volatil' bit means one thing for MEMs, another entirely for REGs. */
- MEM_VOLATILE_P (reg) = volatile_p;
- PUT_CODE (reg, MEM);
-
- /* If this is a memory ref that contains aggregate components,
- mark it as such for cse and loop optimize. If we are reusing a
- previously generated stack slot, then we need to copy the bit in
- case it was set for other reasons. For instance, it is set for
- __builtin_va_alist. */
- MEM_SET_IN_STRUCT_P (reg,
- AGGREGATE_TYPE_P (type) || MEM_IN_STRUCT_P (new));
- MEM_ALIAS_SET (reg) = get_alias_set (type);
-
- /* Now make sure that all refs to the variable, previously made
- when it was a register, are fixed up to be valid again. */
-
- if (used_p && function != 0)
- {
- struct var_refs_queue *temp;
-
- /* Variable is inherited; fix it up when we get back to its function. */
- push_obstacks (function->function_obstack,
- function->function_maybepermanent_obstack);
-
- /* See comment in restore_tree_status in tree.c for why this needs to be
- on saveable obstack. */
- temp
- = (struct var_refs_queue *) savealloc (sizeof (struct var_refs_queue));
- temp->modified = reg;
- temp->promoted_mode = promoted_mode;
- temp->unsignedp = TREE_UNSIGNED (type);
- temp->next = function->fixup_var_refs_queue;
- function->fixup_var_refs_queue = temp;
- pop_obstacks ();
- }
- else if (used_p)
- /* Variable is local; fix it up now. */
- fixup_var_refs (reg, promoted_mode, TREE_UNSIGNED (type));
-}
-
-static void
-fixup_var_refs (var, promoted_mode, unsignedp)
- rtx var;
- enum machine_mode promoted_mode;
- int unsignedp;
-{
- tree pending;
- rtx first_insn = get_insns ();
- struct sequence_stack *stack = sequence_stack;
- tree rtl_exps = rtl_expr_chain;
-
- /* Must scan all insns for stack-refs that exceed the limit. */
- fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn, stack == 0);
-
- /* Scan all pending sequences too. */
- for (; stack; stack = stack->next)
- {
- push_to_sequence (stack->first);
- fixup_var_refs_insns (var, promoted_mode, unsignedp,
- stack->first, stack->next != 0);
- /* Update remembered end of sequence
- in case we added an insn at the end. */
- stack->last = get_last_insn ();
- end_sequence ();
- }
-
- /* Scan all waiting RTL_EXPRs too. */
- for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending))
- {
- rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending));
- if (seq != const0_rtx && seq != 0)
- {
- push_to_sequence (seq);
- fixup_var_refs_insns (var, promoted_mode, unsignedp, seq, 0);
- end_sequence ();
- }
- }
-
- /* Scan the catch clauses for exception handling too. */
- push_to_sequence (catch_clauses);
- fixup_var_refs_insns (var, promoted_mode, unsignedp, catch_clauses, 0);
- end_sequence ();
-}
-
-/* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is
- some part of an insn. Return a struct fixup_replacement whose OLD
- value is equal to X. Allocate a new structure if no such entry exists. */
-
-static struct fixup_replacement *
-find_fixup_replacement (replacements, x)
- struct fixup_replacement **replacements;
- rtx x;
-{
- struct fixup_replacement *p;
-
- /* See if we have already replaced this. */
- for (p = *replacements; p && p->old != x; p = p->next)
- ;
-
- if (p == 0)
- {
- p = (struct fixup_replacement *) oballoc (sizeof (struct fixup_replacement));
- p->old = x;
- p->new = 0;
- p->next = *replacements;
- *replacements = p;
- }
-
- return p;
-}
-
-/* Scan the insn-chain starting with INSN for refs to VAR
- and fix them up. TOPLEVEL is nonzero if this chain is the
- main chain of insns for the current function. */
-
-static void
-fixup_var_refs_insns (var, promoted_mode, unsignedp, insn, toplevel)
- rtx var;
- enum machine_mode promoted_mode;
- int unsignedp;
- rtx insn;
- int toplevel;
-{
- rtx call_dest = 0;
-
- while (insn)
- {
- rtx next = NEXT_INSN (insn);
- rtx set, prev, prev_set;
- rtx note;
-
- if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
- {
- /* If this is a CLOBBER of VAR, delete it.
-
- If it has a REG_LIBCALL note, delete the REG_LIBCALL
- and REG_RETVAL notes too. */
- if (GET_CODE (PATTERN (insn)) == CLOBBER
- && (XEXP (PATTERN (insn), 0) == var
- || (GET_CODE (XEXP (PATTERN (insn), 0)) == CONCAT
- && (XEXP (XEXP (PATTERN (insn), 0), 0) == var
- || XEXP (XEXP (PATTERN (insn), 0), 1) == var))))
- {
- if ((note = find_reg_note (insn, REG_LIBCALL, NULL_RTX)) != 0)
- /* The REG_LIBCALL note will go away since we are going to
- turn INSN into a NOTE, so just delete the
- corresponding REG_RETVAL note. */
- remove_note (XEXP (note, 0),
- find_reg_note (XEXP (note, 0), REG_RETVAL,
- NULL_RTX));
-
- /* In unoptimized compilation, we shouldn't call delete_insn
- except in jump.c doing warnings. */
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- }
-
- /* The insn to load VAR from a home in the arglist
- is now a no-op. When we see it, just delete it.
- Similarly if this is storing VAR from a register from which
- it was loaded in the previous insn. This will occur
- when an ADDRESSOF was made for an arglist slot. */
- else if (toplevel
- && (set = single_set (insn)) != 0
- && SET_DEST (set) == var
- /* If this represents the result of an insn group,
- don't delete the insn. */
- && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0
- && (rtx_equal_p (SET_SRC (set), var)
- || (GET_CODE (SET_SRC (set)) == REG
- && (prev = prev_nonnote_insn (insn)) != 0
- && (prev_set = single_set (prev)) != 0
- && SET_DEST (prev_set) == SET_SRC (set)
- && rtx_equal_p (SET_SRC (prev_set), var))))
- {
- /* In unoptimized compilation, we shouldn't call delete_insn
- except in jump.c doing warnings. */
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- if (insn == last_parm_insn)
- last_parm_insn = PREV_INSN (next);
- }
- else
- {
- struct fixup_replacement *replacements = 0;
- rtx next_insn = NEXT_INSN (insn);
-
- if (SMALL_REGISTER_CLASSES)
- {
- /* If the insn that copies the results of a CALL_INSN
- into a pseudo now references VAR, we have to use an
- intermediate pseudo since we want the life of the
- return value register to be only a single insn.
-
- If we don't use an intermediate pseudo, such things as
- address computations to make the address of VAR valid
- if it is not can be placed between the CALL_INSN and INSN.
-
- To make sure this doesn't happen, we record the destination
- of the CALL_INSN and see if the next insn uses both that
- and VAR. */
-
- if (call_dest != 0 && GET_CODE (insn) == INSN
- && reg_mentioned_p (var, PATTERN (insn))
- && reg_mentioned_p (call_dest, PATTERN (insn)))
- {
- rtx temp = gen_reg_rtx (GET_MODE (call_dest));
-
- emit_insn_before (gen_move_insn (temp, call_dest), insn);
-
- PATTERN (insn) = replace_rtx (PATTERN (insn),
- call_dest, temp);
- }
-
- if (GET_CODE (insn) == CALL_INSN
- && GET_CODE (PATTERN (insn)) == SET)
- call_dest = SET_DEST (PATTERN (insn));
- else if (GET_CODE (insn) == CALL_INSN
- && GET_CODE (PATTERN (insn)) == PARALLEL
- && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
- call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
- else
- call_dest = 0;
- }
-
- /* See if we have to do anything to INSN now that VAR is in
- memory. If it needs to be loaded into a pseudo, use a single
- pseudo for the entire insn in case there is a MATCH_DUP
- between two operands. We pass a pointer to the head of
- a list of struct fixup_replacements. If fixup_var_refs_1
- needs to allocate pseudos or replacement MEMs (for SUBREGs),
- it will record them in this list.
-
- If it allocated a pseudo for any replacement, we copy into
- it here. */
-
- fixup_var_refs_1 (var, promoted_mode, &PATTERN (insn), insn,
- &replacements);
-
- /* If this is last_parm_insn, and any instructions were output
- after it to fix it up, then we must set last_parm_insn to
- the last such instruction emitted. */
- if (insn == last_parm_insn)
- last_parm_insn = PREV_INSN (next_insn);
-
- while (replacements)
- {
- if (GET_CODE (replacements->new) == REG)
- {
- rtx insert_before;
- rtx seq;
-
- /* OLD might be a (subreg (mem)). */
- if (GET_CODE (replacements->old) == SUBREG)
- replacements->old
- = fixup_memory_subreg (replacements->old, insn, 0);
- else
- replacements->old
- = fixup_stack_1 (replacements->old, insn);
-
- insert_before = insn;
-
- /* If we are changing the mode, do a conversion.
- This might be wasteful, but combine.c will
- eliminate much of the waste. */
-
- if (GET_MODE (replacements->new)
- != GET_MODE (replacements->old))
- {
- start_sequence ();
- convert_move (replacements->new,
- replacements->old, unsignedp);
- seq = gen_sequence ();
- end_sequence ();
- }
- else
- seq = gen_move_insn (replacements->new,
- replacements->old);
-
- emit_insn_before (seq, insert_before);
- }
-
- replacements = replacements->next;
- }
- }
-
- /* Also fix up any invalid exprs in the REG_NOTES of this insn.
- But don't touch other insns referred to by reg-notes;
- we will get them elsewhere. */
- for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
- if (GET_CODE (note) != INSN_LIST)
- XEXP (note, 0)
- = walk_fixup_memory_subreg (XEXP (note, 0), insn, 1);
- }
- insn = next;
- }
-}
-
-/* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE.
- See if the rtx expression at *LOC in INSN needs to be changed.
-
- REPLACEMENTS is a pointer to a list head that starts out zero, but may
- contain a list of original rtx's and replacements. If we find that we need
- to modify this insn by replacing a memory reference with a pseudo or by
- making a new MEM to implement a SUBREG, we consult that list to see if
- we have already chosen a replacement. If none has already been allocated,
- we allocate it and update the list. fixup_var_refs_insns will copy VAR
- or the SUBREG, as appropriate, to the pseudo. */
-
-static void
-fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements)
- register rtx var;
- enum machine_mode promoted_mode;
- register rtx *loc;
- rtx insn;
- struct fixup_replacement **replacements;
-{
- register int i;
- register rtx x = *loc;
- RTX_CODE code = GET_CODE (x);
- register char *fmt;
- register rtx tem, tem1;
- struct fixup_replacement *replacement;
-
- switch (code)
- {
- case ADDRESSOF:
- if (XEXP (x, 0) == var)
- {
- /* Prevent sharing of rtl that might lose. */
- rtx sub = copy_rtx (XEXP (var, 0));
-
- start_sequence ();
-
- if (! validate_change (insn, loc, sub, 0))
- {
- rtx y = force_operand (sub, NULL_RTX);
-
- if (! validate_change (insn, loc, y, 0))
- *loc = copy_to_reg (y);
- }
-
- emit_insn_before (gen_sequence (), insn);
- end_sequence ();
- }
- return;
-
- case MEM:
- if (var == x)
- {
- /* If we already have a replacement, use it. Otherwise,
- try to fix up this address in case it is invalid. */
-
- replacement = find_fixup_replacement (replacements, var);
- if (replacement->new)
- {
- *loc = replacement->new;
- return;
- }
-
- *loc = replacement->new = x = fixup_stack_1 (x, insn);
-
- /* Unless we are forcing memory to register or we changed the mode,
- we can leave things the way they are if the insn is valid. */
-
- INSN_CODE (insn) = -1;
- if (! flag_force_mem && GET_MODE (x) == promoted_mode
- && recog_memoized (insn) >= 0)
- return;
-
- *loc = replacement->new = gen_reg_rtx (promoted_mode);
- return;
- }
-
- /* If X contains VAR, we need to unshare it here so that we update
- each occurrence separately. But all identical MEMs in one insn
- must be replaced with the same rtx because of the possibility of
- MATCH_DUPs. */
-
- if (reg_mentioned_p (var, x))
- {
- replacement = find_fixup_replacement (replacements, x);
- if (replacement->new == 0)
- replacement->new = copy_most_rtx (x, var);
-
- *loc = x = replacement->new;
- }
- break;
-
- case REG:
- case CC0:
- case PC:
- case CONST_INT:
- case CONST:
- case SYMBOL_REF:
- case LABEL_REF:
- case CONST_DOUBLE:
- return;
-
- case SIGN_EXTRACT:
- case ZERO_EXTRACT:
- /* Note that in some cases those types of expressions are altered
- by optimize_bit_field, and do not survive to get here. */
- if (XEXP (x, 0) == var
- || (GET_CODE (XEXP (x, 0)) == SUBREG
- && SUBREG_REG (XEXP (x, 0)) == var))
- {
- /* Get TEM as a valid MEM in the mode presently in the insn.
-
- We don't worry about the possibility of MATCH_DUP here; it
- is highly unlikely and would be tricky to handle. */
-
- tem = XEXP (x, 0);
- if (GET_CODE (tem) == SUBREG)
- {
- if (GET_MODE_BITSIZE (GET_MODE (tem))
- > GET_MODE_BITSIZE (GET_MODE (var)))
- {
- replacement = find_fixup_replacement (replacements, var);
- if (replacement->new == 0)
- replacement->new = gen_reg_rtx (GET_MODE (var));
- SUBREG_REG (tem) = replacement->new;
- }
- else
- tem = fixup_memory_subreg (tem, insn, 0);
- }
- else
- tem = fixup_stack_1 (tem, insn);
-
- /* Unless we want to load from memory, get TEM into the proper mode
- for an extract from memory. This can only be done if the
- extract is at a constant position and length. */
-
- if (! flag_force_mem && GET_CODE (XEXP (x, 1)) == CONST_INT
- && GET_CODE (XEXP (x, 2)) == CONST_INT
- && ! mode_dependent_address_p (XEXP (tem, 0))
- && ! MEM_VOLATILE_P (tem))
- {
- enum machine_mode wanted_mode = VOIDmode;
- enum machine_mode is_mode = GET_MODE (tem);
- HOST_WIDE_INT pos = INTVAL (XEXP (x, 2));
-
-#ifdef HAVE_extzv
- if (GET_CODE (x) == ZERO_EXTRACT)
- {
- wanted_mode = insn_operand_mode[(int) CODE_FOR_extzv][1];
- if (wanted_mode == VOIDmode)
- wanted_mode = word_mode;
- }
-#endif
-#ifdef HAVE_extv
- if (GET_CODE (x) == SIGN_EXTRACT)
- {
- wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1];
- if (wanted_mode == VOIDmode)
- wanted_mode = word_mode;
- }
-#endif
- /* If we have a narrower mode, we can do something. */
- if (wanted_mode != VOIDmode
- && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
- {
- HOST_WIDE_INT offset = pos / BITS_PER_UNIT;
- rtx old_pos = XEXP (x, 2);
- rtx newmem;
-
- /* If the bytes and bits are counted differently, we
- must adjust the offset. */
- if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
- offset = (GET_MODE_SIZE (is_mode)
- - GET_MODE_SIZE (wanted_mode) - offset);
-
- pos %= GET_MODE_BITSIZE (wanted_mode);
-
- newmem = gen_rtx_MEM (wanted_mode,
- plus_constant (XEXP (tem, 0), offset));
- RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem);
- MEM_COPY_ATTRIBUTES (newmem, tem);
-
- /* Make the change and see if the insn remains valid. */
- INSN_CODE (insn) = -1;
- XEXP (x, 0) = newmem;
- XEXP (x, 2) = GEN_INT (pos);
-
- if (recog_memoized (insn) >= 0)
- return;
-
- /* Otherwise, restore old position. XEXP (x, 0) will be
- restored later. */
- XEXP (x, 2) = old_pos;
- }
- }
-
- /* If we get here, the bitfield extract insn can't accept a memory
- reference. Copy the input into a register. */
-
- tem1 = gen_reg_rtx (GET_MODE (tem));
- emit_insn_before (gen_move_insn (tem1, tem), insn);
- XEXP (x, 0) = tem1;
- return;
- }
- break;
-
- case SUBREG:
- if (SUBREG_REG (x) == var)
- {
- /* If this is a special SUBREG made because VAR was promoted
- from a wider mode, replace it with VAR and call ourself
- recursively, this time saying that the object previously
- had its current mode (by virtue of the SUBREG). */
-
- if (SUBREG_PROMOTED_VAR_P (x))
- {
- *loc = var;
- fixup_var_refs_1 (var, GET_MODE (var), loc, insn, replacements);
- return;
- }
-
- /* If this SUBREG makes VAR wider, it has become a paradoxical
- SUBREG with VAR in memory, but these aren't allowed at this
- stage of the compilation. So load VAR into a pseudo and take
- a SUBREG of that pseudo. */
- if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var)))
- {
- replacement = find_fixup_replacement (replacements, var);
- if (replacement->new == 0)
- replacement->new = gen_reg_rtx (GET_MODE (var));
- SUBREG_REG (x) = replacement->new;
- return;
- }
-
- /* See if we have already found a replacement for this SUBREG.
- If so, use it. Otherwise, make a MEM and see if the insn
- is recognized. If not, or if we should force MEM into a register,
- make a pseudo for this SUBREG. */
- replacement = find_fixup_replacement (replacements, x);
- if (replacement->new)
- {
- *loc = replacement->new;
- return;
- }
-
- replacement->new = *loc = fixup_memory_subreg (x, insn, 0);
-
- INSN_CODE (insn) = -1;
- if (! flag_force_mem && recog_memoized (insn) >= 0)
- return;
-
- *loc = replacement->new = gen_reg_rtx (GET_MODE (x));
- return;
- }
- break;
-
- case SET:
- /* First do special simplification of bit-field references. */
- if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT
- || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
- optimize_bit_field (x, insn, 0);
- if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
- || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
- optimize_bit_field (x, insn, NULL_PTR);
-
- /* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object
- into a register and then store it back out. */
- if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
- && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG
- && SUBREG_REG (XEXP (SET_DEST (x), 0)) == var
- && (GET_MODE_SIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
- > GET_MODE_SIZE (GET_MODE (var))))
- {
- replacement = find_fixup_replacement (replacements, var);
- if (replacement->new == 0)
- replacement->new = gen_reg_rtx (GET_MODE (var));
-
- SUBREG_REG (XEXP (SET_DEST (x), 0)) = replacement->new;
- emit_insn_after (gen_move_insn (var, replacement->new), insn);
- }
-
- /* If SET_DEST is now a paradoxical SUBREG, put the result of this
- insn into a pseudo and store the low part of the pseudo into VAR. */
- if (GET_CODE (SET_DEST (x)) == SUBREG
- && SUBREG_REG (SET_DEST (x)) == var
- && (GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
- > GET_MODE_SIZE (GET_MODE (var))))
- {
- SET_DEST (x) = tem = gen_reg_rtx (GET_MODE (SET_DEST (x)));
- emit_insn_after (gen_move_insn (var, gen_lowpart (GET_MODE (var),
- tem)),
- insn);
- break;
- }
-
- {
- rtx dest = SET_DEST (x);
- rtx src = SET_SRC (x);
-#ifdef HAVE_insv
- rtx outerdest = dest;
-#endif
-
- while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
- || GET_CODE (dest) == SIGN_EXTRACT
- || GET_CODE (dest) == ZERO_EXTRACT)
- dest = XEXP (dest, 0);
-
- if (GET_CODE (src) == SUBREG)
- src = XEXP (src, 0);
-
- /* If VAR does not appear at the top level of the SET
- just scan the lower levels of the tree. */
-
- if (src != var && dest != var)
- break;
-
- /* We will need to rerecognize this insn. */
- INSN_CODE (insn) = -1;
-
-#ifdef HAVE_insv
- if (GET_CODE (outerdest) == ZERO_EXTRACT && dest == var)
- {
- /* Since this case will return, ensure we fixup all the
- operands here. */
- fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 1),
- insn, replacements);
- fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 2),
- insn, replacements);
- fixup_var_refs_1 (var, promoted_mode, &SET_SRC (x),
- insn, replacements);
-
- tem = XEXP (outerdest, 0);
-
- /* Clean up (SUBREG:SI (MEM:mode ...) 0)
- that may appear inside a ZERO_EXTRACT.
- This was legitimate when the MEM was a REG. */
- if (GET_CODE (tem) == SUBREG
- && SUBREG_REG (tem) == var)
- tem = fixup_memory_subreg (tem, insn, 0);
- else
- tem = fixup_stack_1 (tem, insn);
-
- if (GET_CODE (XEXP (outerdest, 1)) == CONST_INT
- && GET_CODE (XEXP (outerdest, 2)) == CONST_INT
- && ! mode_dependent_address_p (XEXP (tem, 0))
- && ! MEM_VOLATILE_P (tem))
- {
- enum machine_mode wanted_mode;
- enum machine_mode is_mode = GET_MODE (tem);
- HOST_WIDE_INT pos = INTVAL (XEXP (outerdest, 2));
-
- wanted_mode = insn_operand_mode[(int) CODE_FOR_insv][0];
- if (wanted_mode == VOIDmode)
- wanted_mode = word_mode;
-
- /* If we have a narrower mode, we can do something. */
- if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
- {
- HOST_WIDE_INT offset = pos / BITS_PER_UNIT;
- rtx old_pos = XEXP (outerdest, 2);
- rtx newmem;
-
- if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN)
- offset = (GET_MODE_SIZE (is_mode)
- - GET_MODE_SIZE (wanted_mode) - offset);
-
- pos %= GET_MODE_BITSIZE (wanted_mode);
-
- newmem = gen_rtx_MEM (wanted_mode,
- plus_constant (XEXP (tem, 0), offset));
- RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem);
- MEM_COPY_ATTRIBUTES (newmem, tem);
-
- /* Make the change and see if the insn remains valid. */
- INSN_CODE (insn) = -1;
- XEXP (outerdest, 0) = newmem;
- XEXP (outerdest, 2) = GEN_INT (pos);
-
- if (recog_memoized (insn) >= 0)
- return;
-
- /* Otherwise, restore old position. XEXP (x, 0) will be
- restored later. */
- XEXP (outerdest, 2) = old_pos;
- }
- }
-
- /* If we get here, the bit-field store doesn't allow memory
- or isn't located at a constant position. Load the value into
- a register, do the store, and put it back into memory. */
-
- tem1 = gen_reg_rtx (GET_MODE (tem));
- emit_insn_before (gen_move_insn (tem1, tem), insn);
- emit_insn_after (gen_move_insn (tem, tem1), insn);
- XEXP (outerdest, 0) = tem1;
- return;
- }
-#endif
-
- /* STRICT_LOW_PART is a no-op on memory references
- and it can cause combinations to be unrecognizable,
- so eliminate it. */
-
- if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
- SET_DEST (x) = XEXP (SET_DEST (x), 0);
-
- /* A valid insn to copy VAR into or out of a register
- must be left alone, to avoid an infinite loop here.
- If the reference to VAR is by a subreg, fix that up,
- since SUBREG is not valid for a memref.
- Also fix up the address of the stack slot.
-
- Note that we must not try to recognize the insn until
- after we know that we have valid addresses and no
- (subreg (mem ...) ...) constructs, since these interfere
- with determining the validity of the insn. */
-
- if ((SET_SRC (x) == var
- || (GET_CODE (SET_SRC (x)) == SUBREG
- && SUBREG_REG (SET_SRC (x)) == var))
- && (GET_CODE (SET_DEST (x)) == REG
- || (GET_CODE (SET_DEST (x)) == SUBREG
- && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG))
- && GET_MODE (var) == promoted_mode
- && x == single_set (insn))
- {
- rtx pat;
-
- replacement = find_fixup_replacement (replacements, SET_SRC (x));
- if (replacement->new)
- SET_SRC (x) = replacement->new;
- else if (GET_CODE (SET_SRC (x)) == SUBREG)
- SET_SRC (x) = replacement->new
- = fixup_memory_subreg (SET_SRC (x), insn, 0);
- else
- SET_SRC (x) = replacement->new
- = fixup_stack_1 (SET_SRC (x), insn);
-
- if (recog_memoized (insn) >= 0)
- return;
-
- /* INSN is not valid, but we know that we want to
- copy SET_SRC (x) to SET_DEST (x) in some way. So
- we generate the move and see whether it requires more
- than one insn. If it does, we emit those insns and
- delete INSN. Otherwise, we an just replace the pattern
- of INSN; we have already verified above that INSN has
- no other function that to do X. */
-
- pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
- if (GET_CODE (pat) == SEQUENCE)
- {
- emit_insn_after (pat, insn);
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- }
- else
- PATTERN (insn) = pat;
-
- return;
- }
-
- if ((SET_DEST (x) == var
- || (GET_CODE (SET_DEST (x)) == SUBREG
- && SUBREG_REG (SET_DEST (x)) == var))
- && (GET_CODE (SET_SRC (x)) == REG
- || (GET_CODE (SET_SRC (x)) == SUBREG
- && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG))
- && GET_MODE (var) == promoted_mode
- && x == single_set (insn))
- {
- rtx pat;
-
- if (GET_CODE (SET_DEST (x)) == SUBREG)
- SET_DEST (x) = fixup_memory_subreg (SET_DEST (x), insn, 0);
- else
- SET_DEST (x) = fixup_stack_1 (SET_DEST (x), insn);
-
- if (recog_memoized (insn) >= 0)
- return;
-
- pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
- if (GET_CODE (pat) == SEQUENCE)
- {
- emit_insn_after (pat, insn);
- PUT_CODE (insn, NOTE);
- NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (insn) = 0;
- }
- else
- PATTERN (insn) = pat;
-
- return;
- }
-
- /* Otherwise, storing into VAR must be handled specially
- by storing into a temporary and copying that into VAR
- with a new insn after this one. Note that this case
- will be used when storing into a promoted scalar since
- the insn will now have different modes on the input
- and output and hence will be invalid (except for the case
- of setting it to a constant, which does not need any
- change if it is valid). We generate extra code in that case,
- but combine.c will eliminate it. */
-
- if (dest == var)
- {
- rtx temp;
- rtx fixeddest = SET_DEST (x);
-
- /* STRICT_LOW_PART can be discarded, around a MEM. */
- if (GET_CODE (fixeddest) == STRICT_LOW_PART)
- fixeddest = XEXP (fixeddest, 0);
- /* Convert (SUBREG (MEM)) to a MEM in a changed mode. */
- if (GET_CODE (fixeddest) == SUBREG)
- {
- fixeddest = fixup_memory_subreg (fixeddest, insn, 0);
- promoted_mode = GET_MODE (fixeddest);
- }
- else
- fixeddest = fixup_stack_1 (fixeddest, insn);
-
- temp = gen_reg_rtx (promoted_mode);
-
- emit_insn_after (gen_move_insn (fixeddest,
- gen_lowpart (GET_MODE (fixeddest),
- temp)),
- insn);
-
- SET_DEST (x) = temp;
- }
- }
-
- default:
- break;
- }
-
- /* Nothing special about this RTX; fix its operands. */
-
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e')
- fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements);
- if (fmt[i] == 'E')
- {
- register int j;
- for (j = 0; j < XVECLEN (x, i); j++)
- fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j),
- insn, replacements);
- }
- }
-}
-
-/* Given X, an rtx of the form (SUBREG:m1 (MEM:m2 addr)),
- return an rtx (MEM:m1 newaddr) which is equivalent.
- If any insns must be emitted to compute NEWADDR, put them before INSN.
-
- UNCRITICAL nonzero means accept paradoxical subregs.
- This is used for subregs found inside REG_NOTES. */
-
-static rtx
-fixup_memory_subreg (x, insn, uncritical)
- rtx x;
- rtx insn;
- int uncritical;
-{
- int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
- rtx addr = XEXP (SUBREG_REG (x), 0);
- enum machine_mode mode = GET_MODE (x);
- rtx result;
-
- /* Paradoxical SUBREGs are usually invalid during RTL generation. */
- if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
- && ! uncritical)
- abort ();
-
- if (BYTES_BIG_ENDIAN)
- offset += (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
- - MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)));
- addr = plus_constant (addr, offset);
- if (!flag_force_addr && memory_address_p (mode, addr))
- /* Shortcut if no insns need be emitted. */
- return change_address (SUBREG_REG (x), mode, addr);
- start_sequence ();
- result = change_address (SUBREG_REG (x), mode, addr);
- emit_insn_before (gen_sequence (), insn);
- end_sequence ();
- return result;
-}
-
-/* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X.
- Replace subexpressions of X in place.
- If X itself is a (SUBREG (MEM ...) ...), return the replacement expression.
- Otherwise return X, with its contents possibly altered.
-
- If any insns must be emitted to compute NEWADDR, put them before INSN.
-
- UNCRITICAL is as in fixup_memory_subreg. */
-
-static rtx
-walk_fixup_memory_subreg (x, insn, uncritical)
- register rtx x;
- rtx insn;
- int uncritical;
-{
- register enum rtx_code code;
- register char *fmt;
- register int i;
-
- if (x == 0)
- return 0;
-
- code = GET_CODE (x);
-
- if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
- return fixup_memory_subreg (x, insn, uncritical);
-
- /* Nothing special about this RTX; fix its operands. */
-
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e')
- XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn, uncritical);
- if (fmt[i] == 'E')
- {
- register int j;
- for (j = 0; j < XVECLEN (x, i); j++)
- XVECEXP (x, i, j)
- = walk_fixup_memory_subreg (XVECEXP (x, i, j), insn, uncritical);
- }
- }
- return x;
-}
-
-/* For each memory ref within X, if it refers to a stack slot
- with an out of range displacement, put the address in a temp register
- (emitting new insns before INSN to load these registers)
- and alter the memory ref to use that register.
- Replace each such MEM rtx with a copy, to avoid clobberage. */
-
-static rtx
-fixup_stack_1 (x, insn)
- rtx x;
- rtx insn;
-{
- register int i;
- register RTX_CODE code = GET_CODE (x);
- register char *fmt;
-
- if (code == MEM)
- {
- register rtx ad = XEXP (x, 0);
- /* If we have address of a stack slot but it's not valid
- (displacement is too large), compute the sum in a register. */
- if (GET_CODE (ad) == PLUS
- && GET_CODE (XEXP (ad, 0)) == REG
- && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER
- && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER)
- || REGNO (XEXP (ad, 0)) == FRAME_POINTER_REGNUM
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
- || REGNO (XEXP (ad, 0)) == HARD_FRAME_POINTER_REGNUM
-#endif
- || REGNO (XEXP (ad, 0)) == STACK_POINTER_REGNUM
- || REGNO (XEXP (ad, 0)) == ARG_POINTER_REGNUM
- || XEXP (ad, 0) == current_function_internal_arg_pointer)
- && GET_CODE (XEXP (ad, 1)) == CONST_INT)
- {
- rtx temp, seq;
- if (memory_address_p (GET_MODE (x), ad))
- return x;
-
- start_sequence ();
- temp = copy_to_reg (ad);
- seq = gen_sequence ();
- end_sequence ();
- emit_insn_before (seq, insn);
- return change_address (x, VOIDmode, temp);
- }
- return x;
- }
-
- fmt = GET_RTX_FORMAT (code);
- for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
- {
- if (fmt[i] == 'e')
- XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn);
- if (fmt[i] == 'E')
- {
- register int j;
- for (j = 0; j < XVECLEN (x, i); j++)
- XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn);
- }
- }
- return x;
-}
-
-/* Optimization: a bit-field instruction whose field
- happens to be a byte or halfword in memory
- can be changed to a move instruction.
-
- We call here when INSN is an insn to examine or store into a bit-field.
- BODY is the SET-rtx to be altered.
-
- EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0.
- (Currently this is called only from function.c, and EQUIV_MEM
- is always 0.) */
-
-static void
-optimize_bit_field (body, insn, equiv_mem)
- rtx body;
- rtx insn;
- rtx *equiv_mem;
-{
- register rtx bitfield;
- int destflag;
- rtx seq = 0;
- enum machine_mode mode;
-
- if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT
- || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT)
- bitfield = SET_DEST (body), destflag = 1;
- else
- bitfield = SET_SRC (body), destflag = 0;
-
- /* First check that the field being stored has constant size and position
- and is in fact a byte or halfword suitably aligned. */
-
- if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT
- && GET_CODE (XEXP (bitfield, 2)) == CONST_INT
- && ((mode = mode_for_size (INTVAL (XEXP (bitfield, 1)), MODE_INT, 1))
- != BLKmode)
- && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0)
- {
- register rtx memref = 0;
-
- /* Now check that the containing word is memory, not a register,
- and that it is safe to change the machine mode. */
-
- if (GET_CODE (XEXP (bitfield, 0)) == MEM)
- memref = XEXP (bitfield, 0);
- else if (GET_CODE (XEXP (bitfield, 0)) == REG
- && equiv_mem != 0)
- memref = equiv_mem[REGNO (XEXP (bitfield, 0))];
- else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
- && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM)
- memref = SUBREG_REG (XEXP (bitfield, 0));
- else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
- && equiv_mem != 0
- && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG)
- memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))];
-
- if (memref
- && ! mode_dependent_address_p (XEXP (memref, 0))
- && ! MEM_VOLATILE_P (memref))
- {
- /* Now adjust the address, first for any subreg'ing
- that we are now getting rid of,
- and then for which byte of the word is wanted. */
-
- HOST_WIDE_INT offset = INTVAL (XEXP (bitfield, 2));
- rtx insns;
-
- /* Adjust OFFSET to count bits from low-address byte. */
- if (BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN)
- offset = (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield, 0)))
- - offset - INTVAL (XEXP (bitfield, 1)));
-
- /* Adjust OFFSET to count bytes from low-address byte. */
- offset /= BITS_PER_UNIT;
- if (GET_CODE (XEXP (bitfield, 0)) == SUBREG)
- {
- offset += SUBREG_WORD (XEXP (bitfield, 0)) * UNITS_PER_WORD;
- if (BYTES_BIG_ENDIAN)
- offset -= (MIN (UNITS_PER_WORD,
- GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0))))
- - MIN (UNITS_PER_WORD,
- GET_MODE_SIZE (GET_MODE (memref))));
- }
-
- start_sequence ();
- memref = change_address (memref, mode,
- plus_constant (XEXP (memref, 0), offset));
- insns = get_insns ();
- end_sequence ();
- emit_insns_before (insns, insn);
-
- /* Store this memory reference where
- we found the bit field reference. */
-
- if (destflag)
- {
- validate_change (insn, &SET_DEST (body), memref, 1);
- if (! CONSTANT_ADDRESS_P (SET_SRC (body)))
- {
- rtx src = SET_SRC (body);
- while (GET_CODE (src) == SUBREG
- && SUBREG_WORD (src) == 0)
- src = SUBREG_REG (src);
- if (GET_MODE (src) != GET_MODE (memref))
- src = gen_lowpart (GET_MODE (memref), SET_SRC (body));
- validate_change (insn, &SET_SRC (body), src, 1);
- }
- else if (GET_MODE (SET_SRC (body)) != VOIDmode
- && GET_MODE (SET_SRC (body)) != GET_MODE (memref))
- /* This shouldn't happen because anything that didn't have
- one of these modes should have got converted explicitly
- and then referenced through a subreg.
- This is so because the original bit-field was
- handled by agg_mode and so its tree structure had
- the same mode that memref now has. */
- abort ();
- }
- else
- {
- rtx dest = SET_DEST (body);
-
- while (GET_CODE (dest) == SUBREG
- && SUBREG_WORD (dest) == 0
- && (GET_MODE_CLASS (GET_MODE (dest))
- == GET_MODE_CLASS (GET_MODE (SUBREG_REG (dest)))))
- dest = SUBREG_REG (dest);
-
- validate_change (insn, &SET_DEST (body), dest, 1);
-
- if (GET_MODE (dest) == GET_MODE (memref))
- validate_change (insn, &SET_SRC (body), memref, 1);
- else
- {
- /* Convert the mem ref to the destination mode. */
- rtx newreg = gen_reg_rtx (GET_MODE (dest));
-
- start_sequence ();
- convert_move (newreg, memref,
- GET_CODE (SET_SRC (body)) == ZERO_EXTRACT);
- seq = get_insns ();
- end_sequence ();
-
- validate_change (insn, &SET_SRC (body), newreg, 1);
- }
- }
-
- /* See if we can convert this extraction or insertion into
- a simple move insn. We might not be able to do so if this
- was, for example, part of a PARALLEL.
-
- If we succeed, write out any needed conversions. If we fail,
- it is hard to guess why we failed, so don't do anything
- special; just let the optimization be suppressed. */
-
- if (apply_change_group () && seq)
- emit_insns_before (seq, insn);
- }
- }
-}
-
-/* These routines are responsible for converting virtual register references
- to the actual hard register references once RTL generation is complete.
-
- The following four variables are used for communication between the
- routines. They contain the offsets of the virtual registers from their
- respective hard registers. */
-
-static int in_arg_offset;
-static int var_offset;
-static int dynamic_offset;
-static int out_arg_offset;
-static int cfa_offset;
-
-/* In most machines, the stack pointer register is equivalent to the bottom
- of the stack. */
-
-#ifndef STACK_POINTER_OFFSET
-#define STACK_POINTER_OFFSET 0
-#endif
-
-/* If not defined, pick an appropriate default for the offset of dynamically
- allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
- REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
-
-#ifndef STACK_DYNAMIC_OFFSET
-
-#ifdef ACCUMULATE_OUTGOING_ARGS
-/* The bottom of the stack points to the actual arguments. If
- REG_PARM_STACK_SPACE is defined, this includes the space for the register
- parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
- stack space for register parameters is not pushed by the caller, but
- rather part of the fixed stack areas and hence not included in
- `current_function_outgoing_args_size'. Nevertheless, we must allow
- for it when allocating stack dynamic objects. */
-
-#if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
-#define STACK_DYNAMIC_OFFSET(FNDECL) \
-(current_function_outgoing_args_size \
- + REG_PARM_STACK_SPACE (FNDECL) + (STACK_POINTER_OFFSET))
-
-#else
-#define STACK_DYNAMIC_OFFSET(FNDECL) \
-(current_function_outgoing_args_size + (STACK_POINTER_OFFSET))
-#endif
-
-#else
-#define STACK_DYNAMIC_OFFSET(FNDECL) STACK_POINTER_OFFSET
-#endif
-#endif
-
-/* On a few machines, the CFA coincides with the arg pointer. */
-
-#ifndef ARG_POINTER_CFA_OFFSET
-#define ARG_POINTER_CFA_OFFSET 0
-#endif
-
-
-/* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had
- its address taken. DECL is the decl for the object stored in the
- register, for later use if we do need to force REG into the stack.
- REG is overwritten by the MEM like in put_reg_into_stack. */
-
-rtx
-gen_mem_addressof (reg, decl)
- rtx reg;
- tree decl;
-{
- tree type = TREE_TYPE (decl);
- rtx r = gen_rtx_ADDRESSOF (Pmode, gen_reg_rtx (GET_MODE (reg)), REGNO (reg));
- SET_ADDRESSOF_DECL (r, decl);
- /* If the original REG was a user-variable, then so is the REG whose
- address is being taken. */
- REG_USERVAR_P (XEXP (r, 0)) = REG_USERVAR_P (reg);
-
- XEXP (reg, 0) = r;
- PUT_CODE (reg, MEM);
- PUT_MODE (reg, DECL_MODE (decl));
- MEM_VOLATILE_P (reg) = TREE_SIDE_EFFECTS (decl);
- MEM_SET_IN_STRUCT_P (reg, AGGREGATE_TYPE_P (type));
- MEM_ALIAS_SET (reg) = get_alias_set (decl);
-
- if (TREE_USED (decl) || DECL_INITIAL (decl) != 0)
- fixup_var_refs (reg, GET_MODE (reg), TREE_UNSIGNED (type));
-
- return reg;
-}
-
-/* If DECL has an RTL that is an ADDRESSOF rtx, put it into the stack. */
-
-void
-flush_addressof (decl)
- tree decl;
-{
- if ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL)
- && DECL_RTL (decl) != 0
- && GET_CODE (DECL_RTL (decl)) == MEM
- && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF
- && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == REG)
- put_addressof_into_stack (XEXP (DECL_RTL (decl), 0));
-}
-
-/* Force the register pointed to by R, an ADDRESSOF rtx, into the stack. */
-
-static void
-put_addressof_into_stack (r)
- rtx r;
-{
- tree decl = ADDRESSOF_DECL (r);
- rtx reg = XEXP (r, 0);
-
- if (GET_CODE (reg) != REG)
- abort ();
-
- put_reg_into_stack (0, reg, TREE_TYPE (decl), GET_MODE (reg),
- DECL_MODE (decl), TREE_SIDE_EFFECTS (decl),
- ADDRESSOF_REGNO (r),
- TREE_USED (decl) || DECL_INITIAL (decl) != 0);
-}
-
-/* List of replacements made below in purge_addressof_1 when creating
- bitfield insertions. */
-static rtx purge_addressof_replacements;
-
-/* Helper function for purge_addressof. See if the rtx expression at *LOC
- in INSN needs to be changed. If FORCE, always put any ADDRESSOFs into
- the stack. */
-
-static void
-purge_addressof_1 (loc, insn, force, store)
- rtx *loc;
- rtx insn;
- int force, store;
-{
- rtx x;
- RTX_CODE code;
- int i, j;
- char *fmt;
-
- /* Re-start here to avoid recursion in common cases. */
- restart:
-
- x = *loc;
- if (x == 0)
- return;
-
- code = GET_CODE (x);
-
- if (code == ADDRESSOF && GET_CODE (XEXP (x, 0)) == MEM)
- {
- rtx insns;
- /* We must create a copy of the rtx because it was created by
- overwriting a REG rtx which is always shared. */
- rtx sub = copy_rtx (XEXP (XEXP (x, 0), 0));
-
- if (validate_change (insn, loc, sub, 0))
- return;
-
- start_sequence ();
- if (! validate_change (insn, loc,
- force_operand (sub, NULL_RTX),
- 0))
- abort ();
-
- insns = gen_sequence ();
- end_sequence ();
- emit_insn_before (insns, insn);
- return;
- }
- else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force)
- {
- rtx sub = XEXP (XEXP (x, 0), 0);
-
- if (GET_CODE (sub) == MEM)
- sub = gen_rtx_MEM (GET_MODE (x), copy_rtx (XEXP (sub, 0)));
-
- if (GET_CODE (sub) == REG
- && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
- {
- put_addressof_into_stack (XEXP (x, 0));
- return;
- }
- else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
- {
- int size_x, size_sub;
-
- if (!insn)
- {
- /* When processing REG_NOTES look at the list of
- replacements done on the insn to find the register that X
- was replaced by. */
- rtx tem;
-
- for (tem = purge_addressof_replacements; tem != NULL_RTX;
- tem = XEXP (XEXP (tem, 1), 1))
- {
- rtx y = XEXP (tem, 0);
- if (GET_CODE (y) == MEM
- && rtx_equal_p (XEXP (x, 0), XEXP (y, 0)))
- {
- /* It can happen that the note may speak of things in
- a wider (or just different) mode than the code did.
- This is especially true of REG_RETVAL. */
-
- rtx z = XEXP (XEXP (tem, 1), 0);
- if (GET_MODE (x) != GET_MODE (y))
- {
- if (GET_CODE (z) == SUBREG && SUBREG_WORD (z) == 0)
- z = SUBREG_REG (z);
-
- /* ??? If we'd gotten into any of the really complex
- cases below, I'm not sure we can do a proper
- replacement. Might we be able to delete the
- note in some cases? */
- if (GET_MODE_SIZE (GET_MODE (x))
- < GET_MODE_SIZE (GET_MODE (y)))
- abort ();
-
- if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
- && (GET_MODE_SIZE (GET_MODE (x))
- > GET_MODE_SIZE (GET_MODE (z))))
- {
- /* This can occur as a result in invalid
- pointer casts, e.g. float f; ...
- *(long long int *)&f.
- ??? We could emit a warning here, but
- without a line number that wouldn't be
- very helpful. */
- z = gen_rtx_SUBREG (GET_MODE (x), z, 0);
- }
- else
- z = gen_lowpart (GET_MODE (x), z);
- }
-
- *loc = z;
- return;
- }
- }
-
- /* There should always be such a replacement. */
- abort ();
- }
-
- size_x = GET_MODE_BITSIZE (GET_MODE (x));
- size_sub = GET_MODE_BITSIZE (GET_MODE (sub));
-
- /* Don't even consider working with paradoxical subregs,
- or the moral equivalent seen here. */
- if (size_x <= size_sub
- && int_mode_for_mode (GET_MODE (sub)) != BLKmode)
- {
- /* Do a bitfield insertion to mirror what would happen
- in memory. */
-
- rtx val, seq;
-
- if (store)
- {
- rtx p;
-
- start_sequence ();
- val = gen_reg_rtx (GET_MODE (x));
- if (! validate_change (insn, loc, val, 0))
- {
- /* Discard the current sequence and put the
- ADDRESSOF on stack. */
- end_sequence ();
- goto give_up;
- }
- seq = gen_sequence ();
- end_sequence ();
- emit_insn_before (seq, insn);
-
- start_sequence ();
- store_bit_field (sub, size_x, 0, GET_MODE (x),
- val, GET_MODE_SIZE (GET_MODE (sub)),
- GET_MODE_SIZE (GET_MODE (sub)));
-
- /* Make sure to unshare any shared rtl that store_bit_field
- might have created. */
- for (p = get_insns(); p; p = NEXT_INSN (p))
- {
- reset_used_flags (PATTERN (p));
- reset_used_flags (REG_NOTES (p));
- reset_used_flags (LOG_LINKS (p));
- }
- unshare_all_rtl (get_insns ());
-
- seq = gen_sequence ();
- end_sequence ();
- emit_insn_after (seq, insn);
- }
- else
- {
- start_sequence ();
- val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX,
- GET_MODE (x), GET_MODE (x),
- GET_MODE_SIZE (GET_MODE (sub)),
- GET_MODE_SIZE (GET_MODE (sub)));
-
- if (! validate_change (insn, loc, val, 0))
- {
- /* Discard the current sequence and put the
- ADDRESSOF on stack. */
- end_sequence ();
- goto give_up;
- }
-
- seq = gen_sequence ();
- end_sequence ();
- emit_insn_before (seq, insn);
- }
-
- /* Remember the replacement so that the same one can be done
- on the REG_NOTES. */
- purge_addressof_replacements
- = gen_rtx_EXPR_LIST (VOIDmode, x,
- gen_rtx_EXPR_LIST (VOIDmode, val,
- purge_addressof_replacements));
-
- /* We replaced with a reg -- all done. */
- return;
- }
- }
- else if (validate_change (insn, loc, sub, 0))
- {
- /* Remember the replacement so that the same one can be done
- on the REG_NOTES. */
- purge_addressof_replacements
- = gen_rtx_EXPR_LIST (VOIDmode, x,
- gen_rtx_EXPR_LIST (VOIDmode, sub,
- purge_addressof_replacements));
- goto restart;
- }
- give_up:;
- /* else give up and put it into the stack */
- }
- else if (code == ADDRESSOF)
- {
- put_addressof_into_stack (x);
- return;
- }
- else if (code == SET)
- {
- purge_addressof_1 (&SET_DEST (x), insn, force, 1);
- purge_addressof_1 (&SET_SRC (x), insn, force, 0);
- return;
- }
- else if (code == CALL)
- {
- purge_addressof_1 (&XEXP (x, 0), insn, 1, 0);
- purge_addressof_1 (&XEXP (x, 1), insn, force, 0);
- return;
- }
-
- /* Scan all subexpressions. */
- fmt = GET_RTX_FORMAT (code);
- for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
- {
- if (*fmt == 'e')
- purge_addressof_1 (&XEXP (x, i), insn, force, 0);
- else if (*fmt == 'E')
- for (j = 0; j < XVECLEN (x, i); j++)
- purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0);
- }
-}
-
-/* Eliminate all occurrences of ADDRESSOF from INSNS. Elide any remaining
- (MEM (ADDRESSOF)) patterns, and force any needed registers into the
- stack. */
-
-void
-purge_addressof (insns)
- rtx insns;
-{
- rtx insn;
- for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
- || GET_CODE (insn) == CALL_INSN)
- {
- purge_addressof_1 (&PATTERN (insn), insn,
- asm_noperands (PATTERN (insn)) > 0, 0);
- purge_addressof_1 (®_NOTES (insn), NULL_RTX, 0, 0);
- }
- purge_addressof_replacements = 0;
-}
-
-/* Pass through the INSNS of function FNDECL and convert virtual register
- references to hard register references. */
-
-void
-instantiate_virtual_regs (fndecl, insns)
- tree fndecl;
- rtx insns;
-{
- rtx insn;
- int i;
-
- /* Compute the offsets to use for this function. */
- in_arg_offset = FIRST_PARM_OFFSET (fndecl);
- var_offset = STARTING_FRAME_OFFSET;
- dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl);
- out_arg_offset = STACK_POINTER_OFFSET;
- cfa_offset = ARG_POINTER_CFA_OFFSET;
-
- /* Scan all variables and parameters of this function. For each that is
- in memory, instantiate all virtual registers if the result is a valid
- address. If not, we do it later. That will handle most uses of virtual
- regs on many machines. */
- instantiate_decls (fndecl, 1);
-
- /* Initialize recognition, indicating that volatile is OK. */
- init_recog ();
-
- /* Scan through all the insns, instantiating every virtual register still
- present. */
- for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
- || GET_CODE (insn) == CALL_INSN)
- {
- instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
- instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0);
- }
-
- /* Instantiate the stack slots for the parm registers, for later use in
- addressof elimination. */
- for (i = 0; i < max_parm_reg; ++i)
- if (parm_reg_stack_loc[i])
- instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0);
-
- /* Now instantiate the remaining register equivalences for debugging info.
- These will not be valid addresses. */
- instantiate_decls (fndecl, 0);
-
- /* Indicate that, from now on, assign_stack_local should use
- frame_pointer_rtx. */
- virtuals_instantiated = 1;
-}
-
-/* Scan all decls in FNDECL (both variables and parameters) and instantiate
- all virtual registers in their DECL_RTL's.
-
- If VALID_ONLY, do this only if the resulting address is still valid.
- Otherwise, always do it. */
-
-static void
-instantiate_decls (fndecl, valid_only)
- tree fndecl;
- int valid_only;
-{
- tree decl;
-
- if (DECL_SAVED_INSNS (fndecl))
- /* When compiling an inline function, the obstack used for
- rtl allocation is the maybepermanent_obstack. Calling
- `resume_temporary_allocation' switches us back to that
- obstack while we process this function's parameters. */
- resume_temporary_allocation ();
-
- /* Process all parameters of the function. */
- for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
- {
- HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
-
- instantiate_decl (DECL_RTL (decl), size, valid_only);
-
- /* If the parameter was promoted, then the incoming RTL mode may be
- larger than the declared type size. We must use the larger of
- the two sizes. */
- size = MAX (GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl))), size);
- instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only);
- }
-
- /* Now process all variables defined in the function or its subblocks. */
- instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
-
- if (DECL_INLINE (fndecl) || DECL_DEFER_OUTPUT (fndecl))
- {
- /* Save all rtl allocated for this function by raising the
- high-water mark on the maybepermanent_obstack. */
- preserve_data ();
- /* All further rtl allocation is now done in the current_obstack. */
- rtl_in_current_obstack ();
- }
-}
-
-/* Subroutine of instantiate_decls: Process all decls in the given
- BLOCK node and all its subblocks. */
-
-static void
-instantiate_decls_1 (let, valid_only)
- tree let;
- int valid_only;
-{
- tree t;
-
- for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
- instantiate_decl (DECL_RTL (t), int_size_in_bytes (TREE_TYPE (t)),
- valid_only);
-
- /* Process all subblocks. */
- for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
- instantiate_decls_1 (t, valid_only);
-}
-
-/* Subroutine of the preceding procedures: Given RTL representing a
- decl and the size of the object, do any instantiation required.
-
- If VALID_ONLY is non-zero, it means that the RTL should only be
- changed if the new address is valid. */
-
-static void
-instantiate_decl (x, size, valid_only)
- rtx x;
- int size;
- int valid_only;
-{
- enum machine_mode mode;
- rtx addr;
-
- /* If this is not a MEM, no need to do anything. Similarly if the
- address is a constant or a register that is not a virtual register. */
-
- if (x == 0 || GET_CODE (x) != MEM)
- return;
-
- addr = XEXP (x, 0);
- if (CONSTANT_P (addr)
- || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG)
- || (GET_CODE (addr) == REG
- && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
- || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
- return;
-
- /* If we should only do this if the address is valid, copy the address.
- We need to do this so we can undo any changes that might make the
- address invalid. This copy is unfortunate, but probably can't be
- avoided. */
-
- if (valid_only)
- addr = copy_rtx (addr);
-
- instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
-
- if (valid_only)
- {
- /* Now verify that the resulting address is valid for every integer or
- floating-point mode up to and including SIZE bytes long. We do this
- since the object might be accessed in any mode and frame addresses
- are shared. */
-
- for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
- mode != VOIDmode && GET_MODE_SIZE (mode) <= size;
- mode = GET_MODE_WIDER_MODE (mode))
- if (! memory_address_p (mode, addr))
- return;
-
- for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
- mode != VOIDmode && GET_MODE_SIZE (mode) <= size;
- mode = GET_MODE_WIDER_MODE (mode))
- if (! memory_address_p (mode, addr))
- return;
- }
-
- /* Put back the address now that we have updated it and we either know
- it is valid or we don't care whether it is valid. */
-
- XEXP (x, 0) = addr;
-}
-
-/* Given a pointer to a piece of rtx and an optional pointer to the
- containing object, instantiate any virtual registers present in it.
-
- If EXTRA_INSNS, we always do the replacement and generate
- any extra insns before OBJECT. If it zero, we do nothing if replacement
- is not valid.
-
- Return 1 if we either had nothing to do or if we were able to do the
- needed replacement. Return 0 otherwise; we only return zero if
- EXTRA_INSNS is zero.
-
- We first try some simple transformations to avoid the creation of extra
- pseudos. */
-
-static int
-instantiate_virtual_regs_1 (loc, object, extra_insns)
- rtx *loc;
- rtx object;
- int extra_insns;
-{
- rtx x;
- RTX_CODE code;
- rtx new = 0;
- HOST_WIDE_INT offset;
- rtx temp;
- rtx seq;
- int i, j;
- char *fmt;
-
- /* Re-start here to avoid recursion in common cases. */
- restart:
-
- x = *loc;
- if (x == 0)
- return 1;
-
- code = GET_CODE (x);
-
- /* Check for some special cases. */
- switch (code)
- {
- case CONST_INT:
- case CONST_DOUBLE:
- case CONST:
- case SYMBOL_REF:
- case CODE_LABEL:
- case PC:
- case CC0:
- case ASM_INPUT:
- case ADDR_VEC:
- case ADDR_DIFF_VEC:
- case RETURN:
- return 1;
-
- case SET:
- /* We are allowed to set the virtual registers. This means that
- the actual register should receive the source minus the
- appropriate offset. This is used, for example, in the handling
- of non-local gotos. */
- if (SET_DEST (x) == virtual_incoming_args_rtx)
- new = arg_pointer_rtx, offset = - in_arg_offset;
- else if (SET_DEST (x) == virtual_stack_vars_rtx)
- new = frame_pointer_rtx, offset = - var_offset;
- else if (SET_DEST (x) == virtual_stack_dynamic_rtx)
- new = stack_pointer_rtx, offset = - dynamic_offset;
- else if (SET_DEST (x) == virtual_outgoing_args_rtx)
- new = stack_pointer_rtx, offset = - out_arg_offset;
- else if (SET_DEST (x) == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = - cfa_offset;
-
- if (new)
- {
- /* The only valid sources here are PLUS or REG. Just do
- the simplest possible thing to handle them. */
- if (GET_CODE (SET_SRC (x)) != REG
- && GET_CODE (SET_SRC (x)) != PLUS)
- abort ();
-
- start_sequence ();
- if (GET_CODE (SET_SRC (x)) != REG)
- temp = force_operand (SET_SRC (x), NULL_RTX);
- else
- temp = SET_SRC (x);
- temp = force_operand (plus_constant (temp, offset), NULL_RTX);
- seq = get_insns ();
- end_sequence ();
-
- emit_insns_before (seq, object);
- SET_DEST (x) = new;
-
- if (! validate_change (object, &SET_SRC (x), temp, 0)
- || ! extra_insns)
- abort ();
-
- return 1;
- }
-
- instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
- loc = &SET_SRC (x);
- goto restart;
-
- case PLUS:
- /* Handle special case of virtual register plus constant. */
- if (CONSTANT_P (XEXP (x, 1)))
- {
- rtx old, new_offset;
-
- /* Check for (plus (plus VIRT foo) (const_int)) first. */
- if (GET_CODE (XEXP (x, 0)) == PLUS)
- {
- rtx inner = XEXP (XEXP (x, 0), 0);
-
- if (inner == virtual_incoming_args_rtx)
- new = arg_pointer_rtx, offset = in_arg_offset;
- else if (inner == virtual_stack_vars_rtx)
- new = frame_pointer_rtx, offset = var_offset;
- else if (inner == virtual_stack_dynamic_rtx)
- new = stack_pointer_rtx, offset = dynamic_offset;
- else if (inner == virtual_outgoing_args_rtx)
- new = stack_pointer_rtx, offset = out_arg_offset;
- else if (inner == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
- else
- {
- loc = &XEXP (x, 0);
- goto restart;
- }
-
- instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
- extra_insns);
- new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1));
- }
-
- else if (XEXP (x, 0) == virtual_incoming_args_rtx)
- new = arg_pointer_rtx, offset = in_arg_offset;
- else if (XEXP (x, 0) == virtual_stack_vars_rtx)
- new = frame_pointer_rtx, offset = var_offset;
- else if (XEXP (x, 0) == virtual_stack_dynamic_rtx)
- new = stack_pointer_rtx, offset = dynamic_offset;
- else if (XEXP (x, 0) == virtual_outgoing_args_rtx)
- new = stack_pointer_rtx, offset = out_arg_offset;
- else if (XEXP (x, 0) == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
- else
- {
- /* We know the second operand is a constant. Unless the
- first operand is a REG (which has been already checked),
- it needs to be checked. */
- if (GET_CODE (XEXP (x, 0)) != REG)
- {
- loc = &XEXP (x, 0);
- goto restart;
- }
- return 1;
- }
-
- new_offset = plus_constant (XEXP (x, 1), offset);
-
- /* If the new constant is zero, try to replace the sum with just
- the register. */
- if (new_offset == const0_rtx
- && validate_change (object, loc, new, 0))
- return 1;
-
- /* Next try to replace the register and new offset.
- There are two changes to validate here and we can't assume that
- in the case of old offset equals new just changing the register
- will yield a valid insn. In the interests of a little efficiency,
- however, we only call validate change once (we don't queue up the
- changes and then call apply_change_group). */
-
- old = XEXP (x, 0);
- if (offset == 0
- ? ! validate_change (object, &XEXP (x, 0), new, 0)
- : (XEXP (x, 0) = new,
- ! validate_change (object, &XEXP (x, 1), new_offset, 0)))
- {
- if (! extra_insns)
- {
- XEXP (x, 0) = old;
- return 0;
- }
-
- /* Otherwise copy the new constant into a register and replace
- constant with that register. */
- temp = gen_reg_rtx (Pmode);
- XEXP (x, 0) = new;
- if (validate_change (object, &XEXP (x, 1), temp, 0))
- emit_insn_before (gen_move_insn (temp, new_offset), object);
- else
- {
- /* If that didn't work, replace this expression with a
- register containing the sum. */
-
- XEXP (x, 0) = old;
- new = gen_rtx_PLUS (Pmode, new, new_offset);
-
- start_sequence ();
- temp = force_operand (new, NULL_RTX);
- seq = get_insns ();
- end_sequence ();
-
- emit_insns_before (seq, object);
- if (! validate_change (object, loc, temp, 0)
- && ! validate_replace_rtx (x, temp, object))
- abort ();
- }
- }
-
- return 1;
- }
-
- /* Fall through to generic two-operand expression case. */
- case EXPR_LIST:
- case CALL:
- case COMPARE:
- case MINUS:
- case MULT:
- case DIV: case UDIV:
- case MOD: case UMOD:
- case AND: case IOR: case XOR:
- case ROTATERT: case ROTATE:
- case ASHIFTRT: case LSHIFTRT: case ASHIFT:
- case NE: case EQ:
- case GE: case GT: case GEU: case GTU:
- case LE: case LT: case LEU: case LTU:
- if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
- instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
- loc = &XEXP (x, 0);
- goto restart;
-
- case MEM:
- /* Most cases of MEM that convert to valid addresses have already been
- handled by our scan of decls. The only special handling we
- need here is to make a copy of the rtx to ensure it isn't being
- shared if we have to change it to a pseudo.
-
- If the rtx is a simple reference to an address via a virtual register,
- it can potentially be shared. In such cases, first try to make it
- a valid address, which can also be shared. Otherwise, copy it and
- proceed normally.
-
- First check for common cases that need no processing. These are
- usually due to instantiation already being done on a previous instance
- of a shared rtx. */
-
- temp = XEXP (x, 0);
- if (CONSTANT_ADDRESS_P (temp)
-#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
- || temp == arg_pointer_rtx
-#endif
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
- || temp == hard_frame_pointer_rtx
-#endif
- || temp == frame_pointer_rtx)
- return 1;
-
- if (GET_CODE (temp) == PLUS
- && CONSTANT_ADDRESS_P (XEXP (temp, 1))
- && (XEXP (temp, 0) == frame_pointer_rtx
-#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
- || XEXP (temp, 0) == hard_frame_pointer_rtx
-#endif
-#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
- || XEXP (temp, 0) == arg_pointer_rtx
-#endif
- ))
- return 1;
-
- if (temp == virtual_stack_vars_rtx
- || temp == virtual_incoming_args_rtx
- || (GET_CODE (temp) == PLUS
- && CONSTANT_ADDRESS_P (XEXP (temp, 1))
- && (XEXP (temp, 0) == virtual_stack_vars_rtx
- || XEXP (temp, 0) == virtual_incoming_args_rtx)))
- {
- /* This MEM may be shared. If the substitution can be done without
- the need to generate new pseudos, we want to do it in place
- so all copies of the shared rtx benefit. The call below will
- only make substitutions if the resulting address is still
- valid.
-
- Note that we cannot pass X as the object in the recursive call
- since the insn being processed may not allow all valid
- addresses. However, if we were not passed on object, we can
- only modify X without copying it if X will have a valid
- address.
-
- ??? Also note that this can still lose if OBJECT is an insn that
- has less restrictions on an address that some other insn.
- In that case, we will modify the shared address. This case
- doesn't seem very likely, though. One case where this could
- happen is in the case of a USE or CLOBBER reference, but we
- take care of that below. */
-
- if (instantiate_virtual_regs_1 (&XEXP (x, 0),
- object ? object : x, 0))
- return 1;
-
- /* Otherwise make a copy and process that copy. We copy the entire
- RTL expression since it might be a PLUS which could also be
- shared. */
- *loc = x = copy_rtx (x);
- }
-
- /* Fall through to generic unary operation case. */
- case SUBREG:
- case STRICT_LOW_PART:
- case NEG: case NOT:
- case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC:
- case SIGN_EXTEND: case ZERO_EXTEND:
- case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE:
- case FLOAT: case FIX:
- case UNSIGNED_FIX: case UNSIGNED_FLOAT:
- case ABS:
- case SQRT:
- case FFS:
- /* These case either have just one operand or we know that we need not
- check the rest of the operands. */
- loc = &XEXP (x, 0);
- goto restart;
-
- case USE:
- case CLOBBER:
- /* If the operand is a MEM, see if the change is a valid MEM. If not,
- go ahead and make the invalid one, but do it to a copy. For a REG,
- just make the recursive call, since there's no chance of a problem. */
-
- if ((GET_CODE (XEXP (x, 0)) == MEM
- && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0),
- 0))
- || (GET_CODE (XEXP (x, 0)) == REG
- && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0)))
- return 1;
-
- XEXP (x, 0) = copy_rtx (XEXP (x, 0));
- loc = &XEXP (x, 0);
- goto restart;
-
- case REG:
- /* Try to replace with a PLUS. If that doesn't work, compute the sum
- in front of this insn and substitute the temporary. */
- if (x == virtual_incoming_args_rtx)
- new = arg_pointer_rtx, offset = in_arg_offset;
- else if (x == virtual_stack_vars_rtx)
- new = frame_pointer_rtx, offset = var_offset;
- else if (x == virtual_stack_dynamic_rtx)
- new = stack_pointer_rtx, offset = dynamic_offset;
- else if (x == virtual_outgoing_args_rtx)
- new = stack_pointer_rtx, offset = out_arg_offset;
- else if (x == virtual_cfa_rtx)
- new = arg_pointer_rtx, offset = cfa_offset;
-
- if (new)
- {
- temp = plus_constant (new, offset);
- if (!validate_change (object, loc, temp, 0))
- {
- if (! extra_insns)
- return 0;
-
- start_sequence ();
- temp = force_operand (temp, NULL_RTX);
- seq = get_insns ();
- end_sequence ();
-
- emit_insns_before (seq, object);
- if (! validate_change (object, loc, temp, 0)
- && ! validate_replace_rtx (x, temp, object))
- abort ();
- }
- }
-
- return 1;
-
- case ADDRESSOF:
- if (GET_CODE (XEXP (x, 0)) == REG)
- return 1;
-
- else if (GET_CODE (XEXP (x, 0)) == MEM)
- {
- /* If we have a (addressof (mem ..)), do any instantiation inside
- since we know we'll be making the inside valid when we finally
- remove the ADDRESSOF. */
- instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0);
- return 1;
- }
- break;
-
- default:
- break;
- }
-
- /* Scan all subexpressions. */
- fmt = GET_RTX_FORMAT (code);
- for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
- if (*fmt == 'e')
- {
- if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
- return 0;
- }
- else if (*fmt == 'E')
- for (j = 0; j < XVECLEN (x, i); j++)
- if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
- extra_insns))
- return 0;
-
- return 1;
-}
-
-/* Optimization: assuming this function does not receive nonlocal gotos,
- delete the handlers for such, as well as the insns to establish
- and disestablish them. */
-
-static void
-delete_handlers ()
-{
- rtx insn;
- for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- {
- /* Delete the handler by turning off the flag that would
- prevent jump_optimize from deleting it.
- Also permit deletion of the nonlocal labels themselves
- if nothing local refers to them. */
- if (GET_CODE (insn) == CODE_LABEL)
- {
- tree t, last_t;
-
- LABEL_PRESERVE_P (insn) = 0;
-
- /* Remove it from the nonlocal_label list, to avoid confusing
- flow. */
- for (t = nonlocal_labels, last_t = 0; t;
- last_t = t, t = TREE_CHAIN (t))
- if (DECL_RTL (TREE_VALUE (t)) == insn)
- break;
- if (t)
- {
- if (! last_t)
- nonlocal_labels = TREE_CHAIN (nonlocal_labels);
- else
- TREE_CHAIN (last_t) = TREE_CHAIN (t);
- }
- }
- if (GET_CODE (insn) == INSN)
- {
- int can_delete = 0;
- rtx t;
- for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1))
- if (reg_mentioned_p (t, PATTERN (insn)))
- {
- can_delete = 1;
- break;
- }
- if (can_delete
- || (nonlocal_goto_stack_level != 0
- && reg_mentioned_p (nonlocal_goto_stack_level,
- PATTERN (insn))))
- delete_insn (insn);
- }
- }
-}
-
-/* Return a list (chain of EXPR_LIST nodes) for the nonlocal labels
- of the current function. */
-
-rtx
-nonlocal_label_rtx_list ()
-{
- tree t;
- rtx x = 0;
-
- for (t = nonlocal_labels; t; t = TREE_CHAIN (t))
- x = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (TREE_VALUE (t)), x);
-
- return x;
-}
-
-/* Output a USE for any register use in RTL.
- This is used with -noreg to mark the extent of lifespan
- of any registers used in a user-visible variable's DECL_RTL. */
-
-void
-use_variable (rtl)
- rtx rtl;
-{
- if (GET_CODE (rtl) == REG)
- /* This is a register variable. */
- emit_insn (gen_rtx_USE (VOIDmode, rtl));
- else if (GET_CODE (rtl) == MEM
- && GET_CODE (XEXP (rtl, 0)) == REG
- && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER
- || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER)
- && XEXP (rtl, 0) != current_function_internal_arg_pointer)
- /* This is a variable-sized structure. */
- emit_insn (gen_rtx_USE (VOIDmode, XEXP (rtl, 0)));
-}
-
-/* Like use_variable except that it outputs the USEs after INSN
- instead of at the end of the insn-chain. */
-
-void
-use_variable_after (rtl, insn)
- rtx rtl, insn;
-{
- if (GET_CODE (rtl) == REG)
- /* This is a register variable. */
- emit_insn_after (gen_rtx_USE (VOIDmode, rtl), insn);
- else if (GET_CODE (rtl) == MEM
- && GET_CODE (XEXP (rtl, 0)) == REG
- && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER
- || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER)
- && XEXP (rtl, 0) != current_function_internal_arg_pointer)
- /* This is a variable-sized structure. */
- emit_insn_after (gen_rtx_USE (VOIDmode, XEXP (rtl, 0)), insn);
-}
-
-int
-max_parm_reg_num ()
-{
- return max_parm_reg;
-}
-
-/* Return the first insn following those generated by `assign_parms'. */
-
-rtx
-get_first_nonparm_insn ()
-{
- if (last_parm_insn)
- return NEXT_INSN (last_parm_insn);
- return get_insns ();
-}
-
-/* Return the first NOTE_INSN_BLOCK_BEG note in the function.
- Crash if there is none. */
-
-rtx
-get_first_block_beg ()
-{
- register rtx searcher;
- register rtx insn = get_first_nonparm_insn ();
-
- for (searcher = insn; searcher; searcher = NEXT_INSN (searcher))
- if (GET_CODE (searcher) == NOTE
- && NOTE_LINE_NUMBER (searcher) == NOTE_INSN_BLOCK_BEG)
- return searcher;
-
- abort (); /* Invalid call to this function. (See comments above.) */
- return NULL_RTX;
-}
-
-/* Return 1 if EXP is an aggregate type (or a value with aggregate type).
- This means a type for which function calls must pass an address to the
- function or get an address back from the function.
- EXP may be a type node or an expression (whose type is tested). */
-
-int
-aggregate_value_p (exp)
- tree exp;
-{
- int i, regno, nregs;
- rtx reg;
- tree type;
- if (TREE_CODE_CLASS (TREE_CODE (exp)) == 't')
- type = exp;
- else
- type = TREE_TYPE (exp);
-
- if (RETURN_IN_MEMORY (type))
- return 1;
- /* Types that are TREE_ADDRESSABLE must be constructed in memory,
- and thus can't be returned in registers. */
- if (TREE_ADDRESSABLE (type))
- return 1;
- if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type))
- return 1;
- /* Make sure we have suitable call-clobbered regs to return
- the value in; if not, we must return it in memory. */
- reg = hard_function_value (type, 0);
-
- /* If we have something other than a REG (e.g. a PARALLEL), then assume
- it is OK. */
- if (GET_CODE (reg) != REG)
- return 0;
-
- regno = REGNO (reg);
- nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
- for (i = 0; i < nregs; i++)
- if (! call_used_regs[regno + i])
- return 1;
- return 0;
-}
-
-/* Assign RTL expressions to the function's parameters.
- This may involve copying them into registers and using
- those registers as the RTL for them.
-
- If SECOND_TIME is non-zero it means that this function is being
- called a second time. This is done by integrate.c when a function's
- compilation is deferred. We need to come back here in case the
- FUNCTION_ARG macro computes items needed for the rest of the compilation
- (such as changing which registers are fixed or caller-saved). But suppress
- writing any insns or setting DECL_RTL of anything in this case. */
-
-void
-assign_parms (fndecl, second_time)
- tree fndecl;
- int second_time;
-{
- register tree parm;
- register rtx entry_parm = 0;
- register rtx stack_parm = 0;
- CUMULATIVE_ARGS args_so_far;
- enum machine_mode promoted_mode, passed_mode;
- enum machine_mode nominal_mode, promoted_nominal_mode;
- int unsignedp;
- /* Total space needed so far for args on the stack,
- given as a constant and a tree-expression. */
- struct args_size stack_args_size;
- tree fntype = TREE_TYPE (fndecl);
- tree fnargs = DECL_ARGUMENTS (fndecl);
- /* This is used for the arg pointer when referring to stack args. */
- rtx internal_arg_pointer;
- /* This is a dummy PARM_DECL that we used for the function result if
- the function returns a structure. */
- tree function_result_decl = 0;
- int varargs_setup = 0;
- rtx conversion_insns = 0;
-
- /* Nonzero if the last arg is named `__builtin_va_alist',
- which is used on some machines for old-fashioned non-ANSI varargs.h;
- this should be stuck onto the stack as if it had arrived there. */
- int hide_last_arg
- = (current_function_varargs
- && fnargs
- && (parm = tree_last (fnargs)) != 0
- && DECL_NAME (parm)
- && (! strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
- "__builtin_va_alist")));
-
- /* Nonzero if function takes extra anonymous args.
- This means the last named arg must be on the stack
- right before the anonymous ones. */
- int stdarg
- = (TYPE_ARG_TYPES (fntype) != 0
- && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
- != void_type_node));
-
- current_function_stdarg = stdarg;
-
- /* If the reg that the virtual arg pointer will be translated into is
- not a fixed reg or is the stack pointer, make a copy of the virtual
- arg pointer, and address parms via the copy. The frame pointer is
- considered fixed even though it is not marked as such.
-
- The second time through, simply use ap to avoid generating rtx. */
-
- if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
- || ! (fixed_regs[ARG_POINTER_REGNUM]
- || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM))
- && ! second_time)
- internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
- else
- internal_arg_pointer = virtual_incoming_args_rtx;
- current_function_internal_arg_pointer = internal_arg_pointer;
-
- stack_args_size.constant = 0;
- stack_args_size.var = 0;
-
- /* If struct value address is treated as the first argument, make it so. */
- if (aggregate_value_p (DECL_RESULT (fndecl))
- && ! current_function_returns_pcc_struct
- && struct_value_incoming_rtx == 0)
- {
- tree type = build_pointer_type (TREE_TYPE (fntype));
-
- function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
-
- DECL_ARG_TYPE (function_result_decl) = type;
- TREE_CHAIN (function_result_decl) = fnargs;
- fnargs = function_result_decl;
- }
-
- max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
- parm_reg_stack_loc = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
- bzero ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx));
-
-#ifdef INIT_CUMULATIVE_INCOMING_ARGS
- INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
-#else
- INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, 0);
-#endif
-
- /* We haven't yet found an argument that we must push and pretend the
- caller did. */
- current_function_pretend_args_size = 0;
-
- for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
- {
- int aggregate = AGGREGATE_TYPE_P (TREE_TYPE (parm));
- struct args_size stack_offset;
- struct args_size arg_size;
- int passed_pointer = 0;
- int did_conversion = 0;
- tree passed_type = DECL_ARG_TYPE (parm);
- tree nominal_type = TREE_TYPE (parm);
-
- /* Set LAST_NAMED if this is last named arg before some
- anonymous args. */
- int last_named = ((TREE_CHAIN (parm) == 0
- || DECL_NAME (TREE_CHAIN (parm)) == 0)
- && (stdarg || current_function_varargs));
- /* Set NAMED_ARG if this arg should be treated as a named arg. For
- most machines, if this is a varargs/stdarg function, then we treat
- the last named arg as if it were anonymous too. */
- int named_arg = STRICT_ARGUMENT_NAMING ? 1 : ! last_named;
-
- if (TREE_TYPE (parm) == error_mark_node
- /* This can happen after weird syntax errors
- or if an enum type is defined among the parms. */
- || TREE_CODE (parm) != PARM_DECL
- || passed_type == NULL)
- {
- DECL_INCOMING_RTL (parm) = DECL_RTL (parm)
- = gen_rtx_MEM (BLKmode, const0_rtx);
- TREE_USED (parm) = 1;
- continue;
- }
-
- /* For varargs.h function, save info about regs and stack space
- used by the individual args, not including the va_alist arg. */
- if (hide_last_arg && last_named)
- current_function_args_info = args_so_far;
-
- /* Find mode of arg as it is passed, and mode of arg
- as it should be during execution of this function. */
- passed_mode = TYPE_MODE (passed_type);
- nominal_mode = TYPE_MODE (nominal_type);
-
- /* If the parm's mode is VOID, its value doesn't matter,
- and avoid the usual things like emit_move_insn that could crash. */
- if (nominal_mode == VOIDmode)
- {
- DECL_INCOMING_RTL (parm) = DECL_RTL (parm) = const0_rtx;
- continue;
- }
-
- /* If the parm is to be passed as a transparent union, use the
- type of the first field for the tests below. We have already
- verified that the modes are the same. */
- if (DECL_TRANSPARENT_UNION (parm)
- || TYPE_TRANSPARENT_UNION (passed_type))
- passed_type = TREE_TYPE (TYPE_FIELDS (passed_type));
-
- /* See if this arg was passed by invisible reference. It is if
- it is an object whose size depends on the contents of the
- object itself or if the machine requires these objects be passed
- that way. */
-
- if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
- && contains_placeholder_p (TYPE_SIZE (passed_type)))
- || TREE_ADDRESSABLE (passed_type)
-#ifdef FUNCTION_ARG_PASS_BY_REFERENCE
- || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
- passed_type, named_arg)
-#endif
- )
- {
- passed_type = nominal_type = build_pointer_type (passed_type);
- passed_pointer = 1;
- passed_mode = nominal_mode = Pmode;
- }
-
- promoted_mode = passed_mode;
-
-#ifdef PROMOTE_FUNCTION_ARGS
- /* Compute the mode in which the arg is actually extended to. */
- unsignedp = TREE_UNSIGNED (passed_type);
- promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1);
-#endif
-
- /* Let machine desc say which reg (if any) the parm arrives in.
- 0 means it arrives on the stack. */
-#ifdef FUNCTION_INCOMING_ARG
- entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
- passed_type, named_arg);
-#else
- entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
- passed_type, named_arg);
-#endif
-
- if (entry_parm == 0)
- promoted_mode = passed_mode;
-
-#ifdef SETUP_INCOMING_VARARGS
- /* If this is the last named parameter, do any required setup for
- varargs or stdargs. We need to know about the case of this being an
- addressable type, in which case we skip the registers it
- would have arrived in.
-
- For stdargs, LAST_NAMED will be set for two parameters, the one that
- is actually the last named, and the dummy parameter. We only
- want to do this action once.
-
- Also, indicate when RTL generation is to be suppressed. */
- if (last_named && !varargs_setup)
- {
- SETUP_INCOMING_VARARGS (args_so_far, promoted_mode, passed_type,
- current_function_pretend_args_size,
- second_time);
- varargs_setup = 1;
- }
-#endif
-
- /* Determine parm's home in the stack,
- in case it arrives in the stack or we should pretend it did.
-
- Compute the stack position and rtx where the argument arrives
- and its size.
-
- There is one complexity here: If this was a parameter that would
- have been passed in registers, but wasn't only because it is
- __builtin_va_alist, we want locate_and_pad_parm to treat it as if
- it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
- In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
- 0 as it was the previous time. */
-
- locate_and_pad_parm (promoted_mode, passed_type,
-#ifdef STACK_PARMS_IN_REG_PARM_AREA
- 1,
-#else
-#ifdef FUNCTION_INCOMING_ARG
- FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
- passed_type,
- (named_arg
- || varargs_setup)) != 0,
-#else
- FUNCTION_ARG (args_so_far, promoted_mode,
- passed_type,
- named_arg || varargs_setup) != 0,
-#endif
-#endif
- fndecl, &stack_args_size, &stack_offset, &arg_size);
-
- if (! second_time)
- {
- rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
-
- if (offset_rtx == const0_rtx)
- stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer);
- else
- stack_parm = gen_rtx_MEM (promoted_mode,
- gen_rtx_PLUS (Pmode,
- internal_arg_pointer,
- offset_rtx));
-
- /* If this is a memory ref that contains aggregate components,
- mark it as such for cse and loop optimize. Likewise if it
- is readonly. */
- MEM_SET_IN_STRUCT_P (stack_parm, aggregate);
- RTX_UNCHANGING_P (stack_parm) = TREE_READONLY (parm);
- MEM_ALIAS_SET (stack_parm) = get_alias_set (parm);
- }
-
- /* If this parameter was passed both in registers and in the stack,
- use the copy on the stack. */
- if (MUST_PASS_IN_STACK (promoted_mode, passed_type))
- entry_parm = 0;
-
-#ifdef FUNCTION_ARG_PARTIAL_NREGS
- /* If this parm was passed part in regs and part in memory,
- pretend it arrived entirely in memory
- by pushing the register-part onto the stack.
-
- In the special case of a DImode or DFmode that is split,
- we could put it together in a pseudoreg directly,
- but for now that's not worth bothering with. */
-
- if (entry_parm)
- {
- int nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode,
- passed_type, named_arg);
-
- if (nregs > 0)
- {
- current_function_pretend_args_size
- = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1)
- / (PARM_BOUNDARY / BITS_PER_UNIT)
- * (PARM_BOUNDARY / BITS_PER_UNIT));
-
- if (! second_time)
- {
- /* Handle calls that pass values in multiple non-contiguous
- locations. The Irix 6 ABI has examples of this. */
- if (GET_CODE (entry_parm) == PARALLEL)
- emit_group_store (validize_mem (stack_parm), entry_parm,
- int_size_in_bytes (TREE_TYPE (parm)),
- (TYPE_ALIGN (TREE_TYPE (parm))
- / BITS_PER_UNIT));
- else
- move_block_from_reg (REGNO (entry_parm),
- validize_mem (stack_parm), nregs,
- int_size_in_bytes (TREE_TYPE (parm)));
- }
- entry_parm = stack_parm;
- }
- }
-#endif
-
- /* If we didn't decide this parm came in a register,
- by default it came on the stack. */
- if (entry_parm == 0)
- entry_parm = stack_parm;
-
- /* Record permanently how this parm was passed. */
- if (! second_time)
- DECL_INCOMING_RTL (parm) = entry_parm;
-
- /* If there is actually space on the stack for this parm,
- count it in stack_args_size; otherwise set stack_parm to 0
- to indicate there is no preallocated stack slot for the parm. */
-
- if (entry_parm == stack_parm
-#if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
- /* On some machines, even if a parm value arrives in a register
- there is still an (uninitialized) stack slot allocated for it.
-
- ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
- whether this parameter already has a stack slot allocated,
- because an arg block exists only if current_function_args_size
- is larger than some threshold, and we haven't calculated that
- yet. So, for now, we just assume that stack slots never exist
- in this case. */
- || REG_PARM_STACK_SPACE (fndecl) > 0
-#endif
- )
- {
- stack_args_size.constant += arg_size.constant;
- if (arg_size.var)
- ADD_PARM_SIZE (stack_args_size, arg_size.var);
- }
- else
- /* No stack slot was pushed for this parm. */
- stack_parm = 0;
-
- /* Update info on where next arg arrives in registers. */
-
- FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode,
- passed_type, named_arg);
-
- /* If this is our second time through, we are done with this parm. */
- if (second_time)
- continue;
-
- /* If we can't trust the parm stack slot to be aligned enough
- for its ultimate type, don't use that slot after entry.
- We'll make another stack slot, if we need one. */
- {
- int thisparm_boundary
- = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type);
-
- if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
- stack_parm = 0;
- }
-
- /* If parm was passed in memory, and we need to convert it on entry,
- don't store it back in that same slot. */
- if (entry_parm != 0
- && nominal_mode != BLKmode && nominal_mode != passed_mode)
- stack_parm = 0;
-
-#if 0
- /* Now adjust STACK_PARM to the mode and precise location
- where this parameter should live during execution,
- if we discover that it must live in the stack during execution.
- To make debuggers happier on big-endian machines, we store
- the value in the last bytes of the space available. */
-
- if (nominal_mode != BLKmode && nominal_mode != passed_mode
- && stack_parm != 0)
- {
- rtx offset_rtx;
-
- if (BYTES_BIG_ENDIAN
- && GET_MODE_SIZE (nominal_mode) < UNITS_PER_WORD)
- stack_offset.constant += (GET_MODE_SIZE (passed_mode)
- - GET_MODE_SIZE (nominal_mode));
-
- offset_rtx = ARGS_SIZE_RTX (stack_offset);
- if (offset_rtx == const0_rtx)
- stack_parm = gen_rtx_MEM (nominal_mode, internal_arg_pointer);
- else
- stack_parm = gen_rtx_MEM (nominal_mode,
- gen_rtx_PLUS (Pmode,
- internal_arg_pointer,
- offset_rtx));
-
- /* If this is a memory ref that contains aggregate components,
- mark it as such for cse and loop optimize. */
- MEM_SET_IN_STRUCT_P (stack_parm, aggregate);
- }
-#endif /* 0 */
-
-#ifdef STACK_REGS
- /* We need this "use" info, because the gcc-register->stack-register
- converter in reg-stack.c needs to know which registers are active
- at the start of the function call. The actual parameter loading
- instructions are not always available then anymore, since they might
- have been optimised away. */
-
- if (GET_CODE (entry_parm) == REG && !(hide_last_arg && last_named))
- emit_insn (gen_rtx_USE (GET_MODE (entry_parm), entry_parm));
-#endif
-
- /* ENTRY_PARM is an RTX for the parameter as it arrives,
- in the mode in which it arrives.
- STACK_PARM is an RTX for a stack slot where the parameter can live
- during the function (in case we want to put it there).
- STACK_PARM is 0 if no stack slot was pushed for it.
-
- Now output code if necessary to convert ENTRY_PARM to
- the type in which this function declares it,
- and store that result in an appropriate place,
- which may be a pseudo reg, may be STACK_PARM,
- or may be a local stack slot if STACK_PARM is 0.
-
- Set DECL_RTL to that place. */
-
- if (nominal_mode == BLKmode || GET_CODE (entry_parm) == PARALLEL)
- {
- /* If a BLKmode arrives in registers, copy it to a stack slot.
- Handle calls that pass values in multiple non-contiguous
- locations. The Irix 6 ABI has examples of this. */
- if (GET_CODE (entry_parm) == REG
- || GET_CODE (entry_parm) == PARALLEL)
- {
- int size_stored
- = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)),
- UNITS_PER_WORD);
-
- /* Note that we will be storing an integral number of words.
- So we have to be careful to ensure that we allocate an
- integral number of words. We do this below in the
- assign_stack_local if space was not allocated in the argument
- list. If it was, this will not work if PARM_BOUNDARY is not
- a multiple of BITS_PER_WORD. It isn't clear how to fix this
- if it becomes a problem. */
-
- if (stack_parm == 0)
- {
- stack_parm
- = assign_stack_local (GET_MODE (entry_parm),
- size_stored, 0);
-
- /* If this is a memory ref that contains aggregate
- components, mark it as such for cse and loop optimize. */
- MEM_SET_IN_STRUCT_P (stack_parm, aggregate);
- }
-
- else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
- abort ();
-
- if (TREE_READONLY (parm))
- RTX_UNCHANGING_P (stack_parm) = 1;
-
- /* Handle calls that pass values in multiple non-contiguous
- locations. The Irix 6 ABI has examples of this. */
- if (GET_CODE (entry_parm) == PARALLEL)
- emit_group_store (validize_mem (stack_parm), entry_parm,
- int_size_in_bytes (TREE_TYPE (parm)),
- (TYPE_ALIGN (TREE_TYPE (parm))
- / BITS_PER_UNIT));
- else
- move_block_from_reg (REGNO (entry_parm),
- validize_mem (stack_parm),
- size_stored / UNITS_PER_WORD,
- int_size_in_bytes (TREE_TYPE (parm)));
- }
- DECL_RTL (parm) = stack_parm;
- }
- else if (! ((obey_regdecls && ! DECL_REGISTER (parm)
- && ! DECL_INLINE (fndecl))
- /* layout_decl may set this. */
- || TREE_ADDRESSABLE (parm)
- || TREE_SIDE_EFFECTS (parm)
- /* If -ffloat-store specified, don't put explicit
- float variables into registers. */
- || (flag_float_store
- && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
- /* Always assign pseudo to structure return or item passed
- by invisible reference. */
- || passed_pointer || parm == function_result_decl)
- {
- /* Store the parm in a pseudoregister during the function, but we
- may need to do it in a wider mode. */
-
- register rtx parmreg;
- int regno, regnoi = 0, regnor = 0;
-
- unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
-
- promoted_nominal_mode
- = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0);
-
- parmreg = gen_reg_rtx (promoted_nominal_mode);
- mark_user_reg (parmreg);
-
- /* If this was an item that we received a pointer to, set DECL_RTL
- appropriately. */
- if (passed_pointer)
- {
- DECL_RTL (parm)
- = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)), parmreg);
- MEM_SET_IN_STRUCT_P (DECL_RTL (parm), aggregate);
- }
- else
- DECL_RTL (parm) = parmreg;
-
- /* Copy the value into the register. */
- if (nominal_mode != passed_mode
- || promoted_nominal_mode != promoted_mode)
- {
- int save_tree_used;
- /* ENTRY_PARM has been converted to PROMOTED_MODE, its
- mode, by the caller. We now have to convert it to
- NOMINAL_MODE, if different. However, PARMREG may be in
- a different mode than NOMINAL_MODE if it is being stored
- promoted.
-
- If ENTRY_PARM is a hard register, it might be in a register
- not valid for operating in its mode (e.g., an odd-numbered
- register for a DFmode). In that case, moves are the only
- thing valid, so we can't do a convert from there. This
- occurs when the calling sequence allow such misaligned
- usages.
-
- In addition, the conversion may involve a call, which could
- clobber parameters which haven't been copied to pseudo
- registers yet. Therefore, we must first copy the parm to
- a pseudo reg here, and save the conversion until after all
- parameters have been moved. */
-
- rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
-
- emit_move_insn (tempreg, validize_mem (entry_parm));
-
- push_to_sequence (conversion_insns);
- tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp);
-
- /* TREE_USED gets set erroneously during expand_assignment. */
- save_tree_used = TREE_USED (parm);
- expand_assignment (parm,
- make_tree (nominal_type, tempreg), 0, 0);
- TREE_USED (parm) = save_tree_used;
- conversion_insns = get_insns ();
- did_conversion = 1;
- end_sequence ();
- }
- else
- emit_move_insn (parmreg, validize_mem (entry_parm));
-
- /* If we were passed a pointer but the actual value
- can safely live in a register, put it in one. */
- if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
- /* CYGNUS LOCAL -- FUNCTION_ARG_KEEP_AS_REFERENCE/meissner */
-#ifdef FUNCTION_ARG_KEEP_AS_REFERENCE
- && !FUNCTION_ARG_KEEP_AS_REFERENCE (args_so_far, passed_mode,
- passed_type, ! last_named)
-#endif
- /* END CYGNUS LOCAL */
- && ! ((obey_regdecls && ! DECL_REGISTER (parm)
- && ! DECL_INLINE (fndecl))
- /* layout_decl may set this. */
- || TREE_ADDRESSABLE (parm)
- || TREE_SIDE_EFFECTS (parm)
- /* If -ffloat-store specified, don't put explicit
- float variables into registers. */
- || (flag_float_store
- && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)))
- {
- /* We can't use nominal_mode, because it will have been set to
- Pmode above. We must use the actual mode of the parm. */
- parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
- mark_user_reg (parmreg);
- emit_move_insn (parmreg, DECL_RTL (parm));
- DECL_RTL (parm) = parmreg;
- /* STACK_PARM is the pointer, not the parm, and PARMREG is
- now the parm. */
- stack_parm = 0;
- }
-#ifdef FUNCTION_ARG_CALLEE_COPIES
- /* If we are passed an arg by reference and it is our responsibility
- to make a copy, do it now.
- PASSED_TYPE and PASSED mode now refer to the pointer, not the
- original argument, so we must recreate them in the call to
- FUNCTION_ARG_CALLEE_COPIES. */
- /* ??? Later add code to handle the case that if the argument isn't
- modified, don't do the copy. */
-
- else if (passed_pointer
- && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
- TYPE_MODE (DECL_ARG_TYPE (parm)),
- DECL_ARG_TYPE (parm),
- named_arg)
- && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm)))
- {
- rtx copy;
- tree type = DECL_ARG_TYPE (parm);
-
- /* This sequence may involve a library call perhaps clobbering
- registers that haven't been copied to pseudos yet. */
-
- push_to_sequence (conversion_insns);
-
- if (TYPE_SIZE (type) == 0
- || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
- /* This is a variable sized object. */
- copy = gen_rtx_MEM (BLKmode,
- allocate_dynamic_stack_space
- (expr_size (parm), NULL_RTX,
- TYPE_ALIGN (type)));
- else
- copy = assign_stack_temp (TYPE_MODE (type),
- int_size_in_bytes (type), 1);
- MEM_SET_IN_STRUCT_P (copy, AGGREGATE_TYPE_P (type));
- RTX_UNCHANGING_P (copy) = TREE_READONLY (parm);
-
- store_expr (parm, copy, 0);
- emit_move_insn (parmreg, XEXP (copy, 0));
- if (current_function_check_memory_usage)
- emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
- XEXP (copy, 0), ptr_mode,
- GEN_INT (int_size_in_bytes (type)),
- TYPE_MODE (sizetype),
- GEN_INT (MEMORY_USE_RW),
- TYPE_MODE (integer_type_node));
- conversion_insns = get_insns ();
- did_conversion = 1;
- end_sequence ();
- }
-#endif /* FUNCTION_ARG_CALLEE_COPIES */
-
- /* In any case, record the parm's desired stack location
- in case we later discover it must live in the stack.
-
- If it is a COMPLEX value, store the stack location for both
- halves. */
-
- if (GET_CODE (parmreg) == CONCAT)
- regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
- else
- regno = REGNO (parmreg);
-
- if (regno >= max_parm_reg)
- {
- rtx *new;
- int old_max_parm_reg = max_parm_reg;
-
- /* It's slow to expand this one register at a time,
- but it's also rare and we need max_parm_reg to be
- precisely correct. */
- max_parm_reg = regno + 1;
- new = (rtx *) savealloc (max_parm_reg * sizeof (rtx));
- bcopy ((char *) parm_reg_stack_loc, (char *) new,
- old_max_parm_reg * sizeof (rtx));
- bzero ((char *) (new + old_max_parm_reg),
- (max_parm_reg - old_max_parm_reg) * sizeof (rtx));
- parm_reg_stack_loc = new;
- }
-
- if (GET_CODE (parmreg) == CONCAT)
- {
- enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
-
- regnor = REGNO (gen_realpart (submode, parmreg));
- regnoi = REGNO (gen_imagpart (submode, parmreg));
-
- if (stack_parm != 0)
- {
- parm_reg_stack_loc[regnor]
- = gen_realpart (submode, stack_parm);
- parm_reg_stack_loc[regnoi]
- = gen_imagpart (submode, stack_parm);
- }
- else
- {
- parm_reg_stack_loc[regnor] = 0;
- parm_reg_stack_loc[regnoi] = 0;
- }
- }
- else
- parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
-
- /* Mark the register as eliminable if we did no conversion
- and it was copied from memory at a fixed offset,
- and the arg pointer was not copied to a pseudo-reg.
- If the arg pointer is a pseudo reg or the offset formed
- an invalid address, such memory-equivalences
- as we make here would screw up life analysis for it. */
- if (nominal_mode == passed_mode
- && ! did_conversion
- && stack_parm != 0
- && GET_CODE (stack_parm) == MEM
- && stack_offset.var == 0
- && reg_mentioned_p (virtual_incoming_args_rtx,
- XEXP (stack_parm, 0)))
- {
- rtx linsn = get_last_insn ();
- rtx sinsn, set;
-
- /* Mark complex types separately. */
- if (GET_CODE (parmreg) == CONCAT)
- /* Scan backwards for the set of the real and
- imaginary parts. */
- for (sinsn = linsn; sinsn != 0;
- sinsn = prev_nonnote_insn (sinsn))
- {
- set = single_set (sinsn);
- if (set != 0
- && SET_DEST (set) == regno_reg_rtx [regnoi])
- REG_NOTES (sinsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV,
- parm_reg_stack_loc[regnoi],
- REG_NOTES (sinsn));
- else if (set != 0
- && SET_DEST (set) == regno_reg_rtx [regnor])
- REG_NOTES (sinsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV,
- parm_reg_stack_loc[regnor],
- REG_NOTES (sinsn));
- }
- else if ((set = single_set (linsn)) != 0
- && SET_DEST (set) == parmreg)
- REG_NOTES (linsn)
- = gen_rtx_EXPR_LIST (REG_EQUIV,
- stack_parm, REG_NOTES (linsn));
- }
-
- /* For pointer data type, suggest pointer register. */
- if (POINTER_TYPE_P (TREE_TYPE (parm)))
- mark_reg_pointer (parmreg,
- (TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm)))
- / BITS_PER_UNIT));
- }
- else
- {
- /* Value must be stored in the stack slot STACK_PARM
- during function execution. */
-
- if (promoted_mode != nominal_mode)
- {
- /* Conversion is required. */
- rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
-
- emit_move_insn (tempreg, validize_mem (entry_parm));
-
- push_to_sequence (conversion_insns);
- entry_parm = convert_to_mode (nominal_mode, tempreg,
- TREE_UNSIGNED (TREE_TYPE (parm)));
- if (stack_parm)
- {
- /* ??? This may need a big-endian conversion on sparc64. */
- stack_parm = change_address (stack_parm, nominal_mode,
- NULL_RTX);
- }
- conversion_insns = get_insns ();
- did_conversion = 1;
- end_sequence ();
- }
-
- if (entry_parm != stack_parm)
- {
- if (stack_parm == 0)
- {
- stack_parm
- = assign_stack_local (GET_MODE (entry_parm),
- GET_MODE_SIZE (GET_MODE (entry_parm)), 0);
- /* If this is a memory ref that contains aggregate components,
- mark it as such for cse and loop optimize. */
- MEM_SET_IN_STRUCT_P (stack_parm, aggregate);
- }
-
- if (promoted_mode != nominal_mode)
- {
- push_to_sequence (conversion_insns);
- emit_move_insn (validize_mem (stack_parm),
- validize_mem (entry_parm));
- conversion_insns = get_insns ();
- end_sequence ();
- }
- else
- emit_move_insn (validize_mem (stack_parm),
- validize_mem (entry_parm));
- }
- if (current_function_check_memory_usage)
- {
- push_to_sequence (conversion_insns);
- emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
- XEXP (stack_parm, 0), ptr_mode,
- GEN_INT (GET_MODE_SIZE (GET_MODE
- (entry_parm))),
- TYPE_MODE (sizetype),
- GEN_INT (MEMORY_USE_RW),
- TYPE_MODE (integer_type_node));
-
- conversion_insns = get_insns ();
- end_sequence ();
- }
- DECL_RTL (parm) = stack_parm;
- }
-
- /* If this "parameter" was the place where we are receiving the
- function's incoming structure pointer, set up the result. */
- if (parm == function_result_decl)
- {
- tree result = DECL_RESULT (fndecl);
- tree restype = TREE_TYPE (result);
-
- DECL_RTL (result)
- = gen_rtx_MEM (DECL_MODE (result), DECL_RTL (parm));
-
- MEM_SET_IN_STRUCT_P (DECL_RTL (result),
- AGGREGATE_TYPE_P (restype));
- }
-
- if (TREE_THIS_VOLATILE (parm))
- MEM_VOLATILE_P (DECL_RTL (parm)) = 1;
- if (TREE_READONLY (parm))
- RTX_UNCHANGING_P (DECL_RTL (parm)) = 1;
- }
-
- /* Output all parameter conversion instructions (possibly including calls)
- now that all parameters have been copied out of hard registers. */
- emit_insns (conversion_insns);
-
- last_parm_insn = get_last_insn ();
-
- current_function_args_size = stack_args_size.constant;
-
- /* Adjust function incoming argument size for alignment and
- minimum length. */
-
-#ifdef REG_PARM_STACK_SPACE
-#ifndef MAYBE_REG_PARM_STACK_SPACE
- current_function_args_size = MAX (current_function_args_size,
- REG_PARM_STACK_SPACE (fndecl));
-#endif
-#endif
-
-#ifdef PREFERRED_STACK_BOUNDARY
-#define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
-
- current_function_args_size
- = ((current_function_args_size + STACK_BYTES - 1)
- / STACK_BYTES) * STACK_BYTES;
-#endif
-
-#ifdef ARGS_GROW_DOWNWARD
- current_function_arg_offset_rtx
- = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
- : expand_expr (size_binop (MINUS_EXPR, stack_args_size.var,
- size_int (-stack_args_size.constant)),
- NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD));
-#else
- current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
-#endif
-
- /* See how many bytes, if any, of its args a function should try to pop
- on return. */
-
- current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl),
- current_function_args_size);
-
- /* For stdarg.h function, save info about
- regs and stack space used by the named args. */
-
- if (!hide_last_arg)
- current_function_args_info = args_so_far;
-
- /* Set the rtx used for the function return value. Put this in its
- own variable so any optimizers that need this information don't have
- to include tree.h. Do this here so it gets done when an inlined
- function gets output. */
-
- current_function_return_rtx = DECL_RTL (DECL_RESULT (fndecl));
-}
-
-/* Indicate whether REGNO is an incoming argument to the current function
- that was promoted to a wider mode. If so, return the RTX for the
- register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
- that REGNO is promoted from and whether the promotion was signed or
- unsigned. */
-
-#ifdef PROMOTE_FUNCTION_ARGS
-
-rtx
-promoted_input_arg (regno, pmode, punsignedp)
- int regno;
- enum machine_mode *pmode;
- int *punsignedp;
-{
- tree arg;
-
- for (arg = DECL_ARGUMENTS (current_function_decl); arg;
- arg = TREE_CHAIN (arg))
- if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
- && REGNO (DECL_INCOMING_RTL (arg)) == regno
- && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg)))
- {
- enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
- int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
-
- mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1);
- if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
- && mode != DECL_MODE (arg))
- {
- *pmode = DECL_MODE (arg);
- *punsignedp = unsignedp;
- return DECL_INCOMING_RTL (arg);
- }
- }
-
- return 0;
-}
-
-#endif
-
-/* Compute the size and offset from the start of the stacked arguments for a
- parm passed in mode PASSED_MODE and with type TYPE.
-
- INITIAL_OFFSET_PTR points to the current offset into the stacked
- arguments.
-
- The starting offset and size for this parm are returned in *OFFSET_PTR
- and *ARG_SIZE_PTR, respectively.
-
- IN_REGS is non-zero if the argument will be passed in registers. It will
- never be set if REG_PARM_STACK_SPACE is not defined.
-
- FNDECL is the function in which the argument was defined.
-
- There are two types of rounding that are done. The first, controlled by
- FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
- list to be aligned to the specific boundary (in bits). This rounding
- affects the initial and starting offsets, but not the argument size.
-
- The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
- optionally rounds the size of the parm to PARM_BOUNDARY. The
- initial offset is not affected by this rounding, while the size always
- is and the starting offset may be. */
-
-/* offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
- initial_offset_ptr is positive because locate_and_pad_parm's
- callers pass in the total size of args so far as
- initial_offset_ptr. arg_size_ptr is always positive.*/
-
-void
-locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
- initial_offset_ptr, offset_ptr, arg_size_ptr)
- enum machine_mode passed_mode;
- tree type;
- int in_regs;
- tree fndecl;
- struct args_size *initial_offset_ptr;
- struct args_size *offset_ptr;
- struct args_size *arg_size_ptr;
-{
- tree sizetree
- = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
- enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
- int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
-
-#ifdef REG_PARM_STACK_SPACE
- /* If we have found a stack parm before we reach the end of the
- area reserved for registers, skip that area. */
- if (! in_regs)
- {
- int reg_parm_stack_space = 0;
-
-#ifdef MAYBE_REG_PARM_STACK_SPACE
- reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
-#else
- reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
-#endif
- if (reg_parm_stack_space > 0)
- {
- if (initial_offset_ptr->var)
- {
- initial_offset_ptr->var
- = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
- size_int (reg_parm_stack_space));
- initial_offset_ptr->constant = 0;
- }
- else if (initial_offset_ptr->constant < reg_parm_stack_space)
- initial_offset_ptr->constant = reg_parm_stack_space;
- }
- }
-#endif /* REG_PARM_STACK_SPACE */
-
- arg_size_ptr->var = 0;
- arg_size_ptr->constant = 0;
-
-#ifdef ARGS_GROW_DOWNWARD
- if (initial_offset_ptr->var)
- {
- offset_ptr->constant = 0;
- offset_ptr->var = size_binop (MINUS_EXPR, integer_zero_node,
- initial_offset_ptr->var);
- }
- else
- {
- offset_ptr->constant = - initial_offset_ptr->constant;
- offset_ptr->var = 0;
- }
- if (where_pad != none
- && (TREE_CODE (sizetree) != INTEGER_CST
- || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)))
- sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
- SUB_PARM_SIZE (*offset_ptr, sizetree);
- if (where_pad != downward)
- pad_to_arg_alignment (offset_ptr, boundary);
- if (initial_offset_ptr->var)
- {
- arg_size_ptr->var = size_binop (MINUS_EXPR,
- size_binop (MINUS_EXPR,
- integer_zero_node,
- initial_offset_ptr->var),
- offset_ptr->var);
- }
- else
- {
- arg_size_ptr->constant = (- initial_offset_ptr->constant
- - offset_ptr->constant);
- }
-#else /* !ARGS_GROW_DOWNWARD */
- pad_to_arg_alignment (initial_offset_ptr, boundary);
- *offset_ptr = *initial_offset_ptr;
-
-#ifdef PUSH_ROUNDING
- if (passed_mode != BLKmode)
- sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
-#endif
-
- /* Pad_below needs the pre-rounded size to know how much to pad below
- so this must be done before rounding up. */
- if (where_pad == downward
- /* However, BLKmode args passed in regs have their padding done elsewhere.
- The stack slot must be able to hold the entire register. */
- && !(in_regs && passed_mode == BLKmode))
- pad_below (offset_ptr, passed_mode, sizetree);
-
- if (where_pad != none
- && (TREE_CODE (sizetree) != INTEGER_CST
- || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)))
- sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
-
- ADD_PARM_SIZE (*arg_size_ptr, sizetree);
-#endif /* ARGS_GROW_DOWNWARD */
-}
-
-/* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
- BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
-
-static void
-pad_to_arg_alignment (offset_ptr, boundary)
- struct args_size *offset_ptr;
- int boundary;
-{
- int boundary_in_bytes = boundary / BITS_PER_UNIT;
-
- if (boundary > BITS_PER_UNIT)
- {
- if (offset_ptr->var)
- {
- offset_ptr->var =
-#ifdef ARGS_GROW_DOWNWARD
- round_down
-#else
- round_up
-#endif
- (ARGS_SIZE_TREE (*offset_ptr),
- boundary / BITS_PER_UNIT);
- offset_ptr->constant = 0; /*?*/
- }
- else
- offset_ptr->constant =
-#ifdef ARGS_GROW_DOWNWARD
- FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
-#else
- CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
-#endif
- }
-}
-
-#ifndef ARGS_GROW_DOWNWARD
-static void
-pad_below (offset_ptr, passed_mode, sizetree)
- struct args_size *offset_ptr;
- enum machine_mode passed_mode;
- tree sizetree;
-{
- if (passed_mode != BLKmode)
- {
- if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
- offset_ptr->constant
- += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
- / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
- - GET_MODE_SIZE (passed_mode));
- }
- else
- {
- if (TREE_CODE (sizetree) != INTEGER_CST
- || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
- {
- /* Round the size up to multiple of PARM_BOUNDARY bits. */
- tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
- /* Add it in. */
- ADD_PARM_SIZE (*offset_ptr, s2);
- SUB_PARM_SIZE (*offset_ptr, sizetree);
- }
- }
-}
-#endif
-
-#ifdef ARGS_GROW_DOWNWARD
-static tree
-round_down (value, divisor)
- tree value;
- int divisor;
-{
- return size_binop (MULT_EXPR,
- size_binop (FLOOR_DIV_EXPR, value, size_int (divisor)),
- size_int (divisor));
-}
-#endif
-
-/* Walk the tree of blocks describing the binding levels within a function
- and warn about uninitialized variables.
- This is done after calling flow_analysis and before global_alloc
- clobbers the pseudo-regs to hard regs. */
-
-void
-uninitialized_vars_warning (block)
- tree block;
-{
- register tree decl, sub;
- for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
- {
- if (TREE_CODE (decl) == VAR_DECL
- /* These warnings are unreliable for and aggregates
- because assigning the fields one by one can fail to convince
- flow.c that the entire aggregate was initialized.
- Unions are troublesome because members may be shorter. */
- && ! AGGREGATE_TYPE_P (TREE_TYPE (decl))
- && DECL_RTL (decl) != 0
- && GET_CODE (DECL_RTL (decl)) == REG
- /* Global optimizations can make it difficult to determine if a
- particular variable has been initialized. However, a VAR_DECL
- with a nonzero DECL_INITIAL had an initializer, so do not
- claim it is potentially uninitialized.
-
- We do not care about the actual value in DECL_INITIAL, so we do
- not worry that it may be a dangling pointer. */
- && DECL_INITIAL (decl) == NULL_TREE
- && regno_uninitialized (REGNO (DECL_RTL (decl))))
- warning_with_decl (decl,
- "`%s' might be used uninitialized in this function");
- if (TREE_CODE (decl) == VAR_DECL
- && DECL_RTL (decl) != 0
- && GET_CODE (DECL_RTL (decl)) == REG
- && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
- warning_with_decl (decl,
- "variable `%s' might be clobbered by `longjmp' or `vfork'");
- }
- for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
- uninitialized_vars_warning (sub);
-}
-
-/* Do the appropriate part of uninitialized_vars_warning
- but for arguments instead of local variables. */
-
-void
-setjmp_args_warning ()
-{
- register tree decl;
- for (decl = DECL_ARGUMENTS (current_function_decl);
- decl; decl = TREE_CHAIN (decl))
- if (DECL_RTL (decl) != 0
- && GET_CODE (DECL_RTL (decl)) == REG
- && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
- warning_with_decl (decl, "argument `%s' might be clobbered by `longjmp' or `vfork'");
-}
-
-/* If this function call setjmp, put all vars into the stack
- unless they were declared `register'. */
-
-void
-setjmp_protect (block)
- tree block;
-{
- register tree decl, sub;
- for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
- if ((TREE_CODE (decl) == VAR_DECL
- || TREE_CODE (decl) == PARM_DECL)
- && DECL_RTL (decl) != 0
- && (GET_CODE (DECL_RTL (decl)) == REG
- || (GET_CODE (DECL_RTL (decl)) == MEM
- && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
- /* If this variable came from an inline function, it must be
- that its life doesn't overlap the setjmp. If there was a
- setjmp in the function, it would already be in memory. We
- must exclude such variable because their DECL_RTL might be
- set to strange things such as virtual_stack_vars_rtx. */
- && ! DECL_FROM_INLINE (decl)
- && (
-#ifdef NON_SAVING_SETJMP
- /* If longjmp doesn't restore the registers,
- don't put anything in them. */
- NON_SAVING_SETJMP
- ||
-#endif
- ! DECL_REGISTER (decl)))
- put_var_into_stack (decl);
- for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
- setjmp_protect (sub);
-}
-
-/* Like the previous function, but for args instead of local variables. */
-
-void
-setjmp_protect_args ()
-{
- register tree decl;
- for (decl = DECL_ARGUMENTS (current_function_decl);
- decl; decl = TREE_CHAIN (decl))
- if ((TREE_CODE (decl) == VAR_DECL
- || TREE_CODE (decl) == PARM_DECL)
- && DECL_RTL (decl) != 0
- && (GET_CODE (DECL_RTL (decl)) == REG
- || (GET_CODE (DECL_RTL (decl)) == MEM
- && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF))
- && (
- /* If longjmp doesn't restore the registers,
- don't put anything in them. */
-#ifdef NON_SAVING_SETJMP
- NON_SAVING_SETJMP
- ||
-#endif
- ! DECL_REGISTER (decl)))
- put_var_into_stack (decl);
-}
-
-/* Return the context-pointer register corresponding to DECL,
- or 0 if it does not need one. */
-
-rtx
-lookup_static_chain (decl)
- tree decl;
-{
- tree context = decl_function_context (decl);
- tree link;
-
- if (context == 0
- || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl)))
- return 0;
-
- /* We treat inline_function_decl as an alias for the current function
- because that is the inline function whose vars, types, etc.
- are being merged into the current function.
- See expand_inline_function. */
- if (context == current_function_decl || context == inline_function_decl)
- return virtual_stack_vars_rtx;
-
- for (link = context_display; link; link = TREE_CHAIN (link))
- if (TREE_PURPOSE (link) == context)
- return RTL_EXPR_RTL (TREE_VALUE (link));
-
- abort ();
-}
-
-/* Convert a stack slot address ADDR for variable VAR
- (from a containing function)
- into an address valid in this function (using a static chain). */
-
-rtx
-fix_lexical_addr (addr, var)
- rtx addr;
- tree var;
-{
- rtx basereg;
- HOST_WIDE_INT displacement;
- tree context = decl_function_context (var);
- struct function *fp;
- rtx base = 0;
-
- /* If this is the present function, we need not do anything. */
- if (context == current_function_decl || context == inline_function_decl)
- return addr;
-
- for (fp = outer_function_chain; fp; fp = fp->next)
- if (fp->decl == context)
- break;
-
- if (fp == 0)
- abort ();
-
- if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM)
- addr = XEXP (XEXP (addr, 0), 0);
-
- /* Decode given address as base reg plus displacement. */
- if (GET_CODE (addr) == REG)
- basereg = addr, displacement = 0;
- else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
- basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
- else
- abort ();
-
- /* We accept vars reached via the containing function's
- incoming arg pointer and via its stack variables pointer. */
- if (basereg == fp->internal_arg_pointer)
- {
- /* If reached via arg pointer, get the arg pointer value
- out of that function's stack frame.
-
- There are two cases: If a separate ap is needed, allocate a
- slot in the outer function for it and dereference it that way.
- This is correct even if the real ap is actually a pseudo.
- Otherwise, just adjust the offset from the frame pointer to
- compensate. */
-
-#ifdef NEED_SEPARATE_AP
- rtx addr;
-
- if (fp->arg_pointer_save_area == 0)
- fp->arg_pointer_save_area
- = assign_outer_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0, fp);
-
- addr = fix_lexical_addr (XEXP (fp->arg_pointer_save_area, 0), var);
- addr = memory_address (Pmode, addr);
-
- base = copy_to_reg (gen_rtx_MEM (Pmode, addr));
-#else
- displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
- base = lookup_static_chain (var);
-#endif
- }
-
- else if (basereg == virtual_stack_vars_rtx)
- {
- /* This is the same code as lookup_static_chain, duplicated here to
- avoid an extra call to decl_function_context. */
- tree link;
-
- for (link = context_display; link; link = TREE_CHAIN (link))
- if (TREE_PURPOSE (link) == context)
- {
- base = RTL_EXPR_RTL (TREE_VALUE (link));
- break;
- }
- }
-
- if (base == 0)
- abort ();
-
- /* Use same offset, relative to appropriate static chain or argument
- pointer. */
- return plus_constant (base, displacement);
-}
-
-/* Return the address of the trampoline for entering nested fn FUNCTION.
- If necessary, allocate a trampoline (in the stack frame)
- and emit rtl to initialize its contents (at entry to this function). */
-
-rtx
-trampoline_address (function)
- tree function;
-{
- tree link;
- tree rtlexp;
- rtx tramp;
- struct function *fp;
- tree fn_context;
-
- /* Find an existing trampoline and return it. */
- for (link = trampoline_list; link; link = TREE_CHAIN (link))
- if (TREE_PURPOSE (link) == function)
- return
- round_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0));
-
- for (fp = outer_function_chain; fp; fp = fp->next)
- for (link = fp->trampoline_list; link; link = TREE_CHAIN (link))
- if (TREE_PURPOSE (link) == function)
- {
- tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
- function);
- return round_trampoline_addr (tramp);
- }
-
- /* None exists; we must make one. */
-
- /* Find the `struct function' for the function containing FUNCTION. */
- fp = 0;
- fn_context = decl_function_context (function);
- if (fn_context != current_function_decl
- && fn_context != inline_function_decl)
- for (fp = outer_function_chain; fp; fp = fp->next)
- if (fp->decl == fn_context)
- break;
-
- /* Allocate run-time space for this trampoline
- (usually in the defining function's stack frame). */
-#ifdef ALLOCATE_TRAMPOLINE
- tramp = ALLOCATE_TRAMPOLINE (fp);
-#else
- /* If rounding needed, allocate extra space
- to ensure we have TRAMPOLINE_SIZE bytes left after rounding up. */
-#ifdef TRAMPOLINE_ALIGNMENT
-#define TRAMPOLINE_REAL_SIZE \
- (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1)
-#else
-#define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE)
-#endif
- if (fp != 0)
- tramp = assign_outer_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0, fp);
- else
- tramp = assign_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0);
-#endif
-
- /* Record the trampoline for reuse and note it for later initialization
- by expand_function_end. */
- if (fp != 0)
- {
- push_obstacks (fp->function_maybepermanent_obstack,
- fp->function_maybepermanent_obstack);
- rtlexp = make_node (RTL_EXPR);
- RTL_EXPR_RTL (rtlexp) = tramp;
- fp->trampoline_list = tree_cons (function, rtlexp, fp->trampoline_list);
- pop_obstacks ();
- }
- else
- {
- /* Make the RTL_EXPR node temporary, not momentary, so that the
- trampoline_list doesn't become garbage. */
- int momentary = suspend_momentary ();
- rtlexp = make_node (RTL_EXPR);
- resume_momentary (momentary);
-
- RTL_EXPR_RTL (rtlexp) = tramp;
- trampoline_list = tree_cons (function, rtlexp, trampoline_list);
- }
-
- tramp = fix_lexical_addr (XEXP (tramp, 0), function);
- return round_trampoline_addr (tramp);
-}
-
-/* Given a trampoline address,
- round it to multiple of TRAMPOLINE_ALIGNMENT. */
-
-static rtx
-round_trampoline_addr (tramp)
- rtx tramp;
-{
-#ifdef TRAMPOLINE_ALIGNMENT
- /* Round address up to desired boundary. */
- rtx temp = gen_reg_rtx (Pmode);
- temp = expand_binop (Pmode, add_optab, tramp,
- GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1),
- temp, 0, OPTAB_LIB_WIDEN);
- tramp = expand_binop (Pmode, and_optab, temp,
- GEN_INT (- TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT),
- temp, 0, OPTAB_LIB_WIDEN);
-#endif
- return tramp;
-}
-
-/* The functions identify_blocks and reorder_blocks provide a way to
- reorder the tree of BLOCK nodes, for optimizers that reshuffle or
- duplicate portions of the RTL code. Call identify_blocks before
- changing the RTL, and call reorder_blocks after. */
-
-/* Put all this function's BLOCK nodes including those that are chained
- onto the first block into a vector, and return it.
- Also store in each NOTE for the beginning or end of a block
- the index of that block in the vector.
- The arguments are BLOCK, the chain of top-level blocks of the function,
- and INSNS, the insn chain of the function. */
-
-tree *
-identify_blocks (block, insns)
- tree block;
- rtx insns;
-{
- int n_blocks;
- tree *block_vector;
- int *block_stack;
- int depth = 0;
- int next_block_number = 1;
- int current_block_number = 1;
- rtx insn;
-
- if (block == 0)
- return 0;
-
- n_blocks = all_blocks (block, 0);
- block_vector = (tree *) xmalloc (n_blocks * sizeof (tree));
- block_stack = (int *) alloca (n_blocks * sizeof (int));
-
- all_blocks (block, block_vector);
-
- for (insn = insns; insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == NOTE)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
- {
- block_stack[depth++] = current_block_number;
- current_block_number = next_block_number;
- NOTE_BLOCK_NUMBER (insn) = next_block_number++;
- }
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
- {
- NOTE_BLOCK_NUMBER (insn) = current_block_number;
- current_block_number = block_stack[--depth];
- }
- }
-
- if (n_blocks != next_block_number)
- abort ();
-
- return block_vector;
-}
-
-/* Given BLOCK_VECTOR which was returned by identify_blocks,
- and a revised instruction chain, rebuild the tree structure
- of BLOCK nodes to correspond to the new order of RTL.
- The new block tree is inserted below TOP_BLOCK.
- Returns the current top-level block. */
-
-tree
-reorder_blocks (block_vector, block, insns)
- tree *block_vector;
- tree block;
- rtx insns;
-{
- tree current_block = block;
- rtx insn;
-
- if (block_vector == 0)
- return block;
-
- /* Prune the old trees away, so that it doesn't get in the way. */
- BLOCK_SUBBLOCKS (current_block) = 0;
- BLOCK_CHAIN (current_block) = 0;
-
- /* CYGNUS LOCAL LRS */
- for (insn = insns; insn; insn = NEXT_INSN (insn))
- {
- tree block, range_start_block = NULL_TREE;
-
- if (GET_CODE (insn) == NOTE)
- switch (NOTE_LINE_NUMBER (insn))
- {
- /* Block beginning, link into block chain */
- case NOTE_INSN_BLOCK_BEG:
- if (NOTE_BLOCK_NUMBER (insn) == NOTE_BLOCK_LIVE_RANGE_BLOCK)
- {
- range_start_block = block = make_node (BLOCK);
- BLOCK_LIVE_RANGE_FLAG (block) = TRUE;
- TREE_USED (block) = TRUE;
- }
- else if (NOTE_BLOCK_NUMBER (insn) <= 0)
- abort ();
- else
- {
- block = block_vector[NOTE_BLOCK_NUMBER (insn)];
- range_start_block = NULL_TREE;
-
- /* If we have seen this block before, copy it. */
- if (TREE_ASM_WRITTEN (block))
- block = copy_node (block);
- }
-
- BLOCK_SUBBLOCKS (block) = 0;
- TREE_ASM_WRITTEN (block) = 1;
- BLOCK_SUPERCONTEXT (block) = current_block;
- BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
- BLOCK_SUBBLOCKS (current_block) = block;
- NOTE_SOURCE_FILE (insn) = 0;
- current_block = block;
- break;
-
- /* Block ending, restore current block, reset block number. */
- case NOTE_INSN_BLOCK_END:
- BLOCK_SUBBLOCKS (current_block)
- = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
- current_block = BLOCK_SUPERCONTEXT (current_block);
- NOTE_BLOCK_NUMBER (insn) = 0;
- break;
-
- /* Range start, if we created a new block for the range, link
- any new copies into the range. */
- case NOTE_INSN_RANGE_START:
- if (range_start_block)
- {
- rtx ri = NOTE_RANGE_INFO (insn);
- int i;
- for (i = 0; i < (int)RANGE_INFO_NUM_REGS (ri); i++)
- if (RANGE_REG_SYMBOL_NODE (ri, i))
- {
- tree new_sym = copy_node (RANGE_REG_SYMBOL_NODE (ri, i));
- DECL_RTL (new_sym) = regno_reg_rtx[RANGE_REG_COPY (ri, i)];
- TREE_CHAIN (new_sym) = BLOCK_VARS (range_start_block);
- BLOCK_VARS (range_start_block) = new_sym;
- RANGE_REG_SYMBOL_NODE (ri, i) = new_sym;
- RANGE_REG_BLOCK_NODE (ri, i) = range_start_block;
- }
- }
- break;
- }
- }
- /* END CYGNUS LOCAL */
-
- BLOCK_SUBBLOCKS (current_block)
- = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
- return current_block;
-}
-
-/* Reverse the order of elements in the chain T of blocks,
- and return the new head of the chain (old last element). */
-
-static tree
-blocks_nreverse (t)
- tree t;
-{
- register tree prev = 0, decl, next;
- for (decl = t; decl; decl = next)
- {
- next = BLOCK_CHAIN (decl);
- BLOCK_CHAIN (decl) = prev;
- prev = decl;
- }
- return prev;
-}
-
-/* Count the subblocks of the list starting with BLOCK, and list them
- all into the vector VECTOR. Also clear TREE_ASM_WRITTEN in all
- blocks. */
-
-static int
-all_blocks (block, vector)
- tree block;
- tree *vector;
-{
- int n_blocks = 0;
-
- while (block)
- {
- TREE_ASM_WRITTEN (block) = 0;
-
- /* Record this block. */
- if (vector)
- vector[n_blocks] = block;
-
- ++n_blocks;
-
- /* Record the subblocks, and their subblocks... */
- n_blocks += all_blocks (BLOCK_SUBBLOCKS (block),
- vector ? vector + n_blocks : 0);
- block = BLOCK_CHAIN (block);
- }
-
- return n_blocks;
-}
-
-/* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
- and initialize static variables for generating RTL for the statements
- of the function. */
-
-void
-init_function_start (subr, filename, line)
- tree subr;
- char *filename;
- int line;
-{
- init_stmt_for_function ();
-
- cse_not_expected = ! optimize;
-
- /* Caller save not needed yet. */
- caller_save_needed = 0;
-
- /* No stack slots have been made yet. */
- stack_slot_list = 0;
-
- /* There is no stack slot for handling nonlocal gotos. */
- nonlocal_goto_handler_slots = 0;
- nonlocal_goto_stack_level = 0;
-
- /* No labels have been declared for nonlocal use. */
- nonlocal_labels = 0;
-
- /* No function calls so far in this function. */
- function_call_count = 0;
-
- /* No parm regs have been allocated.
- (This is important for output_inline_function.) */
- max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
-
- /* Initialize the RTL mechanism. */
- init_emit ();
-
- /* Initialize the queue of pending postincrement and postdecrements,
- and some other info in expr.c. */
- init_expr ();
-
- /* We haven't done register allocation yet. */
- reg_renumber = 0;
-
- init_const_rtx_hash_table ();
-
- current_function_name = (*decl_printable_name) (subr, 2);
-
- /* Nonzero if this is a nested function that uses a static chain. */
-
- current_function_needs_context
- = (decl_function_context (current_function_decl) != 0
- && ! DECL_NO_STATIC_CHAIN (current_function_decl));
-
- /* Set if a call to setjmp is seen. */
- current_function_calls_setjmp = 0;
-
- /* Set if a call to longjmp is seen. */
- current_function_calls_longjmp = 0;
-
- current_function_calls_alloca = 0;
- current_function_has_nonlocal_label = 0;
- current_function_has_nonlocal_goto = 0;
- current_function_contains_functions = 0;
- current_function_sp_is_unchanging = 0;
- current_function_is_thunk = 0;
-
- current_function_returns_pcc_struct = 0;
- current_function_returns_struct = 0;
- current_function_epilogue_delay_list = 0;
- current_function_uses_const_pool = 0;
- current_function_uses_pic_offset_table = 0;
- current_function_cannot_inline = 0;
- /* CYGNUS LOCAL -- Branch Prediction */
- current_function_uses_expect = 0;
- current_function_processing_expect = 0;
- /* END CYGNUS LOCAL -- Branch Prediction */
-
- /* We have not yet needed to make a label to jump to for tail-recursion. */
- tail_recursion_label = 0;
-
- /* We haven't had a need to make a save area for ap yet. */
-
- arg_pointer_save_area = 0;
-
- /* No stack slots allocated yet. */
- frame_offset = 0;
-
- /* No SAVE_EXPRs in this function yet. */
- save_expr_regs = 0;
-
- /* No RTL_EXPRs in this function yet. */
- rtl_expr_chain = 0;
-
- /* Set up to allocate temporaries. */
- init_temp_slots ();
-
- /* Within function body, compute a type's size as soon it is laid out. */
- immediate_size_expand++;
-
- /* We haven't made any trampolines for this function yet. */
- trampoline_list = 0;
-
- init_pending_stack_adjust ();
- inhibit_defer_pop = 0;
-
- current_function_outgoing_args_size = 0;
-
- /* Prevent ever trying to delete the first instruction of a function.
- Also tell final how to output a linenum before the function prologue.
- Note linenums could be missing, e.g. when compiling a Java .class file. */
- if (line > 0)
- emit_line_note (filename, line);
-
- /* Make sure first insn is a note even if we don't want linenums.
- This makes sure the first insn will never be deleted.
- Also, final expects a note to appear there. */
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
-
- /* Set flags used by final.c. */
- if (aggregate_value_p (DECL_RESULT (subr)))
- {
-#ifdef PCC_STATIC_STRUCT_RETURN
- current_function_returns_pcc_struct = 1;
-#endif
- current_function_returns_struct = 1;
- }
-
- /* Warn if this value is an aggregate type,
- regardless of which calling convention we are using for it. */
- if (warn_aggregate_return
- && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr))))
- warning ("function returns an aggregate");
-
- current_function_returns_pointer
- = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr)));
-
- /* Indicate that we need to distinguish between the return value of the
- present function and the return value of a function being called. */
- rtx_equal_function_value_matters = 1;
-
- /* Indicate that we have not instantiated virtual registers yet. */
- virtuals_instantiated = 0;
-
- /* Indicate we have no need of a frame pointer yet. */
- frame_pointer_needed = 0;
-
- /* By default assume not varargs or stdarg. */
- current_function_varargs = 0;
- current_function_stdarg = 0;
-}
-
-/* Indicate that the current function uses extra args
- not explicitly mentioned in the argument list in any fashion. */
-
-void
-mark_varargs ()
-{
- current_function_varargs = 1;
-}
-
-/* Expand a call to __main at the beginning of a possible main function. */
-
-#if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main)
-#undef HAS_INIT_SECTION
-#define HAS_INIT_SECTION
-#endif
-
-void
-expand_main_function ()
-{
-#if !defined (HAS_INIT_SECTION)
- emit_library_call (gen_rtx_SYMBOL_REF (Pmode, NAME__MAIN), 0,
- VOIDmode, 0);
-#endif /* not HAS_INIT_SECTION */
-}
-
-extern struct obstack permanent_obstack;
-
-/* Start the RTL for a new function, and set variables used for
- emitting RTL.
- SUBR is the FUNCTION_DECL node.
- PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
- the function's parameters, which must be run at any return statement. */
-
-void
-expand_function_start (subr, parms_have_cleanups)
- tree subr;
- int parms_have_cleanups;
-{
- register int i;
- tree tem;
- rtx last_ptr = NULL_RTX;
-
- /* Make sure volatile mem refs aren't considered
- valid operands of arithmetic insns. */
- init_recog_no_volatile ();
-
- /* Set this before generating any memory accesses. */
- current_function_check_memory_usage
- = (flag_check_memory_usage
- && ! DECL_NO_CHECK_MEMORY_USAGE (current_function_decl));
-
- current_function_instrument_entry_exit
- = (flag_instrument_function_entry_exit
- && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr));
-
- /* If function gets a static chain arg, store it in the stack frame.
- Do this first, so it gets the first stack slot offset. */
- if (current_function_needs_context)
- {
- last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
-
- /* Delay copying static chain if it is not a register to avoid
- conflicts with regs used for parameters. */
- if (! SMALL_REGISTER_CLASSES
- || GET_CODE (static_chain_incoming_rtx) == REG)
- emit_move_insn (last_ptr, static_chain_incoming_rtx);
- }
-
- /* If the parameters of this function need cleaning up, get a label
- for the beginning of the code which executes those cleanups. This must
- be done before doing anything with return_label. */
- if (parms_have_cleanups)
- cleanup_label = gen_label_rtx ();
- else
- cleanup_label = 0;
-
- /* Make the label for return statements to jump to, if this machine
- does not have a one-instruction return and uses an epilogue,
- or if it returns a structure, or if it has parm cleanups. */
-#ifdef HAVE_return
- if (cleanup_label == 0 && HAVE_return
- && ! current_function_instrument_entry_exit
- && ! current_function_returns_pcc_struct
- && ! (current_function_returns_struct && ! optimize))
- return_label = 0;
- else
- return_label = gen_label_rtx ();
-#else
- return_label = gen_label_rtx ();
-#endif
-
- /* Initialize rtx used to return the value. */
- /* Do this before assign_parms so that we copy the struct value address
- before any library calls that assign parms might generate. */
-
- /* Decide whether to return the value in memory or in a register. */
- if (aggregate_value_p (DECL_RESULT (subr)))
- {
- /* Returning something that won't go in a register. */
- register rtx value_address = 0;
-
-#ifdef PCC_STATIC_STRUCT_RETURN
- if (current_function_returns_pcc_struct)
- {
- int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
- value_address = assemble_static_space (size);
- }
- else
-#endif
- {
- /* Expect to be passed the address of a place to store the value.
- If it is passed as an argument, assign_parms will take care of
- it. */
- if (struct_value_incoming_rtx)
- {
- value_address = gen_reg_rtx (Pmode);
- emit_move_insn (value_address, struct_value_incoming_rtx);
- }
- }
- if (value_address)
- {
- DECL_RTL (DECL_RESULT (subr))
- = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address);
- MEM_SET_IN_STRUCT_P (DECL_RTL (DECL_RESULT (subr)),
- AGGREGATE_TYPE_P (TREE_TYPE
- (DECL_RESULT
- (subr))));
- }
- }
- else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
- /* If return mode is void, this decl rtl should not be used. */
- DECL_RTL (DECL_RESULT (subr)) = 0;
- else if (parms_have_cleanups || current_function_instrument_entry_exit)
- {
- /* If function will end with cleanup code for parms,
- compute the return values into a pseudo reg,
- which we will copy into the true return register
- after the cleanups are done. */
-
- enum machine_mode mode = DECL_MODE (DECL_RESULT (subr));
-
-#ifdef PROMOTE_FUNCTION_RETURN
- tree type = TREE_TYPE (DECL_RESULT (subr));
- int unsignedp = TREE_UNSIGNED (type);
-
- mode = promote_mode (type, mode, &unsignedp, 1);
-#endif
-
- DECL_RTL (DECL_RESULT (subr)) = gen_reg_rtx (mode);
- }
- else
- /* Scalar, returned in a register. */
- {
-#ifdef FUNCTION_OUTGOING_VALUE
- DECL_RTL (DECL_RESULT (subr))
- = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
-#else
- DECL_RTL (DECL_RESULT (subr))
- = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
-#endif
-
- /* Mark this reg as the function's return value. */
- if (GET_CODE (DECL_RTL (DECL_RESULT (subr))) == REG)
- {
- REG_FUNCTION_VALUE_P (DECL_RTL (DECL_RESULT (subr))) = 1;
- /* Needed because we may need to move this to memory
- in case it's a named return value whose address is taken. */
- DECL_REGISTER (DECL_RESULT (subr)) = 1;
- }
- }
-
- /* Initialize rtx for parameters and local variables.
- In some cases this requires emitting insns. */
-
- assign_parms (subr, 0);
-
- /* Copy the static chain now if it wasn't a register. The delay is to
- avoid conflicts with the parameter passing registers. */
-
- if (SMALL_REGISTER_CLASSES && current_function_needs_context)
- if (GET_CODE (static_chain_incoming_rtx) != REG)
- emit_move_insn (last_ptr, static_chain_incoming_rtx);
-
- /* The following was moved from init_function_start.
- The move is supposed to make sdb output more accurate. */
- /* Indicate the beginning of the function body,
- as opposed to parm setup. */
- emit_note (NULL_PTR, NOTE_INSN_FUNCTION_BEG);
-
- /* If doing stupid allocation, mark parms as born here. */
-
- if (GET_CODE (get_last_insn ()) != NOTE)
- emit_note (NULL_PTR, NOTE_INSN_DELETED);
- parm_birth_insn = get_last_insn ();
-
- if (obey_regdecls)
- {
- for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++)
- use_variable (regno_reg_rtx[i]);
-
- if (current_function_internal_arg_pointer != virtual_incoming_args_rtx)
- use_variable (current_function_internal_arg_pointer);
- }
-
- context_display = 0;
- if (current_function_needs_context)
- {
- /* Fetch static chain values for containing functions. */
- tem = decl_function_context (current_function_decl);
- /* If not doing stupid register allocation copy the static chain
- pointer into a pseudo. If we have small register classes, copy
- the value from memory if static_chain_incoming_rtx is a REG. If
- we do stupid register allocation, we use the stack address
- generated above. */
- if (tem && ! obey_regdecls)
- {
- /* If the static chain originally came in a register, put it back
- there, then move it out in the next insn. The reason for
- this peculiar code is to satisfy function integration. */
- if (SMALL_REGISTER_CLASSES
- && GET_CODE (static_chain_incoming_rtx) == REG)
- emit_move_insn (static_chain_incoming_rtx, last_ptr);
- last_ptr = copy_to_reg (static_chain_incoming_rtx);
- }
-
- while (tem)
- {
- tree rtlexp = make_node (RTL_EXPR);
-
- RTL_EXPR_RTL (rtlexp) = last_ptr;
- context_display = tree_cons (tem, rtlexp, context_display);
- tem = decl_function_context (tem);
- if (tem == 0)
- break;
- /* Chain thru stack frames, assuming pointer to next lexical frame
- is found at the place we always store it. */
-#ifdef FRAME_GROWS_DOWNWARD
- last_ptr = plus_constant (last_ptr, - GET_MODE_SIZE (Pmode));
-#endif
- last_ptr = copy_to_reg (gen_rtx_MEM (Pmode,
- memory_address (Pmode, last_ptr)));
-
- /* If we are not optimizing, ensure that we know that this
- piece of context is live over the entire function. */
- if (! optimize)
- save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr,
- save_expr_regs);
- }
- }
-
- if (current_function_instrument_entry_exit)
- {
- rtx fun = DECL_RTL (current_function_decl);
- if (GET_CODE (fun) == MEM)
- fun = XEXP (fun, 0);
- else
- abort ();
- emit_library_call (profile_function_entry_libfunc, 0, VOIDmode, 2,
- fun, Pmode,
- expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
- 0,
- hard_frame_pointer_rtx),
- Pmode);
- }
-
- /* After the display initializations is where the tail-recursion label
- should go, if we end up needing one. Ensure we have a NOTE here
- since some things (like trampolines) get placed before this. */
- tail_recursion_reentry = emit_note (NULL_PTR, NOTE_INSN_DELETED);
-
- /* Evaluate now the sizes of any types declared among the arguments. */
- for (tem = nreverse (get_pending_sizes ()); tem; tem = TREE_CHAIN (tem))
- {
- expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode,
- EXPAND_MEMORY_USE_BAD);
- /* Flush the queue in case this parameter declaration has
- side-effects. */
- emit_queue ();
- }
-
- /* Make sure there is a line number after the function entry setup code. */
- force_next_line_note ();
-}
-
-/* Call DOIT for each hard register used as a return value from
- the current function. */
-
-static void
-diddle_return_value (doit, arg)
- void (*doit) PARAMS ((rtx, void *));
- void *arg;
-{
- rtx outgoing = current_function_return_rtx;
- int pcc;
-
- if (! outgoing)
- return;
-
- pcc = (current_function_returns_struct
- || current_function_returns_pcc_struct);
-
- if ((GET_CODE (outgoing) == REG
- && REGNO (outgoing) >= FIRST_PSEUDO_REGISTER)
- || pcc)
- {
- tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
-
- /* A PCC-style return returns a pointer to the memory in which
- the structure is stored. */
- if (pcc)
- type = build_pointer_type (type);
-
-#ifdef FUNCTION_OUTGOING_VALUE
- outgoing = FUNCTION_OUTGOING_VALUE (type, current_function_decl);
-#else
- outgoing = FUNCTION_VALUE (type, current_function_decl);
-#endif
- /* If this is a BLKmode structure being returned in registers, then use
- the mode computed in expand_return. */
- if (GET_MODE (outgoing) == BLKmode)
- PUT_MODE (outgoing, GET_MODE (current_function_return_rtx));
- REG_FUNCTION_VALUE_P (outgoing) = 1;
- }
-
- if (GET_CODE (outgoing) == REG)
- (*doit) (outgoing, arg);
- else if (GET_CODE (outgoing) == PARALLEL)
- {
- int i;
-
- for (i = 0; i < XVECLEN (outgoing, 0); i++)
- {
- rtx x = XEXP (XVECEXP (outgoing, 0, i), 0);
-
- if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
- (*doit) (x, arg);
- }
- }
-}
-
-static void
-do_use_return_reg (reg, arg)
- rtx reg;
- void *arg ATTRIBUTE_UNUSED;
-{
- emit_insn (gen_rtx_USE (VOIDmode, reg));
-}
-
-static void
-use_return_register ()
-{
- diddle_return_value (do_use_return_reg, NULL);
-}
-
-/* Generate RTL for the end of the current function.
- FILENAME and LINE are the current position in the source file.
-
- It is up to language-specific callers to do cleanups for parameters--
- or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */
-
-void
-expand_function_end (filename, line, end_bindings)
- char *filename;
- int line;
- int end_bindings;
-{
- register int i;
- tree link;
-
-#ifdef TRAMPOLINE_TEMPLATE
- static rtx initial_trampoline;
-#endif
-
-#ifdef NON_SAVING_SETJMP
- /* Don't put any variables in registers if we call setjmp
- on a machine that fails to restore the registers. */
- if (NON_SAVING_SETJMP && current_function_calls_setjmp)
- {
- if (DECL_INITIAL (current_function_decl) != error_mark_node)
- setjmp_protect (DECL_INITIAL (current_function_decl));
-
- setjmp_protect_args ();
- }
-#endif
-
- /* Save the argument pointer if a save area was made for it. */
- if (arg_pointer_save_area)
- {
- /* arg_pointer_save_area may not be a valid memory address, so we
- have to check it and fix it if necessary. */
- rtx seq;
- start_sequence ();
- emit_move_insn (validize_mem (arg_pointer_save_area),
- virtual_incoming_args_rtx);
- seq = gen_sequence ();
- end_sequence ();
- emit_insn_before (seq, tail_recursion_reentry);
- }
-
- /* Initialize any trampolines required by this function. */
- for (link = trampoline_list; link; link = TREE_CHAIN (link))
- {
- tree function = TREE_PURPOSE (link);
- rtx context = lookup_static_chain (function);
- rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
-#ifdef TRAMPOLINE_TEMPLATE
- rtx blktramp;
-#endif
- rtx seq;
-
-#ifdef TRAMPOLINE_TEMPLATE
- /* First make sure this compilation has a template for
- initializing trampolines. */
- if (initial_trampoline == 0)
- {
- end_temporary_allocation ();
- initial_trampoline
- = gen_rtx_MEM (BLKmode, assemble_trampoline_template ());
- resume_temporary_allocation ();
- }
-#endif
-
- /* Generate insns to initialize the trampoline. */
- start_sequence ();
- tramp = round_trampoline_addr (XEXP (tramp, 0));
-#ifdef TRAMPOLINE_TEMPLATE
- blktramp = change_address (initial_trampoline, BLKmode, tramp);
- emit_block_move (blktramp, initial_trampoline,
- GEN_INT (TRAMPOLINE_SIZE),
- TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
-#endif
- INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context);
- seq = get_insns ();
- end_sequence ();
-
- /* Put those insns at entry to the containing function (this one). */
- emit_insns_before (seq, tail_recursion_reentry);
- }
-
- /* If we are doing stack checking and this function makes calls,
- do a stack probe at the start of the function to ensure we have enough
- space for another stack frame. */
- if (flag_stack_check && ! STACK_CHECK_BUILTIN)
- {
- rtx insn, seq;
-
- for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
- if (GET_CODE (insn) == CALL_INSN)
- {
- start_sequence ();
- probe_stack_range (STACK_CHECK_PROTECT,
- GEN_INT (STACK_CHECK_MAX_FRAME_SIZE));
- seq = get_insns ();
- end_sequence ();
- emit_insns_before (seq, tail_recursion_reentry);
- break;
- }
- }
-
- /* Warn about unused parms if extra warnings were specified. */
- if (warn_unused && extra_warnings)
- {
- tree decl;
-
- for (decl = DECL_ARGUMENTS (current_function_decl);
- decl; decl = TREE_CHAIN (decl))
- if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL
- && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
- warning_with_decl (decl, "unused parameter `%s'");
- }
-
- /* Delete handlers for nonlocal gotos if nothing uses them. */
- if (nonlocal_goto_handler_slots != 0
- && ! current_function_has_nonlocal_label)
- delete_handlers ();
-
- /* End any sequences that failed to be closed due to syntax errors. */
- while (in_sequence_p ())
- end_sequence ();
-
- /* Outside function body, can't compute type's actual size
- until next function's body starts. */
- immediate_size_expand--;
-
- /* If doing stupid register allocation,
- mark register parms as dying here. */
-
- if (obey_regdecls)
- {
- rtx tem;
- for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++)
- use_variable (regno_reg_rtx[i]);
-
- /* Likewise for the regs of all the SAVE_EXPRs in the function. */
-
- for (tem = save_expr_regs; tem; tem = XEXP (tem, 1))
- {
- use_variable (XEXP (tem, 0));
- use_variable_after (XEXP (tem, 0), parm_birth_insn);
- }
-
- if (current_function_internal_arg_pointer != virtual_incoming_args_rtx)
- use_variable (current_function_internal_arg_pointer);
- }
-
- clear_pending_stack_adjust ();
- do_pending_stack_adjust ();
-
- /* Mark the end of the function body.
- If control reaches this insn, the function can drop through
- without returning a value. */
- emit_note (NULL_PTR, NOTE_INSN_FUNCTION_END);
-
- /* Output a linenumber for the end of the function.
- SDB depends on this. */
- emit_line_note_force (filename, line);
-
- /* Output the label for the actual return from the function,
- if one is expected. This happens either because a function epilogue
- is used instead of a return instruction, or because a return was done
- with a goto in order to run local cleanups, or because of pcc-style
- structure returning. */
-
- if (return_label)
- emit_label (return_label);
-
- /* C++ uses this. */
- if (end_bindings)
- expand_end_bindings (0, 0, 0);
-
- /* Now handle any leftover exception regions that may have been
- created for the parameters. */
- {
- rtx last = get_last_insn ();
- rtx label;
-
- expand_leftover_cleanups ();
-
- /* If the above emitted any code, may sure we jump around it. */
- if (last != get_last_insn ())
- {
- label = gen_label_rtx ();
- last = emit_jump_insn_after (gen_jump (label), last);
- last = emit_barrier_after (last);
- emit_label (label);
- }
- }
-
- if (current_function_instrument_entry_exit)
- {
- rtx fun = DECL_RTL (current_function_decl);
- if (GET_CODE (fun) == MEM)
- fun = XEXP (fun, 0);
- else
- abort ();
- emit_library_call (profile_function_exit_libfunc, 0, VOIDmode, 2,
- fun, Pmode,
- expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
- 0,
- hard_frame_pointer_rtx),
- Pmode);
- }
-
- /* If we had calls to alloca, and this machine needs
- an accurate stack pointer to exit the function,
- insert some code to save and restore the stack pointer. */
-#ifdef EXIT_IGNORE_STACK
- if (! EXIT_IGNORE_STACK)
-#endif
- if (current_function_calls_alloca)
- {
- rtx tem = 0;
-
- emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
- emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
- }
-
- /* If scalar return value was computed in a pseudo-reg,
- copy that to the hard return register. */
- if (DECL_RTL (DECL_RESULT (current_function_decl)) != 0
- && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG
- && (REGNO (DECL_RTL (DECL_RESULT (current_function_decl)))
- >= FIRST_PSEUDO_REGISTER))
- {
- rtx real_decl_result;
-
-#ifdef FUNCTION_OUTGOING_VALUE
- real_decl_result
- = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)),
- current_function_decl);
-#else
- real_decl_result
- = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)),
- current_function_decl);
-#endif
- REG_FUNCTION_VALUE_P (real_decl_result) = 1;
- /* If this is a BLKmode structure being returned in registers, then use
- the mode computed in expand_return. */
- if (GET_MODE (real_decl_result) == BLKmode)
- PUT_MODE (real_decl_result,
- GET_MODE (DECL_RTL (DECL_RESULT (current_function_decl))));
- emit_move_insn (real_decl_result,
- DECL_RTL (DECL_RESULT (current_function_decl)));
- emit_insn (gen_rtx_USE (VOIDmode, real_decl_result));
-
- /* The delay slot scheduler assumes that current_function_return_rtx
- holds the hard register containing the return value, not a temporary
- pseudo. */
- current_function_return_rtx = real_decl_result;
- }
-
- /* If returning a structure, arrange to return the address of the value
- in a place where debuggers expect to find it.
-
- If returning a structure PCC style,
- the caller also depends on this value.
- And current_function_returns_pcc_struct is not necessarily set. */
- if (current_function_returns_struct
- || current_function_returns_pcc_struct)
- {
- rtx value_address = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
- tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
-#ifdef FUNCTION_OUTGOING_VALUE
- rtx outgoing
- = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
- current_function_decl);
-#else
- rtx outgoing
- = FUNCTION_VALUE (build_pointer_type (type),
- current_function_decl);
-#endif
-
- /* Mark this as a function return value so integrate will delete the
- assignment and USE below when inlining this function. */
- REG_FUNCTION_VALUE_P (outgoing) = 1;
-
- emit_move_insn (outgoing, value_address);
- use_variable (outgoing);
- }
-
- use_return_register ();
-
- /* If this is an implementation of __throw, do what's necessary to
- communicate between __builtin_eh_return and the epilogue. */
- expand_eh_return ();
-
- /* Output a return insn if we are using one.
- Otherwise, let the rtl chain end here, to drop through
- into the epilogue. */
-
-#ifdef HAVE_return
- if (HAVE_return)
- {
- emit_jump_insn (gen_return ());
- emit_barrier ();
- }
-#endif
-
- /* Fix up any gotos that jumped out to the outermost
- binding level of the function.
- Must follow emitting RETURN_LABEL. */
-
- /* If you have any cleanups to do at this point,
- and they need to create temporary variables,
- then you will lose. */
- expand_fixups (get_insns ());
-}
-
-/* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
-
-static int *prologue;
-static int *epilogue;
-
-/* Create an array that records the INSN_UIDs of INSNS (either a sequence
- or a single insn). */
-
-#if defined (HAVE_prologue) || defined (HAVE_epilogue)
-static int *
-record_insns (insns)
- rtx insns;
-{
- int *vec;
-
- if (GET_CODE (insns) == SEQUENCE)
- {
- int len = XVECLEN (insns, 0);
- vec = (int *) oballoc ((len + 1) * sizeof (int));
- vec[len] = 0;
- while (--len >= 0)
- vec[len] = INSN_UID (XVECEXP (insns, 0, len));
- }
- else
- {
- vec = (int *) oballoc (2 * sizeof (int));
- vec[0] = INSN_UID (insns);
- vec[1] = 0;
- }
- return vec;
-}
-
-/* Determine how many INSN_UIDs in VEC are part of INSN. */
-
-static int
-contains (insn, vec)
- rtx insn;
- int *vec;
-{
- register int i, j;
-
- if (GET_CODE (insn) == INSN
- && GET_CODE (PATTERN (insn)) == SEQUENCE)
- {
- int count = 0;
- for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
- for (j = 0; vec[j]; j++)
- if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == vec[j])
- count++;
- return count;
- }
- else
- {
- for (j = 0; vec[j]; j++)
- if (INSN_UID (insn) == vec[j])
- return 1;
- }
- return 0;
-}
-#endif /* HAVE_prologue || HAVE_epilogue */
-
-/* Generate the prologue and epilogue RTL if the machine supports it. Thread
- this into place with notes indicating where the prologue ends and where
- the epilogue begins. Update the basic block information when possible. */
-
-void
-thread_prologue_and_epilogue_insns (f)
- rtx f ATTRIBUTE_UNUSED;
-{
-#ifdef HAVE_prologue
- if (HAVE_prologue)
- {
- rtx head, seq;
-
- /* The first insn (a NOTE_INSN_DELETED) is followed by zero or more
- prologue insns and a NOTE_INSN_PROLOGUE_END. */
- emit_note_after (NOTE_INSN_PROLOGUE_END, f);
- seq = gen_prologue ();
- head = emit_insn_after (seq, f);
-
- /* Include the new prologue insns in the first block. Ignore them
- if they form a basic block unto themselves. */
- if (x_basic_block_head && n_basic_blocks
- && GET_CODE (BLOCK_HEAD (0)) != CODE_LABEL)
- BLOCK_HEAD (0) = NEXT_INSN (f);
-
- /* Retain a map of the prologue insns. */
- prologue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : head);
- }
- else
-#endif
- prologue = 0;
-
-#ifdef HAVE_epilogue
- if (HAVE_epilogue)
- {
- rtx insn = get_last_insn ();
- rtx prev = prev_nonnote_insn (insn);
-
- /* If we end with a BARRIER, we don't need an epilogue. */
- if (! (prev && GET_CODE (prev) == BARRIER))
- {
- rtx tail, seq, tem;
- rtx first_use = 0;
- rtx last_use = 0;
-
- /* The last basic block ends with a NOTE_INSN_EPILOGUE_BEG, the
- epilogue insns, the USE insns at the end of a function,
- the jump insn that returns, and then a BARRIER. */
-
- /* Move the USE insns at the end of a function onto a list. */
- while (prev
- && GET_CODE (prev) == INSN
- && GET_CODE (PATTERN (prev)) == USE)
- {
- tem = prev;
- prev = prev_nonnote_insn (prev);
-
- NEXT_INSN (PREV_INSN (tem)) = NEXT_INSN (tem);
- PREV_INSN (NEXT_INSN (tem)) = PREV_INSN (tem);
- if (first_use)
- {
- NEXT_INSN (tem) = first_use;
- PREV_INSN (first_use) = tem;
- }
- first_use = tem;
- if (!last_use)
- last_use = tem;
- }
-
- emit_barrier_after (insn);
-
- seq = gen_epilogue ();
- tail = emit_jump_insn_after (seq, insn);
-
- /* Insert the USE insns immediately before the return insn, which
- must be the first instruction before the final barrier. */
- if (first_use)
- {
- tem = prev_nonnote_insn (get_last_insn ());
- NEXT_INSN (PREV_INSN (tem)) = first_use;
- PREV_INSN (first_use) = PREV_INSN (tem);
- PREV_INSN (tem) = last_use;
- NEXT_INSN (last_use) = tem;
- }
-
- emit_note_after (NOTE_INSN_EPILOGUE_BEG, insn);
-
- /* Include the new epilogue insns in the last block. Ignore
- them if they form a basic block unto themselves. */
- if (x_basic_block_end && n_basic_blocks
- && GET_CODE (BLOCK_END (n_basic_blocks - 1)) != JUMP_INSN)
- BLOCK_END (n_basic_blocks - 1) = tail;
-
- /* Retain a map of the epilogue insns. */
- epilogue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : tail);
- return;
- }
- }
-#endif
- epilogue = 0;
-}
-
-/* Reposition the prologue-end and epilogue-begin notes after instruction
- scheduling and delayed branch scheduling. */
-
-void
-reposition_prologue_and_epilogue_notes (f)
- rtx f ATTRIBUTE_UNUSED;
-{
-#if defined (HAVE_prologue) || defined (HAVE_epilogue)
- /* Reposition the prologue and epilogue notes. */
- if (n_basic_blocks)
- {
- int len;
-
- if (prologue)
- {
- register rtx insn, note = 0;
-
- /* Scan from the beginning until we reach the last prologue insn.
- We apparently can't depend on basic_block_{head,end} after
- reorg has run. */
- for (len = 0; prologue[len]; len++)
- ;
- for (insn = f; len && insn; insn = NEXT_INSN (insn))
- {
- if (GET_CODE (insn) == NOTE)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
- note = insn;
- }
- else if ((len -= contains (insn, prologue)) == 0)
- {
- rtx next;
- /* Find the prologue-end note if we haven't already, and
- move it to just after the last prologue insn. */
- if (note == 0)
- {
- for (note = insn; (note = NEXT_INSN (note));)
- if (GET_CODE (note) == NOTE
- && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
- break;
- }
-
- next = NEXT_INSN (note);
-
- /* Whether or not we can depend on BLOCK_HEAD,
- attempt to keep it up-to-date. */
- if (BLOCK_HEAD (0) == note)
- BLOCK_HEAD (0) = next;
-
- remove_insn (note);
- add_insn_after (note, insn);
- }
- }
- }
-
- if (epilogue)
- {
- register rtx insn, note = 0;
-
- /* Scan from the end until we reach the first epilogue insn.
- We apparently can't depend on basic_block_{head,end} after
- reorg has run. */
- for (len = 0; epilogue[len]; len++)
- ;
- for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn))
- {
- if (GET_CODE (insn) == NOTE)
- {
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
- note = insn;
- }
- else if ((len -= contains (insn, epilogue)) == 0)
- {
- /* Find the epilogue-begin note if we haven't already, and
- move it to just before the first epilogue insn. */
- if (note == 0)
- {
- for (note = insn; (note = PREV_INSN (note));)
- if (GET_CODE (note) == NOTE
- && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
- break;
- }
-
- /* Whether or not we can depend on BLOCK_HEAD,
- attempt to keep it up-to-date. */
- if (n_basic_blocks
- && BLOCK_HEAD (n_basic_blocks-1) == insn)
- BLOCK_HEAD (n_basic_blocks-1) = note;
-
- remove_insn (note);
- add_insn_before (note, insn);
- }
- }
- }
- }
-#endif /* HAVE_prologue or HAVE_epilogue */
-}
diff --git a/gcc/function_990206.c b/gcc/function_990206.c deleted file mode 100755 index 064ea3d..0000000 --- a/gcc/function_990206.c +++ /dev/null @@ -1,6578 +0,0 @@ -/* Expands front end tree to back end RTL for GNU C-Compiler - Copyright (C) 1987, 88, 89, 91-98, 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. */ - - -/* This file handles the generation of rtl code from tree structure - at the level of the function as a whole. - It creates the rtl expressions for parameters and auto variables - and has full responsibility for allocating stack slots. - - `expand_function_start' is called at the beginning of a function, - before the function body is parsed, and `expand_function_end' is - called after parsing the body. - - Call `assign_stack_local' to allocate a stack slot for a local variable. - This is usually done during the RTL generation for the function body, - but it can also be done in the reload pass when a pseudo-register does - not get a hard register. - - Call `put_var_into_stack' when you learn, belatedly, that a variable - previously given a pseudo-register must in fact go in the stack. - This function changes the DECL_RTL to be a stack slot instead of a reg - then scans all the RTL instructions so far generated to correct them. */ - -#include "config.h" -#include "system.h" -#include "rtl.h" -#include "tree.h" -#include "flags.h" -#include "except.h" -#include "function.h" -#include "insn-flags.h" -#include "expr.h" -#include "insn-codes.h" -#include "regs.h" -#include "hard-reg-set.h" -#include "insn-config.h" -#include "recog.h" -#include "output.h" -#include "basic-block.h" -#include "obstack.h" -#include "toplev.h" - -#if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY -#define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY -#endif - -#ifndef TRAMPOLINE_ALIGNMENT -#define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY -#endif - -/* Some systems use __main in a way incompatible with its use in gcc, in these - cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to - give the same symbol without quotes for an alternative entry point. You - must define both, or neither. */ -#ifndef NAME__MAIN -#define NAME__MAIN "__main" -#define SYMBOL__MAIN __main -#endif - -/* Round a value to the lowest integer less than it that is a multiple of - the required alignment. Avoid using division in case the value is - negative. Assume the alignment is a power of two. */ -#define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1)) - -/* Similar, but round to the next highest integer that meets the - alignment. */ -#define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1)) - -/* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp - during rtl generation. If they are different register numbers, this is - always true. It may also be true if - FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl - generation. See fix_lexical_addr for details. */ - -#if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM -#define NEED_SEPARATE_AP -#endif - -/* Number of bytes of args popped by function being compiled on its return. - Zero if no bytes are to be popped. - May affect compilation of return insn or of function epilogue. */ - -int current_function_pops_args; - -/* Nonzero if function being compiled needs to be given an address - where the value should be stored. */ - -int current_function_returns_struct; - -/* Nonzero if function being compiled needs to - return the address of where it has put a structure value. */ - -int current_function_returns_pcc_struct; - -/* Nonzero if function being compiled needs to be passed a static chain. */ - -int current_function_needs_context; - -/* Nonzero if function being compiled can call setjmp. */ - -int current_function_calls_setjmp; - -/* Nonzero if function being compiled can call longjmp. */ - -int current_function_calls_longjmp; - -/* Nonzero if function being compiled receives nonlocal gotos - from nested functions. */ - -int current_function_has_nonlocal_label; - -/* Nonzero if function being compiled has nonlocal gotos to parent - function. */ - -int current_function_has_nonlocal_goto; - -/* Nonzero if this function has a computed goto. - - It is computed during find_basic_blocks or during stupid life - analysis. */ - -int current_function_has_computed_jump; - -/* Nonzero if function being compiled contains nested functions. */ - -int current_function_contains_functions; - -/* Nonzero if function being compiled doesn't modify the stack pointer - (ignoring the prologue and epilogue). This is only valid after - life_analysis has run. */ - -int current_function_sp_is_unchanging; - -/* Nonzero if the current function is a thunk (a lightweight function that - just adjusts one of its arguments and forwards to another function), so - we should try to cut corners where we can. */ -int current_function_is_thunk; - -/* Nonzero if function being compiled can call alloca, - either as a subroutine or builtin. */ - -int current_function_calls_alloca; - -/* Nonzero if the current function returns a pointer type */ - -int current_function_returns_pointer; - -/* If some insns can be deferred to the delay slots of the epilogue, the - delay list for them is recorded here. */ - -rtx current_function_epilogue_delay_list; - -/* If function's args have a fixed size, this is that size, in bytes. - Otherwise, it is -1. - May affect compilation of return insn or of function epilogue. */ - -int current_function_args_size; - -/* # bytes the prologue should push and pretend that the caller pushed them. - The prologue must do this, but only if parms can be passed in registers. */ - -int current_function_pretend_args_size; - -/* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is - defined, the needed space is pushed by the prologue. */ - -int current_function_outgoing_args_size; - -/* This is the offset from the arg pointer to the place where the first - anonymous arg can be found, if there is one. */ - -rtx current_function_arg_offset_rtx; - -/* Nonzero if current function uses varargs.h or equivalent. - Zero for functions that use stdarg.h. */ - -int current_function_varargs; - -/* Nonzero if current function uses stdarg.h or equivalent. - Zero for functions that use varargs.h. */ - -int current_function_stdarg; - -/* Quantities of various kinds of registers - used for the current function's args. */ - -CUMULATIVE_ARGS current_function_args_info; - -/* Name of function now being compiled. */ - -char *current_function_name; - -/* If non-zero, an RTL expression for the location at which the current - function returns its result. If the current function returns its - result in a register, current_function_return_rtx will always be - the hard register containing the result. */ - -rtx current_function_return_rtx; - -/* Nonzero if the current function uses the constant pool. */ - -int current_function_uses_const_pool; - -/* Nonzero if the current function uses pic_offset_table_rtx. */ -int current_function_uses_pic_offset_table; - -/* The arg pointer hard register, or the pseudo into which it was copied. */ -rtx current_function_internal_arg_pointer; - -/* CYGNUS LOCAL -- Branch Prediction */ -/* The current function uses __builtin_expect for branch prediction. */ -int current_function_uses_expect; - -/* The current function is currently expanding the first argument to - __builtin_expect. */ -int current_function_processing_expect; -/* END CYGNUS LOCAL -- Branch Prediction */ - -/* Language-specific reason why the current function cannot be made inline. */ -char *current_function_cannot_inline; - -/* Nonzero if instrumentation calls for function entry and exit should be - generated. */ -int current_function_instrument_entry_exit; - -/* Nonzero if memory access checking be enabled in the current function. */ -int current_function_check_memory_usage; - -/* The FUNCTION_DECL for an inline function currently being expanded. */ -tree inline_function_decl; - -/* Number of function calls seen so far in current function. */ - -int function_call_count; - -/* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels - (labels to which there can be nonlocal gotos from nested functions) - in this function. */ - -tree nonlocal_labels; - -/* List (chain of EXPR_LIST) of stack slots that hold the current handlers - for nonlocal gotos. There is one for every nonlocal label in the function; - this list matches the one in nonlocal_labels. - Zero when function does not have nonlocal labels. */ - -rtx nonlocal_goto_handler_slots; - -/* RTX for stack slot that holds the stack pointer value to restore - for a nonlocal goto. - Zero when function does not have nonlocal labels. */ - -rtx nonlocal_goto_stack_level; - -/* Label that will go on parm cleanup code, if any. - Jumping to this label runs cleanup code for parameters, if - such code must be run. Following this code is the logical return label. */ - -rtx cleanup_label; - -/* Label that will go on function epilogue. - Jumping to this label serves as a "return" instruction - on machines which require execution of the epilogue on all returns. */ - -rtx return_label; - -/* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs. - So we can mark them all live at the end of the function, if nonopt. */ -rtx save_expr_regs; - -/* List (chain of EXPR_LISTs) of all stack slots in this function. - Made for the sake of unshare_all_rtl. */ -rtx stack_slot_list; - -/* Chain of all RTL_EXPRs that have insns in them. */ -tree rtl_expr_chain; - -/* Label to jump back to for tail recursion, or 0 if we have - not yet needed one for this function. */ -rtx tail_recursion_label; - -/* Place after which to insert the tail_recursion_label if we need one. */ -rtx tail_recursion_reentry; - -/* Location at which to save the argument pointer if it will need to be - referenced. There are two cases where this is done: if nonlocal gotos - exist, or if vars stored at an offset from the argument pointer will be - needed by inner routines. */ - -rtx arg_pointer_save_area; - -/* Offset to end of allocated area of stack frame. - If stack grows down, this is the address of the last stack slot allocated. - If stack grows up, this is the address for the next slot. */ -HOST_WIDE_INT frame_offset; - -/* List (chain of TREE_LISTs) of static chains for containing functions. - Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx - in an RTL_EXPR in the TREE_VALUE. */ -static tree context_display; - -/* List (chain of TREE_LISTs) of trampolines for nested functions. - The trampoline sets up the static chain and jumps to the function. - We supply the trampoline's address when the function's address is requested. - - Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx - in an RTL_EXPR in the TREE_VALUE. */ -static tree trampoline_list; - -/* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */ -static rtx parm_birth_insn; - -#if 0 -/* Nonzero if a stack slot has been generated whose address is not - actually valid. It means that the generated rtl must all be scanned - to detect and correct the invalid addresses where they occur. */ -static int invalid_stack_slot; -#endif - -/* Last insn of those whose job was to put parms into their nominal homes. */ -static rtx last_parm_insn; - -/* 1 + last pseudo register number possibly used for loading a copy - of a parameter of this function. */ -int max_parm_reg; - -/* Vector indexed by REGNO, containing location on stack in which - to put the parm which is nominally in pseudo register REGNO, - if we discover that that parm must go in the stack. The highest - element in this vector is one less than MAX_PARM_REG, above. */ -rtx *parm_reg_stack_loc; - -/* Nonzero once virtual register instantiation has been done. - assign_stack_local uses frame_pointer_rtx when this is nonzero. */ -static int virtuals_instantiated; - -/* These variables hold pointers to functions to - save and restore machine-specific data, - in push_function_context and pop_function_context. */ -void (*save_machine_status) PROTO((struct function *)); -void (*restore_machine_status) PROTO((struct function *)); - -/* Nonzero if we need to distinguish between the return value of this function - and the return value of a function called by this function. This helps - integrate.c */ - -extern int rtx_equal_function_value_matters; -extern tree sequence_rtl_expr; - -/* In order to evaluate some expressions, such as function calls returning - structures in memory, we need to temporarily allocate stack locations. - We record each allocated temporary in the following structure. - - Associated with each temporary slot is a nesting level. When we pop up - one level, all temporaries associated with the previous level are freed. - Normally, all temporaries are freed after the execution of the statement - in which they were created. However, if we are inside a ({...}) grouping, - the result may be in a temporary and hence must be preserved. If the - result could be in a temporary, we preserve it if we can determine which - one it is in. If we cannot determine which temporary may contain the - result, all temporaries are preserved. A temporary is preserved by - pretending it was allocated at the previous nesting level. - - Automatic variables are also assigned temporary slots, at the nesting - level where they are defined. They are marked a "kept" so that - free_temp_slots will not free them. */ - -struct temp_slot -{ - /* Points to next temporary slot. */ - struct temp_slot *next; - /* The rtx to used to reference the slot. */ - rtx slot; - /* The rtx used to represent the address if not the address of the - slot above. May be an EXPR_LIST if multiple addresses exist. */ - rtx address; - /* The size, in units, of the slot. */ - HOST_WIDE_INT size; - /* The value of `sequence_rtl_expr' when this temporary is allocated. */ - tree rtl_expr; - /* Non-zero if this temporary is currently in use. */ - char in_use; - /* Non-zero if this temporary has its address taken. */ - char addr_taken; - /* Nesting level at which this slot is being used. */ - int level; - /* Non-zero if this should survive a call to free_temp_slots. */ - int keep; - /* The offset of the slot from the frame_pointer, including extra space - for alignment. This info is for combine_temp_slots. */ - HOST_WIDE_INT base_offset; - /* The size of the slot, including extra space for alignment. This - info is for combine_temp_slots. */ - HOST_WIDE_INT full_size; -}; - -/* List of all temporaries allocated, both available and in use. */ - -struct temp_slot *temp_slots; - -/* Current nesting level for temporaries. */ - -int temp_slot_level; - -/* Current nesting level for variables in a block. */ - -int var_temp_slot_level; - -/* When temporaries are created by TARGET_EXPRs, they are created at - this level of temp_slot_level, so that they can remain allocated - until no longer needed. CLEANUP_POINT_EXPRs define the lifetime - of TARGET_EXPRs. */ -int target_temp_slot_level; - -/* This structure is used to record MEMs or pseudos used to replace VAR, any - SUBREGs of VAR, and any MEMs containing VAR as an address. We need to - maintain this list in case two operands of an insn were required to match; - in that case we must ensure we use the same replacement. */ - -struct fixup_replacement -{ - rtx old; - rtx new; - struct fixup_replacement *next; -}; - -/* Forward declarations. */ - -static rtx assign_outer_stack_local PROTO ((enum machine_mode, HOST_WIDE_INT, - int, struct function *)); -static struct temp_slot *find_temp_slot_from_address PROTO((rtx)); -static void put_reg_into_stack PROTO((struct function *, rtx, tree, - enum machine_mode, enum machine_mode, - int, int, int)); -static void fixup_var_refs PROTO((rtx, enum machine_mode, int)); -static struct fixup_replacement - *find_fixup_replacement PROTO((struct fixup_replacement **, rtx)); -static void fixup_var_refs_insns PROTO((rtx, enum machine_mode, int, - rtx, int)); -static void fixup_var_refs_1 PROTO((rtx, enum machine_mode, rtx *, rtx, - struct fixup_replacement **)); -static rtx fixup_memory_subreg PROTO((rtx, rtx, int)); -static rtx walk_fixup_memory_subreg PROTO((rtx, rtx, int)); -static rtx fixup_stack_1 PROTO((rtx, rtx)); -static void optimize_bit_field PROTO((rtx, rtx, rtx *)); -static void instantiate_decls PROTO((tree, int)); -static void instantiate_decls_1 PROTO((tree, int)); -static void instantiate_decl PROTO((rtx, int, int)); -static int instantiate_virtual_regs_1 PROTO((rtx *, rtx, int)); -static void delete_handlers PROTO((void)); -static void pad_to_arg_alignment PROTO((struct args_size *, int)); -#ifndef ARGS_GROW_DOWNWARD -static void pad_below PROTO((struct args_size *, enum machine_mode, - tree)); -#endif -#ifdef ARGS_GROW_DOWNWARD -static tree round_down PROTO((tree, int)); -#endif -static rtx round_trampoline_addr PROTO((rtx)); -static tree blocks_nreverse PROTO((tree)); -static int all_blocks PROTO((tree, tree *)); -#if defined (HAVE_prologue) || defined (HAVE_epilogue) -static int *record_insns PROTO((rtx)); -static int contains PROTO((rtx, int *)); -#endif /* HAVE_prologue || HAVE_epilogue */ -static void put_addressof_into_stack PROTO((rtx)); -static void purge_addressof_1 PROTO((rtx *, rtx, int, int)); - -/* Pointer to chain of `struct function' for containing functions. */ -struct function *outer_function_chain; - -/* Given a function decl for a containing function, - return the `struct function' for it. */ - -struct function * -find_function_data (decl) - tree decl; -{ - struct function *p; - - for (p = outer_function_chain; p; p = p->next) - if (p->decl == decl) - return p; - - abort (); -} - -/* Save the current context for compilation of a nested function. - This is called from language-specific code. - The caller is responsible for saving any language-specific status, - since this function knows only about language-independent variables. */ - -void -push_function_context_to (context) - tree context; -{ - struct function *p = (struct function *) xmalloc (sizeof (struct function)); - - p->next = outer_function_chain; - outer_function_chain = p; - - p->name = current_function_name; - p->decl = current_function_decl; - p->pops_args = current_function_pops_args; - p->returns_struct = current_function_returns_struct; - p->returns_pcc_struct = current_function_returns_pcc_struct; - p->returns_pointer = current_function_returns_pointer; - p->needs_context = current_function_needs_context; - p->calls_setjmp = current_function_calls_setjmp; - p->calls_longjmp = current_function_calls_longjmp; - p->calls_alloca = current_function_calls_alloca; - p->has_nonlocal_label = current_function_has_nonlocal_label; - p->has_nonlocal_goto = current_function_has_nonlocal_goto; - p->contains_functions = current_function_contains_functions; - p->is_thunk = current_function_is_thunk; - p->args_size = current_function_args_size; - p->pretend_args_size = current_function_pretend_args_size; - p->arg_offset_rtx = current_function_arg_offset_rtx; - p->varargs = current_function_varargs; - p->stdarg = current_function_stdarg; - p->uses_const_pool = current_function_uses_const_pool; - p->uses_pic_offset_table = current_function_uses_pic_offset_table; - p->internal_arg_pointer = current_function_internal_arg_pointer; - p->cannot_inline = current_function_cannot_inline; - p->max_parm_reg = max_parm_reg; - p->parm_reg_stack_loc = parm_reg_stack_loc; - p->outgoing_args_size = current_function_outgoing_args_size; - p->return_rtx = current_function_return_rtx; - p->nonlocal_goto_handler_slots = nonlocal_goto_handler_slots; - p->nonlocal_goto_stack_level = nonlocal_goto_stack_level; - p->nonlocal_labels = nonlocal_labels; - p->cleanup_label = cleanup_label; - p->return_label = return_label; - p->save_expr_regs = save_expr_regs; - p->stack_slot_list = stack_slot_list; - p->parm_birth_insn = parm_birth_insn; - p->frame_offset = frame_offset; - p->tail_recursion_label = tail_recursion_label; - p->tail_recursion_reentry = tail_recursion_reentry; - p->arg_pointer_save_area = arg_pointer_save_area; - p->rtl_expr_chain = rtl_expr_chain; - p->last_parm_insn = last_parm_insn; - p->context_display = context_display; - p->trampoline_list = trampoline_list; - p->function_call_count = function_call_count; - p->temp_slots = temp_slots; - p->temp_slot_level = temp_slot_level; - p->target_temp_slot_level = target_temp_slot_level; - p->var_temp_slot_level = var_temp_slot_level; - p->fixup_var_refs_queue = 0; - p->epilogue_delay_list = current_function_epilogue_delay_list; - p->args_info = current_function_args_info; - p->check_memory_usage = current_function_check_memory_usage; - p->instrument_entry_exit = current_function_instrument_entry_exit; - /* CYGNUS LOCAL -- Branch Prediction */ - p->uses_expect = current_function_uses_expect; - /* END CYGNUS LOCAL -- Branch Prediction */ - - save_tree_status (p, context); - save_storage_status (p); - save_emit_status (p); - save_expr_status (p); - save_stmt_status (p); - save_varasm_status (p, context); - if (save_machine_status) - (*save_machine_status) (p); -} - -void -push_function_context () -{ - push_function_context_to (current_function_decl); -} - -/* Restore the last saved context, at the end of a nested function. - This function is called from language-specific code. */ - -void -pop_function_context_from (context) - tree context; -{ - struct function *p = outer_function_chain; - struct var_refs_queue *queue; - - outer_function_chain = p->next; - - current_function_contains_functions - = p->contains_functions || p->inline_obstacks - || context == current_function_decl; - current_function_name = p->name; - current_function_decl = p->decl; - current_function_pops_args = p->pops_args; - current_function_returns_struct = p->returns_struct; - current_function_returns_pcc_struct = p->returns_pcc_struct; - current_function_returns_pointer = p->returns_pointer; - current_function_needs_context = p->needs_context; - current_function_calls_setjmp = p->calls_setjmp; - current_function_calls_longjmp = p->calls_longjmp; - current_function_calls_alloca = p->calls_alloca; - current_function_has_nonlocal_label = p->has_nonlocal_label; - current_function_has_nonlocal_goto = p->has_nonlocal_goto; - current_function_is_thunk = p->is_thunk; - current_function_args_size = p->args_size; - current_function_pretend_args_size = p->pretend_args_size; - current_function_arg_offset_rtx = p->arg_offset_rtx; - current_function_varargs = p->varargs; - current_function_stdarg = p->stdarg; - current_function_uses_const_pool = p->uses_const_pool; - current_function_uses_pic_offset_table = p->uses_pic_offset_table; - current_function_internal_arg_pointer = p->internal_arg_pointer; - current_function_cannot_inline = p->cannot_inline; - max_parm_reg = p->max_parm_reg; - parm_reg_stack_loc = p->parm_reg_stack_loc; - current_function_outgoing_args_size = p->outgoing_args_size; - current_function_return_rtx = p->return_rtx; - nonlocal_goto_handler_slots = p->nonlocal_goto_handler_slots; - nonlocal_goto_stack_level = p->nonlocal_goto_stack_level; - nonlocal_labels = p->nonlocal_labels; - cleanup_label = p->cleanup_label; - return_label = p->return_label; - save_expr_regs = p->save_expr_regs; - stack_slot_list = p->stack_slot_list; - parm_birth_insn = p->parm_birth_insn; - frame_offset = p->frame_offset; - tail_recursion_label = p->tail_recursion_label; - tail_recursion_reentry = p->tail_recursion_reentry; - arg_pointer_save_area = p->arg_pointer_save_area; - rtl_expr_chain = p->rtl_expr_chain; - last_parm_insn = p->last_parm_insn; - context_display = p->context_display; - trampoline_list = p->trampoline_list; - function_call_count = p->function_call_count; - temp_slots = p->temp_slots; - temp_slot_level = p->temp_slot_level; - target_temp_slot_level = p->target_temp_slot_level; - var_temp_slot_level = p->var_temp_slot_level; - current_function_epilogue_delay_list = p->epilogue_delay_list; - reg_renumber = 0; - current_function_args_info = p->args_info; - current_function_check_memory_usage = p->check_memory_usage; - current_function_instrument_entry_exit = p->instrument_entry_exit; - /* CYGNUS LOCAL -- Branch Prediction */ - current_function_uses_expect = p->uses_expect; - /* END CYGNUS LOCAL -- Branch Prediction */ - - restore_tree_status (p, context); - restore_storage_status (p); - restore_expr_status (p); - restore_emit_status (p); - restore_stmt_status (p); - restore_varasm_status (p); - - if (restore_machine_status) - (*restore_machine_status) (p); - - /* Finish doing put_var_into_stack for any of our variables - which became addressable during the nested function. */ - for (queue = p->fixup_var_refs_queue; queue; queue = queue->next) - fixup_var_refs (queue->modified, queue->promoted_mode, queue->unsignedp); - - free (p); - - /* Reset variables that have known state during rtx generation. */ - rtx_equal_function_value_matters = 1; - virtuals_instantiated = 0; -} - -void pop_function_context () -{ - pop_function_context_from (current_function_decl); -} - -/* Allocate fixed slots in the stack frame of the current function. */ - -/* Return size needed for stack frame based on slots so far allocated. - This size counts from zero. It is not rounded to PREFERRED_STACK_BOUNDARY; - the caller may have to do that. */ - -HOST_WIDE_INT -get_frame_size () -{ -#ifdef FRAME_GROWS_DOWNWARD - return -frame_offset; -#else - return frame_offset; -#endif -} - -/* Allocate a stack slot of SIZE bytes and return a MEM rtx for it - with machine mode MODE. - - ALIGN controls the amount of alignment for the address of the slot: - 0 means according to MODE, - -1 means use BIGGEST_ALIGNMENT and round size to multiple of that, - positive specifies alignment boundary in bits. - - We do not round to stack_boundary here. */ - -rtx -assign_stack_local (mode, size, align) - enum machine_mode mode; - HOST_WIDE_INT size; - int align; -{ - register rtx x, addr; - int bigend_correction = 0; - int alignment; - - if (align == 0) - { - alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; - if (mode == BLKmode) - alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; - } - else if (align == -1) - { - alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; - size = CEIL_ROUND (size, alignment); - } - else - alignment = align / BITS_PER_UNIT; - - /* Round frame offset to that alignment. - We must be careful here, since FRAME_OFFSET might be negative and - division with a negative dividend isn't as well defined as we might - like. So we instead assume that ALIGNMENT is a power of two and - use logical operations which are unambiguous. */ -#ifdef FRAME_GROWS_DOWNWARD - frame_offset = FLOOR_ROUND (frame_offset, alignment); -#else - frame_offset = CEIL_ROUND (frame_offset, alignment); -#endif - - /* On a big-endian machine, if we are allocating more space than we will use, - use the least significant bytes of those that are allocated. */ - if (BYTES_BIG_ENDIAN && mode != BLKmode) - bigend_correction = size - GET_MODE_SIZE (mode); - -#ifdef FRAME_GROWS_DOWNWARD - frame_offset -= size; -#endif - - /* If we have already instantiated virtual registers, return the actual - address relative to the frame pointer. */ - if (virtuals_instantiated) - addr = plus_constant (frame_pointer_rtx, - (frame_offset + bigend_correction - + STARTING_FRAME_OFFSET)); - else - addr = plus_constant (virtual_stack_vars_rtx, - frame_offset + bigend_correction); - -#ifndef FRAME_GROWS_DOWNWARD - frame_offset += size; -#endif - - x = gen_rtx_MEM (mode, addr); - - stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, x, stack_slot_list); - - return x; -} - -/* Assign a stack slot in a containing function. - First three arguments are same as in preceding function. - The last argument specifies the function to allocate in. */ - -static rtx -assign_outer_stack_local (mode, size, align, function) - enum machine_mode mode; - HOST_WIDE_INT size; - int align; - struct function *function; -{ - register rtx x, addr; - int bigend_correction = 0; - int alignment; - - /* Allocate in the memory associated with the function in whose frame - we are assigning. */ - push_obstacks (function->function_obstack, - function->function_maybepermanent_obstack); - - if (align == 0) - { - alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT; - if (mode == BLKmode) - alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; - } - else if (align == -1) - { - alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; - size = CEIL_ROUND (size, alignment); - } - else - alignment = align / BITS_PER_UNIT; - - /* Round frame offset to that alignment. */ -#ifdef FRAME_GROWS_DOWNWARD - function->frame_offset = FLOOR_ROUND (function->frame_offset, alignment); -#else - function->frame_offset = CEIL_ROUND (function->frame_offset, alignment); -#endif - - /* On a big-endian machine, if we are allocating more space than we will use, - use the least significant bytes of those that are allocated. */ - if (BYTES_BIG_ENDIAN && mode != BLKmode) - bigend_correction = size - GET_MODE_SIZE (mode); - -#ifdef FRAME_GROWS_DOWNWARD - function->frame_offset -= size; -#endif - addr = plus_constant (virtual_stack_vars_rtx, - function->frame_offset + bigend_correction); -#ifndef FRAME_GROWS_DOWNWARD - function->frame_offset += size; -#endif - - x = gen_rtx_MEM (mode, addr); - - function->stack_slot_list - = gen_rtx_EXPR_LIST (VOIDmode, x, function->stack_slot_list); - - pop_obstacks (); - - return x; -} - -/* Allocate a temporary stack slot and record it for possible later - reuse. - - MODE is the machine mode to be given to the returned rtx. - - SIZE is the size in units of the space required. We do no rounding here - since assign_stack_local will do any required rounding. - - KEEP is 1 if this slot is to be retained after a call to - free_temp_slots. Automatic variables for a block are allocated - with this flag. KEEP is 2 if we allocate a longer term temporary, - whose lifetime is controlled by CLEANUP_POINT_EXPRs. KEEP is 3 - if we are to allocate something at an inner level to be treated as - a variable in the block (e.g., a SAVE_EXPR). */ - -rtx -assign_stack_temp (mode, size, keep) - enum machine_mode mode; - HOST_WIDE_INT size; - int keep; -{ - struct temp_slot *p, *best_p = 0; - - /* If SIZE is -1 it means that somebody tried to allocate a temporary - of a variable size. */ - if (size == -1) - abort (); - - /* First try to find an available, already-allocated temporary that is the - exact size we require. */ - for (p = temp_slots; p; p = p->next) - if (p->size == size && GET_MODE (p->slot) == mode && ! p->in_use) - break; - - /* If we didn't find, one, try one that is larger than what we want. We - find the smallest such. */ - if (p == 0) - for (p = temp_slots; p; p = p->next) - if (p->size > size && GET_MODE (p->slot) == mode && ! p->in_use - && (best_p == 0 || best_p->size > p->size)) - best_p = p; - - /* Make our best, if any, the one to use. */ - if (best_p) - { - /* If there are enough aligned bytes left over, make them into a new - temp_slot so that the extra bytes don't get wasted. Do this only - for BLKmode slots, so that we can be sure of the alignment. */ - if (GET_MODE (best_p->slot) == BLKmode) - { - int alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT; - HOST_WIDE_INT rounded_size = CEIL_ROUND (size, alignment); - - if (best_p->size - rounded_size >= alignment) - { - p = (struct temp_slot *) oballoc (sizeof (struct temp_slot)); - p->in_use = p->addr_taken = 0; - p->size = best_p->size - rounded_size; - p->base_offset = best_p->base_offset + rounded_size; - p->full_size = best_p->full_size - rounded_size; - p->slot = gen_rtx_MEM (BLKmode, - plus_constant (XEXP (best_p->slot, 0), - rounded_size)); - p->address = 0; - p->rtl_expr = 0; - p->next = temp_slots; - temp_slots = p; - - stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, p->slot, - stack_slot_list); - - best_p->size = rounded_size; - best_p->full_size = rounded_size; - } - } - - p = best_p; - } - - /* If we still didn't find one, make a new temporary. */ - if (p == 0) - { - HOST_WIDE_INT frame_offset_old = frame_offset; - - p = (struct temp_slot *) oballoc (sizeof (struct temp_slot)); - - /* If the temp slot mode doesn't indicate the alignment, - use the largest possible, so no one will be disappointed. */ - p->slot = assign_stack_local (mode, size, mode == BLKmode ? -1 : 0); - - /* The following slot size computation is necessary because we don't - know the actual size of the temporary slot until assign_stack_local - has performed all the frame alignment and size rounding for the - requested temporary. Note that extra space added for alignment - can be either above or below this stack slot depending on which - way the frame grows. We include the extra space if and only if it - is above this slot. */ -#ifdef FRAME_GROWS_DOWNWARD - p->size = frame_offset_old - frame_offset; -#else - p->size = size; -#endif - - /* Now define the fields used by combine_temp_slots. */ -#ifdef FRAME_GROWS_DOWNWARD - p->base_offset = frame_offset; - p->full_size = frame_offset_old - frame_offset; -#else - p->base_offset = frame_offset_old; - p->full_size = frame_offset - frame_offset_old; -#endif - p->address = 0; - p->next = temp_slots; - temp_slots = p; - } - - p->in_use = 1; - p->addr_taken = 0; - p->rtl_expr = sequence_rtl_expr; - - if (keep == 2) - { - p->level = target_temp_slot_level; - p->keep = 0; - } - else if (keep == 3) - { - p->level = var_temp_slot_level; - p->keep = 0; - } - else - { - p->level = temp_slot_level; - p->keep = keep; - } - - /* We may be reusing an old slot, so clear any MEM flags that may have been - set from before. */ - RTX_UNCHANGING_P (p->slot) = 0; - MEM_IN_STRUCT_P (p->slot) = 0; - MEM_SCALAR_P (p->slot) = 0; - MEM_ALIAS_SET (p->slot) = 0; - return p->slot; -} - -/* Assign a temporary of given TYPE. - KEEP is as for assign_stack_temp. - MEMORY_REQUIRED is 1 if the result must be addressable stack memory; - it is 0 if a register is OK. - DONT_PROMOTE is 1 if we should not promote values in register - to wider modes. */ - -rtx -assign_temp (type, keep, memory_required, dont_promote) - tree type; - int keep; - int memory_required; - int dont_promote; -{ - enum machine_mode mode = TYPE_MODE (type); - int unsignedp = TREE_UNSIGNED (type); - - if (mode == BLKmode || memory_required) - { - HOST_WIDE_INT size = int_size_in_bytes (type); - rtx tmp; - - /* Unfortunately, we don't yet know how to allocate variable-sized - temporaries. However, sometimes we have a fixed upper limit on - the size (which is stored in TYPE_ARRAY_MAX_SIZE) and can use that - instead. This is the case for Chill variable-sized strings. */ - if (size == -1 && TREE_CODE (type) == ARRAY_TYPE - && TYPE_ARRAY_MAX_SIZE (type) != NULL_TREE - && TREE_CODE (TYPE_ARRAY_MAX_SIZE (type)) == INTEGER_CST) - size = TREE_INT_CST_LOW (TYPE_ARRAY_MAX_SIZE (type)); - - tmp = assign_stack_temp (mode, size, keep); - MEM_SET_IN_STRUCT_P (tmp, AGGREGATE_TYPE_P (type)); - return tmp; - } - -#ifndef PROMOTE_FOR_CALL_ONLY - if (! dont_promote) - mode = promote_mode (type, mode, &unsignedp, 0); -#endif - - return gen_reg_rtx (mode); -} - -/* Combine temporary stack slots which are adjacent on the stack. - - This allows for better use of already allocated stack space. This is only - done for BLKmode slots because we can be sure that we won't have alignment - problems in this case. */ - -void -combine_temp_slots () -{ - struct temp_slot *p, *q; - struct temp_slot *prev_p, *prev_q; - int num_slots; - - /* If there are a lot of temp slots, don't do anything unless - high levels of optimizaton. */ - if (! flag_expensive_optimizations) - for (p = temp_slots, num_slots = 0; p; p = p->next, num_slots++) - if (num_slots > 100 || (num_slots > 10 && optimize == 0)) - return; - - for (p = temp_slots, prev_p = 0; p; p = prev_p ? prev_p->next : temp_slots) - { - int delete_p = 0; - - if (! p->in_use && GET_MODE (p->slot) == BLKmode) - for (q = p->next, prev_q = p; q; q = prev_q->next) - { - int delete_q = 0; - if (! q->in_use && GET_MODE (q->slot) == BLKmode) - { - if (p->base_offset + p->full_size == q->base_offset) - { - /* Q comes after P; combine Q into P. */ - p->size += q->size; - p->full_size += q->full_size; - delete_q = 1; - } - else if (q->base_offset + q->full_size == p->base_offset) - { - /* P comes after Q; combine P into Q. */ - q->size += p->size; - q->full_size += p->full_size; - delete_p = 1; - break; - } - } - /* Either delete Q or advance past it. */ - if (delete_q) - prev_q->next = q->next; - else - prev_q = q; - } - /* Either delete P or advance past it. */ - if (delete_p) - { - if (prev_p) - prev_p->next = p->next; - else - temp_slots = p->next; - } - else - prev_p = p; - } -} - -/* Find the temp slot corresponding to the object at address X. */ - -static struct temp_slot * -find_temp_slot_from_address (x) - rtx x; -{ - struct temp_slot *p; - rtx next; - - for (p = temp_slots; p; p = p->next) - { - if (! p->in_use) - continue; - - else if (XEXP (p->slot, 0) == x - || p->address == x - || (GET_CODE (x) == PLUS - && XEXP (x, 0) == virtual_stack_vars_rtx - && GET_CODE (XEXP (x, 1)) == CONST_INT - && INTVAL (XEXP (x, 1)) >= p->base_offset - && INTVAL (XEXP (x, 1)) < p->base_offset + p->full_size)) - return p; - - else if (p->address != 0 && GET_CODE (p->address) == EXPR_LIST) - for (next = p->address; next; next = XEXP (next, 1)) - if (XEXP (next, 0) == x) - return p; - } - - return 0; -} - -/* Indicate that NEW is an alternate way of referring to the temp slot - that previously was known by OLD. */ - -void -update_temp_slot_address (old, new) - rtx old, new; -{ - struct temp_slot *p = find_temp_slot_from_address (old); - - /* If none, return. Else add NEW as an alias. */ - if (p == 0) - return; - else if (p->address == 0) - p->address = new; - else - { - if (GET_CODE (p->address) != EXPR_LIST) - p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); - - p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); - } -} - -/* If X could be a reference to a temporary slot, mark the fact that its - address was taken. */ - -void -mark_temp_addr_taken (x) - rtx x; -{ - struct temp_slot *p; - - if (x == 0) - return; - - /* If X is not in memory or is at a constant address, it cannot be in - a temporary slot. */ - if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) - return; - - p = find_temp_slot_from_address (XEXP (x, 0)); - if (p != 0) - p->addr_taken = 1; -} - -/* If X could be a reference to a temporary slot, mark that slot as - belonging to the to one level higher than the current level. If X - matched one of our slots, just mark that one. Otherwise, we can't - easily predict which it is, so upgrade all of them. Kept slots - need not be touched. - - This is called when an ({...}) construct occurs and a statement - returns a value in memory. */ - -void -preserve_temp_slots (x) - rtx x; -{ - struct temp_slot *p = 0; - - /* If there is no result, we still might have some objects whose address - were taken, so we need to make sure they stay around. */ - if (x == 0) - { - for (p = temp_slots; p; p = p->next) - if (p->in_use && p->level == temp_slot_level && p->addr_taken) - p->level--; - - return; - } - - /* If X is a register that is being used as a pointer, see if we have - a temporary slot we know it points to. To be consistent with - the code below, we really should preserve all non-kept slots - if we can't find a match, but that seems to be much too costly. */ - if (GET_CODE (x) == REG && REGNO_POINTER_FLAG (REGNO (x))) - p = find_temp_slot_from_address (x); - - /* If X is not in memory or is at a constant address, it cannot be in - a temporary slot, but it can contain something whose address was - taken. */ - if (p == 0 && (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))) - { - for (p = temp_slots; p; p = p->next) - if (p->in_use && p->level == temp_slot_level && p->addr_taken) - p->level--; - - return; - } - - /* First see if we can find a match. */ - if (p == 0) - p = find_temp_slot_from_address (XEXP (x, 0)); - - if (p != 0) - { - /* Move everything at our level whose address was taken to our new - level in case we used its address. */ - struct temp_slot *q; - - if (p->level == temp_slot_level) - { - for (q = temp_slots; q; q = q->next) - if (q != p && q->addr_taken && q->level == p->level) - q->level--; - - p->level--; - p->addr_taken = 0; - } - return; - } - - /* Otherwise, preserve all non-kept slots at this level. */ - for (p = temp_slots; p; p = p->next) - if (p->in_use && p->level == temp_slot_level && ! p->keep) - p->level--; -} - -/* X is the result of an RTL_EXPR. If it is a temporary slot associated - with that RTL_EXPR, promote it into a temporary slot at the present - level so it will not be freed when we free slots made in the - RTL_EXPR. */ - -void -preserve_rtl_expr_result (x) - rtx x; -{ - struct temp_slot *p; - - /* If X is not in memory or is at a constant address, it cannot be in - a temporary slot. */ - if (x == 0 || GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) - return; - - /* If we can find a match, move it to our level unless it is already at - an upper level. */ - p = find_temp_slot_from_address (XEXP (x, 0)); - if (p != 0) - { - p->level = MIN (p->level, temp_slot_level); - p->rtl_expr = 0; - } - - return; -} - -/* Free all temporaries used so far. This is normally called at the end - of generating code for a statement. Don't free any temporaries - currently in use for an RTL_EXPR that hasn't yet been emitted. - We could eventually do better than this since it can be reused while - generating the same RTL_EXPR, but this is complex and probably not - worthwhile. */ - -void -free_temp_slots () -{ - struct temp_slot *p; - - for (p = temp_slots; p; p = p->next) - if (p->in_use && p->level == temp_slot_level && ! p->keep - && p->rtl_expr == 0) - p->in_use = 0; - - combine_temp_slots (); -} - -/* Free all temporary slots used in T, an RTL_EXPR node. */ - -void -free_temps_for_rtl_expr (t) - tree t; -{ - struct temp_slot *p; - - for (p = temp_slots; p; p = p->next) - if (p->rtl_expr == t) - p->in_use = 0; - - combine_temp_slots (); -} - -/* Mark all temporaries ever allocated in this function as not suitable - for reuse until the current level is exited. */ - -void -mark_all_temps_used () -{ - struct temp_slot *p; - - for (p = temp_slots; p; p = p->next) - { - p->in_use = p->keep = 1; - p->level = MIN (p->level, temp_slot_level); - } -} - -/* Push deeper into the nesting level for stack temporaries. */ - -void -push_temp_slots () -{ - temp_slot_level++; -} - -/* Likewise, but save the new level as the place to allocate variables - for blocks. */ - -void -push_temp_slots_for_block () -{ - push_temp_slots (); - - var_temp_slot_level = temp_slot_level; -} - -/* Likewise, but save the new level as the place to allocate temporaries - for TARGET_EXPRs. */ - -void -push_temp_slots_for_target () -{ - push_temp_slots (); - - target_temp_slot_level = temp_slot_level; -} - -/* Set and get the value of target_temp_slot_level. The only - permitted use of these functions is to save and restore this value. */ - -int -get_target_temp_slot_level () -{ - return target_temp_slot_level; -} - -void -set_target_temp_slot_level (level) - int level; -{ - target_temp_slot_level = level; -} - -/* Pop a temporary nesting level. All slots in use in the current level - are freed. */ - -void -pop_temp_slots () -{ - struct temp_slot *p; - - for (p = temp_slots; p; p = p->next) - if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0) - p->in_use = 0; - - combine_temp_slots (); - - temp_slot_level--; -} - -/* Initialize temporary slots. */ - -void -init_temp_slots () -{ - /* We have not allocated any temporaries yet. */ - temp_slots = 0; - temp_slot_level = 0; - var_temp_slot_level = 0; - target_temp_slot_level = 0; -} - -/* Retroactively move an auto variable from a register to a stack slot. - This is done when an address-reference to the variable is seen. */ - -void -put_var_into_stack (decl) - tree decl; -{ - register rtx reg; - enum machine_mode promoted_mode, decl_mode; - struct function *function = 0; - tree context; - int can_use_addressof; - - context = decl_function_context (decl); - - /* Get the current rtl used for this object and its original mode. */ - reg = TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl) : DECL_RTL (decl); - - /* No need to do anything if decl has no rtx yet - since in that case caller is setting TREE_ADDRESSABLE - and a stack slot will be assigned when the rtl is made. */ - if (reg == 0) - return; - - /* Get the declared mode for this object. */ - decl_mode = (TREE_CODE (decl) == SAVE_EXPR ? TYPE_MODE (TREE_TYPE (decl)) - : DECL_MODE (decl)); - /* Get the mode it's actually stored in. */ - promoted_mode = GET_MODE (reg); - - /* If this variable comes from an outer function, - find that function's saved context. */ - if (context != current_function_decl && context != inline_function_decl) - for (function = outer_function_chain; function; function = function->next) - if (function->decl == context) - break; - - /* If this is a variable-size object with a pseudo to address it, - put that pseudo into the stack, if the var is nonlocal. */ - if (DECL_NONLOCAL (decl) - && GET_CODE (reg) == MEM - && GET_CODE (XEXP (reg, 0)) == REG - && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER) - { - reg = XEXP (reg, 0); - decl_mode = promoted_mode = GET_MODE (reg); - } - - can_use_addressof - = (function == 0 - && optimize > 0 - /* FIXME make it work for promoted modes too */ - && decl_mode == promoted_mode -#ifdef NON_SAVING_SETJMP - && ! (NON_SAVING_SETJMP && current_function_calls_setjmp) -#endif - ); - - /* If we can't use ADDRESSOF, make sure we see through one we already - generated. */ - if (! can_use_addressof && GET_CODE (reg) == MEM - && GET_CODE (XEXP (reg, 0)) == ADDRESSOF) - reg = XEXP (XEXP (reg, 0), 0); - - /* Now we should have a value that resides in one or more pseudo regs. */ - - if (GET_CODE (reg) == REG) - { - /* If this variable lives in the current function and we don't need - to put things in the stack for the sake of setjmp, try to keep it - in a register until we know we actually need the address. */ - if (can_use_addressof) - gen_mem_addressof (reg, decl); - else - put_reg_into_stack (function, reg, TREE_TYPE (decl), - promoted_mode, decl_mode, - TREE_SIDE_EFFECTS (decl), 0, - TREE_USED (decl) - || DECL_INITIAL (decl) != 0); - } - else if (GET_CODE (reg) == CONCAT) - { - /* A CONCAT contains two pseudos; put them both in the stack. - We do it so they end up consecutive. */ - enum machine_mode part_mode = GET_MODE (XEXP (reg, 0)); - tree part_type = TREE_TYPE (TREE_TYPE (decl)); -#ifdef FRAME_GROWS_DOWNWARD - /* Since part 0 should have a lower address, do it second. */ - put_reg_into_stack (function, XEXP (reg, 1), part_type, part_mode, - part_mode, TREE_SIDE_EFFECTS (decl), 0, - TREE_USED (decl) || DECL_INITIAL (decl) != 0); - put_reg_into_stack (function, XEXP (reg, 0), part_type, part_mode, - part_mode, TREE_SIDE_EFFECTS (decl), 0, - TREE_USED (decl) || DECL_INITIAL (decl) != 0); -#else - put_reg_into_stack (function, XEXP (reg, 0), part_type, part_mode, - part_mode, TREE_SIDE_EFFECTS (decl), 0, - TREE_USED (decl) || DECL_INITIAL (decl) != 0); - put_reg_into_stack (function, XEXP (reg, 1), part_type, part_mode, - part_mode, TREE_SIDE_EFFECTS (decl), 0, - TREE_USED (decl) || DECL_INITIAL (decl) != 0); -#endif - - /* Change the CONCAT into a combined MEM for both parts. */ - PUT_CODE (reg, MEM); - MEM_VOLATILE_P (reg) = MEM_VOLATILE_P (XEXP (reg, 0)); - MEM_ALIAS_SET (reg) = get_alias_set (decl); - - /* The two parts are in memory order already. - Use the lower parts address as ours. */ - XEXP (reg, 0) = XEXP (XEXP (reg, 0), 0); - /* Prevent sharing of rtl that might lose. */ - if (GET_CODE (XEXP (reg, 0)) == PLUS) - XEXP (reg, 0) = copy_rtx (XEXP (reg, 0)); - } - else - return; - - if (current_function_check_memory_usage) - emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, - XEXP (reg, 0), ptr_mode, - GEN_INT (GET_MODE_SIZE (GET_MODE (reg))), - TYPE_MODE (sizetype), - GEN_INT (MEMORY_USE_RW), - TYPE_MODE (integer_type_node)); -} - -/* Subroutine of put_var_into_stack. This puts a single pseudo reg REG - into the stack frame of FUNCTION (0 means the current function). - DECL_MODE is the machine mode of the user-level data type. - PROMOTED_MODE is the machine mode of the register. - VOLATILE_P is nonzero if this is for a "volatile" decl. - USED_P is nonzero if this reg might have already been used in an insn. */ - -static void -put_reg_into_stack (function, reg, type, promoted_mode, decl_mode, volatile_p, - original_regno, used_p) - struct function *function; - rtx reg; - tree type; - enum machine_mode promoted_mode, decl_mode; - int volatile_p; - int original_regno; - int used_p; -{ - rtx new = 0; - int regno = original_regno; - - if (regno == 0) - regno = REGNO (reg); - - if (function) - { - if (regno < function->max_parm_reg) - new = function->parm_reg_stack_loc[regno]; - if (new == 0) - new = assign_outer_stack_local (decl_mode, GET_MODE_SIZE (decl_mode), - 0, function); - } - else - { - if (regno < max_parm_reg) - new = parm_reg_stack_loc[regno]; - if (new == 0) - new = assign_stack_local (decl_mode, GET_MODE_SIZE (decl_mode), 0); - } - - PUT_MODE (reg, decl_mode); - XEXP (reg, 0) = XEXP (new, 0); - /* `volatil' bit means one thing for MEMs, another entirely for REGs. */ - MEM_VOLATILE_P (reg) = volatile_p; - PUT_CODE (reg, MEM); - - /* If this is a memory ref that contains aggregate components, - mark it as such for cse and loop optimize. If we are reusing a - previously generated stack slot, then we need to copy the bit in - case it was set for other reasons. For instance, it is set for - __builtin_va_alist. */ - MEM_SET_IN_STRUCT_P (reg, - AGGREGATE_TYPE_P (type) || MEM_IN_STRUCT_P (new)); - MEM_ALIAS_SET (reg) = get_alias_set (type); - - /* Now make sure that all refs to the variable, previously made - when it was a register, are fixed up to be valid again. */ - - if (used_p && function != 0) - { - struct var_refs_queue *temp; - - /* Variable is inherited; fix it up when we get back to its function. */ - push_obstacks (function->function_obstack, - function->function_maybepermanent_obstack); - - /* See comment in restore_tree_status in tree.c for why this needs to be - on saveable obstack. */ - temp - = (struct var_refs_queue *) savealloc (sizeof (struct var_refs_queue)); - temp->modified = reg; - temp->promoted_mode = promoted_mode; - temp->unsignedp = TREE_UNSIGNED (type); - temp->next = function->fixup_var_refs_queue; - function->fixup_var_refs_queue = temp; - pop_obstacks (); - } - else if (used_p) - /* Variable is local; fix it up now. */ - fixup_var_refs (reg, promoted_mode, TREE_UNSIGNED (type)); -} - -static void -fixup_var_refs (var, promoted_mode, unsignedp) - rtx var; - enum machine_mode promoted_mode; - int unsignedp; -{ - tree pending; - rtx first_insn = get_insns (); - struct sequence_stack *stack = sequence_stack; - tree rtl_exps = rtl_expr_chain; - - /* Must scan all insns for stack-refs that exceed the limit. */ - fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn, stack == 0); - - /* Scan all pending sequences too. */ - for (; stack; stack = stack->next) - { - push_to_sequence (stack->first); - fixup_var_refs_insns (var, promoted_mode, unsignedp, - stack->first, stack->next != 0); - /* Update remembered end of sequence - in case we added an insn at the end. */ - stack->last = get_last_insn (); - end_sequence (); - } - - /* Scan all waiting RTL_EXPRs too. */ - for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending)) - { - rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending)); - if (seq != const0_rtx && seq != 0) - { - push_to_sequence (seq); - fixup_var_refs_insns (var, promoted_mode, unsignedp, seq, 0); - end_sequence (); - } - } - - /* Scan the catch clauses for exception handling too. */ - push_to_sequence (catch_clauses); - fixup_var_refs_insns (var, promoted_mode, unsignedp, catch_clauses, 0); - end_sequence (); -} - -/* REPLACEMENTS is a pointer to a list of the struct fixup_replacement and X is - some part of an insn. Return a struct fixup_replacement whose OLD - value is equal to X. Allocate a new structure if no such entry exists. */ - -static struct fixup_replacement * -find_fixup_replacement (replacements, x) - struct fixup_replacement **replacements; - rtx x; -{ - struct fixup_replacement *p; - - /* See if we have already replaced this. */ - for (p = *replacements; p && p->old != x; p = p->next) - ; - - if (p == 0) - { - p = (struct fixup_replacement *) oballoc (sizeof (struct fixup_replacement)); - p->old = x; - p->new = 0; - p->next = *replacements; - *replacements = p; - } - - return p; -} - -/* Scan the insn-chain starting with INSN for refs to VAR - and fix them up. TOPLEVEL is nonzero if this chain is the - main chain of insns for the current function. */ - -static void -fixup_var_refs_insns (var, promoted_mode, unsignedp, insn, toplevel) - rtx var; - enum machine_mode promoted_mode; - int unsignedp; - rtx insn; - int toplevel; -{ - rtx call_dest = 0; - - while (insn) - { - rtx next = NEXT_INSN (insn); - rtx set, prev, prev_set; - rtx note; - - if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') - { - /* If this is a CLOBBER of VAR, delete it. - - If it has a REG_LIBCALL note, delete the REG_LIBCALL - and REG_RETVAL notes too. */ - if (GET_CODE (PATTERN (insn)) == CLOBBER - && (XEXP (PATTERN (insn), 0) == var - || (GET_CODE (XEXP (PATTERN (insn), 0)) == CONCAT - && (XEXP (XEXP (PATTERN (insn), 0), 0) == var - || XEXP (XEXP (PATTERN (insn), 0), 1) == var)))) - { - if ((note = find_reg_note (insn, REG_LIBCALL, NULL_RTX)) != 0) - /* The REG_LIBCALL note will go away since we are going to - turn INSN into a NOTE, so just delete the - corresponding REG_RETVAL note. */ - remove_note (XEXP (note, 0), - find_reg_note (XEXP (note, 0), REG_RETVAL, - NULL_RTX)); - - /* In unoptimized compilation, we shouldn't call delete_insn - except in jump.c doing warnings. */ - PUT_CODE (insn, NOTE); - NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; - NOTE_SOURCE_FILE (insn) = 0; - } - - /* The insn to load VAR from a home in the arglist - is now a no-op. When we see it, just delete it. - Similarly if this is storing VAR from a register from which - it was loaded in the previous insn. This will occur - when an ADDRESSOF was made for an arglist slot. */ - else if (toplevel - && (set = single_set (insn)) != 0 - && SET_DEST (set) == var - /* If this represents the result of an insn group, - don't delete the insn. */ - && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0 - && (rtx_equal_p (SET_SRC (set), var) - || (GET_CODE (SET_SRC (set)) == REG - && (prev = prev_nonnote_insn (insn)) != 0 - && (prev_set = single_set (prev)) != 0 - && SET_DEST (prev_set) == SET_SRC (set) - && rtx_equal_p (SET_SRC (prev_set), var)))) - { - /* In unoptimized compilation, we shouldn't call delete_insn - except in jump.c doing warnings. */ - PUT_CODE (insn, NOTE); - NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; - NOTE_SOURCE_FILE (insn) = 0; - if (insn == last_parm_insn) - last_parm_insn = PREV_INSN (next); - } - else - { - struct fixup_replacement *replacements = 0; - rtx next_insn = NEXT_INSN (insn); - - if (SMALL_REGISTER_CLASSES) - { - /* If the insn that copies the results of a CALL_INSN - into a pseudo now references VAR, we have to use an - intermediate pseudo since we want the life of the - return value register to be only a single insn. - - If we don't use an intermediate pseudo, such things as - address computations to make the address of VAR valid - if it is not can be placed between the CALL_INSN and INSN. - - To make sure this doesn't happen, we record the destination - of the CALL_INSN and see if the next insn uses both that - and VAR. */ - - if (call_dest != 0 && GET_CODE (insn) == INSN - && reg_mentioned_p (var, PATTERN (insn)) - && reg_mentioned_p (call_dest, PATTERN (insn))) - { - rtx temp = gen_reg_rtx (GET_MODE (call_dest)); - - emit_insn_before (gen_move_insn (temp, call_dest), insn); - - PATTERN (insn) = replace_rtx (PATTERN (insn), - call_dest, temp); - } - - if (GET_CODE (insn) == CALL_INSN - && GET_CODE (PATTERN (insn)) == SET) - call_dest = SET_DEST (PATTERN (insn)); - else if (GET_CODE (insn) == CALL_INSN - && GET_CODE (PATTERN (insn)) == PARALLEL - && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET) - call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0)); - else - call_dest = 0; - } - - /* See if we have to do anything to INSN now that VAR is in - memory. If it needs to be loaded into a pseudo, use a single - pseudo for the entire insn in case there is a MATCH_DUP - between two operands. We pass a pointer to the head of - a list of struct fixup_replacements. If fixup_var_refs_1 - needs to allocate pseudos or replacement MEMs (for SUBREGs), - it will record them in this list. - - If it allocated a pseudo for any replacement, we copy into - it here. */ - - fixup_var_refs_1 (var, promoted_mode, &PATTERN (insn), insn, - &replacements); - - /* If this is last_parm_insn, and any instructions were output - after it to fix it up, then we must set last_parm_insn to - the last such instruction emitted. */ - if (insn == last_parm_insn) - last_parm_insn = PREV_INSN (next_insn); - - while (replacements) - { - if (GET_CODE (replacements->new) == REG) - { - rtx insert_before; - rtx seq; - - /* OLD might be a (subreg (mem)). */ - if (GET_CODE (replacements->old) == SUBREG) - replacements->old - = fixup_memory_subreg (replacements->old, insn, 0); - else - replacements->old - = fixup_stack_1 (replacements->old, insn); - - insert_before = insn; - - /* If we are changing the mode, do a conversion. - This might be wasteful, but combine.c will - eliminate much of the waste. */ - - if (GET_MODE (replacements->new) - != GET_MODE (replacements->old)) - { - start_sequence (); - convert_move (replacements->new, - replacements->old, unsignedp); - seq = gen_sequence (); - end_sequence (); - } - else - seq = gen_move_insn (replacements->new, - replacements->old); - - emit_insn_before (seq, insert_before); - } - - replacements = replacements->next; - } - } - - /* Also fix up any invalid exprs in the REG_NOTES of this insn. - But don't touch other insns referred to by reg-notes; - we will get them elsewhere. */ - for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) - if (GET_CODE (note) != INSN_LIST) - XEXP (note, 0) - = walk_fixup_memory_subreg (XEXP (note, 0), insn, 1); - } - insn = next; - } -} - -/* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE. - See if the rtx expression at *LOC in INSN needs to be changed. - - REPLACEMENTS is a pointer to a list head that starts out zero, but may - contain a list of original rtx's and replacements. If we find that we need - to modify this insn by replacing a memory reference with a pseudo or by - making a new MEM to implement a SUBREG, we consult that list to see if - we have already chosen a replacement. If none has already been allocated, - we allocate it and update the list. fixup_var_refs_insns will copy VAR - or the SUBREG, as appropriate, to the pseudo. */ - -static void -fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements) - register rtx var; - enum machine_mode promoted_mode; - register rtx *loc; - rtx insn; - struct fixup_replacement **replacements; -{ - register int i; - register rtx x = *loc; - RTX_CODE code = GET_CODE (x); - register char *fmt; - register rtx tem, tem1; - struct fixup_replacement *replacement; - - switch (code) - { - case ADDRESSOF: - if (XEXP (x, 0) == var) - { - /* Prevent sharing of rtl that might lose. */ - rtx sub = copy_rtx (XEXP (var, 0)); - - start_sequence (); - - if (! validate_change (insn, loc, sub, 0)) - { - rtx y = force_operand (sub, NULL_RTX); - - if (! validate_change (insn, loc, y, 0)) - *loc = copy_to_reg (y); - } - - emit_insn_before (gen_sequence (), insn); - end_sequence (); - } - return; - - case MEM: - if (var == x) - { - /* If we already have a replacement, use it. Otherwise, - try to fix up this address in case it is invalid. */ - - replacement = find_fixup_replacement (replacements, var); - if (replacement->new) - { - *loc = replacement->new; - return; - } - - *loc = replacement->new = x = fixup_stack_1 (x, insn); - - /* Unless we are forcing memory to register or we changed the mode, - we can leave things the way they are if the insn is valid. */ - - INSN_CODE (insn) = -1; - if (! flag_force_mem && GET_MODE (x) == promoted_mode - && recog_memoized (insn) >= 0) - return; - - *loc = replacement->new = gen_reg_rtx (promoted_mode); - return; - } - - /* If X contains VAR, we need to unshare it here so that we update - each occurrence separately. But all identical MEMs in one insn - must be replaced with the same rtx because of the possibility of - MATCH_DUPs. */ - - if (reg_mentioned_p (var, x)) - { - replacement = find_fixup_replacement (replacements, x); - if (replacement->new == 0) - replacement->new = copy_most_rtx (x, var); - - *loc = x = replacement->new; - } - break; - - case REG: - case CC0: - case PC: - case CONST_INT: - case CONST: - case SYMBOL_REF: - case LABEL_REF: - case CONST_DOUBLE: - return; - - case SIGN_EXTRACT: - case ZERO_EXTRACT: - /* Note that in some cases those types of expressions are altered - by optimize_bit_field, and do not survive to get here. */ - if (XEXP (x, 0) == var - || (GET_CODE (XEXP (x, 0)) == SUBREG - && SUBREG_REG (XEXP (x, 0)) == var)) - { - /* Get TEM as a valid MEM in the mode presently in the insn. - - We don't worry about the possibility of MATCH_DUP here; it - is highly unlikely and would be tricky to handle. */ - - tem = XEXP (x, 0); - if (GET_CODE (tem) == SUBREG) - { - if (GET_MODE_BITSIZE (GET_MODE (tem)) - > GET_MODE_BITSIZE (GET_MODE (var))) - { - replacement = find_fixup_replacement (replacements, var); - if (replacement->new == 0) - replacement->new = gen_reg_rtx (GET_MODE (var)); - SUBREG_REG (tem) = replacement->new; - } - else - tem = fixup_memory_subreg (tem, insn, 0); - } - else - tem = fixup_stack_1 (tem, insn); - - /* Unless we want to load from memory, get TEM into the proper mode - for an extract from memory. This can only be done if the - extract is at a constant position and length. */ - - if (! flag_force_mem && GET_CODE (XEXP (x, 1)) == CONST_INT - && GET_CODE (XEXP (x, 2)) == CONST_INT - && ! mode_dependent_address_p (XEXP (tem, 0)) - && ! MEM_VOLATILE_P (tem)) - { - enum machine_mode wanted_mode = VOIDmode; - enum machine_mode is_mode = GET_MODE (tem); - HOST_WIDE_INT pos = INTVAL (XEXP (x, 2)); - -#ifdef HAVE_extzv - if (GET_CODE (x) == ZERO_EXTRACT) - { - wanted_mode = insn_operand_mode[(int) CODE_FOR_extzv][1]; - if (wanted_mode == VOIDmode) - wanted_mode = word_mode; - } -#endif -#ifdef HAVE_extv - if (GET_CODE (x) == SIGN_EXTRACT) - { - wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1]; - if (wanted_mode == VOIDmode) - wanted_mode = word_mode; - } -#endif - /* If we have a narrower mode, we can do something. */ - if (wanted_mode != VOIDmode - && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode)) - { - HOST_WIDE_INT offset = pos / BITS_PER_UNIT; - rtx old_pos = XEXP (x, 2); - rtx newmem; - - /* If the bytes and bits are counted differently, we - must adjust the offset. */ - if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN) - offset = (GET_MODE_SIZE (is_mode) - - GET_MODE_SIZE (wanted_mode) - offset); - - pos %= GET_MODE_BITSIZE (wanted_mode); - - newmem = gen_rtx_MEM (wanted_mode, - plus_constant (XEXP (tem, 0), offset)); - RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem); - MEM_COPY_ATTRIBUTES (newmem, tem); - - /* Make the change and see if the insn remains valid. */ - INSN_CODE (insn) = -1; - XEXP (x, 0) = newmem; - XEXP (x, 2) = GEN_INT (pos); - - if (recog_memoized (insn) >= 0) - return; - - /* Otherwise, restore old position. XEXP (x, 0) will be - restored later. */ - XEXP (x, 2) = old_pos; - } - } - - /* If we get here, the bitfield extract insn can't accept a memory - reference. Copy the input into a register. */ - - tem1 = gen_reg_rtx (GET_MODE (tem)); - emit_insn_before (gen_move_insn (tem1, tem), insn); - XEXP (x, 0) = tem1; - return; - } - break; - - case SUBREG: - if (SUBREG_REG (x) == var) - { - /* If this is a special SUBREG made because VAR was promoted - from a wider mode, replace it with VAR and call ourself - recursively, this time saying that the object previously - had its current mode (by virtue of the SUBREG). */ - - if (SUBREG_PROMOTED_VAR_P (x)) - { - *loc = var; - fixup_var_refs_1 (var, GET_MODE (var), loc, insn, replacements); - return; - } - - /* If this SUBREG makes VAR wider, it has become a paradoxical - SUBREG with VAR in memory, but these aren't allowed at this - stage of the compilation. So load VAR into a pseudo and take - a SUBREG of that pseudo. */ - if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var))) - { - replacement = find_fixup_replacement (replacements, var); - if (replacement->new == 0) - replacement->new = gen_reg_rtx (GET_MODE (var)); - SUBREG_REG (x) = replacement->new; - return; - } - - /* See if we have already found a replacement for this SUBREG. - If so, use it. Otherwise, make a MEM and see if the insn - is recognized. If not, or if we should force MEM into a register, - make a pseudo for this SUBREG. */ - replacement = find_fixup_replacement (replacements, x); - if (replacement->new) - { - *loc = replacement->new; - return; - } - - replacement->new = *loc = fixup_memory_subreg (x, insn, 0); - - INSN_CODE (insn) = -1; - if (! flag_force_mem && recog_memoized (insn) >= 0) - return; - - *loc = replacement->new = gen_reg_rtx (GET_MODE (x)); - return; - } - break; - - case SET: - /* First do special simplification of bit-field references. */ - if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT - || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT) - optimize_bit_field (x, insn, 0); - if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT - || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT) - optimize_bit_field (x, insn, NULL_PTR); - - /* For a paradoxical SUBREG inside a ZERO_EXTRACT, load the object - into a register and then store it back out. */ - if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT - && GET_CODE (XEXP (SET_DEST (x), 0)) == SUBREG - && SUBREG_REG (XEXP (SET_DEST (x), 0)) == var - && (GET_MODE_SIZE (GET_MODE (XEXP (SET_DEST (x), 0))) - > GET_MODE_SIZE (GET_MODE (var)))) - { - replacement = find_fixup_replacement (replacements, var); - if (replacement->new == 0) - replacement->new = gen_reg_rtx (GET_MODE (var)); - - SUBREG_REG (XEXP (SET_DEST (x), 0)) = replacement->new; - emit_insn_after (gen_move_insn (var, replacement->new), insn); - } - - /* If SET_DEST is now a paradoxical SUBREG, put the result of this - insn into a pseudo and store the low part of the pseudo into VAR. */ - if (GET_CODE (SET_DEST (x)) == SUBREG - && SUBREG_REG (SET_DEST (x)) == var - && (GET_MODE_SIZE (GET_MODE (SET_DEST (x))) - > GET_MODE_SIZE (GET_MODE (var)))) - { - SET_DEST (x) = tem = gen_reg_rtx (GET_MODE (SET_DEST (x))); - emit_insn_after (gen_move_insn (var, gen_lowpart (GET_MODE (var), - tem)), - insn); - break; - } - - { - rtx dest = SET_DEST (x); - rtx src = SET_SRC (x); -#ifdef HAVE_insv - rtx outerdest = dest; -#endif - - while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART - || GET_CODE (dest) == SIGN_EXTRACT - || GET_CODE (dest) == ZERO_EXTRACT) - dest = XEXP (dest, 0); - - if (GET_CODE (src) == SUBREG) - src = XEXP (src, 0); - - /* If VAR does not appear at the top level of the SET - just scan the lower levels of the tree. */ - - if (src != var && dest != var) - break; - - /* We will need to rerecognize this insn. */ - INSN_CODE (insn) = -1; - -#ifdef HAVE_insv - if (GET_CODE (outerdest) == ZERO_EXTRACT && dest == var) - { - /* Since this case will return, ensure we fixup all the - operands here. */ - fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 1), - insn, replacements); - fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 2), - insn, replacements); - fixup_var_refs_1 (var, promoted_mode, &SET_SRC (x), - insn, replacements); - - tem = XEXP (outerdest, 0); - - /* Clean up (SUBREG:SI (MEM:mode ...) 0) - that may appear inside a ZERO_EXTRACT. - This was legitimate when the MEM was a REG. */ - if (GET_CODE (tem) == SUBREG - && SUBREG_REG (tem) == var) - tem = fixup_memory_subreg (tem, insn, 0); - else - tem = fixup_stack_1 (tem, insn); - - if (GET_CODE (XEXP (outerdest, 1)) == CONST_INT - && GET_CODE (XEXP (outerdest, 2)) == CONST_INT - && ! mode_dependent_address_p (XEXP (tem, 0)) - && ! MEM_VOLATILE_P (tem)) - { - enum machine_mode wanted_mode; - enum machine_mode is_mode = GET_MODE (tem); - HOST_WIDE_INT pos = INTVAL (XEXP (outerdest, 2)); - - wanted_mode = insn_operand_mode[(int) CODE_FOR_insv][0]; - if (wanted_mode == VOIDmode) - wanted_mode = word_mode; - - /* If we have a narrower mode, we can do something. */ - if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode)) - { - HOST_WIDE_INT offset = pos / BITS_PER_UNIT; - rtx old_pos = XEXP (outerdest, 2); - rtx newmem; - - if (BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN) - offset = (GET_MODE_SIZE (is_mode) - - GET_MODE_SIZE (wanted_mode) - offset); - - pos %= GET_MODE_BITSIZE (wanted_mode); - - newmem = gen_rtx_MEM (wanted_mode, - plus_constant (XEXP (tem, 0), offset)); - RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem); - MEM_COPY_ATTRIBUTES (newmem, tem); - - /* Make the change and see if the insn remains valid. */ - INSN_CODE (insn) = -1; - XEXP (outerdest, 0) = newmem; - XEXP (outerdest, 2) = GEN_INT (pos); - - if (recog_memoized (insn) >= 0) - return; - - /* Otherwise, restore old position. XEXP (x, 0) will be - restored later. */ - XEXP (outerdest, 2) = old_pos; - } - } - - /* If we get here, the bit-field store doesn't allow memory - or isn't located at a constant position. Load the value into - a register, do the store, and put it back into memory. */ - - tem1 = gen_reg_rtx (GET_MODE (tem)); - emit_insn_before (gen_move_insn (tem1, tem), insn); - emit_insn_after (gen_move_insn (tem, tem1), insn); - XEXP (outerdest, 0) = tem1; - return; - } -#endif - - /* STRICT_LOW_PART is a no-op on memory references - and it can cause combinations to be unrecognizable, - so eliminate it. */ - - if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART) - SET_DEST (x) = XEXP (SET_DEST (x), 0); - - /* A valid insn to copy VAR into or out of a register - must be left alone, to avoid an infinite loop here. - If the reference to VAR is by a subreg, fix that up, - since SUBREG is not valid for a memref. - Also fix up the address of the stack slot. - - Note that we must not try to recognize the insn until - after we know that we have valid addresses and no - (subreg (mem ...) ...) constructs, since these interfere - with determining the validity of the insn. */ - - if ((SET_SRC (x) == var - || (GET_CODE (SET_SRC (x)) == SUBREG - && SUBREG_REG (SET_SRC (x)) == var)) - && (GET_CODE (SET_DEST (x)) == REG - || (GET_CODE (SET_DEST (x)) == SUBREG - && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG)) - && GET_MODE (var) == promoted_mode - && x == single_set (insn)) - { - rtx pat; - - replacement = find_fixup_replacement (replacements, SET_SRC (x)); - if (replacement->new) - SET_SRC (x) = replacement->new; - else if (GET_CODE (SET_SRC (x)) == SUBREG) - SET_SRC (x) = replacement->new - = fixup_memory_subreg (SET_SRC (x), insn, 0); - else - SET_SRC (x) = replacement->new - = fixup_stack_1 (SET_SRC (x), insn); - - if (recog_memoized (insn) >= 0) - return; - - /* INSN is not valid, but we know that we want to - copy SET_SRC (x) to SET_DEST (x) in some way. So - we generate the move and see whether it requires more - than one insn. If it does, we emit those insns and - delete INSN. Otherwise, we an just replace the pattern - of INSN; we have already verified above that INSN has - no other function that to do X. */ - - pat = gen_move_insn (SET_DEST (x), SET_SRC (x)); - if (GET_CODE (pat) == SEQUENCE) - { - emit_insn_after (pat, insn); - PUT_CODE (insn, NOTE); - NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; - NOTE_SOURCE_FILE (insn) = 0; - } - else - PATTERN (insn) = pat; - - return; - } - - if ((SET_DEST (x) == var - || (GET_CODE (SET_DEST (x)) == SUBREG - && SUBREG_REG (SET_DEST (x)) == var)) - && (GET_CODE (SET_SRC (x)) == REG - || (GET_CODE (SET_SRC (x)) == SUBREG - && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG)) - && GET_MODE (var) == promoted_mode - && x == single_set (insn)) - { - rtx pat; - - if (GET_CODE (SET_DEST (x)) == SUBREG) - SET_DEST (x) = fixup_memory_subreg (SET_DEST (x), insn, 0); - else - SET_DEST (x) = fixup_stack_1 (SET_DEST (x), insn); - - if (recog_memoized (insn) >= 0) - return; - - pat = gen_move_insn (SET_DEST (x), SET_SRC (x)); - if (GET_CODE (pat) == SEQUENCE) - { - emit_insn_after (pat, insn); - PUT_CODE (insn, NOTE); - NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; - NOTE_SOURCE_FILE (insn) = 0; - } - else - PATTERN (insn) = pat; - - return; - } - - /* Otherwise, storing into VAR must be handled specially - by storing into a temporary and copying that into VAR - with a new insn after this one. Note that this case - will be used when storing into a promoted scalar since - the insn will now have different modes on the input - and output and hence will be invalid (except for the case - of setting it to a constant, which does not need any - change if it is valid). We generate extra code in that case, - but combine.c will eliminate it. */ - - if (dest == var) - { - rtx temp; - rtx fixeddest = SET_DEST (x); - - /* STRICT_LOW_PART can be discarded, around a MEM. */ - if (GET_CODE (fixeddest) == STRICT_LOW_PART) - fixeddest = XEXP (fixeddest, 0); - /* Convert (SUBREG (MEM)) to a MEM in a changed mode. */ - if (GET_CODE (fixeddest) == SUBREG) - { - fixeddest = fixup_memory_subreg (fixeddest, insn, 0); - promoted_mode = GET_MODE (fixeddest); - } - else - fixeddest = fixup_stack_1 (fixeddest, insn); - - temp = gen_reg_rtx (promoted_mode); - - emit_insn_after (gen_move_insn (fixeddest, - gen_lowpart (GET_MODE (fixeddest), - temp)), - insn); - - SET_DEST (x) = temp; - } - } - - default: - break; - } - - /* Nothing special about this RTX; fix its operands. */ - - fmt = GET_RTX_FORMAT (code); - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) - { - if (fmt[i] == 'e') - fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements); - if (fmt[i] == 'E') - { - register int j; - for (j = 0; j < XVECLEN (x, i); j++) - fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j), - insn, replacements); - } - } -} - -/* Given X, an rtx of the form (SUBREG:m1 (MEM:m2 addr)), - return an rtx (MEM:m1 newaddr) which is equivalent. - If any insns must be emitted to compute NEWADDR, put them before INSN. - - UNCRITICAL nonzero means accept paradoxical subregs. - This is used for subregs found inside REG_NOTES. */ - -static rtx -fixup_memory_subreg (x, insn, uncritical) - rtx x; - rtx insn; - int uncritical; -{ - int offset = SUBREG_WORD (x) * UNITS_PER_WORD; - rtx addr = XEXP (SUBREG_REG (x), 0); - enum machine_mode mode = GET_MODE (x); - rtx result; - - /* Paradoxical SUBREGs are usually invalid during RTL generation. */ - if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))) - && ! uncritical) - abort (); - - if (BYTES_BIG_ENDIAN) - offset += (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))) - - MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))); - addr = plus_constant (addr, offset); - if (!flag_force_addr && memory_address_p (mode, addr)) - /* Shortcut if no insns need be emitted. */ - return change_address (SUBREG_REG (x), mode, addr); - start_sequence (); - result = change_address (SUBREG_REG (x), mode, addr); - emit_insn_before (gen_sequence (), insn); - end_sequence (); - return result; -} - -/* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X. - Replace subexpressions of X in place. - If X itself is a (SUBREG (MEM ...) ...), return the replacement expression. - Otherwise return X, with its contents possibly altered. - - If any insns must be emitted to compute NEWADDR, put them before INSN. - - UNCRITICAL is as in fixup_memory_subreg. */ - -static rtx -walk_fixup_memory_subreg (x, insn, uncritical) - register rtx x; - rtx insn; - int uncritical; -{ - register enum rtx_code code; - register char *fmt; - register int i; - - if (x == 0) - return 0; - - code = GET_CODE (x); - - if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM) - return fixup_memory_subreg (x, insn, uncritical); - - /* Nothing special about this RTX; fix its operands. */ - - fmt = GET_RTX_FORMAT (code); - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) - { - if (fmt[i] == 'e') - XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn, uncritical); - if (fmt[i] == 'E') - { - register int j; - for (j = 0; j < XVECLEN (x, i); j++) - XVECEXP (x, i, j) - = walk_fixup_memory_subreg (XVECEXP (x, i, j), insn, uncritical); - } - } - return x; -} - -/* For each memory ref within X, if it refers to a stack slot - with an out of range displacement, put the address in a temp register - (emitting new insns before INSN to load these registers) - and alter the memory ref to use that register. - Replace each such MEM rtx with a copy, to avoid clobberage. */ - -static rtx -fixup_stack_1 (x, insn) - rtx x; - rtx insn; -{ - register int i; - register RTX_CODE code = GET_CODE (x); - register char *fmt; - - if (code == MEM) - { - register rtx ad = XEXP (x, 0); - /* If we have address of a stack slot but it's not valid - (displacement is too large), compute the sum in a register. */ - if (GET_CODE (ad) == PLUS - && GET_CODE (XEXP (ad, 0)) == REG - && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER - && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER) - || REGNO (XEXP (ad, 0)) == FRAME_POINTER_REGNUM -#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM - || REGNO (XEXP (ad, 0)) == HARD_FRAME_POINTER_REGNUM -#endif - || REGNO (XEXP (ad, 0)) == STACK_POINTER_REGNUM - || REGNO (XEXP (ad, 0)) == ARG_POINTER_REGNUM - || XEXP (ad, 0) == current_function_internal_arg_pointer) - && GET_CODE (XEXP (ad, 1)) == CONST_INT) - { - rtx temp, seq; - if (memory_address_p (GET_MODE (x), ad)) - return x; - - start_sequence (); - temp = copy_to_reg (ad); - seq = gen_sequence (); - end_sequence (); - emit_insn_before (seq, insn); - return change_address (x, VOIDmode, temp); - } - return x; - } - - fmt = GET_RTX_FORMAT (code); - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) - { - if (fmt[i] == 'e') - XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn); - if (fmt[i] == 'E') - { - register int j; - for (j = 0; j < XVECLEN (x, i); j++) - XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn); - } - } - return x; -} - -/* Optimization: a bit-field instruction whose field - happens to be a byte or halfword in memory - can be changed to a move instruction. - - We call here when INSN is an insn to examine or store into a bit-field. - BODY is the SET-rtx to be altered. - - EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0. - (Currently this is called only from function.c, and EQUIV_MEM - is always 0.) */ - -static void -optimize_bit_field (body, insn, equiv_mem) - rtx body; - rtx insn; - rtx *equiv_mem; -{ - register rtx bitfield; - int destflag; - rtx seq = 0; - enum machine_mode mode; - - if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT - || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT) - bitfield = SET_DEST (body), destflag = 1; - else - bitfield = SET_SRC (body), destflag = 0; - - /* First check that the field being stored has constant size and position - and is in fact a byte or halfword suitably aligned. */ - - if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT - && GET_CODE (XEXP (bitfield, 2)) == CONST_INT - && ((mode = mode_for_size (INTVAL (XEXP (bitfield, 1)), MODE_INT, 1)) - != BLKmode) - && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0) - { - register rtx memref = 0; - - /* Now check that the containing word is memory, not a register, - and that it is safe to change the machine mode. */ - - if (GET_CODE (XEXP (bitfield, 0)) == MEM) - memref = XEXP (bitfield, 0); - else if (GET_CODE (XEXP (bitfield, 0)) == REG - && equiv_mem != 0) - memref = equiv_mem[REGNO (XEXP (bitfield, 0))]; - else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG - && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM) - memref = SUBREG_REG (XEXP (bitfield, 0)); - else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG - && equiv_mem != 0 - && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG) - memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))]; - - if (memref - && ! mode_dependent_address_p (XEXP (memref, 0)) - && ! MEM_VOLATILE_P (memref)) - { - /* Now adjust the address, first for any subreg'ing - that we are now getting rid of, - and then for which byte of the word is wanted. */ - - HOST_WIDE_INT offset = INTVAL (XEXP (bitfield, 2)); - rtx insns; - - /* Adjust OFFSET to count bits from low-address byte. */ - if (BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN) - offset = (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield, 0))) - - offset - INTVAL (XEXP (bitfield, 1))); - - /* Adjust OFFSET to count bytes from low-address byte. */ - offset /= BITS_PER_UNIT; - if (GET_CODE (XEXP (bitfield, 0)) == SUBREG) - { - offset += SUBREG_WORD (XEXP (bitfield, 0)) * UNITS_PER_WORD; - if (BYTES_BIG_ENDIAN) - offset -= (MIN (UNITS_PER_WORD, - GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0)))) - - MIN (UNITS_PER_WORD, - GET_MODE_SIZE (GET_MODE (memref)))); - } - - start_sequence (); - memref = change_address (memref, mode, - plus_constant (XEXP (memref, 0), offset)); - insns = get_insns (); - end_sequence (); - emit_insns_before (insns, insn); - - /* Store this memory reference where - we found the bit field reference. */ - - if (destflag) - { - validate_change (insn, &SET_DEST (body), memref, 1); - if (! CONSTANT_ADDRESS_P (SET_SRC (body))) - { - rtx src = SET_SRC (body); - while (GET_CODE (src) == SUBREG - && SUBREG_WORD (src) == 0) - src = SUBREG_REG (src); - if (GET_MODE (src) != GET_MODE (memref)) - src = gen_lowpart (GET_MODE (memref), SET_SRC (body)); - validate_change (insn, &SET_SRC (body), src, 1); - } - else if (GET_MODE (SET_SRC (body)) != VOIDmode - && GET_MODE (SET_SRC (body)) != GET_MODE (memref)) - /* This shouldn't happen because anything that didn't have - one of these modes should have got converted explicitly - and then referenced through a subreg. - This is so because the original bit-field was - handled by agg_mode and so its tree structure had - the same mode that memref now has. */ - abort (); - } - else - { - rtx dest = SET_DEST (body); - - while (GET_CODE (dest) == SUBREG - && SUBREG_WORD (dest) == 0 - && (GET_MODE_CLASS (GET_MODE (dest)) - == GET_MODE_CLASS (GET_MODE (SUBREG_REG (dest))))) - dest = SUBREG_REG (dest); - - validate_change (insn, &SET_DEST (body), dest, 1); - - if (GET_MODE (dest) == GET_MODE (memref)) - validate_change (insn, &SET_SRC (body), memref, 1); - else - { - /* Convert the mem ref to the destination mode. */ - rtx newreg = gen_reg_rtx (GET_MODE (dest)); - - start_sequence (); - convert_move (newreg, memref, - GET_CODE (SET_SRC (body)) == ZERO_EXTRACT); - seq = get_insns (); - end_sequence (); - - validate_change (insn, &SET_SRC (body), newreg, 1); - } - } - - /* See if we can convert this extraction or insertion into - a simple move insn. We might not be able to do so if this - was, for example, part of a PARALLEL. - - If we succeed, write out any needed conversions. If we fail, - it is hard to guess why we failed, so don't do anything - special; just let the optimization be suppressed. */ - - if (apply_change_group () && seq) - emit_insns_before (seq, insn); - } - } -} - -/* These routines are responsible for converting virtual register references - to the actual hard register references once RTL generation is complete. - - The following four variables are used for communication between the - routines. They contain the offsets of the virtual registers from their - respective hard registers. */ - -static int in_arg_offset; -static int var_offset; -static int dynamic_offset; -static int out_arg_offset; -static int cfa_offset; - -/* In most machines, the stack pointer register is equivalent to the bottom - of the stack. */ - -#ifndef STACK_POINTER_OFFSET -#define STACK_POINTER_OFFSET 0 -#endif - -/* If not defined, pick an appropriate default for the offset of dynamically - allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS, - REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */ - -#ifndef STACK_DYNAMIC_OFFSET - -#ifdef ACCUMULATE_OUTGOING_ARGS -/* The bottom of the stack points to the actual arguments. If - REG_PARM_STACK_SPACE is defined, this includes the space for the register - parameters. However, if OUTGOING_REG_PARM_STACK space is not defined, - stack space for register parameters is not pushed by the caller, but - rather part of the fixed stack areas and hence not included in - `current_function_outgoing_args_size'. Nevertheless, we must allow - for it when allocating stack dynamic objects. */ - -#if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) -#define STACK_DYNAMIC_OFFSET(FNDECL) \ -(current_function_outgoing_args_size \ - + REG_PARM_STACK_SPACE (FNDECL) + (STACK_POINTER_OFFSET)) - -#else -#define STACK_DYNAMIC_OFFSET(FNDECL) \ -(current_function_outgoing_args_size + (STACK_POINTER_OFFSET)) -#endif - -#else -#define STACK_DYNAMIC_OFFSET(FNDECL) STACK_POINTER_OFFSET -#endif -#endif - -/* On a few machines, the CFA coincides with the arg pointer. */ - -#ifndef ARG_POINTER_CFA_OFFSET -#define ARG_POINTER_CFA_OFFSET 0 -#endif - - -/* Build up a (MEM (ADDRESSOF (REG))) rtx for a register REG that just had - its address taken. DECL is the decl for the object stored in the - register, for later use if we do need to force REG into the stack. - REG is overwritten by the MEM like in put_reg_into_stack. */ - -rtx -gen_mem_addressof (reg, decl) - rtx reg; - tree decl; -{ - tree type = TREE_TYPE (decl); - rtx r = gen_rtx_ADDRESSOF (Pmode, gen_reg_rtx (GET_MODE (reg)), REGNO (reg)); - SET_ADDRESSOF_DECL (r, decl); - /* If the original REG was a user-variable, then so is the REG whose - address is being taken. */ - REG_USERVAR_P (XEXP (r, 0)) = REG_USERVAR_P (reg); - - XEXP (reg, 0) = r; - PUT_CODE (reg, MEM); - PUT_MODE (reg, DECL_MODE (decl)); - MEM_VOLATILE_P (reg) = TREE_SIDE_EFFECTS (decl); - MEM_SET_IN_STRUCT_P (reg, AGGREGATE_TYPE_P (type)); - MEM_ALIAS_SET (reg) = get_alias_set (decl); - - if (TREE_USED (decl) || DECL_INITIAL (decl) != 0) - fixup_var_refs (reg, GET_MODE (reg), TREE_UNSIGNED (type)); - - return reg; -} - -/* If DECL has an RTL that is an ADDRESSOF rtx, put it into the stack. */ - -void -flush_addressof (decl) - tree decl; -{ - if ((TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL) - && DECL_RTL (decl) != 0 - && GET_CODE (DECL_RTL (decl)) == MEM - && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF - && GET_CODE (XEXP (XEXP (DECL_RTL (decl), 0), 0)) == REG) - put_addressof_into_stack (XEXP (DECL_RTL (decl), 0)); -} - -/* Force the register pointed to by R, an ADDRESSOF rtx, into the stack. */ - -static void -put_addressof_into_stack (r) - rtx r; -{ - tree decl = ADDRESSOF_DECL (r); - rtx reg = XEXP (r, 0); - - if (GET_CODE (reg) != REG) - abort (); - - put_reg_into_stack (0, reg, TREE_TYPE (decl), GET_MODE (reg), - DECL_MODE (decl), TREE_SIDE_EFFECTS (decl), - ADDRESSOF_REGNO (r), - TREE_USED (decl) || DECL_INITIAL (decl) != 0); -} - -/* List of replacements made below in purge_addressof_1 when creating - bitfield insertions. */ -static rtx purge_addressof_replacements; - -/* Helper function for purge_addressof. See if the rtx expression at *LOC - in INSN needs to be changed. If FORCE, always put any ADDRESSOFs into - the stack. */ - -static void -purge_addressof_1 (loc, insn, force, store) - rtx *loc; - rtx insn; - int force, store; -{ - rtx x; - RTX_CODE code; - int i, j; - char *fmt; - - /* Re-start here to avoid recursion in common cases. */ - restart: - - x = *loc; - if (x == 0) - return; - - code = GET_CODE (x); - - if (code == ADDRESSOF && GET_CODE (XEXP (x, 0)) == MEM) - { - rtx insns; - /* We must create a copy of the rtx because it was created by - overwriting a REG rtx which is always shared. */ - rtx sub = copy_rtx (XEXP (XEXP (x, 0), 0)); - - if (validate_change (insn, loc, sub, 0)) - return; - - start_sequence (); - if (! validate_change (insn, loc, - force_operand (sub, NULL_RTX), - 0)) - abort (); - - insns = gen_sequence (); - end_sequence (); - emit_insn_before (insns, insn); - return; - } - else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force) - { - rtx sub = XEXP (XEXP (x, 0), 0); - - if (GET_CODE (sub) == MEM) - sub = gen_rtx_MEM (GET_MODE (x), copy_rtx (XEXP (sub, 0))); - - if (GET_CODE (sub) == REG - && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode)) - { - put_addressof_into_stack (XEXP (x, 0)); - return; - } - else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub)) - { - int size_x, size_sub; - - if (!insn) - { - /* When processing REG_NOTES look at the list of - replacements done on the insn to find the register that X - was replaced by. */ - rtx tem; - - for (tem = purge_addressof_replacements; tem != NULL_RTX; - tem = XEXP (XEXP (tem, 1), 1)) - { - rtx y = XEXP (tem, 0); - if (GET_CODE (y) == MEM - && rtx_equal_p (XEXP (x, 0), XEXP (y, 0))) - { - /* It can happen that the note may speak of things in - a wider (or just different) mode than the code did. - This is especially true of REG_RETVAL. */ - - rtx z = XEXP (XEXP (tem, 1), 0); - if (GET_MODE (x) != GET_MODE (y)) - { - if (GET_CODE (z) == SUBREG && SUBREG_WORD (z) == 0) - z = SUBREG_REG (z); - - /* ??? If we'd gotten into any of the really complex - cases below, I'm not sure we can do a proper - replacement. Might we be able to delete the - note in some cases? */ - if (GET_MODE_SIZE (GET_MODE (x)) - < GET_MODE_SIZE (GET_MODE (y))) - abort (); - - if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD - && (GET_MODE_SIZE (GET_MODE (x)) - > GET_MODE_SIZE (GET_MODE (z)))) - { - /* This can occur as a result in invalid - pointer casts, e.g. float f; ... - *(long long int *)&f. - ??? We could emit a warning here, but - without a line number that wouldn't be - very helpful. */ - z = gen_rtx_SUBREG (GET_MODE (x), z, 0); - } - else - z = gen_lowpart (GET_MODE (x), z); - } - - *loc = z; - return; - } - } - - /* There should always be such a replacement. */ - abort (); - } - - size_x = GET_MODE_BITSIZE (GET_MODE (x)); - size_sub = GET_MODE_BITSIZE (GET_MODE (sub)); - - /* Don't even consider working with paradoxical subregs, - or the moral equivalent seen here. */ - if (size_x <= size_sub - && int_mode_for_mode (GET_MODE (sub)) != BLKmode) - { - /* Do a bitfield insertion to mirror what would happen - in memory. */ - - rtx val, seq; - - if (store) - { - rtx p; - - start_sequence (); - val = gen_reg_rtx (GET_MODE (x)); - if (! validate_change (insn, loc, val, 0)) - { - /* Discard the current sequence and put the - ADDRESSOF on stack. */ - end_sequence (); - goto give_up; - } - seq = gen_sequence (); - end_sequence (); - emit_insn_before (seq, insn); - - start_sequence (); - store_bit_field (sub, size_x, 0, GET_MODE (x), - val, GET_MODE_SIZE (GET_MODE (sub)), - GET_MODE_SIZE (GET_MODE (sub))); - - /* Make sure to unshare any shared rtl that store_bit_field - might have created. */ - for (p = get_insns(); p; p = NEXT_INSN (p)) - { - reset_used_flags (PATTERN (p)); - reset_used_flags (REG_NOTES (p)); - reset_used_flags (LOG_LINKS (p)); - } - unshare_all_rtl (get_insns ()); - - seq = gen_sequence (); - end_sequence (); - emit_insn_after (seq, insn); - } - else - { - start_sequence (); - val = extract_bit_field (sub, size_x, 0, 1, NULL_RTX, - GET_MODE (x), GET_MODE (x), - GET_MODE_SIZE (GET_MODE (sub)), - GET_MODE_SIZE (GET_MODE (sub))); - - if (! validate_change (insn, loc, val, 0)) - { - /* Discard the current sequence and put the - ADDRESSOF on stack. */ - end_sequence (); - goto give_up; - } - - seq = gen_sequence (); - end_sequence (); - emit_insn_before (seq, insn); - } - - /* Remember the replacement so that the same one can be done - on the REG_NOTES. */ - purge_addressof_replacements - = gen_rtx_EXPR_LIST (VOIDmode, x, - gen_rtx_EXPR_LIST (VOIDmode, val, - purge_addressof_replacements)); - - /* We replaced with a reg -- all done. */ - return; - } - } - else if (validate_change (insn, loc, sub, 0)) - { - /* Remember the replacement so that the same one can be done - on the REG_NOTES. */ - purge_addressof_replacements - = gen_rtx_EXPR_LIST (VOIDmode, x, - gen_rtx_EXPR_LIST (VOIDmode, sub, - purge_addressof_replacements)); - goto restart; - } - give_up:; - /* else give up and put it into the stack */ - } - else if (code == ADDRESSOF) - { - put_addressof_into_stack (x); - return; - } - else if (code == SET) - { - purge_addressof_1 (&SET_DEST (x), insn, force, 1); - purge_addressof_1 (&SET_SRC (x), insn, force, 0); - return; - } - else if (code == CALL) - { - purge_addressof_1 (&XEXP (x, 0), insn, 1, 0); - purge_addressof_1 (&XEXP (x, 1), insn, force, 0); - return; - } - - /* Scan all subexpressions. */ - fmt = GET_RTX_FORMAT (code); - for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) - { - if (*fmt == 'e') - purge_addressof_1 (&XEXP (x, i), insn, force, 0); - else if (*fmt == 'E') - for (j = 0; j < XVECLEN (x, i); j++) - purge_addressof_1 (&XVECEXP (x, i, j), insn, force, 0); - } -} - -/* Eliminate all occurrences of ADDRESSOF from INSNS. Elide any remaining - (MEM (ADDRESSOF)) patterns, and force any needed registers into the - stack. */ - -void -purge_addressof (insns) - rtx insns; -{ - rtx insn; - for (insn = insns; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN) - { - purge_addressof_1 (&PATTERN (insn), insn, - asm_noperands (PATTERN (insn)) > 0, 0); - purge_addressof_1 (®_NOTES (insn), NULL_RTX, 0, 0); - } - purge_addressof_replacements = 0; -} - -/* Pass through the INSNS of function FNDECL and convert virtual register - references to hard register references. */ - -void -instantiate_virtual_regs (fndecl, insns) - tree fndecl; - rtx insns; -{ - rtx insn; - int i; - - /* Compute the offsets to use for this function. */ - in_arg_offset = FIRST_PARM_OFFSET (fndecl); - var_offset = STARTING_FRAME_OFFSET; - dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl); - out_arg_offset = STACK_POINTER_OFFSET; - cfa_offset = ARG_POINTER_CFA_OFFSET; - - /* Scan all variables and parameters of this function. For each that is - in memory, instantiate all virtual registers if the result is a valid - address. If not, we do it later. That will handle most uses of virtual - regs on many machines. */ - instantiate_decls (fndecl, 1); - - /* Initialize recognition, indicating that volatile is OK. */ - init_recog (); - - /* Scan through all the insns, instantiating every virtual register still - present. */ - for (insn = insns; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN) - { - instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1); - instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0); - } - - /* Instantiate the stack slots for the parm registers, for later use in - addressof elimination. */ - for (i = 0; i < max_parm_reg; ++i) - if (parm_reg_stack_loc[i]) - instantiate_virtual_regs_1 (&parm_reg_stack_loc[i], NULL_RTX, 0); - - /* Now instantiate the remaining register equivalences for debugging info. - These will not be valid addresses. */ - instantiate_decls (fndecl, 0); - - /* Indicate that, from now on, assign_stack_local should use - frame_pointer_rtx. */ - virtuals_instantiated = 1; -} - -/* Scan all decls in FNDECL (both variables and parameters) and instantiate - all virtual registers in their DECL_RTL's. - - If VALID_ONLY, do this only if the resulting address is still valid. - Otherwise, always do it. */ - -static void -instantiate_decls (fndecl, valid_only) - tree fndecl; - int valid_only; -{ - tree decl; - - if (DECL_SAVED_INSNS (fndecl)) - /* When compiling an inline function, the obstack used for - rtl allocation is the maybepermanent_obstack. Calling - `resume_temporary_allocation' switches us back to that - obstack while we process this function's parameters. */ - resume_temporary_allocation (); - - /* Process all parameters of the function. */ - for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl)) - { - HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl)); - - instantiate_decl (DECL_RTL (decl), size, valid_only); - - /* If the parameter was promoted, then the incoming RTL mode may be - larger than the declared type size. We must use the larger of - the two sizes. */ - size = MAX (GET_MODE_SIZE (GET_MODE (DECL_INCOMING_RTL (decl))), size); - instantiate_decl (DECL_INCOMING_RTL (decl), size, valid_only); - } - - /* Now process all variables defined in the function or its subblocks. */ - instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only); - - if (DECL_INLINE (fndecl) || DECL_DEFER_OUTPUT (fndecl)) - { - /* Save all rtl allocated for this function by raising the - high-water mark on the maybepermanent_obstack. */ - preserve_data (); - /* All further rtl allocation is now done in the current_obstack. */ - rtl_in_current_obstack (); - } -} - -/* Subroutine of instantiate_decls: Process all decls in the given - BLOCK node and all its subblocks. */ - -static void -instantiate_decls_1 (let, valid_only) - tree let; - int valid_only; -{ - tree t; - - for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t)) - instantiate_decl (DECL_RTL (t), int_size_in_bytes (TREE_TYPE (t)), - valid_only); - - /* Process all subblocks. */ - for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t)) - instantiate_decls_1 (t, valid_only); -} - -/* Subroutine of the preceding procedures: Given RTL representing a - decl and the size of the object, do any instantiation required. - - If VALID_ONLY is non-zero, it means that the RTL should only be - changed if the new address is valid. */ - -static void -instantiate_decl (x, size, valid_only) - rtx x; - int size; - int valid_only; -{ - enum machine_mode mode; - rtx addr; - - /* If this is not a MEM, no need to do anything. Similarly if the - address is a constant or a register that is not a virtual register. */ - - if (x == 0 || GET_CODE (x) != MEM) - return; - - addr = XEXP (x, 0); - if (CONSTANT_P (addr) - || (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == REG) - || (GET_CODE (addr) == REG - && (REGNO (addr) < FIRST_VIRTUAL_REGISTER - || REGNO (addr) > LAST_VIRTUAL_REGISTER))) - return; - - /* If we should only do this if the address is valid, copy the address. - We need to do this so we can undo any changes that might make the - address invalid. This copy is unfortunate, but probably can't be - avoided. */ - - if (valid_only) - addr = copy_rtx (addr); - - instantiate_virtual_regs_1 (&addr, NULL_RTX, 0); - - if (valid_only) - { - /* Now verify that the resulting address is valid for every integer or - floating-point mode up to and including SIZE bytes long. We do this - since the object might be accessed in any mode and frame addresses - are shared. */ - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); - mode != VOIDmode && GET_MODE_SIZE (mode) <= size; - mode = GET_MODE_WIDER_MODE (mode)) - if (! memory_address_p (mode, addr)) - return; - - for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); - mode != VOIDmode && GET_MODE_SIZE (mode) <= size; - mode = GET_MODE_WIDER_MODE (mode)) - if (! memory_address_p (mode, addr)) - return; - } - - /* Put back the address now that we have updated it and we either know - it is valid or we don't care whether it is valid. */ - - XEXP (x, 0) = addr; -} - -/* Given a pointer to a piece of rtx and an optional pointer to the - containing object, instantiate any virtual registers present in it. - - If EXTRA_INSNS, we always do the replacement and generate - any extra insns before OBJECT. If it zero, we do nothing if replacement - is not valid. - - Return 1 if we either had nothing to do or if we were able to do the - needed replacement. Return 0 otherwise; we only return zero if - EXTRA_INSNS is zero. - - We first try some simple transformations to avoid the creation of extra - pseudos. */ - -static int -instantiate_virtual_regs_1 (loc, object, extra_insns) - rtx *loc; - rtx object; - int extra_insns; -{ - rtx x; - RTX_CODE code; - rtx new = 0; - HOST_WIDE_INT offset; - rtx temp; - rtx seq; - int i, j; - char *fmt; - - /* Re-start here to avoid recursion in common cases. */ - restart: - - x = *loc; - if (x == 0) - return 1; - - code = GET_CODE (x); - - /* Check for some special cases. */ - switch (code) - { - case CONST_INT: - case CONST_DOUBLE: - case CONST: - case SYMBOL_REF: - case CODE_LABEL: - case PC: - case CC0: - case ASM_INPUT: - case ADDR_VEC: - case ADDR_DIFF_VEC: - case RETURN: - return 1; - - case SET: - /* We are allowed to set the virtual registers. This means that - the actual register should receive the source minus the - appropriate offset. This is used, for example, in the handling - of non-local gotos. */ - if (SET_DEST (x) == virtual_incoming_args_rtx) - new = arg_pointer_rtx, offset = - in_arg_offset; - else if (SET_DEST (x) == virtual_stack_vars_rtx) - new = frame_pointer_rtx, offset = - var_offset; - else if (SET_DEST (x) == virtual_stack_dynamic_rtx) - new = stack_pointer_rtx, offset = - dynamic_offset; - else if (SET_DEST (x) == virtual_outgoing_args_rtx) - new = stack_pointer_rtx, offset = - out_arg_offset; - else if (SET_DEST (x) == virtual_cfa_rtx) - new = arg_pointer_rtx, offset = - cfa_offset; - - if (new) - { - /* The only valid sources here are PLUS or REG. Just do - the simplest possible thing to handle them. */ - if (GET_CODE (SET_SRC (x)) != REG - && GET_CODE (SET_SRC (x)) != PLUS) - abort (); - - start_sequence (); - if (GET_CODE (SET_SRC (x)) != REG) - temp = force_operand (SET_SRC (x), NULL_RTX); - else - temp = SET_SRC (x); - temp = force_operand (plus_constant (temp, offset), NULL_RTX); - seq = get_insns (); - end_sequence (); - - emit_insns_before (seq, object); - SET_DEST (x) = new; - - if (! validate_change (object, &SET_SRC (x), temp, 0) - || ! extra_insns) - abort (); - - return 1; - } - - instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns); - loc = &SET_SRC (x); - goto restart; - - case PLUS: - /* Handle special case of virtual register plus constant. */ - if (CONSTANT_P (XEXP (x, 1))) - { - rtx old, new_offset; - - /* Check for (plus (plus VIRT foo) (const_int)) first. */ - if (GET_CODE (XEXP (x, 0)) == PLUS) - { - rtx inner = XEXP (XEXP (x, 0), 0); - - if (inner == virtual_incoming_args_rtx) - new = arg_pointer_rtx, offset = in_arg_offset; - else if (inner == virtual_stack_vars_rtx) - new = frame_pointer_rtx, offset = var_offset; - else if (inner == virtual_stack_dynamic_rtx) - new = stack_pointer_rtx, offset = dynamic_offset; - else if (inner == virtual_outgoing_args_rtx) - new = stack_pointer_rtx, offset = out_arg_offset; - else if (inner == virtual_cfa_rtx) - new = arg_pointer_rtx, offset = cfa_offset; - else - { - loc = &XEXP (x, 0); - goto restart; - } - - instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object, - extra_insns); - new = gen_rtx_PLUS (Pmode, new, XEXP (XEXP (x, 0), 1)); - } - - else if (XEXP (x, 0) == virtual_incoming_args_rtx) - new = arg_pointer_rtx, offset = in_arg_offset; - else if (XEXP (x, 0) == virtual_stack_vars_rtx) - new = frame_pointer_rtx, offset = var_offset; - else if (XEXP (x, 0) == virtual_stack_dynamic_rtx) - new = stack_pointer_rtx, offset = dynamic_offset; - else if (XEXP (x, 0) == virtual_outgoing_args_rtx) - new = stack_pointer_rtx, offset = out_arg_offset; - else if (XEXP (x, 0) == virtual_cfa_rtx) - new = arg_pointer_rtx, offset = cfa_offset; - else - { - /* We know the second operand is a constant. Unless the - first operand is a REG (which has been already checked), - it needs to be checked. */ - if (GET_CODE (XEXP (x, 0)) != REG) - { - loc = &XEXP (x, 0); - goto restart; - } - return 1; - } - - new_offset = plus_constant (XEXP (x, 1), offset); - - /* If the new constant is zero, try to replace the sum with just - the register. */ - if (new_offset == const0_rtx - && validate_change (object, loc, new, 0)) - return 1; - - /* Next try to replace the register and new offset. - There are two changes to validate here and we can't assume that - in the case of old offset equals new just changing the register - will yield a valid insn. In the interests of a little efficiency, - however, we only call validate change once (we don't queue up the - changes and then call apply_change_group). */ - - old = XEXP (x, 0); - if (offset == 0 - ? ! validate_change (object, &XEXP (x, 0), new, 0) - : (XEXP (x, 0) = new, - ! validate_change (object, &XEXP (x, 1), new_offset, 0))) - { - if (! extra_insns) - { - XEXP (x, 0) = old; - return 0; - } - - /* Otherwise copy the new constant into a register and replace - constant with that register. */ - temp = gen_reg_rtx (Pmode); - XEXP (x, 0) = new; - if (validate_change (object, &XEXP (x, 1), temp, 0)) - emit_insn_before (gen_move_insn (temp, new_offset), object); - else - { - /* If that didn't work, replace this expression with a - register containing the sum. */ - - XEXP (x, 0) = old; - new = gen_rtx_PLUS (Pmode, new, new_offset); - - start_sequence (); - temp = force_operand (new, NULL_RTX); - seq = get_insns (); - end_sequence (); - - emit_insns_before (seq, object); - if (! validate_change (object, loc, temp, 0) - && ! validate_replace_rtx (x, temp, object)) - abort (); - } - } - - return 1; - } - - /* Fall through to generic two-operand expression case. */ - case EXPR_LIST: - case CALL: - case COMPARE: - case MINUS: - case MULT: - case DIV: case UDIV: - case MOD: case UMOD: - case AND: case IOR: case XOR: - case ROTATERT: case ROTATE: - case ASHIFTRT: case LSHIFTRT: case ASHIFT: - case NE: case EQ: - case GE: case GT: case GEU: case GTU: - case LE: case LT: case LEU: case LTU: - if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1))) - instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns); - loc = &XEXP (x, 0); - goto restart; - - case MEM: - /* Most cases of MEM that convert to valid addresses have already been - handled by our scan of decls. The only special handling we - need here is to make a copy of the rtx to ensure it isn't being - shared if we have to change it to a pseudo. - - If the rtx is a simple reference to an address via a virtual register, - it can potentially be shared. In such cases, first try to make it - a valid address, which can also be shared. Otherwise, copy it and - proceed normally. - - First check for common cases that need no processing. These are - usually due to instantiation already being done on a previous instance - of a shared rtx. */ - - temp = XEXP (x, 0); - if (CONSTANT_ADDRESS_P (temp) -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - || temp == arg_pointer_rtx -#endif -#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM - || temp == hard_frame_pointer_rtx -#endif - || temp == frame_pointer_rtx) - return 1; - - if (GET_CODE (temp) == PLUS - && CONSTANT_ADDRESS_P (XEXP (temp, 1)) - && (XEXP (temp, 0) == frame_pointer_rtx -#if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM - || XEXP (temp, 0) == hard_frame_pointer_rtx -#endif -#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM - || XEXP (temp, 0) == arg_pointer_rtx -#endif - )) - return 1; - - if (temp == virtual_stack_vars_rtx - || temp == virtual_incoming_args_rtx - || (GET_CODE (temp) == PLUS - && CONSTANT_ADDRESS_P (XEXP (temp, 1)) - && (XEXP (temp, 0) == virtual_stack_vars_rtx - || XEXP (temp, 0) == virtual_incoming_args_rtx))) - { - /* This MEM may be shared. If the substitution can be done without - the need to generate new pseudos, we want to do it in place - so all copies of the shared rtx benefit. The call below will - only make substitutions if the resulting address is still - valid. - - Note that we cannot pass X as the object in the recursive call - since the insn being processed may not allow all valid - addresses. However, if we were not passed on object, we can - only modify X without copying it if X will have a valid - address. - - ??? Also note that this can still lose if OBJECT is an insn that - has less restrictions on an address that some other insn. - In that case, we will modify the shared address. This case - doesn't seem very likely, though. One case where this could - happen is in the case of a USE or CLOBBER reference, but we - take care of that below. */ - - if (instantiate_virtual_regs_1 (&XEXP (x, 0), - object ? object : x, 0)) - return 1; - - /* Otherwise make a copy and process that copy. We copy the entire - RTL expression since it might be a PLUS which could also be - shared. */ - *loc = x = copy_rtx (x); - } - - /* Fall through to generic unary operation case. */ - case SUBREG: - case STRICT_LOW_PART: - case NEG: case NOT: - case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC: - case SIGN_EXTEND: case ZERO_EXTEND: - case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE: - case FLOAT: case FIX: - case UNSIGNED_FIX: case UNSIGNED_FLOAT: - case ABS: - case SQRT: - case FFS: - /* These case either have just one operand or we know that we need not - check the rest of the operands. */ - loc = &XEXP (x, 0); - goto restart; - - case USE: - case CLOBBER: - /* If the operand is a MEM, see if the change is a valid MEM. If not, - go ahead and make the invalid one, but do it to a copy. For a REG, - just make the recursive call, since there's no chance of a problem. */ - - if ((GET_CODE (XEXP (x, 0)) == MEM - && instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), XEXP (x, 0), - 0)) - || (GET_CODE (XEXP (x, 0)) == REG - && instantiate_virtual_regs_1 (&XEXP (x, 0), object, 0))) - return 1; - - XEXP (x, 0) = copy_rtx (XEXP (x, 0)); - loc = &XEXP (x, 0); - goto restart; - - case REG: - /* Try to replace with a PLUS. If that doesn't work, compute the sum - in front of this insn and substitute the temporary. */ - if (x == virtual_incoming_args_rtx) - new = arg_pointer_rtx, offset = in_arg_offset; - else if (x == virtual_stack_vars_rtx) - new = frame_pointer_rtx, offset = var_offset; - else if (x == virtual_stack_dynamic_rtx) - new = stack_pointer_rtx, offset = dynamic_offset; - else if (x == virtual_outgoing_args_rtx) - new = stack_pointer_rtx, offset = out_arg_offset; - else if (x == virtual_cfa_rtx) - new = arg_pointer_rtx, offset = cfa_offset; - - if (new) - { - temp = plus_constant (new, offset); - if (!validate_change (object, loc, temp, 0)) - { - if (! extra_insns) - return 0; - - start_sequence (); - temp = force_operand (temp, NULL_RTX); - seq = get_insns (); - end_sequence (); - - emit_insns_before (seq, object); - if (! validate_change (object, loc, temp, 0) - && ! validate_replace_rtx (x, temp, object)) - abort (); - } - } - - return 1; - - case ADDRESSOF: - if (GET_CODE (XEXP (x, 0)) == REG) - return 1; - - else if (GET_CODE (XEXP (x, 0)) == MEM) - { - /* If we have a (addressof (mem ..)), do any instantiation inside - since we know we'll be making the inside valid when we finally - remove the ADDRESSOF. */ - instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 0), NULL_RTX, 0); - return 1; - } - break; - - default: - break; - } - - /* Scan all subexpressions. */ - fmt = GET_RTX_FORMAT (code); - for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++) - if (*fmt == 'e') - { - if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns)) - return 0; - } - else if (*fmt == 'E') - for (j = 0; j < XVECLEN (x, i); j++) - if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object, - extra_insns)) - return 0; - - return 1; -} - -/* Optimization: assuming this function does not receive nonlocal gotos, - delete the handlers for such, as well as the insns to establish - and disestablish them. */ - -static void -delete_handlers () -{ - rtx insn; - for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) - { - /* Delete the handler by turning off the flag that would - prevent jump_optimize from deleting it. - Also permit deletion of the nonlocal labels themselves - if nothing local refers to them. */ - if (GET_CODE (insn) == CODE_LABEL) - { - tree t, last_t; - - LABEL_PRESERVE_P (insn) = 0; - - /* Remove it from the nonlocal_label list, to avoid confusing - flow. */ - for (t = nonlocal_labels, last_t = 0; t; - last_t = t, t = TREE_CHAIN (t)) - if (DECL_RTL (TREE_VALUE (t)) == insn) - break; - if (t) - { - if (! last_t) - nonlocal_labels = TREE_CHAIN (nonlocal_labels); - else - TREE_CHAIN (last_t) = TREE_CHAIN (t); - } - } - if (GET_CODE (insn) == INSN) - { - int can_delete = 0; - rtx t; - for (t = nonlocal_goto_handler_slots; t != 0; t = XEXP (t, 1)) - if (reg_mentioned_p (t, PATTERN (insn))) - { - can_delete = 1; - break; - } - if (can_delete - || (nonlocal_goto_stack_level != 0 - && reg_mentioned_p (nonlocal_goto_stack_level, - PATTERN (insn)))) - delete_insn (insn); - } - } -} - -/* Return a list (chain of EXPR_LIST nodes) for the nonlocal labels - of the current function. */ - -rtx -nonlocal_label_rtx_list () -{ - tree t; - rtx x = 0; - - for (t = nonlocal_labels; t; t = TREE_CHAIN (t)) - x = gen_rtx_EXPR_LIST (VOIDmode, label_rtx (TREE_VALUE (t)), x); - - return x; -} - -/* Output a USE for any register use in RTL. - This is used with -noreg to mark the extent of lifespan - of any registers used in a user-visible variable's DECL_RTL. */ - -void -use_variable (rtl) - rtx rtl; -{ - if (GET_CODE (rtl) == REG) - /* This is a register variable. */ - emit_insn (gen_rtx_USE (VOIDmode, rtl)); - else if (GET_CODE (rtl) == MEM - && GET_CODE (XEXP (rtl, 0)) == REG - && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER - || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER) - && XEXP (rtl, 0) != current_function_internal_arg_pointer) - /* This is a variable-sized structure. */ - emit_insn (gen_rtx_USE (VOIDmode, XEXP (rtl, 0))); -} - -/* Like use_variable except that it outputs the USEs after INSN - instead of at the end of the insn-chain. */ - -void -use_variable_after (rtl, insn) - rtx rtl, insn; -{ - if (GET_CODE (rtl) == REG) - /* This is a register variable. */ - emit_insn_after (gen_rtx_USE (VOIDmode, rtl), insn); - else if (GET_CODE (rtl) == MEM - && GET_CODE (XEXP (rtl, 0)) == REG - && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER - || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER) - && XEXP (rtl, 0) != current_function_internal_arg_pointer) - /* This is a variable-sized structure. */ - emit_insn_after (gen_rtx_USE (VOIDmode, XEXP (rtl, 0)), insn); -} - -int -max_parm_reg_num () -{ - return max_parm_reg; -} - -/* Return the first insn following those generated by `assign_parms'. */ - -rtx -get_first_nonparm_insn () -{ - if (last_parm_insn) - return NEXT_INSN (last_parm_insn); - return get_insns (); -} - -/* Return the first NOTE_INSN_BLOCK_BEG note in the function. - Crash if there is none. */ - -rtx -get_first_block_beg () -{ - register rtx searcher; - register rtx insn = get_first_nonparm_insn (); - - for (searcher = insn; searcher; searcher = NEXT_INSN (searcher)) - if (GET_CODE (searcher) == NOTE - && NOTE_LINE_NUMBER (searcher) == NOTE_INSN_BLOCK_BEG) - return searcher; - - abort (); /* Invalid call to this function. (See comments above.) */ - return NULL_RTX; -} - -/* Return 1 if EXP is an aggregate type (or a value with aggregate type). - This means a type for which function calls must pass an address to the - function or get an address back from the function. - EXP may be a type node or an expression (whose type is tested). */ - -int -aggregate_value_p (exp) - tree exp; -{ - int i, regno, nregs; - rtx reg; - tree type; - if (TREE_CODE_CLASS (TREE_CODE (exp)) == 't') - type = exp; - else - type = TREE_TYPE (exp); - - if (RETURN_IN_MEMORY (type)) - return 1; - /* Types that are TREE_ADDRESSABLE must be constructed in memory, - and thus can't be returned in registers. */ - if (TREE_ADDRESSABLE (type)) - return 1; - if (flag_pcc_struct_return && AGGREGATE_TYPE_P (type)) - return 1; - /* Make sure we have suitable call-clobbered regs to return - the value in; if not, we must return it in memory. */ - reg = hard_function_value (type, 0); - - /* If we have something other than a REG (e.g. a PARALLEL), then assume - it is OK. */ - if (GET_CODE (reg) != REG) - return 0; - - regno = REGNO (reg); - nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type)); - for (i = 0; i < nregs; i++) - if (! call_used_regs[regno + i]) - return 1; - return 0; -} - -/* Assign RTL expressions to the function's parameters. - This may involve copying them into registers and using - those registers as the RTL for them. - - If SECOND_TIME is non-zero it means that this function is being - called a second time. This is done by integrate.c when a function's - compilation is deferred. We need to come back here in case the - FUNCTION_ARG macro computes items needed for the rest of the compilation - (such as changing which registers are fixed or caller-saved). But suppress - writing any insns or setting DECL_RTL of anything in this case. */ - -void -assign_parms (fndecl, second_time) - tree fndecl; - int second_time; -{ - register tree parm; - register rtx entry_parm = 0; - register rtx stack_parm = 0; - CUMULATIVE_ARGS args_so_far; - enum machine_mode promoted_mode, passed_mode; - enum machine_mode nominal_mode, promoted_nominal_mode; - int unsignedp; - /* Total space needed so far for args on the stack, - given as a constant and a tree-expression. */ - struct args_size stack_args_size; - tree fntype = TREE_TYPE (fndecl); - tree fnargs = DECL_ARGUMENTS (fndecl); - /* This is used for the arg pointer when referring to stack args. */ - rtx internal_arg_pointer; - /* This is a dummy PARM_DECL that we used for the function result if - the function returns a structure. */ - tree function_result_decl = 0; - int varargs_setup = 0; - rtx conversion_insns = 0; - - /* Nonzero if the last arg is named `__builtin_va_alist', - which is used on some machines for old-fashioned non-ANSI varargs.h; - this should be stuck onto the stack as if it had arrived there. */ - int hide_last_arg - = (current_function_varargs - && fnargs - && (parm = tree_last (fnargs)) != 0 - && DECL_NAME (parm) - && (! strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)), - "__builtin_va_alist"))); - - /* Nonzero if function takes extra anonymous args. - This means the last named arg must be on the stack - right before the anonymous ones. */ - int stdarg - = (TYPE_ARG_TYPES (fntype) != 0 - && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype))) - != void_type_node)); - - current_function_stdarg = stdarg; - - /* If the reg that the virtual arg pointer will be translated into is - not a fixed reg or is the stack pointer, make a copy of the virtual - arg pointer, and address parms via the copy. The frame pointer is - considered fixed even though it is not marked as such. - - The second time through, simply use ap to avoid generating rtx. */ - - if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM - || ! (fixed_regs[ARG_POINTER_REGNUM] - || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM)) - && ! second_time) - internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx); - else - internal_arg_pointer = virtual_incoming_args_rtx; - current_function_internal_arg_pointer = internal_arg_pointer; - - stack_args_size.constant = 0; - stack_args_size.var = 0; - - /* If struct value address is treated as the first argument, make it so. */ - if (aggregate_value_p (DECL_RESULT (fndecl)) - && ! current_function_returns_pcc_struct - && struct_value_incoming_rtx == 0) - { - tree type = build_pointer_type (TREE_TYPE (fntype)); - - function_result_decl = build_decl (PARM_DECL, NULL_TREE, type); - - DECL_ARG_TYPE (function_result_decl) = type; - TREE_CHAIN (function_result_decl) = fnargs; - fnargs = function_result_decl; - } - - max_parm_reg = LAST_VIRTUAL_REGISTER + 1; - parm_reg_stack_loc = (rtx *) savealloc (max_parm_reg * sizeof (rtx)); - zero_memory ((char *) parm_reg_stack_loc, max_parm_reg * sizeof (rtx)); - -#ifdef INIT_CUMULATIVE_INCOMING_ARGS - INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX); -#else - INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX, 0); -#endif - - /* We haven't yet found an argument that we must push and pretend the - caller did. */ - current_function_pretend_args_size = 0; - - for (parm = fnargs; parm; parm = TREE_CHAIN (parm)) - { - int aggregate = AGGREGATE_TYPE_P (TREE_TYPE (parm)); - struct args_size stack_offset; - struct args_size arg_size; - int passed_pointer = 0; - int did_conversion = 0; - tree passed_type = DECL_ARG_TYPE (parm); - tree nominal_type = TREE_TYPE (parm); - - /* Set LAST_NAMED if this is last named arg before some - anonymous args. */ - int last_named = ((TREE_CHAIN (parm) == 0 - || DECL_NAME (TREE_CHAIN (parm)) == 0) - && (stdarg || current_function_varargs)); - /* Set NAMED_ARG if this arg should be treated as a named arg. For - most machines, if this is a varargs/stdarg function, then we treat - the last named arg as if it were anonymous too. */ - int named_arg = STRICT_ARGUMENT_NAMING ? 1 : ! last_named; - - if (TREE_TYPE (parm) == error_mark_node - /* This can happen after weird syntax errors - or if an enum type is defined among the parms. */ - || TREE_CODE (parm) != PARM_DECL - || passed_type == NULL) - { - DECL_INCOMING_RTL (parm) = DECL_RTL (parm) - = gen_rtx_MEM (BLKmode, const0_rtx); - TREE_USED (parm) = 1; - continue; - } - - /* For varargs.h function, save info about regs and stack space - used by the individual args, not including the va_alist arg. */ - if (hide_last_arg && last_named) - current_function_args_info = args_so_far; - - /* Find mode of arg as it is passed, and mode of arg - as it should be during execution of this function. */ - passed_mode = TYPE_MODE (passed_type); - nominal_mode = TYPE_MODE (nominal_type); - - /* If the parm's mode is VOID, its value doesn't matter, - and avoid the usual things like emit_move_insn that could crash. */ - if (nominal_mode == VOIDmode) - { - DECL_INCOMING_RTL (parm) = DECL_RTL (parm) = const0_rtx; - continue; - } - - /* If the parm is to be passed as a transparent union, use the - type of the first field for the tests below. We have already - verified that the modes are the same. */ - if (DECL_TRANSPARENT_UNION (parm) - || TYPE_TRANSPARENT_UNION (passed_type)) - passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); - - /* See if this arg was passed by invisible reference. It is if - it is an object whose size depends on the contents of the - object itself or if the machine requires these objects be passed - that way. */ - - if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST - && contains_placeholder_p (TYPE_SIZE (passed_type))) - || TREE_ADDRESSABLE (passed_type) -#ifdef FUNCTION_ARG_PASS_BY_REFERENCE - || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode, - passed_type, named_arg) -#endif - ) - { - passed_type = nominal_type = build_pointer_type (passed_type); - passed_pointer = 1; - passed_mode = nominal_mode = Pmode; - } - - promoted_mode = passed_mode; - -#ifdef PROMOTE_FUNCTION_ARGS - /* Compute the mode in which the arg is actually extended to. */ - unsignedp = TREE_UNSIGNED (passed_type); - promoted_mode = promote_mode (passed_type, promoted_mode, &unsignedp, 1); -#endif - - /* Let machine desc say which reg (if any) the parm arrives in. - 0 means it arrives on the stack. */ -#ifdef FUNCTION_INCOMING_ARG - entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, - passed_type, named_arg); -#else - entry_parm = FUNCTION_ARG (args_so_far, promoted_mode, - passed_type, named_arg); -#endif - - if (entry_parm == 0) - promoted_mode = passed_mode; - -#ifdef SETUP_INCOMING_VARARGS - /* If this is the last named parameter, do any required setup for - varargs or stdargs. We need to know about the case of this being an - addressable type, in which case we skip the registers it - would have arrived in. - - For stdargs, LAST_NAMED will be set for two parameters, the one that - is actually the last named, and the dummy parameter. We only - want to do this action once. - - Also, indicate when RTL generation is to be suppressed. */ - if (last_named && !varargs_setup) - { - SETUP_INCOMING_VARARGS (args_so_far, promoted_mode, passed_type, - current_function_pretend_args_size, - second_time); - varargs_setup = 1; - } -#endif - - /* Determine parm's home in the stack, - in case it arrives in the stack or we should pretend it did. - - Compute the stack position and rtx where the argument arrives - and its size. - - There is one complexity here: If this was a parameter that would - have been passed in registers, but wasn't only because it is - __builtin_va_alist, we want locate_and_pad_parm to treat it as if - it came in a register so that REG_PARM_STACK_SPACE isn't skipped. - In this case, we call FUNCTION_ARG with NAMED set to 1 instead of - 0 as it was the previous time. */ - - locate_and_pad_parm (promoted_mode, passed_type, -#ifdef STACK_PARMS_IN_REG_PARM_AREA - 1, -#else -#ifdef FUNCTION_INCOMING_ARG - FUNCTION_INCOMING_ARG (args_so_far, promoted_mode, - passed_type, - (named_arg - || varargs_setup)) != 0, -#else - FUNCTION_ARG (args_so_far, promoted_mode, - passed_type, - named_arg || varargs_setup) != 0, -#endif -#endif - fndecl, &stack_args_size, &stack_offset, &arg_size); - - if (! second_time) - { - rtx offset_rtx = ARGS_SIZE_RTX (stack_offset); - - if (offset_rtx == const0_rtx) - stack_parm = gen_rtx_MEM (promoted_mode, internal_arg_pointer); - else - stack_parm = gen_rtx_MEM (promoted_mode, - gen_rtx_PLUS (Pmode, - internal_arg_pointer, - offset_rtx)); - - /* If this is a memory ref that contains aggregate components, - mark it as such for cse and loop optimize. Likewise if it - is readonly. */ - MEM_SET_IN_STRUCT_P (stack_parm, aggregate); - RTX_UNCHANGING_P (stack_parm) = TREE_READONLY (parm); - MEM_ALIAS_SET (stack_parm) = get_alias_set (parm); - } - - /* If this parameter was passed both in registers and in the stack, - use the copy on the stack. */ - if (MUST_PASS_IN_STACK (promoted_mode, passed_type)) - entry_parm = 0; - -#ifdef FUNCTION_ARG_PARTIAL_NREGS - /* If this parm was passed part in regs and part in memory, - pretend it arrived entirely in memory - by pushing the register-part onto the stack. - - In the special case of a DImode or DFmode that is split, - we could put it together in a pseudoreg directly, - but for now that's not worth bothering with. */ - - if (entry_parm) - { - int nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, promoted_mode, - passed_type, named_arg); - - if (nregs > 0) - { - current_function_pretend_args_size - = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1) - / (PARM_BOUNDARY / BITS_PER_UNIT) - * (PARM_BOUNDARY / BITS_PER_UNIT)); - - if (! second_time) - { - /* Handle calls that pass values in multiple non-contiguous - locations. The Irix 6 ABI has examples of this. */ - if (GET_CODE (entry_parm) == PARALLEL) - emit_group_store (validize_mem (stack_parm), entry_parm, - int_size_in_bytes (TREE_TYPE (parm)), - (TYPE_ALIGN (TREE_TYPE (parm)) - / BITS_PER_UNIT)); - else - move_block_from_reg (REGNO (entry_parm), - validize_mem (stack_parm), nregs, - int_size_in_bytes (TREE_TYPE (parm))); - } - entry_parm = stack_parm; - } - } -#endif - - /* If we didn't decide this parm came in a register, - by default it came on the stack. */ - if (entry_parm == 0) - entry_parm = stack_parm; - - /* Record permanently how this parm was passed. */ - if (! second_time) - DECL_INCOMING_RTL (parm) = entry_parm; - - /* If there is actually space on the stack for this parm, - count it in stack_args_size; otherwise set stack_parm to 0 - to indicate there is no preallocated stack slot for the parm. */ - - if (entry_parm == stack_parm -#if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE) - /* On some machines, even if a parm value arrives in a register - there is still an (uninitialized) stack slot allocated for it. - - ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell - whether this parameter already has a stack slot allocated, - because an arg block exists only if current_function_args_size - is larger than some threshold, and we haven't calculated that - yet. So, for now, we just assume that stack slots never exist - in this case. */ - || REG_PARM_STACK_SPACE (fndecl) > 0 -#endif - ) - { - stack_args_size.constant += arg_size.constant; - if (arg_size.var) - ADD_PARM_SIZE (stack_args_size, arg_size.var); - } - else - /* No stack slot was pushed for this parm. */ - stack_parm = 0; - - /* Update info on where next arg arrives in registers. */ - - FUNCTION_ARG_ADVANCE (args_so_far, promoted_mode, - passed_type, named_arg); - - /* If this is our second time through, we are done with this parm. */ - if (second_time) - continue; - - /* If we can't trust the parm stack slot to be aligned enough - for its ultimate type, don't use that slot after entry. - We'll make another stack slot, if we need one. */ - { - int thisparm_boundary - = FUNCTION_ARG_BOUNDARY (promoted_mode, passed_type); - - if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary) - stack_parm = 0; - } - - /* If parm was passed in memory, and we need to convert it on entry, - don't store it back in that same slot. */ - if (entry_parm != 0 - && nominal_mode != BLKmode && nominal_mode != passed_mode) - stack_parm = 0; - -#if 0 - /* Now adjust STACK_PARM to the mode and precise location - where this parameter should live during execution, - if we discover that it must live in the stack during execution. - To make debuggers happier on big-endian machines, we store - the value in the last bytes of the space available. */ - - if (nominal_mode != BLKmode && nominal_mode != passed_mode - && stack_parm != 0) - { - rtx offset_rtx; - - if (BYTES_BIG_ENDIAN - && GET_MODE_SIZE (nominal_mode) < UNITS_PER_WORD) - stack_offset.constant += (GET_MODE_SIZE (passed_mode) - - GET_MODE_SIZE (nominal_mode)); - - offset_rtx = ARGS_SIZE_RTX (stack_offset); - if (offset_rtx == const0_rtx) - stack_parm = gen_rtx_MEM (nominal_mode, internal_arg_pointer); - else - stack_parm = gen_rtx_MEM (nominal_mode, - gen_rtx_PLUS (Pmode, - internal_arg_pointer, - offset_rtx)); - - /* If this is a memory ref that contains aggregate components, - mark it as such for cse and loop optimize. */ - MEM_SET_IN_STRUCT_P (stack_parm, aggregate); - } -#endif /* 0 */ - -#ifdef STACK_REGS - /* We need this "use" info, because the gcc-register->stack-register - converter in reg-stack.c needs to know which registers are active - at the start of the function call. The actual parameter loading - instructions are not always available then anymore, since they might - have been optimised away. */ - - if (GET_CODE (entry_parm) == REG && !(hide_last_arg && last_named)) - emit_insn (gen_rtx_USE (GET_MODE (entry_parm), entry_parm)); -#endif - - /* ENTRY_PARM is an RTX for the parameter as it arrives, - in the mode in which it arrives. - STACK_PARM is an RTX for a stack slot where the parameter can live - during the function (in case we want to put it there). - STACK_PARM is 0 if no stack slot was pushed for it. - - Now output code if necessary to convert ENTRY_PARM to - the type in which this function declares it, - and store that result in an appropriate place, - which may be a pseudo reg, may be STACK_PARM, - or may be a local stack slot if STACK_PARM is 0. - - Set DECL_RTL to that place. */ - - if (nominal_mode == BLKmode || GET_CODE (entry_parm) == PARALLEL) - { - /* If a BLKmode arrives in registers, copy it to a stack slot. - Handle calls that pass values in multiple non-contiguous - locations. The Irix 6 ABI has examples of this. */ - if (GET_CODE (entry_parm) == REG - || GET_CODE (entry_parm) == PARALLEL) - { - int size_stored - = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)), - UNITS_PER_WORD); - - /* Note that we will be storing an integral number of words. - So we have to be careful to ensure that we allocate an - integral number of words. We do this below in the - assign_stack_local if space was not allocated in the argument - list. If it was, this will not work if PARM_BOUNDARY is not - a multiple of BITS_PER_WORD. It isn't clear how to fix this - if it becomes a problem. */ - - if (stack_parm == 0) - { - stack_parm - = assign_stack_local (GET_MODE (entry_parm), - size_stored, 0); - - /* If this is a memory ref that contains aggregate - components, mark it as such for cse and loop optimize. */ - MEM_SET_IN_STRUCT_P (stack_parm, aggregate); - } - - else if (PARM_BOUNDARY % BITS_PER_WORD != 0) - abort (); - - if (TREE_READONLY (parm)) - RTX_UNCHANGING_P (stack_parm) = 1; - - /* Handle calls that pass values in multiple non-contiguous - locations. The Irix 6 ABI has examples of this. */ - if (GET_CODE (entry_parm) == PARALLEL) - emit_group_store (validize_mem (stack_parm), entry_parm, - int_size_in_bytes (TREE_TYPE (parm)), - (TYPE_ALIGN (TREE_TYPE (parm)) - / BITS_PER_UNIT)); - else - move_block_from_reg (REGNO (entry_parm), - validize_mem (stack_parm), - size_stored / UNITS_PER_WORD, - int_size_in_bytes (TREE_TYPE (parm))); - } - DECL_RTL (parm) = stack_parm; - } - else if (! ((obey_regdecls && ! DECL_REGISTER (parm) - && ! DECL_INLINE (fndecl)) - /* layout_decl may set this. */ - || TREE_ADDRESSABLE (parm) - || TREE_SIDE_EFFECTS (parm) - /* If -ffloat-store specified, don't put explicit - float variables into registers. */ - || (flag_float_store - && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)) - /* Always assign pseudo to structure return or item passed - by invisible reference. */ - || passed_pointer || parm == function_result_decl) - { - /* Store the parm in a pseudoregister during the function, but we - may need to do it in a wider mode. */ - - register rtx parmreg; - int regno, regnoi = 0, regnor = 0; - - unsignedp = TREE_UNSIGNED (TREE_TYPE (parm)); - - promoted_nominal_mode - = promote_mode (TREE_TYPE (parm), nominal_mode, &unsignedp, 0); - - parmreg = gen_reg_rtx (promoted_nominal_mode); - mark_user_reg (parmreg); - - /* If this was an item that we received a pointer to, set DECL_RTL - appropriately. */ - if (passed_pointer) - { - DECL_RTL (parm) - = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (passed_type)), parmreg); - MEM_SET_IN_STRUCT_P (DECL_RTL (parm), aggregate); - } - else - DECL_RTL (parm) = parmreg; - - /* Copy the value into the register. */ - if (nominal_mode != passed_mode - || promoted_nominal_mode != promoted_mode) - { - int save_tree_used; - /* ENTRY_PARM has been converted to PROMOTED_MODE, its - mode, by the caller. We now have to convert it to - NOMINAL_MODE, if different. However, PARMREG may be in - a different mode than NOMINAL_MODE if it is being stored - promoted. - - If ENTRY_PARM is a hard register, it might be in a register - not valid for operating in its mode (e.g., an odd-numbered - register for a DFmode). In that case, moves are the only - thing valid, so we can't do a convert from there. This - occurs when the calling sequence allow such misaligned - usages. - - In addition, the conversion may involve a call, which could - clobber parameters which haven't been copied to pseudo - registers yet. Therefore, we must first copy the parm to - a pseudo reg here, and save the conversion until after all - parameters have been moved. */ - - rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); - - emit_move_insn (tempreg, validize_mem (entry_parm)); - - push_to_sequence (conversion_insns); - tempreg = convert_to_mode (nominal_mode, tempreg, unsignedp); - - /* TREE_USED gets set erroneously during expand_assignment. */ - save_tree_used = TREE_USED (parm); - expand_assignment (parm, - make_tree (nominal_type, tempreg), 0, 0); - TREE_USED (parm) = save_tree_used; - conversion_insns = get_insns (); - did_conversion = 1; - end_sequence (); - } - else - emit_move_insn (parmreg, validize_mem (entry_parm)); - - /* If we were passed a pointer but the actual value - can safely live in a register, put it in one. */ - if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode - /* CYGNUS LOCAL -- FUNCTION_ARG_KEEP_AS_REFERENCE/meissner */ -#ifdef FUNCTION_ARG_KEEP_AS_REFERENCE - && !FUNCTION_ARG_KEEP_AS_REFERENCE (args_so_far, passed_mode, - passed_type, ! last_named) -#endif - /* END CYGNUS LOCAL */ - && ! ((obey_regdecls && ! DECL_REGISTER (parm) - && ! DECL_INLINE (fndecl)) - /* layout_decl may set this. */ - || TREE_ADDRESSABLE (parm) - || TREE_SIDE_EFFECTS (parm) - /* If -ffloat-store specified, don't put explicit - float variables into registers. */ - || (flag_float_store - && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))) - { - /* We can't use nominal_mode, because it will have been set to - Pmode above. We must use the actual mode of the parm. */ - parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm))); - mark_user_reg (parmreg); - emit_move_insn (parmreg, DECL_RTL (parm)); - DECL_RTL (parm) = parmreg; - /* STACK_PARM is the pointer, not the parm, and PARMREG is - now the parm. */ - stack_parm = 0; - } -#ifdef FUNCTION_ARG_CALLEE_COPIES - /* If we are passed an arg by reference and it is our responsibility - to make a copy, do it now. - PASSED_TYPE and PASSED mode now refer to the pointer, not the - original argument, so we must recreate them in the call to - FUNCTION_ARG_CALLEE_COPIES. */ - /* ??? Later add code to handle the case that if the argument isn't - modified, don't do the copy. */ - - else if (passed_pointer - && FUNCTION_ARG_CALLEE_COPIES (args_so_far, - TYPE_MODE (DECL_ARG_TYPE (parm)), - DECL_ARG_TYPE (parm), - named_arg) - && ! TREE_ADDRESSABLE (DECL_ARG_TYPE (parm))) - { - rtx copy; - tree type = DECL_ARG_TYPE (parm); - - /* This sequence may involve a library call perhaps clobbering - registers that haven't been copied to pseudos yet. */ - - push_to_sequence (conversion_insns); - - if (TYPE_SIZE (type) == 0 - || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) - /* This is a variable sized object. */ - copy = gen_rtx_MEM (BLKmode, - allocate_dynamic_stack_space - (expr_size (parm), NULL_RTX, - TYPE_ALIGN (type))); - else - copy = assign_stack_temp (TYPE_MODE (type), - int_size_in_bytes (type), 1); - MEM_SET_IN_STRUCT_P (copy, AGGREGATE_TYPE_P (type)); - RTX_UNCHANGING_P (copy) = TREE_READONLY (parm); - - store_expr (parm, copy, 0); - emit_move_insn (parmreg, XEXP (copy, 0)); - if (current_function_check_memory_usage) - emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, - XEXP (copy, 0), ptr_mode, - GEN_INT (int_size_in_bytes (type)), - TYPE_MODE (sizetype), - GEN_INT (MEMORY_USE_RW), - TYPE_MODE (integer_type_node)); - conversion_insns = get_insns (); - did_conversion = 1; - end_sequence (); - } -#endif /* FUNCTION_ARG_CALLEE_COPIES */ - - /* In any case, record the parm's desired stack location - in case we later discover it must live in the stack. - - If it is a COMPLEX value, store the stack location for both - halves. */ - - if (GET_CODE (parmreg) == CONCAT) - regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1))); - else - regno = REGNO (parmreg); - - if (regno >= max_parm_reg) - { - rtx *new; - int old_max_parm_reg = max_parm_reg; - - /* It's slow to expand this one register at a time, - but it's also rare and we need max_parm_reg to be - precisely correct. */ - max_parm_reg = regno + 1; - new = (rtx *) savealloc (max_parm_reg * sizeof (rtx)); - copy_memory ((char *) parm_reg_stack_loc, (char *) new, - old_max_parm_reg * sizeof (rtx)); - zero_memory ((char *) (new + old_max_parm_reg), - (max_parm_reg - old_max_parm_reg) * sizeof (rtx)); - parm_reg_stack_loc = new; - } - - if (GET_CODE (parmreg) == CONCAT) - { - enum machine_mode submode = GET_MODE (XEXP (parmreg, 0)); - - regnor = REGNO (gen_realpart (submode, parmreg)); - regnoi = REGNO (gen_imagpart (submode, parmreg)); - - if (stack_parm != 0) - { - parm_reg_stack_loc[regnor] - = gen_realpart (submode, stack_parm); - parm_reg_stack_loc[regnoi] - = gen_imagpart (submode, stack_parm); - } - else - { - parm_reg_stack_loc[regnor] = 0; - parm_reg_stack_loc[regnoi] = 0; - } - } - else - parm_reg_stack_loc[REGNO (parmreg)] = stack_parm; - - /* Mark the register as eliminable if we did no conversion - and it was copied from memory at a fixed offset, - and the arg pointer was not copied to a pseudo-reg. - If the arg pointer is a pseudo reg or the offset formed - an invalid address, such memory-equivalences - as we make here would screw up life analysis for it. */ - if (nominal_mode == passed_mode - && ! did_conversion - && stack_parm != 0 - && GET_CODE (stack_parm) == MEM - && stack_offset.var == 0 - && reg_mentioned_p (virtual_incoming_args_rtx, - XEXP (stack_parm, 0))) - { - rtx linsn = get_last_insn (); - rtx sinsn, set; - - /* Mark complex types separately. */ - if (GET_CODE (parmreg) == CONCAT) - /* Scan backwards for the set of the real and - imaginary parts. */ - for (sinsn = linsn; sinsn != 0; - sinsn = prev_nonnote_insn (sinsn)) - { - set = single_set (sinsn); - if (set != 0 - && SET_DEST (set) == regno_reg_rtx [regnoi]) - REG_NOTES (sinsn) - = gen_rtx_EXPR_LIST (REG_EQUIV, - parm_reg_stack_loc[regnoi], - REG_NOTES (sinsn)); - else if (set != 0 - && SET_DEST (set) == regno_reg_rtx [regnor]) - REG_NOTES (sinsn) - = gen_rtx_EXPR_LIST (REG_EQUIV, - parm_reg_stack_loc[regnor], - REG_NOTES (sinsn)); - } - else if ((set = single_set (linsn)) != 0 - && SET_DEST (set) == parmreg) - REG_NOTES (linsn) - = gen_rtx_EXPR_LIST (REG_EQUIV, - stack_parm, REG_NOTES (linsn)); - } - - /* For pointer data type, suggest pointer register. */ - if (POINTER_TYPE_P (TREE_TYPE (parm))) - mark_reg_pointer (parmreg, - (TYPE_ALIGN (TREE_TYPE (TREE_TYPE (parm))) - / BITS_PER_UNIT)); - } - else - { - /* Value must be stored in the stack slot STACK_PARM - during function execution. */ - - if (promoted_mode != nominal_mode) - { - /* Conversion is required. */ - rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm)); - - emit_move_insn (tempreg, validize_mem (entry_parm)); - - push_to_sequence (conversion_insns); - entry_parm = convert_to_mode (nominal_mode, tempreg, - TREE_UNSIGNED (TREE_TYPE (parm))); - if (stack_parm) - { - /* ??? This may need a big-endian conversion on sparc64. */ - stack_parm = change_address (stack_parm, nominal_mode, - NULL_RTX); - } - conversion_insns = get_insns (); - did_conversion = 1; - end_sequence (); - } - - if (entry_parm != stack_parm) - { - if (stack_parm == 0) - { - stack_parm - = assign_stack_local (GET_MODE (entry_parm), - GET_MODE_SIZE (GET_MODE (entry_parm)), 0); - /* If this is a memory ref that contains aggregate components, - mark it as such for cse and loop optimize. */ - MEM_SET_IN_STRUCT_P (stack_parm, aggregate); - } - - if (promoted_mode != nominal_mode) - { - push_to_sequence (conversion_insns); - emit_move_insn (validize_mem (stack_parm), - validize_mem (entry_parm)); - conversion_insns = get_insns (); - end_sequence (); - } - else - emit_move_insn (validize_mem (stack_parm), - validize_mem (entry_parm)); - } - if (current_function_check_memory_usage) - { - push_to_sequence (conversion_insns); - emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, - XEXP (stack_parm, 0), ptr_mode, - GEN_INT (GET_MODE_SIZE (GET_MODE - (entry_parm))), - TYPE_MODE (sizetype), - GEN_INT (MEMORY_USE_RW), - TYPE_MODE (integer_type_node)); - - conversion_insns = get_insns (); - end_sequence (); - } - DECL_RTL (parm) = stack_parm; - } - - /* If this "parameter" was the place where we are receiving the - function's incoming structure pointer, set up the result. */ - if (parm == function_result_decl) - { - tree result = DECL_RESULT (fndecl); - tree restype = TREE_TYPE (result); - - DECL_RTL (result) - = gen_rtx_MEM (DECL_MODE (result), DECL_RTL (parm)); - - MEM_SET_IN_STRUCT_P (DECL_RTL (result), - AGGREGATE_TYPE_P (restype)); - } - - if (TREE_THIS_VOLATILE (parm)) - MEM_VOLATILE_P (DECL_RTL (parm)) = 1; - if (TREE_READONLY (parm)) - RTX_UNCHANGING_P (DECL_RTL (parm)) = 1; - } - - /* Output all parameter conversion instructions (possibly including calls) - now that all parameters have been copied out of hard registers. */ - emit_insns (conversion_insns); - - last_parm_insn = get_last_insn (); - - current_function_args_size = stack_args_size.constant; - - /* Adjust function incoming argument size for alignment and - minimum length. */ - -#ifdef REG_PARM_STACK_SPACE -#ifndef MAYBE_REG_PARM_STACK_SPACE - current_function_args_size = MAX (current_function_args_size, - REG_PARM_STACK_SPACE (fndecl)); -#endif -#endif - -#ifdef PREFERRED_STACK_BOUNDARY -#define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT) - - current_function_args_size - = ((current_function_args_size + STACK_BYTES - 1) - / STACK_BYTES) * STACK_BYTES; -#endif - -#ifdef ARGS_GROW_DOWNWARD - current_function_arg_offset_rtx - = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant) - : expand_expr (size_binop (MINUS_EXPR, stack_args_size.var, - size_int (-stack_args_size.constant)), - NULL_RTX, VOIDmode, EXPAND_MEMORY_USE_BAD)); -#else - current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size); -#endif - - /* See how many bytes, if any, of its args a function should try to pop - on return. */ - - current_function_pops_args = RETURN_POPS_ARGS (fndecl, TREE_TYPE (fndecl), - current_function_args_size); - - /* For stdarg.h function, save info about - regs and stack space used by the named args. */ - - if (!hide_last_arg) - current_function_args_info = args_so_far; - - /* Set the rtx used for the function return value. Put this in its - own variable so any optimizers that need this information don't have - to include tree.h. Do this here so it gets done when an inlined - function gets output. */ - - current_function_return_rtx = DECL_RTL (DECL_RESULT (fndecl)); -} - -/* Indicate whether REGNO is an incoming argument to the current function - that was promoted to a wider mode. If so, return the RTX for the - register (to get its mode). PMODE and PUNSIGNEDP are set to the mode - that REGNO is promoted from and whether the promotion was signed or - unsigned. */ - -#ifdef PROMOTE_FUNCTION_ARGS - -rtx -promoted_input_arg (regno, pmode, punsignedp) - int regno; - enum machine_mode *pmode; - int *punsignedp; -{ - tree arg; - - for (arg = DECL_ARGUMENTS (current_function_decl); arg; - arg = TREE_CHAIN (arg)) - if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG - && REGNO (DECL_INCOMING_RTL (arg)) == regno - && TYPE_MODE (DECL_ARG_TYPE (arg)) == TYPE_MODE (TREE_TYPE (arg))) - { - enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg)); - int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg)); - - mode = promote_mode (TREE_TYPE (arg), mode, &unsignedp, 1); - if (mode == GET_MODE (DECL_INCOMING_RTL (arg)) - && mode != DECL_MODE (arg)) - { - *pmode = DECL_MODE (arg); - *punsignedp = unsignedp; - return DECL_INCOMING_RTL (arg); - } - } - - return 0; -} - -#endif - -/* Compute the size and offset from the start of the stacked arguments for a - parm passed in mode PASSED_MODE and with type TYPE. - - INITIAL_OFFSET_PTR points to the current offset into the stacked - arguments. - - The starting offset and size for this parm are returned in *OFFSET_PTR - and *ARG_SIZE_PTR, respectively. - - IN_REGS is non-zero if the argument will be passed in registers. It will - never be set if REG_PARM_STACK_SPACE is not defined. - - FNDECL is the function in which the argument was defined. - - There are two types of rounding that are done. The first, controlled by - FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument - list to be aligned to the specific boundary (in bits). This rounding - affects the initial and starting offsets, but not the argument size. - - The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY, - optionally rounds the size of the parm to PARM_BOUNDARY. The - initial offset is not affected by this rounding, while the size always - is and the starting offset may be. */ - -/* offset_ptr will be negative for ARGS_GROW_DOWNWARD case; - initial_offset_ptr is positive because locate_and_pad_parm's - callers pass in the total size of args so far as - initial_offset_ptr. arg_size_ptr is always positive.*/ - -void -locate_and_pad_parm (passed_mode, type, in_regs, fndecl, - initial_offset_ptr, offset_ptr, arg_size_ptr) - enum machine_mode passed_mode; - tree type; - int in_regs; - tree fndecl; - struct args_size *initial_offset_ptr; - struct args_size *offset_ptr; - struct args_size *arg_size_ptr; -{ - tree sizetree - = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode)); - enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type); - int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type); - -#ifdef REG_PARM_STACK_SPACE - /* If we have found a stack parm before we reach the end of the - area reserved for registers, skip that area. */ - if (! in_regs) - { - int reg_parm_stack_space = 0; - -#ifdef MAYBE_REG_PARM_STACK_SPACE - reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE; -#else - reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl); -#endif - if (reg_parm_stack_space > 0) - { - if (initial_offset_ptr->var) - { - initial_offset_ptr->var - = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr), - size_int (reg_parm_stack_space)); - initial_offset_ptr->constant = 0; - } - else if (initial_offset_ptr->constant < reg_parm_stack_space) - initial_offset_ptr->constant = reg_parm_stack_space; - } - } -#endif /* REG_PARM_STACK_SPACE */ - - arg_size_ptr->var = 0; - arg_size_ptr->constant = 0; - -#ifdef ARGS_GROW_DOWNWARD - if (initial_offset_ptr->var) - { - offset_ptr->constant = 0; - offset_ptr->var = size_binop (MINUS_EXPR, integer_zero_node, - initial_offset_ptr->var); - } - else - { - offset_ptr->constant = - initial_offset_ptr->constant; - offset_ptr->var = 0; - } - if (where_pad != none - && (TREE_CODE (sizetree) != INTEGER_CST - || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY))) - sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); - SUB_PARM_SIZE (*offset_ptr, sizetree); - if (where_pad != downward) - pad_to_arg_alignment (offset_ptr, boundary); - if (initial_offset_ptr->var) - { - arg_size_ptr->var = size_binop (MINUS_EXPR, - size_binop (MINUS_EXPR, - integer_zero_node, - initial_offset_ptr->var), - offset_ptr->var); - } - else - { - arg_size_ptr->constant = (- initial_offset_ptr->constant - - offset_ptr->constant); - } -#else /* !ARGS_GROW_DOWNWARD */ - pad_to_arg_alignment (initial_offset_ptr, boundary); - *offset_ptr = *initial_offset_ptr; - -#ifdef PUSH_ROUNDING - if (passed_mode != BLKmode) - sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree))); -#endif - - /* Pad_below needs the pre-rounded size to know how much to pad below - so this must be done before rounding up. */ - if (where_pad == downward - /* However, BLKmode args passed in regs have their padding done elsewhere. - The stack slot must be able to hold the entire register. */ - && !(in_regs && passed_mode == BLKmode)) - pad_below (offset_ptr, passed_mode, sizetree); - - if (where_pad != none - && (TREE_CODE (sizetree) != INTEGER_CST - || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY))) - sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); - - ADD_PARM_SIZE (*arg_size_ptr, sizetree); -#endif /* ARGS_GROW_DOWNWARD */ -} - -/* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY. - BOUNDARY is measured in bits, but must be a multiple of a storage unit. */ - -static void -pad_to_arg_alignment (offset_ptr, boundary) - struct args_size *offset_ptr; - int boundary; -{ - int boundary_in_bytes = boundary / BITS_PER_UNIT; - - if (boundary > BITS_PER_UNIT) - { - if (offset_ptr->var) - { - offset_ptr->var = -#ifdef ARGS_GROW_DOWNWARD - round_down -#else - round_up -#endif - (ARGS_SIZE_TREE (*offset_ptr), - boundary / BITS_PER_UNIT); - offset_ptr->constant = 0; /*?*/ - } - else - offset_ptr->constant = -#ifdef ARGS_GROW_DOWNWARD - FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes); -#else - CEIL_ROUND (offset_ptr->constant, boundary_in_bytes); -#endif - } -} - -#ifndef ARGS_GROW_DOWNWARD -static void -pad_below (offset_ptr, passed_mode, sizetree) - struct args_size *offset_ptr; - enum machine_mode passed_mode; - tree sizetree; -{ - if (passed_mode != BLKmode) - { - if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY) - offset_ptr->constant - += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1) - / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT) - - GET_MODE_SIZE (passed_mode)); - } - else - { - if (TREE_CODE (sizetree) != INTEGER_CST - || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY) - { - /* Round the size up to multiple of PARM_BOUNDARY bits. */ - tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT); - /* Add it in. */ - ADD_PARM_SIZE (*offset_ptr, s2); - SUB_PARM_SIZE (*offset_ptr, sizetree); - } - } -} -#endif - -#ifdef ARGS_GROW_DOWNWARD -static tree -round_down (value, divisor) - tree value; - int divisor; -{ - return size_binop (MULT_EXPR, - size_binop (FLOOR_DIV_EXPR, value, size_int (divisor)), - size_int (divisor)); -} -#endif - -/* Walk the tree of blocks describing the binding levels within a function - and warn about uninitialized variables. - This is done after calling flow_analysis and before global_alloc - clobbers the pseudo-regs to hard regs. */ - -void -uninitialized_vars_warning (block) - tree block; -{ - register tree decl, sub; - for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) - { - if (TREE_CODE (decl) == VAR_DECL - /* These warnings are unreliable for and aggregates - because assigning the fields one by one can fail to convince - flow.c that the entire aggregate was initialized. - Unions are troublesome because members may be shorter. */ - && ! AGGREGATE_TYPE_P (TREE_TYPE (decl)) - && DECL_RTL (decl) != 0 - && GET_CODE (DECL_RTL (decl)) == REG - /* Global optimizations can make it difficult to determine if a - particular variable has been initialized. However, a VAR_DECL - with a nonzero DECL_INITIAL had an initializer, so do not - claim it is potentially uninitialized. - - We do not care about the actual value in DECL_INITIAL, so we do - not worry that it may be a dangling pointer. */ - && DECL_INITIAL (decl) == NULL_TREE - && regno_uninitialized (REGNO (DECL_RTL (decl)))) - warning_with_decl (decl, - "`%s' might be used uninitialized in this function"); - if (TREE_CODE (decl) == VAR_DECL - && DECL_RTL (decl) != 0 - && GET_CODE (DECL_RTL (decl)) == REG - && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) - warning_with_decl (decl, - "variable `%s' might be clobbered by `longjmp' or `vfork'"); - } - for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) - uninitialized_vars_warning (sub); -} - -/* Do the appropriate part of uninitialized_vars_warning - but for arguments instead of local variables. */ - -void -setjmp_args_warning () -{ - register tree decl; - for (decl = DECL_ARGUMENTS (current_function_decl); - decl; decl = TREE_CHAIN (decl)) - if (DECL_RTL (decl) != 0 - && GET_CODE (DECL_RTL (decl)) == REG - && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl)))) - warning_with_decl (decl, "argument `%s' might be clobbered by `longjmp' or `vfork'"); -} - -/* If this function call setjmp, put all vars into the stack - unless they were declared `register'. */ - -void -setjmp_protect (block) - tree block; -{ - register tree decl, sub; - for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) - if ((TREE_CODE (decl) == VAR_DECL - || TREE_CODE (decl) == PARM_DECL) - && DECL_RTL (decl) != 0 - && (GET_CODE (DECL_RTL (decl)) == REG - || (GET_CODE (DECL_RTL (decl)) == MEM - && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF)) - /* If this variable came from an inline function, it must be - that its life doesn't overlap the setjmp. If there was a - setjmp in the function, it would already be in memory. We - must exclude such variable because their DECL_RTL might be - set to strange things such as virtual_stack_vars_rtx. */ - && ! DECL_FROM_INLINE (decl) - && ( -#ifdef NON_SAVING_SETJMP - /* If longjmp doesn't restore the registers, - don't put anything in them. */ - NON_SAVING_SETJMP - || -#endif - ! DECL_REGISTER (decl))) - put_var_into_stack (decl); - for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) - setjmp_protect (sub); -} - -/* Like the previous function, but for args instead of local variables. */ - -void -setjmp_protect_args () -{ - register tree decl; - for (decl = DECL_ARGUMENTS (current_function_decl); - decl; decl = TREE_CHAIN (decl)) - if ((TREE_CODE (decl) == VAR_DECL - || TREE_CODE (decl) == PARM_DECL) - && DECL_RTL (decl) != 0 - && (GET_CODE (DECL_RTL (decl)) == REG - || (GET_CODE (DECL_RTL (decl)) == MEM - && GET_CODE (XEXP (DECL_RTL (decl), 0)) == ADDRESSOF)) - && ( - /* If longjmp doesn't restore the registers, - don't put anything in them. */ -#ifdef NON_SAVING_SETJMP - NON_SAVING_SETJMP - || -#endif - ! DECL_REGISTER (decl))) - put_var_into_stack (decl); -} - -/* Return the context-pointer register corresponding to DECL, - or 0 if it does not need one. */ - -rtx -lookup_static_chain (decl) - tree decl; -{ - tree context = decl_function_context (decl); - tree link; - - if (context == 0 - || (TREE_CODE (decl) == FUNCTION_DECL && DECL_NO_STATIC_CHAIN (decl))) - return 0; - - /* We treat inline_function_decl as an alias for the current function - because that is the inline function whose vars, types, etc. - are being merged into the current function. - See expand_inline_function. */ - if (context == current_function_decl || context == inline_function_decl) - return virtual_stack_vars_rtx; - - for (link = context_display; link; link = TREE_CHAIN (link)) - if (TREE_PURPOSE (link) == context) - return RTL_EXPR_RTL (TREE_VALUE (link)); - - abort (); -} - -/* Convert a stack slot address ADDR for variable VAR - (from a containing function) - into an address valid in this function (using a static chain). */ - -rtx -fix_lexical_addr (addr, var) - rtx addr; - tree var; -{ - rtx basereg; - HOST_WIDE_INT displacement; - tree context = decl_function_context (var); - struct function *fp; - rtx base = 0; - - /* If this is the present function, we need not do anything. */ - if (context == current_function_decl || context == inline_function_decl) - return addr; - - for (fp = outer_function_chain; fp; fp = fp->next) - if (fp->decl == context) - break; - - if (fp == 0) - abort (); - - if (GET_CODE (addr) == ADDRESSOF && GET_CODE (XEXP (addr, 0)) == MEM) - addr = XEXP (XEXP (addr, 0), 0); - - /* Decode given address as base reg plus displacement. */ - if (GET_CODE (addr) == REG) - basereg = addr, displacement = 0; - else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT) - basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1)); - else - abort (); - - /* We accept vars reached via the containing function's - incoming arg pointer and via its stack variables pointer. */ - if (basereg == fp->internal_arg_pointer) - { - /* If reached via arg pointer, get the arg pointer value - out of that function's stack frame. - - There are two cases: If a separate ap is needed, allocate a - slot in the outer function for it and dereference it that way. - This is correct even if the real ap is actually a pseudo. - Otherwise, just adjust the offset from the frame pointer to - compensate. */ - -#ifdef NEED_SEPARATE_AP - rtx addr; - - if (fp->arg_pointer_save_area == 0) - fp->arg_pointer_save_area - = assign_outer_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0, fp); - - addr = fix_lexical_addr (XEXP (fp->arg_pointer_save_area, 0), var); - addr = memory_address (Pmode, addr); - - base = copy_to_reg (gen_rtx_MEM (Pmode, addr)); -#else - displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET); - base = lookup_static_chain (var); -#endif - } - - else if (basereg == virtual_stack_vars_rtx) - { - /* This is the same code as lookup_static_chain, duplicated here to - avoid an extra call to decl_function_context. */ - tree link; - - for (link = context_display; link; link = TREE_CHAIN (link)) - if (TREE_PURPOSE (link) == context) - { - base = RTL_EXPR_RTL (TREE_VALUE (link)); - break; - } - } - - if (base == 0) - abort (); - - /* Use same offset, relative to appropriate static chain or argument - pointer. */ - return plus_constant (base, displacement); -} - -/* Return the address of the trampoline for entering nested fn FUNCTION. - If necessary, allocate a trampoline (in the stack frame) - and emit rtl to initialize its contents (at entry to this function). */ - -rtx -trampoline_address (function) - tree function; -{ - tree link; - tree rtlexp; - rtx tramp; - struct function *fp; - tree fn_context; - - /* Find an existing trampoline and return it. */ - for (link = trampoline_list; link; link = TREE_CHAIN (link)) - if (TREE_PURPOSE (link) == function) - return - round_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0)); - - for (fp = outer_function_chain; fp; fp = fp->next) - for (link = fp->trampoline_list; link; link = TREE_CHAIN (link)) - if (TREE_PURPOSE (link) == function) - { - tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0), - function); - return round_trampoline_addr (tramp); - } - - /* None exists; we must make one. */ - - /* Find the `struct function' for the function containing FUNCTION. */ - fp = 0; - fn_context = decl_function_context (function); - if (fn_context != current_function_decl - && fn_context != inline_function_decl) - for (fp = outer_function_chain; fp; fp = fp->next) - if (fp->decl == fn_context) - break; - - /* Allocate run-time space for this trampoline - (usually in the defining function's stack frame). */ -#ifdef ALLOCATE_TRAMPOLINE - tramp = ALLOCATE_TRAMPOLINE (fp); -#else - /* If rounding needed, allocate extra space - to ensure we have TRAMPOLINE_SIZE bytes left after rounding up. */ -#ifdef TRAMPOLINE_ALIGNMENT -#define TRAMPOLINE_REAL_SIZE \ - (TRAMPOLINE_SIZE + (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT) - 1) -#else -#define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE) -#endif - if (fp != 0) - tramp = assign_outer_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0, fp); - else - tramp = assign_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0); -#endif - - /* Record the trampoline for reuse and note it for later initialization - by expand_function_end. */ - if (fp != 0) - { - push_obstacks (fp->function_maybepermanent_obstack, - fp->function_maybepermanent_obstack); - rtlexp = make_node (RTL_EXPR); - RTL_EXPR_RTL (rtlexp) = tramp; - fp->trampoline_list = tree_cons (function, rtlexp, fp->trampoline_list); - pop_obstacks (); - } - else - { - /* Make the RTL_EXPR node temporary, not momentary, so that the - trampoline_list doesn't become garbage. */ - int momentary = suspend_momentary (); - rtlexp = make_node (RTL_EXPR); - resume_momentary (momentary); - - RTL_EXPR_RTL (rtlexp) = tramp; - trampoline_list = tree_cons (function, rtlexp, trampoline_list); - } - - tramp = fix_lexical_addr (XEXP (tramp, 0), function); - return round_trampoline_addr (tramp); -} - -/* Given a trampoline address, - round it to multiple of TRAMPOLINE_ALIGNMENT. */ - -static rtx -round_trampoline_addr (tramp) - rtx tramp; -{ -#ifdef TRAMPOLINE_ALIGNMENT - /* Round address up to desired boundary. */ - rtx temp = gen_reg_rtx (Pmode); - temp = expand_binop (Pmode, add_optab, tramp, - GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1), - temp, 0, OPTAB_LIB_WIDEN); - tramp = expand_binop (Pmode, and_optab, temp, - GEN_INT (- TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT), - temp, 0, OPTAB_LIB_WIDEN); -#endif - return tramp; -} - -/* The functions identify_blocks and reorder_blocks provide a way to - reorder the tree of BLOCK nodes, for optimizers that reshuffle or - duplicate portions of the RTL code. Call identify_blocks before - changing the RTL, and call reorder_blocks after. */ - -/* Put all this function's BLOCK nodes including those that are chained - onto the first block into a vector, and return it. - Also store in each NOTE for the beginning or end of a block - the index of that block in the vector. - The arguments are BLOCK, the chain of top-level blocks of the function, - and INSNS, the insn chain of the function. */ - -tree * -identify_blocks (block, insns) - tree block; - rtx insns; -{ - int n_blocks; - tree *block_vector; - int *block_stack; - int depth = 0; - int next_block_number = 1; - int current_block_number = 1; - rtx insn; - - if (block == 0) - return 0; - - n_blocks = all_blocks (block, 0); - block_vector = (tree *) xmalloc (n_blocks * sizeof (tree)); - block_stack = (int *) alloca (n_blocks * sizeof (int)); - - all_blocks (block, block_vector); - - for (insn = insns; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == NOTE) - { - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) - { - block_stack[depth++] = current_block_number; - current_block_number = next_block_number; - NOTE_BLOCK_NUMBER (insn) = next_block_number++; - } - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) - { - NOTE_BLOCK_NUMBER (insn) = current_block_number; - current_block_number = block_stack[--depth]; - } - } - - if (n_blocks != next_block_number) - abort (); - - return block_vector; -} - -/* Given BLOCK_VECTOR which was returned by identify_blocks, - and a revised instruction chain, rebuild the tree structure - of BLOCK nodes to correspond to the new order of RTL. - The new block tree is inserted below TOP_BLOCK. - Returns the current top-level block. */ - -tree -reorder_blocks (block_vector, block, insns) - tree *block_vector; - tree block; - rtx insns; -{ - tree current_block = block; - rtx insn; - - if (block_vector == 0) - return block; - - /* Prune the old trees away, so that it doesn't get in the way. */ - BLOCK_SUBBLOCKS (current_block) = 0; - BLOCK_CHAIN (current_block) = 0; - - /* CYGNUS LOCAL LRS */ - for (insn = insns; insn; insn = NEXT_INSN (insn)) - { - tree block, range_start_block = NULL_TREE; - - if (GET_CODE (insn) == NOTE) - switch (NOTE_LINE_NUMBER (insn)) - { - /* Block beginning, link into block chain */ - case NOTE_INSN_BLOCK_BEG: - if (NOTE_BLOCK_NUMBER (insn) == NOTE_BLOCK_LIVE_RANGE_BLOCK) - { - range_start_block = block = make_node (BLOCK); - BLOCK_LIVE_RANGE_FLAG (block) = TRUE; - TREE_USED (block) = TRUE; - } - else if (NOTE_BLOCK_NUMBER (insn) <= 0) - abort (); - else - { - block = block_vector[NOTE_BLOCK_NUMBER (insn)]; - range_start_block = NULL_TREE; - - /* If we have seen this block before, copy it. */ - if (TREE_ASM_WRITTEN (block)) - block = copy_node (block); - } - - BLOCK_SUBBLOCKS (block) = 0; - TREE_ASM_WRITTEN (block) = 1; - BLOCK_SUPERCONTEXT (block) = current_block; - BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block); - BLOCK_SUBBLOCKS (current_block) = block; - NOTE_SOURCE_FILE (insn) = 0; - current_block = block; - break; - - /* Block ending, restore current block, reset block number. */ - case NOTE_INSN_BLOCK_END: - BLOCK_SUBBLOCKS (current_block) - = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); - current_block = BLOCK_SUPERCONTEXT (current_block); - NOTE_BLOCK_NUMBER (insn) = 0; - break; - - /* Range start, if we created a new block for the range, link - any new copies into the range. */ - case NOTE_INSN_RANGE_START: - if (range_start_block) - { - rtx ri = NOTE_RANGE_INFO (insn); - int i; - for (i = 0; i < (int)RANGE_INFO_NUM_REGS (ri); i++) - if (RANGE_REG_SYMBOL_NODE (ri, i)) - { - tree new_sym = copy_node (RANGE_REG_SYMBOL_NODE (ri, i)); - DECL_RTL (new_sym) = regno_reg_rtx[RANGE_REG_COPY (ri, i)]; - TREE_CHAIN (new_sym) = BLOCK_VARS (range_start_block); - BLOCK_VARS (range_start_block) = new_sym; - RANGE_REG_SYMBOL_NODE (ri, i) = new_sym; - RANGE_REG_BLOCK_NODE (ri, i) = range_start_block; - } - } - break; - } - } - /* END CYGNUS LOCAL */ - - BLOCK_SUBBLOCKS (current_block) - = blocks_nreverse (BLOCK_SUBBLOCKS (current_block)); - return current_block; -} - -/* Reverse the order of elements in the chain T of blocks, - and return the new head of the chain (old last element). */ - -static tree -blocks_nreverse (t) - tree t; -{ - register tree prev = 0, decl, next; - for (decl = t; decl; decl = next) - { - next = BLOCK_CHAIN (decl); - BLOCK_CHAIN (decl) = prev; - prev = decl; - } - return prev; -} - -/* Count the subblocks of the list starting with BLOCK, and list them - all into the vector VECTOR. Also clear TREE_ASM_WRITTEN in all - blocks. */ - -static int -all_blocks (block, vector) - tree block; - tree *vector; -{ - int n_blocks = 0; - - while (block) - { - TREE_ASM_WRITTEN (block) = 0; - - /* Record this block. */ - if (vector) - vector[n_blocks] = block; - - ++n_blocks; - - /* Record the subblocks, and their subblocks... */ - n_blocks += all_blocks (BLOCK_SUBBLOCKS (block), - vector ? vector + n_blocks : 0); - block = BLOCK_CHAIN (block); - } - - return n_blocks; -} - -/* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node) - and initialize static variables for generating RTL for the statements - of the function. */ - -void -init_function_start (subr, filename, line) - tree subr; - char *filename; - int line; -{ - init_stmt_for_function (); - - cse_not_expected = ! optimize; - - /* Caller save not needed yet. */ - caller_save_needed = 0; - - /* No stack slots have been made yet. */ - stack_slot_list = 0; - - /* There is no stack slot for handling nonlocal gotos. */ - nonlocal_goto_handler_slots = 0; - nonlocal_goto_stack_level = 0; - - /* No labels have been declared for nonlocal use. */ - nonlocal_labels = 0; - - /* No function calls so far in this function. */ - function_call_count = 0; - - /* No parm regs have been allocated. - (This is important for output_inline_function.) */ - max_parm_reg = LAST_VIRTUAL_REGISTER + 1; - - /* Initialize the RTL mechanism. */ - init_emit (); - - /* Initialize the queue of pending postincrement and postdecrements, - and some other info in expr.c. */ - init_expr (); - - /* We haven't done register allocation yet. */ - reg_renumber = 0; - - init_const_rtx_hash_table (); - - current_function_name = (*decl_printable_name) (subr, 2); - - /* Nonzero if this is a nested function that uses a static chain. */ - - current_function_needs_context - = (decl_function_context (current_function_decl) != 0 - && ! DECL_NO_STATIC_CHAIN (current_function_decl)); - - /* Set if a call to setjmp is seen. */ - current_function_calls_setjmp = 0; - - /* Set if a call to longjmp is seen. */ - current_function_calls_longjmp = 0; - - current_function_calls_alloca = 0; - current_function_has_nonlocal_label = 0; - current_function_has_nonlocal_goto = 0; - current_function_contains_functions = 0; - current_function_sp_is_unchanging = 0; - current_function_is_thunk = 0; - - current_function_returns_pcc_struct = 0; - current_function_returns_struct = 0; - current_function_epilogue_delay_list = 0; - current_function_uses_const_pool = 0; - current_function_uses_pic_offset_table = 0; - current_function_cannot_inline = 0; - /* CYGNUS LOCAL -- Branch Prediction */ - current_function_uses_expect = 0; - current_function_processing_expect = 0; - /* END CYGNUS LOCAL -- Branch Prediction */ - - /* We have not yet needed to make a label to jump to for tail-recursion. */ - tail_recursion_label = 0; - - /* We haven't had a need to make a save area for ap yet. */ - - arg_pointer_save_area = 0; - - /* No stack slots allocated yet. */ - frame_offset = 0; - - /* No SAVE_EXPRs in this function yet. */ - save_expr_regs = 0; - - /* No RTL_EXPRs in this function yet. */ - rtl_expr_chain = 0; - - /* Set up to allocate temporaries. */ - init_temp_slots (); - - /* Within function body, compute a type's size as soon it is laid out. */ - immediate_size_expand++; - - /* We haven't made any trampolines for this function yet. */ - trampoline_list = 0; - - init_pending_stack_adjust (); - inhibit_defer_pop = 0; - - current_function_outgoing_args_size = 0; - - /* Prevent ever trying to delete the first instruction of a function. - Also tell final how to output a linenum before the function prologue. - Note linenums could be missing, e.g. when compiling a Java .class file. */ - if (line > 0) - emit_line_note (filename, line); - - /* Make sure first insn is a note even if we don't want linenums. - This makes sure the first insn will never be deleted. - Also, final expects a note to appear there. */ - emit_note (NULL_PTR, NOTE_INSN_DELETED); - - /* Set flags used by final.c. */ - if (aggregate_value_p (DECL_RESULT (subr))) - { -#ifdef PCC_STATIC_STRUCT_RETURN - current_function_returns_pcc_struct = 1; -#endif - current_function_returns_struct = 1; - } - - /* Warn if this value is an aggregate type, - regardless of which calling convention we are using for it. */ - if (warn_aggregate_return - && AGGREGATE_TYPE_P (TREE_TYPE (DECL_RESULT (subr)))) - warning ("function returns an aggregate"); - - current_function_returns_pointer - = POINTER_TYPE_P (TREE_TYPE (DECL_RESULT (subr))); - - /* Indicate that we need to distinguish between the return value of the - present function and the return value of a function being called. */ - rtx_equal_function_value_matters = 1; - - /* Indicate that we have not instantiated virtual registers yet. */ - virtuals_instantiated = 0; - - /* Indicate we have no need of a frame pointer yet. */ - frame_pointer_needed = 0; - - /* By default assume not varargs or stdarg. */ - current_function_varargs = 0; - current_function_stdarg = 0; -} - -/* Indicate that the current function uses extra args - not explicitly mentioned in the argument list in any fashion. */ - -void -mark_varargs () -{ - current_function_varargs = 1; -} - -/* Expand a call to __main at the beginning of a possible main function. */ - -#if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main) -#undef HAS_INIT_SECTION -#define HAS_INIT_SECTION -#endif - -void -expand_main_function () -{ -#if !defined (HAS_INIT_SECTION) - emit_library_call (gen_rtx_SYMBOL_REF (Pmode, NAME__MAIN), 0, - VOIDmode, 0); -#endif /* not HAS_INIT_SECTION */ -} - -extern struct obstack permanent_obstack; - -/* Start the RTL for a new function, and set variables used for - emitting RTL. - SUBR is the FUNCTION_DECL node. - PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with - the function's parameters, which must be run at any return statement. */ - -void -expand_function_start (subr, parms_have_cleanups) - tree subr; - int parms_have_cleanups; -{ - register int i; - tree tem; - rtx last_ptr = NULL_RTX; - - /* Make sure volatile mem refs aren't considered - valid operands of arithmetic insns. */ - init_recog_no_volatile (); - - /* Set this before generating any memory accesses. */ - current_function_check_memory_usage - = (flag_check_memory_usage - && ! DECL_NO_CHECK_MEMORY_USAGE (current_function_decl)); - - current_function_instrument_entry_exit - = (flag_instrument_function_entry_exit - && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (subr)); - - /* If function gets a static chain arg, store it in the stack frame. - Do this first, so it gets the first stack slot offset. */ - if (current_function_needs_context) - { - last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0); - - /* Delay copying static chain if it is not a register to avoid - conflicts with regs used for parameters. */ - if (! SMALL_REGISTER_CLASSES - || GET_CODE (static_chain_incoming_rtx) == REG) - emit_move_insn (last_ptr, static_chain_incoming_rtx); - } - - /* If the parameters of this function need cleaning up, get a label - for the beginning of the code which executes those cleanups. This must - be done before doing anything with return_label. */ - if (parms_have_cleanups) - cleanup_label = gen_label_rtx (); - else - cleanup_label = 0; - - /* Make the label for return statements to jump to, if this machine - does not have a one-instruction return and uses an epilogue, - or if it returns a structure, or if it has parm cleanups. */ -#ifdef HAVE_return - if (cleanup_label == 0 && HAVE_return - && ! current_function_instrument_entry_exit - && ! current_function_returns_pcc_struct - && ! (current_function_returns_struct && ! optimize)) - return_label = 0; - else - return_label = gen_label_rtx (); -#else - return_label = gen_label_rtx (); -#endif - - /* Initialize rtx used to return the value. */ - /* Do this before assign_parms so that we copy the struct value address - before any library calls that assign parms might generate. */ - - /* Decide whether to return the value in memory or in a register. */ - if (aggregate_value_p (DECL_RESULT (subr))) - { - /* Returning something that won't go in a register. */ - register rtx value_address = 0; - -#ifdef PCC_STATIC_STRUCT_RETURN - if (current_function_returns_pcc_struct) - { - int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr))); - value_address = assemble_static_space (size); - } - else -#endif - { - /* Expect to be passed the address of a place to store the value. - If it is passed as an argument, assign_parms will take care of - it. */ - if (struct_value_incoming_rtx) - { - value_address = gen_reg_rtx (Pmode); - emit_move_insn (value_address, struct_value_incoming_rtx); - } - } - if (value_address) - { - DECL_RTL (DECL_RESULT (subr)) - = gen_rtx_MEM (DECL_MODE (DECL_RESULT (subr)), value_address); - MEM_SET_IN_STRUCT_P (DECL_RTL (DECL_RESULT (subr)), - AGGREGATE_TYPE_P (TREE_TYPE - (DECL_RESULT - (subr)))); - } - } - else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode) - /* If return mode is void, this decl rtl should not be used. */ - DECL_RTL (DECL_RESULT (subr)) = 0; - else if (parms_have_cleanups || current_function_instrument_entry_exit) - { - /* If function will end with cleanup code for parms, - compute the return values into a pseudo reg, - which we will copy into the true return register - after the cleanups are done. */ - - enum machine_mode mode = DECL_MODE (DECL_RESULT (subr)); - -#ifdef PROMOTE_FUNCTION_RETURN - tree type = TREE_TYPE (DECL_RESULT (subr)); - int unsignedp = TREE_UNSIGNED (type); - - mode = promote_mode (type, mode, &unsignedp, 1); -#endif - - DECL_RTL (DECL_RESULT (subr)) = gen_reg_rtx (mode); - } - else - /* Scalar, returned in a register. */ - { -#ifdef FUNCTION_OUTGOING_VALUE - DECL_RTL (DECL_RESULT (subr)) - = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr); -#else - DECL_RTL (DECL_RESULT (subr)) - = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr); -#endif - - /* Mark this reg as the function's return value. */ - if (GET_CODE (DECL_RTL (DECL_RESULT (subr))) == REG) - { - REG_FUNCTION_VALUE_P (DECL_RTL (DECL_RESULT (subr))) = 1; - /* Needed because we may need to move this to memory - in case it's a named return value whose address is taken. */ - DECL_REGISTER (DECL_RESULT (subr)) = 1; - } - } - - /* Initialize rtx for parameters and local variables. - In some cases this requires emitting insns. */ - - assign_parms (subr, 0); - - /* Copy the static chain now if it wasn't a register. The delay is to - avoid conflicts with the parameter passing registers. */ - - if (SMALL_REGISTER_CLASSES && current_function_needs_context) - if (GET_CODE (static_chain_incoming_rtx) != REG) - emit_move_insn (last_ptr, static_chain_incoming_rtx); - - /* The following was moved from init_function_start. - The move is supposed to make sdb output more accurate. */ - /* Indicate the beginning of the function body, - as opposed to parm setup. */ - emit_note (NULL_PTR, NOTE_INSN_FUNCTION_BEG); - - /* If doing stupid allocation, mark parms as born here. */ - - if (GET_CODE (get_last_insn ()) != NOTE) - emit_note (NULL_PTR, NOTE_INSN_DELETED); - parm_birth_insn = get_last_insn (); - - if (obey_regdecls) - { - for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++) - use_variable (regno_reg_rtx[i]); - - if (current_function_internal_arg_pointer != virtual_incoming_args_rtx) - use_variable (current_function_internal_arg_pointer); - } - - context_display = 0; - if (current_function_needs_context) - { - /* Fetch static chain values for containing functions. */ - tem = decl_function_context (current_function_decl); - /* If not doing stupid register allocation copy the static chain - pointer into a pseudo. If we have small register classes, copy - the value from memory if static_chain_incoming_rtx is a REG. If - we do stupid register allocation, we use the stack address - generated above. */ - if (tem && ! obey_regdecls) - { - /* If the static chain originally came in a register, put it back - there, then move it out in the next insn. The reason for - this peculiar code is to satisfy function integration. */ - if (SMALL_REGISTER_CLASSES - && GET_CODE (static_chain_incoming_rtx) == REG) - emit_move_insn (static_chain_incoming_rtx, last_ptr); - last_ptr = copy_to_reg (static_chain_incoming_rtx); - } - - while (tem) - { - tree rtlexp = make_node (RTL_EXPR); - - RTL_EXPR_RTL (rtlexp) = last_ptr; - context_display = tree_cons (tem, rtlexp, context_display); - tem = decl_function_context (tem); - if (tem == 0) - break; - /* Chain thru stack frames, assuming pointer to next lexical frame - is found at the place we always store it. */ -#ifdef FRAME_GROWS_DOWNWARD - last_ptr = plus_constant (last_ptr, - GET_MODE_SIZE (Pmode)); -#endif - last_ptr = copy_to_reg (gen_rtx_MEM (Pmode, - memory_address (Pmode, last_ptr))); - - /* If we are not optimizing, ensure that we know that this - piece of context is live over the entire function. */ - if (! optimize) - save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, last_ptr, - save_expr_regs); - } - } - - if (current_function_instrument_entry_exit) - { - rtx fun = DECL_RTL (current_function_decl); - if (GET_CODE (fun) == MEM) - fun = XEXP (fun, 0); - else - abort (); - emit_library_call (profile_function_entry_libfunc, 0, VOIDmode, 2, - fun, Pmode, - expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, - 0, - hard_frame_pointer_rtx), - Pmode); - } - - /* After the display initializations is where the tail-recursion label - should go, if we end up needing one. Ensure we have a NOTE here - since some things (like trampolines) get placed before this. */ - tail_recursion_reentry = emit_note (NULL_PTR, NOTE_INSN_DELETED); - - /* Evaluate now the sizes of any types declared among the arguments. */ - for (tem = nreverse (get_pending_sizes ()); tem; tem = TREE_CHAIN (tem)) - { - expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, - EXPAND_MEMORY_USE_BAD); - /* Flush the queue in case this parameter declaration has - side-effects. */ - emit_queue (); - } - - /* Make sure there is a line number after the function entry setup code. */ - force_next_line_note (); -} - -/* Generate RTL for the end of the current function. - FILENAME and LINE are the current position in the source file. - - It is up to language-specific callers to do cleanups for parameters-- - or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */ - -void -expand_function_end (filename, line, end_bindings) - char *filename; - int line; - int end_bindings; -{ - register int i; - tree link; - -#ifdef TRAMPOLINE_TEMPLATE - static rtx initial_trampoline; -#endif - -#ifdef NON_SAVING_SETJMP - /* Don't put any variables in registers if we call setjmp - on a machine that fails to restore the registers. */ - if (NON_SAVING_SETJMP && current_function_calls_setjmp) - { - if (DECL_INITIAL (current_function_decl) != error_mark_node) - setjmp_protect (DECL_INITIAL (current_function_decl)); - - setjmp_protect_args (); - } -#endif - - /* Save the argument pointer if a save area was made for it. */ - if (arg_pointer_save_area) - { - /* arg_pointer_save_area may not be a valid memory address, so we - have to check it and fix it if necessary. */ - rtx seq; - start_sequence (); - emit_move_insn (validize_mem (arg_pointer_save_area), - virtual_incoming_args_rtx); - seq = gen_sequence (); - end_sequence (); - emit_insn_before (seq, tail_recursion_reentry); - } - - /* Initialize any trampolines required by this function. */ - for (link = trampoline_list; link; link = TREE_CHAIN (link)) - { - tree function = TREE_PURPOSE (link); - rtx context = lookup_static_chain (function); - rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link)); -#ifdef TRAMPOLINE_TEMPLATE - rtx blktramp; -#endif - rtx seq; - -#ifdef TRAMPOLINE_TEMPLATE - /* First make sure this compilation has a template for - initializing trampolines. */ - if (initial_trampoline == 0) - { - end_temporary_allocation (); - initial_trampoline - = gen_rtx_MEM (BLKmode, assemble_trampoline_template ()); - resume_temporary_allocation (); - } -#endif - - /* Generate insns to initialize the trampoline. */ - start_sequence (); - tramp = round_trampoline_addr (XEXP (tramp, 0)); -#ifdef TRAMPOLINE_TEMPLATE - blktramp = change_address (initial_trampoline, BLKmode, tramp); - emit_block_move (blktramp, initial_trampoline, - GEN_INT (TRAMPOLINE_SIZE), - TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT); -#endif - INITIALIZE_TRAMPOLINE (tramp, XEXP (DECL_RTL (function), 0), context); - seq = get_insns (); - end_sequence (); - - /* Put those insns at entry to the containing function (this one). */ - emit_insns_before (seq, tail_recursion_reentry); - } - - /* If we are doing stack checking and this function makes calls, - do a stack probe at the start of the function to ensure we have enough - space for another stack frame. */ - if (flag_stack_check && ! STACK_CHECK_BUILTIN) - { - rtx insn, seq; - - for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == CALL_INSN) - { - start_sequence (); - probe_stack_range (STACK_CHECK_PROTECT, - GEN_INT (STACK_CHECK_MAX_FRAME_SIZE)); - seq = get_insns (); - end_sequence (); - emit_insns_before (seq, tail_recursion_reentry); - break; - } - } - - /* Warn about unused parms if extra warnings were specified. */ - if (warn_unused && extra_warnings) - { - tree decl; - - for (decl = DECL_ARGUMENTS (current_function_decl); - decl; decl = TREE_CHAIN (decl)) - if (! TREE_USED (decl) && TREE_CODE (decl) == PARM_DECL - && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl)) - warning_with_decl (decl, "unused parameter `%s'"); - } - - /* Delete handlers for nonlocal gotos if nothing uses them. */ - if (nonlocal_goto_handler_slots != 0 - && ! current_function_has_nonlocal_label) - delete_handlers (); - - /* End any sequences that failed to be closed due to syntax errors. */ - while (in_sequence_p ()) - end_sequence (); - - /* Outside function body, can't compute type's actual size - until next function's body starts. */ - immediate_size_expand--; - - /* If doing stupid register allocation, - mark register parms as dying here. */ - - if (obey_regdecls) - { - rtx tem; - for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++) - use_variable (regno_reg_rtx[i]); - - /* Likewise for the regs of all the SAVE_EXPRs in the function. */ - - for (tem = save_expr_regs; tem; tem = XEXP (tem, 1)) - { - use_variable (XEXP (tem, 0)); - use_variable_after (XEXP (tem, 0), parm_birth_insn); - } - - if (current_function_internal_arg_pointer != virtual_incoming_args_rtx) - use_variable (current_function_internal_arg_pointer); - } - - clear_pending_stack_adjust (); - do_pending_stack_adjust (); - - /* Mark the end of the function body. - If control reaches this insn, the function can drop through - without returning a value. */ - emit_note (NULL_PTR, NOTE_INSN_FUNCTION_END); - - /* Output a linenumber for the end of the function. - SDB depends on this. */ - emit_line_note_force (filename, line); - - /* Output the label for the actual return from the function, - if one is expected. This happens either because a function epilogue - is used instead of a return instruction, or because a return was done - with a goto in order to run local cleanups, or because of pcc-style - structure returning. */ - - if (return_label) - emit_label (return_label); - - /* C++ uses this. */ - if (end_bindings) - expand_end_bindings (0, 0, 0); - - /* Now handle any leftover exception regions that may have been - created for the parameters. */ - { - rtx last = get_last_insn (); - rtx label; - - expand_leftover_cleanups (); - - /* If the above emitted any code, may sure we jump around it. */ - if (last != get_last_insn ()) - { - label = gen_label_rtx (); - last = emit_jump_insn_after (gen_jump (label), last); - last = emit_barrier_after (last); - emit_label (label); - } - } - - if (current_function_instrument_entry_exit) - { - rtx fun = DECL_RTL (current_function_decl); - if (GET_CODE (fun) == MEM) - fun = XEXP (fun, 0); - else - abort (); - emit_library_call (profile_function_exit_libfunc, 0, VOIDmode, 2, - fun, Pmode, - expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, - 0, - hard_frame_pointer_rtx), - Pmode); - } - - /* If we had calls to alloca, and this machine needs - an accurate stack pointer to exit the function, - insert some code to save and restore the stack pointer. */ -#ifdef EXIT_IGNORE_STACK - if (! EXIT_IGNORE_STACK) -#endif - if (current_function_calls_alloca) - { - rtx tem = 0; - - emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn); - emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX); - } - - /* If scalar return value was computed in a pseudo-reg, - copy that to the hard return register. */ - if (DECL_RTL (DECL_RESULT (current_function_decl)) != 0 - && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG - && (REGNO (DECL_RTL (DECL_RESULT (current_function_decl))) - >= FIRST_PSEUDO_REGISTER)) - { - rtx real_decl_result; - -#ifdef FUNCTION_OUTGOING_VALUE - real_decl_result - = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)), - current_function_decl); -#else - real_decl_result - = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)), - current_function_decl); -#endif - REG_FUNCTION_VALUE_P (real_decl_result) = 1; - /* If this is a BLKmode structure being returned in registers, then use - the mode computed in expand_return. */ - if (GET_MODE (real_decl_result) == BLKmode) - PUT_MODE (real_decl_result, - GET_MODE (DECL_RTL (DECL_RESULT (current_function_decl)))); - emit_move_insn (real_decl_result, - DECL_RTL (DECL_RESULT (current_function_decl))); - emit_insn (gen_rtx_USE (VOIDmode, real_decl_result)); - - /* The delay slot scheduler assumes that current_function_return_rtx - holds the hard register containing the return value, not a temporary - pseudo. */ - current_function_return_rtx = real_decl_result; - } - - /* If returning a structure, arrange to return the address of the value - in a place where debuggers expect to find it. - - If returning a structure PCC style, - the caller also depends on this value. - And current_function_returns_pcc_struct is not necessarily set. */ - if (current_function_returns_struct - || current_function_returns_pcc_struct) - { - rtx value_address = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0); - tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); -#ifdef FUNCTION_OUTGOING_VALUE - rtx outgoing - = FUNCTION_OUTGOING_VALUE (build_pointer_type (type), - current_function_decl); -#else - rtx outgoing - = FUNCTION_VALUE (build_pointer_type (type), - current_function_decl); -#endif - - /* Mark this as a function return value so integrate will delete the - assignment and USE below when inlining this function. */ - REG_FUNCTION_VALUE_P (outgoing) = 1; - - emit_move_insn (outgoing, value_address); - use_variable (outgoing); - } - - /* If this is an implementation of __throw, do what's necessary to - communicate between __builtin_eh_return and the epilogue. */ - expand_eh_return (); - - /* Output a return insn if we are using one. - Otherwise, let the rtl chain end here, to drop through - into the epilogue. */ - -#ifdef HAVE_return - if (HAVE_return) - { - emit_jump_insn (gen_return ()); - emit_barrier (); - } -#endif - - /* Fix up any gotos that jumped out to the outermost - binding level of the function. - Must follow emitting RETURN_LABEL. */ - - /* If you have any cleanups to do at this point, - and they need to create temporary variables, - then you will lose. */ - expand_fixups (get_insns ()); -} - -/* These arrays record the INSN_UIDs of the prologue and epilogue insns. */ - -static int *prologue; -static int *epilogue; - -/* Create an array that records the INSN_UIDs of INSNS (either a sequence - or a single insn). */ - -#if defined (HAVE_prologue) || defined (HAVE_epilogue) -static int * -record_insns (insns) - rtx insns; -{ - int *vec; - - if (GET_CODE (insns) == SEQUENCE) - { - int len = XVECLEN (insns, 0); - vec = (int *) oballoc ((len + 1) * sizeof (int)); - vec[len] = 0; - while (--len >= 0) - vec[len] = INSN_UID (XVECEXP (insns, 0, len)); - } - else - { - vec = (int *) oballoc (2 * sizeof (int)); - vec[0] = INSN_UID (insns); - vec[1] = 0; - } - return vec; -} - -/* Determine how many INSN_UIDs in VEC are part of INSN. */ - -static int -contains (insn, vec) - rtx insn; - int *vec; -{ - register int i, j; - - if (GET_CODE (insn) == INSN - && GET_CODE (PATTERN (insn)) == SEQUENCE) - { - int count = 0; - for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--) - for (j = 0; vec[j]; j++) - if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == vec[j]) - count++; - return count; - } - else - { - for (j = 0; vec[j]; j++) - if (INSN_UID (insn) == vec[j]) - return 1; - } - return 0; -} -#endif /* HAVE_prologue || HAVE_epilogue */ - -/* Generate the prologue and epilogue RTL if the machine supports it. Thread - this into place with notes indicating where the prologue ends and where - the epilogue begins. Update the basic block information when possible. */ - -void -thread_prologue_and_epilogue_insns (f) - rtx f ATTRIBUTE_UNUSED; -{ -#ifdef HAVE_prologue - if (HAVE_prologue) - { - rtx head, seq; - - /* The first insn (a NOTE_INSN_DELETED) is followed by zero or more - prologue insns and a NOTE_INSN_PROLOGUE_END. */ - emit_note_after (NOTE_INSN_PROLOGUE_END, f); - seq = gen_prologue (); - head = emit_insn_after (seq, f); - - /* Include the new prologue insns in the first block. Ignore them - if they form a basic block unto themselves. */ - if (x_basic_block_head && n_basic_blocks - && GET_CODE (BLOCK_HEAD (0)) != CODE_LABEL) - BLOCK_HEAD (0) = NEXT_INSN (f); - - /* Retain a map of the prologue insns. */ - prologue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : head); - } - else -#endif - prologue = 0; - -#ifdef HAVE_epilogue - if (HAVE_epilogue) - { - rtx insn = get_last_insn (); - rtx prev = prev_nonnote_insn (insn); - - /* If we end with a BARRIER, we don't need an epilogue. */ - if (! (prev && GET_CODE (prev) == BARRIER)) - { - rtx tail, seq, tem; - rtx first_use = 0; - rtx last_use = 0; - - /* The last basic block ends with a NOTE_INSN_EPILOGUE_BEG, the - epilogue insns, the USE insns at the end of a function, - the jump insn that returns, and then a BARRIER. */ - - /* Move the USE insns at the end of a function onto a list. */ - while (prev - && GET_CODE (prev) == INSN - && GET_CODE (PATTERN (prev)) == USE) - { - tem = prev; - prev = prev_nonnote_insn (prev); - - NEXT_INSN (PREV_INSN (tem)) = NEXT_INSN (tem); - PREV_INSN (NEXT_INSN (tem)) = PREV_INSN (tem); - if (first_use) - { - NEXT_INSN (tem) = first_use; - PREV_INSN (first_use) = tem; - } - first_use = tem; - if (!last_use) - last_use = tem; - } - - emit_barrier_after (insn); - - seq = gen_epilogue (); - tail = emit_jump_insn_after (seq, insn); - - /* Insert the USE insns immediately before the return insn, which - must be the first instruction before the final barrier. */ - if (first_use) - { - tem = prev_nonnote_insn (get_last_insn ()); - NEXT_INSN (PREV_INSN (tem)) = first_use; - PREV_INSN (first_use) = PREV_INSN (tem); - PREV_INSN (tem) = last_use; - NEXT_INSN (last_use) = tem; - } - - emit_note_after (NOTE_INSN_EPILOGUE_BEG, insn); - - /* Include the new epilogue insns in the last block. Ignore - them if they form a basic block unto themselves. */ - if (x_basic_block_end && n_basic_blocks - && GET_CODE (BLOCK_END (n_basic_blocks - 1)) != JUMP_INSN) - BLOCK_END (n_basic_blocks - 1) = tail; - - /* Retain a map of the epilogue insns. */ - epilogue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : tail); - return; - } - } -#endif - epilogue = 0; -} - -/* Reposition the prologue-end and epilogue-begin notes after instruction - scheduling and delayed branch scheduling. */ - -void -reposition_prologue_and_epilogue_notes (f) - rtx f ATTRIBUTE_UNUSED; -{ -#if defined (HAVE_prologue) || defined (HAVE_epilogue) - /* Reposition the prologue and epilogue notes. */ - if (n_basic_blocks) - { - int len; - - if (prologue) - { - register rtx insn, note = 0; - - /* Scan from the beginning until we reach the last prologue insn. - We apparently can't depend on basic_block_{head,end} after - reorg has run. */ - for (len = 0; prologue[len]; len++) - ; - for (insn = f; len && insn; insn = NEXT_INSN (insn)) - { - if (GET_CODE (insn) == NOTE) - { - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) - note = insn; - } - else if ((len -= contains (insn, prologue)) == 0) - { - rtx next; - /* Find the prologue-end note if we haven't already, and - move it to just after the last prologue insn. */ - if (note == 0) - { - for (note = insn; (note = NEXT_INSN (note));) - if (GET_CODE (note) == NOTE - && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END) - break; - } - - next = NEXT_INSN (note); - - /* Whether or not we can depend on BLOCK_HEAD, - attempt to keep it up-to-date. */ - if (BLOCK_HEAD (0) == note) - BLOCK_HEAD (0) = next; - - remove_insn (note); - add_insn_after (note, insn); - } - } - } - - if (epilogue) - { - register rtx insn, note = 0; - - /* Scan from the end until we reach the first epilogue insn. - We apparently can't depend on basic_block_{head,end} after - reorg has run. */ - for (len = 0; epilogue[len]; len++) - ; - for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn)) - { - if (GET_CODE (insn) == NOTE) - { - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG) - note = insn; - } - else if ((len -= contains (insn, epilogue)) == 0) - { - /* Find the epilogue-begin note if we haven't already, and - move it to just before the first epilogue insn. */ - if (note == 0) - { - for (note = insn; (note = PREV_INSN (note));) - if (GET_CODE (note) == NOTE - && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG) - break; - } - - /* Whether or not we can depend on BLOCK_HEAD, - attempt to keep it up-to-date. */ - if (n_basic_blocks - && BLOCK_HEAD (n_basic_blocks-1) == insn) - BLOCK_HEAD (n_basic_blocks-1) = note; - - remove_insn (note); - add_insn_before (note, insn); - } - } - } - } -#endif /* HAVE_prologue or HAVE_epilogue */ -} diff --git a/gcc/rtl_020422.c b/gcc/rtl_020422.c deleted file mode 100755 index 291c157..0000000 --- a/gcc/rtl_020422.c +++ /dev/null @@ -1,935 +0,0 @@ -/* Allocate and read RTL for GNU C Compiler. - Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 2002 - 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. */ - - -#include "config.h" -#include "system.h" -#include "rtl.h" -#include "real.h" -#include "bitmap.h" - -#include "obstack.h" -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -/* Obstack used for allocating RTL objects. - Between functions, this is the permanent_obstack. - While parsing and expanding a function, this is maybepermanent_obstack - so we can save it if it is an inline function. - During optimization and output, this is function_obstack. */ - -extern struct obstack *rtl_obstack; - -/* Indexed by rtx code, gives number of operands for an rtx with that code. - Does NOT include rtx header data (code and links). - This array is initialized in init_rtl. */ - -int rtx_length[NUM_RTX_CODE + 1]; - -/* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */ - -#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , - -char *rtx_name[] = { -#include "rtl.def" /* rtl expressions are documented here */ -}; - -#undef DEF_RTL_EXPR - -/* Indexed by machine mode, gives the name of that machine mode. - This name does not include the letters "mode". */ - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) NAME, - -char *mode_name[(int) MAX_MACHINE_MODE + 1] = { -#include "machmode.def" - -#ifdef EXTRA_CC_MODES - EXTRA_CC_NAMES, -#endif - /* Add an extra field to avoid a core dump if someone tries to convert - MAX_MACHINE_MODE to a string. */ - "" -}; - -#undef DEF_MACHMODE - -/* Indexed by machine mode, gives the length of the mode, in bytes. - GET_MODE_CLASS uses this. */ - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) CLASS, - -enum mode_class mode_class[(int) MAX_MACHINE_MODE] = { -#include "machmode.def" -}; - -#undef DEF_MACHMODE - -/* Indexed by machine mode, gives the length of the mode, in bytes. - GET_MODE_SIZE uses this. */ - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) SIZE, - -int mode_size[(int) MAX_MACHINE_MODE] = { -#include "machmode.def" -}; - -#undef DEF_MACHMODE - -/* Indexed by machine mode, gives the length of the mode's subunit. - GET_MODE_UNIT_SIZE uses this. */ - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) UNIT, - -int mode_unit_size[(int) MAX_MACHINE_MODE] = { -#include "machmode.def" /* machine modes are documented here */ -}; - -#undef DEF_MACHMODE - -/* Indexed by machine mode, gives next wider natural mode - (QI -> HI -> SI -> DI, etc.) Widening multiply instructions - use this. */ - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \ - (unsigned char) WIDER, - -unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = { -#include "machmode.def" /* machine modes are documented here */ -}; - -#undef DEF_MACHMODE - -#define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER) \ - ((SIZE) * BITS_PER_UNIT >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (SIZE) * BITS_PER_UNIT) - 1, - -/* Indexed by machine mode, gives mask of significant bits in mode. */ - -unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = { -#include "machmode.def" -}; - -/* Indexed by mode class, gives the narrowest mode for each class. */ - -enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS]; - -/* Indexed by rtx code, gives a sequence of operand-types for - rtx's of that code. The sequence is a C string in which - each character describes one operand. */ - -char *rtx_format[] = { - /* "*" undefined. - can cause a warning message - "0" field is unused (or used in a phase-dependent manner) - prints nothing - "i" an integer - prints the integer - "n" like "i", but prints entries from `note_insn_name' - "w" an integer of width HOST_BITS_PER_WIDE_INT - prints the integer - "s" a pointer to a string - prints the string - "S" like "s", but optional: - the containing rtx may end before this operand - "e" a pointer to an rtl expression - prints the expression - "E" a pointer to a vector that points to a number of rtl expressions - prints a list of the rtl expressions - "V" like "E", but optional: - the containing rtx may end before this operand - "u" a pointer to another insn - prints the uid of the insn. - "b" is a pointer to a bitmap header. - "t" is a tree pointer. */ - -#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , -#include "rtl.def" /* rtl expressions are defined here */ -#undef DEF_RTL_EXPR -}; - -/* Indexed by rtx code, gives a character representing the "class" of - that rtx code. See rtl.def for documentation on the defined classes. */ - -char rtx_class[] = { -#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS, -#include "rtl.def" /* rtl expressions are defined here */ -#undef DEF_RTL_EXPR -}; - -/* Names for kinds of NOTEs and REG_NOTEs. */ - -char *note_insn_name[] = { 0 , "NOTE_INSN_DELETED", - "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END", - "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END", - "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP", - "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP", - "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG", - "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG", - "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END", - "NOTE_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_START", - "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE" }; - -char *reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0", - "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL", - "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED", - "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL", - "REG_DEP_ANTI", "REG_DEP_OUTPUT", - "REG_NOALIAS", "REG_SAVE_AREA", - "REG_BR_PRED", "REG_EH_CONTEXT", - "REG_FRAME_RELATED_EXPR", "REG_EH_REGION", - "REG_EH_RETHROW" }; - -static void dump_and_abort PROTO((int, int, FILE *)) ATTRIBUTE_NORETURN; -static void read_name PROTO((char *, FILE *)); - -/* Allocate an rtx vector of N elements. - Store the length, and initialize all elements to zero. */ - -rtvec -rtvec_alloc (n) - int n; -{ - rtvec rt; - int i; - - rt = (rtvec) obstack_alloc (rtl_obstack, - sizeof (struct rtvec_def) - + (( n - 1) * sizeof (rtunion))); - - /* clear out the vector */ - PUT_NUM_ELEM (rt, n); - - for (i = 0; i < n; i++) - rt->elem[i].rtwint = 0; - - return rt; -} - -/* Allocate an rtx of code CODE. The CODE is stored in the rtx; - all the rest is initialized to zero. */ - -rtx -rtx_alloc (code) - RTX_CODE code; -{ - rtx rt; - register struct obstack *ob = rtl_obstack; - register int nelts = GET_RTX_LENGTH (code); - register int length = sizeof (struct rtx_def) - + (nelts - 1) * sizeof (rtunion); - - /* This function is called more than any other in GCC, - so we manipulate the obstack directly. - - Even though rtx objects are word aligned, we may be sharing an obstack - with tree nodes, which may have to be double-word aligned. So align - our length to the alignment mask in the obstack. */ - - length = (length + ob->alignment_mask) & ~ ob->alignment_mask; - - if (ob->chunk_limit - ob->next_free < length) - _obstack_newchunk (ob, length); - rt = (rtx)ob->object_base; - ob->next_free += length; - ob->object_base = ob->next_free; - - /* We want to clear everything up to the FLD array. Normally, this is - one int, but we don't want to assume that and it isn't very portable - anyway; this is. */ - - memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion)); - - PUT_CODE (rt, code); - - return rt; -} - -/* Free the rtx X and all RTL allocated since X. */ - -void -rtx_free (x) - rtx x; -{ - obstack_free (rtl_obstack, x); -} - -/* Create a new copy of an rtx. - Recursively copies the operands of the rtx, - except for those few rtx codes that are sharable. */ - -rtx -copy_rtx (orig) - register rtx orig; -{ - switch (GET_CODE (orig)) - { - 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. */ - case ADDRESSOF: - return orig; - - 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 (orig, 0)) == PLUS - && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF - && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT) - return orig; - break; - - /* A MEM with a constant address is not sharable. The problem is that - the constant address may need to be reloaded. If the mem is shared, - then reloading one copy of this mem will cause all copies to appear - to have been reloaded. */ - - default: - break; - } - - return really_copy_rtx (orig); -} - -/* Create a new copy of an rtx, even if it could be sharable. */ - -rtx -really_copy_rtx (orig) - rtx orig; -{ - register rtx copy; - register int i, j; - register RTX_CODE code; - register char *format_ptr; - - code = GET_CODE (orig); - - copy = rtx_alloc (code); - PUT_MODE (copy, GET_MODE (orig)); - copy->in_struct = orig->in_struct; - copy->volatil = orig->volatil; - copy->unchanging = orig->unchanging; - copy->integrated = orig->integrated; - - format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); - - for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) - { - switch (*format_ptr++) - { - case 'e': - XEXP (copy, i) = XEXP (orig, i); - if (XEXP (orig, i) != NULL) - XEXP (copy, i) = copy_rtx (XEXP (orig, i)); - break; - - case '0': - case 'u': - XEXP (copy, i) = XEXP (orig, i); - break; - - case 'E': - case 'V': - XVEC (copy, i) = XVEC (orig, i); - if (XVEC (orig, i) != NULL) - { - XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); - for (j = 0; j < XVECLEN (copy, i); j++) - XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j)); - } - break; - - case 'b': - { - bitmap new_bits = BITMAP_OBSTACK_ALLOC (rtl_obstack); - bitmap_copy (new_bits, XBITMAP (orig, i)); - XBITMAP (copy, i) = new_bits; - break; - } - - case 't': - XTREE (copy, i) = XTREE (orig, i); - break; - - case 'w': - XWINT (copy, i) = XWINT (orig, i); - break; - - case 'i': - XINT (copy, i) = XINT (orig, i); - break; - - case 's': - case 'S': - XSTR (copy, i) = XSTR (orig, i); - break; - - default: - abort (); - } - } - return copy; -} - -/* Similar to `copy_rtx' except that if MAY_SHARE is present, it is - placed in the result directly, rather than being copied. */ - -rtx -copy_most_rtx (orig, may_share) - register rtx orig; - register rtx may_share; -{ - register rtx copy; - register int i, j; - register RTX_CODE code; - register char *format_ptr; - - if (orig == may_share) - return orig; - - code = GET_CODE (orig); - - switch (code) - { - case REG: - case QUEUED: - case CONST_INT: - case CONST_DOUBLE: - case SYMBOL_REF: - case CODE_LABEL: - case PC: - case CC0: - return orig; - default: - break; - } - - copy = rtx_alloc (code); - PUT_MODE (copy, GET_MODE (orig)); - copy->in_struct = orig->in_struct; - copy->volatil = orig->volatil; - copy->unchanging = orig->unchanging; - copy->integrated = orig->integrated; - - format_ptr = GET_RTX_FORMAT (GET_CODE (copy)); - - for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++) - { - switch (*format_ptr++) - { - case 'e': - XEXP (copy, i) = XEXP (orig, i); - if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share) - XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share); - break; - - case '0': - case 'u': - XEXP (copy, i) = XEXP (orig, i); - break; - - case 'E': - case 'V': - XVEC (copy, i) = XVEC (orig, i); - if (XVEC (orig, i) != NULL) - { - XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i)); - for (j = 0; j < XVECLEN (copy, i); j++) - XVECEXP (copy, i, j) - = copy_most_rtx (XVECEXP (orig, i, j), may_share); - } - break; - - case 'w': - XWINT (copy, i) = XWINT (orig, i); - break; - - case 'n': - case 'i': - XINT (copy, i) = XINT (orig, i); - break; - - case 's': - case 'S': - XSTR (copy, i) = XSTR (orig, i); - break; - - default: - abort (); - } - } - return copy; -} - -/* Subroutines of read_rtx. */ - -/* Dump code after printing a message. Used when read_rtx finds - invalid data. */ - -static void -dump_and_abort (expected_c, actual_c, infile) - int expected_c, actual_c; - FILE *infile; -{ - int c, i; - - if (expected_c >= 0) - fprintf (stderr, - "Expected character %c. Found character %c.", - expected_c, actual_c); - fprintf (stderr, " At file position: %ld\n", ftell (infile)); - fprintf (stderr, "Following characters are:\n\t"); - for (i = 0; i < 200; i++) - { - c = getc (infile); - if (EOF == c) break; - putc (c, stderr); - } - fprintf (stderr, "Aborting.\n"); - abort (); -} - -/* Read chars from INFILE until a non-whitespace char - and return that. Comments, both Lisp style and C style, - are treated as whitespace. - Tools such as genflags use this function. */ - -int -read_skip_spaces (infile) - FILE *infile; -{ - register int c; - while ((c = getc (infile))) - { - if (c == ' ' || c == '\n' || c == '\t' || c == '\f') - ; - else if (c == ';') - { - while ((c = getc (infile)) && c != '\n' && c != EOF) - ; - } - else if (c == '/') - { - register int prevc; - c = getc (infile); - if (c != '*') - dump_and_abort ('*', c, infile); - - prevc = 0; - while ((c = getc (infile)) && c != EOF) - { - if (prevc == '*' && c == '/') - break; - prevc = c; - } - } - else break; - } - return c; -} - -/* Read an rtx code name into the buffer STR[]. - It is terminated by any of the punctuation chars of rtx printed syntax. */ - -static void -read_name (str, infile) - char *str; - FILE *infile; -{ - register char *p; - register int c; - - c = read_skip_spaces(infile); - - p = str; - while (1) - { - if (c == ' ' || c == '\n' || c == '\t' || c == '\f') - break; - if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/' - || c == '(' || c == '[') - { - ungetc (c, infile); - break; - } - *p++ = c; - c = getc (infile); - } - if (p == str) - { - fprintf (stderr, "missing name or number"); - dump_and_abort (-1, -1, infile); - } - - *p = 0; -} - -/* Provide a version of a function to read a long long if the system does - not provide one. */ -#if HOST_BITS_PER_WIDE_INT > HOST_BITS_PER_LONG && !defined(HAVE_ATOLL) && !defined(HAVE_ATOQ) -HOST_WIDE_INT -atoll(p) - const char *p; -{ - int neg = 0; - HOST_WIDE_INT tmp_wide; - - while (ISSPACE(*p)) - p++; - if (*p == '-') - neg = 1, p++; - else if (*p == '+') - p++; - - tmp_wide = 0; - while (ISDIGIT(*p)) - { - HOST_WIDE_INT new_wide = tmp_wide*10 + (*p - '0'); - if (new_wide < tmp_wide) - { - /* Return INT_MAX equiv on overflow. */ - tmp_wide = (~(unsigned HOST_WIDE_INT)0) >> 1; - break; - } - tmp_wide = new_wide; - p++; - } - - if (neg) - tmp_wide = -tmp_wide; - return tmp_wide; -} -#endif - -/* Read an rtx in printed representation from INFILE - and return an actual rtx in core constructed accordingly. - read_rtx is not used in the compiler proper, but rather in - the utilities gen*.c that construct C code from machine descriptions. */ - -rtx -read_rtx (infile) - FILE *infile; -{ - register int i, j, list_counter; - RTX_CODE tmp_code; - register char *format_ptr; - /* tmp_char is a buffer used for reading decimal integers - and names of rtx types and machine modes. - Therefore, 256 must be enough. */ - char tmp_char[256]; - rtx return_rtx; - register int c; - int tmp_int; - HOST_WIDE_INT tmp_wide; - - /* Linked list structure for making RTXs: */ - struct rtx_list - { - struct rtx_list *next; - rtx value; /* Value of this node... */ - }; - - c = read_skip_spaces (infile); /* Should be open paren. */ - if (c != '(') - dump_and_abort ('(', c, infile); - - read_name (tmp_char, infile); - - tmp_code = UNKNOWN; - - for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */ - { - if (!(strcmp (tmp_char, GET_RTX_NAME (i)))) - { - tmp_code = (RTX_CODE) i; /* get value for name */ - break; - } - } - if (tmp_code == UNKNOWN) - { - fprintf (stderr, - "Unknown rtx read in rtl.read_rtx(). Code name was %s .", - tmp_char); - } - /* (NIL) stands for an expression that isn't there. */ - if (tmp_code == NIL) - { - /* Discard the closeparen. */ - while ((c = getc (infile)) && c != ')'); - return 0; - } - - return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression - then we free this space below. */ - format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx)); - - /* If what follows is `: mode ', read it and - store the mode in the rtx. */ - - i = read_skip_spaces (infile); - if (i == ':') - { - register int k; - read_name (tmp_char, infile); - for (k = 0; k < NUM_MACHINE_MODES; k++) - if (!strcmp (GET_MODE_NAME (k), tmp_char)) - break; - - PUT_MODE (return_rtx, (enum machine_mode) k ); - } - else - ungetc (i, infile); - - for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++) - switch (*format_ptr++) - { - /* 0 means a field for internal use only. - Don't expect it to be present in the input. */ - case '0': - break; - - case 'e': - case 'u': - XEXP (return_rtx, i) = read_rtx (infile); - break; - - case 'V': - /* 'V' is an optional vector: if a closeparen follows, - just store NULL for this element. */ - c = read_skip_spaces (infile); - ungetc (c, infile); - if (c == ')') - { - XVEC (return_rtx, i) = 0; - break; - } - /* Now process the vector. */ - - case 'E': - { - register struct rtx_list *next_rtx, *rtx_list_link; - struct rtx_list *list_rtx = NULL; - - c = read_skip_spaces (infile); - if (c != '[') - dump_and_abort ('[', c, infile); - - /* add expressions to a list, while keeping a count */ - next_rtx = NULL; - list_counter = 0; - while ((c = read_skip_spaces (infile)) && c != ']') - { - ungetc (c, infile); - list_counter++; - rtx_list_link = (struct rtx_list *) - alloca (sizeof (struct rtx_list)); - rtx_list_link->value = read_rtx (infile); - if (next_rtx == 0) - list_rtx = rtx_list_link; - else - next_rtx->next = rtx_list_link; - next_rtx = rtx_list_link; - rtx_list_link->next = 0; - } - /* get vector length and allocate it */ - XVEC (return_rtx, i) = (list_counter - ? rtvec_alloc (list_counter) : NULL_RTVEC); - if (list_counter > 0) - { - next_rtx = list_rtx; - for (j = 0; j < list_counter; j++, - next_rtx = next_rtx->next) - XVECEXP (return_rtx, i, j) = next_rtx->value; - } - /* close bracket gotten */ - } - break; - - case 'S': - /* 'S' is an optional string: if a closeparen follows, - just store NULL for this element. */ - c = read_skip_spaces (infile); - ungetc (c, infile); - if (c == ')') - { - XSTR (return_rtx, i) = 0; - break; - } - - case 's': - { - int saw_paren = 0; - register char *stringbuf; - - c = read_skip_spaces (infile); - if (c == '(') - { - saw_paren = 1; - c = read_skip_spaces (infile); - } - if (c != '"') - dump_and_abort ('"', c, infile); - - while (1) - { - c = getc (infile); /* Read the string */ - if (c == '\\') - { - c = getc (infile); /* Read the string */ - /* \; makes stuff for a C string constant containing - newline and tab. */ - if (c == ';') - { - obstack_grow (rtl_obstack, "\\n\\t", 4); - continue; - } - } - else if (c == '"') - break; - - obstack_1grow (rtl_obstack, c); - } - - obstack_1grow (rtl_obstack, 0); - stringbuf = (char *) obstack_finish (rtl_obstack); - - if (saw_paren) - { - c = read_skip_spaces (infile); - if (c != ')') - dump_and_abort (')', c, infile); - } - XSTR (return_rtx, i) = stringbuf; - } - break; - - case 'w': - read_name (tmp_char, infile); -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT - tmp_wide = atoi (tmp_char); -#else -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG - tmp_wide = atol (tmp_char); -#else - /* Prefer atoll over atoq, since the former is in the ISO C9X draft. - But prefer not to use our hand-rolled function above either. */ -#if defined(HAVE_ATOLL) || !defined(HAVE_ATOQ) - tmp_wide = atoll (tmp_char); -#else - tmp_wide = atoq (tmp_char); -#endif -#endif -#endif - XWINT (return_rtx, i) = tmp_wide; - break; - - case 'i': - case 'n': - read_name (tmp_char, infile); - tmp_int = atoi (tmp_char); - XINT (return_rtx, i) = tmp_int; - break; - - default: - fprintf (stderr, - "switch format wrong in rtl.read_rtx(). format was: %c.\n", - format_ptr[-1]); - fprintf (stderr, "\tfile position: %ld\n", ftell (infile)); - abort (); - } - - c = read_skip_spaces (infile); - if (c != ')') - dump_and_abort (')', c, infile); - - return return_rtx; -} - -/* This is called once per compilation, before any rtx's are constructed. - It initializes the vector `rtx_length', the extra CC modes, if any, - and computes certain commonly-used modes. */ - -void -init_rtl () -{ - int min_class_size[(int) MAX_MODE_CLASS]; - enum machine_mode mode; - int i; - - for (i = 0; i < NUM_RTX_CODE; i++) - rtx_length[i] = strlen (rtx_format[i]); - - /* Make CONST_DOUBLE bigger, if real values are bigger than - it normally expects to have room for. - Note that REAL_VALUE_TYPE is not defined by default, - since tree.h is not included. But the default dfn as `double' - would do no harm. */ -#ifdef REAL_VALUE_TYPE - i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2; - if (rtx_length[(int) CONST_DOUBLE] < i) - { - char *s = (char *) xmalloc (i + 1); - rtx_length[(int) CONST_DOUBLE] = i; - rtx_format[(int) CONST_DOUBLE] = s; - *s++ = 'e'; - *s++ = '0'; - /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string - of as many `w's as we now have elements. Subtract two from - the size to account for the 'e' and the '0'. */ - for (i = 2; i < rtx_length[(int) CONST_DOUBLE]; i++) - *s++ = 'w'; - *s++ = 0; - } -#endif - -#ifdef EXTRA_CC_MODES - for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++) - { - mode_class[i] = MODE_CC; - mode_mask_array[i] = mode_mask_array[(int) CCmode]; - mode_size[i] = mode_size[(int) CCmode]; - mode_unit_size[i] = mode_unit_size[(int) CCmode]; - mode_wider_mode[i - 1] = i; - mode_wider_mode[i] = (unsigned char)VOIDmode; - } -#endif - - /* Find the narrowest mode for each class. */ - - for (i = 0; i < (int) MAX_MODE_CLASS; i++) - min_class_size[i] = 1000; - - for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE; - mode = (enum machine_mode) ((int) mode + 1)) - { - if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)]) - { - class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode; - min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode); - } - } -} diff --git a/gcc/rtl_020422.h b/gcc/rtl_020422.h deleted file mode 100755 index 5e006a8..0000000 --- a/gcc/rtl_020422.h +++ /dev/null @@ -1,1569 +0,0 @@ -/* Register Transfer Language (RTL) definitions for GNU C-Compiler - Copyright (C) 1987, 91-97, 1998, 2002 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. */ - -#ifndef _RTL_H -#define _RTL_H - -#include "machmode.h" - -#undef FFS /* Some systems predefine this symbol; don't let it interfere. */ -#undef FLOAT /* Likewise. */ -#undef ABS /* Likewise. */ -#undef PC /* Likewise. */ - -#ifndef TREE_CODE -union tree_node; -#endif - -/* Register Transfer Language EXPRESSIONS CODES */ - -#define RTX_CODE enum rtx_code -enum rtx_code { - -#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM , -#include "rtl.def" /* rtl expressions are documented here */ -#undef DEF_RTL_EXPR - - LAST_AND_UNUSED_RTX_CODE}; /* A convenient way to get a value for - NUM_RTX_CODE. - Assumes default enum value assignment. */ - -#define NUM_RTX_CODE ((int)LAST_AND_UNUSED_RTX_CODE) - /* The cast here, saves many elsewhere. */ - -extern int rtx_length[]; -#define GET_RTX_LENGTH(CODE) (rtx_length[(int) (CODE)]) - -extern char *rtx_name[]; -#define GET_RTX_NAME(CODE) (rtx_name[(int) (CODE)]) - -extern char *rtx_format[]; -#define GET_RTX_FORMAT(CODE) (rtx_format[(int) (CODE)]) - -extern char rtx_class[]; -#define GET_RTX_CLASS(CODE) (rtx_class[(int) (CODE)]) - -/* The flags and bitfields of an ADDR_DIFF_VEC. BASE is the base label - relative to which the offsets are calculated, as explained in rtl.def. */ -typedef struct -{ - /* Set at the start of shorten_branches - ONLY WHEN OPTIMIZING - : */ - unsigned min_align: 8; - /* Flags: */ - unsigned base_after_vec: 1; /* BASE is after the ADDR_DIFF_VEC. */ - unsigned min_after_vec: 1; /* minimum address target label is after the ADDR_DIFF_VEC. */ - unsigned max_after_vec: 1; /* maximum address target label is after the ADDR_DIFF_VEC. */ - unsigned min_after_base: 1; /* minimum address target label is after BASE. */ - unsigned max_after_base: 1; /* maximum address target label is after BASE. */ - /* Set by the actual branch shortening process - ONLY WHEN OPTIMIZING - : */ - unsigned offset_unsigned: 1; /* offsets have to be treated as unsigned. */ - unsigned : 2; - unsigned scale : 8; -} addr_diff_vec_flags; - -/* Common union for an element of an rtx. */ - -typedef union rtunion_def -{ - HOST_WIDE_INT rtwint; - int rtint; - char *rtstr; - struct rtx_def *rtx; - struct rtvec_def *rtvec; - enum machine_mode rttype; - addr_diff_vec_flags rt_addr_diff_vec_flags; - struct bitmap_head_def *rtbit; - union tree_node *rttree; -} rtunion; - -/* RTL expression ("rtx"). */ - -typedef struct rtx_def -{ -#ifdef ONLY_INT_FIELDS -#ifdef CODE_FIELD_BUG - unsigned int code : 16; -#else - unsigned short code; -#endif -#else - /* The kind of expression this is. */ - enum rtx_code code : 16; -#endif - /* The kind of value the expression has. */ -#ifdef ONLY_INT_FIELDS - int mode : 8; -#else - enum machine_mode mode : 8; -#endif - /* 1 in an INSN if it can alter flow of control - within this function. Not yet used! */ - unsigned int jump : 1; - /* 1 in an INSN if it can call another function. Not yet used! */ - unsigned int call : 1; - /* 1 in a MEM or REG if value of this expression will never change - during the current function, even though it is not - manifestly constant. - 1 in a SUBREG if it is from a promoted variable that is unsigned. - 1 in a SYMBOL_REF if it addresses something in the per-function - constants pool. - 1 in a CALL_INSN if it is a const call. - 1 in a JUMP_INSN if it is a branch that should be annulled. Valid from - reorg until end of compilation; cleared before used. */ - unsigned int unchanging : 1; - /* 1 in a MEM expression if contents of memory are volatile. - 1 in an INSN, CALL_INSN, JUMP_INSN, CODE_LABEL or BARRIER - if it is deleted. - 1 in a REG expression if corresponds to a variable declared by the user. - 0 for an internally generated temporary. - In a SYMBOL_REF, this flag is used for machine-specific purposes. - In a LABEL_REF or in a REG_LABEL note, this is LABEL_REF_NONLOCAL_P. */ - unsigned int volatil : 1; - /* 1 in a MEM referring to a field of an aggregate. - 0 if the MEM was a variable or the result of a * operator in C; - 1 if it was the result of a . or -> operator (on a struct) in C. - 1 in a REG if the register is used only in exit code a loop. - 1 in a SUBREG expression if was generated from a variable with a - promoted mode. - 1 in a CODE_LABEL if the label is used for nonlocal gotos - and must not be deleted even if its count is zero. - 1 in a LABEL_REF if this is a reference to a label outside the - current loop. - 1 in an INSN, JUMP_INSN, or CALL_INSN if this insn must be scheduled - together with the preceding insn. Valid only within sched. - 1 in an INSN, JUMP_INSN, or CALL_INSN if insn is in a delay slot and - from the target of a branch. Valid from reorg until end of compilation; - cleared before used. */ - unsigned int in_struct : 1; - /* 1 if this rtx is used. This is used for copying shared structure. - See `unshare_all_rtl'. - In a REG, this is not needed for that purpose, and used instead - in `leaf_renumber_regs_insn'. - In a SYMBOL_REF, means that emit_library_call - has used it as the function. */ - unsigned int used : 1; - /* Nonzero if this rtx came from procedure integration. - In a REG, nonzero means this reg refers to the return value - of the current function. - CYGNUS LOCAL unaligned-pointers - In a MEM, nonzero means that this address may be unaligned. - END CYGNUS LOCAL - */ - unsigned integrated : 1; - /* 1 in an INSN if this rtx is related to the call frame, - either changing how we compute the frame address or saving and - restoring registers in the prologue and epilogue. - 1 in a MEM if the MEM refers to a scalar, rather than a member of - an aggregate. */ - unsigned frame_related : 1; - /* The first element of the operands of this rtx. - The number of operands and their types are controlled - by the `code' field, according to rtl.def. */ - rtunion fld[1]; -} *rtx; - -#define NULL_RTX (rtx) 0 - -/* Define macros to access the `code' field of the rtx. */ - -#ifdef SHORT_ENUM_BUG -#define GET_CODE(RTX) ((enum rtx_code) ((RTX)->code)) -#define PUT_CODE(RTX, CODE) ((RTX)->code = ((short) (CODE))) -#else -#define GET_CODE(RTX) ((RTX)->code) -#define PUT_CODE(RTX, CODE) ((RTX)->code = (CODE)) -#endif - -#define GET_MODE(RTX) ((RTX)->mode) -#define PUT_MODE(RTX, MODE) ((RTX)->mode = (MODE)) - -#define RTX_INTEGRATED_P(RTX) ((RTX)->integrated) -#define RTX_UNCHANGING_P(RTX) ((RTX)->unchanging) -#define RTX_FRAME_RELATED_P(RTX) ((RTX)->frame_related) - -/* RTL vector. These appear inside RTX's when there is a need - for a variable number of things. The principle use is inside - PARALLEL expressions. */ - -typedef struct rtvec_def{ - int num_elem; /* number of elements */ - rtunion elem[1]; -} *rtvec; - -#define NULL_RTVEC (rtvec) 0 - -#define GET_NUM_ELEM(RTVEC) ((RTVEC)->num_elem) -#define PUT_NUM_ELEM(RTVEC, NUM) ((RTVEC)->num_elem = (NUM)) - -#define RTVEC_ELT(RTVEC, I) ((RTVEC)->elem[(I)].rtx) - -/* 1 if X is a REG. */ - -#define REG_P(X) (GET_CODE (X) == REG) - -/* 1 if X is a constant value that is an integer. */ - -#define CONSTANT_P(X) \ - (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF \ - || GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE \ - || GET_CODE (X) == CONST || GET_CODE (X) == HIGH) - -/* General accessor macros for accessing the fields of an rtx. */ - -#define XEXP(RTX, N) ((RTX)->fld[N].rtx) -#define XINT(RTX, N) ((RTX)->fld[N].rtint) -#define XWINT(RTX, N) ((RTX)->fld[N].rtwint) -#define XSTR(RTX, N) ((RTX)->fld[N].rtstr) -#define XVEC(RTX, N) ((RTX)->fld[N].rtvec) -#define XVECLEN(RTX, N) ((RTX)->fld[N].rtvec->num_elem) -#define XVECEXP(RTX,N,M)((RTX)->fld[N].rtvec->elem[M].rtx) -#define XBITMAP(RTX, N) ((RTX)->fld[N].rtbit) -#define XTREE(RTX, N) ((RTX)->fld[N].rttree) - - -/* ACCESS MACROS for particular fields of insns. */ - -/* Holds a unique number for each insn. - These are not necessarily sequentially increasing. */ -#define INSN_UID(INSN) ((INSN)->fld[0].rtint) - -/* Chain insns together in sequence. */ -#define PREV_INSN(INSN) ((INSN)->fld[1].rtx) -#define NEXT_INSN(INSN) ((INSN)->fld[2].rtx) - -/* The body of an insn. */ -#define PATTERN(INSN) ((INSN)->fld[3].rtx) - -/* Code number of instruction, from when it was recognized. - -1 means this instruction has not been recognized yet. */ -#define INSN_CODE(INSN) ((INSN)->fld[4].rtint) - -/* Set up in flow.c; empty before then. - Holds a chain of INSN_LIST rtx's whose first operands point at - previous insns with direct data-flow connections to this one. - That means that those insns set variables whose next use is in this insn. - They are always in the same basic block as this insn. */ -#define LOG_LINKS(INSN) ((INSN)->fld[5].rtx) - -/* 1 if insn has been deleted. */ -#define INSN_DELETED_P(INSN) ((INSN)->volatil) - -/* 1 if insn is a call to a const function. */ -#define CONST_CALL_P(INSN) ((INSN)->unchanging) - -/* 1 if insn is a branch that should not unconditionally execute its - delay slots, i.e., it is an annulled branch. */ -#define INSN_ANNULLED_BRANCH_P(INSN) ((INSN)->unchanging) - -/* 1 if insn is in a delay slot and is from the target of the branch. If - the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be - executed if the branch is taken. For annulled branches with this bit - clear, the insn should be executed only if the branch is not taken. */ -#define INSN_FROM_TARGET_P(INSN) ((INSN)->in_struct) - -/* Holds a list of notes on what this insn does to various REGs. - It is a chain of EXPR_LIST rtx's, where the second operand - is the chain pointer and the first operand is the REG being described. - The mode field of the EXPR_LIST contains not a real machine mode - but a value that says what this note says about the REG: - REG_DEAD means that the value in REG dies in this insn (i.e., it is - not needed past this insn). If REG is set in this insn, the REG_DEAD - note may, but need not, be omitted. - REG_INC means that the REG is autoincremented or autodecremented. - REG_EQUIV describes the insn as a whole; it says that the insn - sets a register to a constant value or to be equivalent to a memory - address. If the register is spilled to the stack then the constant - value should be substituted for it. The contents of the REG_EQUIV - is the constant value or memory address, which may be different - from the source of the SET although it has the same value. A - REG_EQUIV note may also appear on an insn which copies a register - parameter to a pseudo-register, if there is a memory address which - could be used to hold that pseudo-register throughout the function. - REG_EQUAL is like REG_EQUIV except that the destination - is only momentarily equal to the specified rtx. Therefore, it - cannot be used for substitution; but it can be used for cse. - REG_RETVAL means that this insn copies the return-value of - a library call out of the hard reg for return values. This note - is actually an INSN_LIST and it points to the first insn involved - in setting up arguments for the call. flow.c uses this to delete - the entire library call when its result is dead. - REG_LIBCALL is the inverse of REG_RETVAL: it goes on the first insn - of the library call and points at the one that has the REG_RETVAL. - REG_WAS_0 says that the register set in this insn held 0 before the insn. - The contents of the note is the insn that stored the 0. - If that insn is deleted or patched to a NOTE, the REG_WAS_0 is inoperative. - The REG_WAS_0 note is actually an INSN_LIST, not an EXPR_LIST. - REG_NONNEG means that the register is always nonnegative during - the containing loop. This is used in branches so that decrement and - branch instructions terminating on zero can be matched. There must be - an insn pattern in the md file named `decrement_and_branch_until_zero' - or else this will never be added to any instructions. - REG_NO_CONFLICT means there is no conflict *after this insn* - between the register in the note and the destination of this insn. - REG_UNUSED identifies a register set in this insn and never used. - REG_CC_SETTER and REG_CC_USER link a pair of insns that set and use - CC0, respectively. Normally, these are required to be consecutive insns, - but we permit putting a cc0-setting insn in the delay slot of a branch - as long as only one copy of the insn exists. In that case, these notes - point from one to the other to allow code generation to determine what - any require information and to properly update CC_STATUS. - REG_LABEL points to a CODE_LABEL. Used by non-JUMP_INSNs to - say that the CODE_LABEL contained in the REG_LABEL note is used - by the insn. - REG_DEP_ANTI is used in LOG_LINKS which represent anti (write after read) - dependencies. REG_DEP_OUTPUT is used in LOG_LINKS which represent output - (write after write) dependencies. Data dependencies, which are the only - type of LOG_LINK created by flow, are represented by a 0 reg note kind. */ -/* REG_SAVE_AREA is used to optimize rtl generated by dynamic stack - allocations for targets where SETJMP_VIA_SAVE_AREA is true. - REG_BR_PRED is attached to JUMP_INSNs only, it holds the branch prediction - flags computed by get_jump_flags() after dbr scheduling is complete. - REG_FRAME_RELATED_EXPR is attached to insns that are RTX_FRAME_RELATED_P, - but are too complex for DWARF to interpret what they imply. The attached - rtx is used instead of intuition. */ -/* REG_EH_REGION is used to indicate what exception region an INSN - belongs in. This can be used to indicate what region a call may throw - to. a REGION of 0 indicates that a call cannot throw at all. - REG_EH_RETHROW is used to indicate what that a call is actually a - call to rethrow, and specifies which region the rethrow is targetting. - This provides a way to generate the non standard flow edges required - for a rethrow. */ - - -#define REG_NOTES(INSN) ((INSN)->fld[6].rtx) - -#define ADDR_DIFF_VEC_FLAGS(RTX) ((RTX)->fld[4].rt_addr_diff_vec_flags) - -/* Don't forget to change reg_note_name in rtl.c. */ -enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4, - REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7, - REG_NONNEG = 8, REG_NO_CONFLICT = 9, REG_UNUSED = 10, - REG_CC_SETTER = 11, REG_CC_USER = 12, REG_LABEL = 13, - REG_DEP_ANTI = 14, REG_DEP_OUTPUT = 15, - REG_NOALIAS = 16, REG_SAVE_AREA = 17, - REG_BR_PRED = 18, REG_EH_CONTEXT = 19, - REG_FRAME_RELATED_EXPR = 20, REG_EH_REGION = 21, - REG_EH_RETHROW = 22 }; - -/* Define macros to extract and insert the reg-note kind in an EXPR_LIST. */ -#define REG_NOTE_KIND(LINK) ((enum reg_note) GET_MODE (LINK)) -#define PUT_REG_NOTE_KIND(LINK,KIND) PUT_MODE(LINK, (enum machine_mode) (KIND)) - -/* Names for REG_NOTE's in EXPR_LIST insn's. */ - -extern char *reg_note_name[]; -#define GET_REG_NOTE_NAME(MODE) (reg_note_name[(int) (MODE)]) - -/* This field is only present on CALL_INSNs. It holds a chain of EXPR_LIST of - USE and CLOBBER expressions. - USE expressions list the registers filled with arguments that - are passed to the function. - CLOBBER expressions document the registers explicitly clobbered - by this CALL_INSN. - Pseudo registers can not be mentioned in this list. */ -#define CALL_INSN_FUNCTION_USAGE(INSN) ((INSN)->fld[7].rtx) - -/* The label-number of a code-label. The assembler label - is made from `L' and the label-number printed in decimal. - Label numbers are unique in a compilation. */ -#define CODE_LABEL_NUMBER(INSN) ((INSN)->fld[3].rtint) - -#define LINE_NUMBER NOTE - -/* In a NOTE that is a line number, this is a string for the file name that the - line is in. We use the same field to record block numbers temporarily in - NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes. (We avoid lots of casts - between ints and pointers if we use a different macro for the block number.) - The NOTE_INSN_RANGE_{START,END} and NOTE_INSN_LIVE notes record their - information as a rtx in the field. */ - -#define NOTE_SOURCE_FILE(INSN) ((INSN)->fld[3].rtstr) -#define NOTE_BLOCK_NUMBER(INSN) ((INSN)->fld[3].rtint) -#define NOTE_RANGE_INFO(INSN) ((INSN)->fld[3].rtx) -#define NOTE_LIVE_INFO(INSN) ((INSN)->fld[3].rtx) - -/* If the NOTE_BLOCK_NUMBER field gets a -1, it means create a new - block node for a live range block. */ -#define NOTE_BLOCK_LIVE_RANGE_BLOCK -1 - -/* In a NOTE that is a line number, this is the line number. - Other kinds of NOTEs are identified by negative numbers here. */ -#define NOTE_LINE_NUMBER(INSN) ((INSN)->fld[4].rtint) - -/* Codes that appear in the NOTE_LINE_NUMBER field - for kinds of notes that are not line numbers. - - Notice that we do not try to use zero here for any of - the special note codes because sometimes the source line - actually can be zero! This happens (for example) when we - are generating code for the per-translation-unit constructor - and destructor routines for some C++ translation unit. - - If you should change any of the following values, or if you - should add a new value here, don't forget to change the - note_insn_name array in rtl.c. */ - -/* This note is used to get rid of an insn - when it isn't safe to patch the insn out of the chain. */ -#define NOTE_INSN_DELETED -1 -#define NOTE_INSN_BLOCK_BEG -2 -#define NOTE_INSN_BLOCK_END -3 -#define NOTE_INSN_LOOP_BEG -4 -#define NOTE_INSN_LOOP_END -5 -/* This kind of note is generated at the end of the function body, - just before the return insn or return label. - In an optimizing compilation it is deleted by the first jump optimization, - after enabling that optimizer to determine whether control can fall - off the end of the function body without a return statement. */ -#define NOTE_INSN_FUNCTION_END -6 -/* This kind of note is generated just after each call to `setjmp', et al. */ -#define NOTE_INSN_SETJMP -7 -/* Generated at the place in a loop that `continue' jumps to. */ -#define NOTE_INSN_LOOP_CONT -8 -/* Generated at the start of a duplicated exit test. */ -#define NOTE_INSN_LOOP_VTOP -9 -/* This marks the point immediately after the last prologue insn. */ -#define NOTE_INSN_PROLOGUE_END -10 -/* This marks the point immediately prior to the first epilogue insn. */ -#define NOTE_INSN_EPILOGUE_BEG -11 -/* Generated in place of user-declared labels when they are deleted. */ -#define NOTE_INSN_DELETED_LABEL -12 -/* This note indicates the start of the real body of the function, - i.e. the point just after all of the parms have been moved into - their homes, etc. */ -#define NOTE_INSN_FUNCTION_BEG -13 -/* These note where exception handling regions begin and end. */ -#define NOTE_INSN_EH_REGION_BEG -14 -#define NOTE_INSN_EH_REGION_END -15 -/* Generated whenever a duplicate line number note is output. For example, - one is output after the end of an inline function, in order to prevent - the line containing the inline call from being counted twice in gcov. */ -#define NOTE_REPEATED_LINE_NUMBER -16 - -/* Start/end of a live range region, where pseudos allocated on the stack can - be allocated to temporary registers. */ -#define NOTE_INSN_RANGE_START -17 -#define NOTE_INSN_RANGE_END -18 -/* Record which registers are currently live. */ -#define NOTE_INSN_LIVE -19 - -#if 0 /* These are not used, and I don't know what they were for. --rms. */ -#define NOTE_DECL_NAME(INSN) ((INSN)->fld[3].rtstr) -#define NOTE_DECL_CODE(INSN) ((INSN)->fld[4].rtint) -#define NOTE_DECL_RTL(INSN) ((INSN)->fld[5].rtx) -#define NOTE_DECL_IDENTIFIER(INSN) ((INSN)->fld[6].rtint) -#define NOTE_DECL_TYPE(INSN) ((INSN)->fld[7].rtint) -#endif /* 0 */ - -/* Names for NOTE insn's other than line numbers. */ - -extern char *note_insn_name[]; -#define GET_NOTE_INSN_NAME(NOTE_CODE) (note_insn_name[-(NOTE_CODE)]) - -/* The name of a label, in case it corresponds to an explicit label - in the input source code. */ -#define LABEL_NAME(LABEL) ((LABEL)->fld[4].rtstr) - -/* In jump.c, each label contains a count of the number - of LABEL_REFs that point at it, so unused labels can be deleted. */ -#define LABEL_NUSES(LABEL) ((LABEL)->fld[5].rtint) - -/* The original regno this ADDRESSOF was built for. */ -#define ADDRESSOF_REGNO(RTX) ((RTX)->fld[1].rtint) - -/* The variable in the register we took the address of. */ -#define ADDRESSOF_DECL(X) ((tree) XEXP ((X), 2)) -#define SET_ADDRESSOF_DECL(X, T) (XEXP ((X), 2) = (rtx) (T)) - -/* In jump.c, each JUMP_INSN can point to a label that it can jump to, - so that if the JUMP_INSN is deleted, the label's LABEL_NUSES can - be decremented and possibly the label can be deleted. */ -#define JUMP_LABEL(INSN) ((INSN)->fld[7].rtx) - -/* Once basic blocks are found in flow.c, - each CODE_LABEL starts a chain that goes through - all the LABEL_REFs that jump to that label. - The chain eventually winds up at the CODE_LABEL; it is circular. */ -#define LABEL_REFS(LABEL) ((LABEL)->fld[6].rtx) - -/* This is the field in the LABEL_REF through which the circular chain - of references to a particular label is linked. - This chain is set up in flow.c. */ - -#define LABEL_NEXTREF(REF) ((REF)->fld[1].rtx) - -/* Once basic blocks are found in flow.c, - Each LABEL_REF points to its containing instruction with this field. */ - -#define CONTAINING_INSN(RTX) ((RTX)->fld[2].rtx) - -/* For a REG rtx, REGNO extracts the register number. */ - -#define REGNO(RTX) ((RTX)->fld[0].rtint) - -/* For a REG rtx, REG_FUNCTION_VALUE_P is nonzero if the reg - is the current function's return value. */ - -#define REG_FUNCTION_VALUE_P(RTX) ((RTX)->integrated) - -/* 1 in a REG rtx if it corresponds to a variable declared by the user. */ -#define REG_USERVAR_P(RTX) ((RTX)->volatil) - -/* For a CONST_INT rtx, INTVAL extracts the integer. */ - -#define INTVAL(RTX) ((RTX)->fld[0].rtwint) - -/* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of. - SUBREG_WORD extracts the word-number. */ - -#define SUBREG_REG(RTX) ((RTX)->fld[0].rtx) -#define SUBREG_WORD(RTX) ((RTX)->fld[1].rtint) - -/* 1 if the REG contained in SUBREG_REG is already known to be - sign- or zero-extended from the mode of the SUBREG to the mode of - the reg. SUBREG_PROMOTED_UNSIGNED_P gives the signedness of the - extension. - - When used as a LHS, is means that this extension must be done - when assigning to SUBREG_REG. */ - -#define SUBREG_PROMOTED_VAR_P(RTX) ((RTX)->in_struct) -#define SUBREG_PROMOTED_UNSIGNED_P(RTX) ((RTX)->unchanging) - -/* Access various components of an ASM_OPERANDS rtx. */ - -#define ASM_OPERANDS_TEMPLATE(RTX) XSTR ((RTX), 0) -#define ASM_OPERANDS_OUTPUT_CONSTRAINT(RTX) XSTR ((RTX), 1) -#define ASM_OPERANDS_OUTPUT_IDX(RTX) XINT ((RTX), 2) -#define ASM_OPERANDS_INPUT_VEC(RTX) XVEC ((RTX), 3) -#define ASM_OPERANDS_INPUT_CONSTRAINT_VEC(RTX) XVEC ((RTX), 4) -#define ASM_OPERANDS_INPUT(RTX, N) XVECEXP ((RTX), 3, (N)) -#define ASM_OPERANDS_INPUT_LENGTH(RTX) XVECLEN ((RTX), 3) -#define ASM_OPERANDS_INPUT_CONSTRAINT(RTX, N) XSTR (XVECEXP ((RTX), 4, (N)), 0) -#define ASM_OPERANDS_INPUT_MODE(RTX, N) GET_MODE (XVECEXP ((RTX), 4, (N))) -#define ASM_OPERANDS_SOURCE_FILE(RTX) XSTR ((RTX), 5) -#define ASM_OPERANDS_SOURCE_LINE(RTX) XINT ((RTX), 6) - -/* For a MEM rtx, 1 if it's a volatile reference. - Also in an ASM_OPERANDS rtx. */ -#define MEM_VOLATILE_P(RTX) ((RTX)->volatil) - -/* For a MEM rtx, 1 if it refers to a field of an aggregate. If zero, - RTX may or may not refer to a field of an aggregate. */ -#define MEM_IN_STRUCT_P(RTX) ((RTX)->in_struct) - -/* For a MEM rtx, 1 if it refers to a scalar. If zero, RTX may or may - not refer to a scalar.*/ -#define MEM_SCALAR_P(RTX) ((RTX)->frame_related) - -/* Copy the MEM_VOLATILE_P, MEM_IN_STRUCT_P, and MEM_SCALAR_P - attributes from RHS to LHS. */ -#define MEM_COPY_ATTRIBUTES(LHS, RHS) \ - (MEM_VOLATILE_P (LHS) = MEM_VOLATILE_P (RHS), \ - MEM_IN_STRUCT_P (LHS) = MEM_IN_STRUCT_P (RHS), \ - MEM_SCALAR_P (LHS) = MEM_SCALAR_P (RHS)) \ - -/* If VAL is non-zero, set MEM_IN_STRUCT_P and clear MEM_SCALAR_P in - RTX. Otherwise, vice versa. Use this macro only when you are - *sure* that you know that the MEM is in a structure, or is a - scalar. VAL is evaluated only once. */ -#define MEM_SET_IN_STRUCT_P(RTX, VAL) \ - ((VAL) ? (MEM_IN_STRUCT_P (RTX) = 1, MEM_SCALAR_P (RTX) = 0) \ - : (MEM_IN_STRUCT_P (RTX) = 0, MEM_SCALAR_P (RTX) = 1)) - -/* CYGNUS LOCAL unaligned-pointers */ -/* For a MEM rtx, 1 if it may be an unaligned address. */ -#define MEM_UNALIGNED_P(RTX) ((RTX)->integrated) -/* END CYGNUS LOCAL */ - -/* For a MEM rtx, the alias set. If 0, this MEM is not in any alias - set, and may alias anything. Otherwise, the MEM can only alias - MEMs in the same alias set. This value is set in a - language-dependent manner in the front-end, and should not be - altered in the back-end. These set numbers are tested for zero, - and compared for equality; they have no other significance. In - some front-ends, these numbers may correspond in some way to types, - or other language-level entities, but they need not, and the - back-end makes no such assumptions. */ -#define MEM_ALIAS_SET(RTX) (XINT (RTX, 1)) - -/* For a LABEL_REF, 1 means that this reference is to a label outside the - loop containing the reference. */ -#define LABEL_OUTSIDE_LOOP_P(RTX) ((RTX)->in_struct) - -/* For a LABEL_REF, 1 means it is for a nonlocal label. */ -/* Likewise in an EXPR_LIST for a REG_LABEL note. */ -#define LABEL_REF_NONLOCAL_P(RTX) ((RTX)->volatil) - -/* For a CODE_LABEL, 1 means always consider this label to be needed. */ -#define LABEL_PRESERVE_P(RTX) ((RTX)->in_struct) - -/* For a REG, 1 means the register is used only in an exit test of a loop. */ -#define REG_LOOP_TEST_P(RTX) ((RTX)->in_struct) - -/* During sched, for an insn, 1 means that the insn must be scheduled together - with the preceding insn. */ -#define SCHED_GROUP_P(INSN) ((INSN)->in_struct) - -/* During sched, for the LOG_LINKS of an insn, these cache the adjusted - cost of the dependence link. The cost of executing an instruction - may vary based on how the results are used. LINK_COST_ZERO is 1 when - the cost through the link varies and is unchanged (i.e., the link has - zero additional cost). LINK_COST_FREE is 1 when the cost through the - link is zero (i.e., the link makes the cost free). In other cases, - the adjustment to the cost is recomputed each time it is needed. */ -#define LINK_COST_ZERO(X) ((X)->jump) -#define LINK_COST_FREE(X) ((X)->call) - -/* For a SET rtx, SET_DEST is the place that is set - and SET_SRC is the value it is set to. */ -#define SET_DEST(RTX) ((RTX)->fld[0].rtx) -#define SET_SRC(RTX) ((RTX)->fld[1].rtx) - -/* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */ -#define TRAP_CONDITION(RTX) ((RTX)->fld[0].rtx) -#define TRAP_CODE(RTX) (RTX)->fld[1].rtx - -/* 1 in a SYMBOL_REF if it addresses this function's constants pool. */ -#define CONSTANT_POOL_ADDRESS_P(RTX) ((RTX)->unchanging) - -/* Flag in a SYMBOL_REF for machine-specific purposes. */ -#define SYMBOL_REF_FLAG(RTX) ((RTX)->volatil) - -/* 1 in a SYMBOL_REF if it represents a symbol which might have to change - if its inlined or unrolled. */ -#define SYMBOL_REF_NEED_ADJUST(RTX) ((RTX)->in_struct) - -/* 1 means a SYMBOL_REF has been the library function in emit_library_call. */ -#define SYMBOL_REF_USED(RTX) ((RTX)->used) - -/* For an INLINE_HEADER rtx, FIRST_FUNCTION_INSN is the first insn - of the function that is not involved in copying parameters to - pseudo-registers. FIRST_PARM_INSN is the very first insn of - the function, including the parameter copying. - We keep this around in case we must splice - this function into the assembly code at the end of the file. - FIRST_LABELNO is the first label number used by the function (inclusive). - LAST_LABELNO is the last label used by the function (exclusive). - MAX_REGNUM is the largest pseudo-register used by that function. - FUNCTION_ARGS_SIZE is the size of the argument block in the stack. - POPS_ARGS is the number of bytes of input arguments popped by the function - STACK_SLOT_LIST is the list of stack slots. - FORCED_LABELS is the list of labels whose address was taken. - FUNCTION_FLAGS are where single-bit flags are saved. - OUTGOING_ARGS_SIZE is the size of the largest outgoing stack parameter list. - ORIGINAL_ARG_VECTOR is a vector of the original DECL_RTX values - for the function arguments. - ORIGINAL_DECL_INITIAL is a pointer to the original DECL_INITIAL for the - function. - INLINE_REGNO_REG_RTX, INLINE_REGNO_POINTER_FLAG, and - INLINE_REGNO_POINTER_ALIGN are pointers to the corresponding arrays. - - We want this to lay down like an INSN. The PREV_INSN field - is always NULL. The NEXT_INSN field always points to the - first function insn of the function being squirreled away. */ - -#define FIRST_FUNCTION_INSN(RTX) ((RTX)->fld[2].rtx) -#define FIRST_PARM_INSN(RTX) ((RTX)->fld[3].rtx) -#define FIRST_LABELNO(RTX) ((RTX)->fld[4].rtint) -#define LAST_LABELNO(RTX) ((RTX)->fld[5].rtint) -#define MAX_PARMREG(RTX) ((RTX)->fld[6].rtint) -#define MAX_REGNUM(RTX) ((RTX)->fld[7].rtint) -#define FUNCTION_ARGS_SIZE(RTX) ((RTX)->fld[8].rtint) -#define POPS_ARGS(RTX) ((RTX)->fld[9].rtint) -#define STACK_SLOT_LIST(RTX) ((RTX)->fld[10].rtx) -#define FORCED_LABELS(RTX) ((RTX)->fld[11].rtx) -#define FUNCTION_FLAGS(RTX) ((RTX)->fld[12].rtint) -#define OUTGOING_ARGS_SIZE(RTX) ((RTX)->fld[13].rtint) -#define ORIGINAL_ARG_VECTOR(RTX) ((RTX)->fld[14].rtvec) -#define ORIGINAL_DECL_INITIAL(RTX) ((RTX)->fld[15].rtx) -#define INLINE_REGNO_REG_RTX(RTX) ((RTX)->fld[16].rtvec) -#define INLINE_REGNO_POINTER_FLAG(RTX) ((RTX)->fld[17].rtstr) -#define INLINE_REGNO_POINTER_ALIGN(RTX) ((RTX)->fld[18].rtstr) -#define PARMREG_STACK_LOC(RTX) ((RTX)->fld[19].rtvec) - -/* In FUNCTION_FLAGS we save some variables computed when emitting the code - for the function and which must be `or'ed into the current flag values when - insns from that function are being inlined. */ - -/* These ought to be an enum, but non-ANSI compilers don't like that. */ -#define FUNCTION_FLAGS_CALLS_ALLOCA 01 -#define FUNCTION_FLAGS_CALLS_SETJMP 02 -#define FUNCTION_FLAGS_RETURNS_STRUCT 04 -#define FUNCTION_FLAGS_RETURNS_PCC_STRUCT 010 -#define FUNCTION_FLAGS_NEEDS_CONTEXT 020 -#define FUNCTION_FLAGS_HAS_NONLOCAL_LABEL 040 -#define FUNCTION_FLAGS_RETURNS_POINTER 0100 -#define FUNCTION_FLAGS_USES_CONST_POOL 0200 -#define FUNCTION_FLAGS_CALLS_LONGJMP 0400 -#define FUNCTION_FLAGS_USES_PIC_OFFSET_TABLE 01000 - -/* Define a macro to look for REG_INC notes, - but save time on machines where they never exist. */ - -/* Don't continue this line--convex cc version 4.1 would lose. */ -#if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT)) -#define FIND_REG_INC_NOTE(insn, reg) (find_reg_note ((insn), REG_INC, (reg))) -#else -#define FIND_REG_INC_NOTE(insn, reg) 0 -#endif - -/* Indicate whether the machine has any sort of auto increment addressing. - If not, we can avoid checking for REG_INC notes. */ - -/* Don't continue this line--convex cc version 4.1 would lose. */ -#if (defined (HAVE_PRE_INCREMENT) || defined (HAVE_PRE_DECREMENT) || defined (HAVE_POST_INCREMENT) || defined (HAVE_POST_DECREMENT)) -#define AUTO_INC_DEC -#endif - -#ifndef HAVE_PRE_INCREMENT -#define HAVE_PRE_INCREMENT 0 -#endif - -#ifndef HAVE_PRE_DECREMENT -#define HAVE_PRE_DECREMENT 0 -#endif - -#ifndef HAVE_POST_INCREMENT -#define HAVE_POST_INCREMENT 0 -#endif - -#ifndef HAVE_POST_DECREMENT -#define HAVE_POST_DECREMENT 0 -#endif - -/* Accessors for RANGE_INFO. */ -/* For RANGE_{START,END} notes return the RANGE_START note. */ -#define RANGE_INFO_NOTE_START(INSN) (XEXP (INSN, 0)) - -/* For RANGE_{START,END} notes return the RANGE_START note. */ -#define RANGE_INFO_NOTE_END(INSN) (XEXP (INSN, 1)) - -/* For RANGE_{START,END} notes, return the vector containing the registers used - in the range. */ -#define RANGE_INFO_REGS(INSN) (XVEC (INSN, 2)) -#define RANGE_INFO_REGS_REG(INSN, N) (XVECEXP (INSN, 2, N)) -#define RANGE_INFO_NUM_REGS(INSN) (XVECLEN (INSN, 2)) - -/* For RANGE_{START,END} notes, the number of calls within the range. */ -#define RANGE_INFO_NCALLS(INSN) (XINT (INSN, 3)) - -/* For RANGE_{START,END} notes, the number of insns within the range. */ -#define RANGE_INFO_NINSNS(INSN) (XINT (INSN, 4)) - -/* For RANGE_{START,END} notes, a unique # to identify this range. */ -#define RANGE_INFO_UNIQUE(INSN) (XINT (INSN, 5)) - -/* For RANGE_{START,END} notes, the basic block # the range starts with. */ -#define RANGE_INFO_BB_START(INSN) (XINT (INSN, 6)) - -/* For RANGE_{START,END} notes, the basic block # the range ends with. */ -#define RANGE_INFO_BB_END(INSN) (XINT (INSN, 7)) - -/* For RANGE_{START,END} notes, the loop depth the range is in. */ -#define RANGE_INFO_LOOP_DEPTH(INSN) (XINT (INSN, 8)) - -/* For RANGE_{START,END} notes, the bitmap of live registers at the start - of the range. */ -#define RANGE_INFO_LIVE_START(INSN) (XBITMAP (INSN, 9)) - -/* For RANGE_{START,END} notes, the bitmap of live registers at the end - of the range. */ -#define RANGE_INFO_LIVE_END(INSN) (XBITMAP (INSN, 10)) - -/* For RANGE_START notes, the marker # of the start of the range. */ -#define RANGE_INFO_MARKER_START(INSN) (XINT (INSN, 11)) - -/* For RANGE_START notes, the marker # of the end of the range. */ -#define RANGE_INFO_MARKER_END(INSN) (XINT (INSN, 12)) - -/* Original pseudo register # for a live range note. */ -#define RANGE_REG_PSEUDO(INSN,N) (XINT (XVECEXP (INSN, 2, N), 0)) - -/* Pseudo register # original register is copied into or -1. */ -#define RANGE_REG_COPY(INSN,N) (XINT (XVECEXP (INSN, 2, N), 1)) - -/* How many times a register in a live range note was referenced. */ -#define RANGE_REG_REFS(INSN,N) (XINT (XVECEXP (INSN, 2, N), 2)) - -/* How many times a register in a live range note was set. */ -#define RANGE_REG_SETS(INSN,N) (XINT (XVECEXP (INSN, 2, N), 3)) - -/* How many times a register in a live range note died. */ -#define RANGE_REG_DEATHS(INSN,N) (XINT (XVECEXP (INSN, 2, N), 4)) - -/* Whether the original value is needed to be copied into the range register at - the start of the range. */ -#define RANGE_REG_COPY_FLAGS(INSN,N) (XINT (XVECEXP (INSN, 2, N), 5)) - -/* # of insns the register copy is live over. */ -#define RANGE_REG_LIVE_LENGTH(INSN,N) (XINT (XVECEXP (INSN, 2, N), 6)) - -/* # of calls the register copy is live over. */ -#define RANGE_REG_N_CALLS(INSN,N) (XINT (XVECEXP (INSN, 2, N), 7)) - -/* DECL_NODE pointer of the declaration if the register is a user defined - variable. */ -#define RANGE_REG_SYMBOL_NODE(INSN,N) (XTREE (XVECEXP (INSN, 2, N), 8)) - -/* BLOCK_NODE pointer to the block the variable is declared in if the - register is a user defined variable. */ -#define RANGE_REG_BLOCK_NODE(INSN,N) (XTREE (XVECEXP (INSN, 2, N), 9)) - -/* EXPR_LIST of the distinct ranges a variable is in. */ -#define RANGE_VAR_LIST(INSN) (XEXP (INSN, 0)) - -/* Block a variable is declared in. */ -#define RANGE_VAR_BLOCK(INSN) (XTREE (INSN, 1)) - -/* # of distinct ranges a variable is in. */ -#define RANGE_VAR_NUM(INSN) (XINT (INSN, 2)) - -/* For a NOTE_INSN_LIVE note, the registers which are currently live. */ -#define RANGE_LIVE_BITMAP(INSN) (XBITMAP (INSN, 0)) - -/* For a NOTE_INSN_LIVE note, the original basic block number. */ -#define RANGE_LIVE_ORIG_BLOCK(INSN) (XINT (INSN, 1)) - -/* Generally useful functions. */ - -/* The following functions accept a wide integer argument. Rather than - having to cast on every function call, we use a macro instead, that is - defined here and in tree.h. */ - -#ifndef exact_log2 -#define exact_log2(N) exact_log2_wide ((unsigned HOST_WIDE_INT) (N)) -#define floor_log2(N) floor_log2_wide ((unsigned HOST_WIDE_INT) (N)) -#endif -extern int exact_log2_wide PROTO((unsigned HOST_WIDE_INT)); -extern int floor_log2_wide PROTO((unsigned HOST_WIDE_INT)); - -/* In expmed.c */ -extern int ceil_log2 PROTO((unsigned HOST_WIDE_INT)); - -#define plus_constant(X,C) plus_constant_wide (X, (HOST_WIDE_INT) (C)) - -#define plus_constant_for_output(X,C) \ - plus_constant_for_output_wide (X, (HOST_WIDE_INT) (C)) - -/* In explow.c */ -extern rtx plus_constant_wide PROTO((rtx, HOST_WIDE_INT)); -extern rtx plus_constant_for_output_wide PROTO((rtx, HOST_WIDE_INT)); -extern void optimize_save_area_alloca PROTO((rtx)); - -extern rtx gen_rtx PVPROTO((enum rtx_code, - enum machine_mode, ...)); -extern rtvec gen_rtvec PVPROTO((int, ...)); - -#ifdef BUFSIZ -extern rtx read_rtx PROTO((FILE *)); -#endif - -extern char *oballoc PROTO((int)); -extern char *permalloc PROTO((int)); -extern rtx rtx_alloc PROTO((RTX_CODE)); -extern rtvec rtvec_alloc PROTO((int)); -extern rtx copy_rtx PROTO((rtx)); -extern rtx really_copy_rtx PROTO((rtx)); -extern rtx copy_rtx_if_shared PROTO((rtx)); -extern rtx copy_most_rtx PROTO((rtx, rtx)); -extern rtvec gen_rtvec_v PROTO((int, rtx *)); -extern rtvec gen_rtvec_vv PROTO((int, rtunion *)); -extern rtx gen_reg_rtx PROTO((enum machine_mode)); -extern rtx gen_label_rtx PROTO((void)); -extern rtx gen_inline_header_rtx PROTO((rtx, rtx, int, int, int, int, - int, int, rtx, rtx, int, int, - rtvec, rtx, - rtvec, char *, char *, rtvec)); -extern rtx gen_lowpart_common PROTO((enum machine_mode, rtx)); -extern rtx gen_lowpart PROTO((enum machine_mode, rtx)); -extern rtx gen_lowpart_if_possible PROTO((enum machine_mode, rtx)); -extern rtx gen_highpart PROTO((enum machine_mode, rtx)); -extern rtx gen_realpart PROTO((enum machine_mode, rtx)); -extern rtx gen_imagpart PROTO((enum machine_mode, rtx)); -extern rtx operand_subword PROTO((rtx, int, int, enum machine_mode)); -extern rtx operand_subword_force PROTO((rtx, int, enum machine_mode)); -extern int subreg_lowpart_p PROTO((rtx)); -extern rtx make_safe_from PROTO((rtx, rtx)); -extern rtx convert_memory_address PROTO((enum machine_mode, rtx)); -extern rtx memory_address PROTO((enum machine_mode, rtx)); -extern rtx get_insns PROTO((void)); -extern rtx get_last_insn PROTO((void)); -extern rtx get_last_insn_anywhere PROTO((void)); -extern void start_sequence PROTO((void)); -extern void push_to_sequence PROTO((rtx)); -extern void end_sequence PROTO((void)); -extern rtx gen_sequence PROTO((void)); -extern rtx immed_double_const PROTO((HOST_WIDE_INT, HOST_WIDE_INT, enum machine_mode)); -extern rtx force_const_mem PROTO((enum machine_mode, rtx)); -extern rtx force_reg PROTO((enum machine_mode, rtx)); -extern rtx get_pool_constant PROTO((rtx)); -extern enum machine_mode get_pool_mode PROTO((rtx)); -extern int get_pool_offset PROTO((rtx)); -extern rtx simplify_subtraction PROTO((rtx)); -extern rtx assign_stack_local PROTO((enum machine_mode, - HOST_WIDE_INT, int)); -extern rtx assign_stack_temp PROTO((enum machine_mode, - HOST_WIDE_INT, int)); -extern rtx assign_temp PROTO((union tree_node *, - int, int, int)); -extern rtx protect_from_queue PROTO((rtx, int)); -extern void emit_queue PROTO((void)); -extern rtx emit_move_insn PROTO((rtx, rtx)); -extern rtx emit_insn_before PROTO((rtx, rtx)); -extern rtx emit_jump_insn_before PROTO((rtx, rtx)); -extern rtx emit_call_insn_before PROTO((rtx, rtx)); -extern rtx emit_barrier_before PROTO((rtx)); -extern rtx emit_note_before PROTO((int, rtx)); -extern rtx emit_insn_after PROTO((rtx, rtx)); -extern rtx emit_jump_insn_after PROTO((rtx, rtx)); -extern rtx emit_barrier_after PROTO((rtx)); -extern rtx emit_label_after PROTO((rtx, rtx)); -extern rtx emit_note_after PROTO((int, rtx)); -extern rtx emit_line_note_after PROTO((char *, int, rtx)); -extern rtx emit_insn PROTO((rtx)); -extern rtx emit_insns PROTO((rtx)); -extern rtx emit_insns_before PROTO((rtx, rtx)); -extern rtx emit_insns_after PROTO((rtx, rtx)); -extern rtx emit_jump_insn PROTO((rtx)); -extern rtx emit_call_insn PROTO((rtx)); -extern rtx emit_label PROTO((rtx)); -extern rtx emit_barrier PROTO((void)); -extern rtx emit_line_note PROTO((char *, int)); -extern rtx emit_note PROTO((char *, int)); -extern rtx emit_line_note_force PROTO((char *, int)); -extern rtx make_insn_raw PROTO((rtx)); -extern rtx previous_insn PROTO((rtx)); -extern rtx next_insn PROTO((rtx)); -extern rtx prev_nonnote_insn PROTO((rtx)); -extern rtx next_nonnote_insn PROTO((rtx)); -extern rtx prev_real_insn PROTO((rtx)); -extern rtx next_real_insn PROTO((rtx)); -extern rtx prev_active_insn PROTO((rtx)); -extern rtx next_active_insn PROTO((rtx)); -extern rtx prev_label PROTO((rtx)); -extern rtx next_label PROTO((rtx)); -extern rtx next_cc0_user PROTO((rtx)); -extern rtx prev_cc0_setter PROTO((rtx)); -extern rtx next_nondeleted_insn PROTO((rtx)); -extern enum rtx_code reverse_condition PROTO((enum rtx_code)); -extern enum rtx_code swap_condition PROTO((enum rtx_code)); -extern enum rtx_code unsigned_condition PROTO((enum rtx_code)); -extern enum rtx_code signed_condition PROTO((enum rtx_code)); -extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *, int, enum machine_mode)); -extern rtx squeeze_notes PROTO((rtx, rtx)); -extern rtx delete_insn PROTO((rtx)); -extern void delete_jump PROTO((rtx)); -extern rtx get_label_before PROTO((rtx)); -extern rtx get_label_after PROTO((rtx)); -extern rtx follow_jumps PROTO((rtx)); -extern rtx adj_offsettable_operand PROTO((rtx, int)); -extern rtx try_split PROTO((rtx, rtx, int)); -extern rtx split_insns PROTO((rtx, rtx)); -extern rtx simplify_unary_operation PROTO((enum rtx_code, enum machine_mode, rtx, enum machine_mode)); -extern rtx simplify_binary_operation PROTO((enum rtx_code, enum machine_mode, rtx, rtx)); -extern rtx simplify_ternary_operation PROTO((enum rtx_code, enum machine_mode, enum machine_mode, rtx, rtx, rtx)); -extern rtx simplify_relational_operation PROTO((enum rtx_code, enum machine_mode, rtx, rtx)); -extern rtx nonlocal_label_rtx_list PROTO((void)); -extern rtx gen_move_insn PROTO((rtx, rtx)); -extern rtx gen_jump PROTO((rtx)); -extern rtx gen_beq PROTO((rtx)); -extern rtx gen_bge PROTO((rtx)); -extern rtx gen_ble PROTO((rtx)); -extern rtx gen_mem_addressof PROTO((rtx, union tree_node *)); -extern rtx eliminate_constant_term PROTO((rtx, rtx *)); -extern rtx expand_complex_abs PROTO((enum machine_mode, rtx, rtx, int)); -extern enum machine_mode choose_hard_reg_mode PROTO((int, int)); - -/* Functions in rtlanal.c */ - -extern int rtx_unstable_p PROTO((rtx)); -extern int rtx_varies_p PROTO((rtx)); -extern int rtx_addr_varies_p PROTO((rtx)); -extern HOST_WIDE_INT get_integer_term PROTO((rtx)); -extern rtx get_related_value PROTO((rtx)); -extern int reg_mentioned_p PROTO((rtx, rtx)); -extern int reg_referenced_p PROTO((rtx, rtx)); -extern int reg_used_between_p PROTO((rtx, rtx, rtx)); -extern int reg_referenced_between_p PROTO((rtx, rtx, rtx)); -extern int reg_set_between_p PROTO((rtx, rtx, rtx)); -extern int regs_set_between_p PROTO((rtx, rtx, rtx)); -extern int modified_between_p PROTO((rtx, rtx, rtx)); -extern int no_labels_between_p PROTO((rtx, rtx)); -extern int no_jumps_between_p PROTO((rtx, rtx)); -extern int modified_in_p PROTO((rtx, rtx)); -extern int reg_set_p PROTO((rtx, rtx)); -extern rtx single_set PROTO((rtx)); -extern int multiple_sets PROTO((rtx)); -extern rtx find_last_value PROTO((rtx, rtx *, rtx)); -extern int refers_to_regno_p PROTO((int, int, rtx, rtx *)); -extern int reg_overlap_mentioned_p PROTO((rtx, rtx)); -extern void note_stores PROTO((rtx, void (*)())); -extern rtx reg_set_last PROTO((rtx, rtx)); -extern int rtx_equal_p PROTO((rtx, rtx)); -extern int dead_or_set_p PROTO((rtx, rtx)); -extern int dead_or_set_regno_p PROTO((rtx, int)); -extern rtx find_reg_note PROTO((rtx, enum reg_note, rtx)); -extern rtx find_regno_note PROTO((rtx, enum reg_note, int)); -extern int find_reg_fusage PROTO((rtx, enum rtx_code, rtx)); -extern int find_regno_fusage PROTO((rtx, enum rtx_code, int)); -extern void remove_note PROTO((rtx, rtx)); -extern int side_effects_p PROTO((rtx)); -extern int volatile_refs_p PROTO((rtx)); -extern int volatile_insn_p PROTO((rtx)); -extern int may_trap_p PROTO((rtx)); -extern int inequality_comparisons_p PROTO ((rtx)); -extern rtx replace_rtx PROTO((rtx, rtx, rtx)); -extern rtx replace_regs PROTO((rtx, rtx *, int, int)); -extern int computed_jump_p PROTO((rtx)); -typedef int (*rtx_function) PROTO((rtx *, void *)); -extern int for_each_rtx PROTO((rtx *, rtx_function, void *)); -extern int insn_first_p PROTO((rtx, rtx)); -extern rtx regno_use_in PROTO((int, rtx)); - -/* flow.c */ - -extern rtx find_use_as_address PROTO((rtx, rtx, HOST_WIDE_INT)); - -/* regclass.c */ - -/* Maximum number of parallel sets and clobbers in any insn in this fn. - Always at least 3, since the combiner could put that many togetherm - and we want this to remain correct for all the remaining passes. */ - -extern int max_parallel; - -/* Free up register info memory. */ -extern void free_reg_info PROTO((void)); - -/* recog.c */ -extern int asm_noperands PROTO((rtx)); -extern char *decode_asm_operands PROTO((rtx, rtx *, rtx **, char **, enum machine_mode *)); - -extern enum reg_class reg_preferred_class PROTO((int)); -extern enum reg_class reg_alternate_class PROTO((int)); - -extern rtx get_first_nonparm_insn PROTO((void)); - -extern void split_block_insns PROTO((int, int)); -extern void update_flow_info PROTO((rtx, rtx, rtx, rtx)); - -/* Standard pieces of rtx, to be substituted directly into things. */ -#define pc_rtx (&global_rtl.pc_val) -#define cc0_rtx (&global_rtl.cc0_val) - -#define MAX_SAVED_CONST_INT 64 -extern struct rtx_def const_int_rtx[MAX_SAVED_CONST_INT * 2 + 1]; - -#define const0_rtx (&const_int_rtx[MAX_SAVED_CONST_INT]) -#define const1_rtx (&const_int_rtx[MAX_SAVED_CONST_INT+1]) -#define const2_rtx (&const_int_rtx[MAX_SAVED_CONST_INT+2]) -#define constm1_rtx (&const_int_rtx[MAX_SAVED_CONST_INT-1]) -extern rtx const_true_rtx; - -extern rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE]; - -/* Returns a constant 0 rtx in mode MODE. Integer modes are treated the - same as VOIDmode. */ - -#define CONST0_RTX(MODE) (const_tiny_rtx[0][(int) (MODE)]) - -/* Likewise, for the constants 1 and 2. */ - -#define CONST1_RTX(MODE) (const_tiny_rtx[1][(int) (MODE)]) -#define CONST2_RTX(MODE) (const_tiny_rtx[2][(int) (MODE)]) - -extern struct _global_rtl -{ - struct rtx_def pc_val, cc0_val; - struct rtx_def stack_pointer_val, frame_pointer_val; - struct rtx_def hard_frame_pointer_val; - struct rtx_def arg_pointer_val; - struct rtx_def virtual_incoming_args_val; - struct rtx_def virtual_stack_vars_val; - struct rtx_def virtual_stack_dynamic_val; - struct rtx_def virtual_outgoing_args_val; - struct rtx_def virtual_cfa_val; -} global_rtl; - -/* All references to certain hard regs, except those created - by allocating pseudo regs into them (when that's possible), - go through these unique rtx objects. */ -#define stack_pointer_rtx (&global_rtl.stack_pointer_val) -#define frame_pointer_rtx (&global_rtl.frame_pointer_val) - -extern rtx pic_offset_table_rtx; -extern rtx struct_value_rtx; -extern rtx struct_value_incoming_rtx; -extern rtx static_chain_rtx; -extern rtx static_chain_incoming_rtx; -extern rtx return_address_pointer_rtx; - -/* Include the RTL generation functions. */ - -#ifndef NO_GENRTL_H -#include "genrtl.h" -#endif - -/* There are some RTL codes that require special attention; the - generation functions included above do the raw handling. If you - add to this list, modify special_rtx in gengenrtl.c as well. You - should also modify gen_rtx to use the special function. */ - -extern rtx gen_rtx_CONST_INT PROTO((enum machine_mode, HOST_WIDE_INT)); -extern rtx gen_rtx_REG PROTO((enum machine_mode, int)); -extern rtx gen_rtx_MEM PROTO((enum machine_mode, rtx)); - -/* We need the cast here to ensure that we get the same result both with - and without prototypes. */ -#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (HOST_WIDE_INT) (N)) - - -/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg - is used to represent the frame pointer. This is because the - hard frame pointer and the automatic variables are separated by an amount - that cannot be determined until after register allocation. We can assume - that in this case ELIMINABLE_REGS will be defined, one action of which - will be to eliminate FRAME_POINTER_REGNUM into HARD_FRAME_POINTER_REGNUM. */ -#ifndef HARD_FRAME_POINTER_REGNUM -#define HARD_FRAME_POINTER_REGNUM FRAME_POINTER_REGNUM -#endif - -/* For register elimination to work properly these hard_frame_pointer_rtx, - frame_pointer_rtx, and arg_pointer_rtx must be the same if they refer to - the same register. */ -#if HARD_FRAME_POINTER_REGNUM == FRAME_POINTER_REGNUM -#define hard_frame_pointer_rtx (&global_rtl.frame_pointer_val) -#else -#define hard_frame_pointer_rtx (&global_rtl.hard_frame_pointer_val) -#endif - -#if FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM -#define arg_pointer_rtx (&global_rtl.frame_pointer_val) -#else -#if HARD_FRAME_POINTER_REGNUM == ARG_POINTER_REGNUM -#define arg_pointer_rtx (&global_rtl.hard_frame_pointer_val) -#else -#define arg_pointer_rtx (&global_rtl.arg_pointer_val) -#endif -#endif - -/* Virtual registers are used during RTL generation to refer to locations into - the stack frame when the actual location isn't known until RTL generation - is complete. The routine instantiate_virtual_regs replaces these with - the proper value, which is normally {frame,arg,stack}_pointer_rtx plus - a constant. */ - -#define FIRST_VIRTUAL_REGISTER (FIRST_PSEUDO_REGISTER) - -/* This points to the first word of the incoming arguments passed on the stack, - either by the caller or by the callee when pretending it was passed by the - caller. */ - -#define virtual_incoming_args_rtx (&global_rtl.virtual_incoming_args_val) - -#define VIRTUAL_INCOMING_ARGS_REGNUM (FIRST_VIRTUAL_REGISTER) - -/* If FRAME_GROWS_DOWNWARD, this points to immediately above the first - variable on the stack. Otherwise, it points to the first variable on - the stack. */ - -#define virtual_stack_vars_rtx (&global_rtl.virtual_stack_vars_val) - -#define VIRTUAL_STACK_VARS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 1) - -/* This points to the location of dynamically-allocated memory on the stack - immediately after the stack pointer has been adjusted by the amount - desired. */ - -#define virtual_stack_dynamic_rtx (&global_rtl.virtual_stack_dynamic_val) - -#define VIRTUAL_STACK_DYNAMIC_REGNUM ((FIRST_VIRTUAL_REGISTER) + 2) - -/* This points to the location in the stack at which outgoing arguments should - be written when the stack is pre-pushed (arguments pushed using push - insns always use sp). */ - -#define virtual_outgoing_args_rtx (&global_rtl.virtual_outgoing_args_val) - -#define VIRTUAL_OUTGOING_ARGS_REGNUM ((FIRST_VIRTUAL_REGISTER) + 3) - -/* This points to the Canonical Frame Address of the function. This - should corrospond to the CFA produced by INCOMING_FRAME_SP_OFFSET, - but is calculated relative to the arg pointer for simplicity; the - frame pointer nor stack pointer are necessarily fixed relative to - the CFA until after reload. */ - -#define virtual_cfa_rtx (&global_rtl.virtual_cfa_val) - -#define VIRTUAL_CFA_REGNUM ((FIRST_VIRTUAL_REGISTER) + 4) - -#define LAST_VIRTUAL_REGISTER ((FIRST_VIRTUAL_REGISTER) + 4) - -extern rtx find_next_ref PROTO((rtx, rtx)); -extern rtx *find_single_use PROTO((rtx, rtx, rtx *)); - -extern rtx output_constant_def PROTO((union tree_node *)); -extern rtx immed_real_const PROTO((union tree_node *)); -extern union tree_node *make_tree PROTO((union tree_node *, rtx)); - -/* Define a default value for STORE_FLAG_VALUE. */ - -#ifndef STORE_FLAG_VALUE -#define STORE_FLAG_VALUE 1 -#endif - -/* Nonzero after the second flow pass has completed. - Set to 1 or 0 by toplev.c */ -extern int flow2_completed; - -/* Nonzero after end of reload pass. - Set to 1 or 0 by reload1.c. */ - -extern int reload_completed; - -/* Set to 1 while reload_as_needed is operating. - Required by some machines to handle any generated moves differently. */ - -extern int reload_in_progress; - -/* If this is nonzero, we do not bother generating VOLATILE - around volatile memory references, and we are willing to - output indirect addresses. If cse is to follow, we reject - indirect addresses so a useful potential cse is generated; - if it is used only once, instruction combination will produce - the same indirect address eventually. */ -extern int cse_not_expected; - -/* Set to nonzero before life analysis to indicate that it is unsafe to - generate any new pseudo registers. */ -extern int no_new_pseudos; - -/* Indexed by pseudo register number, gives the rtx for that pseudo. - Allocated in parallel with regno_pointer_flag. */ -extern rtx *regno_reg_rtx; - -/* Vector indexed by regno; contain the alignment in bytes and type - pointed to for a register that contains a pointer, if known. */ -extern char *regno_pointer_align; -#define REGNO_POINTER_ALIGN(REGNO) regno_pointer_align[REGNO] - -/* Translates rtx code to tree code, for those codes needed by - REAL_ARITHMETIC. The function returns an int because the caller may not - know what `enum tree_code' means. */ - -extern int rtx_to_tree_code PROTO((enum rtx_code)); - -/* In tree.c */ -extern void obfree PROTO ((char *)); -struct obstack; -extern void gcc_obstack_init PROTO ((struct obstack *)); -extern void pop_obstacks PROTO ((void)); -extern void push_obstacks PROTO ((struct obstack *, - struct obstack *)); -/* CYGNUS LOCAL SH4-OPT */ -/* Save the current set of obstacks, but don't change them. */ -extern void push_obstacks_nochange PROTO((void)); -extern void end_temporary_allocation PROTO((void)); -/* END CYGNUS LOCAL */ -#ifdef BUFSIZ -extern int read_skip_spaces PROTO ((FILE *)); -#endif - -/* In cse.c */ -struct cse_basic_block_data; -extern int rtx_cost PROTO ((rtx, enum rtx_code)); -extern void delete_trivially_dead_insns PROTO ((rtx, int)); -#ifdef BUFSIZ -extern int cse_main PROTO ((rtx, int, int, FILE *)); -#endif -extern void cse_end_of_basic_block PROTO ((rtx, - struct cse_basic_block_data *, - int, int, int)); - -/* In jump.c */ -extern int comparison_dominates_p PROTO ((enum rtx_code, enum rtx_code)); -extern int condjump_p PROTO ((rtx)); -extern rtx condjump_label PROTO ((rtx)); -extern int simplejump_p PROTO ((rtx)); -extern int sets_cc0_p PROTO ((rtx)); -extern int invert_jump PROTO ((rtx, rtx)); -extern int rtx_renumbered_equal_p PROTO ((rtx, rtx)); -extern int true_regnum PROTO ((rtx)); -extern int redirect_jump PROTO ((rtx, rtx)); -extern void jump_optimize PROTO ((rtx, int, int, int)); -extern void thread_jumps PROTO ((rtx, int, int)); -extern int redirect_exp PROTO ((rtx *, rtx, rtx, rtx)); -extern int rtx_equal_for_thread_p PROTO ((rtx, rtx, rtx)); -extern int invert_exp PROTO ((rtx, rtx)); -extern int can_reverse_comparison_p PROTO ((rtx, rtx)); -extern void delete_for_peephole PROTO ((rtx, rtx)); -extern int condjump_in_parallel_p PROTO ((rtx)); - -/* Flags for jump_optimize() */ -#define JUMP_CROSS_JUMP 1 -#define JUMP_NOOP_MOVES 1 -#define JUMP_AFTER_REGSCAN 1 - -/* In emit-rtl.c. */ -extern int max_reg_num PROTO ((void)); -extern int max_label_num PROTO ((void)); -extern int get_first_label_num PROTO ((void)); -extern void delete_insns_since PROTO ((rtx)); -extern void mark_reg_pointer PROTO ((rtx, int)); -extern void mark_user_reg PROTO ((rtx)); -extern void reset_used_flags PROTO ((rtx)); -extern void reorder_insns PROTO ((rtx, rtx, rtx)); -extern int get_max_uid PROTO ((void)); -extern int in_sequence_p PROTO ((void)); -extern void force_next_line_note PROTO ((void)); -extern void init_emit PROTO ((void)); -extern void init_emit_once PROTO ((int)); -extern void push_topmost_sequence PROTO ((void)); -extern void pop_topmost_sequence PROTO ((void)); -extern int subreg_realpart_p PROTO ((rtx)); -extern void reverse_comparison PROTO ((rtx)); -extern void set_new_first_and_last_insn PROTO ((rtx, rtx)); -extern void set_new_first_and_last_label_num PROTO ((int, int)); -extern void unshare_all_rtl PROTO ((rtx)); -extern void set_last_insn PROTO ((rtx)); -extern void link_cc0_insns PROTO ((rtx)); -extern void add_insn PROTO ((rtx)); -extern void add_insn_before PROTO ((rtx, rtx)); -extern void add_insn_after PROTO ((rtx, rtx)); -extern void remove_insn PROTO ((rtx)); -extern void reorder_insns_with_line_notes PROTO ((rtx, rtx, rtx)); -extern void emit_insn_after_with_line_notes PROTO ((rtx, rtx, rtx)); -extern enum rtx_code classify_insn PROTO ((rtx)); -extern void init_virtual_regs PROTO ((void)); -extern rtx emit PROTO ((rtx)); -/* 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 PROTO((void)); -void restore_line_number_status PROTO((int old_value)); - -/* In insn-emit.c */ -extern void add_clobbers PROTO ((rtx, int)); - -/* In combine.c */ -extern void combine_instructions PROTO ((rtx, int)); -extern int extended_count PROTO ((rtx, enum machine_mode, int)); -extern rtx remove_death PROTO ((int, rtx)); -#ifdef BUFSIZ -extern void dump_combine_stats PROTO ((FILE *)); -extern void dump_combine_total_stats PROTO ((FILE *)); -#endif - -/* In sched.c. */ -#ifdef BUFSIZ -extern void schedule_insns PROTO ((FILE *)); -#endif -#ifdef HAIFA -extern void fix_sched_param PROTO ((char *, char *)); -#endif - -/* In print-rtl.c */ -extern void debug_rtx PROTO ((rtx)); -extern void debug_rtx_list PROTO ((rtx, int)); -extern rtx debug_rtx_find PROTO ((rtx, int)); -#ifdef BUFSIZ -extern void print_rtl PROTO ((FILE *, rtx)); -extern int print_rtl_single PROTO ((FILE *, rtx)); -extern void print_inline_rtx PROTO ((FILE *, rtx, int)); -#endif - -/* In loop.c */ -extern void init_loop PROTO ((void)); -#ifdef BUFSIZ -extern void loop_optimize PROTO ((rtx, FILE *, int, int)); -#endif -extern void record_excess_regs PROTO ((rtx, rtx, rtx *)); - -/* In function.c */ -extern void reposition_prologue_and_epilogue_notes PROTO ((rtx)); -extern void thread_prologue_and_epilogue_insns PROTO ((rtx)); -extern void use_variable PROTO ((rtx)); -extern HOST_WIDE_INT get_frame_size PROTO ((void)); -extern void preserve_rtl_expr_result PROTO ((rtx)); -extern void mark_temp_addr_taken PROTO ((rtx)); -extern void update_temp_slot_address PROTO ((rtx, rtx)); -extern void use_variable_after PROTO ((rtx, rtx)); -extern void purge_addressof PROTO ((rtx)); - -/* In reload.c */ -extern int operands_match_p PROTO ((rtx, rtx)); -extern int safe_from_earlyclobber PROTO ((rtx, rtx)); - -/* In stmt.c */ -extern void expand_null_return PROTO((void)); -extern void emit_jump PROTO ((rtx)); -extern int preserve_subexpressions_p PROTO ((void)); - -/* In expr.c */ -extern void init_expr_once PROTO ((void)); -extern void move_by_pieces PROTO ((rtx, rtx, int, int)); - - -/* In stupid.c */ -#ifdef BUFSIZ -extern void stupid_life_analysis PROTO ((rtx, int, FILE *)); -#endif - -/* In flow.c */ -extern void allocate_for_life_analysis PROTO ((void)); -extern void recompute_reg_usage PROTO ((rtx, int)); -#ifdef BUFSIZ -extern void dump_flow_info PROTO ((FILE *)); -#endif -extern void free_bb_memory PROTO ((void)); - -/* In expmed.c */ -extern void init_expmed PROTO ((void)); -extern void expand_inc PROTO ((rtx, rtx)); -extern void expand_dec PROTO ((rtx, rtx)); -extern rtx expand_mult_highpart PROTO ((enum machine_mode, rtx, - unsigned HOST_WIDE_INT, rtx, - int, int)); - -/* In gcse.c */ -#ifdef BUFSIZ -/* CYGNUS LOCAL gcse/law */ -extern int gcse_main PROTO ((rtx, FILE *)); -/* END CYGNUS LOCAL */ -#endif - -/* In global.c */ -extern void mark_elimination PROTO ((int, int)); -#ifdef BUFSIZ -extern int global_alloc PROTO ((FILE *)); -extern void dump_global_regs PROTO ((FILE *)); -#endif -#ifdef HARD_CONST -extern void retry_global_alloc PROTO ((int, HARD_REG_SET)); -#endif - -/* In regclass.c */ -extern int reg_classes_intersect_p PROTO ((enum reg_class, enum reg_class)); -extern int reg_class_subset_p PROTO ((enum reg_class, enum reg_class)); -extern void globalize_reg PROTO ((int)); -extern void init_regs PROTO ((void)); -extern void init_reg_sets PROTO ((void)); -extern void regset_release_memory PROTO ((void)); -extern void regclass_init PROTO ((void)); -extern void regclass PROTO ((rtx, int)); -extern void reg_scan PROTO ((rtx, int, int)); -extern void reg_scan_update PROTO ((rtx, rtx, int)); -extern void fix_register PROTO ((char *, int, int)); - -/* In regmove.c */ -#ifdef BUFSIZ -extern void regmove_optimize PROTO ((rtx, int, FILE *)); -#endif - -/* In reorg.c */ -#ifdef BUFSIZ -extern void dbr_schedule PROTO ((rtx, FILE *)); -#endif - -/* In optabs.c */ -extern void init_optabs PROTO ((void)); - -/* In local-alloc.c */ -#ifdef BUFSIZ -extern void dump_local_alloc PROTO ((FILE *)); -#endif -extern void local_alloc PROTO ((void)); -extern int function_invariant_p PROTO ((rtx)); - -/* In reload1.c */ -extern void reload_cse_regs PROTO ((rtx)); -extern void init_reload PROTO ((void)); -extern void mark_home_live PROTO ((int)); -#ifdef BUFSIZ -extern int reload PROTO ((rtx, int, FILE *)); -#endif - -/* In caller-save.c */ -extern void init_caller_save PROTO ((void)); - -/* In reg-stack.c */ -#ifdef BUFSIZ -extern void reg_to_stack PROTO ((rtx, FILE *)); -#endif -extern int stack_regs_mentioned_p PROTO ((rtx)); - -/* In fold-const.c */ -extern int add_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT *, HOST_WIDE_INT *)); -extern int neg_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT *, HOST_WIDE_INT *)); -extern int mul_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT *, HOST_WIDE_INT *)); -extern void lshift_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, int, HOST_WIDE_INT *, - HOST_WIDE_INT *, int)); -extern void rshift_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, int, - HOST_WIDE_INT *, HOST_WIDE_INT *, int)); -extern void lrotate_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, int, HOST_WIDE_INT *, - HOST_WIDE_INT *)); -extern void rrotate_double PROTO ((HOST_WIDE_INT, HOST_WIDE_INT, - HOST_WIDE_INT, int, HOST_WIDE_INT *, - HOST_WIDE_INT *)); - -/* In calls.c */ -/* Emit library call. */ -extern void emit_library_call PVPROTO ((rtx, int, enum machine_mode, - int, ...)); -extern rtx emit_library_call_value PVPROTO((rtx, rtx, int, - enum machine_mode, - int, ...)); - -/* In unroll.c */ -extern int set_dominates_use PROTO ((int, int, int, rtx, rtx)); - -/* In varasm.c */ -extern void bss_section PROTO ((void)); -extern int in_data_section PROTO ((void)); -extern int supports_one_only PROTO ((void)); - -/* In rtl.c */ -extern void init_rtl PROTO ((void)); -extern void rtx_free PROTO ((rtx)); - -/* In alias.c */ -extern int true_dependence PROTO ((rtx, enum machine_mode, rtx, - int (*)(rtx))); -extern int read_dependence PROTO ((rtx, rtx)); -extern int anti_dependence PROTO ((rtx, rtx)); -extern int output_dependence PROTO ((rtx, rtx)); -extern void init_alias_once PROTO ((void)); -extern void init_alias_analysis PROTO ((void)); -extern void end_alias_analysis PROTO ((void)); - -extern void record_base_value PROTO ((int, rtx, int)); -extern void record_alias_subset PROTO ((int, int)); -extern rtx addr_side_effect_eval PROTO ((rtx, int, int)); - -#endif /* _RTL_H */ diff --git a/gcc/unroll_991002.c b/gcc/unroll_991002.c deleted file mode 100755 index 431c0dc..0000000 --- a/gcc/unroll_991002.c +++ /dev/null @@ -1,4045 +0,0 @@ -/* Try to unroll loops, and split induction variables. - Copyright (C) 1992, 93, 94, 95, 97, 98, 1999 Free Software Foundation, Inc. - Contributed by James E. Wilson, Cygnus Support/UC Berkeley. - -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. */ - -/* Try to unroll a loop, and split induction variables. - - Loops for which the number of iterations can be calculated exactly are - handled specially. If the number of iterations times the insn_count is - less than MAX_UNROLLED_INSNS, then the loop is unrolled completely. - Otherwise, we try to unroll the loop a number of times modulo the number - of iterations, so that only one exit test will be needed. It is unrolled - a number of times approximately equal to MAX_UNROLLED_INSNS divided by - the insn count. - - Otherwise, if the number of iterations can be calculated exactly at - run time, and the loop is always entered at the top, then we try to - precondition the loop. That is, at run time, calculate how many times - the loop will execute, and then execute the loop body a few times so - that the remaining iterations will be some multiple of 4 (or 2 if the - loop is large). Then fall through to a loop unrolled 4 (or 2) times, - with only one exit test needed at the end of the loop. - - Otherwise, if the number of iterations can not be calculated exactly, - not even at run time, then we still unroll the loop a number of times - approximately equal to MAX_UNROLLED_INSNS divided by the insn count, - but there must be an exit test after each copy of the loop body. - - For each induction variable, which is dead outside the loop (replaceable) - or for which we can easily calculate the final value, if we can easily - calculate its value at each place where it is set as a function of the - current loop unroll count and the variable's value at loop entry, then - the induction variable is split into `N' different variables, one for - each copy of the loop body. One variable is live across the backward - branch, and the others are all calculated as a function of this variable. - This helps eliminate data dependencies, and leads to further opportunities - for cse. */ - -/* Possible improvements follow: */ - -/* ??? Add an extra pass somewhere to determine whether unrolling will - give any benefit. E.g. after generating all unrolled insns, compute the - cost of all insns and compare against cost of insns in rolled loop. - - - On traditional architectures, unrolling a non-constant bound loop - is a win if there is a giv whose only use is in memory addresses, the - memory addresses can be split, and hence giv increments can be - eliminated. - - It is also a win if the loop is executed many times, and preconditioning - can be performed for the loop. - Add code to check for these and similar cases. */ - -/* ??? Improve control of which loops get unrolled. Could use profiling - info to only unroll the most commonly executed loops. Perhaps have - a user specifyable option to control the amount of code expansion, - or the percent of loops to consider for unrolling. Etc. */ - -/* ??? Look at the register copies inside the loop to see if they form a - simple permutation. If so, iterate the permutation until it gets back to - the start state. This is how many times we should unroll the loop, for - best results, because then all register copies can be eliminated. - For example, the lisp nreverse function should be unrolled 3 times - while (this) - { - next = this->cdr; - this->cdr = prev; - prev = this; - this = next; - } - - ??? The number of times to unroll the loop may also be based on data - references in the loop. For example, if we have a loop that references - x[i-1], x[i], and x[i+1], we should unroll it a multiple of 3 times. */ - -/* ??? Add some simple linear equation solving capability so that we can - determine the number of loop iterations for more complex loops. - For example, consider this loop from gdb - #define SWAP_TARGET_AND_HOST(buffer,len) - { - char tmp; - char *p = (char *) buffer; - char *q = ((char *) buffer) + len - 1; - int iterations = (len + 1) >> 1; - int i; - for (p; p < q; p++, q--;) - { - tmp = *q; - *q = *p; - *p = tmp; - } - } - Note that: - start value = p = &buffer + current_iteration - end value = q = &buffer + len - 1 - current_iteration - Given the loop exit test of "p < q", then there must be "q - p" iterations, - set equal to zero and solve for number of iterations: - q - p = len - 1 - 2*current_iteration = 0 - current_iteration = (len - 1) / 2 - Hence, there are (len - 1) / 2 (rounded up to the nearest integer) - iterations of this loop. */ - -/* ??? Currently, no labels are marked as loop invariant when doing loop - unrolling. This is because an insn inside the loop, that loads the address - of a label inside the loop into a register, could be moved outside the loop - by the invariant code motion pass if labels were invariant. If the loop - is subsequently unrolled, the code will be wrong because each unrolled - body of the loop will use the same address, whereas each actually needs a - different address. A case where this happens is when a loop containing - a switch statement is unrolled. - - It would be better to let labels be considered invariant. When we - unroll loops here, check to see if any insns using a label local to the - loop were moved before the loop. If so, then correct the problem, by - moving the insn back into the loop, or perhaps replicate the insn before - the loop, one copy for each time the loop is unrolled. */ - -/* The prime factors looked for when trying to unroll a loop by some - number which is modulo the total number of iterations. Just checking - for these 4 prime factors will find at least one factor for 75% of - all numbers theoretically. Practically speaking, this will succeed - almost all of the time since loops are generally a multiple of 2 - and/or 5. */ - -#define NUM_FACTORS 4 - -struct _factor { int factor, count; } factors[NUM_FACTORS] - = { {2, 0}, {3, 0}, {5, 0}, {7, 0}}; - -/* Describes the different types of loop unrolling performed. */ - -enum unroll_types { UNROLL_COMPLETELY, UNROLL_MODULO, UNROLL_NAIVE }; - -#include "config.h" -#include "system.h" -#include "rtl.h" -#include "insn-config.h" -#include "integrate.h" -#include "regs.h" -#include "recog.h" -#include "flags.h" -#include "expr.h" -#include "loop.h" -#include "toplev.h" - -/* This controls which loops are unrolled, and by how much we unroll - them. */ - -#ifndef MAX_UNROLLED_INSNS -#define MAX_UNROLLED_INSNS 100 -#endif - -/* Indexed by register number, if non-zero, then it contains a pointer - to a struct induction for a DEST_REG giv which has been combined with - one of more address givs. This is needed because whenever such a DEST_REG - giv is modified, we must modify the value of all split address givs - that were combined with this DEST_REG giv. */ - -static struct induction **addr_combined_regs; - -/* Indexed by register number, if this is a splittable induction variable, - then this will hold the current value of the register, which depends on the - iteration number. */ - -static rtx *splittable_regs; - -/* Indexed by register number, if this is a splittable induction variable, - this indicates if it was made from a derived giv. */ -static char *derived_regs; - -/* Indexed by register number, if this is a splittable induction variable, - then this will hold the number of instructions in the loop that modify - the induction variable. Used to ensure that only the last insn modifying - a split iv will update the original iv of the dest. */ - -static int *splittable_regs_updates; - -/* Forward declarations. */ - -static void init_reg_map PROTO((struct inline_remap *, int)); -static rtx calculate_giv_inc PROTO((rtx, rtx, int)); -static rtx initial_reg_note_copy PROTO((rtx, struct inline_remap *)); -static void final_reg_note_copy PROTO((rtx, struct inline_remap *)); -static void copy_loop_body PROTO((rtx, rtx, struct inline_remap *, rtx, int, - enum unroll_types, rtx, rtx, rtx, rtx)); -static void iteration_info PROTO((rtx, rtx *, rtx *, rtx, rtx)); -static int find_splittable_regs PROTO((enum unroll_types, rtx, rtx, rtx, int, - unsigned HOST_WIDE_INT)); -static int find_splittable_givs PROTO((struct iv_class *, enum unroll_types, - rtx, rtx, rtx, int)); -static int reg_dead_after_loop PROTO((rtx, rtx, rtx)); -static rtx fold_rtx_mult_add PROTO((rtx, rtx, rtx, enum machine_mode)); -static int verify_addresses PROTO((struct induction *, rtx, int)); -static rtx remap_split_bivs PROTO((rtx)); - -/* Try to unroll one loop and split induction variables in the loop. - - The loop is described by the arguments LOOP_END, INSN_COUNT, and - LOOP_START. END_INSERT_BEFORE indicates where insns should be added - which need to be executed when the loop falls through. STRENGTH_REDUCTION_P - indicates whether information generated in the strength reduction pass - is available. - - This function is intended to be called from within `strength_reduce' - in loop.c. */ - -void -unroll_loop (loop_end, insn_count, loop_start, end_insert_before, - loop_info, strength_reduce_p) - rtx loop_end; - int insn_count; - rtx loop_start; - rtx end_insert_before; - struct loop_info *loop_info; - int strength_reduce_p; -{ - int i, j, temp; - int unroll_number = 1; - rtx copy_start, copy_end; - rtx insn, sequence, pattern, tem; - int max_labelno, max_insnno; - rtx insert_before; - struct inline_remap *map; - char *local_label; - char *local_regno; - int maxregnum; - int new_maxregnum; - rtx exit_label = 0; - rtx start_label; - struct iv_class *bl; - int splitting_not_safe = 0; - enum unroll_types unroll_type; - int loop_preconditioned = 0; - rtx safety_label; - /* This points to the last real insn in the loop, which should be either - a JUMP_INSN (for conditional jumps) or a BARRIER (for unconditional - jumps). */ - rtx last_loop_insn; - - /* Don't bother unrolling huge loops. Since the minimum factor is - two, loops greater than one half of MAX_UNROLLED_INSNS will never - be unrolled. */ - if (insn_count > MAX_UNROLLED_INSNS / 2) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, "Unrolling failure: Loop too big.\n"); - return; - } - - /* When emitting debugger info, we can't unroll loops with unequal numbers - of block_beg and block_end notes, because that would unbalance the block - structure of the function. This can happen as a result of the - "if (foo) bar; else break;" optimization in jump.c. */ - /* ??? Gcc has a general policy that -g is never supposed to change the code - that the compiler emits, so we must disable this optimization always, - even if debug info is not being output. This is rare, so this should - not be a significant performance problem. */ - - if (1 /* write_symbols != NO_DEBUG */) - { - int block_begins = 0; - int block_ends = 0; - - for (insn = loop_start; insn != loop_end; insn = NEXT_INSN (insn)) - { - if (GET_CODE (insn) == NOTE) - { - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG) - block_begins++; - else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END) - block_ends++; - } - } - - if (block_begins != block_ends) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: Unbalanced block notes.\n"); - return; - } - } - - /* Determine type of unroll to perform. Depends on the number of iterations - and the size of the loop. */ - - /* If there is no strength reduce info, then set - loop_info->n_iterations to zero. This can happen if - strength_reduce can't find any bivs in the loop. A value of zero - indicates that the number of iterations could not be calculated. */ - - if (! strength_reduce_p) - loop_info->n_iterations = 0; - - if (loop_dump_stream && loop_info->n_iterations > 0) - { - fputs ("Loop unrolling: ", loop_dump_stream); - fprintf (loop_dump_stream, HOST_WIDE_INT_PRINT_DEC, - loop_info->n_iterations); - fputs (" iterations.\n", loop_dump_stream); - } - - /* Find and save a pointer to the last nonnote insn in the loop. */ - - last_loop_insn = prev_nonnote_insn (loop_end); - - /* Calculate how many times to unroll the loop. Indicate whether or - not the loop is being completely unrolled. */ - - if (loop_info->n_iterations == 1) - { - /* If number of iterations is exactly 1, then eliminate the compare and - branch at the end of the loop since they will never be taken. - Then return, since no other action is needed here. */ - - /* If the last instruction is not a BARRIER or a JUMP_INSN, then - don't do anything. */ - - if (GET_CODE (last_loop_insn) == BARRIER) - { - /* Delete the jump insn. This will delete the barrier also. */ - delete_insn (PREV_INSN (last_loop_insn)); - } - else if (GET_CODE (last_loop_insn) == JUMP_INSN) - { -#ifdef HAVE_cc0 - /* The immediately preceding insn is a compare which must be - deleted. */ - delete_insn (last_loop_insn); - delete_insn (PREV_INSN (last_loop_insn)); -#else - /* The immediately preceding insn may not be the compare, so don't - delete it. */ - delete_insn (last_loop_insn); -#endif - } - return; - } - else if (loop_info->n_iterations > 0 - && loop_info->n_iterations * insn_count < MAX_UNROLLED_INSNS) - { - unroll_number = loop_info->n_iterations; - unroll_type = UNROLL_COMPLETELY; - } - else if (loop_info->n_iterations > 0) - { - /* Try to factor the number of iterations. Don't bother with the - general case, only using 2, 3, 5, and 7 will get 75% of all - numbers theoretically, and almost all in practice. */ - - for (i = 0; i < NUM_FACTORS; i++) - factors[i].count = 0; - - temp = loop_info->n_iterations; - for (i = NUM_FACTORS - 1; i >= 0; i--) - while (temp % factors[i].factor == 0) - { - factors[i].count++; - temp = temp / factors[i].factor; - } - - /* Start with the larger factors first so that we generally - get lots of unrolling. */ - - unroll_number = 1; - temp = insn_count; - for (i = 3; i >= 0; i--) - while (factors[i].count--) - { - if (temp * factors[i].factor < MAX_UNROLLED_INSNS) - { - unroll_number *= factors[i].factor; - temp *= factors[i].factor; - } - else - break; - } - - /* If we couldn't find any factors, then unroll as in the normal - case. */ - if (unroll_number == 1) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: No factors found.\n"); - } - else - unroll_type = UNROLL_MODULO; - } - - - /* Default case, calculate number of times to unroll loop based on its - size. */ - if (unroll_number == 1) - { - if (8 * insn_count < MAX_UNROLLED_INSNS) - unroll_number = 8; - else if (4 * insn_count < MAX_UNROLLED_INSNS) - unroll_number = 4; - else - unroll_number = 2; - - unroll_type = UNROLL_NAIVE; - } - - /* Now we know how many times to unroll the loop. */ - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling loop %d times.\n", unroll_number); - - - if (unroll_type == UNROLL_COMPLETELY || unroll_type == UNROLL_MODULO) - { - /* Loops of these types can start with jump down to the exit condition - in rare circumstances. - - Consider a pair of nested loops where the inner loop is part - of the exit code for the outer loop. - - In this case jump.c will not duplicate the exit test for the outer - loop, so it will start with a jump to the exit code. - - Then consider if the inner loop turns out to iterate once and - only once. We will end up deleting the jumps associated with - the inner loop. However, the loop notes are not removed from - the instruction stream. - - And finally assume that we can compute the number of iterations - for the outer loop. - - In this case unroll may want to unroll the outer loop even though - it starts with a jump to the outer loop's exit code. - - We could try to optimize this case, but it hardly seems worth it. - Just return without unrolling the loop in such cases. */ - - insn = loop_start; - while (GET_CODE (insn) != CODE_LABEL && GET_CODE (insn) != JUMP_INSN) - insn = NEXT_INSN (insn); - if (GET_CODE (insn) == JUMP_INSN) - return; - } - - if (unroll_type == UNROLL_COMPLETELY) - { - /* Completely unrolling the loop: Delete the compare and branch at - the end (the last two instructions). This delete must done at the - very end of loop unrolling, to avoid problems with calls to - back_branch_in_range_p, which is called by find_splittable_regs. - All increments of splittable bivs/givs are changed to load constant - instructions. */ - - copy_start = loop_start; - - /* Set insert_before to the instruction immediately after the JUMP_INSN - (or BARRIER), so that any NOTEs between the JUMP_INSN and the end of - the loop will be correctly handled by copy_loop_body. */ - insert_before = NEXT_INSN (last_loop_insn); - - /* Set copy_end to the insn before the jump at the end of the loop. */ - if (GET_CODE (last_loop_insn) == BARRIER) - copy_end = PREV_INSN (PREV_INSN (last_loop_insn)); - else if (GET_CODE (last_loop_insn) == JUMP_INSN) - { -#ifdef HAVE_cc0 - /* The instruction immediately before the JUMP_INSN is a compare - instruction which we do not want to copy. */ - copy_end = PREV_INSN (PREV_INSN (last_loop_insn)); -#else - /* The instruction immediately before the JUMP_INSN may not be the - compare, so we must copy it. */ - copy_end = PREV_INSN (last_loop_insn); -#endif - } - else - { - /* We currently can't unroll a loop if it doesn't end with a - JUMP_INSN. There would need to be a mechanism that recognizes - this case, and then inserts a jump after each loop body, which - jumps to after the last loop body. */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: loop does not end with a JUMP_INSN.\n"); - return; - } - } - else if (unroll_type == UNROLL_MODULO) - { - /* Partially unrolling the loop: The compare and branch at the end - (the last two instructions) must remain. Don't copy the compare - and branch instructions at the end of the loop. Insert the unrolled - code immediately before the compare/branch at the end so that the - code will fall through to them as before. */ - - copy_start = loop_start; - - /* Set insert_before to the jump insn at the end of the loop. - Set copy_end to before the jump insn at the end of the loop. */ - if (GET_CODE (last_loop_insn) == BARRIER) - { - insert_before = PREV_INSN (last_loop_insn); - copy_end = PREV_INSN (insert_before); - } - else if (GET_CODE (last_loop_insn) == JUMP_INSN) - { -#ifdef HAVE_cc0 - /* The instruction immediately before the JUMP_INSN is a compare - instruction which we do not want to copy or delete. */ - insert_before = PREV_INSN (last_loop_insn); - copy_end = PREV_INSN (insert_before); -#else - /* The instruction immediately before the JUMP_INSN may not be the - compare, so we must copy it. */ - insert_before = last_loop_insn; - copy_end = PREV_INSN (last_loop_insn); -#endif - } - else - { - /* We currently can't unroll a loop if it doesn't end with a - JUMP_INSN. There would need to be a mechanism that recognizes - this case, and then inserts a jump after each loop body, which - jumps to after the last loop body. */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: loop does not end with a JUMP_INSN.\n"); - return; - } - } - else - { - /* Normal case: Must copy the compare and branch instructions at the - end of the loop. */ - - if (GET_CODE (last_loop_insn) == BARRIER) - { - /* Loop ends with an unconditional jump and a barrier. - Handle this like above, don't copy jump and barrier. - This is not strictly necessary, but doing so prevents generating - unconditional jumps to an immediately following label. - - This will be corrected below if the target of this jump is - not the start_label. */ - - insert_before = PREV_INSN (last_loop_insn); - copy_end = PREV_INSN (insert_before); - } - else if (GET_CODE (last_loop_insn) == JUMP_INSN) - { - /* Set insert_before to immediately after the JUMP_INSN, so that - NOTEs at the end of the loop will be correctly handled by - copy_loop_body. */ - insert_before = NEXT_INSN (last_loop_insn); - copy_end = last_loop_insn; - } - else - { - /* We currently can't unroll a loop if it doesn't end with a - JUMP_INSN. There would need to be a mechanism that recognizes - this case, and then inserts a jump after each loop body, which - jumps to after the last loop body. */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: loop does not end with a JUMP_INSN.\n"); - return; - } - - /* If copying exit test branches because they can not be eliminated, - then must convert the fall through case of the branch to a jump past - the end of the loop. Create a label to emit after the loop and save - it for later use. Do not use the label after the loop, if any, since - it might be used by insns outside the loop, or there might be insns - added before it later by final_[bg]iv_value which must be after - the real exit label. */ - exit_label = gen_label_rtx (); - - insn = loop_start; - while (GET_CODE (insn) != CODE_LABEL && GET_CODE (insn) != JUMP_INSN) - insn = NEXT_INSN (insn); - - if (GET_CODE (insn) == JUMP_INSN) - { - /* The loop starts with a jump down to the exit condition test. - Start copying the loop after the barrier following this - jump insn. */ - copy_start = NEXT_INSN (insn); - - /* Splitting induction variables doesn't work when the loop is - entered via a jump to the bottom, because then we end up doing - a comparison against a new register for a split variable, but - we did not execute the set insn for the new register because - it was skipped over. */ - splitting_not_safe = 1; - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Splitting not safe, because loop not entered at top.\n"); - } - else - copy_start = loop_start; - } - - /* This should always be the first label in the loop. */ - start_label = NEXT_INSN (copy_start); - /* There may be a line number note and/or a loop continue note here. */ - while (GET_CODE (start_label) == NOTE) - start_label = NEXT_INSN (start_label); - if (GET_CODE (start_label) != CODE_LABEL) - { - /* This can happen as a result of jump threading. If the first insns in - the loop test the same condition as the loop's backward jump, or the - opposite condition, then the backward jump will be modified to point - to elsewhere, and the loop's start label is deleted. - - This case currently can not be handled by the loop unrolling code. */ - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: unknown insns between BEG note and loop label.\n"); - return; - } - if (LABEL_NAME (start_label)) - { - /* The jump optimization pass must have combined the original start label - with a named label for a goto. We can't unroll this case because - jumps which go to the named label must be handled differently than - jumps to the loop start, and it is impossible to differentiate them - in this case. */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: loop start label is gone\n"); - return; - } - - if (unroll_type == UNROLL_NAIVE - && GET_CODE (last_loop_insn) == BARRIER - && start_label != JUMP_LABEL (PREV_INSN (last_loop_insn))) - { - /* In this case, we must copy the jump and barrier, because they will - not be converted to jumps to an immediately following label. */ - - insert_before = NEXT_INSN (last_loop_insn); - copy_end = last_loop_insn; - } - - if (unroll_type == UNROLL_NAIVE - && GET_CODE (last_loop_insn) == JUMP_INSN - && start_label != JUMP_LABEL (last_loop_insn)) - { - /* ??? The loop ends with a conditional branch that does not branch back - to the loop start label. In this case, we must emit an unconditional - branch to the loop exit after emitting the final branch. - copy_loop_body does not have support for this currently, so we - give up. It doesn't seem worthwhile to unroll anyways since - unrolling would increase the number of branch instructions - executed. */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Unrolling failure: final conditional branch not to loop start\n"); - return; - } - - /* Allocate a translation table for the labels and insn numbers. - They will be filled in as we copy the insns in the loop. */ - - max_labelno = max_label_num (); - max_insnno = get_max_uid (); - - map = (struct inline_remap *) alloca (sizeof (struct inline_remap)); - - map->integrating = 0; - - /* Allocate the label map. */ - - if (max_labelno > 0) - { - map->label_map = (rtx *) alloca (max_labelno * sizeof (rtx)); - - local_label = (char *) alloca (max_labelno); - zero_memory (local_label, max_labelno); - } - else - map->label_map = 0; - - /* Search the loop and mark all local labels, i.e. the ones which have to - be distinct labels when copied. For all labels which might be - non-local, set their label_map entries to point to themselves. - If they happen to be local their label_map entries will be overwritten - before the loop body is copied. The label_map entries for local labels - will be set to a different value each time the loop body is copied. */ - - for (insn = copy_start; insn != loop_end; insn = NEXT_INSN (insn)) - { - rtx note; - - if (GET_CODE (insn) == CODE_LABEL) - local_label[CODE_LABEL_NUMBER (insn)] = 1; - else if (GET_CODE (insn) == JUMP_INSN) - { - if (JUMP_LABEL (insn)) - set_label_in_map (map, - CODE_LABEL_NUMBER (JUMP_LABEL (insn)), - JUMP_LABEL (insn)); - else if (GET_CODE (PATTERN (insn)) == ADDR_VEC - || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC) - { - rtx pat = PATTERN (insn); - int diff_vec_p = GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC; - int len = XVECLEN (pat, diff_vec_p); - rtx label; - - for (i = 0; i < len; i++) - { - label = XEXP (XVECEXP (pat, diff_vec_p, i), 0); - set_label_in_map (map, - CODE_LABEL_NUMBER (label), - label); - } - } - } - else if ((note = find_reg_note (insn, REG_LABEL, NULL_RTX))) - set_label_in_map (map, CODE_LABEL_NUMBER (XEXP (note, 0)), - XEXP (note, 0)); - } - - /* Allocate space for the insn map. */ - - map->insn_map = (rtx *) alloca (max_insnno * sizeof (rtx)); - - /* Set this to zero, to indicate that we are doing loop unrolling, - not function inlining. */ - map->inline_target = 0; - - /* The register and constant maps depend on the number of registers - present, so the final maps can't be created until after - find_splittable_regs is called. However, they are needed for - preconditioning, so we create temporary maps when preconditioning - is performed. */ - - /* The preconditioning code may allocate two new pseudo registers. */ - maxregnum = max_reg_num (); - - /* Allocate and zero out the splittable_regs and addr_combined_regs - arrays. These must be zeroed here because they will be used if - loop preconditioning is performed, and must be zero for that case. - - It is safe to do this here, since the extra registers created by the - preconditioning code and find_splittable_regs will never be used - to access the splittable_regs[] and addr_combined_regs[] arrays. */ - - splittable_regs = (rtx *) alloca (maxregnum * sizeof (rtx)); - zero_memory ((char *) splittable_regs, maxregnum * sizeof (rtx)); - derived_regs = alloca (maxregnum); - zero_memory (derived_regs, maxregnum); - splittable_regs_updates = (int *) alloca (maxregnum * sizeof (int)); - zero_memory ((char *) splittable_regs_updates, maxregnum * sizeof (int)); - addr_combined_regs - = (struct induction **) alloca (maxregnum * sizeof (struct induction *)); - zero_memory ((char *) addr_combined_regs, maxregnum * sizeof (struct induction *)); - local_regno = (char *) alloca (maxregnum); - zero_memory (local_regno, maxregnum); - - /* Mark all local registers, i.e. the ones which are referenced only - inside the loop. */ - if (INSN_UID (copy_end) < max_uid_for_loop) - { - int copy_start_luid = INSN_LUID (copy_start); - int copy_end_luid = INSN_LUID (copy_end); - - /* If a register is used in the jump insn, we must not duplicate it - since it will also be used outside the loop. */ - if (GET_CODE (copy_end) == JUMP_INSN) - copy_end_luid--; - /* If copy_start points to the NOTE that starts the loop, then we must - use the next luid, because invariant pseudo-regs moved out of the loop - have their lifetimes modified to start here, but they are not safe - to duplicate. */ - if (copy_start == loop_start) - copy_start_luid++; - - /* If a pseudo's lifetime is entirely contained within this loop, then we - can use a different pseudo in each unrolled copy of the loop. This - results in better code. */ - /* We must limit the generic test to max_reg_before_loop, because only - these pseudo registers have valid regno_first_uid info. */ - for (j = FIRST_PSEUDO_REGISTER; j < max_reg_before_loop; ++j) - if (REGNO_FIRST_UID (j) > 0 && REGNO_FIRST_UID (j) <= max_uid_for_loop - && uid_luid[REGNO_FIRST_UID (j)] >= copy_start_luid - && REGNO_LAST_UID (j) > 0 && REGNO_LAST_UID (j) <= max_uid_for_loop - && uid_luid[REGNO_LAST_UID (j)] <= copy_end_luid) - { - /* However, we must also check for loop-carried dependencies. - If the value the pseudo has at the end of iteration X is - used by iteration X+1, then we can not use a different pseudo - for each unrolled copy of the loop. */ - /* A pseudo is safe if regno_first_uid is a set, and this - set dominates all instructions from regno_first_uid to - regno_last_uid. */ - /* ??? This check is simplistic. We would get better code if - this check was more sophisticated. */ - if (set_dominates_use (j, REGNO_FIRST_UID (j), REGNO_LAST_UID (j), - copy_start, copy_end)) - local_regno[j] = 1; - - if (loop_dump_stream) - { - if (local_regno[j]) - fprintf (loop_dump_stream, "Marked reg %d as local\n", j); - else - fprintf (loop_dump_stream, "Did not mark reg %d as local\n", - j); - } - } - /* Givs that have been created from multiple biv increments always have - local registers. */ - for (j = first_increment_giv; j <= last_increment_giv; j++) - { - local_regno[j] = 1; - if (loop_dump_stream) - fprintf (loop_dump_stream, "Marked reg %d as local\n", j); - } - } - - /* If this loop requires exit tests when unrolled, check to see if we - can precondition the loop so as to make the exit tests unnecessary. - Just like variable splitting, this is not safe if the loop is entered - via a jump to the bottom. Also, can not do this if no strength - reduce info, because precondition_loop_p uses this info. */ - - /* Must copy the loop body for preconditioning before the following - find_splittable_regs call since that will emit insns which need to - be after the preconditioned loop copies, but immediately before the - unrolled loop copies. */ - - /* Also, it is not safe to split induction variables for the preconditioned - copies of the loop body. If we split induction variables, then the code - assumes that each induction variable can be represented as a function - of its initial value and the loop iteration number. This is not true - in this case, because the last preconditioned copy of the loop body - could be any iteration from the first up to the `unroll_number-1'th, - depending on the initial value of the iteration variable. Therefore - we can not split induction variables here, because we can not calculate - their value. Hence, this code must occur before find_splittable_regs - is called. */ - - if (unroll_type == UNROLL_NAIVE && ! splitting_not_safe && strength_reduce_p) - { - rtx initial_value, final_value, increment; - enum machine_mode mode; - - if (precondition_loop_p (loop_start, loop_info, - &initial_value, &final_value, &increment, - &mode)) - { - register rtx diff ; - rtx *labels; - int abs_inc, neg_inc; - - map->reg_map = (rtx *) alloca (maxregnum * sizeof (rtx)); - - map->const_equiv_map = (rtx *) alloca (maxregnum * sizeof (rtx)); - map->const_age_map = (unsigned *) alloca (maxregnum - * sizeof (unsigned)); - map->const_equiv_map_size = maxregnum; - global_const_equiv_map = map->const_equiv_map; - global_const_equiv_map_size = maxregnum; - - init_reg_map (map, maxregnum); - - /* Limit loop unrolling to 4, since this will make 7 copies of - the loop body. */ - if (unroll_number > 4) - unroll_number = 4; - - /* Save the absolute value of the increment, and also whether or - not it is negative. */ - neg_inc = 0; - abs_inc = INTVAL (increment); - if (abs_inc < 0) - { - abs_inc = - abs_inc; - neg_inc = 1; - } - - start_sequence (); - - /* Calculate the difference between the final and initial values. - Final value may be a (plus (reg x) (const_int 1)) rtx. - Let the following cse pass simplify this if initial value is - a constant. - - We must copy the final and initial values here to avoid - improperly shared rtl. */ - - diff = expand_binop (mode, sub_optab, copy_rtx (final_value), - copy_rtx (initial_value), NULL_RTX, 0, - OPTAB_LIB_WIDEN); - - /* Now calculate (diff % (unroll * abs (increment))) by using an - and instruction. */ - diff = expand_binop (GET_MODE (diff), and_optab, diff, - GEN_INT (unroll_number * abs_inc - 1), - NULL_RTX, 0, OPTAB_LIB_WIDEN); - - /* Now emit a sequence of branches to jump to the proper precond - loop entry point. */ - - labels = (rtx *) alloca (sizeof (rtx) * unroll_number); - for (i = 0; i < unroll_number; i++) - labels[i] = gen_label_rtx (); - - /* Check for the case where the initial value is greater than or - equal to the final value. In that case, we want to execute - exactly one loop iteration. The code below will fail for this - case. This check does not apply if the loop has a NE - comparison at the end. */ - - if (loop_info->comparison_code != NE) - { - emit_cmp_and_jump_insns (initial_value, final_value, - neg_inc ? LE : GE, - NULL_RTX, mode, 0, 0, labels[1]); - JUMP_LABEL (get_last_insn ()) = labels[1]; - LABEL_NUSES (labels[1])++; - } - - /* Assuming the unroll_number is 4, and the increment is 2, then - for a negative increment: for a positive increment: - diff = 0,1 precond 0 diff = 0,7 precond 0 - diff = 2,3 precond 3 diff = 1,2 precond 1 - diff = 4,5 precond 2 diff = 3,4 precond 2 - diff = 6,7 precond 1 diff = 5,6 precond 3 */ - - /* We only need to emit (unroll_number - 1) branches here, the - last case just falls through to the following code. */ - - /* ??? This would give better code if we emitted a tree of branches - instead of the current linear list of branches. */ - - for (i = 0; i < unroll_number - 1; i++) - { - int cmp_const; - enum rtx_code cmp_code; - - /* For negative increments, must invert the constant compared - against, except when comparing against zero. */ - if (i == 0) - { - cmp_const = 0; - cmp_code = EQ; - } - else if (neg_inc) - { - cmp_const = unroll_number - i; - cmp_code = GE; - } - else - { - cmp_const = i; - cmp_code = LE; - } - - emit_cmp_and_jump_insns (diff, GEN_INT (abs_inc * cmp_const), - cmp_code, NULL_RTX, mode, 0, 0, - labels[i]); - JUMP_LABEL (get_last_insn ()) = labels[i]; - LABEL_NUSES (labels[i])++; - } - - /* If the increment is greater than one, then we need another branch, - to handle other cases equivalent to 0. */ - - /* ??? This should be merged into the code above somehow to help - simplify the code here, and reduce the number of branches emitted. - For the negative increment case, the branch here could easily - be merged with the `0' case branch above. For the positive - increment case, it is not clear how this can be simplified. */ - - if (abs_inc != 1) - { - int cmp_const; - enum rtx_code cmp_code; - - if (neg_inc) - { - cmp_const = abs_inc - 1; - cmp_code = LE; - } - else - { - cmp_const = abs_inc * (unroll_number - 1) + 1; - cmp_code = GE; - } - - emit_cmp_and_jump_insns (diff, GEN_INT (cmp_const), cmp_code, - NULL_RTX, mode, 0, 0, labels[0]); - JUMP_LABEL (get_last_insn ()) = labels[0]; - LABEL_NUSES (labels[0])++; - } - - sequence = gen_sequence (); - end_sequence (); - emit_insn_before (sequence, loop_start); - - /* Only the last copy of the loop body here needs the exit - test, so set copy_end to exclude the compare/branch here, - and then reset it inside the loop when get to the last - copy. */ - - if (GET_CODE (last_loop_insn) == BARRIER) - copy_end = PREV_INSN (PREV_INSN (last_loop_insn)); - else if (GET_CODE (last_loop_insn) == JUMP_INSN) - { -#ifdef HAVE_cc0 - /* The immediately preceding insn is a compare which we do not - want to copy. */ - copy_end = PREV_INSN (PREV_INSN (last_loop_insn)); -#else - /* The immediately preceding insn may not be a compare, so we - must copy it. */ - copy_end = PREV_INSN (last_loop_insn); -#endif - } - else - abort (); - - for (i = 1; i < unroll_number; i++) - { - emit_label_after (labels[unroll_number - i], - PREV_INSN (loop_start)); - - zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx)); - zero_memory ((char *) map->const_equiv_map, maxregnum * sizeof (rtx)); - zero_memory ((char *) map->const_age_map, - maxregnum * sizeof (unsigned)); - map->const_age = 0; - - for (j = 0; j < max_labelno; j++) - if (local_label[j]) - set_label_in_map (map, j, gen_label_rtx ()); - - for (j = FIRST_PSEUDO_REGISTER; j < maxregnum; j++) - if (local_regno[j]) - { - map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j])); - record_base_value (REGNO (map->reg_map[j]), - regno_reg_rtx[j], 0); - } - /* The last copy needs the compare/branch insns at the end, - so reset copy_end here if the loop ends with a conditional - branch. */ - - if (i == unroll_number - 1) - { - if (GET_CODE (last_loop_insn) == BARRIER) - copy_end = PREV_INSN (PREV_INSN (last_loop_insn)); - else - copy_end = last_loop_insn; - } - - /* None of the copies are the `last_iteration', so just - pass zero for that parameter. */ - copy_loop_body (copy_start, copy_end, map, exit_label, 0, - unroll_type, start_label, loop_end, - loop_start, copy_end); - } - emit_label_after (labels[0], PREV_INSN (loop_start)); - - if (GET_CODE (last_loop_insn) == BARRIER) - { - insert_before = PREV_INSN (last_loop_insn); - copy_end = PREV_INSN (insert_before); - } - else - { -#ifdef HAVE_cc0 - /* The immediately preceding insn is a compare which we do not - want to copy. */ - insert_before = PREV_INSN (last_loop_insn); - copy_end = PREV_INSN (insert_before); -#else - /* The immediately preceding insn may not be a compare, so we - must copy it. */ - insert_before = last_loop_insn; - copy_end = PREV_INSN (last_loop_insn); -#endif - } - - /* Set unroll type to MODULO now. */ - unroll_type = UNROLL_MODULO; - loop_preconditioned = 1; - } - } - - /* If reach here, and the loop type is UNROLL_NAIVE, then don't unroll - the loop unless all loops are being unrolled. */ - if (unroll_type == UNROLL_NAIVE && ! flag_unroll_all_loops) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, "Unrolling failure: Naive unrolling not being done.\n"); - return; - } - - /* At this point, we are guaranteed to unroll the loop. */ - - /* Keep track of the unroll factor for the loop. */ - if (unroll_type == UNROLL_COMPLETELY) - loop_info->unroll_number = -1; - else - loop_info->unroll_number = unroll_number; - - - /* For each biv and giv, determine whether it can be safely split into - a different variable for each unrolled copy of the loop body. - We precalculate and save this info here, since computing it is - expensive. - - Do this before deleting any instructions from the loop, so that - back_branch_in_range_p will work correctly. */ - - if (splitting_not_safe) - temp = 0; - else - temp = find_splittable_regs (unroll_type, loop_start, loop_end, - end_insert_before, unroll_number, - loop_info->n_iterations); - - /* find_splittable_regs may have created some new registers, so must - reallocate the reg_map with the new larger size, and must realloc - the constant maps also. */ - - maxregnum = max_reg_num (); - map->reg_map = (rtx *) alloca (maxregnum * sizeof (rtx)); - - init_reg_map (map, maxregnum); - - /* Space is needed in some of the map for new registers, so new_maxregnum - is an (over)estimate of how many registers will exist at the end. */ - new_maxregnum = maxregnum + (temp * unroll_number * 2); - - /* Must realloc space for the constant maps, because the number of registers - may have changed. */ - - map->const_equiv_map = (rtx *) alloca (new_maxregnum * sizeof (rtx)); - map->const_age_map = (unsigned *) alloca (new_maxregnum * sizeof (unsigned)); - - map->const_equiv_map_size = new_maxregnum; - global_const_equiv_map = map->const_equiv_map; - global_const_equiv_map_size = new_maxregnum; - - /* Search the list of bivs and givs to find ones which need to be remapped - when split, and set their reg_map entry appropriately. */ - - for (bl = loop_iv_list; bl; bl = bl->next) - { - if (REGNO (bl->biv->src_reg) != bl->regno) - map->reg_map[bl->regno] = bl->biv->src_reg; -#if 0 - /* Currently, non-reduced/final-value givs are never split. */ - for (v = bl->giv; v; v = v->next_iv) - if (REGNO (v->src_reg) != bl->regno) - map->reg_map[REGNO (v->dest_reg)] = v->src_reg; -#endif - } - - /* Use our current register alignment and pointer flags. */ - map->regno_pointer_flag = regno_pointer_flag; - map->regno_pointer_align = regno_pointer_align; - - /* If the loop is being partially unrolled, and the iteration variables - are being split, and are being renamed for the split, then must fix up - the compare/jump instruction at the end of the loop to refer to the new - registers. This compare isn't copied, so the registers used in it - will never be replaced if it isn't done here. */ - - if (unroll_type == UNROLL_MODULO) - { - insn = NEXT_INSN (copy_end); - if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN) - PATTERN (insn) = remap_split_bivs (PATTERN (insn)); - } - - /* For unroll_number times, make a copy of each instruction - between copy_start and copy_end, and insert these new instructions - before the end of the loop. */ - - for (i = 0; i < unroll_number; i++) - { - zero_memory ((char *) map->insn_map, max_insnno * sizeof (rtx)); - zero_memory ((char *) map->const_equiv_map, new_maxregnum * sizeof (rtx)); - zero_memory ((char *) map->const_age_map, new_maxregnum * sizeof (unsigned)); - map->const_age = 0; - - for (j = 0; j < max_labelno; j++) - if (local_label[j]) - set_label_in_map (map, j, gen_label_rtx ()); - - for (j = FIRST_PSEUDO_REGISTER; j < maxregnum; j++) - if (local_regno[j]) - { - map->reg_map[j] = gen_reg_rtx (GET_MODE (regno_reg_rtx[j])); - record_base_value (REGNO (map->reg_map[j]), - regno_reg_rtx[j], 0); - } - - /* If loop starts with a branch to the test, then fix it so that - it points to the test of the first unrolled copy of the loop. */ - if (i == 0 && loop_start != copy_start) - { - insn = PREV_INSN (copy_start); - pattern = PATTERN (insn); - - tem = get_label_from_map (map, - CODE_LABEL_NUMBER - (XEXP (SET_SRC (pattern), 0))); - SET_SRC (pattern) = gen_rtx_LABEL_REF (VOIDmode, tem); - - /* Set the jump label so that it can be used by later loop unrolling - passes. */ - JUMP_LABEL (insn) = tem; - LABEL_NUSES (tem)++; - } - - copy_loop_body (copy_start, copy_end, map, exit_label, - i == unroll_number - 1, unroll_type, start_label, - loop_end, insert_before, insert_before); - } - - /* Before deleting any insns, emit a CODE_LABEL immediately after the last - insn to be deleted. This prevents any runaway delete_insn call from - more insns that it should, as it always stops at a CODE_LABEL. */ - - /* Delete the compare and branch at the end of the loop if completely - unrolling the loop. Deleting the backward branch at the end also - deletes the code label at the start of the loop. This is done at - the very end to avoid problems with back_branch_in_range_p. */ - - if (unroll_type == UNROLL_COMPLETELY) - safety_label = emit_label_after (gen_label_rtx (), last_loop_insn); - else - safety_label = emit_label_after (gen_label_rtx (), copy_end); - - /* Delete all of the original loop instructions. Don't delete the - LOOP_BEG note, or the first code label in the loop. */ - - insn = NEXT_INSN (copy_start); - while (insn != safety_label) - { - if (insn != start_label) - insn = delete_insn (insn); - else - insn = NEXT_INSN (insn); - } - - /* Can now delete the 'safety' label emitted to protect us from runaway - delete_insn calls. */ - if (INSN_DELETED_P (safety_label)) - abort (); - delete_insn (safety_label); - - /* If exit_label exists, emit it after the loop. Doing the emit here - forces it to have a higher INSN_UID than any insn in the unrolled loop. - This is needed so that mostly_true_jump in reorg.c will treat jumps - to this loop end label correctly, i.e. predict that they are usually - not taken. */ - if (exit_label) - emit_label_after (exit_label, loop_end); -} - -/* Return true if the loop can be safely, and profitably, preconditioned - so that the unrolled copies of the loop body don't need exit tests. - - This only works if final_value, initial_value and increment can be - determined, and if increment is a constant power of 2. - If increment is not a power of 2, then the preconditioning modulo - operation would require a real modulo instead of a boolean AND, and this - is not considered `profitable'. */ - -/* ??? If the loop is known to be executed very many times, or the machine - has a very cheap divide instruction, then preconditioning is a win even - when the increment is not a power of 2. Use RTX_COST to compute - whether divide is cheap. - ??? A divide by constant doesn't actually need a divide, look at - expand_divmod. The reduced cost of this optimized modulo is not - reflected in RTX_COST. */ - -int -precondition_loop_p (loop_start, loop_info, - initial_value, final_value, increment, mode) - rtx loop_start; - struct loop_info *loop_info; - rtx *initial_value, *final_value, *increment; - enum machine_mode *mode; -{ - - if (loop_info->n_iterations > 0) - { - *initial_value = const0_rtx; - *increment = const1_rtx; - *final_value = GEN_INT (loop_info->n_iterations); - *mode = word_mode; - - if (loop_dump_stream) - { - fputs ("Preconditioning: Success, number of iterations known, ", - loop_dump_stream); - fprintf (loop_dump_stream, HOST_WIDE_INT_PRINT_DEC, - loop_info->n_iterations); - fputs (".\n", loop_dump_stream); - } - return 1; - } - - if (loop_info->initial_value == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Could not find initial value.\n"); - return 0; - } - else if (loop_info->increment == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Could not find increment value.\n"); - return 0; - } - else if (GET_CODE (loop_info->increment) != CONST_INT) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Increment not a constant.\n"); - return 0; - } - else if ((exact_log2 (INTVAL (loop_info->increment)) < 0) - && (exact_log2 (- INTVAL (loop_info->increment)) < 0)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Increment not a constant power of 2.\n"); - return 0; - } - - /* Unsigned_compare and compare_dir can be ignored here, since they do - not matter for preconditioning. */ - - if (loop_info->final_value == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: EQ comparison loop.\n"); - return 0; - } - - /* Must ensure that final_value is invariant, so call invariant_p to - check. Before doing so, must check regno against max_reg_before_loop - to make sure that the register is in the range covered by invariant_p. - If it isn't, then it is most likely a biv/giv which by definition are - not invariant. */ - if ((GET_CODE (loop_info->final_value) == REG - && REGNO (loop_info->final_value) >= max_reg_before_loop) - || (GET_CODE (loop_info->final_value) == PLUS - && REGNO (XEXP (loop_info->final_value, 0)) >= max_reg_before_loop) - || ! invariant_p (loop_info->final_value)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Final value not invariant.\n"); - return 0; - } - - /* Fail for floating point values, since the caller of this function - does not have code to deal with them. */ - if (GET_MODE_CLASS (GET_MODE (loop_info->final_value)) == MODE_FLOAT - || GET_MODE_CLASS (GET_MODE (loop_info->initial_value)) == MODE_FLOAT) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Floating point final or initial value.\n"); - return 0; - } - - /* Fail if loop_info->iteration_var is not live before loop_start, - since we need to test its value in the preconditioning code. */ - - if (uid_luid[REGNO_FIRST_UID (REGNO (loop_info->iteration_var))] - > INSN_LUID (loop_start)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Preconditioning: Iteration var not live before loop start.\n"); - return 0; - } - - /* ??? Note that if iteration_info is modifed to allow GIV iterators - such as "while (i-- > 0)", the initial value will be one too small. - In this case, loop_iteration_var could be used to determine - the correct initial value, provided the loop has not been reversed. - - Also note that the absolute values of initial_value and - final_value are unimportant as only their difference is used for - calculating the number of loop iterations. */ - *initial_value = loop_info->initial_value; - *increment = loop_info->increment; - *final_value = loop_info->final_value; - - /* Decide what mode to do these calculations in. Choose the larger - of final_value's mode and initial_value's mode, or a full-word if - both are constants. */ - *mode = GET_MODE (*final_value); - if (*mode == VOIDmode) - { - *mode = GET_MODE (*initial_value); - if (*mode == VOIDmode) - *mode = word_mode; - } - else if (*mode != GET_MODE (*initial_value) - && (GET_MODE_SIZE (*mode) - < GET_MODE_SIZE (GET_MODE (*initial_value)))) - *mode = GET_MODE (*initial_value); - - /* Success! */ - if (loop_dump_stream) - fprintf (loop_dump_stream, "Preconditioning: Successful.\n"); - return 1; -} - - -/* All pseudo-registers must be mapped to themselves. Two hard registers - must be mapped, VIRTUAL_STACK_VARS_REGNUM and VIRTUAL_INCOMING_ARGS_ - REGNUM, to avoid function-inlining specific conversions of these - registers. All other hard regs can not be mapped because they may be - used with different - modes. */ - -static void -init_reg_map (map, maxregnum) - struct inline_remap *map; - int maxregnum; -{ - int i; - - for (i = maxregnum - 1; i > LAST_VIRTUAL_REGISTER; i--) - map->reg_map[i] = regno_reg_rtx[i]; - /* Just clear the rest of the entries. */ - for (i = LAST_VIRTUAL_REGISTER; i >= 0; i--) - map->reg_map[i] = 0; - - map->reg_map[VIRTUAL_STACK_VARS_REGNUM] - = regno_reg_rtx[VIRTUAL_STACK_VARS_REGNUM]; - map->reg_map[VIRTUAL_INCOMING_ARGS_REGNUM] - = regno_reg_rtx[VIRTUAL_INCOMING_ARGS_REGNUM]; -} - -/* Strength-reduction will often emit code for optimized biv/givs which - calculates their value in a temporary register, and then copies the result - to the iv. This procedure reconstructs the pattern computing the iv; - verifying that all operands are of the proper form. - - PATTERN must be the result of single_set. - The return value is the amount that the giv is incremented by. */ - -static rtx -calculate_giv_inc (pattern, src_insn, regno) - rtx pattern, src_insn; - int regno; -{ - rtx increment; - rtx increment_total = 0; - int tries = 0; - - retry: - /* Verify that we have an increment insn here. First check for a plus - as the set source. */ - if (GET_CODE (SET_SRC (pattern)) != PLUS) - { - /* SR sometimes computes the new giv value in a temp, then copies it - to the new_reg. */ - src_insn = PREV_INSN (src_insn); - pattern = PATTERN (src_insn); - if (GET_CODE (SET_SRC (pattern)) != PLUS) - abort (); - - /* The last insn emitted is not needed, so delete it to avoid confusing - the second cse pass. This insn sets the giv unnecessarily. */ - delete_insn (get_last_insn ()); - } - - /* Verify that we have a constant as the second operand of the plus. */ - increment = XEXP (SET_SRC (pattern), 1); - if (GET_CODE (increment) != CONST_INT) - { - /* SR sometimes puts the constant in a register, especially if it is - too big to be an add immed operand. */ - src_insn = PREV_INSN (src_insn); - increment = SET_SRC (PATTERN (src_insn)); - - /* SR may have used LO_SUM to compute the constant if it is too large - for a load immed operand. In this case, the constant is in operand - one of the LO_SUM rtx. */ - if (GET_CODE (increment) == LO_SUM) - increment = XEXP (increment, 1); - - /* Some ports store large constants in memory and add a REG_EQUAL - note to the store insn. */ - else if (GET_CODE (increment) == MEM) - { - rtx note = find_reg_note (src_insn, REG_EQUAL, 0); - if (note) - increment = XEXP (note, 0); - } - - else if (GET_CODE (increment) == IOR - || GET_CODE (increment) == ASHIFT - || GET_CODE (increment) == PLUS) - { - /* The rs6000 port loads some constants with IOR. - The alpha port loads some constants with ASHIFT and PLUS. */ - rtx second_part = XEXP (increment, 1); - enum rtx_code code = GET_CODE (increment); - - src_insn = PREV_INSN (src_insn); - increment = SET_SRC (PATTERN (src_insn)); - /* Don't need the last insn anymore. */ - delete_insn (get_last_insn ()); - - if (GET_CODE (second_part) != CONST_INT - || GET_CODE (increment) != CONST_INT) - abort (); - - if (code == IOR) - increment = GEN_INT (INTVAL (increment) | INTVAL (second_part)); - else if (code == PLUS) - increment = GEN_INT (INTVAL (increment) + INTVAL (second_part)); - else - increment = GEN_INT (INTVAL (increment) << INTVAL (second_part)); - } - - if (GET_CODE (increment) != CONST_INT) - abort (); - - /* The insn loading the constant into a register is no longer needed, - so delete it. */ - delete_insn (get_last_insn ()); - } - - if (increment_total) - increment_total = GEN_INT (INTVAL (increment_total) + INTVAL (increment)); - else - increment_total = increment; - - /* Check that the source register is the same as the register we expected - to see as the source. If not, something is seriously wrong. */ - if (GET_CODE (XEXP (SET_SRC (pattern), 0)) != REG - || REGNO (XEXP (SET_SRC (pattern), 0)) != regno) - { - /* Some machines (e.g. the romp), may emit two add instructions for - certain constants, so lets try looking for another add immediately - before this one if we have only seen one add insn so far. */ - - if (tries == 0) - { - tries++; - - src_insn = PREV_INSN (src_insn); - pattern = PATTERN (src_insn); - - delete_insn (get_last_insn ()); - - goto retry; - } - - abort (); - } - - return increment_total; -} - -/* Copy REG_NOTES, except for insn references, because not all insn_map - entries are valid yet. We do need to copy registers now though, because - the reg_map entries can change during copying. */ - -static rtx -initial_reg_note_copy (notes, map) - rtx notes; - struct inline_remap *map; -{ - rtx copy; - - if (notes == 0) - return 0; - - copy = rtx_alloc (GET_CODE (notes)); - PUT_MODE (copy, GET_MODE (notes)); - - if (GET_CODE (notes) == EXPR_LIST) - XEXP (copy, 0) = copy_rtx_and_substitute (XEXP (notes, 0), map); - else if (GET_CODE (notes) == INSN_LIST) - /* Don't substitute for these yet. */ - XEXP (copy, 0) = XEXP (notes, 0); - else - abort (); - - XEXP (copy, 1) = initial_reg_note_copy (XEXP (notes, 1), map); - - return copy; -} - -/* Fixup insn references in copied REG_NOTES. */ - -static void -final_reg_note_copy (notes, map) - rtx notes; - struct inline_remap *map; -{ - rtx note; - - for (note = notes; note; note = XEXP (note, 1)) - if (GET_CODE (note) == INSN_LIST) - XEXP (note, 0) = map->insn_map[INSN_UID (XEXP (note, 0))]; -} - -/* Copy each instruction in the loop, substituting from map as appropriate. - This is very similar to a loop in expand_inline_function. */ - -static void -copy_loop_body (copy_start, copy_end, map, exit_label, last_iteration, - unroll_type, start_label, loop_end, insert_before, - copy_notes_from) - rtx copy_start, copy_end; - struct inline_remap *map; - rtx exit_label; - int last_iteration; - enum unroll_types unroll_type; - rtx start_label, loop_end, insert_before, copy_notes_from; -{ - rtx insn, pattern; - rtx set, tem, copy; - int dest_reg_was_split, i; -#ifdef HAVE_cc0 - rtx cc0_insn = 0; -#endif - rtx final_label = 0; - rtx giv_inc, giv_dest_reg, giv_src_reg; - - /* If this isn't the last iteration, then map any references to the - start_label to final_label. Final label will then be emitted immediately - after the end of this loop body if it was ever used. - - If this is the last iteration, then map references to the start_label - to itself. */ - if (! last_iteration) - { - final_label = gen_label_rtx (); - set_label_in_map (map, CODE_LABEL_NUMBER (start_label), - final_label); - } - else - set_label_in_map (map, CODE_LABEL_NUMBER (start_label), start_label); - - start_sequence (); - - /* Emit a NOTE_INSN_DELETED to force at least two insns onto the sequence. - Else gen_sequence could return a raw pattern for a jump which we pass - off to emit_insn_before (instead of emit_jump_insn_before) which causes - a variety of losing behaviors later. */ - emit_note (0, NOTE_INSN_DELETED); - - insn = copy_start; - do - { - insn = NEXT_INSN (insn); - - map->orig_asm_operands_vector = 0; - - switch (GET_CODE (insn)) - { - case INSN: - pattern = PATTERN (insn); - copy = 0; - giv_inc = 0; - - /* Check to see if this is a giv that has been combined with - some split address givs. (Combined in the sense that - `combine_givs' in loop.c has put two givs in the same register.) - In this case, we must search all givs based on the same biv to - find the address givs. Then split the address givs. - Do this before splitting the giv, since that may map the - SET_DEST to a new register. */ - - if ((set = single_set (insn)) - && GET_CODE (SET_DEST (set)) == REG - && addr_combined_regs[REGNO (SET_DEST (set))]) - { - struct iv_class *bl; - struct induction *v, *tv; - int regno = REGNO (SET_DEST (set)); - - v = addr_combined_regs[REGNO (SET_DEST (set))]; - bl = reg_biv_class[REGNO (v->src_reg)]; - - /* Although the giv_inc amount is not needed here, we must call - calculate_giv_inc here since it might try to delete the - last insn emitted. If we wait until later to call it, - we might accidentally delete insns generated immediately - below by emit_unrolled_add. */ - - if (! derived_regs[regno]) - giv_inc = calculate_giv_inc (set, insn, regno); - - /* Now find all address giv's that were combined with this - giv 'v'. */ - for (tv = bl->giv; tv; tv = tv->next_iv) - if (tv->giv_type == DEST_ADDR && tv->same == v) - { - int this_giv_inc; - - /* If this DEST_ADDR giv was not split, then ignore it. */ - if (*tv->location != tv->dest_reg) - continue; - - /* Scale this_giv_inc if the multiplicative factors of - the two givs are different. */ - this_giv_inc = INTVAL (giv_inc); - if (tv->mult_val != v->mult_val) - this_giv_inc = (this_giv_inc / INTVAL (v->mult_val) - * INTVAL (tv->mult_val)); - - tv->dest_reg = plus_constant (tv->dest_reg, this_giv_inc); - *tv->location = tv->dest_reg; - - if (last_iteration && unroll_type != UNROLL_COMPLETELY) - { - /* Must emit an insn to increment the split address - giv. Add in the const_adjust field in case there - was a constant eliminated from the address. */ - rtx value, dest_reg; - - /* tv->dest_reg will be either a bare register, - or else a register plus a constant. */ - if (GET_CODE (tv->dest_reg) == REG) - dest_reg = tv->dest_reg; - else - dest_reg = XEXP (tv->dest_reg, 0); - - /* Check for shared address givs, and avoid - incrementing the shared pseudo reg more than - once. */ - if (! tv->same_insn && ! tv->shared) - { - /* tv->dest_reg may actually be a (PLUS (REG) - (CONST)) here, so we must call plus_constant - to add the const_adjust amount before calling - emit_unrolled_add below. */ - value = plus_constant (tv->dest_reg, - tv->const_adjust); - - /* The constant could be too large for an add - immediate, so can't directly emit an insn - here. */ - emit_unrolled_add (dest_reg, XEXP (value, 0), - XEXP (value, 1)); - } - - /* Reset the giv to be just the register again, in case - it is used after the set we have just emitted. - We must subtract the const_adjust factor added in - above. */ - tv->dest_reg = plus_constant (dest_reg, - - tv->const_adjust); - *tv->location = tv->dest_reg; - } - } - } - - /* If this is a setting of a splittable variable, then determine - how to split the variable, create a new set based on this split, - and set up the reg_map so that later uses of the variable will - use the new split variable. */ - - dest_reg_was_split = 0; - - if ((set = single_set (insn)) - && GET_CODE (SET_DEST (set)) == REG - && splittable_regs[REGNO (SET_DEST (set))]) - { - int regno = REGNO (SET_DEST (set)); - int src_regno; - - dest_reg_was_split = 1; - - giv_dest_reg = SET_DEST (set); - if (derived_regs[regno]) - { - /* ??? This relies on SET_SRC (SET) to be of - the form (plus (reg) (const_int)), and thus - forces recombine_givs to restrict the kind - of giv derivations it does before unrolling. */ - giv_src_reg = XEXP (SET_SRC (set), 0); - giv_inc = XEXP (SET_SRC (set), 1); - } - else - { - giv_src_reg = giv_dest_reg; - /* Compute the increment value for the giv, if it wasn't - already computed above. */ - if (giv_inc == 0) - giv_inc = calculate_giv_inc (set, insn, regno); - } - src_regno = REGNO (giv_src_reg); - - if (unroll_type == UNROLL_COMPLETELY) - { - /* Completely unrolling the loop. Set the induction - variable to a known constant value. */ - - /* The value in splittable_regs may be an invariant - value, so we must use plus_constant here. */ - splittable_regs[regno] - = plus_constant (splittable_regs[src_regno], - INTVAL (giv_inc)); - - if (GET_CODE (splittable_regs[regno]) == PLUS) - { - giv_src_reg = XEXP (splittable_regs[regno], 0); - giv_inc = XEXP (splittable_regs[regno], 1); - } - else - { - /* The splittable_regs value must be a REG or a - CONST_INT, so put the entire value in the giv_src_reg - variable. */ - giv_src_reg = splittable_regs[regno]; - giv_inc = const0_rtx; - } - } - else - { - /* Partially unrolling loop. Create a new pseudo - register for the iteration variable, and set it to - be a constant plus the original register. Except - on the last iteration, when the result has to - go back into the original iteration var register. */ - - /* Handle bivs which must be mapped to a new register - when split. This happens for bivs which need their - final value set before loop entry. The new register - for the biv was stored in the biv's first struct - induction entry by find_splittable_regs. */ - - if (regno < max_reg_before_loop - && REG_IV_TYPE (regno) == BASIC_INDUCT) - { - giv_src_reg = reg_biv_class[regno]->biv->src_reg; - giv_dest_reg = giv_src_reg; - } - -#if 0 - /* If non-reduced/final-value givs were split, then - this would have to remap those givs also. See - find_splittable_regs. */ -#endif - - splittable_regs[regno] - = GEN_INT (INTVAL (giv_inc) - + INTVAL (splittable_regs[src_regno])); - giv_inc = splittable_regs[regno]; - - /* Now split the induction variable by changing the dest - of this insn to a new register, and setting its - reg_map entry to point to this new register. - - If this is the last iteration, and this is the last insn - that will update the iv, then reuse the original dest, - to ensure that the iv will have the proper value when - the loop exits or repeats. - - Using splittable_regs_updates here like this is safe, - because it can only be greater than one if all - instructions modifying the iv are always executed in - order. */ - - if (! last_iteration - || (splittable_regs_updates[regno]-- != 1)) - { - tem = gen_reg_rtx (GET_MODE (giv_src_reg)); - giv_dest_reg = tem; - map->reg_map[regno] = tem; - record_base_value (REGNO (tem), - giv_inc == const0_rtx - ? giv_src_reg - : gen_rtx_PLUS (GET_MODE (giv_src_reg), - giv_src_reg, giv_inc), - 1); - } - else - map->reg_map[regno] = giv_src_reg; - } - - /* The constant being added could be too large for an add - immediate, so can't directly emit an insn here. */ - emit_unrolled_add (giv_dest_reg, giv_src_reg, giv_inc); - copy = get_last_insn (); - pattern = PATTERN (copy); - } - else - { - pattern = copy_rtx_and_substitute (pattern, map); - copy = emit_insn (pattern); - } - REG_NOTES (copy) = initial_reg_note_copy (REG_NOTES (insn), map); - -#ifdef HAVE_cc0 - /* If this insn is setting CC0, it may need to look at - the insn that uses CC0 to see what type of insn it is. - In that case, the call to recog via validate_change will - fail. So don't substitute constants here. Instead, - do it when we emit the following insn. - - For example, see the pyr.md file. That machine has signed and - unsigned compares. The compare patterns must check the - following branch insn to see which what kind of compare to - emit. - - If the previous insn set CC0, substitute constants on it as - well. */ - if (sets_cc0_p (PATTERN (copy)) != 0) - cc0_insn = copy; - else - { - if (cc0_insn) - try_constants (cc0_insn, map); - cc0_insn = 0; - try_constants (copy, map); - } -#else - try_constants (copy, map); -#endif - - /* Make split induction variable constants `permanent' since we - know there are no backward branches across iteration variable - settings which would invalidate this. */ - if (dest_reg_was_split) - { - int regno = REGNO (SET_DEST (pattern)); - - if (regno < map->const_equiv_map_size - && map->const_age_map[regno] == map->const_age) - map->const_age_map[regno] = -1; - } - break; - - case JUMP_INSN: - pattern = copy_rtx_and_substitute (PATTERN (insn), map); - copy = emit_jump_insn (pattern); - REG_NOTES (copy) = initial_reg_note_copy (REG_NOTES (insn), map); - - if (JUMP_LABEL (insn) == start_label && insn == copy_end - && ! last_iteration) - { - /* This is a branch to the beginning of the loop; this is the - last insn being copied; and this is not the last iteration. - In this case, we want to change the original fall through - case to be a branch past the end of the loop, and the - original jump label case to fall_through. */ - - if (invert_exp (pattern, copy)) - { - if (! redirect_exp (&pattern, - get_label_from_map (map, - CODE_LABEL_NUMBER - (JUMP_LABEL (insn))), - exit_label, copy)) - abort (); - } - else - { - rtx jmp; - rtx lab = gen_label_rtx (); - /* Can't do it by reversing the jump (probably because we - couldn't reverse the conditions), so emit a new - jump_insn after COPY, and redirect the jump around - that. */ - jmp = emit_jump_insn_after (gen_jump (exit_label), copy); - jmp = emit_barrier_after (jmp); - emit_label_after (lab, jmp); - LABEL_NUSES (lab) = 0; - if (! redirect_exp (&pattern, - get_label_from_map (map, - CODE_LABEL_NUMBER - (JUMP_LABEL (insn))), - lab, copy)) - abort (); - } - } - -#ifdef HAVE_cc0 - if (cc0_insn) - try_constants (cc0_insn, map); - cc0_insn = 0; -#endif - try_constants (copy, map); - - /* Set the jump label of COPY correctly to avoid problems with - later passes of unroll_loop, if INSN had jump label set. */ - if (JUMP_LABEL (insn)) - { - rtx label = 0; - - /* Can't use the label_map for every insn, since this may be - the backward branch, and hence the label was not mapped. */ - if ((set = single_set (copy))) - { - tem = SET_SRC (set); - if (GET_CODE (tem) == LABEL_REF) - label = XEXP (tem, 0); - else if (GET_CODE (tem) == IF_THEN_ELSE) - { - if (XEXP (tem, 1) != pc_rtx) - label = XEXP (XEXP (tem, 1), 0); - else - label = XEXP (XEXP (tem, 2), 0); - } - } - - if (label && GET_CODE (label) == CODE_LABEL) - JUMP_LABEL (copy) = label; - else - { - /* An unrecognizable jump insn, probably the entry jump - for a switch statement. This label must have been mapped, - so just use the label_map to get the new jump label. */ - JUMP_LABEL (copy) - = get_label_from_map (map, - CODE_LABEL_NUMBER (JUMP_LABEL (insn))); - } - - /* If this is a non-local jump, then must increase the label - use count so that the label will not be deleted when the - original jump is deleted. */ - LABEL_NUSES (JUMP_LABEL (copy))++; - } - else if (GET_CODE (PATTERN (copy)) == ADDR_VEC - || GET_CODE (PATTERN (copy)) == ADDR_DIFF_VEC) - { - rtx pat = PATTERN (copy); - int diff_vec_p = GET_CODE (pat) == ADDR_DIFF_VEC; - int len = XVECLEN (pat, diff_vec_p); - int i; - - for (i = 0; i < len; i++) - LABEL_NUSES (XEXP (XVECEXP (pat, diff_vec_p, i), 0))++; - } - - /* If this used to be a conditional jump insn but whose branch - direction is now known, we must do something special. */ - if (condjump_p (insn) && !simplejump_p (insn) && map->last_pc_value) - { -#ifdef HAVE_cc0 - /* The previous insn set cc0 for us. So delete it. */ - delete_insn (PREV_INSN (copy)); -#endif - - /* If this is now a no-op, delete it. */ - if (map->last_pc_value == pc_rtx) - { - /* Don't let delete_insn delete the label referenced here, - because we might possibly need it later for some other - instruction in the loop. */ - if (JUMP_LABEL (copy)) - LABEL_NUSES (JUMP_LABEL (copy))++; - delete_insn (copy); - if (JUMP_LABEL (copy)) - LABEL_NUSES (JUMP_LABEL (copy))--; - copy = 0; - } - else - /* Otherwise, this is unconditional jump so we must put a - BARRIER after it. We could do some dead code elimination - here, but jump.c will do it just as well. */ - emit_barrier (); - } - break; - - case CALL_INSN: - pattern = copy_rtx_and_substitute (PATTERN (insn), map); - copy = emit_call_insn (pattern); - REG_NOTES (copy) = initial_reg_note_copy (REG_NOTES (insn), map); - - /* Because the USAGE information potentially contains objects other - than hard registers, we need to copy it. */ - CALL_INSN_FUNCTION_USAGE (copy) - = copy_rtx_and_substitute (CALL_INSN_FUNCTION_USAGE (insn), map); - -#ifdef HAVE_cc0 - if (cc0_insn) - try_constants (cc0_insn, map); - cc0_insn = 0; -#endif - try_constants (copy, map); - - /* Be lazy and assume CALL_INSNs clobber all hard registers. */ - for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - map->const_equiv_map[i] = 0; - break; - - case CODE_LABEL: - /* If this is the loop start label, then we don't need to emit a - copy of this label since no one will use it. */ - - if (insn != start_label) - { - copy = emit_label (get_label_from_map (map, - CODE_LABEL_NUMBER (insn))); - map->const_age++; - } - break; - - case BARRIER: - copy = emit_barrier (); - break; - - case NOTE: - /* VTOP and CONT notes are valid only before the loop exit test. - If placed anywhere else, loop may generate bad code. */ - - if (NOTE_LINE_NUMBER (insn) != NOTE_INSN_DELETED - && ((NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_VTOP - && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_CONT) - || (last_iteration && unroll_type != UNROLL_COMPLETELY))) - copy = emit_note (NOTE_SOURCE_FILE (insn), - NOTE_LINE_NUMBER (insn)); - else - copy = 0; - break; - - default: - abort (); - break; - } - - map->insn_map[INSN_UID (insn)] = copy; - } - while (insn != copy_end); - - /* Now finish coping the REG_NOTES. */ - insn = copy_start; - do - { - insn = NEXT_INSN (insn); - if ((GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN - || GET_CODE (insn) == CALL_INSN) - && map->insn_map[INSN_UID (insn)]) - final_reg_note_copy (REG_NOTES (map->insn_map[INSN_UID (insn)]), map); - } - while (insn != copy_end); - - /* There may be notes between copy_notes_from and loop_end. Emit a copy of - each of these notes here, since there may be some important ones, such as - NOTE_INSN_BLOCK_END notes, in this group. We don't do this on the last - iteration, because the original notes won't be deleted. - - We can't use insert_before here, because when from preconditioning, - insert_before points before the loop. We can't use copy_end, because - there may be insns already inserted after it (which we don't want to - copy) when not from preconditioning code. */ - - if (! last_iteration) - { - for (insn = copy_notes_from; insn != loop_end; insn = NEXT_INSN (insn)) - { - if (GET_CODE (insn) == NOTE - && NOTE_LINE_NUMBER (insn) != NOTE_INSN_DELETED) - emit_note (NOTE_SOURCE_FILE (insn), NOTE_LINE_NUMBER (insn)); - } - } - - if (final_label && LABEL_NUSES (final_label) > 0) - emit_label (final_label); - - tem = gen_sequence (); - end_sequence (); - emit_insn_before (tem, insert_before); -} - -/* Emit an insn, using the expand_binop to ensure that a valid insn is - emitted. This will correctly handle the case where the increment value - won't fit in the immediate field of a PLUS insns. */ - -void -emit_unrolled_add (dest_reg, src_reg, increment) - rtx dest_reg, src_reg, increment; -{ - rtx result; - - result = expand_binop (GET_MODE (dest_reg), add_optab, src_reg, increment, - dest_reg, 0, OPTAB_LIB_WIDEN); - - if (dest_reg != result) - emit_move_insn (dest_reg, result); -} - -/* Searches the insns between INSN and LOOP_END. Returns 1 if there - is a backward branch in that range that branches to somewhere between - LOOP_START and INSN. Returns 0 otherwise. */ - -/* ??? This is quadratic algorithm. Could be rewritten to be linear. - In practice, this is not a problem, because this function is seldom called, - and uses a negligible amount of CPU time on average. */ - -int -back_branch_in_range_p (insn, loop_start, loop_end) - rtx insn; - rtx loop_start, loop_end; -{ - rtx p, q, target_insn; - rtx orig_loop_end = loop_end; - - /* Stop before we get to the backward branch at the end of the loop. */ - loop_end = prev_nonnote_insn (loop_end); - if (GET_CODE (loop_end) == BARRIER) - loop_end = PREV_INSN (loop_end); - - /* Check in case insn has been deleted, search forward for first non - deleted insn following it. */ - while (INSN_DELETED_P (insn)) - insn = NEXT_INSN (insn); - - /* Check for the case where insn is the last insn in the loop. Deal - with the case where INSN was a deleted loop test insn, in which case - it will now be the NOTE_LOOP_END. */ - if (insn == loop_end || insn == orig_loop_end) - return 0; - - for (p = NEXT_INSN (insn); p != loop_end; p = NEXT_INSN (p)) - { - if (GET_CODE (p) == JUMP_INSN) - { - target_insn = JUMP_LABEL (p); - - /* Search from loop_start to insn, to see if one of them is - the target_insn. We can't use INSN_LUID comparisons here, - since insn may not have an LUID entry. */ - for (q = loop_start; q != insn; q = NEXT_INSN (q)) - if (q == target_insn) - return 1; - } - } - - return 0; -} - -/* Try to generate the simplest rtx for the expression - (PLUS (MULT mult1 mult2) add1). This is used to calculate the initial - value of giv's. */ - -static rtx -fold_rtx_mult_add (mult1, mult2, add1, mode) - rtx mult1, mult2, add1; - enum machine_mode mode; -{ - rtx temp, mult_res; - rtx result; - - /* The modes must all be the same. This should always be true. For now, - check to make sure. */ - if ((GET_MODE (mult1) != mode && GET_MODE (mult1) != VOIDmode) - || (GET_MODE (mult2) != mode && GET_MODE (mult2) != VOIDmode) - || (GET_MODE (add1) != mode && GET_MODE (add1) != VOIDmode)) - abort (); - - /* Ensure that if at least one of mult1/mult2 are constant, then mult2 - will be a constant. */ - if (GET_CODE (mult1) == CONST_INT) - { - temp = mult2; - mult2 = mult1; - mult1 = temp; - } - - mult_res = simplify_binary_operation (MULT, mode, mult1, mult2); - if (! mult_res) - mult_res = gen_rtx_MULT (mode, mult1, mult2); - - /* Again, put the constant second. */ - if (GET_CODE (add1) == CONST_INT) - { - temp = add1; - add1 = mult_res; - mult_res = temp; - } - - result = simplify_binary_operation (PLUS, mode, add1, mult_res); - if (! result) - result = gen_rtx_PLUS (mode, add1, mult_res); - - return result; -} - -/* Searches the list of induction struct's for the biv BL, to try to calculate - the total increment value for one iteration of the loop as a constant. - - Returns the increment value as an rtx, simplified as much as possible, - if it can be calculated. Otherwise, returns 0. */ - -rtx -biv_total_increment (bl, loop_start, loop_end) - struct iv_class *bl; - rtx loop_start, loop_end; -{ - struct induction *v; - rtx result; - - /* For increment, must check every instruction that sets it. Each - instruction must be executed only once each time through the loop. - To verify this, we check that the insn is always executed, and that - there are no backward branches after the insn that branch to before it. - Also, the insn must have a mult_val of one (to make sure it really is - an increment). */ - - result = const0_rtx; - for (v = bl->biv; v; v = v->next_iv) - { - if (v->always_computable && v->mult_val == const1_rtx - && ! v->maybe_multiple) - result = fold_rtx_mult_add (result, const1_rtx, v->add_val, v->mode); - else - return 0; - } - - return result; -} - -/* Determine the initial value of the iteration variable, and the amount - that it is incremented each loop. Use the tables constructed by - the strength reduction pass to calculate these values. - - Initial_value and/or increment are set to zero if their values could not - be calculated. */ - -static void -iteration_info (iteration_var, initial_value, increment, loop_start, loop_end) - rtx iteration_var, *initial_value, *increment; - rtx loop_start, loop_end; -{ - struct iv_class *bl; -#if 0 - struct induction *v; -#endif - - /* Clear the result values, in case no answer can be found. */ - *initial_value = 0; - *increment = 0; - - /* The iteration variable can be either a giv or a biv. Check to see - which it is, and compute the variable's initial value, and increment - value if possible. */ - - /* If this is a new register, can't handle it since we don't have any - reg_iv_type entry for it. */ - if ((unsigned) REGNO (iteration_var) > reg_iv_type->num_elements) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: No reg_iv_type entry for iteration var.\n"); - return; - } - - /* Reject iteration variables larger than the host wide int size, since they - could result in a number of iterations greater than the range of our - `unsigned HOST_WIDE_INT' variable loop_info->n_iterations. */ - else if ((GET_MODE_BITSIZE (GET_MODE (iteration_var)) - > HOST_BITS_PER_WIDE_INT)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Iteration var rejected because mode too large.\n"); - return; - } - else if (GET_MODE_CLASS (GET_MODE (iteration_var)) != MODE_INT) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Iteration var not an integer.\n"); - return; - } - else if (REG_IV_TYPE (REGNO (iteration_var)) == BASIC_INDUCT) - { - /* Grab initial value, only useful if it is a constant. */ - bl = reg_biv_class[REGNO (iteration_var)]; - *initial_value = bl->initial_value; - - *increment = biv_total_increment (bl, loop_start, loop_end); - } - else if (REG_IV_TYPE (REGNO (iteration_var)) == GENERAL_INDUCT) - { -#if 1 - /* ??? The code below does not work because the incorrect number of - iterations is calculated when the biv is incremented after the giv - is set (which is the usual case). This can probably be accounted - for by biasing the initial_value by subtracting the amount of the - increment that occurs between the giv set and the giv test. However, - a giv as an iterator is very rare, so it does not seem worthwhile - to handle this. */ - /* ??? An example failure is: i = 6; do {;} while (i++ < 9). */ - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Giv iterators are not handled.\n"); - return; -#else - /* Initial value is mult_val times the biv's initial value plus - add_val. Only useful if it is a constant. */ - v = REG_IV_INFO (REGNO (iteration_var)); - bl = reg_biv_class[REGNO (v->src_reg)]; - *initial_value = fold_rtx_mult_add (v->mult_val, bl->initial_value, - v->add_val, v->mode); - - /* Increment value is mult_val times the increment value of the biv. */ - - *increment = biv_total_increment (bl, loop_start, loop_end); - if (*increment) - *increment = fold_rtx_mult_add (v->mult_val, *increment, const0_rtx, - v->mode); -#endif - } - else - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Not basic or general induction var.\n"); - return; - } -} - - -/* For each biv and giv, determine whether it can be safely split into - a different variable for each unrolled copy of the loop body. If it - is safe to split, then indicate that by saving some useful info - in the splittable_regs array. - - If the loop is being completely unrolled, then splittable_regs will hold - the current value of the induction variable while the loop is unrolled. - It must be set to the initial value of the induction variable here. - Otherwise, splittable_regs will hold the difference between the current - value of the induction variable and the value the induction variable had - at the top of the loop. It must be set to the value 0 here. - - Returns the total number of instructions that set registers that are - splittable. */ - -/* ?? If the loop is only unrolled twice, then most of the restrictions to - constant values are unnecessary, since we can easily calculate increment - values in this case even if nothing is constant. The increment value - should not involve a multiply however. */ - -/* ?? Even if the biv/giv increment values aren't constant, it may still - be beneficial to split the variable if the loop is only unrolled a few - times, since multiplies by small integers (1,2,3,4) are very cheap. */ - -static int -find_splittable_regs (unroll_type, loop_start, loop_end, end_insert_before, - unroll_number, n_iterations) - enum unroll_types unroll_type; - rtx loop_start, loop_end; - rtx end_insert_before; - int unroll_number; - unsigned HOST_WIDE_INT n_iterations; -{ - struct iv_class *bl; - struct induction *v; - rtx increment, tem; - rtx biv_final_value; - int biv_splittable; - int result = 0; - - for (bl = loop_iv_list; bl; bl = bl->next) - { - /* Biv_total_increment must return a constant value, - otherwise we can not calculate the split values. */ - - increment = biv_total_increment (bl, loop_start, loop_end); - if (! increment || GET_CODE (increment) != CONST_INT) - continue; - - /* The loop must be unrolled completely, or else have a known number - of iterations and only one exit, or else the biv must be dead - outside the loop, or else the final value must be known. Otherwise, - it is unsafe to split the biv since it may not have the proper - value on loop exit. */ - - /* loop_number_exit_count is non-zero if the loop has an exit other than - a fall through at the end. */ - - biv_splittable = 1; - biv_final_value = 0; - if (unroll_type != UNROLL_COMPLETELY - && (loop_number_exit_count[uid_loop_num[INSN_UID (loop_start)]] - || unroll_type == UNROLL_NAIVE) - && (uid_luid[REGNO_LAST_UID (bl->regno)] >= INSN_LUID (loop_end) - || ! bl->init_insn - || INSN_UID (bl->init_insn) >= max_uid_for_loop - || (uid_luid[REGNO_FIRST_UID (bl->regno)] - < INSN_LUID (bl->init_insn)) - || reg_mentioned_p (bl->biv->dest_reg, SET_SRC (bl->init_set))) - && ! (biv_final_value = final_biv_value (bl, loop_start, loop_end, - n_iterations))) - biv_splittable = 0; - - /* If any of the insns setting the BIV don't do so with a simple - PLUS, we don't know how to split it. */ - for (v = bl->biv; biv_splittable && v; v = v->next_iv) - if ((tem = single_set (v->insn)) == 0 - || GET_CODE (SET_DEST (tem)) != REG - || REGNO (SET_DEST (tem)) != bl->regno - || GET_CODE (SET_SRC (tem)) != PLUS) - biv_splittable = 0; - - /* If final value is non-zero, then must emit an instruction which sets - the value of the biv to the proper value. This is done after - handling all of the givs, since some of them may need to use the - biv's value in their initialization code. */ - - /* This biv is splittable. If completely unrolling the loop, save - the biv's initial value. Otherwise, save the constant zero. */ - - if (biv_splittable == 1) - { - if (unroll_type == UNROLL_COMPLETELY) - { - /* If the initial value of the biv is itself (i.e. it is too - complicated for strength_reduce to compute), or is a hard - register, or it isn't invariant, then we must create a new - pseudo reg to hold the initial value of the biv. */ - - if (GET_CODE (bl->initial_value) == REG - && (REGNO (bl->initial_value) == bl->regno - || REGNO (bl->initial_value) < FIRST_PSEUDO_REGISTER - || ! invariant_p (bl->initial_value))) - { - rtx tem = gen_reg_rtx (bl->biv->mode); - - record_base_value (REGNO (tem), bl->biv->add_val, 0); - emit_insn_before (gen_move_insn (tem, bl->biv->src_reg), - loop_start); - - if (loop_dump_stream) - fprintf (loop_dump_stream, "Biv %d initial value remapped to %d.\n", - bl->regno, REGNO (tem)); - - splittable_regs[bl->regno] = tem; - } - else - splittable_regs[bl->regno] = bl->initial_value; - } - else - splittable_regs[bl->regno] = const0_rtx; - - /* Save the number of instructions that modify the biv, so that - we can treat the last one specially. */ - - splittable_regs_updates[bl->regno] = bl->biv_count; - result += bl->biv_count; - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Biv %d safe to split.\n", bl->regno); - } - - /* Check every giv that depends on this biv to see whether it is - splittable also. Even if the biv isn't splittable, givs which - depend on it may be splittable if the biv is live outside the - loop, and the givs aren't. */ - - result += find_splittable_givs (bl, unroll_type, loop_start, loop_end, - increment, unroll_number); - - /* If final value is non-zero, then must emit an instruction which sets - the value of the biv to the proper value. This is done after - handling all of the givs, since some of them may need to use the - biv's value in their initialization code. */ - if (biv_final_value) - { - /* If the loop has multiple exits, emit the insns before the - loop to ensure that it will always be executed no matter - how the loop exits. Otherwise emit the insn after the loop, - since this is slightly more efficient. */ - if (! loop_number_exit_count[uid_loop_num[INSN_UID (loop_start)]]) - emit_insn_before (gen_move_insn (bl->biv->src_reg, - biv_final_value), - end_insert_before); - else - { - /* Create a new register to hold the value of the biv, and then - set the biv to its final value before the loop start. The biv - is set to its final value before loop start to ensure that - this insn will always be executed, no matter how the loop - exits. */ - rtx tem = gen_reg_rtx (bl->biv->mode); - record_base_value (REGNO (tem), bl->biv->add_val, 0); - - emit_insn_before (gen_move_insn (tem, bl->biv->src_reg), - loop_start); - emit_insn_before (gen_move_insn (bl->biv->src_reg, - biv_final_value), - loop_start); - - if (loop_dump_stream) - fprintf (loop_dump_stream, "Biv %d mapped to %d for split.\n", - REGNO (bl->biv->src_reg), REGNO (tem)); - - /* Set up the mapping from the original biv register to the new - register. */ - bl->biv->src_reg = tem; - } - } - } - return result; -} - -/* Return 1 if the first and last unrolled copy of the address giv V is valid - for the instruction that is using it. Do not make any changes to that - instruction. */ - -static int -verify_addresses (v, giv_inc, unroll_number) - struct induction *v; - rtx giv_inc; - int unroll_number; -{ - int ret = 1; - rtx orig_addr = *v->location; - rtx last_addr = plus_constant (v->dest_reg, - INTVAL (giv_inc) * (unroll_number - 1)); - - /* First check to see if either address would fail. Handle the fact - that we have may have a match_dup. */ - if (! validate_replace_rtx (*v->location, v->dest_reg, v->insn) - || ! validate_replace_rtx (*v->location, last_addr, v->insn)) - ret = 0; - - /* Now put things back the way they were before. This should always - succeed. */ - if (! validate_replace_rtx (*v->location, orig_addr, v->insn)) - abort (); - - return ret; -} - -/* For every giv based on the biv BL, check to determine whether it is - splittable. This is a subroutine to find_splittable_regs (). - - Return the number of instructions that set splittable registers. */ - -static int -find_splittable_givs (bl, unroll_type, loop_start, loop_end, increment, - unroll_number) - struct iv_class *bl; - enum unroll_types unroll_type; - rtx loop_start, loop_end; - rtx increment; - int unroll_number; -{ - struct induction *v, *v2; - rtx final_value; - rtx tem; - int result = 0; - - /* Scan the list of givs, and set the same_insn field when there are - multiple identical givs in the same insn. */ - for (v = bl->giv; v; v = v->next_iv) - for (v2 = v->next_iv; v2; v2 = v2->next_iv) - if (v->insn == v2->insn && rtx_equal_p (v->new_reg, v2->new_reg) - && ! v2->same_insn) - v2->same_insn = v; - - for (v = bl->giv; v; v = v->next_iv) - { - rtx giv_inc, value; - - /* Only split the giv if it has already been reduced, or if the loop is - being completely unrolled. */ - if (unroll_type != UNROLL_COMPLETELY && v->ignore) - continue; - - /* The giv can be split if the insn that sets the giv is executed once - and only once on every iteration of the loop. */ - /* An address giv can always be split. v->insn is just a use not a set, - and hence it does not matter whether it is always executed. All that - matters is that all the biv increments are always executed, and we - won't reach here if they aren't. */ - if (v->giv_type != DEST_ADDR - && (! v->always_computable - || back_branch_in_range_p (v->insn, loop_start, loop_end))) - continue; - - /* The giv increment value must be a constant. */ - giv_inc = fold_rtx_mult_add (v->mult_val, increment, const0_rtx, - v->mode); - if (! giv_inc || GET_CODE (giv_inc) != CONST_INT) - continue; - - /* The loop must be unrolled completely, or else have a known number of - iterations and only one exit, or else the giv must be dead outside - the loop, or else the final value of the giv must be known. - Otherwise, it is not safe to split the giv since it may not have the - proper value on loop exit. */ - - /* The used outside loop test will fail for DEST_ADDR givs. They are - never used outside the loop anyways, so it is always safe to split a - DEST_ADDR giv. */ - - final_value = 0; - if (unroll_type != UNROLL_COMPLETELY - && (loop_number_exit_count[uid_loop_num[INSN_UID (loop_start)]] - || unroll_type == UNROLL_NAIVE) - && v->giv_type != DEST_ADDR - /* The next part is true if the pseudo is used outside the loop. - We assume that this is true for any pseudo created after loop - starts, because we don't have a reg_n_info entry for them. */ - && (REGNO (v->dest_reg) >= max_reg_before_loop - || (REGNO_FIRST_UID (REGNO (v->dest_reg)) != INSN_UID (v->insn) - /* Check for the case where the pseudo is set by a shift/add - sequence, in which case the first insn setting the pseudo - is the first insn of the shift/add sequence. */ - && (! (tem = find_reg_note (v->insn, REG_RETVAL, NULL_RTX)) - || (REGNO_FIRST_UID (REGNO (v->dest_reg)) - != INSN_UID (XEXP (tem, 0))))) - /* Line above always fails if INSN was moved by loop opt. */ - || (uid_luid[REGNO_LAST_UID (REGNO (v->dest_reg))] - >= INSN_LUID (loop_end))) - /* Givs made from biv increments are missed by the above test, so - test explicitly for them. */ - && (REGNO (v->dest_reg) < first_increment_giv - || REGNO (v->dest_reg) > last_increment_giv) - && ! (final_value = v->final_value)) - continue; - -#if 0 - /* Currently, non-reduced/final-value givs are never split. */ - /* Should emit insns after the loop if possible, as the biv final value - code below does. */ - - /* If the final value is non-zero, and the giv has not been reduced, - then must emit an instruction to set the final value. */ - if (final_value && !v->new_reg) - { - /* Create a new register to hold the value of the giv, and then set - the giv to its final value before the loop start. The giv is set - to its final value before loop start to ensure that this insn - will always be executed, no matter how we exit. */ - tem = gen_reg_rtx (v->mode); - emit_insn_before (gen_move_insn (tem, v->dest_reg), loop_start); - emit_insn_before (gen_move_insn (v->dest_reg, final_value), - loop_start); - - if (loop_dump_stream) - fprintf (loop_dump_stream, "Giv %d mapped to %d for split.\n", - REGNO (v->dest_reg), REGNO (tem)); - - v->src_reg = tem; - } -#endif - - /* This giv is splittable. If completely unrolling the loop, save the - giv's initial value. Otherwise, save the constant zero for it. */ - - if (unroll_type == UNROLL_COMPLETELY) - { - /* It is not safe to use bl->initial_value here, because it may not - be invariant. It is safe to use the initial value stored in - the splittable_regs array if it is set. In rare cases, it won't - be set, so then we do exactly the same thing as - find_splittable_regs does to get a safe value. */ - rtx biv_initial_value; - - if (splittable_regs[bl->regno]) - biv_initial_value = splittable_regs[bl->regno]; - else if (GET_CODE (bl->initial_value) != REG - || (REGNO (bl->initial_value) != bl->regno - && REGNO (bl->initial_value) >= FIRST_PSEUDO_REGISTER)) - biv_initial_value = bl->initial_value; - else - { - rtx tem = gen_reg_rtx (bl->biv->mode); - - record_base_value (REGNO (tem), bl->biv->add_val, 0); - emit_insn_before (gen_move_insn (tem, bl->biv->src_reg), - loop_start); - biv_initial_value = tem; - } - value = fold_rtx_mult_add (v->mult_val, biv_initial_value, - v->add_val, v->mode); - } - else - value = const0_rtx; - - if (v->new_reg) - { - /* If a giv was combined with another giv, then we can only split - this giv if the giv it was combined with was reduced. This - is because the value of v->new_reg is meaningless in this - case. */ - if (v->same && ! v->same->new_reg) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "giv combined with unreduced giv not split.\n"); - continue; - } - /* If the giv is an address destination, it could be something other - than a simple register, these have to be treated differently. */ - else if (v->giv_type == DEST_REG) - { - /* If value is not a constant, register, or register plus - constant, then compute its value into a register before - loop start. This prevents invalid rtx sharing, and should - generate better code. We can use bl->initial_value here - instead of splittable_regs[bl->regno] because this code - is going before the loop start. */ - if (unroll_type == UNROLL_COMPLETELY - && GET_CODE (value) != CONST_INT - && GET_CODE (value) != REG - && (GET_CODE (value) != PLUS - || GET_CODE (XEXP (value, 0)) != REG - || GET_CODE (XEXP (value, 1)) != CONST_INT)) - { - rtx tem = gen_reg_rtx (v->mode); - record_base_value (REGNO (tem), v->add_val, 0); - emit_iv_add_mult (bl->initial_value, v->mult_val, - v->add_val, tem, loop_start); - value = tem; - } - - splittable_regs[REGNO (v->new_reg)] = value; - derived_regs[REGNO (v->new_reg)] = v->derived_from != 0; - } - else - { - /* Splitting address givs is useful since it will often allow us - to eliminate some increment insns for the base giv as - unnecessary. */ - - /* If the addr giv is combined with a dest_reg giv, then all - references to that dest reg will be remapped, which is NOT - what we want for split addr regs. We always create a new - register for the split addr giv, just to be safe. */ - - /* If we have multiple identical address givs within a - single instruction, then use a single pseudo reg for - both. This is necessary in case one is a match_dup - of the other. */ - - v->const_adjust = 0; - - if (v->same_insn) - { - v->dest_reg = v->same_insn->dest_reg; - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Sharing address givs in insn %d\n", - INSN_UID (v->insn)); - } - /* If multiple address GIVs have been combined with the - same dest_reg GIV, do not create a new register for - each. */ - else if (unroll_type != UNROLL_COMPLETELY - && v->giv_type == DEST_ADDR - && v->same && v->same->giv_type == DEST_ADDR - && v->same->unrolled - /* combine_givs_p may return true for some cases - where the add and mult values are not equal. - To share a register here, the values must be - equal. */ - && rtx_equal_p (v->same->mult_val, v->mult_val) - && rtx_equal_p (v->same->add_val, v->add_val)) - - { - v->dest_reg = v->same->dest_reg; - v->shared = 1; - } - else if (unroll_type != UNROLL_COMPLETELY) - { - /* If not completely unrolling the loop, then create a new - register to hold the split value of the DEST_ADDR giv. - Emit insn to initialize its value before loop start. */ - - rtx tem = gen_reg_rtx (v->mode); - struct induction *same = v->same; - rtx new_reg = v->new_reg; - record_base_value (REGNO (tem), v->add_val, 0); - - if (same && same->derived_from) - { - /* calculate_giv_inc doesn't work for derived givs. - copy_loop_body works around the problem for the - DEST_REG givs themselves, but it can't handle - DEST_ADDR givs that have been combined with - a derived DEST_REG giv. - So Handle V as if the giv from which V->SAME has - been derived has been combined with V. - recombine_givs only derives givs from givs that - are reduced the ordinary, so we need not worry - about same->derived_from being in turn derived. */ - - same = same->derived_from; - new_reg = express_from (same, v); - new_reg = replace_rtx (new_reg, same->dest_reg, - same->new_reg); - } - - /* If the address giv has a constant in its new_reg value, - then this constant can be pulled out and put in value, - instead of being part of the initialization code. */ - - if (GET_CODE (new_reg) == PLUS - && GET_CODE (XEXP (new_reg, 1)) == CONST_INT) - { - v->dest_reg - = plus_constant (tem, INTVAL (XEXP (new_reg, 1))); - - /* Only succeed if this will give valid addresses. - Try to validate both the first and the last - address resulting from loop unrolling, if - one fails, then can't do const elim here. */ - if (verify_addresses (v, giv_inc, unroll_number)) - { - /* Save the negative of the eliminated const, so - that we can calculate the dest_reg's increment - value later. */ - v->const_adjust = - INTVAL (XEXP (new_reg, 1)); - - new_reg = XEXP (new_reg, 0); - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Eliminating constant from giv %d\n", - REGNO (tem)); - } - else - v->dest_reg = tem; - } - else - v->dest_reg = tem; - - /* If the address hasn't been checked for validity yet, do so - now, and fail completely if either the first or the last - unrolled copy of the address is not a valid address - for the instruction that uses it. */ - if (v->dest_reg == tem - && ! verify_addresses (v, giv_inc, unroll_number)) - { - for (v2 = v->next_iv; v2; v2 = v2->next_iv) - if (v2->same_insn == v) - v2->same_insn = 0; - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Invalid address for giv at insn %d\n", - INSN_UID (v->insn)); - continue; - } - - v->new_reg = new_reg; - v->same = same; - - /* We set this after the address check, to guarantee that - the register will be initialized. */ - v->unrolled = 1; - - /* To initialize the new register, just move the value of - new_reg into it. This is not guaranteed to give a valid - instruction on machines with complex addressing modes. - If we can't recognize it, then delete it and emit insns - to calculate the value from scratch. */ - emit_insn_before (gen_rtx_SET (VOIDmode, tem, - copy_rtx (v->new_reg)), - loop_start); - if (recog_memoized (PREV_INSN (loop_start)) < 0) - { - rtx sequence, ret; - - /* We can't use bl->initial_value to compute the initial - value, because the loop may have been preconditioned. - We must calculate it from NEW_REG. Try using - force_operand instead of emit_iv_add_mult. */ - delete_insn (PREV_INSN (loop_start)); - - start_sequence (); - ret = force_operand (v->new_reg, tem); - if (ret != tem) - emit_move_insn (tem, ret); - sequence = gen_sequence (); - end_sequence (); - emit_insn_before (sequence, loop_start); - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Invalid init insn, rewritten.\n"); - } - } - else - { - v->dest_reg = value; - - /* Check the resulting address for validity, and fail - if the resulting address would be invalid. */ - if (! verify_addresses (v, giv_inc, unroll_number)) - { - for (v2 = v->next_iv; v2; v2 = v2->next_iv) - if (v2->same_insn == v) - v2->same_insn = 0; - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Invalid address for giv at insn %d\n", - INSN_UID (v->insn)); - continue; - } - if (v->same && v->same->derived_from) - { - /* Handle V as if the giv from which V->SAME has - been derived has been combined with V. */ - - v->same = v->same->derived_from; - v->new_reg = express_from (v->same, v); - v->new_reg = replace_rtx (v->new_reg, v->same->dest_reg, - v->same->new_reg); - } - - } - - /* Store the value of dest_reg into the insn. This sharing - will not be a problem as this insn will always be copied - later. */ - - *v->location = v->dest_reg; - - /* If this address giv is combined with a dest reg giv, then - save the base giv's induction pointer so that we will be - able to handle this address giv properly. The base giv - itself does not have to be splittable. */ - - if (v->same && v->same->giv_type == DEST_REG) - addr_combined_regs[REGNO (v->same->new_reg)] = v->same; - - if (GET_CODE (v->new_reg) == REG) - { - /* This giv maybe hasn't been combined with any others. - Make sure that it's giv is marked as splittable here. */ - - splittable_regs[REGNO (v->new_reg)] = value; - derived_regs[REGNO (v->new_reg)] = v->derived_from != 0; - - /* Make it appear to depend upon itself, so that the - giv will be properly split in the main loop above. */ - if (! v->same) - { - v->same = v; - addr_combined_regs[REGNO (v->new_reg)] = v; - } - } - - if (loop_dump_stream) - fprintf (loop_dump_stream, "DEST_ADDR giv being split.\n"); - } - } - else - { -#if 0 - /* Currently, unreduced giv's can't be split. This is not too much - of a problem since unreduced giv's are not live across loop - iterations anyways. When unrolling a loop completely though, - it makes sense to reduce&split givs when possible, as this will - result in simpler instructions, and will not require that a reg - be live across loop iterations. */ - - splittable_regs[REGNO (v->dest_reg)] = value; - fprintf (stderr, "Giv %d at insn %d not reduced\n", - REGNO (v->dest_reg), INSN_UID (v->insn)); -#else - continue; -#endif - } - - /* Unreduced givs are only updated once by definition. Reduced givs - are updated as many times as their biv is. Mark it so if this is - a splittable register. Don't need to do anything for address givs - where this may not be a register. */ - - if (GET_CODE (v->new_reg) == REG) - { - int count = 1; - if (! v->ignore) - count = reg_biv_class[REGNO (v->src_reg)]->biv_count; - - if (count > 1 && v->derived_from) - /* In this case, there is one set where the giv insn was and one - set each after each biv increment. (Most are likely dead.) */ - count++; - - splittable_regs_updates[REGNO (v->new_reg)] = count; - } - - result++; - - if (loop_dump_stream) - { - int regnum; - - if (GET_CODE (v->dest_reg) == CONST_INT) - regnum = -1; - else if (GET_CODE (v->dest_reg) != REG) - regnum = REGNO (XEXP (v->dest_reg, 0)); - else - regnum = REGNO (v->dest_reg); - fprintf (loop_dump_stream, "Giv %d at insn %d safe to split.\n", - regnum, INSN_UID (v->insn)); - } - } - - return result; -} - -/* Try to prove that the register is dead after the loop exits. Trace every - loop exit looking for an insn that will always be executed, which sets - the register to some value, and appears before the first use of the register - is found. If successful, then return 1, otherwise return 0. */ - -/* ?? Could be made more intelligent in the handling of jumps, so that - it can search past if statements and other similar structures. */ - -static int -reg_dead_after_loop (reg, loop_start, loop_end) - rtx reg, loop_start, loop_end; -{ - rtx insn, label; - enum rtx_code code; - int jump_count = 0; - int label_count = 0; - int this_loop_num = uid_loop_num[INSN_UID (loop_start)]; - - /* In addition to checking all exits of this loop, we must also check - all exits of inner nested loops that would exit this loop. We don't - have any way to identify those, so we just give up if there are any - such inner loop exits. */ - - for (label = loop_number_exit_labels[this_loop_num]; label; - label = LABEL_NEXTREF (label)) - label_count++; - - if (label_count != loop_number_exit_count[this_loop_num]) - return 0; - - /* HACK: Must also search the loop fall through exit, create a label_ref - here which points to the loop_end, and append the loop_number_exit_labels - list to it. */ - label = gen_rtx_LABEL_REF (VOIDmode, loop_end); - LABEL_NEXTREF (label) = loop_number_exit_labels[this_loop_num]; - - for ( ; label; label = LABEL_NEXTREF (label)) - { - /* Succeed if find an insn which sets the biv or if reach end of - function. Fail if find an insn that uses the biv, or if come to - a conditional jump. */ - - insn = NEXT_INSN (XEXP (label, 0)); - while (insn) - { - code = GET_CODE (insn); - if (GET_RTX_CLASS (code) == 'i') - { - rtx set; - - if (reg_referenced_p (reg, PATTERN (insn))) - return 0; - - set = single_set (insn); - if (set && rtx_equal_p (SET_DEST (set), reg)) - break; - } - - if (code == JUMP_INSN) - { - if (GET_CODE (PATTERN (insn)) == RETURN) - break; - else if (! simplejump_p (insn) - /* Prevent infinite loop following infinite loops. */ - || jump_count++ > 20) - return 0; - else - insn = JUMP_LABEL (insn); - } - - insn = NEXT_INSN (insn); - } - } - - /* Success, the register is dead on all loop exits. */ - return 1; -} - -/* Try to calculate the final value of the biv, the value it will have at - the end of the loop. If we can do it, return that value. */ - -rtx -final_biv_value (bl, loop_start, loop_end, n_iterations) - struct iv_class *bl; - rtx loop_start, loop_end; - unsigned HOST_WIDE_INT n_iterations; -{ - rtx increment, tem; - - /* ??? This only works for MODE_INT biv's. Reject all others for now. */ - - if (GET_MODE_CLASS (bl->biv->mode) != MODE_INT) - return 0; - - /* The final value for reversed bivs must be calculated differently than - for ordinary bivs. In this case, there is already an insn after the - loop which sets this biv's final value (if necessary), and there are - no other loop exits, so we can return any value. */ - if (bl->reversed) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final biv value for %d, reversed biv.\n", bl->regno); - - return const0_rtx; - } - - /* Try to calculate the final value as initial value + (number of iterations - * increment). For this to work, increment must be invariant, the only - exit from the loop must be the fall through at the bottom (otherwise - it may not have its final value when the loop exits), and the initial - value of the biv must be invariant. */ - - if (n_iterations != 0 - && ! loop_number_exit_count[uid_loop_num[INSN_UID (loop_start)]] - && invariant_p (bl->initial_value)) - { - increment = biv_total_increment (bl, loop_start, loop_end); - - if (increment && invariant_p (increment)) - { - /* Can calculate the loop exit value, emit insns after loop - end to calculate this value into a temporary register in - case it is needed later. */ - - tem = gen_reg_rtx (bl->biv->mode); - record_base_value (REGNO (tem), bl->biv->add_val, 0); - /* Make sure loop_end is not the last insn. */ - if (NEXT_INSN (loop_end) == 0) - emit_note_after (NOTE_INSN_DELETED, loop_end); - emit_iv_add_mult (increment, GEN_INT (n_iterations), - bl->initial_value, tem, NEXT_INSN (loop_end)); - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final biv value for %d, calculated.\n", bl->regno); - - return tem; - } - } - - /* Check to see if the biv is dead at all loop exits. */ - if (reg_dead_after_loop (bl->biv->src_reg, loop_start, loop_end)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final biv value for %d, biv dead after loop exit.\n", - bl->regno); - - return const0_rtx; - } - - return 0; -} - -/* Try to calculate the final value of the giv, the value it will have at - the end of the loop. If we can do it, return that value. */ - -rtx -final_giv_value (v, loop_start, loop_end, n_iterations) - struct induction *v; - rtx loop_start, loop_end; - unsigned HOST_WIDE_INT n_iterations; -{ - struct iv_class *bl; - rtx insn; - rtx increment, tem; - rtx insert_before, seq; - - bl = reg_biv_class[REGNO (v->src_reg)]; - - /* The final value for givs which depend on reversed bivs must be calculated - differently than for ordinary givs. In this case, there is already an - insn after the loop which sets this giv's final value (if necessary), - and there are no other loop exits, so we can return any value. */ - if (bl->reversed) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final giv value for %d, depends on reversed biv\n", - REGNO (v->dest_reg)); - return const0_rtx; - } - - /* Try to calculate the final value as a function of the biv it depends - upon. The only exit from the loop must be the fall through at the bottom - (otherwise it may not have its final value when the loop exits). */ - - /* ??? Can calculate the final giv value by subtracting off the - extra biv increments times the giv's mult_val. The loop must have - only one exit for this to work, but the loop iterations does not need - to be known. */ - - if (n_iterations != 0 - && ! loop_number_exit_count[uid_loop_num[INSN_UID (loop_start)]]) - { - /* ?? It is tempting to use the biv's value here since these insns will - be put after the loop, and hence the biv will have its final value - then. However, this fails if the biv is subsequently eliminated. - Perhaps determine whether biv's are eliminable before trying to - determine whether giv's are replaceable so that we can use the - biv value here if it is not eliminable. */ - - /* We are emitting code after the end of the loop, so we must make - sure that bl->initial_value is still valid then. It will still - be valid if it is invariant. */ - - increment = biv_total_increment (bl, loop_start, loop_end); - - if (increment && invariant_p (increment) - && invariant_p (bl->initial_value)) - { - /* Can calculate the loop exit value of its biv as - (n_iterations * increment) + initial_value */ - - /* The loop exit value of the giv is then - (final_biv_value - extra increments) * mult_val + add_val. - The extra increments are any increments to the biv which - occur in the loop after the giv's value is calculated. - We must search from the insn that sets the giv to the end - of the loop to calculate this value. */ - - insert_before = NEXT_INSN (loop_end); - - /* Put the final biv value in tem. */ - tem = gen_reg_rtx (bl->biv->mode); - record_base_value (REGNO (tem), bl->biv->add_val, 0); - emit_iv_add_mult (increment, GEN_INT (n_iterations), - bl->initial_value, tem, insert_before); - - /* Subtract off extra increments as we find them. */ - for (insn = NEXT_INSN (v->insn); insn != loop_end; - insn = NEXT_INSN (insn)) - { - struct induction *biv; - - for (biv = bl->biv; biv; biv = biv->next_iv) - if (biv->insn == insn) - { - start_sequence (); - tem = expand_binop (GET_MODE (tem), sub_optab, tem, - biv->add_val, NULL_RTX, 0, - OPTAB_LIB_WIDEN); - seq = gen_sequence (); - end_sequence (); - emit_insn_before (seq, insert_before); - } - } - - /* Now calculate the giv's final value. */ - emit_iv_add_mult (tem, v->mult_val, v->add_val, tem, - insert_before); - - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final giv value for %d, calc from biv's value.\n", - REGNO (v->dest_reg)); - - return tem; - } - } - - /* Replaceable giv's should never reach here. */ - if (v->replaceable) - abort (); - - /* Check to see if the biv is dead at all loop exits. */ - if (reg_dead_after_loop (v->dest_reg, loop_start, loop_end)) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Final giv value for %d, giv dead after loop exit.\n", - REGNO (v->dest_reg)); - - return const0_rtx; - } - - return 0; -} - - -/* Look back before LOOP_START for then insn that sets REG and return - the equivalent constant if there is a REG_EQUAL note otherwise just - the SET_SRC of REG. */ - -static rtx -loop_find_equiv_value (loop_start, reg) - rtx loop_start; - rtx reg; -{ - rtx insn, set; - rtx ret; - - ret = reg; - for (insn = PREV_INSN (loop_start); insn ; insn = PREV_INSN (insn)) - { - if (GET_CODE (insn) == CODE_LABEL) - break; - - else if (GET_RTX_CLASS (GET_CODE (insn)) == 'i' - && reg_set_p (reg, insn)) - { - /* We found the last insn before the loop that sets the register. - If it sets the entire register, and has a REG_EQUAL note, - then use the value of the REG_EQUAL note. */ - if ((set = single_set (insn)) - && (SET_DEST (set) == reg)) - { - rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX); - - /* Only use the REG_EQUAL note if it is a constant. - Other things, divide in particular, will cause - problems later if we use them. */ - if (note && GET_CODE (XEXP (note, 0)) != EXPR_LIST - && CONSTANT_P (XEXP (note, 0))) - ret = XEXP (note, 0); - else - ret = SET_SRC (set); - } - break; - } - } - return ret; -} - - -/* Return a simplified rtx for the expression OP - REG. - - REG must appear in OP, and OP must be a register or the sum of a register - and a second term. - - Thus, the return value must be const0_rtx or the second term. - - The caller is responsible for verifying that REG appears in OP and OP has - the proper form. */ - -static rtx -subtract_reg_term (op, reg) - rtx op, reg; -{ - if (op == reg) - return const0_rtx; - if (GET_CODE (op) == PLUS) - { - if (XEXP (op, 0) == reg) - return XEXP (op, 1); - else if (XEXP (op, 1) == reg) - return XEXP (op, 0); - } - /* OP does not contain REG as a term. */ - abort (); -} - - -/* Find and return register term common to both expressions OP0 and - OP1 or NULL_RTX if no such term exists. Each expression must be a - REG or a PLUS of a REG. */ - -static rtx -find_common_reg_term (op0, op1) - rtx op0, op1; -{ - if ((GET_CODE (op0) == REG || GET_CODE (op0) == PLUS) - && (GET_CODE (op1) == REG || GET_CODE (op1) == PLUS)) - { - rtx op00; - rtx op01; - rtx op10; - rtx op11; - - if (GET_CODE (op0) == PLUS) - op01 = XEXP (op0, 1), op00 = XEXP (op0, 0); - else - op01 = const0_rtx, op00 = op0; - - if (GET_CODE (op1) == PLUS) - op11 = XEXP (op1, 1), op10 = XEXP (op1, 0); - else - op11 = const0_rtx, op10 = op1; - - /* Find and return common register term if present. */ - if (REG_P (op00) && (op00 == op10 || op00 == op11)) - return op00; - else if (REG_P (op01) && (op01 == op10 || op01 == op11)) - return op01; - } - - /* No common register term found. */ - return NULL_RTX; -} - - -/* Calculate the number of loop iterations. Returns the exact number of loop - iterations if it can be calculated, otherwise returns zero. */ - -unsigned HOST_WIDE_INT -loop_iterations (loop_start, loop_end, loop_info) - rtx loop_start, loop_end; - struct loop_info *loop_info; -{ - rtx comparison, comparison_value; - rtx iteration_var, initial_value, increment, final_value; - enum rtx_code comparison_code; - HOST_WIDE_INT abs_inc; - unsigned HOST_WIDE_INT abs_diff; - int off_by_one; - int increment_dir; - int unsigned_p, compare_dir, final_larger; - rtx last_loop_insn; - rtx vtop; - rtx reg_term; - - loop_info->n_iterations = 0; - loop_info->initial_value = 0; - loop_info->initial_equiv_value = 0; - loop_info->comparison_value = 0; - loop_info->final_value = 0; - loop_info->final_equiv_value = 0; - loop_info->increment = 0; - loop_info->iteration_var = 0; - loop_info->unroll_number = 1; - loop_info->vtop = 0; - - /* First find the iteration variable. If the last insn is a conditional - branch, and the insn before tests a register value, make that the - iteration variable. */ - - /* We used to use prev_nonnote_insn here, but that fails because it might - accidentally get the branch for a contained loop if the branch for this - loop was deleted. We can only trust branches immediately before the - loop_end. */ - last_loop_insn = PREV_INSN (loop_end); - - comparison = get_condition_for_loop (last_loop_insn); - if (comparison == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop iterations: No final conditional branch found.\n"); - return 0; - } - - /* ??? Get_condition may switch position of induction variable and - invariant register when it canonicalizes the comparison. */ - - comparison_code = GET_CODE (comparison); - iteration_var = XEXP (comparison, 0); - comparison_value = XEXP (comparison, 1); - - /* Check if there is a NOTE_INSN_LOOP_VTOP note. If there is, - that means that this is a for or while style loop, with - a loop exit test at the start. Thus, we can assume that - the loop condition was true when the loop was entered. - - We start at the end and search backwards for the previous - NOTE. If there is no NOTE_INSN_LOOP_VTOP for this loop, - the search will stop at the NOTE_INSN_LOOP_CONT. */ - vtop = loop_end; - do - vtop = PREV_INSN (vtop); - while (GET_CODE (vtop) != NOTE - || NOTE_LINE_NUMBER (vtop) > 0 - || NOTE_LINE_NUMBER (vtop) == NOTE_REPEATED_LINE_NUMBER - || NOTE_LINE_NUMBER (vtop) == NOTE_INSN_DELETED); - if (NOTE_LINE_NUMBER (vtop) != NOTE_INSN_LOOP_VTOP) - vtop = NULL_RTX; - loop_info->vtop = vtop; - - if (GET_CODE (iteration_var) != REG) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop iterations: Comparison not against register.\n"); - return 0; - } - - /* Loop iterations is always called before any new registers are created - now, so this should never occur. */ - - if (REGNO (iteration_var) >= max_reg_before_loop) - abort (); - - iteration_info (iteration_var, &initial_value, &increment, - loop_start, loop_end); - if (initial_value == 0) - /* iteration_info already printed a message. */ - return 0; - - unsigned_p = 0; - off_by_one = 0; - switch (comparison_code) - { - case LEU: - unsigned_p = 1; - case LE: - compare_dir = 1; - off_by_one = 1; - break; - case GEU: - unsigned_p = 1; - case GE: - compare_dir = -1; - off_by_one = -1; - break; - case EQ: - /* Cannot determine loop iterations with this case. */ - compare_dir = 0; - break; - case LTU: - unsigned_p = 1; - case LT: - compare_dir = 1; - break; - case GTU: - unsigned_p = 1; - case GT: - compare_dir = -1; - case NE: - compare_dir = 0; - break; - default: - abort (); - } - - /* If the comparison value is an invariant register, then try to find - its value from the insns before the start of the loop. */ - - final_value = comparison_value; - if (GET_CODE (comparison_value) == REG && invariant_p (comparison_value)) - { - final_value = loop_find_equiv_value (loop_start, comparison_value); - /* If we don't get an invariant final value, we are better - off with the original register. */ - if (!invariant_p (final_value)) - final_value = comparison_value; - } - - /* Calculate the approximate final value of the induction variable - (on the last successful iteration). The exact final value - depends on the branch operator, and increment sign. It will be - wrong if the iteration variable is not incremented by one each - time through the loop and (comparison_value + off_by_one - - initial_value) % increment != 0. - ??? Note that the final_value may overflow and thus final_larger - will be bogus. A potentially infinite loop will be classified - as immediate, e.g. for (i = 0x7ffffff0; i <= 0x7fffffff; i++) */ - if (off_by_one) - final_value = plus_constant (final_value, off_by_one); - - /* Save the calculated values describing this loop's bounds, in case - precondition_loop_p will need them later. These values can not be - recalculated inside precondition_loop_p because strength reduction - optimizations may obscure the loop's structure. - - These values are only required by precondition_loop_p and insert_bct - whenever the number of iterations cannot be computed at compile time. - Only the difference between final_value and initial_value is - important. Note that final_value is only approximate. */ - loop_info->initial_value = initial_value; - loop_info->comparison_value = comparison_value; - loop_info->final_value = plus_constant (comparison_value, off_by_one); - loop_info->increment = increment; - loop_info->iteration_var = iteration_var; - loop_info->comparison_code = comparison_code; - - /* Try to determine the iteration count for loops such - as (for i = init; i < init + const; i++). When running the - loop optimization twice, the first pass often converts simple - loops into this form. */ - - if (REG_P (initial_value)) - { - rtx reg1; - rtx reg2; - rtx const2; - - reg1 = initial_value; - if (GET_CODE (final_value) == PLUS) - reg2 = XEXP (final_value, 0), const2 = XEXP (final_value, 1); - else - reg2 = final_value, const2 = const0_rtx; - - /* Check for initial_value = reg1, final_value = reg2 + const2, - where reg1 != reg2. */ - if (REG_P (reg2) && reg2 != reg1) - { - rtx temp; - - /* Find what reg1 is equivalent to. Hopefully it will - either be reg2 or reg2 plus a constant. */ - temp = loop_find_equiv_value (loop_start, reg1); - if (find_common_reg_term (temp, reg2)) - initial_value = temp; - else - { - /* Find what reg2 is equivalent to. Hopefully it will - either be reg1 or reg1 plus a constant. Let's ignore - the latter case for now since it is not so common. */ - temp = loop_find_equiv_value (loop_start, reg2); - if (temp == loop_info->iteration_var) - temp = initial_value; - if (temp == reg1) - final_value = (const2 == const0_rtx) - ? reg1 : gen_rtx_PLUS (GET_MODE (reg1), reg1, const2); - } - } - else if (loop_info->vtop && GET_CODE (reg2) == CONST_INT) - { - rtx temp; - - /* When running the loop optimizer twice, check_dbra_loop - further obfuscates reversible loops of the form: - for (i = init; i < init + const; i++). We often end up with - final_value = 0, initial_value = temp, temp = temp2 - init, - where temp2 = init + const. If the loop has a vtop we - can replace initial_value with const. */ - - temp = loop_find_equiv_value (loop_start, reg1); - if (GET_CODE (temp) == MINUS && REG_P (XEXP (temp, 0))) - { - rtx temp2 = loop_find_equiv_value (loop_start, XEXP (temp, 0)); - if (GET_CODE (temp2) == PLUS - && XEXP (temp2, 0) == XEXP (temp, 1)) - initial_value = XEXP (temp2, 1); - } - } - } - - /* If have initial_value = reg + const1 and final_value = reg + - const2, then replace initial_value with const1 and final_value - with const2. This should be safe since we are protected by the - initial comparison before entering the loop if we have a vtop. - For example, a + b < a + c is not equivalent to b < c for all a - when using modulo arithmetic. - - ??? Without a vtop we could still perform the optimization if we check - the initial and final values carefully. */ - if (loop_info->vtop - && (reg_term = find_common_reg_term (initial_value, final_value))) - { - initial_value = subtract_reg_term (initial_value, reg_term); - final_value = subtract_reg_term (final_value, reg_term); - } - - loop_info->initial_equiv_value = initial_value; - loop_info->final_equiv_value = final_value; - - if (increment == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop iterations: Increment value can't be calculated.\n"); - return 0; - } - - if (GET_CODE (increment) != CONST_INT) - { - increment = loop_find_equiv_value (loop_start, increment); - - if (GET_CODE (increment) != CONST_INT) - { - if (loop_dump_stream) - { - fprintf (loop_dump_stream, - "Loop iterations: Increment value not constant "); - print_rtl (loop_dump_stream, increment); - fprintf (loop_dump_stream, ".\n"); - } - return 0; - } - loop_info->increment = increment; - } - - if (GET_CODE (initial_value) != CONST_INT) - { - if (loop_dump_stream) - { - fprintf (loop_dump_stream, - "Loop iterations: Initial value not constant "); - print_rtl (loop_dump_stream, initial_value); - fprintf (loop_dump_stream, ".\n"); - } - return 0; - } - else if (comparison_code == EQ) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop iterations: EQ comparison loop.\n"); - return 0; - } - else if (GET_CODE (final_value) != CONST_INT) - { - if (loop_dump_stream) - { - fprintf (loop_dump_stream, - "Loop iterations: Final value not constant "); - print_rtl (loop_dump_stream, final_value); - fprintf (loop_dump_stream, ".\n"); - } - return 0; - } - - /* Final_larger is 1 if final larger, 0 if they are equal, otherwise -1. */ - if (unsigned_p) - final_larger - = ((unsigned HOST_WIDE_INT) INTVAL (final_value) - > (unsigned HOST_WIDE_INT) INTVAL (initial_value)) - - ((unsigned HOST_WIDE_INT) INTVAL (final_value) - < (unsigned HOST_WIDE_INT) INTVAL (initial_value)); - else - final_larger = (INTVAL (final_value) > INTVAL (initial_value)) - - (INTVAL (final_value) < INTVAL (initial_value)); - - if (INTVAL (increment) > 0) - increment_dir = 1; - else if (INTVAL (increment) == 0) - increment_dir = 0; - else - increment_dir = -1; - - /* There are 27 different cases: compare_dir = -1, 0, 1; - final_larger = -1, 0, 1; increment_dir = -1, 0, 1. - There are 4 normal cases, 4 reverse cases (where the iteration variable - will overflow before the loop exits), 4 infinite loop cases, and 15 - immediate exit (0 or 1 iteration depending on loop type) cases. - Only try to optimize the normal cases. */ - - /* (compare_dir/final_larger/increment_dir) - Normal cases: (0/-1/-1), (0/1/1), (-1/-1/-1), (1/1/1) - Reverse cases: (0/-1/1), (0/1/-1), (-1/-1/1), (1/1/-1) - Infinite loops: (0/-1/0), (0/1/0), (-1/-1/0), (1/1/0) - Immediate exit: (0/0/X), (-1/0/X), (-1/1/X), (1/0/X), (1/-1/X) */ - - /* ?? If the meaning of reverse loops (where the iteration variable - will overflow before the loop exits) is undefined, then could - eliminate all of these special checks, and just always assume - the loops are normal/immediate/infinite. Note that this means - the sign of increment_dir does not have to be known. Also, - since it does not really hurt if immediate exit loops or infinite loops - are optimized, then that case could be ignored also, and hence all - loops can be optimized. - - According to ANSI Spec, the reverse loop case result is undefined, - because the action on overflow is undefined. - - See also the special test for NE loops below. */ - - if (final_larger == increment_dir && final_larger != 0 - && (final_larger == compare_dir || compare_dir == 0)) - /* Normal case. */ - ; - else - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop iterations: Not normal loop.\n"); - return 0; - } - - /* Calculate the number of iterations, final_value is only an approximation, - so correct for that. Note that abs_diff and n_iterations are - unsigned, because they can be as large as 2^n - 1. */ - - abs_inc = INTVAL (increment); - if (abs_inc > 0) - abs_diff = INTVAL (final_value) - INTVAL (initial_value); - else if (abs_inc < 0) - { - abs_diff = INTVAL (initial_value) - INTVAL (final_value); - abs_inc = -abs_inc; - } - else - abort (); - - /* For NE tests, make sure that the iteration variable won't miss - the final value. If abs_diff mod abs_incr is not zero, then the - iteration variable will overflow before the loop exits, and we - can not calculate the number of iterations. */ - if (compare_dir == 0 && (abs_diff % abs_inc) != 0) - return 0; - - /* Note that the number of iterations could be calculated using - (abs_diff + abs_inc - 1) / abs_inc, provided care was taken to - handle potential overflow of the summation. */ - loop_info->n_iterations = abs_diff / abs_inc + ((abs_diff % abs_inc) != 0); - return loop_info->n_iterations; -} - - -/* Replace uses of split bivs with their split pseudo register. This is - for original instructions which remain after loop unrolling without - copying. */ - -static rtx -remap_split_bivs (x) - rtx x; -{ - register enum rtx_code code; - register int i; - register char *fmt; - - if (x == 0) - return x; - - code = GET_CODE (x); - switch (code) - { - case SCRATCH: - case PC: - case CC0: - case CONST_INT: - case CONST_DOUBLE: - case CONST: - case SYMBOL_REF: - case LABEL_REF: - return x; - - case REG: -#if 0 - /* If non-reduced/final-value givs were split, then this would also - have to remap those givs also. */ -#endif - if (REGNO (x) < max_reg_before_loop - && REG_IV_TYPE (REGNO (x)) == BASIC_INDUCT) - return reg_biv_class[REGNO (x)]->biv->src_reg; - break; - - default: - break; - } - - fmt = GET_RTX_FORMAT (code); - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--) - { - if (fmt[i] == 'e') - XEXP (x, i) = remap_split_bivs (XEXP (x, i)); - if (fmt[i] == 'E') - { - register int j; - for (j = 0; j < XVECLEN (x, i); j++) - XVECEXP (x, i, j) = remap_split_bivs (XVECEXP (x, i, j)); - } - } - return x; -} - -/* If FIRST_UID is a set of REGNO, and FIRST_UID dominates LAST_UID (e.g. - FIST_UID is always executed if LAST_UID is), then return 1. Otherwise - return 0. COPY_START is where we can start looking for the insns - FIRST_UID and LAST_UID. COPY_END is where we stop looking for these - insns. - - If there is no JUMP_INSN between LOOP_START and FIRST_UID, then FIRST_UID - must dominate LAST_UID. - - If there is a CODE_LABEL between FIRST_UID and LAST_UID, then FIRST_UID - may not dominate LAST_UID. - - If there is no CODE_LABEL between FIRST_UID and LAST_UID, then FIRST_UID - must dominate LAST_UID. */ - -int -set_dominates_use (regno, first_uid, last_uid, copy_start, copy_end) - int regno; - int first_uid; - int last_uid; - rtx copy_start; - rtx copy_end; -{ - int passed_jump = 0; - rtx p = NEXT_INSN (copy_start); - - while (INSN_UID (p) != first_uid) - { - if (GET_CODE (p) == JUMP_INSN) - passed_jump= 1; - /* Could not find FIRST_UID. */ - if (p == copy_end) - return 0; - p = NEXT_INSN (p); - } - - /* Verify that FIRST_UID is an insn that entirely sets REGNO. */ - if (GET_RTX_CLASS (GET_CODE (p)) != 'i' - || ! dead_or_set_regno_p (p, regno)) - return 0; - - /* FIRST_UID is always executed. */ - if (passed_jump == 0) - return 1; - - while (INSN_UID (p) != last_uid) - { - /* If we see a CODE_LABEL between FIRST_UID and LAST_UID, then we - can not be sure that FIRST_UID dominates LAST_UID. */ - if (GET_CODE (p) == CODE_LABEL) - return 0; - /* Could not find LAST_UID, but we reached the end of the loop, so - it must be safe. */ - else if (p == copy_end) - return 1; - p = NEXT_INSN (p); - } - - /* FIRST_UID is always executed if LAST_UID is executed. */ - return 1; -} |