public inbox for gcc@gcc.gnu.org
 help / color / mirror / Atom feed
* gcc-64 on HP-UX 11.00
@ 2002-04-04  2:03 H.Merijn Brand
  2002-04-04  8:22 ` law
       [not found] ` <200204041958.g34JwTbA011272@hiauly1.hia.nrc.ca>
  0 siblings, 2 replies; 225+ messages in thread
From: H.Merijn Brand @ 2002-04-04  2:03 UTC (permalink / raw)
  To: gcc

As I've seen on the gcc web site, HP-UX 11.00 has been promoted to primary
target site. I've got no trouble building gcc in 32 bit mode, but building a
64bit gcc is still almost impossible.

Is there a preferred way to build from the latest snapshot? Do you want more
specific messages about the problems?

I'm not into the gcc sources, but somehow I seem to be willing to function as
a compile farm.

I've got

	The latest HP-UX 11.00 with the latest patches
	The latest C compiler (B.11.11.04 HP C/ANSI C Compiler)
	Several ports of gcc
		3.0.4/32
		3.0.1/64
		3.0.2/64
	binutils-2.11.90/64
	binutils-2.12/64

-- 
H.Merijn Brand        Amsterdam Perl Mongers (http://amsterdam.pm.org/)
using perl-5.6.1, 5.7.3 & 631 on HP-UX 10.20 & 11.00, AIX 4.2, AIX 4.3,
  WinNT 4, Win2K pro & WinCE 2.11.  Smoking perl CORE: smokers@perl.org
http://archives.develooper.com/daily-build@perl.org/   perl-qa@perl.org
send smoke reports to: smokers-reports@perl.org, QA: http://qa.perl.org

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Altivec + 16 byte alignment
@ 2003-02-11 10:07 Gianni Tedesco
  2003-02-11 14:18 ` Gianni Mariani
                   ` (3 more replies)
  0 siblings, 4 replies; 225+ messages in thread
From: Gianni Tedesco @ 2003-02-11 10:07 UTC (permalink / raw)
  To: gcc

[-- Attachment #1: Type: text/plain, Size: 1086 bytes --]

Hi,

I'm currently working on a project which uses altivec (as inline
assembly) to perform 3d affine transformations, and some other 3d vector
functions.

I have a problem in that altivec requires all inputs to be 16 byte
aligned, so I am placing my vectors in a structure like this:

struct vector {
	float x,y,z,w;
}__attribute__((aligned(16)));

This seems to work for global variables, but when allocated on the
stack, my structures end up mis-aligned (on to 8-byte boundaries) which
totally screws up the results of the altivec computation.

Is this a compiler problem, or can't the compiler be expected to
guarantee alignments that large?

gcc version 2.95.4 20010319 (prerelease/franzo/20011204)

PS. Is there any documentation about the vector support directly in C? I
hear gcc3 has that feature.

Thanks.

PS. Please CC replies, im not a list subscriber.

-- 
// Gianni Tedesco (gianni at scaramanga dot co dot uk)
lynx --source www.scaramanga.co.uk/gianni-at-ecsc.asc | gpg --import
8646BE7D: 6D9F 2287 870E A2C9 8F60 3A3C 91B5 7669 8646 BE7D

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 189 bytes --]

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 17:25 John David Anglin
  2003-02-11 18:29 ` Franz Sirl
  0 siblings, 1 reply; 225+ messages in thread
From: John David Anglin @ 2003-02-11 17:25 UTC (permalink / raw)
  To: gcc; +Cc: gianni

> I have a problem in that altivec requires all inputs to be 16 byte
> aligned, so I am placing my vectors in a structure like this:
> 
> struct vector {
>         float x,y,z,w;
> }__attribute__((aligned(16)));

We had a similar problem with respect to the alignment of data for
the ldcw instruction on the PA which needs 16-byte alignment on PA 1.X.
We have found an alternative solution.  However, the patch below
will allow the aligned attribute to be respected for stack locals
up to PREFERRED_STACK_BOUNDARY.  Note however, that alignment of
stack locals is only guaranteed up to STACK_BOUNDARY.  The default
alignment for structs on the stack is BIGGEST_ALIGNMENT, which I
presume is set 64 (8 bytes).

It may well be with altvec you really want BIGGEST_ALIGNMENT set to
256, but the change would affect the ABI and alignment of long doubles.
The i386 code provides an example of what needs doing if there are
types such as long doubles that don't require natural alignment.

Dave
-- 
J. David Anglin                                  dave.anglin@nrc-cnrc.gc.ca
National Research Council of Canada              (613) 990-0752 (FAX: 952-6605)

2003-02-11  John David Anglin  <dave.anglin@nrc-cnrc.gc.ca>

	* function.c (assign_stack_temp_for_type): Allow user to increase
	alignment of stack locals up to PREFERRED_STACK_BOUNDARY.

Index: function.c
===================================================================
RCS file: /cvsroot/gcc/gcc/gcc/function.c,v
retrieving revision 1.388
diff -u -3 -p -r1.388 function.c
--- function.c	27 Nov 2002 02:29:12 -0000	1.388
+++ function.c	6 Dec 2002 23:07:56 -0000
@@ -650,6 +650,12 @@ assign_stack_temp_for_type (mode, size, 
   else
     align = GET_MODE_ALIGNMENT (mode);
 
+  /* Allow the user to increase the default alignment with the aligned
+     attribute but bound the range.  */
+  if (type && TYPE_USER_ALIGN (type))
+    align = MIN (MAX (TYPE_ALIGN (type), align),
+		 MAX (PREFERRED_STACK_BOUNDARY, align));
+
   if (! type)
     type = (*lang_hooks.types.type_for_mode) (mode, 0);
 

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 18:34 Richard Kenner
  2003-02-11 18:59 ` Geoff Keating
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 18:34 UTC (permalink / raw)
  To: Franz.Sirl-kernel; +Cc: gcc

    BIGGEST_ALIGNMENT is 128, but STACK_BOUNDARY is 64 unless you give 
    -mabi=altivec (in 3.2+). 

I must say that I find this confusing.  Although the documentation is
unclear, I've always thought of BIGGEST_ALIGNMENT as being the largest
alignment we can guarantee and I think there's code that depends on that.
But if STACK_BOUNDARY < BIGGEST_ALIGNMENT, that's clearly not true.  

Has the definition changed?  If so, how *do* you find the largest
alignment you can guarantee?

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 19:03 Richard Kenner
  2003-02-11 19:11 ` Mike Stump
                   ` (2 more replies)
  0 siblings, 3 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 19:03 UTC (permalink / raw)
  To: geoffk; +Cc: gcc

    BIGGEST_ALIGNMENT is defined in the documentation as:

    `BIGGEST_ALIGNMENT'
         Biggest alignment that any data type can require on this machine,
         in bits.

Right.  That's what I mean that it's unclear.  Code acts like it means the
largest alignment that can be guaranteed, but the above is ambiguous at best.

    >   If so, how *do* you find the largest alignment you can guarantee?

    For error checking?  MAX_OFILE_ALIGNMENT is probably the value you
    want.

But that's even worse!  It's *larger* than STACK_BOUNDARY.

My question is this: suppose a user says "I need this variable or type
aligned to an N bit boundary".  How can you tell, as a function of N,
whether you can do that or not?

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 19:18 Richard Kenner
  0 siblings, 0 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 19:18 UTC (permalink / raw)
  To: mstump; +Cc: gcc

    I think the answer is the minimum of MAX_OFILE_ALIGNMENT, 
    STACK_BOUNDARY and BIGGEST_ALIGNMENT, if there are no bugs.  If there 
    are bugs, you can't, not without fixing those bugs.

Well, then there's another bug.  Look at the usage of REGNO_POINTER_ALIGNMENT
in combine.c: it assumes that the bits not in that alignment are zero.
Then look at all the calls to mark_reg_pointer that just pass TYPE_ALIGN
or DECL_ALIGN but nothing performs the minimum above before setting those.

But I must say that 

    Biggest alignment that any data type can require on this machine, in bits.

still seems in conflict with the current implementation.  If a type can
*require* that alignment, doesn't that mean that we are going to *give*
it that alignment?  But how can we if STACK_BOUNDARY is smaller?

I think this is a real mess at this point.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 19:43 Richard Kenner
  2003-02-11 20:02 ` Geoff Keating
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 19:43 UTC (permalink / raw)
  To: geoffk; +Cc: gcc

    Such code is wrong, it should be using MAX_OFILE_ALIGNMENT.  Can you
    point at the code in question?

