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
14extern int yylex(void);
15extern 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
24extern struct dt_info *parser_output;
25extern bool treesource_error;
26
27static 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
106sourcefile:
107	  headers memreserves devicetree
108		{
109			parser_output = build_dt_info($1, $2, $3,
110			                              guess_boot_cpuid($3));
111		}
112	;
113
114header:
115	  DT_V1 ';'
116		{
117			$$ = DTSF_V1;
118		}
119	| DT_V1 ';' DT_PLUGIN ';'
120		{
121			$$ = DTSF_V1 | DTSF_PLUGIN;
122		}
123	;
124
125headers:
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
135memreserves:
136	  /* empty */
137		{
138			$$ = NULL;
139		}
140	| memreserve memreserves
141		{
142			$$ = chain_reserve_entry($1, $2);
143		}
144	;
145
146memreserve:
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
158dt_ref: DT_LABEL_REF | DT_PATH_REF;
159
160devicetree:
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
265nodedef:
266	  '{' proplist subnodes '}' ';'
267		{
268			$$ = build_node($2, $3, &@$);
269		}
270	;
271
272proplist:
273	  /* empty */
274		{
275			$$ = NULL;
276		}
277	| proplist propdef
278		{
279			$$ = chain_property($2, $1);
280		}
281	;
282
283propdef:
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
303propdata:
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
353propdataprefix:
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
368arrayprefix:
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
439integer_prim:
440	  DT_LITERAL
441	| DT_CHAR_LITERAL
442	| '(' integer_expr ')'
443		{
444			$$ = $2;
445		}
446	;
447
448integer_expr:
449	integer_trinary
450	;
451
452integer_trinary:
453	  integer_or
454	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
455	;
456
457integer_or:
458	  integer_and
459	| integer_or DT_OR integer_and { $$ = $1 || $3; }
460	;
461
462integer_and:
463	  integer_bitor
464	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
465	;
466
467integer_bitor:
468	  integer_bitxor
469	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
470	;
471
472integer_bitxor:
473	  integer_bitand
474	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
475	;
476
477integer_bitand:
478	  integer_eq
479	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
480	;
481
482integer_eq:
483	  integer_rela
484	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
485	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
486	;
487
488integer_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
496integer_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
502integer_add:
503	  integer_add '+' integer_mul { $$ = $1 + $3; }
504	| integer_add '-' integer_mul { $$ = $1 - $3; }
505	| integer_mul
506	;
507
508integer_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
531integer_unary:
532	  integer_prim
533	| '-' integer_unary { $$ = -$2; }
534	| '~' integer_unary { $$ = ~$2; }
535	| '!' integer_unary { $$ = !$2; }
536	;
537
538bytestring:
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
553subnodes:
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
569subnode:
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
591void yyerror(char const *s)
592{
593	ERROR(&yylloc, "%s", s);
594}
595