Return to regs.h CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/regs.h, revision 1.1.1.3

1.1       root        1: /* Define per-register tables for data flow info and register allocation.
1.1.1.3 ! root        2:    Copyright (C) 1987, 1993 Free Software Foundation, Inc.
1.1       root        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
1.1.1.2   root       87:    is not required.  global.c makes an allocno for this but does
1.1       root       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: 
1.1.1.2   root      111: extern int *regno_first_uid;
1.1       root      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: 
1.1.1.2   root      119: extern int *regno_last_uid;
1.1       root      120: 
1.1.1.3 ! root      121: /* Similar, but includes insns that mention the reg in their notes.  */
        !           122: 
        !           123: extern int *regno_last_note_uid;
        !           124: 
1.1       root      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
1.1.1.3 ! root      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.