The one in combine.c I mentioned in my last message, for example.

    Yes, it's supposed to be.  STACK_BOUNDARY is a minimum, not a maximum.

I don't follow.  STACK_BOUNDARY indeed gives the mimimum that the stack
is guaranteed to be aligned.  That's therefore the maximum that we can
guarantee to align any variable.

    In the abstract, you compare with MAX_OFILE_BOUNDARY.  You can align
    the stack to any value you like, 

Who's the "you"?  Where's the code?  If we have STACK_BOUNDARY of 32,
MAX_OFILE_BOUNDARY of 1024 and a TYPE_ALIGN of 128, what code is
responsible for aligning that variable to a boundary of 128 bits?

      /* Ignore alignment we can't do with expected alignment of the
         boundary.  */
      if (alignment * BITS_PER_UNIT > PREFERRED_STACK_BOUNDARY)
        alignment = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
    
    but really that's wrong, and at a minimum it should warn the user
    that their requested alignment isn't going to happen (better would be
    to just ensure the requested alignment).  We occasionally get bug
    reports about this, but so far no-one has invested the effort to
    implement arbitrary stack alignment.

Now we have *yet another* macro involved in alignment!

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 19:44 Richard Kenner
  0 siblings, 0 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 19:44 UTC (permalink / raw)
  To: tm_gccmail; +Cc: gcc

    The only way to solve this is to example the stack pointer at runtime
    and mask off bits in it to align the stack, which isn't currently
    supported as an option in gcc.

Well, not for C, but see gcc/ada/decl.c:make_aligning_type, which does
just that.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 20:33 Richard Kenner
  2003-02-11 20:34 ` Neil Booth
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 20:33 UTC (permalink / raw)
  To: neil; +Cc: gcc

    Isn't an even better place to do it in the front end, just after parsing
    the alignment request?

Probably not, since it would then have to know the complex formula used
to say what's supported and what isn't.

And then you have the problem of alignment of *types*, where you have to
be able to guarantee the alignment for both stack and memory.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 20:36 Richard Kenner
  2003-02-11 20:39 ` Neil Booth
  2003-02-11 20:46 ` tm_gccmail
  0 siblings, 2 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 20:36 UTC (permalink / raw)
  To: neil; +Cc: gcc

    It's just a function call, exposed to the front end.  Nice and clean.

In which case, why not do it totally in the back end?  I don't see it as
a big deal, but I'm not sure what you gain by adding a call to that function
into every front end.

    > And then you have the problem of alignment of *types*, where you have to
    > be able to guarantee the alignment for both stack and memory.

    Why is that a problem?

It isn't necessarily, just another case to be concerned about.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 21:10 Richard Kenner
  0 siblings, 0 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 21:10 UTC (permalink / raw)
  To: mstump; +Cc: gcc

    Let us agree that this is just a bug, or at least a bug for CPUs that 
    have hard requirements of say 16 bytes (Altivec, SSE) and the user asks 
    for 16 byte alignment and we silently only do 8 byte alignment.

Well it's more complex than that because to *know* that we have these
hard requirement, we have to make STRICT_ALIGNMENT take an operand,
which is the mode.

Moreover, the criteria you cite isn't totally clear.  Even if the
alignment isn't *required* and even if it isn't even preferred from an
efficiency standpoint, can we just ignore it?  In Ada, for example,
you cannot since it imposes constraints on the permitted values of
the object's address.  We also assume those constraints in combine.c.

We have to use all the attribues we have about alignmen to deduce two
things, which are the *default* and the *maximum* alignment we'll allow
for each object and type.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 22:05 Richard Kenner
  2003-02-11 22:09 ` Neil Booth
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 22:05 UTC (permalink / raw)
  To: neil; +Cc: gcc

    > struct foo {
    >   int x __attribute__((aligned (512)));
    > }
    > 
    > which might, or might not, end up on the stack.

    You could diagnose that when the object of that type is declared, just
    like we have to make other checks (particularly in C++) at that time.

