Subversion Repositories openrisc

/* { dg-require-effective-target vect_double } */
 
#include "tree-vect.h"
 
#define N 8
 
typedef __SIZE_TYPE__ size_t;
 
extern void *malloc (size_t __size) __attribute__ ((__nothrow__,
						    __malloc__));
 
typedef double num_t;
static const num_t num__infty = ((num_t)1.0)/((num_t)0.0);
 
struct oct_tt;
typedef struct oct_tt oct_t;
 
typedef unsigned int var_t;
typedef enum {
  OCT_EMPTY = 0,
  OCT_NORMAL = 1,
  OCT_CLOSED = 2
} oct_state;
 
struct oct_tt {
  var_t n;
 
  int ref;
 
  oct_state state;
  struct oct_tt* closed;
 
  num_t* c;
};
 
void* octfapg_mm_malloc (size_t t);
oct_t* octfapg_alloc (var_t n);
oct_t* octfapg_full_copy (oct_t* m);
 
struct mmalloc_tt;
typedef struct mmalloc_tt mmalloc_t;
 
struct mmalloc_tt
{
  int id;
 
  int nb_alloc;
  int nb_realloc;
  int nb_free;
 
  size_t rem;
  size_t max;
  size_t tot;
 
};
 
typedef struct
{
  size_t size;
 
  mmalloc_t* mm;
  int id;
 
  double dummy;
 
} mmheader_t;
 
void*
octfapg_mm_malloc (size_t t)
{
  char* m = (char*)malloc(t+sizeof(mmheader_t));
  return m+sizeof(mmheader_t);
}
 
oct_t* octfapg_empty (var_t n);
 
oct_t*
octfapg_empty (const var_t n)
{
  oct_t* m;
  /*octfapg_timing_enter("oct_empty",3);*/
  m = ((oct_t*) octfapg_mm_malloc (sizeof(oct_t)));
  m->n = n;
  m->ref = 1;
  m->state = OCT_EMPTY;
  m->closed = (oct_t*)((void *)0);
  m->c = (num_t*)((void *)0);
  /*octfapg_timing_exit("oct_empty",3);*/
  return m;
}
 
oct_t*
octfapg_alloc (const var_t n)
{
  size_t nn = (2*(size_t)(n)*((size_t)(n)+1));
  oct_t* m;
  m = octfapg_empty(n);
  m->c = ((num_t*) octfapg_mm_malloc (sizeof(num_t)*(nn)));
  ;
  m->state = OCT_NORMAL;
  m->closed = (oct_t*)((void *)0);
  return m;
}
 
oct_t*
octfapg_universe (const var_t n)
{
  oct_t* m;
  size_t i, nn = (2*(size_t)(n)*((size_t)(n)+1));
  m = octfapg_alloc(n);
  for (i=0;i<nn;i++) *(m->c+i) = num__infty;
  for (i=0;i<2*n;i++) *(m->c+((size_t)(i)+(((size_t)(i)+1)*((size_t)(i)+1))/2)) = (num_t)(0);
  m->state = OCT_CLOSED;
  return m;
}
 
int main (void)
{ 
  int i;
  check_vect ();
 
  oct_t *p = octfapg_universe(10);
  return 0;
} 
 
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" } } */
/* { dg-final { scan-tree-dump-times "vector alignment may not be reachable" 1 "vect" { target { ! vector_alignment_reachable  } } } } */
/* { dg-final { scan-tree-dump-times "Alignment of access forced using versioning" 1 "vect" { target { ! vector_alignment_reachable } } } } */
/* { dg-final { cleanup-tree-dump "vect" } } */