scripts/dtc/dtc-parser.y

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