Support local register variables

Similar to GCC a local asm register variable enforces the use of a specified register in asm operands (and doesn't otherwise matter). Works only if the variable is directly mentioned as operand. For that we now generally store a backpointer from an SValue to a Sym when the SValue was the result of unary() parsing a symbol identifier.

Michael Matz committed 10 years ago

Commit f081acb1 parent 3bc9c324 files · +58 −6Browse files

Unified · Split

4 files

i386-asm.c +33 −0
tcc.h +5 −3
tccgen.c +17 −3
tests/tcctest.c +3 −0

i386-asm.c+33−0

@@ -1185,6 +1185,28 @@ static const char skip_constraint_modifiers(const char p) · 1184 unmodified lines
1185	return p;	1185	return p;
1186	}	1186	}
1187		1187
		1188	/* If T (a token) is of the form "%reg" returns the register
		1189	number and type, otherwise return -1. */
		1190	ST_FUNC int asm_parse_regvar (int t)
		1191	{
		1192	const char *s;
		1193	Operand op;
		1194	if (t < TOK_IDENT)
		1195	return -1;
		1196	s = table_ident[t - TOK_IDENT]->str;
		1197	if (s[0] != '%')
		1198	return -1;
		1199	t = tok_alloc(s+1, strlen(s)-1)->tok;
		1200	unget_tok(t);
		1201	unget_tok('%');
		1202	parse_operand(tcc_state, &op);
		1203	/* Accept only integer regs for now. */
		1204	if (op.type & OP_REG)
		1205	return op.reg;
		1206	else
		1207	return -1;
		1208	}
		1209
1188	#define REG_OUT_MASK 0x01	1210	#define REG_OUT_MASK 0x01
1189	#define REG_IN_MASK 0x02	1211	#define REG_IN_MASK 0x02
1190		1212
@@ -1227,6 +1249,11 @@ ST_FUNC void asm_compute_constraints(ASMOperand *operands, · 36 unmodified lines
1227	tcc_error("cannot reference twice the same operand");	1249	tcc_error("cannot reference twice the same operand");
1228	operands[k].input_index = i;	1250	operands[k].input_index = i;
1229	op->priority = 5;	1251	op->priority = 5;
		1252	} else if ((op->vt->r & VT_VALMASK) == VT_LOCAL
		1253	&& op->vt->sym
		1254	&& (reg = op->vt->sym->r & VT_VALMASK) < VT_CONST) {
		1255	op->priority = 1;
		1256	op->reg = reg;
1230	} else {	1257	} else {
1231	op->priority = constraint_priority(str);	1258	op->priority = constraint_priority(str);
1232	}	1259	}
@@ -1274,6 +1301,12 @@ ST_FUNC void asm_compute_constraints(ASMOperand *operands, · 41 unmodified lines
1274	} else {	1301	} else {
1275	reg_mask = REG_IN_MASK;	1302	reg_mask = REG_IN_MASK;
1276	}	1303	}
		1304	if (op->reg >= 0) {
		1305	if (is_reg_allocated(op->reg))
		1306	tcc_error("asm regvar requests register that's taken already");
		1307	reg = op->reg;
		1308	goto reg_found;
		1309	}
1277	try_next:	1310	try_next:
1278	c = *str++;	1311	c = *str++;
1279	switch(c) {	1312	switch(c) {

tcc.h+5−3

     unsigned short r2;     /* second register, used for 'long long'
                               type. If not used, set to VT_CONST */
     CValue c;              /* constant, if VT_CONST */
-    struct Sym *sym;       /* symbol, if (VT_SYM | VT_CONST) */
+    struct Sym *sym;       /* symbol, if (VT_SYM | VT_CONST), or if
+    			      result of unary() for an identifier. */
 } SValue;
 struct Attribute {
         int scope;  /* scope level for locals */
     };
     union {
-        long r;    /* associated register */
+        long r;    /* associated register or VT_CONST/VT_LOCAL and LVAL type */
         struct Attribute a;
     };
     union {
     };
     CType type;    /* associated type */
     union {
-        struct Sym *next; /* next related symbol */
+        struct Sym *next; /* next related symbol (for fields and anoms) */
         long jnext; /* next jump label */
     };
     struct Sym *prev; /* prev symbol in stack */
 ST_FUNC void gen_expr64(ExprValue *pe);
 #endif
 ST_FUNC void asm_opcode(TCCState *s1, int opcode);
+ST_FUNC int asm_parse_regvar(int t);
 ST_FUNC void asm_compute_constraints(ASMOperand *operands, int nb_operands, int nb_outputs, const uint8_t *clobber_regs, int *pout_reg);
 ST_FUNC void subst_asm_operand(CString *add_str, SValue *sv, int modifier);
 ST_FUNC void asm_gen_code(ASMOperand *operands, int nb_operands, int nb_outputs, int is_output, uint8_t *clobber_regs, int out_reg);

tccgen.c+17−3

     Sym *s;
     s = sym_malloc();
-    s->asm_label = 0;
+    s->scope = 0;
     s->v = v;
     s->type.t = t;
     s->type.ref = NULL;
     vtop->r = r;
     vtop->r2 = VT_CONST;
     vtop->c = *vc;
+    vtop->sym = NULL;
 }
 /* push constant of type "type" with useless value */
             r = VT_SYM | VT_CONST;
         } else {
             r = s->r;
+	    /* A symbol that has a register is a local register variable,
+	       which starts out as VT_LOCAL value.  */
+	    if ((r & VT_VALMASK) < VT_CONST)
+	      r = (r & ~VT_VALMASK) | VT_LOCAL;
         }
         vset(&s->type, r, s->c);
-        /* if forward reference, we must point to s */
+        /* Point to s as backpointer (even without r&VT_SYM).
+	   Will be used by at least the x86 inline asm parser for
+	   regvars.  */
+	vtop->sym = s;
         if (vtop->r & VT_SYM) {
-            vtop->sym = s;
             vtop->c.i = 0;
         }
         break;
 #endif
         if (v) {
             /* local variable */
+#ifdef CONFIG_TCC_ASM
+	    if (ad->asm_label) {
+		int reg = asm_parse_regvar(ad->asm_label);
+		if (reg >= 0)
+		    r = (r & ~VT_VALMASK) | reg;
+	    }
+#endif
             sym_push(v, type, r, addr);
         } else {
             /* push local reference */

tests/tcctest.c+3−0

 #ifdef BOOL_ISOC99
     _Bool somebool;
 #endif
+    register int regvar asm("%esi");
     printf("inline asm:\n");
     val = 44;
     fancy_copy2 (&val, &val2);
     printf ("fancycpy2(%d)=%d\n", val, val2);
+    asm volatile ("mov $0x4243, %%esi" : "=r" (regvar));
+    printf ("regvar=%x\n", regvar);
     return;
  label1:
     goto label2;

Support local register variables

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code