That won't work for Ada, where you have to give the error on the type
definition if you can't support the type in all valid contexts.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 22:10 Richard Kenner
  2003-02-11 22:15 ` Neil Booth
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 22:10 UTC (permalink / raw)
  To: neil; +Cc: gcc

    Exactly, but now it seems *you're* the one arguing for putting the
    check in the front end.

Not necessarily: it can be checked when laying out the type in stor-layout.c.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 22:18 Richard Kenner
  2003-02-11 22:25 ` Neil Booth
  0 siblings, 1 reply; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 22:18 UTC (permalink / raw)
  To: neil; +Cc: gcc

    stor-layout.c is part of the front end; it just happens to be part of
    GCC that is shared between all front ends.  And it shows - it's overly
    generic and nearly incomprehensible.

The complexity is not due to being shared between front ends, but rather
due to the complex ABIs involved on various machines.  If you look back at
early versions, it was just about the same amount of complexity when it
was originally written just for C.

    The C parser I'm working on won't use it to lay out types, since I don't
    use trees.  I'll have to ensure that what stor-layout.c does (during
    lowering) is the same as what I've done.  At least in an initial
    implementation.

I think that's a *very* bad idea: as you say, what stor-layout.c does is
very complex.  There will be a significant amount of work to keep some other
code in sync with it.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 22:27 Robert Dewar
  0 siblings, 0 replies; 225+ messages in thread
From: Robert Dewar @ 2003-02-11 22:27 UTC (permalink / raw)
  To: kenner, neil; +Cc: gcc

> I think that's a *very* bad idea: as you say, what stor-layout.c does is
> very complex.  There will be a significant amount of work to keep some other
> code in sync with it.

I must say I agree with Richard here (I have often wanted to move layout into
the front end of Ada, but Richard has always managed to convince me this is
a bad idea). Can you say *why* you are making this decision:

    The C parser I'm working on won't use it to lay out types, since I don't
    use trees.  I'll have to ensure that what stor-layout.c does (during
    lowering) is the same as what I've done.  At least in an initial
    implementation.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-11 22:28 Richard Kenner
  0 siblings, 0 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-11 22:28 UTC (permalink / raw)
  To: neil; +Cc: gcc

    And I don't have all the C++ issues.  

As far as I know, stor-layout.c has almost no "C++ issues": the point of
separating layout into different functions was to keep that in the front end.

^ permalink raw reply	[flat|nested] 225+ messages in thread
* Re: Altivec + 16 byte alignment
@ 2003-02-12 14:15 Richard Kenner
  0 siblings, 0 replies; 225+ messages in thread
From: Richard Kenner @ 2003-02-12 14:15 UTC (permalink / raw)
  To: fjh; +Cc: gcc

    The alignment declaration might be used by the programmer to ensure
    that the lower bits are available for use as tag bits.

Exactly.

    For example, the following program should result in either success
    or a compile error (if the requested alignment is not supported).
    But IMHO it should not result in an assertion failure.

	#include <assert.h>
	#define ALIGN 32
	int main() {
		char c __attribute__((aligned(ALIGN)));
		assert ((((unsigned long) &c) & (ALIGN - 1)) == 0);
		return 0;
	}

This is *desirable* in C, as you say, but the equivalent Ada program is
*required* to have the behavior you want and there are tests to ensure
that it does.

^ permalink raw reply	[flat|nested] 225+ messages in thread

end of thread, other threads:[~2007-04-15 16:35 UTC | newest]

Thread overview: 225+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
     [not found] <no.id>
1997-09-30  8:09 ` Mini-patch for cccp.c Thomas Koenig
1997-09-30 23:24   ` Jeffrey A Law
1997-10-06  8:25   ` Thomas Koenig
1997-11-16 18:42 ` A new bug in 971114 H.J. Lu
1998-04-20 11:44 ` egcs 1.0.3 on linux/alpha H.J. Lu
1998-07-17 16:48 ` -Wall stops compiling of egcs-1.0.3 Joe Buck
1998-10-30 19:14 ` A bad EH bug H.J. Lu
     [not found] ` <19981218003619.B28066@cerebro.laendle>
     [not found]   ` <19981220010520.A4999@tantalophile.demon.co.uk>
     [not found]     ` <19981220223834.D16580@cerebro.laendle>
