sigrid/tinycc

i386-asm.c+3−5

     s = table_ident[t - TOK_IDENT]->str;
     if (s[0] != '%')
         return -1;
-    t = tok_alloc(s+1, strlen(s)-1)->tok;
+    t = tok_alloc_const(s + 1);
     unget_tok(t);
     unget_tok('%');
     parse_operand(tcc_state, &op);
 		   in the C symbol table when later looking up
 		   this name.  So enter them now into the asm label
 		   list when we still know the symbol.  */
-		get_asm_sym(tok_alloc(name, strlen(name))->tok, sv->sym);
+		get_asm_sym(tok_alloc_const(name), sv->sym);
 	    }
             if (tcc_state->leading_underscore)
               cstr_ccat(add_str, '_');
 ST_FUNC void asm_clobber(uint8_t *clobber_regs, const char *str)
 {
     int reg;
-    TokenSym *ts;
 #ifdef TCC_TARGET_X86_64
     unsigned int type;
 #endif
         !strcmp(str, "cc") ||
 	!strcmp(str, "flags"))
         return;
-    ts = tok_alloc(str, strlen(str));
+    reg = tok_alloc_const(str);
-    reg = ts->tok;
     if (reg >= TOK_ASM_eax && reg <= TOK_ASM_edi) {
         reg -= TOK_ASM_eax;
     } else if (reg >= TOK_ASM_ax && reg <= TOK_ASM_di) {

i386-gen.c+19−19

             size = (size + 3) & ~3;
             /* allocate the necessary size on stack */
 #ifdef TCC_TARGET_PE
-            if (size >= 0x4096) {
+            if (size >= 4096) {
-                /* cannot call alloca with bound checking. Do stack probing. */
+                r = get_reg(RC_EAX);
-                o(0x50);               // push %eax
+                oad(0x68, size); // push size
-                oad(0xb8, size - 4);   // mov size-4,%eax
+                /* cannot call normal 'alloca' with bound checking */
-                oad(0x3d, 4096);       // p1: cmp $4096,%eax
+                gen_static_call(tok_alloc_const("__alloca"));
-                o(0x1476);             // jbe <p2>
+                gadd_sp(4);
-                oad(0x248485,-4096);   // test %eax,-4096(%esp)
+            } else
-                oad(0xec81, 4096);     // sub $4096,%esp
-                oad(0x2d, 4096);       // sub $4096,%eax
-                o(0xe5eb);             // jmp <p1>
-                o(0xc429);             // p2: sub %eax,%esp
-                oad(0xc481, size - 4); // add size-4,%esp
-                o(0x58);               // pop %eax
-            }
 #endif
-            oad(0xec81, size); /* sub $xxx, %esp */
+            {
-            /* generate structure store */
+                oad(0xec81, size); /* sub $xxx, %esp */
-            r = get_reg(RC_INT);
+                /* generate structure store */
-            o(0x89); /* mov %esp, r */
+                r = get_reg(RC_INT);
-            o(0xe0 + r);
+                o(0xe089 + (r << 8)); /* mov %esp, r */
+            }
             vset(&vtop->type, r | VT_LVAL, 0);
             vswap();
             vstore();
 {
     int a, ft, fc, swapped, r;
+    if (op == TOK_NEG) { /* unary minus */
+        gv(RC_FLOAT);
+        o(0xe0d9); /* fchs */
+        return;
+    }
     /* convert constants to memory references */
     if ((vtop[-1].r & (VT_VALMASK | VT_LVAL)) == VT_CONST) {
         vswap();

lib/alloca86.S+14−14

 # define _(s) s
 #endif
-.globl _(alloca)
+.globl _(alloca), _(__alloca)
 _(alloca):
-    pop     %edx
+_(__alloca):
-    pop     %eax
+    push    %ebp
+    mov     %esp,%ebp
+    mov     8(%ebp),%eax
     add     $3,%eax
     and     $-4,%eax
-    jz      p3
 #ifdef _WIN32
+    jmp     .+16 #p2
 p1:
-    cmp     $4096,%eax
-    jbe     p2
-    test    %eax,-4096(%esp)
     sub     $4096,%esp
     sub     $4096,%eax
-    jmp p1
+    test    %eax,(%esp)
 p2:
+    cmp     $4096,%eax
+    jae     p1
 #endif
     sub     %eax,%esp
-    mov     %esp,%eax
+    mov     4(%ebp),%eax
-p3:
+    mov     0(%ebp),%ebp
-    push    %edx
+    add     $8,%esp
-    push    %edx
+    push    %eax
+    lea     8(%esp),%eax
     ret
 /* ---------------------------------------------- */

lib/libtcc1.c+6−0

@@ -625,3 +625,9 @@ long long __fixxfdi (long double a1) · 624 unmodified lines
625	return s ? ret : -ret;	625	return s ? ret : -ret;
626	}	626	}
627	#endif /* !ARM */	627	#endif /* !ARM */
		628
		629	#if defined __x86_64__
		630	/* float constants used for unary minus operation */
		631	const float __mzerosf = -0.0;
		632	const double __mzerodf = -0.0;
		633	#endif

tcc.h+2−0

 #define TOK_SHL     '<' /* shift left */
 #define TOK_SAR     '>' /* signed shift right */
 #define TOK_SHR     0x8b /* unsigned shift right */
+#define TOK_NEG     TOK_MID /* unary minus operation (for floats) */
 #define TOK_ARROW   0xa0 /* -> */
 #define TOK_DOTS    0xa1 /* three dots */
 #define IS_NUM 4
 ST_FUNC TokenSym *tok_alloc(const char *str, int len);
+ST_FUNC int tok_alloc_const(const char *str);
 ST_FUNC const char *get_tok_str(int v, CValue *cv);
 ST_FUNC void begin_macro(TokenString *str, int alloc);
 ST_FUNC void end_macro(void);

tccasm.c+7−12

 ST_FUNC int asm_get_local_label_name(TCCState *s1, unsigned int n)
 {
     char buf[64];
-    TokenSym *ts;
     snprintf(buf, sizeof(buf), "L..%u", n);
-    ts = tok_alloc(buf, strlen(buf));
+    return tok_alloc_const(buf);
-    return ts->tok;
 }
 static int tcc_assemble_internal(TCCState *s1, int do_preprocess, int global);
     if (!name)
       return v;
     if (name[0] == '_') {
-        v = tok_alloc(name + 1, strlen(name) - 1)->tok;
+        v = tok_alloc_const(name + 1);
     } else if (!strchr(name, '.')) {
-        int n = strlen(name) + 2;
         char newname[256];
         snprintf(newname, sizeof newname, ".%s", name);
-        v = tok_alloc(newname, n - 1)->tok;
+        v = tok_alloc_const(newname);
         *addeddot = 1;
     }
     return v;
 static Sym* asm_section_sym(TCCState *s1, Section *sec)
 {
-    char buf[100];
+    char buf[100]; int label; Sym *sym;
-    int label = tok_alloc(buf,
+    snprintf(buf, sizeof buf, "L.%s", sec->name);
-        snprintf(buf, sizeof buf, "L.%s", sec->name)
+    label = tok_alloc_const(buf);
-        )->tok;
+    sym = asm_label_find(label);
-    Sym *sym = asm_label_find(label);
     return sym ? sym : asm_new_label1(s1, label, 1, sec->sh_num, 0);
 }

tccelf.c+5−4

 {
     int i, ret, phnum, phfill, shnum, file_type, file_offset, *sec_order;
     struct dyn_inf dyninf = {0};
-    struct ro_inf roinf, *roinf_use = &roinf;
+    struct ro_inf roinf;
     ElfW(Phdr) *phdr;
     Section *strsec, *interp, *dynamic, *dynstr, *note = NULL;
+#ifndef ELF_OBJ_ONLY
+    struct ro_inf *roinf_use = NULL;
+#endif
     file_type = s1->output_type;
 #if !TARGETOS_FreeBSD && !TARGETOS_NetBSD && !defined(__APPLE__) && !defined(_WIN32)
     /* GNU_RELRO */
     if (file_type != TCC_OUTPUT_OBJ)
-	phnum++;
+	phnum++, roinf_use = &roinf;
-    else
 #endif
-        roinf_use = NULL;
     /* allocate program segment headers */
     phdr = tcc_mallocz(phnum * sizeof(ElfW(Phdr)));

tccgen.c+55−44

     }
 }
