Implement C99 Variable Length Arrays

Implement C99 Variable Length Arrays in tinycc: - Support VLA with multiple level (nested vla) - Update documentation with regards to VT_VLA - Add a testsuite in tcctest.c

Thomas Preud'homme committed 15 years ago

Commit a5a50ea1 parent d35a3ac6 files · +169 −33Browse files

Unified · Split

6 files

Changelog +1 −0
TODO +0 −1
tcc-doc.texi +14 −2
tcc.h +2 −0
tccgen.c +130 −30
tests/tcctest.c +22 −0

Changelog+1−0

@@ -12,6 +12,7 @@ not released: · 11 unmodified lines
12	- fix 32 to 64 bit casts, alignment and struct issues (Shinichiro Hamaji)	12	- fix 32 to 64 bit casts, alignment and struct issues (Shinichiro Hamaji)
13	- mimic all GNU -option forms supported by ld (Kirill Smelkov)	13	- mimic all GNU -option forms supported by ld (Kirill Smelkov)
14	- support indirect functions as externals (Thomas Preud'homme)	14	- support indirect functions as externals (Thomas Preud'homme)
		15	- Add support for C99 variable length arrays (Thomas Preud'homme)
15		16
16	version 0.9.25:	17	version 0.9.25:
17		18

TODO+0−1

@@ -48,7 +48,6 @@ Missing features: · 47 unmodified lines
48	- improve '-E' option.	48	- improve '-E' option.
49	- atexit (Nigel Horne)	49	- atexit (Nigel Horne)
50	- packed attribute	50	- packed attribute
51	- C99: add variable size arrays (gcc 3.2 testsuite issue)
52	- C99: add complex types (gcc 3.2 testsuite issue)	51	- C99: add complex types (gcc 3.2 testsuite issue)
53	- postfix compound literals (see 20010124-1.c)	52	- postfix compound literals (see 20010124-1.c)
54		53

tcc-doc.texi+14−2

 #define VT_BTYPE      0x000f /* mask for basic type */
 #define VT_UNSIGNED   0x0010  /* unsigned type */
 #define VT_ARRAY      0x0020  /* array type (also has VT_PTR) */
+#define VT_VLA        0x10000 /* VLA type (also has VT_PTR and VT_ARRAY) */
 #define VT_BITFIELD   0x0040  /* bitfield modifier */
+#define VT_CONSTANT   0x0800  /* const modifier */
+#define VT_VOLATILE   0x1000  /* volatile modifier */
+#define VT_SIGNED     0x2000  /* signed type */
 #define VT_STRUCT_SHIFT 16   /* structure/enum name shift (16 bits left) */
 @end example
 longs.
 Arrays are considered as pointers @code{VT_PTR} with the flag
-@code{VT_ARRAY} set.
+@code{VT_ARRAY} set. Variable length arrays are considered as special
+arrays and therefore also have flag @code{VT_VLA} set.
 The @code{VT_BITFIELD} flag can be set for chars, shorts, ints and long
 longs. If it is set, then the bitfield position is stored from bits
 #define VT_EXTERN  0x00000080  /* extern definition */
 #define VT_STATIC  0x00000100  /* static variable */
 #define VT_TYPEDEF 0x00000200  /* typedef definition */
+#define VT_INLINE  0x00000400  /* inline definition */
+#define VT_IMPORT  0x00004000  /* win32: extern data imported from dll */
+#define VT_EXPORT  0x00008000  /* win32: data exported from dll */
+#define VT_WEAK    0x00010000  /* win32: data exported from dll */
 @end example
 @section Symbols
 an idenfier is also a token, so a string is never necessary to store
 it). @code{Sym.t} gives the type of the symbol. @code{Sym.r} is usually
 the register in which the corresponding variable is stored. @code{Sym.c} is
-usually a constant associated to the symbol.
+usually a constant associated to the symbol like its address for normal
+symbols, and the number of entries for symbols representing arrays.
+Variable length arrays use @code{Sym.r} instead, which is a pointer to
+a @code{SValue} holding its runtime size.
 Four main symbol stacks are defined:

