compilation of misc tests

Author: rmustacc

Makefile

@@ -0,0 +1,57 @@
+#
+# CTF Tests
+#
+
+CTFDIFF = ctfdiff
+FILES = \
+	array.o \
+	bare1.o \
+	bitfields.o \
+	dedup.o \
+	empty.o \
+	enum.o \
+	extern.o \
+	file.o \
+	int.o \
+	float.o \
+	func.o \
+	fptr.o \
+	packstruct.o \
+	starr.o \
+	static.o \
+	stack.o \
+	siginfo.o \
+	struct.o \
+	typedef.o \
+	union.o \
+	union-bits.o \
+	vla.o \
+	weak.o
+
+CFLAGS = -g -Werror
+CTFFILES = $(FILES:%.o=%.ctf) $(FILES:%.o=%.ctf.orig)
+DIFFFILES = $(FILES:%.o=%.diff)
+DIFFFLAGS = -t -o -f
+CC = gcc
+
+stack.o := CFLAGS += -m64
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+%.ctf: %.o
+	$(CTFCONVERT)-altexec -L VERSION -o $@ $<
+
+%.ctf.orig: %.o
+	$(CTFCONVERT) -L VERSION -o $@ $<
+
+%.diff: %.ctf %.ctf.orig
+	$(CTFDIFF) $(DIFFFLAGS) $$(basename $@ .diff).ctf $$(basename $@ .diff).ctf.orig
+
+
+all: $(CTFFILES)
+
+diff: $(DIFFFILES)
+
+clobber:
+	rm -f $(FILES) $(CTFFILES)

array.c

@@ -0,0 +1,10 @@
+int a[3];
+double b[42];
+const char *c[] = { "17" "31", "169" };
+
+int d[4][5];
+int e[4][5][6];
+int f[4][5][6][7];
+int g[4][5][6][7][8];
+int h[4][5][6][7][8][9];
+int i[4][5][6][7][8][9][10];

bare1.c

@@ -0,0 +1,27 @@
+/*
+ * See if we emit the same things when using bare types.
+ */
+
+struct a {
+	int a;
+};
+
+typedef struct b {
+	int b;
+} b_t;
+
+enum c {
+	C = 0
+};
+
+typedef enum d {
+	D = 0
+} d_t;
+
+union e {
+	int e;
+};
+
+typedef union f {
+	int f;
+} f_t; 

bit-size.c

@@ -0,0 +1,26 @@
+/*
+ * Test that we can generate the right final structure size for the following
+ * structure.
+ */
+
+typedef unsigned long long uint64_t;
+typedef struct system_desc {
+        uint64_t ssd_lolimit:16;        /* segment limit 15:0 */
+        uint64_t ssd_lobase:16;         /* segment base 15:0 */
+        uint64_t ssd_midbase:8;         /* segment base 23:16 */
+        uint64_t ssd_type:4;            /* segment type */
+        uint64_t ssd_zero1:1;           /* must be zero */
+        uint64_t ssd_dpl:2;             /* segment descriptor priority level */
+        uint64_t ssd_p:1;               /* segment descriptor present */
+        uint64_t ssd_hilimit:4;         /* segment limit 19:16 */
+        uint64_t ssd_avl:1;             /* available to sw, but not used */
+        uint64_t ssd_resv1:2;           /* unused, ignored */
+        uint64_t ssd_gran:1;            /* limit unit (bytes vs pages) */
+        uint64_t ssd_hibase:8;          /* segment base 31:24 */
+        uint64_t ssd_hi64base:32;       /* segment base 63:32 */
+        uint64_t ssd_resv2:8;           /* unused, ignored */
+        uint64_t ssd_zero2:5;           /* must be zero */
+        uint64_t ssd_resv3:19;          /* unused, ignored */
+} system_desc_t;
+
+system_desc_t d;

bitfields.c

@@ -0,0 +1,27 @@
+struct foo {
+	char start;
+	int a:3;
+	int b:5;
+	char c;
+};
+
+#pragma pack(1)
+struct bar {
+	int a:3;
+	int b:5;
+	char c;
+};
+#pragma pack()
+
+struct odd_bits {
+	char a:2;
+	char b:4;
+	char c:2;
+	long long d:1;
+	long long e:31;
+	int f;
+};
+
+struct foo a;
+struct bar b;
+struct odd_bits c;

dedup.c

@@ -0,0 +1,22 @@
+int a = 3;
+
+int
+foo(int a, char b)
+{
+	return (a - b);
+}
+
+char c;
+
+void
+bar(signed char a, signed int b)
+{
+}
+
+struct e {
+	double c;
+	char b;
+	int a;
+};
+
+struct e f;

diff/ld/Makefile

@@ -0,0 +1,19 @@
+#
+# Test a bug where different sized structures weren't diffing properly
+#
+
+CTFDIFF = ctfdiff
+CFLAGS = -g -Werror
+CC = gcc
+RM = rm -f 
+
+all: a.ctf b.ctf
+
+%.ctf: %.o
+	$(CTFCONVERT)-altexec -L VERSION -o $@ $<
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clobber:
+	$(RM) -f *.o *.ctf

