Return to regs.h CVS log

Up to [Apple XNU] / GNUtools / cc

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

1.1     ! root        1: /* Define per-register tables for data flow info and register allocation.
        !             2:    Copyright (C) 1987, 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: 
        !            22: #define REG_BYTES(R) mode_size[(int) GET_MODE (R)]
        !            23: 
        !            24: /* Get the number of consecutive hard regs required to hold the REG rtx R.
        !            25:    When something may be an explicit hard reg, REG_SIZE is the only
        !            26:    valid way to get this value.  You cannot get it from the regno.  */
        !            27: 
        !            28: #define REG_SIZE(R) \
        !            29:   ((mode_size[(int) GET_MODE (R)] + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
        !            30: 
        !            31: /* Maximum register number used in this function, plus one.  */
        !            32: 
        !            33: extern int max_regno;
        !            34: 
        !            35: /* Maximum number of SCRATCH rtx's in each block of this function.  */
        !            36: 
        !            37: extern int max_scratch;
        !            38: 
        !            39: /* Indexed by n, gives number of times (REG n) is used or set.
        !            40:    References within loops may be counted more times.  */
        !            41: 
        !            42: extern int *reg_n_refs;
        !            43: 
        !            44: /* Indexed by n, gives number of times (REG n) is set.  */
        !            45: 
        !            46: extern short *reg_n_sets;
        !            47: 
        !            48: /* Indexed by N, gives number of insns in which register N dies.
        !            49:    Note that if register N is live around loops, it can die
        !            50:    in transitions between basic blocks, and that is not counted here.
        !            51:    So this is only a reliable indicator of how many regions of life there are
        !            52:    for registers that are contained in one basic block.  */
        !            53: 
        !            54: extern short *reg_n_deaths;
        !            55: 
        !            56: /* Get the number of consecutive words required to hold pseudo-reg N.  */
        !            57: 
        !            58: #define PSEUDO_REGNO_SIZE(N) \
        !            59:   ((GET_MODE_SIZE (PSEUDO_REGNO_MODE (N)) + UNITS_PER_WORD - 1)                \
        !            60:    / UNITS_PER_WORD)
        !            61: 
        !            62: /* Get the number of bytes required to hold pseudo-reg N.  */
        !            63: 
        !            64: #define PSEUDO_REGNO_BYTES(N) \
        !            65:   GET_MODE_SIZE (PSEUDO_REGNO_MODE (N))
        !            66: 
        !            67: /* Get the machine mode of pseudo-reg N.  */
        !            68: 
        !            69: #define PSEUDO_REGNO_MODE(N) GET_MODE (regno_reg_rtx[N])
        !            70: 
        !            71: /* Indexed by N, gives number of CALL_INSNS across which (REG n) is live.  */
        !            72: 
        !            73: extern int *reg_n_calls_crossed;
        !            74: 
        !            75: /* Total number of instructions at which (REG n) is live.
        !            76:    The larger this is, the less priority (REG n) gets for
        !            77:    allocation in a hard register (in global-alloc).
        !            78:    This is set in flow.c and remains valid for the rest of the compilation
        !            79:    of the function; it is used to control register allocation.
        !            80: 
        !            81:    local-alloc.c may alter this number to change the priority.
        !            82: 
        !            83:    Negative values are special.
        !            84:    -1 is used to mark a pseudo reg which has a constant or memory equivalent
        !            85:    and is used infrequently enough that it should not get a hard register.
        !            86:    -2 is used to mark a pseudo reg for a parameter, when a frame pointer
        !            87:    is not required.  global.c makes an allocno for this but does
        !            88:    not try to assign a hard register to it.  */
        !            89: 
        !            90: extern int *reg_live_length;
        !            91: 
        !            92: /* Vector of substitutions of register numbers,
        !            93:    used to map pseudo regs into hardware regs.  */
        !            94: 
        !            95: extern short *reg_renumber;
        !            96: 
        !            97: /* Vector indexed by hardware reg
        !            98:    saying whether that reg is ever used.  */
        !            99: 
        !           100: extern char regs_ever_live[FIRST_PSEUDO_REGISTER];
        !           101: 
        !           102: /* Vector indexed by hardware reg giving its name.  */
        !           103: 
        !           104: extern char *reg_names[FIRST_PSEUDO_REGISTER];
        !           105: 
        !           106: /* Vector indexed by regno; gives uid of first insn using that reg.
        !           107:    This is computed by reg_scan for use by cse and loop.
        !           108:    It is sometimes adjusted for subsequent changes during loop,
        !           109:    but not adjusted by cse even if cse invalidates it.  */
        !           110: 
        !           111: extern int *regno_first_uid;
        !           112: 
        !           113: /* Vector indexed by regno; gives uid of last insn using that reg.
        !           114:    This is computed by reg_scan for use by cse and loop.
        !           115:    It is sometimes adjusted for subsequent changes during loop,
        !           116:    but not adjusted by cse even if cse invalidates it.
        !           117:    This is harmless since cse won't scan through a loop end.  */
        !           118: 
        !           119: extern int *regno_last_uid;
        !           120: 
        !           121: /* Similar, but includes insns that mention the reg in their notes.  */
        !           122: 
        !           123: extern int *regno_last_note_uid;
        !           124: 
        !           125: /* Vector indexed by regno; contains 1 for a register is considered a pointer.
        !           126:    Reloading, etc. will use a pointer register rather than a non-pointer
        !           127:    as the base register in an address, when there is a choice of two regs.  */
        !           128: 
        !           129: extern char *regno_pointer_flag;
        !           130: #define REGNO_POINTER_FLAG(REGNO) regno_pointer_flag[REGNO]
        !           131: 
        !           132: /* List made of EXPR_LIST rtx's which gives pairs of pseudo registers
        !           133:    that have to go in the same hard reg.  */
        !           134: extern rtx regs_may_share;
        !           135: 
        !           136: /* Vector mapping pseudo regno into the REG rtx for that register.
        !           137:    This is computed by reg_scan.  */
        !           138: 
        !           139: extern rtx *regno_reg_rtx;
        !           140: 
        !           141: /* Flag set by local-alloc or global-alloc if they decide to allocate
        !           142:    something in a call-clobbered register.  */
        !           143: 
        !           144: extern int caller_save_needed;
        !           145: 
        !           146: /* Predicate to decide whether to give a hard reg to a pseudo which
        !           147:    is referenced REFS times and would need to be saved and restored
        !           148:    around a call CALLS times.  */
        !           149: 
        !           150: #ifndef CALLER_SAVE_PROFITABLE
        !           151: #define CALLER_SAVE_PROFITABLE(REFS, CALLS)  (4 * (CALLS) < (REFS))
        !           152: #endif
        !           153: 
        !           154: /* Allocated in local_alloc.  */
        !           155: 
        !           156: /* A list of SCRATCH rtl allocated by local-alloc.  */
        !           157: extern rtx *scratch_list;
        !           158: /* The basic block in which each SCRATCH is used.  */
        !           159: extern int *scratch_block;
        !           160: /* The length of the arrays pointed to by scratch_block and scratch_list.  */
        !           161: extern int scratch_list_length;

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