Open64: osprey-gcc-4.2.0/gcc/machmode.h Source File

00001 /* Machine mode definitions for GCC; included by rtl.h and tree.h.
00002    Copyright (C) 1991, 1993, 1994, 1996, 1998, 1999, 2000, 2001, 2003
00003    Free Software Foundation, Inc.
00004 
00005 This file is part of GCC.
00006 
00007 GCC is free software; you can redistribute it and/or modify it under
00008 the terms of the GNU General Public License as published by the Free
00009 Software Foundation; either version 2, or (at your option) any later
00010 version.
00011 
00012 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
00013 WARRANTY; without even the implied warranty of MERCHANTABILITY or
00014 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
00015 for more details.
00016 
00017 You should have received a copy of the GNU General Public License
00018 along with GCC; see the file COPYING.  If not, write to the Free
00019 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
00020 02110-1301, USA.  */
00021 
00022 #ifndef HAVE_MACHINE_MODES
00023 #define HAVE_MACHINE_MODES
00024 
00025 /* Make an enum class that gives all the machine modes.  */
00026 #include "insn-modes.h"
00027 
00028 /* Get the name of mode MODE as a string.  */
00029 
00030 extern const char * const mode_name[NUM_MACHINE_MODES];
00031 #define GET_MODE_NAME(MODE)  mode_name[MODE]
00032 
00033 /* Mode classes.  */
00034 
00035 #include "mode-classes.def"
00036 #define DEF_MODE_CLASS(M) M
00037 enum mode_class { MODE_CLASSES, MAX_MODE_CLASS };
00038 #undef DEF_MODE_CLASS
00039 #undef MODE_CLASSES
00040 
00041 /* Get the general kind of object that mode MODE represents
00042    (integer, floating, complex, etc.)  */
00043 
00044 extern const unsigned char mode_class[NUM_MACHINE_MODES];
00045 #define GET_MODE_CLASS(MODE)  mode_class[MODE]
00046 
00047 /* Nonzero if MODE is an integral mode.  */
00048 #define INTEGRAL_MODE_P(MODE)     \
00049   (GET_MODE_CLASS (MODE) == MODE_INT    \
00050    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT \
00051    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
00052    || GET_MODE_CLASS (MODE) == MODE_VECTOR_INT)
00053 
00054 /* Nonzero if MODE is a floating-point mode.  */
00055 #define FLOAT_MODE_P(MODE)    \
00056   (GET_MODE_CLASS (MODE) == MODE_FLOAT  \
00057    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT \
00058    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
00059    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
00060 
00061 /* Nonzero if MODE is a complex mode.  */
00062 #define COMPLEX_MODE_P(MODE)      \
00063   (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT  \
00064    || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT)
00065 
00066 /* Nonzero if MODE is a vector mode.  */
00067 #define VECTOR_MODE_P(MODE)     \
00068   (GET_MODE_CLASS (MODE) == MODE_VECTOR_INT \
00069    || GET_MODE_CLASS (MODE) == MODE_VECTOR_FLOAT)
00070 
00071 /* Nonzero if MODE is a scalar integral mode.  */
00072 #define SCALAR_INT_MODE_P(MODE)     \
00073   (GET_MODE_CLASS (MODE) == MODE_INT    \
00074    || GET_MODE_CLASS (MODE) == MODE_PARTIAL_INT)
00075 
00076 /* Nonzero if MODE is a scalar floating point mode.  */
00077 #define SCALAR_FLOAT_MODE_P(MODE)   \
00078   (GET_MODE_CLASS (MODE) == MODE_FLOAT    \
00079    || GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
00080 
00081 /* Nonzero if MODE is a decimal floating point mode.  */
00082 #define DECIMAL_FLOAT_MODE_P(MODE)    \
00083   (GET_MODE_CLASS (MODE) == MODE_DECIMAL_FLOAT)
00084 
00085 /* Nonzero if CLASS modes can be widened.  */
00086 #define CLASS_HAS_WIDER_MODES_P(CLASS)         \
00087   (CLASS == MODE_INT                           \
00088    || CLASS == MODE_FLOAT                      \
00089    || CLASS == MODE_DECIMAL_FLOAT              \
00090    || CLASS == MODE_COMPLEX_FLOAT)
00091 
00092 /* Get the size in bytes and bits of an object of mode MODE.  */
00093 
00094 extern CONST_MODE_SIZE unsigned char mode_size[NUM_MACHINE_MODES];
00095 #define GET_MODE_SIZE(MODE)    ((unsigned short) mode_size[MODE])
00096 #define GET_MODE_BITSIZE(MODE) ((unsigned short) (GET_MODE_SIZE (MODE) * BITS_PER_UNIT))
00097 
00098 /* Get the number of value bits of an object of mode MODE.  */
00099 extern const unsigned short mode_precision[NUM_MACHINE_MODES];
00100 #define GET_MODE_PRECISION(MODE)  mode_precision[MODE]
00101 
00102 /* Get a bitmask containing 1 for all bits in a word
00103    that fit within mode MODE.  */
00104 
00105 extern const unsigned HOST_WIDE_INT mode_mask_array[NUM_MACHINE_MODES];
00106 
00107 #define GET_MODE_MASK(MODE) mode_mask_array[MODE]
00108 
00109 /* Return the mode of the inner elements in a vector.  */
00110 
00111 extern const unsigned char mode_inner[NUM_MACHINE_MODES];
00112 #define GET_MODE_INNER(MODE) mode_inner[MODE]
00113 
00114 /* Get the size in bytes of the basic parts of an object of mode MODE.  */
00115 
00116 #define GET_MODE_UNIT_SIZE(MODE)    \
00117   (GET_MODE_INNER (MODE) == VOIDmode    \
00118    ? GET_MODE_SIZE (MODE)     \
00119    : GET_MODE_SIZE (GET_MODE_INNER (MODE)))
00120 
00121 /* Get the number of units in the object.  */
00122 
00123 extern const unsigned char mode_nunits[NUM_MACHINE_MODES];
00124 #define GET_MODE_NUNITS(MODE)  mode_nunits[MODE]
00125 
00126 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
00127 
00128 extern const unsigned char mode_wider[NUM_MACHINE_MODES];
00129 #define GET_MODE_WIDER_MODE(MODE) mode_wider[MODE]
00130 
00131 extern const unsigned char mode_2xwider[NUM_MACHINE_MODES];
00132 #define GET_MODE_2XWIDER_MODE(MODE) mode_2xwider[MODE]
00133 
00134 /* Return the mode for data of a given size SIZE and mode class CLASS.
00135    If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
00136    The value is BLKmode if no other mode is found.  */
00137 
00138 extern enum machine_mode mode_for_size (unsigned int, enum mode_class, int);
00139 
00140 /* Similar, but find the smallest mode for a given width.  */
00141 
00142 extern enum machine_mode smallest_mode_for_size (unsigned int,
00143              enum mode_class);
00144 
00145 
00146 /* Return an integer mode of the exact same size as the input mode,
00147    or BLKmode on failure.  */
00148 
00149 extern enum machine_mode int_mode_for_mode (enum machine_mode);
00150 
00151 /* Find the best mode to use to access a bit field.  */
00152 
00153 extern enum machine_mode get_best_mode (int, int, unsigned int,
00154           enum machine_mode, int);
00155 
00156 /* Determine alignment, 1<=result<=BIGGEST_ALIGNMENT.  */
00157 
00158 extern CONST_MODE_BASE_ALIGN unsigned char mode_base_align[NUM_MACHINE_MODES];
00159 
00160 extern unsigned get_mode_alignment (enum machine_mode);
00161 
00162 #define GET_MODE_ALIGNMENT(MODE) get_mode_alignment (MODE)
00163 
00164 /* For each class, get the narrowest mode in that class.  */
00165 
00166 extern const unsigned char class_narrowest_mode[MAX_MODE_CLASS];
00167 #define GET_CLASS_NARROWEST_MODE(CLASS) class_narrowest_mode[CLASS]
00168 
00169 /* Define the integer modes whose sizes are BITS_PER_UNIT and BITS_PER_WORD
00170    and the mode whose class is Pmode and whose size is POINTER_SIZE.  */
00171 
00172 extern enum machine_mode byte_mode;
00173 extern enum machine_mode word_mode;
00174 extern enum machine_mode ptr_mode;
00175 
00176 /* Target-dependent machine mode initialization - in insn-modes.c.  */
00177 extern void init_adjust_machine_modes (void);
00178 
00179 #endif /* not HAVE_MACHINE_MODES */