1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * (C) Copyright David Gibson <[email protected]>, IBM Corporation. 2005.
4 */
5 %locations
6
7 %{
8 #include <stdio.h>
9 #include <inttypes.h>
10
11 #include "dtc.h"
12 #include "srcpos.h"
13
14 extern int yylex(void);
15 extern void yyerror(char const *s);
16 #define ERROR(loc, ...) \
17 do { \
18 srcpos_error((loc), "Error", __VA_ARGS__); \
19 treesource_error = true; \
20 } while (0)
21
22 #define YYERROR_CALL(msg) yyerror(msg)
23
24 extern struct dt_info *parser_output;
25 extern bool treesource_error;
26
is_ref_relative(const char * ref)27 static bool is_ref_relative(const char *ref)
28 {
29 return ref[0] != '/' && strchr(&ref[1], '/');
30 }
31
32 %}
33
34 %union {
35 char *propnodename;
36 char *labelref;
37 uint8_t byte;
38 struct data data;
39
40 struct {
41 struct data data;
42 int bits;
43 } array;
44
45 struct property *prop;
46 struct property *proplist;
47 struct node *node;
48 struct node *nodelist;
49 struct reserve_info *re;
50 uint64_t integer;
51 unsigned int flags;
52 }
53
54 %token DT_V1
55 %token DT_PLUGIN
56 %token DT_MEMRESERVE
57 %token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
58 %token DT_BITS
59 %token DT_DEL_PROP
60 %token DT_DEL_NODE
61 %token DT_OMIT_NO_REF
62 %token <propnodename> DT_PROPNODENAME
63 %token <integer> DT_LITERAL
64 %token <integer> DT_CHAR_LITERAL
65 %token <byte> DT_BYTE
66 %token <data> DT_STRING
67 %token <labelref> DT_LABEL
68 %token <labelref> DT_LABEL_REF
69 %token <labelref> DT_PATH_REF
70 %token DT_INCBIN
71
72 %type <data> propdata
73 %type <data> propdataprefix
74 %type <flags> header
75 %type <flags> headers
76 %type <re> memreserve
77 %type <re> memreserves
78 %type <array> arrayprefix
79 %type <data> bytestring
80 %type <prop> propdef
81 %type <proplist> proplist
82 %type <labelref> dt_ref
83
84 %type <node> devicetree
85 %type <node> nodedef
86 %type <node> subnode
87 %type <nodelist> subnodes
88
89 %type <integer> integer_prim
90 %type <integer> integer_unary
91 %type <integer> integer_mul
92 %type <integer> integer_add
93 %type <integer> integer_shift
94 %type <integer> integer_rela
95 %type <integer> integer_eq
96 %type <integer> integer_bitand
97 %type <integer> integer_bitxor
98 %type <integer> integer_bitor
99 %type <integer> integer_and
100 %type <integer> integer_or
101 %type <integer> integer_trinary
102 %type <integer> integer_expr
103
104 %%
105
106 sourcefile:
107 headers memreserves devicetree
108 {
109 parser_output = build_dt_info($1, $2, $3,
110 guess_boot_cpuid($3));
111 }
112 ;
113
114 header:
115 DT_V1 ';'
116 {
117 $$ = DTSF_V1;
118 }
119 | DT_V1 ';' DT_PLUGIN ';'
120 {
121 $$ = DTSF_V1 | DTSF_PLUGIN;
122 }
123 ;
124
125 headers:
126 header
127 | header headers
128 {
129 if ($2 != $1)
130 ERROR(&@2, "Header flags don't match earlier ones");
131 $$ = $1;
132 }
133 ;
134
135 memreserves:
136 /* empty */
137 {
138 $$ = NULL;
139 }
140 | memreserve memreserves
141 {
142 $$ = chain_reserve_entry($1, $2);
143 }
144 ;
145
146 memreserve:
147 DT_MEMRESERVE integer_prim integer_prim ';'
148 {
149 $$ = build_reserve_entry($2, $3);
150 }
151 | DT_LABEL memreserve
152 {
153 add_label(&$2->labels, $1);
154 $$ = $2;
155 }
156 ;
157
158 dt_ref: DT_LABEL_REF | DT_PATH_REF;
159
160 devicetree:
161 '/' nodedef
162 {
163 $$ = name_node($2, "");
164 }
165 | devicetree '/' nodedef
166 {
167 $$ = merge_nodes($1, $3);
168 }
169 | dt_ref nodedef
170 {
171 /*
172 * We rely on the rule being always:
173 * versioninfo plugindecl memreserves devicetree
174 * so $-1 is what we want (plugindecl)
175 */
176 if (!($<flags>-1 & DTSF_PLUGIN))
177 ERROR(&@2, "Label or path %s not found", $1);
178 else if (is_ref_relative($1))
179 ERROR(&@2, "Label-relative reference %s not supported in plugin", $1);
180 $$ = add_orphan_node(
181 name_node(build_node(NULL, NULL, NULL),
182 ""),
183 $2, $1);
184 }
185 | devicetree DT_LABEL dt_ref nodedef
186 {
187 struct node *target = get_node_by_ref($1, $3);
188
189 if (($<flags>-1 & DTSF_PLUGIN) && is_ref_relative($3))
190 ERROR(&@2, "Label-relative reference %s not supported in plugin", $3);
191
192 if (target) {
193 add_label(&target->labels, $2);
194 merge_nodes(target, $4);
195 } else
196 ERROR(&@3, "Label or path %s not found", $3);
197 $$ = $1;
198 }
199 | devicetree DT_PATH_REF nodedef
200 {
201 /*
202 * We rely on the rule being always:
203 * versioninfo plugindecl memreserves devicetree
204 * so $-1 is what we want (plugindecl)
205 */
206 if ($<flags>-1 & DTSF_PLUGIN) {
207 if (is_ref_relative($2))
208 ERROR(&@2, "Label-relative reference %s not supported in plugin", $2);
209 add_orphan_node($1, $3, $2);
210 } else {
211 struct node *target = get_node_by_ref($1, $2);
212
213 if (target)
214 merge_nodes(target, $3);
215 else
216 ERROR(&@2, "Label or path %s not found", $2);
217 }
218 $$ = $1;
219 }
220 | devicetree DT_LABEL_REF nodedef
221 {
222 struct node *target = get_node_by_ref($1, $2);
223
224 if (target) {
225 merge_nodes(target, $3);
226 } else {
227 /*
228 * We rely on the rule being always:
229 * versioninfo plugindecl memreserves devicetree
230 * so $-1 is what we want (plugindecl)
231 */
232 if ($<flags>-1 & DTSF_PLUGIN)
233 add_orphan_node($1, $3, $2);
234 else
235 ERROR(&@2, "Label or path %s not found", $2);
236 }
237 $$ = $1;
238 }
239 | devicetree DT_DEL_NODE dt_ref ';'
240 {
241 struct node *target = get_node_by_ref($1, $3);
242
243 if (target)
244 delete_node(target);
245 else
246 ERROR(&@3, "Label or path %s not found", $3);
247
248
249 $$ = $1;
250 }
251 | devicetree DT_OMIT_NO_REF dt_ref ';'
252 {
253 struct node *target = get_node_by_ref($1, $3);
254
255 if (target)
256 omit_node_if_unused(target);
257 else
258 ERROR(&@3, "Label or path %s not found", $3);
259
260
261 $$ = $1;
262 }
263 | /* empty */
264 {
265 /* build empty node */
266 $$ = name_node(build_node(NULL, NULL, NULL), "");
267 }
268 ;
269
270 nodedef:
271 '{' proplist subnodes '}' ';'
272 {
273 $$ = build_node($2, $3, &@$);
274 }
275 ;
276
277 proplist:
278 /* empty */
279 {
280 $$ = NULL;
281 }
282 | proplist propdef
283 {
284 $$ = chain_property($2, $1);
285 }
286 ;
287
288 propdef:
289 DT_PROPNODENAME '=' propdata ';'
290 {
291 $$ = build_property($1, $3, &@$);
292 }
293 | DT_PROPNODENAME ';'
294 {
295 $$ = build_property($1, empty_data, &@$);
296 }
297 | DT_DEL_PROP DT_PROPNODENAME ';'
298 {
299 $$ = build_property_delete($2);
300 }
301 | DT_LABEL propdef
302 {
303 add_label(&$2->labels, $1);
304 $$ = $2;
305 }
306 ;
307
308 propdata:
309 propdataprefix DT_STRING
310 {
311 $$ = data_merge($1, $2);
312 }
313 | propdataprefix arrayprefix '>'
314 {
315 $$ = data_merge($1, $2.data);
316 }
317 | propdataprefix '[' bytestring ']'
318 {
319 $$ = data_merge($1, $3);
320 }
321 | propdataprefix dt_ref
322 {
323 $1 = data_add_marker($1, TYPE_STRING, $2);
324 $$ = data_add_marker($1, REF_PATH, $2);
325 }
326 | propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
327 {
328 FILE *f = srcfile_relative_open($4.val, NULL);
329 struct data d;
330
331 if ($6 != 0)
332 if (fseek(f, $6, SEEK_SET) != 0)
333 die("Couldn't seek to offset %llu in \"%s\": %s",
334 (unsigned long long)$6, $4.val,
335 strerror(errno));
336
337 d = data_copy_file(f, $8);
338
339 $$ = data_merge($1, d);
340 fclose(f);
341 }
342 | propdataprefix DT_INCBIN '(' DT_STRING ')'
343 {
344 FILE *f = srcfile_relative_open($4.val, NULL);
345 struct data d = empty_data;
346
347 d = data_copy_file(f, -1);
348
349 $$ = data_merge($1, d);
350 fclose(f);
351 }
352 | propdata DT_LABEL
353 {
354 $$ = data_add_marker($1, LABEL, $2);
355 }
356 ;
357
358 propdataprefix:
359 /* empty */
360 {
361 $$ = empty_data;
362 }
363 | propdata ','
364 {
365 $$ = $1;
366 }
367 | propdataprefix DT_LABEL
368 {
369 $$ = data_add_marker($1, LABEL, $2);
370 }
371 ;
372
373 arrayprefix:
374 DT_BITS DT_LITERAL '<'
375 {
376 unsigned long long bits;
377 enum markertype type = TYPE_UINT32;
378
379 bits = $2;
380
381 switch (bits) {
382 case 8: type = TYPE_UINT8; break;
383 case 16: type = TYPE_UINT16; break;
384 case 32: type = TYPE_UINT32; break;
385 case 64: type = TYPE_UINT64; break;
386 default:
387 ERROR(&@2, "Array elements must be"
388 " 8, 16, 32 or 64-bits");
389 bits = 32;
390 }
391
392 $$.data = data_add_marker(empty_data, type, NULL);
393 $$.bits = bits;
394 }
395 | '<'
396 {
397 $$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
398 $$.bits = 32;
399 }
400 | arrayprefix integer_prim
401 {
402 if ($1.bits < 64) {
403 uint64_t mask = (1ULL << $1.bits) - 1;
404 /*
405 * Bits above mask must either be all zero
406 * (positive within range of mask) or all one
407 * (negative and sign-extended). The second
408 * condition is true if when we set all bits
409 * within the mask to one (i.e. | in the
410 * mask), all bits are one.
411 */
412 if (($2 > mask) && (($2 | mask) != -1ULL)) {
413 char *loc = srcpos_string(&@2);
414 fprintf(stderr,
415 "WARNING: %s: Value 0x%016" PRIx64
416 " truncated to 0x%0*" PRIx64 "\n",
417 loc, $2, $1.bits / 4, ($2 & mask));
418 free(loc);
419 }
420 }
421
422 $$.data = data_append_integer($1.data, $2, $1.bits);
423 }
424 | arrayprefix dt_ref
425 {
426 uint64_t val = ~0ULL >> (64 - $1.bits);
427
428 if ($1.bits == 32)
429 $1.data = data_add_marker($1.data,
430 REF_PHANDLE,
431 $2);
432 else
433 ERROR(&@2, "References are only allowed in "
434 "arrays with 32-bit elements.");
435
436 $$.data = data_append_integer($1.data, val, $1.bits);
437 }
438 | arrayprefix DT_LABEL
439 {
440 $$.data = data_add_marker($1.data, LABEL, $2);
441 }
442 ;
443
444 integer_prim:
445 DT_LITERAL
446 | DT_CHAR_LITERAL
447 | '(' integer_expr ')'
448 {
449 $$ = $2;
450 }
451 ;
452
453 integer_expr:
454 integer_trinary
455 ;
456
457 integer_trinary:
458 integer_or
459 | integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
460 ;
461
462 integer_or:
463 integer_and
464 | integer_or DT_OR integer_and { $$ = $1 || $3; }
465 ;
466
467 integer_and:
468 integer_bitor
469 | integer_and DT_AND integer_bitor { $$ = $1 && $3; }
470 ;
471
472 integer_bitor:
473 integer_bitxor
474 | integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
475 ;
476
477 integer_bitxor:
478 integer_bitand
479 | integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
480 ;
481
482 integer_bitand:
483 integer_eq
484 | integer_bitand '&' integer_eq { $$ = $1 & $3; }
485 ;
486
487 integer_eq:
488 integer_rela
489 | integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
490 | integer_eq DT_NE integer_rela { $$ = $1 != $3; }
491 ;
492
493 integer_rela:
494 integer_shift
495 | integer_rela '<' integer_shift { $$ = $1 < $3; }
496 | integer_rela '>' integer_shift { $$ = $1 > $3; }
497 | integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
498 | integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
499 ;
500
501 integer_shift:
502 integer_shift DT_LSHIFT integer_add { $$ = ($3 < 64) ? ($1 << $3) : 0; }
503 | integer_shift DT_RSHIFT integer_add { $$ = ($3 < 64) ? ($1 >> $3) : 0; }
504 | integer_add
505 ;
506
507 integer_add:
508 integer_add '+' integer_mul { $$ = $1 + $3; }
509 | integer_add '-' integer_mul { $$ = $1 - $3; }
510 | integer_mul
511 ;
512
513 integer_mul:
514 integer_mul '*' integer_unary { $$ = $1 * $3; }
515 | integer_mul '/' integer_unary
516 {
517 if ($3 != 0) {
518 $$ = $1 / $3;
519 } else {
520 ERROR(&@$, "Division by zero");
521 $$ = 0;
522 }
523 }
524 | integer_mul '%' integer_unary
525 {
526 if ($3 != 0) {
527 $$ = $1 % $3;
528 } else {
529 ERROR(&@$, "Division by zero");
530 $$ = 0;
531 }
532 }
533 | integer_unary
534 ;
535
536 integer_unary:
537 integer_prim
538 | '-' integer_unary { $$ = -$2; }
539 | '~' integer_unary { $$ = ~$2; }
540 | '!' integer_unary { $$ = !$2; }
541 ;
542
543 bytestring:
544 /* empty */
545 {
546 $$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
547 }
548 | bytestring DT_BYTE
549 {
550 $$ = data_append_byte($1, $2);
551 }
552 | bytestring DT_LABEL
553 {
554 $$ = data_add_marker($1, LABEL, $2);
555 }
556 ;
557
558 subnodes:
559 /* empty */
560 {
561 $$ = NULL;
562 }
563 | subnode subnodes
564 {
565 $$ = chain_node($1, $2);
566 }
567 | subnode propdef
568 {
569 ERROR(&@2, "Properties must precede subnodes");
570 YYERROR;
571 }
572 ;
573
574 subnode:
575 DT_PROPNODENAME nodedef
576 {
577 $$ = name_node($2, $1);
578 }
579 | DT_DEL_NODE DT_PROPNODENAME ';'
580 {
581 $$ = name_node(build_node_delete(&@$), $2);
582 }
583 | DT_OMIT_NO_REF subnode
584 {
585 $$ = omit_node_if_unused($2);
586 }
587 | DT_LABEL subnode
588 {
589 add_label(&$2->labels, $1);
590 $$ = $2;
591 }
592 ;
593
594 %%
595
596 void yyerror(char const *s)
597 {
598 ERROR(&yylloc, "%s", s);
599 }
600