+#if defined TCC_TARGET_X86_64 || defined TCC_TARGET_I386
+# define gen_negf gen_opf
+#else
+/* XXX: implement in gen_opf() for other backends too */
+void gen_negf(int op)
+{
+    /* In IEEE negate(x) isn't subtract(0,x).  Without NaNs it's
+       subtract(-0, x), but with them it's really a sign flip
+       operation.  We implement this with bit manipulation and have
+       to do some type reinterpretation for this, which TCC can do
+       only via memory.  */
+    int align, size, bt;
+    size = type_size(&vtop->type, &align);
+    bt = vtop->type.t & VT_BTYPE;
+    save_reg(gv(RC_TYPE(bt)));
+    vdup();
+    incr_bf_adr(size - 1);
+    vdup();
+    vpushi(0x80); /* flip sign */
+    gen_op('^');
+    vstore();
+    vpop();
+}
+#endif
 /* generate a floating point operation with constant propagation */
 static void gen_opif(int op)
 {
     v1 = vtop - 1;
     v2 = vtop;
+    if (op == TOK_NEG)
+        v1 = v2;
     /* currently, we cannot do computations with forward symbols */
     c1 = (v1->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
     c2 = (v2->r & (VT_VALMASK | VT_LVAL | VT_SYM)) == VT_CONST;
             f1 = v1->c.ld;
             f2 = v2->c.ld;
         }
         /* NOTE: we only do constant propagation if finite number (not
            NaN or infinity) (ANSI spec) */
-        if (!ieee_finite(f1) || !ieee_finite(f2))
+        if (!(ieee_finite(f1) || !ieee_finite(f2)) && !const_wanted)
             goto general_case;
         switch(op) {
         case '+': f1 += f2; break;
         case '-': f1 -= f2; break;
         case '*': f1 *= f2; break;
         case '/':
             if (f2 == 0.0) {
+                union { float f; unsigned u; } x1, x2, y;
 		/* If not in initializer we need to potentially generate
 		   FP exceptions at runtime, otherwise we want to fold.  */
                 if (!const_wanted)
                     goto general_case;
+                /* the run-time result of 0.0/0.0 on x87, also of other compilers
+                   when used to compile the f1 /= f2 below, would be -nan */
+                x1.f = f1, x2.f = f2;
+                if (f1 == 0.0)
+                    y.u = 0x7fc00000; /* nan */
+                else
+                    y.u = 0x7f800000; /* infinity */
+                y.u |= (x1.u ^ x2.u) & 0x80000000; /* set sign */
+                f1 = y.f;
+                break;
             }
             f1 /= f2;
             break;
+        case TOK_NEG:
+            f1 = -f1;
+            goto unary_result;
             /* XXX: also handles tests ? */
         default:
             goto general_case;
         }
+        vtop--;
+    unary_result:
         /* XXX: overflow test ? */
         if (v1->type.t == VT_FLOAT) {
             v1->c.f = f1;
         } else {
             v1->c.ld = f1;
         }
-        vtop--;
     } else {
     general_case:
-        gen_opf(op);
+        if (op == TOK_NEG) {
+            gen_negf(op);
+        } else {
+            gen_opf(op);
+        }
     }
 }
     case '-':
         next();
         unary();
