1 /*
2 * Copyright (c) 2013 Rob Clark <robclark@freedesktop.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24 %{
25 #define YYDEBUG 0
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <math.h>
31 #include "asm.h"
32
33
34 int yyget_lineno(void);
35
36 #ifdef YYDEBUG
37 int yydebug;
38 #endif
39
40 extern int yylex(void);
41 typedef void *YY_BUFFER_STATE;
42 extern YY_BUFFER_STATE yy_scan_string(const char *);
43 extern void yy_delete_buffer(YY_BUFFER_STATE);
44
45 int yyparse(void);
46
47 void yyerror(const char *error);
yyerror(const char * error)48 void yyerror(const char *error)
49 {
50 fprintf(stderr, "error at line %d: %s\n", yyget_lineno(), error);
51 }
52
53 static struct afuc_instr *instr; /* current instruction */
54
55 static void
new_instr(afuc_opc opc)56 new_instr(afuc_opc opc)
57 {
58 instr = next_instr(opc);
59 }
60
61 static void
dst(int num)62 dst(int num)
63 {
64 instr->dst = num;
65 }
66
67 static void
src1(int num)68 src1(int num)
69 {
70 instr->src1 = num;
71 }
72
73 static void
src2(int num)74 src2(int num)
75 {
76 instr->src2 = num;
77 }
78
79 static void
immed(int num)80 immed(int num)
81 {
82 instr->immed = num;
83 instr->has_immed = true;
84 }
85
86 static void
shift(int num)87 shift(int num)
88 {
89 instr->shift = num;
90 instr->has_shift = true;
91 }
92
93 static void
bit(int num)94 bit(int num)
95 {
96 instr->bit = num;
97 instr->has_bit = true;
98 }
99
100 static void
literal(uint32_t num)101 literal(uint32_t num)
102 {
103 instr->literal = num;
104 instr->is_literal = true;
105 }
106
107 static void
label(const char * str)108 label(const char *str)
109 {
110 instr->label = str;
111 }
112
113 %}
114
115 %union {
116 int tok;
117 uint32_t num;
118 const char *str;
119 }
120
121 %token <num> T_INT
122 %token <num> T_HEX
123 %token <num> T_CONTROL_REG
124 %token <num> T_SQE_REG
125 %token <str> T_LABEL_DECL
126 %token <str> T_LABEL_REF
127 %token <num> T_LITERAL
128 %token <num> T_BIT
129 %token <num> T_REGISTER
130
131 %token <tok> T_OP_NOP
132 %token <tok> T_OP_ADD
133 %token <tok> T_OP_ADDHI
134 %token <tok> T_OP_SUB
135 %token <tok> T_OP_SUBHI
136 %token <tok> T_OP_AND
137 %token <tok> T_OP_OR
138 %token <tok> T_OP_XOR
139 %token <tok> T_OP_NOT
140 %token <tok> T_OP_SHL
141 %token <tok> T_OP_USHR
142 %token <tok> T_OP_ISHR
143 %token <tok> T_OP_ROT
144 %token <tok> T_OP_MUL8
145 %token <tok> T_OP_MIN
146 %token <tok> T_OP_MAX
147 %token <tok> T_OP_CMP
148 %token <tok> T_OP_BIC
149 %token <tok> T_OP_MSB
150 %token <tok> T_OP_SETBIT
151 %token <tok> T_OP_CLRBIT
152 %token <tok> T_OP_BFI
153 %token <tok> T_OP_UBFX
154 %token <tok> T_OP_MOV
155 %token <tok> T_OP_CWRITE
156 %token <tok> T_OP_CREAD
157 %token <tok> T_OP_SWRITE
158 %token <tok> T_OP_SREAD
159 %token <tok> T_OP_STORE
160 %token <tok> T_OP_LOAD
161 %token <tok> T_OP_BRNE
162 %token <tok> T_OP_BREQ
163 %token <tok> T_OP_RET
164 %token <tok> T_OP_IRET
165 %token <tok> T_OP_CALL
166 %token <tok> T_OP_JUMP
167 %token <tok> T_OP_WAITIN
168 %token <tok> T_OP_PREEMPTLEAVE
169 %token <tok> T_OP_SETSECURE
170 %token <tok> T_LSHIFT
171 %token <tok> T_REP
172 %token <num> T_XMOV
173 %token <num> T_SDS
174
175 %type <num> reg
176 %type <num> immediate
177
178 %error-verbose
179
180 %start instrs
181
182 %%
183
184 instrs: instr_or_label instrs
185 | instr_or_label
186
187 instr_or_label: instr_r
188 | T_REP instr_r { instr->rep = true; }
189 | branch_instr
190 | other_instr
191 | T_LABEL_DECL { decl_label($1); }
192
193 /* instructions that can optionally have (rep) flag: */
194 instr_r: alu_instr { instr->xmov = 0; }
195 | T_XMOV alu_instr { instr->xmov = $1; }
196 | load_instr
197 | store_instr
198
199 /* need to special case:
200 * - not (single src, possibly an immediate)
201 * - msb (single src, must be reg)
202 * - mov (single src, plus possibly a shift)
203 * from the other ALU instructions:
204 */
205
206 alu_msb_instr: T_OP_MSB reg ',' reg { new_instr(OPC_MSB); dst($2); src1($4); }
207
208 alu_not_instr: T_OP_NOT reg ',' reg { new_instr(OPC_NOT); dst($2); src1($4); }
209 | T_OP_NOT reg ',' immediate { new_instr(OPC_NOT); dst($2); immed($4); }
210
211 alu_mov_instr: T_OP_MOV reg ',' reg { new_instr(OPC_OR); dst($2); src1(0); src2($4); }
212 | T_OP_MOV reg ',' immediate T_LSHIFT immediate {
213 new_instr(OPC_MOVI); dst($2); immed($4); shift($6);
214 }
215 | T_OP_MOV reg ',' immediate { new_instr(OPC_MOVI); dst($2); immed($4); shift(0); }
216 | T_OP_MOV reg ',' T_LABEL_REF T_LSHIFT immediate {
217 new_instr(OPC_MOVI); dst($2); label($4); shift($6);
218 }
219 | T_OP_MOV reg ',' T_LABEL_REF { new_instr(OPC_MOVI); dst($2); label($4); shift(0); }
220
221 alu_2src_op: T_OP_ADD { new_instr(OPC_ADD); }
222 | T_OP_ADDHI { new_instr(OPC_ADDHI); }
223 | T_OP_SUB { new_instr(OPC_SUB); }
224 | T_OP_SUBHI { new_instr(OPC_SUBHI); }
225 | T_OP_AND { new_instr(OPC_AND); }
226 | T_OP_OR { new_instr(OPC_OR); }
227 | T_OP_XOR { new_instr(OPC_XOR); }
228 | T_OP_SHL { new_instr(OPC_SHL); }
229 | T_OP_USHR { new_instr(OPC_USHR); }
230 | T_OP_ISHR { new_instr(OPC_ISHR); }
231 | T_OP_ROT { new_instr(OPC_ROT); }
232 | T_OP_MUL8 { new_instr(OPC_MUL8); }
233 | T_OP_MIN { new_instr(OPC_MIN); }
234 | T_OP_MAX { new_instr(OPC_MAX); }
235 | T_OP_CMP { new_instr(OPC_CMP); }
236 | T_OP_BIC { new_instr(OPC_BIC); }
237
238 alu_2src_instr: alu_2src_op reg ',' reg ',' reg { dst($2); src1($4); src2($6); }
239 | alu_2src_op reg ',' reg ',' immediate { dst($2); src1($4); immed($6); }
240
241 alu_setbit_src2: T_BIT { bit($1); instr->opc = OPC_SETBITI; }
242 | reg { src2($1); }
243
244 alu_clrsetbit_instr: T_OP_SETBIT reg ',' reg ',' alu_setbit_src2 { new_instr(OPC_SETBIT); dst($2); src1($4); }
245 | T_OP_CLRBIT reg ',' reg ',' T_BIT { new_instr(OPC_CLRBIT); dst($2); src1($4); bit($6); }
246
247 alu_bitfield_op: T_OP_UBFX { new_instr(OPC_UBFX); }
248 | T_OP_BFI { new_instr(OPC_BFI); }
249
250 alu_bitfield_instr: alu_bitfield_op reg ',' reg ',' T_BIT ',' T_BIT { dst($2); src1($4); bit($6); immed($8); }
251
252 alu_instr: alu_2src_instr
253 | alu_msb_instr
254 | alu_not_instr
255 | alu_mov_instr
256 | alu_clrsetbit_instr
257 | alu_bitfield_instr
258
259 load_op: T_OP_LOAD { new_instr(OPC_LOAD); }
260 | T_OP_CREAD { new_instr(OPC_CREAD); }
261 | T_OP_SREAD { new_instr(OPC_SREAD); }
262 store_op: T_OP_STORE { new_instr(OPC_STORE); }
263 | T_OP_CWRITE { new_instr(OPC_CWRITE); instr->sds = 0; }
264 | T_SDS T_OP_CWRITE { new_instr(OPC_CWRITE); instr->sds = $1; }
265 | T_OP_SWRITE { new_instr(OPC_SWRITE); }
266
267 preincrement:
268 | '!' { instr->preincrement = true; }
269
270 load_instr: load_op reg ',' '[' reg '+' immediate ']' preincrement {
271 dst($2); src1($5); immed($7);
272 }
273 store_instr: store_op reg ',' '[' reg '+' immediate ']' preincrement {
274 src1($2); src2($5); immed($7);
275 }
276
277 branch_op: T_OP_BRNE { new_instr(OPC_BRNE); }
278 | T_OP_BREQ { new_instr(OPC_BREQ); }
279
280 branch_instr: branch_op reg ',' T_BIT ',' T_LABEL_REF { src1($2); bit($4); label($6); }
281 | branch_op reg ',' immediate ',' T_LABEL_REF { src1($2); immed($4); label($6); }
282
283 other_instr: T_OP_CALL T_LABEL_REF { new_instr(OPC_CALL); label($2); }
284 | T_OP_PREEMPTLEAVE T_LABEL_REF { new_instr(OPC_PREEMPTLEAVE); label($2); }
285 | T_OP_SETSECURE reg ',' T_LABEL_REF { new_instr(OPC_SETSECURE); src1($2); label($4); }
286 | T_OP_RET { new_instr(OPC_RET); }
287 | T_OP_IRET { new_instr(OPC_IRET); }
288 | T_OP_JUMP T_LABEL_REF { new_instr(OPC_JUMP); label($2); }
289 | T_OP_WAITIN { new_instr(OPC_WAITIN); }
290 | T_OP_NOP { new_instr(OPC_NOP); }
291 | T_LITERAL { new_instr(OPC_RAW_LITERAL); literal($1); }
292
293 reg: T_REGISTER
294
295 immediate: T_HEX
296 | T_INT
297 | T_CONTROL_REG
298 | T_CONTROL_REG '+' immediate { $$ = $1 + $3; }
299 | T_SQE_REG
300 | T_SQE_REG '+' immediate { $$ = $1 + $3; }
301
302