Skip to content

R
riscv-gcc-1
Commit 479b6652 by Ira Rosen Committed by Dorit Nuzman
Options

vect-13.c: Added xfail for non ppc platforms. 

2004-09-20  Ira Rosen  <irar@il.ibm.com>

        * gcc.dg/vect/vect-13.c: Added xfail for non ppc platforms.
        * gcc.dg/vect/vect-74.c: Split into 3 tests (vect-79.c, vect-80.c).
        * gcc.dg/vect/vect-62.c: New testcase.
        * gcc.dg/vect/vect-63.c: New testcase.
        * gcc.dg/vect/vect-64.c: New testcase.
        * gcc.dg/vect/vect-65.c: New testcase.
        * gcc.dg/vect/vect-66.c: New testcase.
        * gcc.dg/vect/vect-67.c: New testcase.
        * gcc.dg/vect/vect-68.c: New testcase.
        * gcc.dg/vect/vect-69.c: New testcase.
        * gcc.dg/vect/vect-79.c: New testcase.
        * gcc.dg/vect/vect-80.c: New testcase.

From-SVN: r87745
parent 073cbad3
Showing with 734 additions and 52 deletions
gcc/testsuite/ChangeLog
2004-09-20 Ira Rosen <irar@il.ibm.com>
* gcc.dg/vect/vect-13.c: Added xfail for non ppc platforms.
* gcc.dg/vect/vect-74.c: Split into 3 tests (vect-79.c, vect-80.c).
* gcc.dg/vect/vect-62.c: New testcase.
* gcc.dg/vect/vect-63.c: New testcase.
* gcc.dg/vect/vect-64.c: New testcase.
* gcc.dg/vect/vect-65.c: New testcase.
* gcc.dg/vect/vect-66.c: New testcase.
* gcc.dg/vect/vect-67.c: New testcase.
* gcc.dg/vect/vect-68.c: New testcase.
* gcc.dg/vect/vect-69.c: New testcase.
* gcc.dg/vect/vect-79.c: New testcase.
* gcc.dg/vect/vect-80.c: New testcase.
2004-09-20 Richard Sandiford <rsandifo@redhat.com> 2004-09-20 Richard Sandiford <rsandifo@redhat.com>
* gcc.target/mips/asm-1.c: New test. * gcc.target/mips/asm-1.c: New test.
......
gcc/testsuite/gcc.dg/vect/vect-13.c
...@@ -22,4 +22,4 @@ int main () ...@@ -22,4 +22,4 @@ int main ()
return 0; return 0;
} }
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail i?86-*-* x86_64-*-* } } } */
gcc/testsuite/gcc.dg/vect/vect-62.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
int main1 ()
{
int i, j;
int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
int ia[N][4][N+8];
/* Multidimensional array. Aligned. The "inner" dimensions
are invariant in the inner loop. Store. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ia[i][1][j+8] = ib[i];
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i][1][j+8] != ib[i])
abort();
}
}
/* Multidimensional array. Aligned. The "inner" dimensions
are invariant in the inner loop. Store. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ia[i][1][8] = ib[i];
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i][1][8] != ib[i])
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-63.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
int main1 ()
{
int i, j;
int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
int ia[N*2][4][N];
/* Multidimensional array. Aligned.
The first dimension depends on j: not vectorizable. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ia[i + j][1][j] = ib[i];
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i + j][1][j] != ib[i])
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
gcc/testsuite/gcc.dg/vect/vect-64.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
int main1 ()
{
int i, j;
int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
int ia[N][4][N+1];
int ic[N][N][3][13];
int id[N][N][N];
/* Multidimensional array. Not aligned: not vectorizable. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ia[i][1][j] = ib[i];
}
}
/* Multidimensional array. Aligned: vectorizable. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ic[i][1][1][j] = ib[i];
}
}
/* Multidimensional array. Not aligned: not vectorizable. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
id[i][1][j+1] = ib[i];
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i][1][j] != ib[i])
abort();
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ic[i][1][1][j] != ib[i])
abort();
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (id[i][1][j+1] != ib[i])
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-65.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
#define M 4
int main1 ()
{
int i, j;
int ib[M][M][N] = {{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}},
{{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45},
{0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45}}};
int ia[M][M][N];
int ic[N];
/* Multidimensional array. Aligned. The "inner" dimensions
are invariant in the inner loop. Load and store. */
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
ia[i][1][j] = ib[2][i][j];
}
}
/* check results: */
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i][1][j] != ib[2][i][j])
abort();
}
}
/* Multidimensional array. Aligned. The "inner" dimensions
are invariant in the inner loop. Load. */
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
ic[j] = ib[2][i][j];
}
}
/* check results: */
for (i = 0; i < M; i++)
{
for (j = 0; j < N; j++)
{
if (ic[j] != ib[2][i][j])
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-66.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
int main1 ()
{
int i, j;
int ib[6] = {0,3,6,9,12,15};
int ia[8][5][6];
int ic[16][16][5][6];
/* Multidimensional array. Aligned. */
for (i = 0; i < 16; i++)
{
for (j = 0; j < 4; j++)
{
ia[2][6][j] = 5;
}
}
/* check results: */
for (i = 0; i < 16; i++)
{
for (j = 0; j < 4; j++)
{
if (ia[2][6][j] != 5)
abort();
}
}
/* Multidimensional array. Aligned. */
for (i = 0; i < 16; i++)
{
for (j = 0; j < 4; j++)
ia[3][6][j+2] = 5;
}
/* check results: */
for (i = 0; i < 16; i++)
{
for (j = 2; j < 6; j++)
{
if (ia[3][6][j] != 5)
abort();
}
}
/* Multidimensional array. Not aligned. */
for (i = 0; i < 16; i++)
{
for (j = 0; j < 4; j++)
{
ic[2][1][6][j] = 5;
}
}
/* check results: */
for (i = 0; i < 16; i++)
{
for (j = 0; j < 4; j++)
{
if (ic[2][1][6][j] != 5)
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-67.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
int main1 (int a, int b)
{
int i, j;
int ia[N][4][N+8];
/* Multidimensional array. Aligned. The "inner" dimensions
are invariant in the inner loop. Store.
Not vectorizable: unsupported operation. */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
ia[i][1][j+8] = (a == b);
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (ia[i][1][j+8] != (a == b))
abort();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 (2 ,7);
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
gcc/testsuite/gcc.dg/vect/vect-68.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 32
struct s{
int m;
int n[N][N][N];
};
struct test1{
struct s a; /* array a.n is unaligned */
int b;
int c;
struct s e; /* array e.n is aligned */
};
int main1 ()
{
int i,j;
struct test1 tmp1;
/* 1. unaligned */
for (i = 0; i < N; i++)
{
tmp1.a.n[1][2][i] = 5;
}
/* check results: */
for (i = 0; i <N; i++)
{
if (tmp1.a.n[1][2][i] != 5)
abort ();
}
/* 2. aligned */
for (i = 3; i < N-1; i++)
{
tmp1.a.n[1][2][i] = 6;
}
/* check results: */
for (i = 3; i < N-1; i++)
{
if (tmp1.a.n[1][2][i] != 6)
abort ();
}
/* 3. aligned */
for (i = 0; i < N; i++)
{
tmp1.e.n[1][2][i] = 7;
}
/* check results: */
for (i = 0; i < N; i++)
{
if (tmp1.e.n[1][2][i] != 7)
abort ();
}
/* 4. unaligned */
for (i = 3; i < N-3; i++)
{
tmp1.e.n[1][2][i] = 8;
}
/* check results: */
for (i = 3; i <N-3; i++)
{
if (tmp1.e.n[1][2][i] != 8)
abort ();
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-69.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 32
struct s{
int m;
int n[N][N][N];
};
struct s2{
int m;
int n[N-1][N-1][N-1];
};
struct test1{
struct s a; /* array a.n is unaligned */
int b;
int c;
struct s e; /* array e.n is aligned */
};
struct test2{
struct s2 a; /* array a.n is unaligned */
int b;
int c;
struct s2 e; /* array e.n is aligned */
};
struct test1 tmp1[4];
struct test2 tmp2[4];
int main1 ()
{
int i,j;
/* 1. unaligned */
for (i = 0; i < N; i++)
{
tmp1[2].a.n[1][2][i] = 5;
}
/* check results: */
for (i = 0; i <N; i++)
{
if (tmp1[2].a.n[1][2][i] != 5)
abort ();
}
/* 2. aligned */
for (i = 3; i < N-1; i++)
{
tmp1[2].a.n[1][2][i] = 6;
}
/* check results: */
for (i = 3; i < N-1; i++)
{
if (tmp1[2].a.n[1][2][i] != 6)
abort ();
}
/* 3. aligned */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
tmp1[2].e.n[1][i][j] = 8;
}
}
/* check results: */
for (i = 0; i < N; i++)
{
for (j = 0; j < N; j++)
{
if (tmp1[2].e.n[1][i][j] != 8)
abort ();
}
}
/* 4. unaligned */
for (i = 0; i < N-4; i++)
{
for (j = 0; j < N-4; j++)
{
tmp2[2].e.n[1][i][j] = 8;
}
}
/* check results: */
for (i = 0; i < N-4; i++)
{
for (j = 0; j < N-4; j++)
{
if (tmp2[2].e.n[1][i][j] != 8)
abort ();
}
}
return 0;
}
int main (void)
{
check_vect ();
return main1 ();
}
/* { dg-final { scan-tree-dump-times "vectorized 2 loops" 1 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-74.c
...@@ -14,11 +14,6 @@ afloat a[N]; ...@@ -14,11 +14,6 @@ afloat a[N];
afloat b[N+4] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16, 16.17, 17.18, 18.19, 19.20}; afloat b[N+4] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16, 16.17, 17.18, 18.19, 19.20};
afloat c[N] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16}; afloat c[N] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16};
float fa[N];
float fb[N+4] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16,
16.17, 17.18, 18.19, 19.20};
float fc[N] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16};
int int
main1 (afloat *__restrict__ pa, afloat * __restrict__ pb, afloat * __restrict__ pc) main1 (afloat *__restrict__ pa, afloat * __restrict__ pb, afloat * __restrict__ pc)
{ {
...@@ -39,59 +34,13 @@ main1 (afloat *__restrict__ pa, afloat * __restrict__ pb, afloat * __restrict__ ...@@ -39,59 +34,13 @@ main1 (afloat *__restrict__ pa, afloat * __restrict__ pb, afloat * __restrict__
return 0; return 0;
} }
/* Not vectorizable. Alias. */
int
main2 (afloat *pa, afloat *pb, afloat *pc)
{
int i;
afloat *q = pb + 4;
for (i = 0; i < N; i++)
{
pa[i] = q[i] * pc[i];
}
for (i = 0; i < N; i++)
{
if (pa[i] != q[i] * pc[i])
abort();
}
return 0;
}
/* Not vectorizable: not aligned pointers. */
int
main3 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
{
int i;
afloat *q = pb + 4;
for (i = 0; i < N; i++)
{
pa[i] = q[i] * pc[i];
}
for (i = 0; i < N; i++)
{
if (pa[i] != q[i] * pc[i])
abort();
}
return 0;
}
int main (void) int main (void)
{ {
check_vect (); check_vect ();
main1 (a, b, c); main1 (a, b, c);
main2 (a, b, c);
main3 (fa, fb, fc);
return 0; return 0;
} }
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */ /* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
/* { dg-final { scan-tree-dump-times "vectorized 0 loops" 2 "vect" } } */
gcc/testsuite/gcc.dg/vect/vect-79.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
typedef float afloat __attribute__ ((__aligned__(16)));
afloat a[N];
afloat b[N+4] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16, 16.17, 17.18, 18.19, 19.20};
afloat c[N] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16};
/* Not vectorizable. Alias. */
int
main2 (afloat *pa, afloat *pb, afloat *pc)
{
int i;
afloat *q = pb + 4;
for (i = 0; i < N; i++)
{
pa[i] = q[i] * pc[i];
}
for (i = 0; i < N; i++)
{
if (pa[i] != q[i] * pc[i])
abort();
}
return 0;
}
int main (void)
{
check_vect ();
main2 (a, b, c);
return 0;
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
gcc/testsuite/gcc.dg/vect/vect-80.c 0 → 100644
/* { dg-do run { target powerpc*-*-* } } */
/* { dg-do run { target i?86-*-* x86_64-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -maltivec" { target powerpc*-*-* } } */
/* { dg-options "-O2 -ftree-vectorize -fdump-tree-vect-stats -msse2" { target i?86-*-* x86_64-*-* } } */
#include <stdarg.h>
#include "tree-vect.h"
#define N 16
typedef float afloat __attribute__ ((__aligned__(16)));
float fa[N];
float fb[N+4] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16,
16.17, 17.18, 18.19, 19.20};
float fc[N] = {0.2, 1.3, 2.3, 3.4, 4.5, 5.6, 7.8, 9.0, 10.11, 11.12, 12.13, 13.14, 14.15, 15.16};
/* Not vectorizable: not aligned pointers. */
int
main3 (float * __restrict__ pa, float * __restrict__ pb, float *__restrict__ pc)
{
int i;
afloat *q = pb + 4;
for (i = 0; i < N; i++)
{
pa[i] = q[i] * pc[i];
}
for (i = 0; i < N; i++)
{
if (pa[i] != q[i] * pc[i])
abort();
}
return 0;
}
int main (void)
{
check_vect ();
main3 (fa, fb, fc);
return 0;
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" { xfail *-*-* } } } */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment