This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]

BImode


This is the first in a series of patches to add a mode describing
a single bit -- BImode.  It is intended to be used by targets to
describe predicate registers.  Using CCmode for these has the
disadvantage that we carry around baggage required for more traditional
flags registers, which cannot be optimized in the same way.

The patches were done by Jim Wilson and myself for IA-64, but the use
of BImode would also be appropriate on at least d10v, d30v and sh.

The following only adds the mode itself, and one bit to prevent
misoptimization in combine.



r~


        * machmode.def: Add BImode.  Add a column for bitsize.
        * machmode.h (DEF_MACHMODE): Adjust for extra column.
        (GET_MODE_BITSIZE): Use it.
        * rtl.c (DEF_MACHMODE): Adjust for extra column.
        (mode_bitsize): New.
        (mode_mask_array): Use bitsize.
        * combine.c (combine_simplify_rtx): Require inner and outer
        modes to match on nonzero_bits optimizations.

Index: combine.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/combine.c,v
retrieving revision 1.150
diff -c -p -d -r1.150 combine.c
*** combine.c	2000/09/11 20:20:32	1.150
--- combine.c	2000/09/18 17:37:56
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4347,4359 ****
  
  	  if (STORE_FLAG_VALUE == 1
  	      && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
! 	      && op1 == const0_rtx && nonzero_bits (op0, mode) == 1)
  	    return gen_lowpart_for_combine (mode,
  					    expand_compound_operation (op0));
  
  	  else if (STORE_FLAG_VALUE == 1
  		   && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
  		   && (num_sign_bit_copies (op0, mode)
  		       == GET_MODE_BITSIZE (mode)))
  	    {
--- 4364,4379 ----
  
  	  if (STORE_FLAG_VALUE == 1
  	      && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
! 	      && op1 == const0_rtx
! 	      && mode == GET_MODE (op0)
! 	      && nonzero_bits (op0, mode) == 1)
  	    return gen_lowpart_for_combine (mode,
  					    expand_compound_operation (op0));
  
  	  else if (STORE_FLAG_VALUE == 1
  		   && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && (num_sign_bit_copies (op0, mode)
  		       == GET_MODE_BITSIZE (mode)))
  	    {
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4365,4370 ****
--- 4385,4391 ----
  	  else if (STORE_FLAG_VALUE == 1
  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && nonzero_bits (op0, mode) == 1)
  	    {
  	      op0 = expand_compound_operation (op0);
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4376,4381 ****
--- 4397,4403 ----
  	  else if (STORE_FLAG_VALUE == 1
  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && (num_sign_bit_copies (op0, mode)
  		       == GET_MODE_BITSIZE (mode)))
  	    {
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4396,4401 ****
--- 4418,4424 ----
  	  else if (STORE_FLAG_VALUE == -1
  		   && new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && nonzero_bits (op0, mode) == 1)
  	    {
  	      op0 = expand_compound_operation (op0);
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4406,4411 ****
--- 4429,4435 ----
  	  else if (STORE_FLAG_VALUE == -1
  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && (num_sign_bit_copies (op0, mode)
  		       == GET_MODE_BITSIZE (mode)))
  	    {
*************** combine_simplify_rtx (x, op0_mode, last,
*** 4418,4423 ****
--- 4442,4448 ----
  	  else if (STORE_FLAG_VALUE == -1
  		   && new_code == EQ && GET_MODE_CLASS (mode) == MODE_INT
  		   && op1 == const0_rtx
+ 		   && mode == GET_MODE (op0)
  		   && nonzero_bits (op0, mode) == 1)
  	    {
  	      op0 = expand_compound_operation (op0);
Index: machmode.def
===================================================================
RCS file: /cvs/gcc/egcs/gcc/machmode.def,v
retrieving revision 1.7
diff -c -p -d -r1.7 machmode.def
*** machmode.def	2000/06/24 11:12:58	1.7
--- machmode.def	2000/09/18 17:37:56
*************** Boston, MA 02111-1307, USA.  */
*** 48,145 ****
     MODE_VECTOR_INT, MODE_VECTOR_FLOAT - vector
     MODE_RANDOM - anything else
  
!    Fourth argument is the relative size of the object, in bytes.
     It is zero when the size is meaningless or not determined.
     A byte's size is determined by BITS_PER_UNIT in tm.h. 
  
! 
!    Fifth arg is the relative size of subunits of the object.
     It is same as the fourth argument except for complexes,
     since they are really made of two equal size subunits.
  
!    Sixth arg is next wider natural mode of the same class.
     0 if there is none.  */
  
  /* VOIDmode is used when no mode needs to be specified,
     as for example on CONST_INT RTL expressions.  */
! DEF_MACHMODE (VOIDmode, "VOID", MODE_RANDOM, 0, 0, VOIDmode)
  
! DEF_MACHMODE (PQImode, "PQI", MODE_PARTIAL_INT, 1, 1, PHImode)
! DEF_MACHMODE (QImode, "QI", MODE_INT, 1, 1, HImode)		/* int types */
! DEF_MACHMODE (PHImode, "PHI", MODE_PARTIAL_INT, 2, 2, PSImode)
! DEF_MACHMODE (HImode, "HI", MODE_INT, 2, 2, SImode)
! /* Pointers on some machines use this type to distinguish them from ints.
!    Useful if a pointer is 4 bytes but has some bits that are not significant,
!    so it is really not quite as wide as an integer.  */
! DEF_MACHMODE (PSImode, "PSI", MODE_PARTIAL_INT, 4, 4, PDImode)
! DEF_MACHMODE (SImode, "SI", MODE_INT, 4, 4, DImode)
! DEF_MACHMODE (PDImode, "PDI", MODE_PARTIAL_INT, 8, 8, VOIDmode)
! DEF_MACHMODE (DImode, "DI", MODE_INT, 8, 8, TImode)
! DEF_MACHMODE (TImode, "TI", MODE_INT, 16, 16, OImode)
! DEF_MACHMODE (OImode, "OI", MODE_INT, 32, 32, VOIDmode)
  
! DEF_MACHMODE (QFmode, "QF", MODE_FLOAT, 1, 1, HFmode)
! DEF_MACHMODE (HFmode, "HF", MODE_FLOAT, 2, 2, TQFmode)
! DEF_MACHMODE (TQFmode, "TQF", MODE_FLOAT, 3, 3, SFmode)  /* MIL-STD-1750A */
! DEF_MACHMODE (SFmode, "SF", MODE_FLOAT, 4, 4, DFmode)
! DEF_MACHMODE (DFmode, "DF", MODE_FLOAT, 8, 8, XFmode)
! DEF_MACHMODE (XFmode, "XF", MODE_FLOAT, 12, 12, TFmode)   /* IEEE extended */
! DEF_MACHMODE (TFmode, "TF", MODE_FLOAT, 16, 16, VOIDmode)
  
  /* Complex modes.  */
! DEF_MACHMODE (QCmode, "QC", MODE_COMPLEX_FLOAT, 2, 1, HCmode)
! DEF_MACHMODE (HCmode, "HC", MODE_COMPLEX_FLOAT, 4, 2, SCmode)
! DEF_MACHMODE (SCmode, "SC", MODE_COMPLEX_FLOAT, 8, 4, DCmode)
! DEF_MACHMODE (DCmode, "DC", MODE_COMPLEX_FLOAT, 16, 8, XCmode)
! DEF_MACHMODE (XCmode, "XC", MODE_COMPLEX_FLOAT, 24, 12, TCmode)
! DEF_MACHMODE (TCmode, "TC", MODE_COMPLEX_FLOAT, 32, 16, VOIDmode)
  
! DEF_MACHMODE (CQImode, "CQI", MODE_COMPLEX_INT, 2, 1, CHImode)
! DEF_MACHMODE (CHImode, "CHI", MODE_COMPLEX_INT, 4, 2, CSImode)
! DEF_MACHMODE (CSImode, "CSI", MODE_COMPLEX_INT, 8, 4, CDImode)
! DEF_MACHMODE (CDImode, "CDI", MODE_COMPLEX_INT, 16, 8, CTImode)
! DEF_MACHMODE (CTImode, "CTI", MODE_COMPLEX_INT, 32, 16, COImode)
! DEF_MACHMODE (COImode, "COI", MODE_COMPLEX_INT, 64, 32, VOIDmode)
  
  /* Vector modes.  */
! /* There are no V1xx vector modes.  These are equivalent to normal non-vector
!    modes.  */
! DEF_MACHMODE (V2QImode, "V2QI", MODE_VECTOR_INT, 2, 1, VOIDmode)
! DEF_MACHMODE (V2HImode, "V2HI", MODE_VECTOR_INT, 4, 2, VOIDmode)
! DEF_MACHMODE (V2SImode, "V2SI", MODE_VECTOR_INT, 8, 4, VOIDmode)
! DEF_MACHMODE (V2DImode, "V2DI", MODE_VECTOR_INT, 16, 8, VOIDmode)
  
! DEF_MACHMODE (V4QImode, "V4QI", MODE_VECTOR_INT, 4, 1, VOIDmode)
! DEF_MACHMODE (V4HImode, "V4HI", MODE_VECTOR_INT, 8, 2, VOIDmode)
! DEF_MACHMODE (V4SImode, "V4SI", MODE_VECTOR_INT, 16, 4, VOIDmode)
! DEF_MACHMODE (V4DImode, "V4DI", MODE_VECTOR_INT, 32, 8, VOIDmode)
  
! DEF_MACHMODE (V8QImode, "V8QI", MODE_VECTOR_INT, 8, 1, VOIDmode)
! DEF_MACHMODE (V8HImode, "V8HI", MODE_VECTOR_INT, 16, 2, VOIDmode)
! DEF_MACHMODE (V8SImode, "V8SI", MODE_VECTOR_INT, 32, 4, VOIDmode)
! DEF_MACHMODE (V8DImode, "V8DI", MODE_VECTOR_INT, 64, 8, VOIDmode)
  
! DEF_MACHMODE (V2SFmode, "V2SF", MODE_VECTOR_FLOAT, 8, 4, VOIDmode)
! DEF_MACHMODE (V2DFmode, "V2DF", MODE_VECTOR_FLOAT, 16, 8, VOIDmode)
  
! DEF_MACHMODE (V4SFmode, "V4SF", MODE_VECTOR_FLOAT, 16, 4, VOIDmode)
! DEF_MACHMODE (V4DFmode, "V4DF", MODE_VECTOR_FLOAT, 32, 8, VOIDmode)
  
! DEF_MACHMODE (V8SFmode, "V8SF", MODE_VECTOR_FLOAT, 32, 4, VOIDmode)
! DEF_MACHMODE (V8DFmode, "V8DF", MODE_VECTOR_FLOAT, 64, 8, VOIDmode)
  
  /* BLKmode is used for structures, arrays, etc.
     that fit no more specific mode.  */
! DEF_MACHMODE (BLKmode, "BLK", MODE_RANDOM, 0, 0, VOIDmode)
  
! /* The modes for representing the condition codes come last.  CCmode is
!    always defined.  Additional modes for the condition code can be specified
!    in the EXTRA_CC_MODES macro.
!    All MODE_CC modes are the same width as SImode and have VOIDmode as their
!    next wider mode.
! */
  
! #define CC(E, M)  DEF_MACHMODE (E, M, MODE_CC, 4, 4, VOIDmode)
  
  CC (CCmode, "CC")
  
--- 48,147 ----
     MODE_VECTOR_INT, MODE_VECTOR_FLOAT - vector
     MODE_RANDOM - anything else
  
!    Fourth argument is the relative size of the object, in bits,
!    so we can have modes smaller than 1 byte.
! 
!    Fifth argument is the relative size of the object, in bytes.
     It is zero when the size is meaningless or not determined.
     A byte's size is determined by BITS_PER_UNIT in tm.h. 
  
!    Sixth arg is the relative size of subunits of the object.
     It is same as the fourth argument except for complexes,
     since they are really made of two equal size subunits.
  
!    Seventh arg is next wider natural mode of the same class.
     0 if there is none.  */
  
  /* VOIDmode is used when no mode needs to be specified,
     as for example on CONST_INT RTL expressions.  */
! DEF_MACHMODE (VOIDmode, "VOID", MODE_RANDOM, 0, 0, 0, VOIDmode)
  
! DEF_MACHMODE (BImode, "BI", MODE_INT, 1, 1, 1, QImode)
! DEF_MACHMODE (QImode, "QI", MODE_INT, 8, 1, 1, HImode)
! DEF_MACHMODE (HImode, "HI", MODE_INT, 16, 2, 2, SImode)
! DEF_MACHMODE (SImode, "SI", MODE_INT, 32, 4, 4, DImode)
! DEF_MACHMODE (DImode, "DI", MODE_INT, 64, 8, 8, TImode)
! DEF_MACHMODE (TImode, "TI", MODE_INT, 128, 16, 16, OImode)
! DEF_MACHMODE (OImode, "OI", MODE_INT, 256, 32, 32, VOIDmode)
  
! /* Pointers on some machines use these types to distinguish them from
!    ints.  Useful if a pointer is 4 bytes but has some bits that are
!    not significant, so it is really not quite as wide as an integer.  */
! DEF_MACHMODE (PQImode, "PQI", MODE_PARTIAL_INT, 8, 1, 1, PHImode)
! DEF_MACHMODE (PHImode, "PHI", MODE_PARTIAL_INT, 16, 2, 2, PSImode)
! DEF_MACHMODE (PSImode, "PSI", MODE_PARTIAL_INT, 32, 4, 4, PDImode)
! DEF_MACHMODE (PDImode, "PDI", MODE_PARTIAL_INT, 64, 8, 8, VOIDmode)
  
+ DEF_MACHMODE (QFmode, "QF", MODE_FLOAT, 8, 1, 1, HFmode)
+ DEF_MACHMODE (HFmode, "HF", MODE_FLOAT, 16, 2, 2, TQFmode)
+ DEF_MACHMODE (TQFmode, "TQF", MODE_FLOAT, 24, 3, 3, SFmode) /* MIL-STD-1750A */
+ DEF_MACHMODE (SFmode, "SF", MODE_FLOAT, 32, 4, 4, DFmode)
+ DEF_MACHMODE (DFmode, "DF", MODE_FLOAT, 64, 8, 8, XFmode)
+ DEF_MACHMODE (XFmode, "XF", MODE_FLOAT, 96, 12, 12, TFmode) /* IEEE extended */
+ DEF_MACHMODE (TFmode, "TF", MODE_FLOAT, 128, 16, 16, VOIDmode)
+ 
  /* Complex modes.  */
! DEF_MACHMODE (QCmode, "QC", MODE_COMPLEX_FLOAT, 16, 2, 1, HCmode)
! DEF_MACHMODE (HCmode, "HC", MODE_COMPLEX_FLOAT, 32, 4, 2, SCmode)
! DEF_MACHMODE (SCmode, "SC", MODE_COMPLEX_FLOAT, 64, 8, 4, DCmode)
! DEF_MACHMODE (DCmode, "DC", MODE_COMPLEX_FLOAT, 128, 16, 8, XCmode)
! DEF_MACHMODE (XCmode, "XC", MODE_COMPLEX_FLOAT, 192, 24, 12, TCmode)
! DEF_MACHMODE (TCmode, "TC", MODE_COMPLEX_FLOAT, 256, 32, 16, VOIDmode)
  
! DEF_MACHMODE (CQImode, "CQI", MODE_COMPLEX_INT, 16, 2, 1, CHImode)
! DEF_MACHMODE (CHImode, "CHI", MODE_COMPLEX_INT, 32, 4, 2, CSImode)
! DEF_MACHMODE (CSImode, "CSI", MODE_COMPLEX_INT, 64, 8, 4, CDImode)
! DEF_MACHMODE (CDImode, "CDI", MODE_COMPLEX_INT, 128, 16, 8, CTImode)
! DEF_MACHMODE (CTImode, "CTI", MODE_COMPLEX_INT, 256, 32, 16, COImode)
! DEF_MACHMODE (COImode, "COI", MODE_COMPLEX_INT, 512, 64, 32, VOIDmode)
  
  /* Vector modes.  */
! /* There are no V1xx vector modes.  These are equivalent to normal
!    scalar modes.  */
! DEF_MACHMODE (V2QImode, "V2QI", MODE_VECTOR_INT, 16, 2, 1, VOIDmode)
! DEF_MACHMODE (V2HImode, "V2HI", MODE_VECTOR_INT, 32, 4, 2, VOIDmode)
! DEF_MACHMODE (V2SImode, "V2SI", MODE_VECTOR_INT, 64, 8, 4, VOIDmode)
! DEF_MACHMODE (V2DImode, "V2DI", MODE_VECTOR_INT, 128, 16, 8, VOIDmode)
  
! DEF_MACHMODE (V4QImode, "V4QI", MODE_VECTOR_INT, 32, 4, 1, VOIDmode)
! DEF_MACHMODE (V4HImode, "V4HI", MODE_VECTOR_INT, 64, 8, 2, VOIDmode)
! DEF_MACHMODE (V4SImode, "V4SI", MODE_VECTOR_INT, 128, 16, 4, VOIDmode)
! DEF_MACHMODE (V4DImode, "V4DI", MODE_VECTOR_INT, 256, 32, 8, VOIDmode)
  
! DEF_MACHMODE (V8QImode, "V8QI", MODE_VECTOR_INT, 64, 8, 1, VOIDmode)
! DEF_MACHMODE (V8HImode, "V8HI", MODE_VECTOR_INT, 128, 16, 2, VOIDmode)
! DEF_MACHMODE (V8SImode, "V8SI", MODE_VECTOR_INT, 256, 32, 4, VOIDmode)
! DEF_MACHMODE (V8DImode, "V8DI", MODE_VECTOR_INT, 512, 64, 8, VOIDmode)
  
! DEF_MACHMODE (V2SFmode, "V2SF", MODE_VECTOR_FLOAT, 64, 8, 4, VOIDmode)
! DEF_MACHMODE (V2DFmode, "V2DF", MODE_VECTOR_FLOAT, 128, 16, 8, VOIDmode)
  
! DEF_MACHMODE (V4SFmode, "V4SF", MODE_VECTOR_FLOAT, 128, 16, 4, VOIDmode)
! DEF_MACHMODE (V4DFmode, "V4DF", MODE_VECTOR_FLOAT, 256, 32, 8, VOIDmode)
  
! DEF_MACHMODE (V8SFmode, "V8SF", MODE_VECTOR_FLOAT, 256, 32, 4, VOIDmode)
! DEF_MACHMODE (V8DFmode, "V8DF", MODE_VECTOR_FLOAT, 512, 64, 8, VOIDmode)
  
  /* BLKmode is used for structures, arrays, etc.
     that fit no more specific mode.  */
! DEF_MACHMODE (BLKmode, "BLK", MODE_RANDOM, 0, 0, 0, VOIDmode)
  
! /* The modes for representing the condition codes come last.  CCmode
!    is always defined.  Additional modes for the condition code can be
!    specified in the EXTRA_CC_MODES macro.  All MODE_CC modes are the
!    same width as SImode and have VOIDmode as their next wider mode.  */
  
! #define CC(E, M)  DEF_MACHMODE (E, M, MODE_CC, 32, 4, 4, VOIDmode)
  
  CC (CCmode, "CC")
  
Index: machmode.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/machmode.h,v
retrieving revision 1.23
diff -c -p -d -r1.23 machmode.h
*** machmode.h	2000/06/24 11:12:58	1.23
--- machmode.h	2000/09/18 17:37:56
*************** Boston, MA 02111-1307, USA.  */
*** 24,30 ****
  
  /* Make an enum class that gives all the machine modes.  */
  
! #define DEF_MACHMODE(SYM, NAME, TYPE, SIZE, UNIT, WIDER)  SYM,
  
  enum machine_mode {
  #include "machmode.def"
--- 24,30 ----
  
  /* Make an enum class that gives all the machine modes.  */
  
! #define DEF_MACHMODE(SYM, NAME, TYPE, BITSIZE, SIZE, UNIT, WIDER)  SYM,
  
  enum machine_mode {
  #include "machmode.def"
*************** extern const unsigned int mode_unit_size
*** 93,99 ****
  
  /* Get the size in bits of an object of mode MODE.  */
  
! #define GET_MODE_BITSIZE(MODE)  (BITS_PER_UNIT * mode_size[(int) (MODE)])
  
  #ifdef HOST_WIDE_INT
  
--- 93,100 ----
  
  /* Get the size in bits of an object of mode MODE.  */
  
! extern const unsigned int mode_bitsize[];
! #define GET_MODE_BITSIZE(MODE)  (mode_bitsize[(int) (MODE)])
  
  #ifdef HOST_WIDE_INT
  
Index: rtl.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/rtl.c,v
retrieving revision 1.78
diff -c -p -d -r1.78 rtl.c
*** rtl.c	2000/09/07 09:02:02	1.78
--- rtl.c	2000/09/18 17:48:52
*************** const char * const rtx_name[] = {
*** 128,134 ****
  /* 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,
  
  const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
  #include "machmode.def"
--- 128,134 ----
  /* 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, BITSIZE, SIZE, UNIT, WIDER)  NAME,
  
  const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
  #include "machmode.def"
*************** const char * const mode_name[(int) MAX_M
*** 139,148 ****
  
  #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,
  
  const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"
--- 139,147 ----
  
  #undef DEF_MACHMODE
  
! /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS.  */
  
! #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  CLASS,
  
  const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"
*************** const enum mode_class mode_class[(int) M
*** 150,159 ****
  
  #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,
  
  const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"
--- 149,169 ----
  
  #undef DEF_MACHMODE
  
+ /* Indexed by machine mode, gives the length of the mode, in bits.
+    GET_MODE_BITSIZE uses this.  */
+ 
+ #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  BITSIZE,
+ 
+ const unsigned int mode_bitsize[(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, BITSIZE, SIZE, UNIT, WIDER)  SIZE,
  
  const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"
*************** const unsigned int mode_size[(int) MAX_M
*** 164,170 ****
  /* 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,
  
  const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"		/* machine modes are documented here */
--- 174,180 ----
  /* Indexed by machine mode, gives the length of the mode's subunit.
     GET_MODE_UNIT_SIZE uses this.  */
  
! #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  UNIT,
  
  const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
  #include "machmode.def"		/* machine modes are documented here */
*************** const unsigned int mode_unit_size[(int) 
*** 176,182 ****
     (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
     use this.  */
  
! #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
    (unsigned char) WIDER,
  
  const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
--- 186,192 ----
     (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
     use this.  */
  
! #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
    (unsigned char) WIDER,
  
  const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
*************** const unsigned char mode_wider_mode[(int
*** 185,192 ****
  
  #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.  */
  
--- 195,202 ----
  
  #undef DEF_MACHMODE
  
! #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER)  \
!   ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
  
  /* Indexed by machine mode, gives mask of significant bits in mode.  */
  
*************** const unsigned HOST_WIDE_INT mode_mask_a
*** 196,202 ****
  
  /* Indexed by mode class, gives the narrowest mode for each class.
     The Q modes are always of width 1 (2 for complex) - it is impossible
!    for any mode to be narrower.  */
  
  const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
      /* MODE_RANDOM */		VOIDmode,
--- 206,217 ----
  
  /* Indexed by mode class, gives the narrowest mode for each class.
     The Q modes are always of width 1 (2 for complex) - it is impossible
!    for any mode to be narrower.
! 
!    Note that we use QImode instead of BImode for MODE_INT, since
!    otherwise the middle end will try to use it for bitfields in
!    structures and the like, which we do not want.  Only the target
!    md file should generate BImode widgets.  */
  
  const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
      /* MODE_RANDOM */		VOIDmode,

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]