Mercurial > hg-old > index.cgi

comparison src/insn_gen.c @ 77:a338d496350e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Checkpointing conversion to allow object target
author lost
date Fri, 09 Jan 2009 04:23:00 +0000
parents 31d8e85706e7
children 81fc353d4d69
comparison
equal deleted inserted replaced
76:2fe5fd7d65a3 77:a338d496350e
37 int v1, tv, rval; 37 int v1, tv, rval;
38 lwasm_expr_stack_t *s; 38 lwasm_expr_stack_t *s;
39 int f8 = 0; 39 int f8 = 0;
40 int f16 = 0; 40 int f16 = 0;
41 int isdp = 0; 41 int isdp = 0;
42 42
43 optr2 = *optr; 43 optr2 = *optr;
44 while (*optr2 && !isspace(*optr2) && *optr2 != ',') optr2++ 44 while (*optr2 && !isspace(*optr2) && *optr2 != ',') optr2++
45 /* do nothing */ ; 45 /* do nothing */ ;
46 46
47 if (*optr2 != ',' && **optr != '[') 47 if (*optr2 != ',' && **optr != '[')
60 else if (**optr == '>') 60 else if (**optr == '>')
61 { 61 {
62 (*optr)++; 62 (*optr)++;
63 f16 = 1; 63 f16 = 1;
64 } 64 }
65 s = lwasm_evaluate_expr(as, l, *optr, NULL); 65 rval = lwasm_expr_result2(as, l, optr, 0, &v1, 0);
66 if (!s) 66 if (rval != 0)
67 { 67 {
68 register_error(as, l, 1, "Bad expression"); 68 f16 = 1;
69 return; 69 v1 = 0;
70 }
71 if (!lwasm_expr_is_constant(s) && as -> passnum == 1)
72 {
73 f16 = 1;
74 l -> fsize = 2; 70 l -> fsize = 2;
75 register_error(as, l, 2, "Incomplete reference"); 71 }
76 }
77 v1 = lwasm_expr_get_value(s);
78 lwasm_expr_stack_free(s);
79 72
80 if (((v1 >> 8) & 0xff) == (as -> dpval & 0xff)) 73 if (((v1 >> 8) & 0xff) == (as -> dpval & 0xff))
81 isdp = 1; 74 isdp = 1;
82 75
76 // disallow non-explicit DP in obj target
77 if (as -> outformat == OUTPUT_OBJ && !f8)
78 f16 = 1;
79
83 if (f8 || (!f16 && isdp)) 80 if (f8 || (!f16 && isdp))
84 { 81 {
85 v1 = v1 & 0xffff; 82 v1 = v1 & 0xffff;
86 tv = v1 - ((as -> dpval) << 8); 83 tv = v1 - ((as -> dpval) << 8);
87 if (tv < 0 || tv > 0xff) 84 if (tv < 0 || tv > 0xff)
99 { 96 {
100 // everything else is 16 bit.... 97 // everything else is 16 bit....
101 lwasm_emitop(as, l, instab[opnum].ops[2]); 98 lwasm_emitop(as, l, instab[opnum].ops[2]);
102 if (extra != -1) 99 if (extra != -1)
103 lwasm_emit(as, l, extra); 100 lwasm_emit(as, l, extra);
101 l -> relocoff = as -> addr - l -> codeaddr;
104 lwasm_emit(as, l, v1 >> 8); 102 lwasm_emit(as, l, v1 >> 8);
105 lwasm_emit(as, l, v1 & 0xff); 103 lwasm_emit(as, l, v1 & 0xff);
106 return; 104 return;
107 } 105 }
108 } 106 }
134 } 132 }
135 133
136 OPFUNC(insn_gen8) 134 OPFUNC(insn_gen8)
137 { 135 {
138 int rval; 136 int rval;
137 int r;
139 138
140 if (**p == '#') 139 if (**p == '#')
141 { 140 {
142 lwasm_emitop(as, l, instab[opnum].ops[3]); 141 lwasm_emitop(as, l, instab[opnum].ops[3]);
143 (*p)++; 142 (*p)++;
144 if (lwasm_expr_result(as, l, p, EXPR_PASS2CONST | EXPR_BYTE, &rval) < 0) 143 r = lwasm_expr_result2(as, l, p, EXPR_PASS2CONST | EXPR_BYTE, &rval, 0);
145 rval = 0; 144 if (r != 0)
145 rval = 0;
146 if (r == 1 && as -> passnum == 2)
147 register_error(as, l, 2, "Illegal external or intersegment reference");
146 lwasm_emit(as, l, rval & 0xff); 148 lwasm_emit(as, l, rval & 0xff);
147 return; 149 return;
148 } 150 }
149 151
150 insn_gen_aux(as, l, p, opnum, -1); 152 insn_gen_aux(as, l, p, opnum, -1);
151 } 153 }
152 154
153 OPFUNC(insn_gen16) 155 OPFUNC(insn_gen16)
154 { 156 {
155 lwasm_expr_stack_t *s; 157 int rval, r;
156 int rval;
157 158
158 if (**p == '#') 159 if (**p == '#')
159 { 160 {
160 lwasm_emitop(as, l, instab[opnum].ops[3]); 161 lwasm_emitop(as, l, instab[opnum].ops[3]);
161 (*p)++; 162 (*p)++;
162 s = lwasm_evaluate_expr(as, l, *p, NULL); 163
163 if (!s) 164 r = lwasm_expr_result2(as, l, p, 0, &rval, 0);
164 { 165 if (r != 0)
165 register_error(as, l, 1, "Bad expression"); 166 rval = 0;
166 rval = 0; 167 if (r == 1 && as -> passnum == 2)
167 } 168 {
168 else 169 l -> relocoff = as -> addr - l -> codeaddr;
169 {
170 if (!lwasm_expr_is_constant(s))
171 register_error(as, l, 2, "Incomplete reference");
172 rval = lwasm_expr_get_value(s);
173 lwasm_expr_stack_free(s);
174 } 170 }
175 lwasm_emit(as, l, (rval >> 8) & 0xff); 171 lwasm_emit(as, l, (rval >> 8) & 0xff);
176 lwasm_emit(as, l, rval & 0xff); 172 lwasm_emit(as, l, rval & 0xff);
177 return; 173 return;
178 } 174 }
180 insn_gen_aux(as, l, p, opnum, -1); 176 insn_gen_aux(as, l, p, opnum, -1);
181 } 177 }
182 178
183 OPFUNC(insn_gen32) 179 OPFUNC(insn_gen32)
184 { 180 {
185 lwasm_expr_stack_t *s; 181 int r, rval;
186 int rval;
187 182
188 if (**p == '#') 183 if (**p == '#')
189 { 184 {
190 lwasm_emitop(as, l, instab[opnum].ops[3]); 185 lwasm_emitop(as, l, instab[opnum].ops[3]);
191 (*p)++; 186 (*p)++;
192 s = lwasm_evaluate_expr(as, l, *p, NULL); 187
193 if (!s) 188 r = lwasm_expr_result2(as, l, p, 0, &rval, 0);
194 { 189 if (r != 0)
195 register_error(as, l, 1, "Bad expression"); 190 rval = 0;
196 rval = 0; 191 if (r == 1 && as -> passnum == 2)
197 } 192 {
198 else 193 register_error(as, l, 2, "Illegal external or intersegment reference");
199 { 194 }
200 if (!lwasm_expr_is_constant(s)) 195
201 register_error(as, l, 2, "Incomplete reference");
202 rval = lwasm_expr_get_value(s);
203 lwasm_expr_stack_free(s);
204 }
205 lwasm_emit(as, l, (rval >> 24) & 0xff); 196 lwasm_emit(as, l, (rval >> 24) & 0xff);
206 lwasm_emit(as, l, (rval >> 16) & 0xff); 197 lwasm_emit(as, l, (rval >> 16) & 0xff);
207 lwasm_emit(as, l, (rval >> 8) & 0xff); 198 lwasm_emit(as, l, (rval >> 8) & 0xff);
208 lwasm_emit(as, l, rval & 0xff); 199 lwasm_emit(as, l, rval & 0xff);
209 return; 200 return;
212 insn_gen_aux(as, l, p, opnum, -1); 203 insn_gen_aux(as, l, p, opnum, -1);
213 } 204 }
214 205
215 OPFUNC(insn_imm8) 206 OPFUNC(insn_imm8)
216 { 207 {
217 lwasm_expr_stack_t *s; 208 int r, rval;
218 int rval;
219 209
220 if (**p == '#') 210 if (**p == '#')
221 { 211 {
222 lwasm_emitop(as, l, instab[opnum].ops[0]); 212 lwasm_emitop(as, l, instab[opnum].ops[0]);
223 (*p)++; 213 (*p)++;
224 s = lwasm_evaluate_expr(as, l, *p, NULL); 214
225 if (!s) 215 r = lwasm_expr_result2(as, l, p, EXPR_PASS2CONST | EXPR_BYTE, &rval, 0);
226 { 216 if (r != 0)
227 register_error(as, l, 1, "Bad expression"); 217 rval = 0;
228 rval = 0; 218 if (r == 1 && as -> passnum == 2)
229 } 219 register_error(as, l, 2, "Illegal external or intersegment reference");
230 else 220
231 {
232 if (!lwasm_expr_is_constant(s))
233 register_error(as, l, 2, "Incomplete reference");
234 rval = lwasm_expr_get_value(s);
235 lwasm_expr_stack_free(s);
236 }
237 if (rval < -128 || rval > 255) 221 if (rval < -128 || rval > 255)
238 register_error(as, l, 2, "Byte overflow"); 222 register_error(as, l, 2, "Byte overflow");
239 lwasm_emit(as, l, rval & 0xff); 223 lwasm_emit(as, l, rval & 0xff);
240 return; 224 return;
241 } 225 }