Viewing file:  establish-c.c (4.55 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <ISO_Fortran_binding.h>
#include "dump-descriptors.h"
/* For simplicity, point descriptors at a static buffer. BUFSIZE should
be large enough for any of the standard types and we'll use DIM0 and DIM1
for array dimensions. */
#define BUFSIZE 64
#define DIM0 3
#define DIM1 10
#define ARRAYBUFSIZE BUFSIZE * DIM0 * DIM1
static char *buf[ARRAYBUFSIZE] __attribute__ ((aligned (8)));
static CFI_index_t extents[] = {DIM0, DIM1};
/* Magic number to use for elem_len field. */
#define MAGIC_ELEM_LEN 20
struct tc_info
{
CFI_type_t typecode;
char *name;
size_t size;
};
static struct tc_info tc_table[] =
{
{ CFI_type_signed_char, "CFI_type_signed_char", sizeof (signed char) },
{ CFI_type_short, "CFI_type_short", sizeof (short) },
{ CFI_type_int, "CFI_type_int", sizeof (int) },
{ CFI_type_long, "CFI_type_long", sizeof (long) },
{ CFI_type_long_long, "CFI_type_long_long", sizeof (long long) },
{ CFI_type_size_t, "CFI_type_size_t", sizeof (size_t) },
{ CFI_type_int8_t, "CFI_type_int8_t", sizeof (int8_t) },
{ CFI_type_int16_t, "CFI_type_int16_t", sizeof (int16_t) },
{ CFI_type_int32_t, "CFI_type_int32_t", sizeof (int32_t) },
{ CFI_type_int64_t, "CFI_type_int64_t", sizeof (int64_t) },
{ CFI_type_int_least8_t, "CFI_type_int_least8_t", sizeof (int_least8_t) },
{ CFI_type_int_least16_t, "CFI_type_int_least16_t", sizeof (int_least16_t) },
{ CFI_type_int_least32_t, "CFI_type_int_least32_t", sizeof (int_least32_t) },
{ CFI_type_int_least64_t, "CFI_type_int_least64_t", sizeof (int_least64_t) },
{ CFI_type_int_fast8_t, "CFI_type_int_fast8_t", sizeof (int_fast8_t) },
{ CFI_type_int_fast16_t, "CFI_type_int_fast16_t", sizeof (int_fast16_t) },
{ CFI_type_int_fast32_t, "CFI_type_int_fast32_t", sizeof (int_fast32_t) },
{ CFI_type_int_fast64_t, "CFI_type_int_fast64_t", sizeof (int_fast64_t) },
{ CFI_type_intmax_t, "CFI_type_intmax_t", sizeof (intmax_t) },
{ CFI_type_intptr_t, "CFI_type_intptr_t", sizeof (intptr_t) },
{ CFI_type_ptrdiff_t, "CFI_type_ptrdiff_t", sizeof (ptrdiff_t) },
{ CFI_type_float, "CFI_type_float", sizeof (float) },
{ CFI_type_double, "CFI_type_double", sizeof (double) },
{ CFI_type_long_double, "CFI_type_long_double", sizeof (long double) },
{ CFI_type_float_Complex, "CFI_type_float_Complex",
sizeof (float _Complex) },
{ CFI_type_double_Complex, "CFI_type_double_Complex",
sizeof (double _Complex) },
{ CFI_type_long_double_Complex, "CFI_type_long_double_Complex",
sizeof (long double _Complex) },
{ CFI_type_Bool, "CFI_type_Bool", sizeof (_Bool) },
{ CFI_type_char, "CFI_type_char", sizeof (char) },
{ CFI_type_cptr, "CFI_type_cptr", sizeof (void *) },
{ CFI_type_struct, "CFI_type_struct", 0 },
{ CFI_type_other, "CFI_type_other", -1 }
};
int
test_array (struct tc_info *tc, void *ptr, CFI_attribute_t attr)
{
CFI_CDESC_T(2) desc;
CFI_cdesc_t *a = (CFI_cdesc_t *) &desc;
int bad = 0;
size_t elem_len;
/* Initialize the descriptor to garbage values so we can confirm it's
properly initialized with good ones later. */
memset (a, -1, sizeof(desc));
check_CFI_status ("CFI_establish",
CFI_establish (a, ptr, attr, tc->typecode,
MAGIC_ELEM_LEN, 2, extents));
/* elem_len is ignored unless type is CFI type struct, CFI type other,
or a character type. */
if (tc->typecode == CFI_type_char
|| tc->typecode == CFI_type_struct
|| tc->typecode == CFI_type_other)
elem_len = MAGIC_ELEM_LEN;
else
elem_len = tc->size;
if (a->elem_len != elem_len
|| a->base_addr != ptr
|| a->type != tc->typecode
|| a->version != CFI_VERSION
|| a->attribute != attr
|| a->rank != 2
|| (ptr &&
/* extents parameter is ignored if ptr is null */
(a->dim[0].lower_bound != 0
|| a->dim[0].extent != DIM0
|| a->dim[0].sm != elem_len
|| a->dim[1].lower_bound != 0
|| a->dim[1].extent != DIM1
|| a->dim[1].sm != elem_len*DIM0)))
{
fprintf (stderr, "Bad array descriptor for %s:\n", tc->name);
dump_CFI_cdesc_t (a);
return 1;
}
return 0;
}
/* External entry point. */
extern void ctest_establish (void);
void
ctest_establish (void)
{
int ncodes = sizeof (tc_table) / sizeof (struct tc_info);
int i;
int bad = 0;
for (i = 0; i < ncodes; i++)
{
bad += test_array (&tc_table[i], (void *)buf, CFI_attribute_other);
bad += test_array (&tc_table[i], NULL, CFI_attribute_allocatable);
bad += test_array (&tc_table[i], (void *)buf, CFI_attribute_pointer);
}
if (bad)
abort ();
}
|
