/* This file is generated by gen_types.py */

#include "gpuarray/types.h"

#include <stdlib.h> /* For NULL */

#ifdef _MSC_VER

typedef signed __int8 int8_t;

typedef unsigned __int8 uint8_t;

typedef signed __int16 int16_t;

typedef unsigned __int16 uint16_t;

typedef signed __int32 int32_t;

typedef unsigned __int32 uint32_t;

typedef signed __int64 int64_t;

typedef unsigned __int64 uint64_t;

#else

#include <stdint.h>

#endif

typedef struct _int128 {

union int128_u {

int8_t as_int8[16];

int16_t as_int16[8];

int32_t as_int32[4];

int64_t as_int64[2];

} value;

} int128_t;

typedef struct _uint128 {

union uint128_u {

uint8_t as_uint8[16];

uint16_t as_uint16[8];

uint32_t as_uint32[4];

uint64_t as_uint64[2];

} value;

} uint128_t;

typedef struct _quad {

union {

struct {

int16_t exp;

uint16_t hi;

uint32_t lo;

};

uint128_t raw;

} u;

} ga_quad;

typedef uint16_t half_t;

typedef struct _cfloat {

float r;

float i;

} ga_cfloat;

typedef struct _cdouble {

double r;

double i;

} ga_cdouble;

typedef struct _cquad {

ga_quad r;

ga_quad i;

} ga_cquad;

typedef struct {char c; uint8_t x; } st_bool;

#define BOOL_ALIGN (sizeof(st_bool) - sizeof(uint8_t))

typedef struct {char c; int8_t x; } st_byte;

#define BYTE_ALIGN (sizeof(st_byte) - sizeof(int8_t))

typedef struct {char c; uint8_t x; } st_ubyte;

#define UBYTE_ALIGN (sizeof(st_ubyte) - sizeof(uint8_t))

typedef struct {char c; int16_t x; } st_short;

#define SHORT_ALIGN (sizeof(st_short) - sizeof(int16_t))

typedef struct {char c; uint16_t x; } st_ushort;

#define USHORT_ALIGN (sizeof(st_ushort) - sizeof(uint16_t))

typedef struct {char c; int32_t x; } st_int;

#define INT_ALIGN (sizeof(st_int) - sizeof(int32_t))

typedef struct {char c; uint32_t x; } st_uint;

#define UINT_ALIGN (sizeof(st_uint) - sizeof(uint32_t))

typedef struct {char c; int64_t x; } st_long;

#define LONG_ALIGN (sizeof(st_long) - sizeof(int64_t))

typedef struct {char c; uint64_t x; } st_ulong;

#define ULONG_ALIGN (sizeof(st_ulong) - sizeof(uint64_t))

typedef struct {char c; int128_t x; } st_longlong;

#define LONGLONG_ALIGN (sizeof(st_longlong) - sizeof(int128_t))

typedef struct {char c; uint128_t x; } st_ulonglong;

#define ULONGLONG_ALIGN (sizeof(st_ulonglong) - sizeof(uint128_t))

typedef struct {char c; float x; } st_float;

#define FLOAT_ALIGN (sizeof(st_float) - sizeof(float))

typedef struct {char c; double x; } st_double;

#define DOUBLE_ALIGN (sizeof(st_double) - sizeof(double))

typedef struct {char c; ga_quad x; } st_quad;

#define QUAD_ALIGN (sizeof(st_quad) - sizeof(ga_quad))

typedef struct {char c; ga_cfloat x; } st_cfloat;

#define CFLOAT_ALIGN (sizeof(st_cfloat) - sizeof(ga_cfloat))

typedef struct {char c; ga_cdouble x; } st_cdouble;

#define CDOUBLE_ALIGN (sizeof(st_cdouble) - sizeof(ga_cdouble))

typedef struct {char c; ga_cquad x; } st_cquad;

#define CQUAD_ALIGN (sizeof(st_cquad) - sizeof(ga_cquad))

typedef struct {char c; half_t x; } st_half;

#define HALF_ALIGN (sizeof(st_half) - sizeof(half_t))

typedef struct {char c; size_t x; } st_size;

#define SIZE_ALIGN (sizeof(st_size) - sizeof(size_t))

typedef struct {char c; ssize_t x; } st_ssize;

#define SSIZE_ALIGN (sizeof(st_ssize) - sizeof(ssize_t))