-        t = vtop->type.t & VT_BTYPE;
+	if (is_float(vtop->type.t)) {
-	if (is_float(t)) {
+            gen_opif(TOK_NEG);
-            if ((vtop->r & VT_VALMASK) == VT_CONST) {
-                /* This is what gen_opif would do if we had a NEG operation.  */
-                if (t == VT_FLOAT)
-                  vtop->c.f = -vtop->c.f;
-                else if (t == VT_DOUBLE)
-                  vtop->c.d = -vtop->c.d;
-                else
-                  vtop->c.ld = -vtop->c.ld;
-            } else {
-                /* In IEEE negate(x) isn't subtract(0,x).  Without NaNs it's
-                   subtract(-0, x), but with them it's really a sign flip
-                   operation.  We implement this with bit manipulation and have
-                   to do some type reinterpretation for this, which TCC can do
-                   only via memory.  */
-                int align, size = type_size(&vtop->type, &align);
-                save_reg(gv(RC_TYPE(t)));
-                vdup();
-                gaddrof();
-                vtop->type = char_pointer_type;
-                /* Byte of sign bit.  For big endian, this would have to
-                   add zero always.  */
-#if defined(TCC_TARGET_X86_64) || defined(TCC_TARGET_I386)
-                /* sizeof long double is 12 or 16 here, but it's
-                   really the 80bit extended float format.  */
-                if (t == VT_LDOUBLE)
-                  size = 10;
-#endif
-                vpushi(size - 1);
-                gen_op('+');
-                indir();
-                vdup();
-                vpushi(0x80); /* flip sign */
-                gen_op('^');
-                vstore();
-                vpop();
-            }
 	} else {
             vpushi(0);
             vswap();

tccpp.c+6−0

     return tok_alloc_new(pts, str, len);
 }
+ST_FUNC int tok_alloc_const(const char *str)
+{
+    return tok_alloc(str, strlen(str))->tok;
+}
 /* XXX: buffer overflow */
 /* XXX: float tokens */
 ST_FUNC const char *get_tok_str(int v, CValue *cv)

tcctok.h+2−0

@@ -100,6 +100,8 @@ · 99 unmodified lines
100	DEF(TOK___NAN__, "__nan__")	100	DEF(TOK___NAN__, "__nan__")
101	DEF(TOK___SNAN__, "__snan__")	101	DEF(TOK___SNAN__, "__snan__")
102	DEF(TOK___INF__, "__inf__")	102	DEF(TOK___INF__, "__inf__")
		103	DEF(TOK___mzerosf, "__mzerosf")
		104	DEF(TOK___mzerodf, "__mzerodf")
103		105
104	/* attribute identifiers */	106	/* attribute identifiers */
105	/* XXX: handle all tokens generically since speed is not critical */	107	/* XXX: handle all tokens generically since speed is not critical */

x86_64-gen.c+26−2

@@ -1813,14 +1813,38 @@ void gen_opl(int op) · 1812 unmodified lines
1813	gen_opi(op);	1813	gen_opi(op);
1814	}	1814	}
1815		1815
		1816	void vpush_const(int t, int v)
		1817	{
		1818	CType ctype = { t \| VT_CONSTANT, 0 };
		1819	vpushsym(&ctype, external_global_sym(v, &ctype));
		1820	vtop->r \|= VT_LVAL;
		1821	}
		1822
