[spu, commit] Enable TImode vs. float conversion routines in libgcc

[spu, commit] Enable TImode vs. float conversion routines in libgcc

[Ulrich Weigand]

Hello,

on the SPU, we have the peculiar situation that while word size is
128 bit (since this is actually the register size), we're still
bascially a 32-bit architecture as far as ISA and ABI are concerned.

This has the effect that the back-end must generally support TImode
arithmetic (since many parts of the compiler expect arithmetic to
work at least up to the word size), but this is not just twice, but
four times the size of what most arithmetic instructions support.

While we mostly do support TImode arithmetic, there are a couple of
gaps.  In particular, we have so far not yet supported conversions
between TImode integers and floating-point.  However, this now
causes test suite failures as the Fortran run-time library expects
just such conversions to work; the compiler generates calls to the
appropriate TImode libgcc routines, but those simply are not present.

To fix this, the patch below adds TImode conversion routines to
libgcc, using the existing LIB2_SIDITI_CONV_FUNC mechanism.

This exposed a secondary problem in that spu.h did not use the
LIBGCC2_UNITS_PER_WORD define to choose to build a 32-bit libgcc,
but instead (ab)used MIN_UNITS_PER_WORD to do so.  This breaks
when enabling LIB2_SIDITI_CONV_FUNC, so the patch changes this
as well.

Tested on spu-elf with no regressions.

Committed to mainline.

Bye,
Ulrich


ChangeLog:

	* config/spu/t-spu-elf (LIB2_SIDITI_CONV_FUNC): Define.
	* config/spu/spu.h (MIN_UNITS_PER_WORD): Do not define.
	(LIBGCC2_UNITS_PER_WORD): Define if not already defined.

