xref: /openbmc/linux/scripts/dtc/dtc-parser.y (revision e847c767) 
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * (C) Copyright David Gibson <dwg@au1.ibm.com>, 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 
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 	;
264 
265 nodedef:
266 	  '{' proplist subnodes '}' ';'
267 		{
268 			$$ = build_node($2, $3, &@$);
269 		}
270 	;
271 
272 proplist:
273 	  /* empty */
274 		{
275 			$$ = NULL;
276 		}
277 	| proplist propdef
278 		{
279 			$$ = chain_property($2, $1);
280 		}
281 	;
282 
283 propdef:
284 	  DT_PROPNODENAME '=' propdata ';'
285 		{
286 			$$ = build_property($1, $3, &@$);
287 		}
288 	| DT_PROPNODENAME ';'
289 		{
290 			$$ = build_property($1, empty_data, &@$);
291 		}
292 	| DT_DEL_PROP DT_PROPNODENAME ';'
293 		{
294 			$$ = build_property_delete($2);
295 		}
296 	| DT_LABEL propdef
297 		{
298 			add_label(&$2->labels, $1);
299 			$$ = $2;
300 		}
301 	;
302 
303 propdata:
304 	  propdataprefix DT_STRING
305 		{
306 			$$ = data_merge($1, $2);
307 		}
308 	| propdataprefix arrayprefix '>'
309 		{
310 			$$ = data_merge($1, $2.data);
311 		}
312 	| propdataprefix '[' bytestring ']'
313 		{
314 			$$ = data_merge($1, $3);
315 		}
316 	| propdataprefix dt_ref
317 		{
318 			$1 = data_add_marker($1, TYPE_STRING, $2);
319 			$$ = data_add_marker($1, REF_PATH, $2);
320 		}
321 	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
322 		{
323 			FILE *f = srcfile_relative_open($4.val, NULL);
324 			struct data d;
325 
326 			if ($6 != 0)
327 				if (fseek(f, $6, SEEK_SET) != 0)
328 					die("Couldn't seek to offset %llu in \"%s\": %s",
329 					    (unsigned long long)$6, $4.val,
330 					    strerror(errno));
331 
332 			d = data_copy_file(f, $8);
333 
334 			$$ = data_merge($1, d);
335 			fclose(f);
336 		}
337 	| propdataprefix DT_INCBIN '(' DT_STRING ')'
338 		{
339 			FILE *f = srcfile_relative_open($4.val, NULL);
340 			struct data d = empty_data;
341 
342 			d = data_copy_file(f, -1);
343 
344 			$$ = data_merge($1, d);
345 			fclose(f);
346 		}
347 	| propdata DT_LABEL
348 		{
349 			$$ = data_add_marker($1, LABEL, $2);
350 		}
351 	;
352 
353 propdataprefix:
354 	  /* empty */
355 		{
356 			$$ = empty_data;
357 		}
358 	| propdata ','
359 		{
360 			$$ = $1;
361 		}
362 	| propdataprefix DT_LABEL
363 		{
364 			$$ = data_add_marker($1, LABEL, $2);
365 		}
366 	;
367 
368 arrayprefix:
369 	DT_BITS DT_LITERAL '<'
370 		{
371 			unsigned long long bits;
372 			enum markertype type = TYPE_UINT32;
373 
374 			bits = $2;
375 
376 			switch (bits) {
377 			case 8: type = TYPE_UINT8; break;
378 			case 16: type = TYPE_UINT16; break;
379 			case 32: type = TYPE_UINT32; break;
380 			case 64: type = TYPE_UINT64; break;
381 			default:
382 				ERROR(&@2, "Array elements must be"
383 				      " 8, 16, 32 or 64-bits");
384 				bits = 32;
385 			}
386 
387 			$$.data = data_add_marker(empty_data, type, NULL);
388 			$$.bits = bits;
389 		}
390 	| '<'
391 		{
392 			$$.data = data_add_marker(empty_data, TYPE_UINT32, NULL);
393 			$$.bits = 32;
394 		}
395 	| arrayprefix integer_prim
396 		{
397 			if ($1.bits < 64) {
398 				uint64_t mask = (1ULL << $1.bits) - 1;
399 				/*
400 				 * Bits above mask must either be all zero
401 				 * (positive within range of mask) or all one
402 				 * (negative and sign-extended). The second
403 				 * condition is true if when we set all bits
404 				 * within the mask to one (i.e. | in the
405 				 * mask), all bits are one.
406 				 */
407 				if (($2 > mask) && (($2 | mask) != -1ULL)) {
408 					char *loc = srcpos_string(&@2);
409 					fprintf(stderr,
410 						"WARNING: %s: Value 0x%016" PRIx64
411 						" truncated to 0x%0*" PRIx64 "\n",
412 						loc, $2, $1.bits / 4, ($2 & mask));
413 					free(loc);
414 				}
415 			}
416 
417 			$$.data = data_append_integer($1.data, $2, $1.bits);
418 		}
419 	| arrayprefix dt_ref
420 		{
421 			uint64_t val = ~0ULL >> (64 - $1.bits);
422 
423 			if ($1.bits == 32)
424 				$1.data = data_add_marker($1.data,
425 							  REF_PHANDLE,
426 							  $2);
427 			else
428 				ERROR(&@2, "References are only allowed in "
429 					    "arrays with 32-bit elements.");
430 
431 			$$.data = data_append_integer($1.data, val, $1.bits);
432 		}
433 	| arrayprefix DT_LABEL
434 		{
435 			$$.data = data_add_marker($1.data, LABEL, $2);
436 		}
437 	;
438 
439 integer_prim:
440 	  DT_LITERAL
441 	| DT_CHAR_LITERAL
442 	| '(' integer_expr ')'
443 		{
444 			$$ = $2;
445 		}
446 	;
447 
448 integer_expr:
449 	integer_trinary
450 	;
451 
452 integer_trinary:
453 	  integer_or
454 	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
455 	;
456 
457 integer_or:
458 	  integer_and
459 	| integer_or DT_OR integer_and { $$ = $1 || $3; }
460 	;
461 
462 integer_and:
463 	  integer_bitor
464 	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
465 	;
466 
467 integer_bitor:
468 	  integer_bitxor
469 	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
470 	;
471 
472 integer_bitxor:
473 	  integer_bitand
474 	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
475 	;
476 
477 integer_bitand:
478 	  integer_eq
479 	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
480 	;
481 
482 integer_eq:
483 	  integer_rela
484 	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
485 	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
486 	;
487 
488 integer_rela:
489 	  integer_shift
490 	| integer_rela '<' integer_shift { $$ = $1 < $3; }
491 	| integer_rela '>' integer_shift { $$ = $1 > $3; }
492 	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
493 	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
494 	;
495 
496 integer_shift:
497 	  integer_shift DT_LSHIFT integer_add { $$ = ($3 < 64) ? ($1 << $3) : 0; }
498 	| integer_shift DT_RSHIFT integer_add { $$ = ($3 < 64) ? ($1 >> $3) : 0; }
499 	| integer_add
500 	;
501 
502 integer_add:
503 	  integer_add '+' integer_mul { $$ = $1 + $3; }
504 	| integer_add '-' integer_mul { $$ = $1 - $3; }
505 	| integer_mul
506 	;
507 
508 integer_mul:
509 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
510 	| integer_mul '/' integer_unary
511 		{
512 			if ($3 != 0) {
513 				$$ = $1 / $3;
514 			} else {
515 				ERROR(&@$, "Division by zero");
516 				$$ = 0;
517 			}
518 		}
519 	| integer_mul '%' integer_unary
520 		{
521 			if ($3 != 0) {
522 				$$ = $1 % $3;
523 			} else {
524 				ERROR(&@$, "Division by zero");
525 				$$ = 0;
526 			}
527 		}
528 	| integer_unary
529 	;
530 
531 integer_unary:
532 	  integer_prim
533 	| '-' integer_unary { $$ = -$2; }
534 	| '~' integer_unary { $$ = ~$2; }
535 	| '!' integer_unary { $$ = !$2; }
536 	;
537 
538 bytestring:
539 	  /* empty */
540 		{
541 			$$ = data_add_marker(empty_data, TYPE_UINT8, NULL);
542 		}
543 	| bytestring DT_BYTE
544 		{
545 			$$ = data_append_byte($1, $2);
546 		}
547 	| bytestring DT_LABEL
548 		{
549 			$$ = data_add_marker($1, LABEL, $2);
550 		}
551 	;
552 
553 subnodes:
554 	  /* empty */
555 		{
556 			$$ = NULL;
557 		}
558 	| subnode subnodes
559 		{
560 			$$ = chain_node($1, $2);
561 		}
562 	| subnode propdef
563 		{
564 			ERROR(&@2, "Properties must precede subnodes");
565 			YYERROR;
566 		}
567 	;
568 
569 subnode:
570 	  DT_PROPNODENAME nodedef
571 		{
572 			$$ = name_node($2, $1);
573 		}
574 	| DT_DEL_NODE DT_PROPNODENAME ';'
575 		{
576 			$$ = name_node(build_node_delete(&@$), $2);
577 		}
578 	| DT_OMIT_NO_REF subnode
579 		{
580 			$$ = omit_node_if_unused($2);
581 		}
582 	| DT_LABEL subnode
583 		{
584 			add_label(&$2->labels, $1);
585 			$$ = $2;
586 		}
587 	;
588 
589 %%
590 
591 void yyerror(char const *s)
592 {
593 	ERROR(&yylloc, "%s", s);
594 }
595