scripts/dtc/dtc-parser.y

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