Index: gcc/config/spu/t-spu-elf
===================================================================
*** gcc/config/spu/t-spu-elf	(revision 167696)
--- gcc/config/spu/t-spu-elf	(working copy)
*************** fp-bit.c: $(srcdir)/config/fp-bit.c $(sr
*** 63,68 ****
--- 63,72 ----
  	echo '#undef US_SOFTWARE_GOFAST' >> fp-bit.c
  	cat $(srcdir)/config/fp-bit.c >> fp-bit.c
  
+ # Build TImode conversion routines to support Fortran 128-bit
+ # integer data types.
+ LIB2_SIDITI_CONV_FUNCS=yes
+ 
  # Don't let CTOR_LIST end up in sdata section.
  CRTSTUFF_T_CFLAGS =
  
Index: gcc/config/spu/spu.h
===================================================================
*** gcc/config/spu/spu.h	(revision 167696)
--- gcc/config/spu/spu.h	(working copy)
*************** extern GTY(()) int spu_tune;
*** 65,73 ****
  
  #define UNITS_PER_WORD (BITS_PER_WORD/BITS_PER_UNIT)
  
! /* We never actually change UNITS_PER_WORD, but defining this causes
!    libgcc to use some different sizes of types when compiling. */
! #define MIN_UNITS_PER_WORD 4
  
  #define POINTER_SIZE 32
  
--- 65,80 ----
  
  #define UNITS_PER_WORD (BITS_PER_WORD/BITS_PER_UNIT)
  
! /* When building libgcc, we need to assume 4 words per units even
!    though UNITS_PER_WORD is 16, because the SPU has basically a 32-bit
!    instruction set although register size is 128 bits.  In particular,
!    this causes libgcc to contain __divdi3 instead of __divti3 etc.
!    However, we allow this default to be re-defined on the command
!    line, so that we can use the LIB2_SIDITI_CONV_FUNCS mechanism
!    to get (in addition) TImode versions of some routines.  */
! #ifndef LIBGCC2_UNITS_PER_WORD
! #define LIBGCC2_UNITS_PER_WORD 4
! #endif
  
  #define POINTER_SIZE 32
  
-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [spu, commit] Enable TImode vs. float conversion routines in libgcc

[Joseph S. Myers]

On Thu, 16 Dec 2010, Ulrich Weigand wrote:

> To fix this, the patch below adds TImode conversion routines to
> libgcc, using the existing LIB2_SIDITI_CONV_FUNC mechanism.

It would seem a good idea to enable testing of these functions as well.  
fp-int-convert.h contains logic also present in a few other places in the 
testsuite.

/* Not all platforms support TImode integers; logic as in
   gcc.dg/titype-1.c.  */
#if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
typedef int TItype __attribute__ ((mode (TI)));
typedef unsigned int UTItype __attribute__ ((mode (TI)));
#else
typedef long TItype;
typedef unsigned long UTItype;
#endif

If this target now supports TImode properly, perhaps that logic needs 
updating in whatever places have it to enable TImode for this target.

-- 
Joseph S. Myers
joseph@codesourcery.com

[spu, commit] Fix TImode->SFmode conversions (Re: Enable TImode vs. float conversion routines in libgcc)

[Ulrich Weigand]

Hello,

while the previous patch fixes TImode->DFmode conversions, it does not
correctly provide TImode->SFmode conversions (as noticed by the additional
testing suggested by Joseph Myers).  This is because of two issues:

- There is an unfortunate interaction between LIB2_SIDITI_CONV_FUNCS and
  LIB2FUNCS_EXCLUDE in the libgcc Makefile.in that causes breakage on SPU:

sifuncs := $(filter-out $(LIB2FUNCS_EXCLUDE),$(subst XX,si,$(swfloatfuncs)))
difuncs := $(filter-out $(LIB2FUNCS_EXCLUDE),$(subst XX,di,$(dwfloatfuncs)))
tifuncs := $(filter-out $(LIB2FUNCS_EXCLUDE),$(subst XX,ti,$(dwfloatfuncs)))

iter-items := $(sifuncs) $(difuncs) $(tifuncs)
iter-labels := $(sifuncs) $(difuncs) $(difuncs)
iter-sizes := $(patsubst %,4,$(sifuncs) $(difuncs)) $(patsubst %,8,$(tifuncs))

  These three lists must be of the same length, which in particular implies
  that $(difuncs) and $(tifuncs) must have the same length.  However, it is
  possible for LIB2FUNCS_EXCLUDE to remove some items from $(difuncs) while
  the corresponding items are left in $(tifuncs).  This happens on the SPU,
  because the DImode->SFmode conversion routines are excluded.

- However, for the same reason the DImode->SFmode routines are excluded,
  we actually have to exclude the TImode->SFmode routines too: the default
  implementation in libgcc assumes round-to-nearest, while on the SPU all
  single-precision floating-point operations should always use round-to-zero.

  Therefore the patch below implements TImode->SFmode conversions using
  round-to-zero inline in the compiler, following the existing DImode->
  SFmode model.  This means at this point there is no requirement to
  address the libgcc Makefile.in issue ...


Tested on spu-elf (including additional enabled testcases as pointed out
by Joseph Myers) with no regression.

Committed to mainline.

Bye,
Ulrich


ChangeLog:

	* config/spu/t-spu-elf (LIB2FUNCS_EXCLUDE): Add _floattisf and
	_floatunstisf.
	* config/spu/spu.md ("floattisf2"): New expander.
	("floatunstisf2"): New insn pattern and splitter.
	("cgt_ti_m1"): New insn pattern.


Index: gcc/config/spu/t-spu-elf
===================================================================
*** gcc/config/spu/t-spu-elf	(revision 167950)
--- gcc/config/spu/t-spu-elf	(working copy)
*************** TARGET_LIBGCC2_CFLAGS = -fPIC -mwarn-rel
*** 26,33 ****
  
  # We exclude those because the libgcc2.c default versions do not support
  # the SPU single-precision format (round towards zero).  We provide our
! # own versions below.
! LIB2FUNCS_EXCLUDE = _floatdisf _floatundisf
  
  # We provide our own version of __divdf3 that performs better and has
  # better support for non-default rounding modes.
--- 26,33 ----
  
  # We exclude those because the libgcc2.c default versions do not support
  # the SPU single-precision format (round towards zero).  We provide our
! # own versions below and/or via direct expansion.
! LIB2FUNCS_EXCLUDE = _floatdisf _floatundisf _floattisf _floatunstisf
  
  # We provide our own version of __divdf3 that performs better and has
  # better support for non-default rounding modes.
Index: gcc/config/spu/spu.md
===================================================================
*** gcc/config/spu/spu.md	(revision 167950)
--- gcc/config/spu/spu.md	(working copy)
***************
*** 753,758 ****
--- 753,825 ----
      DONE;
    })
  
+ (define_expand "floattisf2"
+   [(set (match_operand:SF 0 "register_operand" "")
+ 	(float:SF (match_operand:TI 1 "register_operand" "")))]
+   ""
+   {
+     rtx c0 = gen_reg_rtx (SImode);
+     rtx r0 = gen_reg_rtx (TImode);
+     rtx r1 = gen_reg_rtx (SFmode);
+     rtx r2 = gen_reg_rtx (SImode);
+     rtx setneg = gen_reg_rtx (SImode);
+     rtx isneg = gen_reg_rtx (SImode);
+     rtx neg = gen_reg_rtx (TImode);
+     rtx mask = gen_reg_rtx (TImode);
+ 
+     emit_move_insn (c0, GEN_INT (-0x80000000ll));
+ 
+     emit_insn (gen_negti2 (neg, operands[1]));
+     emit_insn (gen_cgt_ti_m1 (isneg, operands[1]));
+     emit_insn (gen_extend_compare (mask, isneg));
+     emit_insn (gen_selb (r0, neg, operands[1], mask));
+     emit_insn (gen_andc_si (setneg, c0, isneg));
+ 
+     emit_insn (gen_floatunstisf2 (r1, r0));
+ 
+     emit_insn (gen_iorsi3 (r2, gen_rtx_SUBREG (SImode, r1, 0), setneg));
+     emit_move_insn (operands[0], gen_rtx_SUBREG (SFmode, r2, 0));
+     DONE;
+   })
+ 
+ (define_insn_and_split "floatunstisf2"
+   [(set (match_operand:SF 0 "register_operand" "=r")
+         (unsigned_float:SF (match_operand:TI 1 "register_operand" "r")))
+    (clobber (match_scratch:SF 2 "=r"))
+    (clobber (match_scratch:SF 3 "=r"))
+    (clobber (match_scratch:SF 4 "=r"))]
+   ""
+   "#"
+   "reload_completed"
+   [(set (match_dup:SF 0)
+         (unsigned_float:SF (match_dup:TI 1)))]
+   {
+     rtx op1_v4si = gen_rtx_REG (V4SImode, REGNO (operands[1]));
+     rtx op2_v4sf = gen_rtx_REG (V4SFmode, REGNO (operands[2]));
+     rtx op2_ti = gen_rtx_REG (TImode, REGNO (operands[2]));
+     rtx op3_ti = gen_rtx_REG (TImode, REGNO (operands[3]));
+ 
+     REAL_VALUE_TYPE scale;
+     real_2expN (&scale, 32, SFmode);
+ 
+     emit_insn (gen_floatunsv4siv4sf2 (op2_v4sf, op1_v4si));
+     emit_insn (gen_shlqby_ti (op3_ti, op2_ti, GEN_INT (4)));
+ 
+     emit_move_insn (operands[4],
+ 		    CONST_DOUBLE_FROM_REAL_VALUE (scale, SFmode));
+     emit_insn (gen_fmasf4 (operands[2],
+ 			   operands[2], operands[4], operands[3]));
+ 
+     emit_insn (gen_shlqby_ti (op3_ti, op3_ti, GEN_INT (4)));
+     emit_insn (gen_fmasf4 (operands[2],
+ 			   operands[2], operands[4], operands[3]));
+ 
+     emit_insn (gen_shlqby_ti (op3_ti, op3_ti, GEN_INT (4)));
+     emit_insn (gen_fmasf4 (operands[0],
+ 			   operands[2], operands[4], operands[3]));
+     DONE;
+   })
+ 
  ;; Do (double)(operands[1]+0x80000000u)-(double)0x80000000
  (define_expand "floatsidf2"
    [(set (match_operand:DF 0 "register_operand" "")
***************
*** 3218,3223 ****
--- 3285,3297 ----
      DONE;
    })
  
+ (define_insn "cgt_ti_m1" 
+   [(set (match_operand:SI 0 "spu_reg_operand" "=r")
+ 	(gt:SI (match_operand:TI 1 "spu_reg_operand" "r")
+ 	       (const_int -1)))]
+   ""
+   "cgti\t%0,%1,-1")
+ 
  (define_insn "cgt_ti"
    [(set (match_operand:SI 0 "spu_reg_operand" "=r")
  	(gt:SI (match_operand:TI 1 "spu_reg_operand" "r")

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

[patch] Enable TImode tests (Re: Enable TImode vs. float conversion routines in libgcc)

[Ulrich Weigand]

Joseph S. Myers wrote:
> On Thu, 16 Dec 2010, Ulrich Weigand wrote:
> > To fix this, the patch below adds TImode conversion routines to
> > libgcc, using the existing LIB2_SIDITI_CONV_FUNC mechanism.
> 
> It would seem a good idea to enable testing of these functions as well.  
> fp-int-convert.h contains logic also present in a few other places in the 
> testsuite.
> 
> /* Not all platforms support TImode integers; logic as in
>    gcc.dg/titype-1.c.  */
> #if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
> typedef int TItype __attribute__ ((mode (TI)));
> typedef unsigned int UTItype __attribute__ ((mode (TI)));
> #else
> typedef long TItype;
> typedef unsigned long UTItype;
> #endif
> 
> If this target now supports TImode properly, perhaps that logic needs 
> updating in whatever places have it to enable TImode for this target.

Thanks for the tip!  I agree that this additional testing is helpful,
and in fact it did find a bug in the TImode->SFmode conversions (the
Fortran tests seemed to only have exercise TImode->DFmode, as it
turns out).  I've now checked in a fix for that problem here:
http://gcc.gnu.org/ml/gcc-patches/2010-12/msg01379.html


The patch below adds __SPU__ as platform supporting TImode in all
testcases I could find that use the gcc.dg/titype-1.c pattern.

Note that only some of them mention _WIN64 -- I'm not sure if this
was deliberate or an oversight (and I don't have access to a Win64
system at the moment), so I left this situation as is.

Does this look good to you, or do you see anything I overlooked?

(Tested on spu-elf with no regressions after the TImode->SFmode
patch was installed.)

Thanks,
Ulrich


ChangeLog:

	* gcc.dg/titype-1.c: Enable TImode on __SPU__.
	* gcc.dg/torture/fp-int-convert.h: Likewise.
	* gcc.dg/tree-ssa/ivopts-1.c: Likewise.
	* gcc.dg/uninit-C.c: Likewise.
	* gcc.dg/uninit-C-O0.c: Likewise.
	* gcc.dg/format/unnamed-1.c: Likewise.
	* gcc.dg/format/ms_unnamed-1.c: Likewise.


Index: gcc/testsuite/gcc.dg/uninit-C.c
===================================================================
*** gcc/testsuite/gcc.dg/uninit-C.c	(revision 167950)
--- gcc/testsuite/gcc.dg/uninit-C.c	(working copy)
***************
*** 3,9 ****
  /* { dg-options "-O -Wuninitialized" } */
  
  /* Not all platforms support TImode integers.  */
! #if defined(__LP64__) && !defined(__hppa__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
--- 3,9 ----
  /* { dg-options "-O -Wuninitialized" } */
  
  /* Not all platforms support TImode integers.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(__SPU__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
Index: gcc/testsuite/gcc.dg/torture/fp-int-convert.h
===================================================================
*** gcc/testsuite/gcc.dg/torture/fp-int-convert.h	(revision 167950)
--- gcc/testsuite/gcc.dg/torture/fp-int-convert.h	(working copy)
*************** extern void exit (int);
*** 7,13 ****
  
  /* Not all platforms support TImode integers; logic as in
     gcc.dg/titype-1.c.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
  typedef int TItype __attribute__ ((mode (TI)));
  typedef unsigned int UTItype __attribute__ ((mode (TI)));
  #else
--- 7,13 ----
  
  /* Not all platforms support TImode integers; logic as in
     gcc.dg/titype-1.c.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64) || defined(__SPU__)
  typedef int TItype __attribute__ ((mode (TI)));
  typedef unsigned int UTItype __attribute__ ((mode (TI)));
  #else
Index: gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c
===================================================================
*** gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c	(revision 167950)
--- gcc/testsuite/gcc.dg/tree-ssa/ivopts-1.c	(working copy)
***************
*** 1,7 ****
  /* { dg-do compile } */
  
  /* Not all platforms support TImode integers.  */
! #if defined(__LP64__) && !defined(__hppa__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
--- 1,7 ----
  /* { dg-do compile } */
  
  /* Not all platforms support TImode integers.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(__SPU__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
Index: gcc/testsuite/gcc.dg/uninit-C-O0.c
===================================================================
*** gcc/testsuite/gcc.dg/uninit-C-O0.c	(revision 167950)
--- gcc/testsuite/gcc.dg/uninit-C-O0.c	(working copy)
***************
*** 3,9 ****
  /* { dg-options "-Wuninitialized" } */
  
  /* Not all platforms support TImode integers.  */
! #if defined(__LP64__) && !defined(__hppa__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
--- 3,9 ----
  /* { dg-options "-Wuninitialized" } */
  
  /* Not all platforms support TImode integers.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(__SPU__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
Index: gcc/testsuite/gcc.dg/titype-1.c
===================================================================
*** gcc/testsuite/gcc.dg/titype-1.c	(revision 167950)
--- gcc/testsuite/gcc.dg/titype-1.c	(working copy)
***************
*** 1,7 ****
  /* { dg-do run } */
  
  /* Not all platforms support TImode integers.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
--- 1,7 ----
  /* { dg-do run } */
  
  /* Not all platforms support TImode integers.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(_WIN64) || defined(__SPU__)
  typedef int TItype __attribute__ ((mode (TI)));
  #else
  typedef long TItype;
Index: gcc/testsuite/gcc.dg/format/unnamed-1.c
===================================================================
*** gcc/testsuite/gcc.dg/format/unnamed-1.c	(revision 167950)
--- gcc/testsuite/gcc.dg/format/unnamed-1.c	(working copy)
***************
*** 10,16 ****
  
  /* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
     but must be a #define to avoid giving the type a name.  */
! #if defined(__LP64__) && !defined(__hppa__)
  #define TItype int __attribute__ ((mode (TI)))
  #else
  #define TItype long
--- 10,16 ----
  
  /* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
     but must be a #define to avoid giving the type a name.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(__SPU__)
  #define TItype int __attribute__ ((mode (TI)))
  #else
  #define TItype long
Index: gcc/testsuite/gcc.dg/format/ms_unnamed-1.c
===================================================================
*** gcc/testsuite/gcc.dg/format/ms_unnamed-1.c	(revision 167950)
--- gcc/testsuite/gcc.dg/format/ms_unnamed-1.c	(working copy)
***************
*** 10,16 ****
  
  /* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
     but must be a #define to avoid giving the type a name.  */
! #if defined(__LP64__) && !defined(__hppa__)
  #define TItype int __attribute__ ((mode (TI)))
  #else
  #define TItype long
--- 10,16 ----
  
  /* Definition of TItype follows same logic as in gcc.dg/titype-1.c,
     but must be a #define to avoid giving the type a name.  */
! #if (defined(__LP64__) && !defined(__hppa__)) || defined(__SPU__)
  #define TItype int __attribute__ ((mode (TI)))
  #else
  #define TItype long


-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [patch] Enable TImode tests (Re: Enable TImode vs. float conversion routines in libgcc)

[Joseph S. Myers]

On Fri, 17 Dec 2010, Ulrich Weigand wrote:

> The patch below adds __SPU__ as platform supporting TImode in all
> testcases I could find that use the gcc.dg/titype-1.c pattern.
> 
> Note that only some of them mention _WIN64 -- I'm not sure if this
> was deliberate or an oversight (and I don't have access to a Win64
> system at the moment), so I left this situation as is.
> 
> Does this look good to you, or do you see anything I overlooked?

As far as I can see this is fine, and I doubt the _WIN64 differences are 
deliberate.

-- 
Joseph S. Myers
joseph@codesourcery.com

Re: [patch] Enable TImode tests (Re: Enable TImode vs. float conversion routines in libgcc)

[Ulrich Weigand]

Joseph S. Myers wrote:
> On Fri, 17 Dec 2010, Ulrich Weigand wrote:
> 
> > The patch below adds __SPU__ as platform supporting TImode in all
> > testcases I could find that use the gcc.dg/titype-1.c pattern.
> > 
> > Note that only some of them mention _WIN64 -- I'm not sure if this
> > was deliberate or an oversight (and I don't have access to a Win64
> > system at the moment), so I left this situation as is.
> > 
> > Does this look good to you, or do you see anything I overlooked?
> 
> As far as I can see this is fine, and I doubt the _WIN64 differences are 
> deliberate.

OK, thanks again!  I've now checked in the patch.

Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com