Return to reload.h CVS log

Up to [Apple XNU] / GNUtools / cc

Annotation of GNUtools/cc/reload.h, revision 1.1

1.1     ! root        1: /* Communication between reload.c and reload1.c.
        !             2:    Copyright (C) 1987, 1991, 1992, 1993 Free Software Foundation, Inc.
        !             3: 
        !             4: This file is part of GNU CC.
        !             5: 
        !             6: GNU CC is free software; you can redistribute it and/or modify
        !             7: it under the terms of the GNU General Public License as published by
        !             8: the Free Software Foundation; either version 2, or (at your option)
        !             9: any later version.
        !            10: 
        !            11: GNU CC is distributed in the hope that it will be useful,
        !            12: but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            14: GNU General Public License for more details.
        !            15: 
        !            16: You should have received a copy of the GNU General Public License
        !            17: along with GNU CC; see the file COPYING.  If not, write to
        !            18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
        !            19: 
        !            20: 
        !            21: /* Add prototype support.  */
        !            22: #ifndef PROTO
        !            23: #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
        !            24: #define PROTO(ARGS) ARGS
        !            25: #else
        !            26: #define PROTO(ARGS) ()
        !            27: #endif
        !            28: #endif
        !            29: 
        !            30: #ifndef STDIO_PROTO
        !            31: #ifdef BUFSIZ
        !            32: #define STDIO_PROTO(ARGS) PROTO(ARGS)
        !            33: #else
        !            34: #define STDIO_PROTO(ARGS) ()
        !            35: #endif
        !            36: #endif
        !            37: 
        !            38: /* If secondary reloads are the same for inputs and outputs, define those
        !            39:    macros here.  */
        !            40: 
        !            41: #ifdef SECONDARY_RELOAD_CLASS
        !            42: #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, X) \
        !            43:   SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
        !            44: #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, X) \
        !            45:   SECONDARY_RELOAD_CLASS (CLASS, MODE, X)
        !            46: #endif
        !            47: 
        !            48: /* If either macro is defined, show that we need secondary reloads.  */
        !            49: #if defined(SECONDARY_INPUT_RELOAD_CLASS) || defined(SECONDARY_OUTPUT_RELOAD_CLASS)
        !            50: #define HAVE_SECONDARY_RELOADS
        !            51: #endif
        !            52: 
        !            53: /* See reload.c and reload1.c for comments on these variables.  */
        !            54: 
        !            55: /* Maximum number of reloads we can need.  */
        !            56: #define MAX_RELOADS (2 * MAX_RECOG_OPERANDS * (MAX_REGS_PER_ADDRESS + 1))
        !            57: 
        !            58: extern rtx reload_in[MAX_RELOADS];
        !            59: extern rtx reload_out[MAX_RELOADS];
        !            60: extern rtx reload_in_reg[MAX_RELOADS];
        !            61: extern enum reg_class reload_reg_class[MAX_RELOADS];
        !            62: extern enum machine_mode reload_inmode[MAX_RELOADS];
        !            63: extern enum machine_mode reload_outmode[MAX_RELOADS];
        !            64: extern char reload_optional[MAX_RELOADS];
        !            65: extern int reload_inc[MAX_RELOADS];
        !            66: extern int reload_opnum[MAX_RELOADS];
        !            67: extern int reload_secondary_reload[MAX_RELOADS];
        !            68: extern int reload_secondary_p[MAX_RELOADS];
        !            69: #ifdef MAX_INSN_CODE
        !            70: extern enum insn_code reload_secondary_icode[MAX_RELOADS];
        !            71: #endif
        !            72: extern int n_reloads;
        !            73: 
        !            74: extern rtx reload_reg_rtx[MAX_RELOADS];
        !            75: 
        !            76: /* Encode the usage of a reload.  The following codes are supported:
        !            77: 
        !            78:    RELOAD_FOR_INPUT            reload of an input operand
        !            79:    RELOAD_FOR_OUTPUT           likewise, for output
        !            80:    RELOAD_FOR_INSN             a reload that must not conflict with anything
        !            81:                                used in the insn, but may conflict with
        !            82:                                something used before or after the insn
        !            83:    RELOAD_FOR_INPUT_ADDRESS    reload for parts of the address of an object
        !            84:                                that is an input reload
        !            85:    RELOAD_FOR_OUTPUT_ADDRESS   likewise, for output reload
        !            86:    RELOAD_FOR_OPERAND_ADDRESS  reload for the address of a non-reloaded
        !            87:                                operand; these don't conflict with
        !            88:                                any other addresses.
        !            89:    RELOAD_OTHER                        none of the above, usually multiple uses
        !            90:    RELOAD_FOR_OTHER_ADDRESS     reload for part of the address of an input
        !            91:                                that is marked RELOAD_OTHER.
        !            92: 
        !            93:    This used to be "enum reload_when_needed" but some debuggers have trouble
        !            94:    with an enum tag and variable of the same name.  */
        !            95: 
        !            96: enum reload_type
        !            97: {
        !            98:   RELOAD_FOR_INPUT, RELOAD_FOR_OUTPUT, RELOAD_FOR_INSN, 
        !            99:   RELOAD_FOR_INPUT_ADDRESS, RELOAD_FOR_OUTPUT_ADDRESS,
        !           100:   RELOAD_FOR_OPERAND_ADDRESS, RELOAD_OTHER, RELOAD_FOR_OTHER_ADDRESS
        !           101: };
        !           102: 
        !           103: extern enum reload_type reload_when_needed[MAX_RELOADS];
        !           104: 
        !           105: extern rtx *reg_equiv_constant;
        !           106: extern rtx *reg_equiv_memory_loc;
        !           107: extern rtx *reg_equiv_address;
        !           108: extern rtx *reg_equiv_mem;
        !           109: 
        !           110: /* All the "earlyclobber" operands of the current insn
        !           111:    are recorded here.  */
        !           112: extern int n_earlyclobbers;
        !           113: extern rtx reload_earlyclobbers[MAX_RECOG_OPERANDS];
        !           114: 
        !           115: /* Save the number of operands.  */
        !           116: extern int reload_n_operands;
        !           117: 
        !           118: /* First uid used by insns created by reload in this function.
        !           119:    Used in find_equiv_reg.  */
        !           120: extern int reload_first_uid;
        !           121: 
        !           122: /* Nonzero if indirect addressing is supported when the innermost MEM is
        !           123:    of the form (MEM (SYMBOL_REF sym)).  It is assumed that the level to
        !           124:    which these are valid is the same as spill_indirect_levels, above.   */
        !           125: 
        !           126: extern char indirect_symref_ok;
        !           127: 
        !           128: /* Nonzero if an address (plus (reg frame_pointer) (reg ...)) is valid.  */
        !           129: extern char double_reg_address_ok;
        !           130: 
        !           131: #ifdef MAX_INSN_CODE
        !           132: /* These arrays record the insn_code of insns that may be needed to
        !           133:    perform input and output reloads of special objects.  They provide a
        !           134:    place to pass a scratch register.  */
        !           135: extern enum insn_code reload_in_optab[];
        !           136: extern enum insn_code reload_out_optab[];
        !           137: #endif
        !           138: 
        !           139: /* Functions from reload.c:  */
        !           140: 
        !           141: /* Return a memory location that will be used to copy X in mode MODE.  
        !           142:    If we haven't already made a location for this mode in this insn,
        !           143:    call find_reloads_address on the location being returned.  */
        !           144: extern rtx get_secondary_mem PROTO((rtx, enum machine_mode,
        !           145:                                    int, enum reload_type));
        !           146: 
        !           147: /* Clear any secondary memory locations we've made.  */
        !           148: extern void clear_secondary_mem PROTO((void));
        !           149: 
        !           150: /* Transfer all replacements that used to be in reload FROM to be in
        !           151:    reload TO.  */
        !           152: extern void transfer_replacements PROTO((int, int));
        !           153: 
        !           154: /* Return 1 if ADDR is a valid memory address for mode MODE,
        !           155:    and check that each pseudo reg has the proper kind of
        !           156:    hard reg.  */
        !           157: extern int strict_memory_address_p PROTO((enum machine_mode, rtx));
        !           158: 
        !           159: /* Like rtx_equal_p except that it allows a REG and a SUBREG to match
        !           160:    if they are the same hard reg, and has special hacks for
        !           161:    autoincrement and autodecrement.  */
        !           162: extern int operands_match_p PROTO((rtx, rtx));
        !           163: 
        !           164: /* Return the number of times character C occurs in string S.  */
        !           165: extern int n_occurrences PROTO((int, char *));
        !           166: 
        !           167: /* Return 1 if altering OP will not modify the value of CLOBBER. */
        !           168: extern int safe_from_earlyclobber PROTO((rtx, rtx));
        !           169: 
        !           170: /* Search the body of INSN for values that need reloading and record them
        !           171:    with push_reload.  REPLACE nonzero means record also where the values occur
        !           172:    so that subst_reloads can be used.  */
        !           173: extern void find_reloads PROTO((rtx, int, int, int, short *));
        !           174: 
        !           175: /* Compute the sum of X and Y, making canonicalizations assumed in an
        !           176:    address, namely: sum constant integers, surround the sum of two
        !           177:    constants with a CONST, put the constant as the second operand, and
        !           178:    group the constant on the outermost sum.  */
        !           179: extern rtx form_sum PROTO((rtx, rtx));
        !           180: 
        !           181: /* Substitute into the current INSN the registers into which we have reloaded
        !           182:    the things that need reloading.  */
        !           183: extern void subst_reloads PROTO((void));
        !           184: 
        !           185: /* Make a copy of any replacements being done into X and move those copies
        !           186:    to locations in Y, a copy of X.  We only look at the highest level of
        !           187:    the RTL.  */
        !           188: extern void copy_replacements PROTO((rtx, rtx));
        !           189: 
        !           190: /* If LOC was scheduled to be replaced by something, return the replacement.
        !           191:    Otherwise, return *LOC.  */
        !           192: extern rtx find_replacement PROTO((rtx *));
        !           193: 
        !           194: /* Return nonzero if register in range [REGNO, ENDREGNO)
        !           195:    appears either explicitly or implicitly in X
        !           196:    other than being stored into.  */
        !           197: extern int refers_to_regno_for_reload_p PROTO((int, int, rtx, rtx *));
        !           198: 
        !           199: /* Nonzero if modifying X will affect IN.  */
        !           200: extern int reg_overlap_mentioned_for_reload_p PROTO((rtx, rtx));
        !           201: 
        !           202: /* Return nonzero if anything in X contains a MEM.  Look also for pseudo
        !           203:    registers.  */
        !           204: extern int refers_to_mem_for_reload_p PROTO((rtx));
        !           205: 
        !           206: /* Check the insns before INSN to see if there is a suitable register
        !           207:    containing the same value as GOAL.  */
        !           208: extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *,
        !           209:                                 int, enum machine_mode));
        !           210: 
        !           211: /* Return 1 if register REGNO is the subject of a clobber in insn INSN.  */
        !           212: extern int regno_clobbered_p PROTO((int, rtx));
        !           213: 
        !           214: 
        !           215: /* Functions in reload1.c:  */
        !           216: 
        !           217: /* Initialize the reload pass once per compilation.  */
        !           218: extern void init_reload PROTO((void));
        !           219: 
        !           220: /* The reload pass itself.  */
        !           221: extern int reload STDIO_PROTO((rtx, int, FILE *));
        !           222: 
        !           223: /* Mark the slots in regs_ever_live for the hard regs
        !           224:    used by pseudo-reg number REGNO.  */
        !           225: extern void mark_home_live PROTO((int));
        !           226: 
        !           227: /* Scan X and replace any eliminable registers (such as fp) with a
        !           228:    replacement (such as sp), plus an offset.  */
        !           229: extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx));
        !           230: 
        !           231: /* Emit code to perform an input reload of IN to RELOADREG.  IN is from
        !           232:    operand OPNUM with reload type TYPE.   */
        !           233: extern rtx gen_input_reload PROTO((rtx, rtx, int, enum reload_type));
        !           234: 
        !           235: /* Functions in caller-save.c:  */
        !           236: 
        !           237: /* Initialize for caller-save.  */
        !           238: extern void init_caller_save PROTO((void));
        !           239: 
        !           240: /* Initialize save areas by showing that we haven't allocated any yet.  */
        !           241: extern void init_save_areas PROTO((void));
        !           242: 
        !           243: /* Allocate save areas for any hard registers that might need saving.  */
        !           244: extern int setup_save_areas PROTO((int *));
        !           245: 
        !           246: /* Find the places where hard regs are live across calls and save them.  */
        !           247: extern void save_call_clobbered_regs PROTO((enum machine_mode));

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.