Subversion Repositories openrisc_me

/* PR target/36533 */

/* { dg-do run { target { { i?86-*-linux* x86_64-*-linux* } && ilp32 } } } */

/* { dg-options "-Os" } */

#include <string.h>

#include <sys/mman.h>

#ifndef MAP_ANONYMOUS

#define MAP_ANONYMOUS MAP_ANON

#endif

typedef struct S1

{

  unsigned long s1;

  struct S1 *s2;

  char *s3;

} S1;

typedef struct

{

  unsigned int s4;

  unsigned int s5;

  int s6;

  unsigned int *s7;

} S2;

typedef struct

{

  unsigned int s8;

  unsigned short s9;

  unsigned char s10;

  unsigned char s11;

  char s12[255];

} S3;

typedef struct

{

  unsigned int s4;

  unsigned short s13;

  unsigned short s14;

} S4;

typedef struct

{

  char s15[16];

  unsigned long s16;

} S5;

typedef struct

{

  char s15[48];

  S5 *s17;

} S6;

typedef struct

{

  S1 *s18;

} S7;

__attribute__((regparm (3), noinline)) int

fn1 (const char *x, void *y, S1 *z)

{

  asm volatile ("" : : : "memory");

  return *x + (y != 0);

}

__attribute__((regparm (3), noinline)) int

fn2 (const char *x, int y, S2 *z)

{

  asm volatile ("" : : : "memory");

  return 0;

}

static inline __attribute__ ((always_inline)) unsigned int

fn4 (unsigned short x)

{

  unsigned len = x;

  if (len == ((1 << 16) - 1))

    return 1 << 16;

  return len;

}

static inline __attribute__ ((always_inline)) S3 *

fn3 (S3 *p)

{

  return (S3 *) ((char *) p + fn4 (p->s9));

}

__attribute__((regparm (3), noinline)) int

fn5 (void)

{

  asm volatile ("" : : : "memory");

  return 0;

}

static inline __attribute__ ((always_inline)) int

fn6 (S3 *w, int x, S2 *y, S4 *z)

{

  int a = 2;

  char *b = (char *) w;

  S2 c = *y;

  while ((char *) w < b + x - 2 * sizeof (S4))

    {

      if (w->s10 && w->s8)

        {

          fn2 (w->s12, w->s10, &c);

          z--;

          z->s4 = c.s4;

          z->s13 = (unsigned short) ((char *) w - b);

          z->s14 = w->s9;

          a++;

          fn5 ();

        }

      w = fn3 (w);

    }

  return a;

}

__attribute__((regparm (3), noinline)) unsigned int

test (void *u, S6 *v, S1 **w, S7 *x, S2 *y, S1 *z)

{

  unsigned b = v->s17->s16;

  unsigned a;

  S4 *c;

  unsigned d, e, f, i;

  fn1 (__func__, u, x->s18);

  c = (S4 *) (z->s3 + b);

  a = fn6 ((S3 *) (*w)->s3, b, y, c);

  c -= a;

  f = 0;

  e = 2;

  for (i = a - 1; ; i--)

    {

      if (f + (unsigned short) (c[i].s14 / 2) > b / 2)

        break;

      f += c[i].s14;

      e++;

    }

  d = a - e;

  return c[d].s4;

}

int main (void)

{

  char *p = mmap (NULL, 131072, PROT_READ | PROT_WRITE,

                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

  S1 wb, z, *w;

  S6 v;

  S7 x;

  S2 y;

  S5 vb;

  S4 s4;

  if (p == MAP_FAILED)

    return 0;

  if (munmap (p + 65536, 65536) < 0)

    return 0;

  memset (&wb, 0, sizeof (wb));

  memset (&z, 0, sizeof (z));

  memset (&v, 0, sizeof (v));

  memset (&x, 0, sizeof (x));

  memset (&y, 0, sizeof (y));

  memset (&vb, 0, sizeof (vb));

  memset (&s4, 0, sizeof (s4));

  s4.s14 = 254;

  z.s3 = p + 65536 - 2 * sizeof (S4);

  w = &wb;

  v.s17 = &vb;

  vb.s16 = 2 * sizeof (S4);

  memcpy (z.s3, &s4, sizeof (s4));

  memcpy (z.s3 + sizeof (s4), &s4, sizeof (s4));

  test ((void *) 0, &v, &w, &x, &y, &z);

  return 0;

}