Re: optimization/6162: gcc 3.0.4: certain i386 asm reloader ice

[Torbjorn Granlund <tege@swox.com>]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3497 bytes --]

The following reply was made to PR optimization/6162; it has been noted by GNATS.

From: Torbjorn Granlund <tege@swox.com>
To: Michael Matz <matz@suse.de>
Cc: Kevin Ryde <user42@zip.com.au>,
	Nathanael Nerode <neroden@twcny.rr.com>, <gcc-gnats@gcc.gnu.org>,
	<gcc-bugs@gcc.gnu.org>, <gcc@gcc.gnu.org>
Subject: Re: optimization/6162: gcc 3.0.4: certain i386 asm reloader ice
Date: 30 Oct 2002 23:55:08 +0100

 Michael Matz <matz@suse.de> writes:
 
   
   Wow.  Indeed. Some of them even have such funny things like:
   __asm__ ("{a%I4|add%I4c} %1,%3,%4\n\t{ame|addme} %0,%2"           \
                : "=r" ((USItype) (sh)),                                   \
                  "=&r" ((USItype) (sl))                                   \
                : "%r" ((USItype) (ah)),                                   \
                  "%r" ((USItype) (al)),                                   \
                  "rI" ((USItype) (bl)));
   
   which obviously is broken, or
 
 Fixed in gmp's longlong.h:
 
 2002-01-21  Torbjorn Granlund  <tege@swox.com>
 
         * longlong.h (32-bit powerpc add_ssaaaa): Remove spurious commutative
         declaration.
 
   __asm__ ("addu.co %1,%r4,%r5\n\taddu.ci %0,%r2,%r3"                   \
              : "=r" ((USItype) (sh)),                                     \
                "=&r" ((USItype) (sl))                                     \
              : "%rJ" ((USItype) (ah)),                                    \
                "rJ" ((USItype) (bh)),                                     \
                "%rJ" ((USItype) (al)),                                    \
                "rJ" ((USItype) (bl)))
   
   which is useless (they have the same constraints, so commutativity doesn't
   matter at all).  
 
 Well, we put commutativity declarations where they apply for
 consistency.
 
   Some of them probably are just lucky, like:
 
   __asm__ ("add.f       %1, %4, %5\n\tadc       %0, %2, %3"             \
              : "=r" ((USItype) (sh)),                                     \
                "=&r" ((USItype) (sl))                                     \
              : "%r" ((USItype) (ah)),                                     \
                "rIJ" ((USItype) (bh)),                                    \
                "%r" ((USItype) (al)),                                     \
                "rIJ" ((USItype) (bl)))
   
   If called with only variables, or constants already in the right operands,
   the swapping also doesn't take place.  But if then also operand matching
   comes into play (like some asms in longlong and also your example) the
   chance of getting unlucky is even higher.  Anyway given that longlong.h
   uses it I again looked into reload, and no, it simply can't handle
   correctly more than one pair which needs swapping.  It keeps track of only
   one operand which is commutative (the 'commutative' variable), and it only
   tries each alternative twice at most (once normally and once with the last
   pair swapped).  Therefore I think longlong.h is broken, but I wonder why
   this never popped up.
 
 In GCC, I doubt immediate values will be used for add_ssaaaa.  In GMP
 immediates are used, but by conventions they are used for the 2nd
 operand.
 
 There are a couple of other packages that use longlong.h as well, but
 they don't use immediates.
 
 I suggest that we don't touch longlong.h, since it is not really a
 problem.  Who knows, one day GCC might get this right.
 
 -- 
 Torbjörn