const gpuarray_type scalar_types[] = {

{"ga_bool", 1, BOOL_ALIGN, GA_BOOL},

{"ga_byte", 1, BYTE_ALIGN, GA_BYTE},

{"ga_ubyte", 1, UBYTE_ALIGN, GA_UBYTE},

{"ga_short", 2, SHORT_ALIGN, GA_SHORT},

{"ga_ushort", 2, USHORT_ALIGN, GA_USHORT},

{"ga_int", 4, INT_ALIGN, GA_INT},

{"ga_uint", 4, UINT_ALIGN, GA_UINT},

{"ga_long", 8, LONG_ALIGN, GA_LONG},

{"ga_ulong", 8, ULONG_ALIGN, GA_ULONG},

{"ga_longlong", 16, LONGLONG_ALIGN, GA_LONGLONG},

{"ga_ulonglong", 16, ULONGLONG_ALIGN, GA_ULONGLONG},

{"ga_float", 4, FLOAT_ALIGN, GA_FLOAT},

{"ga_double", 8, DOUBLE_ALIGN, GA_DOUBLE},

{"ga_quad", 16, QUAD_ALIGN, GA_QUAD},

{"ga_cfloat", 8, CFLOAT_ALIGN, GA_CFLOAT},

{"ga_cdouble", 16, CDOUBLE_ALIGN, GA_CDOUBLE},

{"ga_cquad", 32, CQUAD_ALIGN, GA_CQUAD},

{NULL, 0, 0, -1},

{NULL, 0, 0, -1},

{NULL, 0, 0, -1},

{NULL, 0, 0, -1},

{NULL, 0, 0, -1},

{NULL, 0, 0, -1},

{"ga_half", 2, HALF_ALIGN, GA_HALF},

{"ga_size", sizeof(size_t), SIZE_ALIGN, GA_SIZE},

{"ga_ssize", sizeof(ssize_t), SSIZE_ALIGN, GA_SSIZE},

};

const gpuarray_type vector_types[] = {

{"ga_byte2", 2, 0, GA_BYTE2},

{"ga_ubyte2", 2, 0, GA_UBYTE2},

{"ga_byte3", 3, 0, GA_BYTE3},

{"ga_ubyte3", 3, 0, GA_UBYTE3},

{"ga_byte4", 4, 0, GA_BYTE4},

{"ga_ubyte4", 4, 0, GA_UBYTE4},

{"ga_byte8", 8, 0, GA_BYTE8},

{"ga_ubyte8", 8, 0, GA_UBYTE8},

{"ga_byte16", 16, 0, GA_BYTE16},

{"ga_ubyte16", 16, 0, GA_UBYTE16},

{"ga_short2", 4, 0, GA_SHORT2},

{"ga_ushort2", 4, 0, GA_USHORT2},

{"ga_short3", 6, 0, GA_SHORT3},

{"ga_ushort3", 6, 0, GA_USHORT3},

{"ga_short4", 8, 0, GA_SHORT4},

{"ga_ushort4", 8, 0, GA_USHORT4},

{"ga_short8", 16, 0, GA_SHORT8},

{"ga_ushort8", 16, 0, GA_USHORT8},

{"ga_short16", 32, 0, GA_SHORT16},

{"ga_ushort16", 32, 0, GA_USHORT16},

{"ga_int2", 8, 0, GA_INT2},

{"ga_uint2", 8, 0, GA_UINT2},

{"ga_int3", 12, 0, GA_INT3},

{"ga_uint3", 12, 0, GA_UINT3},

{"ga_int4", 16, 0, GA_INT4},

{"ga_uint4", 16, 0, GA_UINT4},

{"ga_int8", 32, 0, GA_INT8},

{"ga_uint8", 32, 0, GA_UINT8},

{"ga_int16", 64, 0, GA_INT16},

{"ga_uint16", 64, 0, GA_UINT16},

{"ga_long2", 16, 0, GA_LONG2},

{"ga_ulong2", 16, 0, GA_ULONG2},

{"ga_long3", 24, 0, GA_LONG3},

{"ga_ulong3", 24, 0, GA_ULONG3},

{"ga_long4", 32, 0, GA_LONG4},

{"ga_ulong4", 32, 0, GA_ULONG4},

{"ga_long8", 64, 0, GA_LONG8},

{"ga_ulong8", 64, 0, GA_ULONG8},

{"ga_long16", 128, 0, GA_LONG16},

{"ga_ulong16", 128, 0, GA_ULONG16},

{"ga_float2", 8, 0, GA_FLOAT2},

{"ga_float4", 16, 0, GA_FLOAT4},

{"ga_float8", 32, 0, GA_FLOAT8},

{"ga_float16", 64, 0, GA_FLOAT16},

{"ga_double2", 16, 0, GA_DOUBLE2},

{"ga_double4", 32, 0, GA_DOUBLE4},

{"ga_double8", 64, 0, GA_DOUBLE8},

{"ga_double16", 128, 0, GA_DOUBLE16},

{"ga_half2", 4, 0, GA_HALF2},

{"ga_half4", 8, 0, GA_HALF4},

{"ga_half8", 16, 0, GA_HALF8},

{"ga_half16", 32, 0, GA_HALF16},

};