1998-12-21  2:53       ` GCC 2.7.2.3 good, EGCS 1.0.3 bad for x86 subtract then test Jamie Lokier
1998-12-23 14:19         ` Richard Henderson
1998-12-23 20:57           ` Jeffrey A Law
1998-12-24  1:11             ` Toshiyasu Morita
1998-12-25 18:17           ` Michael Hayes
1998-12-25 21:57             ` Jeffrey A Law
1998-12-26  2:07               ` Michael Hayes
1998-12-27  0:13                 ` Jeffrey A Law
1998-12-27  0:59                   ` Michael Hayes
2000-12-19 21:48 ` FWIW: VAX fix backport and gcc built on 4.3BSD first time ever! John David Anglin
2000-12-21 14:32   ` John David Anglin
2001-01-01 16:37 ` pa reload problem John David Anglin
2001-01-03 20:57   ` Jeffrey A Law
2001-01-03 22:08     ` John David Anglin
2001-01-04  9:55       ` Jeffrey A Law
2001-01-04 11:12         ` John David Anglin
2001-01-04 11:35         ` John David Anglin
2001-01-04 11:48           ` Alexandre Oliva
2001-01-04 13:06             ` John David Anglin
2001-01-04 13:18               ` Alexandre Oliva
2001-01-04 14:12                 ` John David Anglin
2001-01-12 19:40 ` RFC: Jump to const_int John David Anglin
2001-01-12 21:10   ` Fergus Henderson
2001-04-17 19:11 ` GCC 3.0 Status Report John David Anglin
2001-04-18  0:55   ` Mark Mitchell
2001-04-18  9:00     ` John David Anglin
2001-04-18 13:51     ` John David Anglin
2001-04-20 13:36       ` Mark Mitchell
2001-04-21 19:33 ` C++ Issue on GCC 3.0 branch John David Anglin
2001-04-23  2:18   ` Bernd Schmidt
2001-04-23  7:51     ` law
2001-04-23  7:55       ` Bernd Schmidt
2001-04-23  7:56       ` Bernd Schmidt
2001-04-23  8:14         ` law
2001-04-25 10:26   ` Mark Mitchell
2001-04-25 14:04     ` John David Anglin
2001-04-25 17:31       ` Mark Mitchell
2001-04-26  8:31         ` John David Anglin
2001-04-26 10:25           ` Mark Mitchell
2001-04-26 10:02         ` law
2001-04-23 15:21 ` John David Anglin
2001-04-24 19:21   ` law
2001-04-24 20:23     ` John David Anglin
2001-04-26 16:45       ` law
2001-04-26 17:02         ` Mark Mitchell
2001-04-26 17:29           ` law
2001-04-27 10:43         ` John David Anglin
2001-04-27 15:14         ` John David Anglin
2001-04-28  9:55           ` law
2001-04-30  8:59         ` John David Anglin
2001-05-16 16:22 ` gcc 2.95.2 Joe Buck
2001-06-14  9:58 ` STL warnings recently appeared in the 3.0 branch John David Anglin
2001-06-14 11:34 ` Possible corruption of gcc-3.0-20010614.tar.bz2 John David Anglin
2001-06-14 15:56 ` PATCH: Fix invalid loader fixups from shared libobjc with John David Anglin
2001-08-09 15:12 ` Simple returns are broken in gcc 3.X John David Anglin
2001-08-09 15:48   ` Richard Henderson
2001-12-12  8:49 ` Question regarding ICE in instantiate_virtual_regs_1, at function.c:3880 John David Anglin
2001-12-12 15:58   ` John David Anglin
2001-12-13  1:28     ` Jan Hubicka
2001-12-13 11:57       ` John David Anglin
2001-12-13 12:05         ` Jan Hubicka
2001-12-14 13:26           ` John David Anglin
2002-01-30 17:36 ` condition codes, haifa-sched and virtual-stack-vars Ulrich Weigand
2002-02-21 13:31 ` Help! DW function pointer encoding for PA John David Anglin
2002-02-21 19:28   ` David Edelsohn
2002-04-05 12:45 ` middle-end/6180: Infinite loop in cc1 during dbr pass John David Anglin
2002-04-05 13:54   ` Richard Henderson
2002-04-06 12:58     ` John David Anglin
2002-04-06 14:51       ` Richard Henderson
2002-04-10 15:30 ` gcc-64 on HP-UX 11.00 John David Anglin
2002-04-11 10:25 ` John David Anglin
2002-04-11 10:43   ` H.Merijn Brand
2002-04-11 11:04   ` law
2002-04-15 13:39 ` John David Anglin
2002-04-16 13:14   ` law
2002-04-16 15:25     ` John David Anglin
2002-11-13  3:37   ` gcc-64 20021111 broken " H.Merijn Brand
2002-11-13  5:38     ` H.Merijn Brand
2002-11-13  8:31       ` John David Anglin
2002-11-13 13:12       ` John David Anglin
2002-11-15  9:54         ` H.Merijn Brand
2002-11-13  8:30     ` John David Anglin
2002-04-26 10:43 ` bison 1.33 problem with mainline c-parse.in: yyfree_stacks John David Anglin
2002-05-11 20:28 ` corrections to recent profile-arcs change John David Anglin
2002-06-01 17:01 ` vax double precision broken Joe Buck
2002-07-11  6:34 ` Bootstrapping hppa64? CPP problem John David Anglin
2002-07-16 13:21 ` [parisc-linux] gcc-3.[02] alignment problem John David Anglin
2002-07-16 13:43   ` Randolph Chung
2002-07-16 13:45     ` Matthew Wilcox
2002-07-17  5:26       ` Randolph Chung
2002-07-16 14:26     ` Richard Henderson
2002-07-26 20:16 ` mainline bootstrap failure in bitmap.c on sparcv9-sun-solaris2.8 John David Anglin
2002-07-27 18:50   ` Richard Henderson
2002-07-28  4:50   ` Richard Henderson
2002-07-28 13:08     ` John David Anglin
2002-07-28 21:35     ` John David Anglin
2002-08-01 12:02 ` gcc 3.2's cpp breaks configure scripts John David Anglin
2002-10-08 16:26 ` soft-float support Graeme Peterson
2002-11-13 14:19 ` gcc-64 20021111 broken on HP-UX 11.00 John David Anglin
2002-11-23  0:26 ` HP-UX IA64 Patch to fix earlier patch John David Anglin
2002-12-17  9:52 ` Setting LD tool default to ld breaks configure check for ld used by GCC John David Anglin
2002-12-20 17:39   ` John David Anglin
2003-01-02 17:48 ` Miscompilation of glibc with CVS mainline John David Anglin
2003-01-02 17:54   ` Jakub Jelinek
2003-01-02 18:58     ` John David Anglin
2003-01-02 17:57   ` Daniel Jacobowitz
2003-02-03  5:02 ` hppa-linux regressions and 3.2.2 release John David Anglin
2003-02-03 11:03   ` Gabriel Dos Reis
2003-02-03 16:26   ` John David Anglin
2003-02-03 16:54     ` Gabriel Dos Reis
2003-02-03 18:02       ` John David Anglin
2003-02-11 19:37 ` Bootstrap failure on hppa-unknown-linux-gnu, trunk John David Anglin
2003-02-11 22:37   ` Josef Zlomek
2003-02-11 22:51     ` John David Anglin
2003-03-05 22:03   ` Josef Zlomek
2003-03-05 22:05     ` Josef Zlomek
2003-02-11 19:59 ` Altivec + 16 byte alignment John David Anglin
2003-02-11 21:02   ` Mike Stump
2003-02-12  5:55     ` Fergus Henderson
2003-02-12 16:39       ` John David Anglin
2003-05-07  1:13 ` GCC 3.3 Prelease broken on s390 Ulrich Weigand
2003-05-07  1:27   ` Richard Henderson
2003-05-07  5:53     ` Mark Mitchell
2003-05-07 14:54     ` Ulrich Weigand
2003-05-07 15:53       ` Mark Mitchell
2003-05-07 16:03         ` Joe Buck
2003-05-07 16:13           ` Mark Mitchell
2003-05-07 17:02         ` Ulrich Weigand
2003-05-07 17:09           ` Joe Buck
2003-05-07 17:11           ` Mark Mitchell
2003-05-07 19:39             ` Ulrich Weigand
2003-05-07 19:45               ` Mark Mitchell
2003-05-07 18:19           ` Jonathan Lennox
2003-05-07 18:27             ` Mark Mitchell
2003-05-07 18:30               ` Jonathan Lennox
2003-05-07 18:36                 ` Mark Mitchell
2003-05-07 18:49                 ` Daniel Jacobowitz
2003-05-07 17:51       ` Richard Henderson
2003-05-07 19:42         ` Ulrich Weigand
2003-05-07 19:46           ` Mark Mitchell
2003-07-05 17:01 ` Solaris 8/SPARC bootstrap broken building 64-bit libgcc John David Anglin
2003-10-08  3:11 ` Someone broke bootstrap John David Anglin
2003-10-08  7:25   ` Eric Christopher
2003-10-08 17:26     ` John David Anglin
2004-01-06  0:43 ` autoconf changes break bootstrap on hppa*-*-hpux* John David Anglin
2007-04-15 19:13 ` Call to arms: testsuite failures on various targets John David Anglin
2002-04-04  2:03 gcc-64 on HP-UX 11.00 H.Merijn Brand
2002-04-04  8:22 ` law
     [not found] ` <200204041958.g34JwTbA011272@hiauly1.hia.nrc.ca>