tcc.h+2−0

     union {
         long c;    /* associated number */
         int *d;   /* define token stream */
+        SValue *s; /* associated stack value */
     };
     CType type;    /* associated type */
     union {
 #define VT_BTYPE      0x000f /* mask for basic type */
 #define VT_UNSIGNED   0x0010  /* unsigned type */
 #define VT_ARRAY      0x0020  /* array type (also has VT_PTR) */
+#define VT_VLA        0x10000 /* VLA type (also has VT_PTR and VT_ARRAY) */
 #define VT_BITFIELD   0x0040  /* bitfield modifier */
 #define VT_CONSTANT   0x0800  /* const modifier */
 #define VT_VOLATILE   0x1000  /* volatile modifier */

tccgen.c+130−30

 static void decl_initializer_alloc(CType *type, AttributeDef *ad, int r, int has_init, int v, int scope);
 static void expr_eq(void);
 static void unary_type(CType *type);
+static void vla_runtime_type_size(CType *type, int *a);
 static int is_compatible_parameter_types(CType *type1, CType *type2);
 static void expr_type(CType *type);
     return type_size(pointed_type(type), &align);
 }
+static void vla_runtime_pointed_size(CType *type)
+{
+    int align;
+    vla_runtime_type_size(pointed_type(type), &align);
+}
 static inline int is_null_pointer(SValue *p)
 {
     if ((p->r & (VT_VALMASK | VT_LVAL | VT_SYM)) != VT_CONST)
         }
         /* if both pointers, then it must be the '-' op */
         if (bt1 == VT_PTR && bt2 == VT_PTR) {
+            int ptr1_is_vla;
+            ptr1_is_vla = 0;
             if (op != '-')
                 error("cannot use pointers here");
             check_comparison_pointer_types(vtop - 1, vtop, op);
             /* XXX: check that types are compatible */
-            u = pointed_size(&vtop[-1].type);
+            if (vtop[-1].type.t & VT_VLA) {
+                vla_runtime_pointed_size(&vtop[-1].type);
+                vrott(3);
+                ptr1_is_vla = 1;
+            } else {
+                u = pointed_size(&vtop[-1].type);
+            }
             gen_opic(op);
             /* set to integer type */
 #ifdef TCC_TARGET_X86_64
 #else
             vtop->type.t = VT_INT;
 #endif
-            vpushi(u);
+            if (ptr1_is_vla)
+                vswap();
+            else
+                vpushi(u);
             gen_op(TOK_PDIV);
         } else {
             /* exactly one pointer : must be '+' or '-'. */
                 swap(&t1, &t2);
             }
             type1 = vtop[-1].type;