diff/ld/a.c

@@ -0,0 +1,5 @@
+typedef unsigned long ulong_t;
+typedef ulong_t size_t;
+typedef size_t foo_t;
+
+foo_t a;

diff/ld/b.c

@@ -0,0 +1,4 @@
+typedef unsigned long size_t;
+typedef size_t foo_t;
+
+foo_t a;

empty.c

@@ -0,0 +1 @@
+struct foo;

enum.c

@@ -0,0 +1,14 @@
+enum foo {
+	HELLO,
+	WORLD
+};
+
+enum bar {
+	CELES = 1,
+	TERRA = 2,
+	EDGAR = 3,
+	SABIN = 4,
+	KEFKA = -1
+};
+
+typedef enum bar bar_t;

extern.c

@@ -0,0 +1,9 @@
+struct foo;
+
+struct bar {
+	struct foo *prev;
+	struct foo *next;
+	int forward;
+};
+
+struct bar a;

file.c

@@ -0,0 +1,3 @@
+#include <stdio.h>
+
+FILE *foo;

float.c

@@ -0,0 +1,16 @@
+#include <math.h>
+#include <complex.h>
+
+/*
+ * GCC unfortuantely doesn't support imaginary types.
+ */
+
+float a;
+double b;
+long double c;
+float d = 1I;
+double e = 2I;
+long double f = 3I;
+float complex g;
+double complex h;
+long double complex i;

fptr.c

@@ -0,0 +1,11 @@
+typedef int (foo_t)(void *, const char *);
+
+typedef void (*bar_t)(void *, ...);
+
+typedef void (baz_t)(void);
+
+int
+mumble(foo_t *a, bar_t b)
+{
+	return ((int)a - (int)b);
+}

func.c

@@ -0,0 +1,32 @@
+struct s {
+	int s_int;
+};
+
+void
+foo(void)
+{
+}
+
+int
+bar(void)
+{
+	return (42);
+}
+
+int
+baz(int a, float b, long c)
+{
+	return (a + (int)b + c);
+}
+
+int
+var(int a, ...)
+{
+	return (a);
+}
+
+struct s *
+mumble(struct s *s)
+{
+	return (s);
+}

int.c

@@ -0,0 +1,19 @@
+char a;
+unsigned char b;
+signed char c;
+
+short d;
+unsigned short e;
+signed short f;
+
+int g;
+unsigned int h;
+signed int i;
+
+long j;
+unsigned long k;
+signed long l;
+
+long long m;
+unsigned long long n;
+signed long long o;

int.ctf.nodedup

@@ -0,0 +1,11 @@
+/*
+ * Simulate the conversion failure from lib/libc/port/gen/time_data.c
+ */
+
+const int __mon_lengths[2][12] = { };
+
+const int __year_lengths[2] = { 365, 366 };
+const int __yday_to_month[12] = {0, 31, 59, 90, 120, 151, 181, 212,
+	243, 273, 304, 334};
+const int __lyday_to_month[12] = {0, 31, 60, 91, 121, 152, 182, 213,
+	244, 274, 305, 335};

libc-time.c

@@ -0,0 +1,29 @@
+#
+# Test a bug where if we have two different structs in an object file
+# with different names that we don't end up merging them correctly.
+#
+
+CTFCONVERT = ctfconvert
+CVTFLAGS = -L VERSION 
+CTFMERGE = ctfmerge
+MRGFLAGS = -j1 -t -f -L VERSION
+CFLAGS = -g -Werror
+CC = gcc
+RM = rm -f 
+
+PROG = test
+CONVOBJS = a.ctf b.ctf c.ctf
+OBJS = $(CONVOBJS:%.ctf=%.o)
+
+$(PROG): $(CONVOBJS)
+	$(CC) $(CFLAGS) -o $@ $(OBJS)
+	$(CTFMERGE) $(MRGFLAGS) -o $@ $(CONVOBJS)
+
+%.o: %.c
+	$(CC) $(CFLAGS) -c $< -o $@
+
+%.ctf: %.o
+	$(CTFCONVERT)-altexec $(CVTFLAGS) -o $@ $<
+
+clobber:
+	$(RM) $(PROG) $(CONVOBJS) $(OBJS)

merge/dup/Makefile

@@ -0,0 +1,6 @@
+typedef struct foo {
+	int bar;
+	int baz;
+} foo_t;
+
+foo_t a;

merge/dup/a.c

@@ -0,0 +1,7 @@
+typedef struct foo {
+	int bar;
+	int baz;
+	char blah;
+} foo_t;
+
+foo_t b;

merge/dup/b.c

@@ -0,0 +1,8 @@
+typedef struct foo foo_t;
+extern foo_t *c;
+
+int
+main(void)
+{
+	return (0);
+}

merge/dup/c.c

@@ -0,0 +1,14 @@
+struct unpacked {
+	char a;
+	long b;
+};
+
+#pragma pack(1)
+struct packed {
+	char a;
+	long b;
+};
+#pragma pack()
+
+struct unpacked a;
+struct packed b;