2002-04-05  4:51   ` H.Merijn Brand
2002-04-05  5:01     ` H.Merijn Brand
2002-04-05  9:19     ` John David Anglin
2002-04-07  7:26       ` H.Merijn Brand
2002-04-07 12:17         ` John David Anglin
2002-04-10  3:39       ` H.Merijn Brand
2002-04-10 11:21         ` John David Anglin
2002-04-10 11:56           ` H.Merijn Brand
2002-04-10 12:50             ` John David Anglin
2002-04-11  2:19               ` H.Merijn Brand
2002-04-11  8:59                 ` John David Anglin
2002-04-11  9:15                   ` H.Merijn Brand
2002-04-11  9:19                   ` law
2003-02-11 10:07 Altivec + 16 byte alignment Gianni Tedesco
2003-02-11 14:18 ` Gianni Mariani
2003-02-11 14:49   ` Gianni Mariani
2003-02-11 14:57     ` Gianni Tedesco
2003-02-11 19:26   ` tm_gccmail
2003-02-11 14:32 ` Michael S. Zick
2003-02-11 14:49   ` Gianni Tedesco
2003-02-11 23:58 ` Daniel Egger
2003-02-14  2:41 ` Segher Boessenkool
2003-02-14 16:07   ` Michael S. Zick
2003-02-11 17:25 John David Anglin
2003-02-11 18:29 ` Franz Sirl
2003-02-11 18:32   ` David Edelsohn
2003-02-11 18:57     ` Franz Sirl
2003-02-11 22:35       ` Spundun Bhatt
     [not found]         ` <1045070773.1118.140.camel@lemsip>
2003-02-12 18:06           ` Spundun Bhatt
2003-02-12  0:42   ` Richard Henderson
2003-02-12 21:17     ` Franz Sirl
2003-02-12 21:46       ` Richard Henderson
2003-02-12 22:31         ` Franz Sirl
2003-02-13  0:04           ` Gabriel Paubert
2003-02-12 22:47         ` John David Anglin
2003-02-13  0:40           ` Richard Henderson
2003-02-13  6:31             ` John David Anglin
2003-02-13  8:59               ` Richard Henderson
2003-02-13 18:06                 ` John David Anglin
2003-02-11 18:34 Richard Kenner
2003-02-11 18:59 ` Geoff Keating
2003-02-11 19:03 Richard Kenner
2003-02-11 19:11 ` Mike Stump
2003-02-11 19:26 ` Geoff Keating
2003-02-11 19:40   ` David Edelsohn
2003-02-11 20:29   ` Neil Booth
2003-02-11 20:45     ` Geoff Keating
2003-02-11 22:03       ` Neil Booth
2003-02-11 22:07         ` Neil Booth
2003-02-11 20:01 ` Geert Bosch
2003-02-11 19:18 Richard Kenner
2003-02-11 19:43 Richard Kenner
2003-02-11 20:02 ` Geoff Keating
2003-02-12  0:52   ` Richard Henderson
2003-02-11 19:44 Richard Kenner
2003-02-11 20:33 Richard Kenner
2003-02-11 20:34 ` Neil Booth
2003-02-11 20:36 Richard Kenner
2003-02-11 20:39 ` Neil Booth
2003-02-11 20:46 ` tm_gccmail
2003-02-11 21:10 Richard Kenner
2003-02-11 22:05 Richard Kenner
2003-02-11 22:09 ` Neil Booth
2003-02-11 22:10 Richard Kenner
2003-02-11 22:15 ` Neil Booth
2003-02-11 22:18 Richard Kenner
2003-02-11 22:25 ` Neil Booth
2003-02-11 22:27 Robert Dewar
2003-02-11 22:28 Richard Kenner
2003-02-12 14:15 Richard Kenner

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).