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