1816	/* generate a floating point operation 'v = t1 op t2' instruction. The	1823	/* generate a floating point operation 'v = t1 op t2' instruction. The
1817	two operands are guaranteed to have the same floating point type */	1824	two operands are guaranteed to have the same floating point type */
1818	/* XXX: need to use ST1 too */	1825	/* XXX: need to use ST1 too */
1819	void gen_opf(int op)	1826	void gen_opf(int op)
1820	{	1827	{
1821	int a, ft, fc, swapped, r;	1828	int a, ft, fc, swapped, r;
1822	int float_type =	1829	int bt = vtop->type.t & VT_BTYPE;
1823	(vtop->type.t & VT_BTYPE) == VT_LDOUBLE ? RC_ST0 : RC_FLOAT;	1830	int float_type = bt == VT_LDOUBLE ? RC_ST0 : RC_FLOAT;
		1831
		1832	if (op == TOK_NEG) { /* unary minus */
		1833	gv(float_type);
		1834	if (float_type == RC_ST0) {
		1835	o(0xe0d9); /* fchs */
		1836	} else {
		1837	/* -0.0, in libtcc1.c */
		1838	vpush_const(bt, bt == VT_FLOAT ? TOK___mzerosf : TOK___mzerodf);
		1839	gv(RC_FLOAT);
		1840	if (bt == VT_DOUBLE)
		1841	o(0x66);
		1842	/* xorp[sd] %xmm1, %xmm0 */
		1843	o(0xc0570f \| (REG_VALUE(vtop[0].r) + REG_VALUE(vtop[-1].r)*8) << 16);
		1844	vtop--;
		1845	}
		1846	return;
		1847	}
1824		1848
1825	/* convert constants to memory references */	1849	/* convert constants to memory references */
1826	if ((vtop[-1].r & (VT_VALMASK \| VT_LVAL)) == VT_CONST) {	1850	if ((vtop[-1].r & (VT_VALMASK \| VT_LVAL)) == VT_CONST) {

tccgen: introduce TOK_NEG for unary minus

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code