-            type1.t &= ~VT_ARRAY;
+            type1.t &= ~(VT_ARRAY|VT_VLA);
-            u = pointed_size(&vtop[-1].type);
+            if (vtop[-1].type.t & VT_VLA)
-            if (u < 0)
+                vla_runtime_pointed_size(&vtop[-1].type);
-                error("unknown array element size");
+            else {
+                u = pointed_size(&vtop[-1].type);
+                if (u < 0)
+                    error("unknown array element size");
 #ifdef TCC_TARGET_X86_64
-            vpushll(u);
+                vpushll(u);
 #else
-            /* XXX: cast to int ? (long long case) */
+                /* XXX: cast to int ? (long long case) */
-            vpushi(u);
+                vpushi(u);
 #endif
+            }
             gen_op('*');
 #ifdef CONFIG_TCC_BCHECK
             /* if evaluating constant expression, no code should be
     vtop->type = *type;
 }
-/* return type size. Put alignment at 'a' */
+/* return type size as known at compile time. Put alignment at 'a' */
 ST_FUNC int type_size(CType *type, int *a)
 {
     Sym *s;
         *a = s->r;
         return s->c;
     } else if (bt == VT_PTR) {
-        if (type->t & VT_ARRAY) {
+        if (type->t & VT_VLA) {
+            *a = 1;
+            return 0;
+        } else if (type->t & VT_ARRAY) {
             int ts;
             s = type->ref;
     }
 }
+/* push type size as known at runtime time on top of value stack. Put
+   alignment at 'a' */
+ST_FUNC void vla_runtime_type_size(CType *type, int *a)
+{
+    if (type->t & VT_VLA) {
+        Sym *s;
+        s = type->ref;
+        vla_runtime_type_size(&s->type, a);
+        vpushv(s->s);
+        if ((vtop->r & (VT_SYM|VT_LVAL|VT_VALMASK)) != VT_CONST) {
+            gv_dup();
+            vswap();
+            vpop();
+        }
+        gen_op('*');
+    } else {
+        int size;
+        size = type_size(type, a);
+        vpushi(size);
+    }
+}
 /* return the pointed type of t */
 static inline CType *pointed_type(CType *type)
 {
         type->t = t1 | VT_FUNC;
         type->ref = s;
     } else if (tok == '[') {
+        SValue *last_vtop = NULL;
         /* array definition */
         next();
         if (tok == TOK_RESTRICT1)
             next();
         n = -1;
         if (tok != ']') {
-            n = expr_const();
+            gexpr();
-            if (n < 0)
+            if ((vtop->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST) {
-                error("invalid array size");
+                n = vtop->c.i;
+                last_vtop = vtop;
+                if (n < 0)
+                    error("invalid array size");
+            } else {
+                if (!is_integer_btype(vtop->type.t & VT_BTYPE))
+                    error("size of variable length array should be an integer");
+                type->t |= VT_VLA;
+                last_vtop = vtop;
+            }
         }
         skip(']');
         /* parse next post type */
-        t1 = type->t & VT_STORAGE;
+        t1 = type->t & (VT_STORAGE|VT_VLA);
-        type->t &= ~VT_STORAGE;
+        type->t &= ~(VT_STORAGE|VT_VLA);
         post_type(type, ad);
+        t1 |= type->t & VT_VLA;
-        /* we push a anonymous symbol which will contain the array
+        /* we push an anonymous symbol which will contain the array
            element type */
         s = sym_push(SYM_FIELD, type, 0, n);
+        if (t1 & VT_VLA) {
+            s->s = last_vtop; // That's ok, we don't need n with VLA
+        } else {
+            if (n >= 0)
+                vpop();
+        }
         type->t = t1 | VT_ARRAY | VT_PTR;
         type->ref = s;
     }
         next();
         in_sizeof++;
         unary_type(&type); // Perform a in_sizeof = 0;
-        size = type_size(&type, &align);
+        if ((t == TOK_SIZEOF) && (type.t & VT_VLA)) {
+            vla_runtime_type_size(&type, &align);
+            size = 0;
+        } else {
+            size = type_size(&type, &align);
+        }
         if (t == TOK_SIZEOF) {
-            if (size < 0)
+            if (!(type.t & VT_VLA)) {
-                error("sizeof applied to an incomplete type");
+                if (size < 0)
-            vpushi(size);
+                    error("sizeof applied to an incomplete type");
+                vpushi(size);
+            }
         } else {
             vpushi(align);
         }
         } else {
             r = s->r;
         }
-        vset(&s->type, r, s->c);
+        if (s->type.t & VT_VLA)
+            vpushv(s->s);
+        else
+            vset(&s->type, r, s->c);
         /* if forward reference, we must point to s */
         if (vtop->r & VT_SYM) {
             vtop->sym = s;
     Sym *s, *f;
     CType *t1;
-    if (type->t & VT_ARRAY) {
+    if (type->t & VT_VLA) {
+        int a;
+        CValue retcval;
+        vpush_global_sym(&func_old_type, TOK_alloca);
+        vla_runtime_type_size(type, &a);
+        gfunc_call(1);
+        /* return value */
+        retcval.i = 0;
+        vsetc(type, REG_IRET, &retcval);
+    } else if (type->t & VT_ARRAY) {
         s = type->ref;
         n = s->c;
         array_length = 0;
     ParseState saved_parse_state = {0};
     TokenString init_str;
     Section *sec;
+    Sym *vla = NULL;
     size = type_size(type, &align);
     /* If unknown size, we must evaluate it before
     if ((r & VT_VALMASK) == VT_LOCAL) {
         sec = NULL;
 #ifdef CONFIG_TCC_BCHECK
-        if (tcc_state->do_bounds_check && (type->t & VT_ARRAY))
+        if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) {
-            loc--;
+            if (type->t & VT_VLA)
+                warning("Array bound check don't work for VLA");
+            else
+                loc--;
+        }
 #endif
         loc = (loc - size) & -align;
         addr = loc;
         /* handles bounds */
         /* XXX: currently, since we do only one pass, we cannot track
            '&' operators, so we add only arrays */
-        if (tcc_state->do_bounds_check && (type->t & VT_ARRAY)) {
+        if (tcc_state->do_bounds_check && (type->t & VT_ARRAY) &&
+            !(type->t & VT_VLA)) {
             unsigned long *bounds_ptr;
             /* add padding between regions */
             loc--;
 #endif
         if (v) {
             /* local variable */
-            sym_push(v, type, r, addr);
+            vla = sym_push(v, type, r, addr);
         } else {
             /* push local reference */
             vset(type, r, addr);
         }
 #endif
     }
-    if (has_init) {
+    if (has_init || (type->t & VT_VLA)) {
         decl_initializer(type, sec, addr, 1, 0);
+        if (type->t & VT_VLA)
+            vla->s = vtop;
         /* restore parse state if needed */
         if (init_str.str) {
             tok_str_free(init_str.str);
                     if (!(type.t & VT_ARRAY))
                         r |= lvalue_type(type.t);
                     has_init = (tok == '=');
+                    if (has_init && (type.t & VT_VLA))
+                        error("Variable length array cannot be initialized");
                     if ((btype.t & VT_EXTERN) ||
-                        ((type.t & VT_ARRAY) && (type.t & VT_STATIC) &&
+                        ((type.t & VT_ARRAY) && (!(type.t & VT_VLA)) &&
-                         !has_init && l == VT_CONST && type.ref->c < 0)) {
+                        (type.t & VT_STATIC) && !has_init && l == VT_CONST &&
+                        type.ref->c < 0)) {
                         /* external variable */
                         /* NOTE: as GCC, uninitialized global static
                            arrays of null size are considered as

tests/tcctest.c+22−0

@@ -77,6 +77,7 @@ void whitespace_test(void); · 76 unmodified lines
77	void relocation_test(void);	77	void relocation_test(void);
78	void old_style_function(void);	78	void old_style_function(void);
79	void alloca_test(void);	79	void alloca_test(void);
		80	void c99_vla_test(int size1, int size2);
80	void sizeof_test(void);	81	void sizeof_test(void);
81	void typeof_test(void);	82	void typeof_test(void);
82	void local_label_test(void);	83	void local_label_test(void);
@@ -563,6 +564,7 @@ int main(int argc, char **argv) · 480 unmodified lines
563	relocation_test();	564	relocation_test();
564	old_style_function();	565	old_style_function();
565	alloca_test();	566	alloca_test();
		567	c99_vla_test(5, 2);
566	sizeof_test();	568	sizeof_test();
567	typeof_test();	569	typeof_test();
568	statement_expr_test();	570	statement_expr_test();
@@ -2018,6 +2020,26 @@ void alloca_test() · 1449 unmodified lines
2018	#endif	2020	#endif
2019	}	2021	}
2020		2022
		2023	void c99_vla_test(int size1, int size2)
		2024	{
		2025	#if defined __i386__ \|\| defined __x86_64__
		2026	int tab1[size1 * size2][2], tab2[10][2];
		2027	void tab1_ptr, tab2_ptr;
		2028
		2029	printf("Test C99 VLA 1 (sizeof): ");
		2030	printf("%s\n", (sizeof tab1 == size1 * size2 * 2 * sizeof(int)) ? "PASSED" : "FAILED");
		2031	tab1_ptr = tab1;
		2032	tab2_ptr = tab2;
		2033	printf("Test C99 VLA 2 (ptrs substract): ");
		2034	printf("%s\n", (tab2 - tab1 == (tab2_ptr - tab1_ptr) / (sizeof(int) * 2)) ? "PASSED" : "FAILED");
		2035	printf("Test C99 VLA 3 (ptr add): ");
		2036	printf("%s\n", &tab1[5][1] == (tab1_ptr + (5 * 2 + 1) * sizeof(int)) ? "PASSED" : "FAILED");
		2037	printf("Test C99 VLA 4 (ptr access): ");
		2038	tab1[size1][1] = 42;
		2039	printf("%s\n", (((int ) (tab1_ptr + (size1 * 2 + 1) * sizeof(int))) == 42) ? "PASSED" : "FAILED");
		2040	#endif
		2041	}
		2042
2021	void sizeof_test(void)	2043	void sizeof_test(void)
2022	{	2044	{
2023	int a;	2045	int a;

Implement C99 Variable Length Arrays

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code