xref: /openbmc/linux/scripts/dtc/dtc-parser.y (revision 93d90ad7) 
1 /*
2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, IBM Corporation.  2005.
3  *
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation; either version 2 of the
8  * License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  *  General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18  *                                                                   USA
19  */
20 
21 %{
22 #include <stdio.h>
23 
24 #include "dtc.h"
25 #include "srcpos.h"
26 
27 YYLTYPE yylloc;
28 
29 extern int yylex(void);
30 extern void print_error(char const *fmt, ...);
31 extern void yyerror(char const *s);
32 
33 extern struct boot_info *the_boot_info;
34 extern int treesource_error;
35 
36 static unsigned long long eval_literal(const char *s, int base, int bits);
37 static unsigned char eval_char_literal(const char *s);
38 %}
39 
40 %union {
41 	char *propnodename;
42 	char *literal;
43 	char *labelref;
44 	unsigned int cbase;
45 	uint8_t byte;
46 	struct data data;
47 
48 	struct {
49 		struct data	data;
50 		int		bits;
51 	} array;
52 
53 	struct property *prop;
54 	struct property *proplist;
55 	struct node *node;
56 	struct node *nodelist;
57 	struct reserve_info *re;
58 	uint64_t integer;
59 }
60 
61 %token DT_V1
62 %token DT_MEMRESERVE
63 %token DT_LSHIFT DT_RSHIFT DT_LE DT_GE DT_EQ DT_NE DT_AND DT_OR
64 %token DT_BITS
65 %token DT_DEL_PROP
66 %token DT_DEL_NODE
67 %token <propnodename> DT_PROPNODENAME
68 %token <literal> DT_LITERAL
69 %token <literal> DT_CHAR_LITERAL
70 %token <cbase> DT_BASE
71 %token <byte> DT_BYTE
72 %token <data> DT_STRING
73 %token <labelref> DT_LABEL
74 %token <labelref> DT_REF
75 %token DT_INCBIN
76 
77 %type <data> propdata
78 %type <data> propdataprefix
79 %type <re> memreserve
80 %type <re> memreserves
81 %type <array> arrayprefix
82 %type <data> bytestring
83 %type <prop> propdef
84 %type <proplist> proplist
85 
86 %type <node> devicetree
87 %type <node> nodedef
88 %type <node> subnode
89 %type <nodelist> subnodes
90 
91 %type <integer> integer_prim
92 %type <integer> integer_unary
93 %type <integer> integer_mul
94 %type <integer> integer_add
95 %type <integer> integer_shift
96 %type <integer> integer_rela
97 %type <integer> integer_eq
98 %type <integer> integer_bitand
99 %type <integer> integer_bitxor
100 %type <integer> integer_bitor
101 %type <integer> integer_and
102 %type <integer> integer_or
103 %type <integer> integer_trinary
104 %type <integer> integer_expr
105 
106 %%
107 
108 sourcefile:
109 	  DT_V1 ';' memreserves devicetree
110 		{
111 			the_boot_info = build_boot_info($3, $4,
112 							guess_boot_cpuid($4));
113 		}
114 	;
115 
116 memreserves:
117 	  /* empty */
118 		{
119 			$$ = NULL;
120 		}
121 	| memreserve memreserves
122 		{
123 			$$ = chain_reserve_entry($1, $2);
124 		}
125 	;
126 
127 memreserve:
128 	  DT_MEMRESERVE integer_prim integer_prim ';'
129 		{
130 			$$ = build_reserve_entry($2, $3);
131 		}
132 	| DT_LABEL memreserve
133 		{
134 			add_label(&$2->labels, $1);
135 			$$ = $2;
136 		}
137 	;
138 
139 devicetree:
140 	  '/' nodedef
141 		{
142 			$$ = name_node($2, "");
143 		}
144 	| devicetree '/' nodedef
145 		{
146 			$$ = merge_nodes($1, $3);
147 		}
148 	| devicetree DT_REF nodedef
149 		{
150 			struct node *target = get_node_by_ref($1, $2);
151 
152 			if (target)
153 				merge_nodes(target, $3);
154 			else
155 				print_error("label or path, '%s', not found", $2);
156 			$$ = $1;
157 		}
158 	| devicetree DT_DEL_NODE DT_REF ';'
159 		{
160 			struct node *target = get_node_by_ref($1, $3);
161 
162 			if (!target)
163 				print_error("label or path, '%s', not found", $3);
164 			else
165 				delete_node(target);
166 
167 			$$ = $1;
168 		}
169 	;
170 
171 nodedef:
172 	  '{' proplist subnodes '}' ';'
173 		{
174 			$$ = build_node($2, $3);
175 		}
176 	;
177 
178 proplist:
179 	  /* empty */
180 		{
181 			$$ = NULL;
182 		}
183 	| proplist propdef
184 		{
185 			$$ = chain_property($2, $1);
186 		}
187 	;
188 
189 propdef:
190 	  DT_PROPNODENAME '=' propdata ';'
191 		{
192 			$$ = build_property($1, $3);
193 		}
194 	| DT_PROPNODENAME ';'
195 		{
196 			$$ = build_property($1, empty_data);
197 		}
198 	| DT_DEL_PROP DT_PROPNODENAME ';'
199 		{
200 			$$ = build_property_delete($2);
201 		}
202 	| DT_LABEL propdef
203 		{
204 			add_label(&$2->labels, $1);
205 			$$ = $2;
206 		}
207 	;
208 
209 propdata:
210 	  propdataprefix DT_STRING
211 		{
212 			$$ = data_merge($1, $2);
213 		}
214 	| propdataprefix arrayprefix '>'
215 		{
216 			$$ = data_merge($1, $2.data);
217 		}
218 	| propdataprefix '[' bytestring ']'
219 		{
220 			$$ = data_merge($1, $3);
221 		}
222 	| propdataprefix DT_REF
223 		{
224 			$$ = data_add_marker($1, REF_PATH, $2);
225 		}
226 	| propdataprefix DT_INCBIN '(' DT_STRING ',' integer_prim ',' integer_prim ')'
227 		{
228 			FILE *f = srcfile_relative_open($4.val, NULL);
229 			struct data d;
230 
231 			if ($6 != 0)
232 				if (fseek(f, $6, SEEK_SET) != 0)
233 					print_error("Couldn't seek to offset %llu in \"%s\": %s",
234 						     (unsigned long long)$6,
235 						     $4.val,
236 						     strerror(errno));
237 
238 			d = data_copy_file(f, $8);
239 
240 			$$ = data_merge($1, d);
241 			fclose(f);
242 		}
243 	| propdataprefix DT_INCBIN '(' DT_STRING ')'
244 		{
245 			FILE *f = srcfile_relative_open($4.val, NULL);
246 			struct data d = empty_data;
247 
248 			d = data_copy_file(f, -1);
249 
250 			$$ = data_merge($1, d);
251 			fclose(f);
252 		}
253 	| propdata DT_LABEL
254 		{
255 			$$ = data_add_marker($1, LABEL, $2);
256 		}
257 	;
258 
259 propdataprefix:
260 	  /* empty */
261 		{
262 			$$ = empty_data;
263 		}
264 	| propdata ','
265 		{
266 			$$ = $1;
267 		}
268 	| propdataprefix DT_LABEL
269 		{
270 			$$ = data_add_marker($1, LABEL, $2);
271 		}
272 	;
273 
274 arrayprefix:
275 	DT_BITS DT_LITERAL '<'
276 		{
277 			$$.data = empty_data;
278 			$$.bits = eval_literal($2, 0, 7);
279 
280 			if (($$.bits !=  8) &&
281 			    ($$.bits != 16) &&
282 			    ($$.bits != 32) &&
283 			    ($$.bits != 64))
284 			{
285 				print_error("Only 8, 16, 32 and 64-bit elements"
286 					    " are currently supported");
287 				$$.bits = 32;
288 			}
289 		}
290 	| '<'
291 		{
292 			$$.data = empty_data;
293 			$$.bits = 32;
294 		}
295 	| arrayprefix integer_prim
296 		{
297 			if ($1.bits < 64) {
298 				uint64_t mask = (1ULL << $1.bits) - 1;
299 				/*
300 				 * Bits above mask must either be all zero
301 				 * (positive within range of mask) or all one
302 				 * (negative and sign-extended). The second
303 				 * condition is true if when we set all bits
304 				 * within the mask to one (i.e. | in the
305 				 * mask), all bits are one.
306 				 */
307 				if (($2 > mask) && (($2 | mask) != -1ULL))
308 					print_error(
309 						"integer value out of range "
310 						"%016lx (%d bits)", $1.bits);
311 			}
312 
313 			$$.data = data_append_integer($1.data, $2, $1.bits);
314 		}
315 	| arrayprefix DT_REF
316 		{
317 			uint64_t val = ~0ULL >> (64 - $1.bits);
318 
319 			if ($1.bits == 32)
320 				$1.data = data_add_marker($1.data,
321 							  REF_PHANDLE,
322 							  $2);
323 			else
324 				print_error("References are only allowed in "
325 					    "arrays with 32-bit elements.");
326 
327 			$$.data = data_append_integer($1.data, val, $1.bits);
328 		}
329 	| arrayprefix DT_LABEL
330 		{
331 			$$.data = data_add_marker($1.data, LABEL, $2);
332 		}
333 	;
334 
335 integer_prim:
336 	  DT_LITERAL
337 		{
338 			$$ = eval_literal($1, 0, 64);
339 		}
340 	| DT_CHAR_LITERAL
341 		{
342 			$$ = eval_char_literal($1);
343 		}
344 	| '(' integer_expr ')'
345 		{
346 			$$ = $2;
347 		}
348 	;
349 
350 integer_expr:
351 	integer_trinary
352 	;
353 
354 integer_trinary:
355 	  integer_or
356 	| integer_or '?' integer_expr ':' integer_trinary { $$ = $1 ? $3 : $5; }
357 	;
358 
359 integer_or:
360 	  integer_and
361 	| integer_or DT_OR integer_and { $$ = $1 || $3; }
362 	;
363 
364 integer_and:
365 	  integer_bitor
366 	| integer_and DT_AND integer_bitor { $$ = $1 && $3; }
367 	;
368 
369 integer_bitor:
370 	  integer_bitxor
371 	| integer_bitor '|' integer_bitxor { $$ = $1 | $3; }
372 	;
373 
374 integer_bitxor:
375 	  integer_bitand
376 	| integer_bitxor '^' integer_bitand { $$ = $1 ^ $3; }
377 	;
378 
379 integer_bitand:
380 	  integer_eq
381 	| integer_bitand '&' integer_eq { $$ = $1 & $3; }
382 	;
383 
384 integer_eq:
385 	  integer_rela
386 	| integer_eq DT_EQ integer_rela { $$ = $1 == $3; }
387 	| integer_eq DT_NE integer_rela { $$ = $1 != $3; }
388 	;
389 
390 integer_rela:
391 	  integer_shift
392 	| integer_rela '<' integer_shift { $$ = $1 < $3; }
393 	| integer_rela '>' integer_shift { $$ = $1 > $3; }
394 	| integer_rela DT_LE integer_shift { $$ = $1 <= $3; }
395 	| integer_rela DT_GE integer_shift { $$ = $1 >= $3; }
396 	;
397 
398 integer_shift:
399 	  integer_shift DT_LSHIFT integer_add { $$ = $1 << $3; }
400 	| integer_shift DT_RSHIFT integer_add { $$ = $1 >> $3; }
401 	| integer_add
402 	;
403 
404 integer_add:
405 	  integer_add '+' integer_mul { $$ = $1 + $3; }
406 	| integer_add '-' integer_mul { $$ = $1 - $3; }
407 	| integer_mul
408 	;
409 
410 integer_mul:
411 	  integer_mul '*' integer_unary { $$ = $1 * $3; }
412 	| integer_mul '/' integer_unary { $$ = $1 / $3; }
413 	| integer_mul '%' integer_unary { $$ = $1 % $3; }
414 	| integer_unary
415 	;
416 
417 integer_unary:
418 	  integer_prim
419 	| '-' integer_unary { $$ = -$2; }
420 	| '~' integer_unary { $$ = ~$2; }
421 	| '!' integer_unary { $$ = !$2; }
422 	;
423 
424 bytestring:
425 	  /* empty */
426 		{
427 			$$ = empty_data;
428 		}
429 	| bytestring DT_BYTE
430 		{
431 			$$ = data_append_byte($1, $2);
432 		}
433 	| bytestring DT_LABEL
434 		{
435 			$$ = data_add_marker($1, LABEL, $2);
436 		}
437 	;
438 
439 subnodes:
440 	  /* empty */
441 		{
442 			$$ = NULL;
443 		}
444 	| subnode subnodes
445 		{
446 			$$ = chain_node($1, $2);
447 		}
448 	| subnode propdef
449 		{
450 			print_error("syntax error: properties must precede subnodes");
451 			YYERROR;
452 		}
453 	;
454 
455 subnode:
456 	  DT_PROPNODENAME nodedef
457 		{
458 			$$ = name_node($2, $1);
459 		}
460 	| DT_DEL_NODE DT_PROPNODENAME ';'
461 		{
462 			$$ = name_node(build_node_delete(), $2);
463 		}
464 	| DT_LABEL subnode
465 		{
466 			add_label(&$2->labels, $1);
467 			$$ = $2;
468 		}
469 	;
470 
471 %%
472 
473 void print_error(char const *fmt, ...)
474 {
475 	va_list va;
476 
477 	va_start(va, fmt);
478 	srcpos_verror(&yylloc, fmt, va);
479 	va_end(va);
480 
481 	treesource_error = 1;
482 }
483 
484 void yyerror(char const *s) {
485 	print_error("%s", s);
486 }
487 
488 static unsigned long long eval_literal(const char *s, int base, int bits)
489 {
490 	unsigned long long val;
491 	char *e;
492 
493 	errno = 0;
494 	val = strtoull(s, &e, base);
495 	if (*e) {
496 		size_t uls = strspn(e, "UL");
497 		if (e[uls])
498 			print_error("bad characters in literal");
499 	}
500 	if ((errno == ERANGE)
501 		 || ((bits < 64) && (val >= (1ULL << bits))))
502 		print_error("literal out of range");
503 	else if (errno != 0)
504 		print_error("bad literal");
505 	return val;
506 }
507 
508 static unsigned char eval_char_literal(const char *s)
509 {
510 	int i = 1;
511 	char c = s[0];
512 
513 	if (c == '\0')
514 	{
515 		print_error("empty character literal");
516 		return 0;
517 	}
518 
519 	/*
520 	 * If the first character in the character literal is a \ then process
521 	 * the remaining characters as an escape encoding. If the first
522 	 * character is neither an escape or a terminator it should be the only
523 	 * character in the literal and will be returned.
524 	 */
525 	if (c == '\\')
526 		c = get_escape_char(s, &i);
527 
528 	if (s[i] != '\0')
529 		print_error("malformed character literal");
530 
531 	return c;
532 }
533