Lab
/
cosmopolitan
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
cosmopolitan/third_party/chibicc/test/builtin_test.c

419 lines
12 KiB
C
Raw Blame History

#include "third_party/chibicc/test/test.h"
#define FPNAN 0
#define FPINFINITE 1
#define FPZERO 2
#define FPSUBNORMAL 3
#define FPNORMAL 4
#define FPCLASSIFY(x) \
__builtin_fpclassify(FPNAN, FPINFINITE, FPNORMAL, FPSUBNORMAL, FPZERO, x)
#define conceal(x) \
({ \
typeof(x) cloak = x; \
asm("" : "+r"(cloak)); \
cloak; \
})
struct frame {
struct frame *next;
intptr_t addr;
};
struct frame *frame(void) {
struct frame *myframe = __builtin_frame_address(0);
struct frame *parentframe = myframe->next;
return parentframe;
}
void test_frame_address(void) {
ASSERT(1, __builtin_frame_address(0) == frame());
}
void test_constant(void) {
ASSERT(1, __builtin_constant_p(1));
ASSERT(0, __builtin_constant_p(conceal(1)));
ASSERT(0, __builtin_constant_p(stdin));
ASSERT(1, __builtin_constant_p(__builtin_popcount(0b10111011)));
ASSERT(1, __builtin_constant_p(__builtin_popcountll((size_t)0b10111011)));
}
void test_ignored(void) {
ASSERT(123, __builtin_assume_aligned(123, 8));
ASSERT(123, __builtin_assume_aligned(123, 32, 8));
ASSERT(123, __builtin_expect(123, 0));
}
void __attribute__((__aligned__(16))) test_clz(void) {
ASSERT(31, __builtin_clz(1));
ASSERT(63, __builtin_clzl(1));
ASSERT(63, __builtin_clzll(1));
ASSERT(25, __builtin_clz(77));
ASSERT(4, __builtin_clz(0x08000000));
ASSERT(4, __builtin_clz(0xfff08000000));
ASSERT(25, __builtin_clz(conceal(77)));
__builtin_clz(conceal(77));
}
__attribute__((__weak__)) void test_ctz(void) {
ASSERT(0, __builtin_ctz(1));
ASSERT(0, __builtin_ctz(77));
ASSERT(27, __builtin_ctz(0x08000000));
ASSERT(27, __builtin_ctz(0xffff08000000));
ASSERT(63, __builtin_ctzl(0x8000000000000000));
ASSERT(63, __builtin_ctzll(0x8000000000000000));
ASSERT(0, __builtin_ctz(conceal(77)));
}
void test_ffs(void) {
ASSERT(0, __builtin_ffs(0));
ASSERT(1, __builtin_ffs(1));
ASSERT(1, __builtin_ffs(77));
ASSERT(28, __builtin_ffs(0x08000000));
ASSERT(28, __builtin_ffs(0xffff08000000));
ASSERT(1, __builtin_ffs(conceal(77)));
}
void test_popcnt(void) {
ASSERT(0, __builtin_popcount(0));
ASSERT(1, __builtin_popcount(1));
ASSERT(6, __builtin_popcount(0b10111011));
ASSERT(6, __builtin_popcountl(0b10111011));
ASSERT(6, __builtin_popcountll(0xbb00000000000000));
ASSERT(6, __builtin_popcountl(conceal(0b10111011)));
}
void test_bswap(void) {
ASSERT(0x3412, __builtin_bswap16(0x1234));
ASSERT(0x78563412, __builtin_bswap32(0x12345678));
ASSERT(0xefcdab8967452301, __builtin_bswap64(0x0123456789abcdef));
ASSERT(0xefcdab89, __builtin_bswap32(0x0123456789abcdef));
ASSERT(0x78563412, __builtin_bswap32(conceal(0x12345678)));
}
void test_fpclassify(void) {
float minf = __FLT_MIN__;
double min = __DBL_MIN__;
long double minl = __LDBL_MIN__;
ASSERT(FPZERO, FPCLASSIFY(.0f));
ASSERT(FPZERO, FPCLASSIFY(.0));
ASSERT(FPZERO, FPCLASSIFY(.0L));
ASSERT(FPNORMAL, FPCLASSIFY(1.f));
ASSERT(FPNORMAL, FPCLASSIFY(1.));
ASSERT(FPNORMAL, FPCLASSIFY(1.L));
ASSERT(FPNORMAL, FPCLASSIFY(1.f));
ASSERT(FPNORMAL, FPCLASSIFY(1.));
ASSERT(FPNORMAL, FPCLASSIFY(1.L));
ASSERT(FPNORMAL, FPCLASSIFY(minf));
ASSERT(FPNORMAL, FPCLASSIFY(min));
ASSERT(FPNORMAL, FPCLASSIFY(minl));
ASSERT(FPSUBNORMAL, FPCLASSIFY(minf / 2));
ASSERT(FPSUBNORMAL, FPCLASSIFY(min / 2));
ASSERT(FPSUBNORMAL, FPCLASSIFY(minl / 2));
ASSERT(FPNAN, FPCLASSIFY(__builtin_nanf("")));
ASSERT(FPNAN, FPCLASSIFY(__builtin_nan("")));
ASSERT(FPNAN, FPCLASSIFY(__builtin_nanl("")));
}
void test_strlen(void) {
ASSERT(5, strlen("hello"));
ASSERT(5, __builtin_strlen("hello"));
}
void test_strchr(void) {
ASSERT(1, __builtin_strchr("hello", 'z') == NULL);
ASSERT(0, (strcmp)(__builtin_strchr("hello", 'e'), "ello"));
}
void test_strpbrk(void) {
ASSERT(1, __builtin_strpbrk("hello", "z") == NULL);
ASSERT(0, (strcmp)(__builtin_strpbrk("hello", "ze"), "ello"));
}
void test_strstr(void) {
ASSERT(1, __builtin_strstr("hello", "sup") == NULL);
ASSERT(0, (strcmp)(__builtin_strstr("hello", "ell"), "ello"));
}
void test_memcpy(void) {
{
char x[5] = {4, 3, 2, 1, 0};
char y[5] = {0, 1, 2, 3, 4};
char z[5] = {2, 3, 4, 1, 0};
ASSERT(1, x == (memcpy)(x, y + 2, 3));
ASSERT(0, memcmp(x, z, 5));
}
{
char x[5] = {4, 3, 2, 1, 0};
char y[5] = {0, 1, 2, 3, 4};
char z[5] = {2, 3, 4, 1, 0};
ASSERT(1, x == __builtin_memcpy(x, y + 2, 3));
ASSERT(0, memcmp(x, z, 5));
}
{
int n = 3;
char x[5] = {4, 3, 2, 1, 0};
char y[5] = {0, 1, 2, 3, 4};
char z[5] = {2, 3, 4, 1, 0};
ASSERT(1, x == __builtin_memcpy(x, y + 2, n));
ASSERT(0, memcmp(x, z, 5));
}
{
char x[5] = {4, 3, 2, 1, 0};
ASSERT(1, x == __builtin_memcpy(x, x + 1, 4));
ASSERT(0, memcmp(x, (char[5]){3, 2, 1, 0, 0}, 5));
}
}
void test_add_overflow(void) {
{
int z;
ASSERT(0, __builtin_add_overflow(2, 3, &z));
ASSERT(5, z);
}
{
int x, y, z;
x = 2;
y = 3;
ASSERT(0, __builtin_add_overflow(x, y, &z));
ASSERT(5, z);
}
{
int x, y, z;
x = 0x7fffffff;
y = 1;
ASSERT(1, __builtin_add_overflow(x, y, &z));
ASSERT(-2147483648, z);
}
{
long x, y, z;
x = 0x7fffffff;
y = 1;
ASSERT(0, __builtin_add_overflow(x, y, &z));
ASSERT(2147483648, z);
}
}
void test_sub_overflow(void) {
{
int x, y, z;
x = 2;
y = 3;
ASSERT(0, __builtin_sub_overflow(x, y, &z));
ASSERT(-1, z);
}
{
int x, y, z;
x = -2147483648;
y = 1;
ASSERT(1, __builtin_sub_overflow(x, y, &z));
ASSERT(2147483647, z);
}
{
long x, y, z;
x = -2147483648;
y = 1;
ASSERT(0, __builtin_sub_overflow(x, y, &z));
ASSERT(-2147483649, z);
}
}
void test_mul_overflow(void) {
{
int x, y, z;
x = 2;
y = 3;
ASSERT(0, __builtin_mul_overflow(x, y, &z));
ASSERT(6, z);
}
{
int x, y, z;
x = 2147483647;
y = 2;
ASSERT(1, __builtin_mul_overflow(x, y, &z));
ASSERT(-2, z);
}
{
long x, y, z;
x = 2147483647;
y = 2;
ASSERT(0, __builtin_mul_overflow(x, y, &z));
ASSERT(4294967294, z);
}
}
void test_neg_overflow(void) {
{
int x, z;
x = 2;
ASSERT(0, __builtin_neg_overflow(x, &z));
ASSERT(-2, z);
}
{
int x, z;
x = -2147483648;
ASSERT(1, __builtin_neg_overflow(x, &z));
ASSERT(-2147483648, z);
}
{
long x, z;
x = -2147483648;
ASSERT(0, __builtin_neg_overflow(x, &z));
ASSERT(2147483648, z);
}
}
void test_inf(void) {
ASSERT(0, __builtin_isinf(0));
ASSERT(0, __builtin_isinf(1));
ASSERT(1, __builtin_isinf(__builtin_inff()));
ASSERT(1, __builtin_isinf(-__builtin_inff()));
ASSERT(1, __builtin_isinf(__builtin_inf()));
ASSERT(1, __builtin_isinf(-__builtin_inf()));
ASSERT(1, __builtin_isinf(__builtin_infl()));
ASSERT(1, __builtin_isinf(-__builtin_infl()));
ASSERT(1, __builtin_isfinite(0));
ASSERT(1, __builtin_isfinite(1));
ASSERT(0, __builtin_isfinite(__builtin_inff()));
ASSERT(0, __builtin_isfinite(-__builtin_inff()));
ASSERT(0, __builtin_isfinite(__builtin_inf()));
ASSERT(0, __builtin_isfinite(-__builtin_inf()));
ASSERT(0, __builtin_isfinite(__builtin_infl()));
ASSERT(0, __builtin_isfinite(-__builtin_infl()));
}
void test_signbit(void) {
ASSERT(0, !!__builtin_signbitf(0));
ASSERT(0, !!__builtin_signbitf(0.f));
ASSERT(0, !!__builtin_signbit(0.));
ASSERT(0, !!__builtin_signbitl(0.L));
ASSERT(1, !!__builtin_signbitf(-0.f));
ASSERT(1, !!__builtin_signbit(-0.));
ASSERT(1, !!__builtin_signbitl(-0.L));
ASSERT(0, !!__builtin_signbitf(__builtin_nanf("")));
ASSERT(1, !!__builtin_signbitf(-__builtin_nanf("")));
ASSERT(0, !!__builtin_signbit(__builtin_nan("")));
ASSERT(1, !!__builtin_signbit(-__builtin_nan("")));
ASSERT(0, !!__builtin_signbitl(__builtin_nanl("")));
ASSERT(1, !!__builtin_signbitl(-__builtin_nanl("")));
ASSERT(0, !!__builtin_signbitf(__builtin_inff()));
ASSERT(1, !!__builtin_signbitf(-__builtin_inff()));
ASSERT(0, !!__builtin_signbit(__builtin_inf()));
ASSERT(1, !!__builtin_signbit(-__builtin_inf()));
ASSERT(0, !!__builtin_signbitl(__builtin_infl()));
ASSERT(1, !!__builtin_signbitl(-__builtin_infl()));
}
void test_nan(void) {
ASSERT(0, __builtin_isnan(0));
ASSERT(0, __builtin_isnan(1));
ASSERT(1, __builtin_isnan(__builtin_nanf("")));
ASSERT(1, __builtin_isnan(-__builtin_nanf("")));
ASSERT(1, __builtin_isnan(__builtin_nan("")));
ASSERT(1, __builtin_isnan(-__builtin_nan("")));
ASSERT(1, __builtin_isnan(__builtin_nanl("")));
ASSERT(1, __builtin_isnan(-__builtin_nanl("")));
ASSERT(0, __builtin_isunordered(0, 0));
ASSERT(0, __builtin_isunordered(-1, 1));
ASSERT(1, __builtin_isunordered(0, __builtin_nanf("")));
ASSERT(1, __builtin_isunordered(__builtin_nanf(""), 0));
ASSERT(1, __builtin_isunordered(__builtin_nanf(""), __builtin_nanf("")));
}
void test_double(void) { /* TODO */
/* ASSERT(1, __DBL_MIN__ < 0.0L); */
/* ASSERT(1, __DBL_MAX__ > 0.0L); */
}
void test_types_compatible_p(void) {
ASSERT(1, __builtin_types_compatible_p(int, int));
ASSERT(1, __builtin_types_compatible_p(double, double));
ASSERT(0, __builtin_types_compatible_p(int, long));
ASSERT(0, __builtin_types_compatible_p(long, float));
ASSERT(1, __builtin_types_compatible_p(int *, int *));
ASSERT(0, __builtin_types_compatible_p(short *, int *));
ASSERT(0, __builtin_types_compatible_p(int **, int *));
ASSERT(1, __builtin_types_compatible_p(const int, int));
ASSERT(0, __builtin_types_compatible_p(unsigned, int));
ASSERT(1, __builtin_types_compatible_p(signed, int));
ASSERT(0, __builtin_types_compatible_p(
struct { int a; }, struct { int a; }));
ASSERT(1, __builtin_types_compatible_p(int (*)(void), int (*)(void)));
ASSERT(1, __builtin_types_compatible_p(void (*)(int), void (*)(int)));
ASSERT(1, __builtin_types_compatible_p(void (*)(int, double),
void (*)(int, double)));
ASSERT(1, __builtin_types_compatible_p(int (*)(float, double),
int (*)(float, double)));
ASSERT(0, __builtin_types_compatible_p(int (*)(float, double), int));
ASSERT(0,
__builtin_types_compatible_p(int (*)(float, double), int (*)(float)));
ASSERT(0, __builtin_types_compatible_p(int (*)(float, double),
int (*)(float, double, int)));
ASSERT(1, __builtin_types_compatible_p(double (*)(...), double (*)(...)));
ASSERT(0, __builtin_types_compatible_p(double (*)(...), double (*)(void)));
ASSERT(1, ({
typedef struct {
int a;
} T;
__builtin_types_compatible_p(T, T);
}));
ASSERT(1, ({
typedef struct {
int a;
} T;
__builtin_types_compatible_p(T, const T);
}));
ASSERT(1, ({
struct {
int a;
int b;
} x;
__builtin_types_compatible_p(typeof(x.a), typeof(x.b));
}));
}
void test_offsetof(void) {
ASSERT(0, ({
struct T {
int a;
int b;
};
__builtin_offsetof(struct T, a);
}));
ASSERT(4, ({
struct T {
int a;
int b;
};
__builtin_offsetof(struct T, b);
}));
}
int main() {
test_constant();
test_frame_address();
test_types_compatible_p();
test_clz();
test_ctz();
test_ffs();
test_bswap();
test_popcnt();
test_inf();
test_nan();
test_double();
test_fpclassify();
test_signbit();
test_memcpy();
test_offsetof();
test_ignored();
test_add_overflow();
test_sub_overflow();
test_mul_overflow();
test_neg_overflow();
test_strlen();
test_strchr();
test_strpbrk();
test_strstr();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink