3.2 branch/openserver g++ test results looking bad

[Robert Lipe <robertlipe@usa.net>]

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

Once upon a time in the not terribly distant pass, GCC's testuite
results on OpenServer (i686-*-sco3.2v5*) were at approximate parity with
Linux on IA32.  I've been a big slacker and haven't had my eye on it in
many months.  I just cranked off a bootstrap and a testsuite run and
it's not looking good for G++.

The C language tests are basically in the game with 234 unexpected
failures.  The G++ tests are still running, but by inspection of the
still-growing g++.log, it looks like the majority of the failures have
the same root:

	/usr/tmp/blah.s:name already bound as global: blah

If I take the attached registers1.ii (derived from a random failing
testsuite entry) I'll see:

$ ./xgcc -c ./registers1.ii
/usr/tmp//ccG6WKmc.s:4:name already bound as global: float_src
/usr/tmp//ccG6WKmc.s:12:name already bound as global: float_dest
/usr/tmp//ccG6WKmc.s:19:name already bound as global: int_src
/usr/tmp//ccG6WKmc.s:26:name already bound as global: int_dest

Sure enough, it's emitting double .globl for C++ things.  

(robertl) rjlhome:/play/negcs-3.2/gcc
$ head -5 registers1.s
        .file   "registers1.C"
        .version        "01.01"
        .globl  float_src
        .globl  float_src
        .data

3.0.4 didn't do this.  You can argue that the assembler is being lame
and I won't argue, but it'd be helpful to folks that use AT&T derived
assemblers if we wouldn't torment them.

Can anyone offer a hand on this?

Thanx,
RJL

[-- Attachment #2: registers1.ii --]
[-- Type: text/plain, Size: 3181 bytes --]

# 1 "/play/gcc-3.2/gcc/testsuite/g++.dg/eh/registers1.C"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "/play/gcc-3.2/gcc/testsuite/g++.dg/eh/registers1.C"




extern "C" void exit(int);
extern "C" void abort();
# 15 "/play/gcc-3.2/gcc/testsuite/g++.dg/eh/registers1.C"
const int num_vars = 16;
const int depth = 3;

float float_src[num_vars * depth];
float float_dest[num_vars];

int int_src[num_vars * depth];
int int_dest[num_vars];

void foo (int level, int throw_to)
{
  float *fsrc = &float_src[level * num_vars];
  float f00 = *fsrc++ + 1.0f;
  float f01 = *fsrc++ + 1.0f;
  float f02 = *fsrc++ + 1.0f;
  float f03 = *fsrc++ + 1.0f;
  float f04 = *fsrc++ + 1.0f;
  float f05 = *fsrc++ + 1.0f;
  float f06 = *fsrc++ + 1.0f;
  float f07 = *fsrc++ + 1.0f;
  float f08 = *fsrc++ + 1.0f;
  float f09 = *fsrc++ + 1.0f;
  float f10 = *fsrc++ + 1.0f;
  float f11 = *fsrc++ + 1.0f;
  float f12 = *fsrc++ + 1.0f;
  float f13 = *fsrc++ + 1.0f;
  float f14 = *fsrc++ + 1.0f;
  float f15 = *fsrc++ + 1.0f;

  int *isrc = &int_src[level * num_vars];
  int i00 = *isrc++ + 1;
  int i01 = *isrc++ + 1;
  int i02 = *isrc++ + 1;
  int i03 = *isrc++ + 1;
  int i04 = *isrc++ + 1;
  int i05 = *isrc++ + 1;
  int i06 = *isrc++ + 1;
  int i07 = *isrc++ + 1;
  int i08 = *isrc++ + 1;
  int i09 = *isrc++ + 1;
  int i10 = *isrc++ + 1;
  int i11 = *isrc++ + 1;
  int i12 = *isrc++ + 1;
  int i13 = *isrc++ + 1;
  int i14 = *isrc++ + 1;
  int i15 = *isrc++ + 1;

  try
    {
      if (level == 0)
        throw throw_to;
      else
        foo (level - 1, throw_to);
    }
  catch (int i)
    {
      if (i == level)
        {
          float *fdest = float_dest;
          *fdest++ = f00;
          *fdest++ = f01;
          *fdest++ = f02;
          *fdest++ = f03;
          *fdest++ = f04;
          *fdest++ = f05;
          *fdest++ = f06;
          *fdest++ = f07;
          *fdest++ = f08;
          *fdest++ = f09;
          *fdest++ = f10;
          *fdest++ = f11;
          *fdest++ = f12;
          *fdest++ = f13;
          *fdest++ = f14;
          *fdest++ = f15;

          int *idest = int_dest;
          *idest++ = i00;
          *idest++ = i01;
          *idest++ = i02;
          *idest++ = i03;
          *idest++ = i04;
          *idest++ = i05;
          *idest++ = i06;
          *idest++ = i07;
          *idest++ = i08;
          *idest++ = i09;
          *idest++ = i10;
          *idest++ = i11;
          *idest++ = i12;
          *idest++ = i13;
          *idest++ = i14;
          *idest++ = i15;
        }
      else
        {
          throw;
        }
    }
}

int main ()
{
  for (int i = 0; i < depth * num_vars; i++)
    {
      int_src[i] = i * i;
      float_src[i] = i * 2.0f;
    }
  for (int level = 0; level < depth; level++)
    for (int throw_to = 0; throw_to <= level; throw_to++)
      {
        foo (level, throw_to);
        float *fsrc = &float_src[throw_to * num_vars];
        int *isrc = &int_src[throw_to * num_vars];
        for (int i = 0; i < num_vars; i++)
          {
            if (int_dest[i] != isrc[i] + 1)
              abort ();
            if (float_dest[i] != fsrc[i] + 1.0f)
              abort ();
          }
      }
  exit (0);
}