Mercurial > hg-old > index.cgi
comparison src/insn_gen.c @ 77:a338d496350e
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 } |