src/ldscript.y

   1 %{
   2 /* Parser for linker scripts.
   3    Copyright (C) 2001-2011 Red Hat, Inc.
   4    This file is part of elfutils.
   5    Written by Ulrich Drepper <drepper@redhat.com>, 2001.
   6
   7    This file is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    elfutils is distributed in the hope that it will be useful, but
  13    WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <assert.h>
  25 #include <error.h>
  26 #include <libintl.h>
  27 #include <stdbool.h>
  28 #include <stdint.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #include <system.h>
  34 #include <ld.h>
  35
  36 /* The error handler.  */
  37 static void yyerror (const char *s);
  38
  39 /* Some helper functions we need to construct the data structures
  40    describing information from the file.  */
  41 static struct expression *new_expr (int tag);
  42 static struct input_section_name *new_input_section_name (const char *name,
  43                                                           bool sort_flag);
  44 static struct input_rule *new_input_rule (int tag);
  45 static struct output_rule *new_output_rule (int tag);
  46 static struct assignment *new_assignment (const char *variable,
  47                                           struct expression *expression,
  48                                           bool provide_flag);
  49 static void new_segment (int mode, struct output_rule *output_rule);
  50 static struct filename_list *new_filename_listelem (const char *string);
  51 static void add_inputfiles (struct filename_list *fnames);
  52 static struct id_list *new_id_listelem (const char *str);
  53  static struct filename_list *mark_as_needed (struct filename_list *listp);
  54 static struct version *new_version (struct id_list *local,
  55                                     struct id_list *global);
  56 static struct version *merge_versions (struct version *one,
  57                                        struct version *two);
  58 static void add_versions (struct version *versions);
  59
  60 extern int yylex (void);
  61 %}
  62
  63 %union {
  64   uintmax_t num;
  65   enum expression_tag op;
  66   char *str;
  67   struct expression *expr;
  68   struct input_section_name *sectionname;
  69   struct filemask_section_name *filemask_section_name;
  70   struct input_rule *input_rule;
  71   struct output_rule *output_rule;
  72   struct assignment *assignment;
  73   struct filename_list *filename_list;
  74   struct version *version;
  75   struct id_list *id_list;
  76 }
  77
  78 %token kADD_OP
  79 %token kALIGN
  80 %token kAS_NEEDED
  81 %token kENTRY
  82 %token kEXCLUDE_FILE
  83 %token <str> kFILENAME
  84 %token kGLOBAL
  85 %token kGROUP
  86 %token <str> kID
  87 %token kINPUT
  88 %token kINTERP
  89 %token kKEEP
  90 %token kLOCAL
  91 %token <num> kMODE
  92 %token kMUL_OP
  93 %token <num> kNUM
  94 %token kOUTPUT_FORMAT
  95 %token kPAGESIZE
  96 %token kPROVIDE
  97 %token kSEARCH_DIR
  98 %token kSEGMENT
  99 %token kSIZEOF_HEADERS
 100 %token kSORT
 101 %token kVERSION
 102 %token kVERSION_SCRIPT
 103
 104 %left '|'
 105 %left '&'
 106 %left ADD_OP
 107 %left MUL_OP '*'
 108
 109 %type <op> kADD_OP
 110 %type <op> kMUL_OP
 111 %type <str> filename_id
 112 %type <str> filename_id_star
 113 %type <str> exclude_opt
 114 %type <expr> expr
 115 %type <sectionname> sort_opt_name
 116 %type <filemask_section_name> sectionname
 117 %type <input_rule> inputsection
 118 %type <input_rule> inputsections
 119 %type <output_rule> outputsection
 120 %type <output_rule> outputsections
 121 %type <assignment> assignment
 122 %type <filename_list> filename_id_list
 123 %type <filename_list> filename_id_listelem
 124 %type <version> versionlist
 125 %type <version> version
 126 %type <version> version_stmt_list
 127 %type <version> version_stmt
 128 %type <id_list> filename_id_star_list
 129
 130 %expect 16
 131
 132 %%
 133
 134 script_or_version:
 135                   file
 136                 | kVERSION_SCRIPT versionlist
 137                     { add_versions ($2); }
 138                 ;
 139
 140 file:             file content
 141                 | content
 142                 ;
 143
 144 content:          kENTRY '(' kID ')' ';'
 145                     {
 146                       if (likely (ld_state.entry == NULL))
 147                         ld_state.entry = $3;
 148                     }
 149                 | kSEARCH_DIR '(' filename_id ')' ';'
 150                     {
 151                       ld_new_searchdir ($3);
 152                     }
 153                 | kPAGESIZE '(' kNUM ')' ';'
 154                     {
 155                       if (likely (ld_state.pagesize == 0))
 156                         ld_state.pagesize = $3;
 157                     }
 158                 | kINTERP '(' filename_id ')' ';'
 159                     {
 160                       if (likely (ld_state.interp == NULL)
 161                           && ld_state.file_type != dso_file_type)
 162                         ld_state.interp = $3;
 163                     }
 164                 | kSEGMENT kMODE '{' outputsections '}'
 165                     {
 166                       new_segment ($2, $4);
 167                     }
 168                 | kSEGMENT error '{' outputsections '}'
 169                     {
 170                       fputs_unlocked (gettext ("mode for segment invalid\n"),
 171                                       stderr);
 172                       new_segment (0, $4);
 173                     }
 174                 | kGROUP '(' filename_id_list ')'
 175                     {
 176                       /* First little optimization.  If there is only one
 177                          file in the group don't do anything.  */
 178                       if ($3 != $3->next)
 179                         {
 180                           $3->next->group_start = 1;
 181                           $3->group_end = 1;
 182                         }
 183                       add_inputfiles ($3);
 184                     }
 185                 | kINPUT '(' filename_id_list ')'
 186                     { add_inputfiles ($3); }
 187                 | kAS_NEEDED '(' filename_id_list ')'
 188                     { add_inputfiles (mark_as_needed ($3)); }
 189                 | kVERSION '{' versionlist '}'
 190                     { add_versions ($3); }
 191                 | kOUTPUT_FORMAT '(' filename_id ')'
 192                     { /* XXX TODO */ }
 193                 ;
 194
 195 outputsections:   outputsections outputsection
 196                     {
 197                       $2->next = $1->next;
 198                       $$ = $1->next = $2;
 199                     }
 200                 | outputsection
 201                     { $$ = $1; }
 202                 ;
 203
 204 outputsection:    assignment ';'
 205                     {
 206                       $$ = new_output_rule (output_assignment);
 207                       $$->val.assignment = $1;
 208                     }
 209                 | kID '{' inputsections '}'
 210                     {
 211                       $$ = new_output_rule (output_section);
 212                       $$->val.section.name = $1;
 213                       $$->val.section.input = $3->next;
 214                       if (ld_state.strip == strip_debug
 215                           && ebl_debugscn_p (ld_state.ebl, $1))
 216                         $$->val.section.ignored = true;
 217                       else
 218                         $$->val.section.ignored = false;
 219                       $3->next = NULL;
 220                     }
 221                 | kID ';'
 222                     {
 223                       /* This is a short cut for "ID { *(ID) }".  */
 224                       $$ = new_output_rule (output_section);
 225                       $$->val.section.name = $1;
 226                       $$->val.section.input = new_input_rule (input_section);
 227                       $$->val.section.input->next = NULL;
 228                       $$->val.section.input->val.section =
 229                         (struct filemask_section_name *)
 230                           obstack_alloc (&ld_state.smem,
 231                                          sizeof (struct filemask_section_name));
 232                       $$->val.section.input->val.section->filemask = NULL;
 233                       $$->val.section.input->val.section->excludemask = NULL;
 234                       $$->val.section.input->val.section->section_name =
 235                         new_input_section_name ($1, false);
 236                       $$->val.section.input->val.section->keep_flag = false;
 237                       if (ld_state.strip == strip_debug
 238                           && ebl_debugscn_p (ld_state.ebl, $1))
 239                         $$->val.section.ignored = true;
 240                       else
 241                         $$->val.section.ignored = false;
 242                     }
 243                 ;
 244
 245 assignment:       kID '=' expr
 246                     { $$ = new_assignment ($1, $3, false); }
 247                 | kPROVIDE '(' kID '=' expr ')'
 248                     { $$ = new_assignment ($3, $5, true); }
 249                 ;
 250
 251 inputsections:    inputsections inputsection
 252                     {
 253                       $2->next = $1->next;
 254                       $$ = $1->next = $2;
 255                     }
 256                 | inputsection
 257                     { $$ = $1; }
 258                 ;
 259
 260 inputsection:     sectionname
 261                     {
 262                       $$ = new_input_rule (input_section);
 263                       $$->val.section = $1;
 264                     }
 265                 | kKEEP '(' sectionname ')'
 266                     {
 267                       $3->keep_flag = true;
 268
 269                       $$ = new_input_rule (input_section);
 270                       $$->val.section = $3;
 271                     }
 272                 | assignment ';'
 273                     {
 274                       $$ = new_input_rule (input_assignment);
 275                       $$->val.assignment = $1;
 276                     }
 277                 ;
 278
 279 sectionname:      filename_id_star '(' exclude_opt sort_opt_name ')'
 280                     {
 281                       $$ = (struct filemask_section_name *)
 282                         obstack_alloc (&ld_state.smem, sizeof (*$$));
 283                       $$->filemask = $1;
 284                       $$->excludemask = $3;
 285                       $$->section_name = $4;
 286                       $$->keep_flag = false;
 287                     }
 288                 ;
 289
 290 sort_opt_name:    kID
 291                     { $$ = new_input_section_name ($1, false); }
 292                 | kSORT '(' kID ')'
 293                     { $$ = new_input_section_name ($3, true); }
 294                 ;
 295
 296 exclude_opt:      kEXCLUDE_FILE '(' filename_id ')'
 297                     { $$ = $3; }
 298                 |
 299                     { $$ = NULL; }
 300                 ;
 301
 302 expr:             kALIGN '(' expr ')'
 303                     {
 304                       $$ = new_expr (exp_align);
 305                       $$->val.child = $3;
 306                     }
 307                 | '(' expr ')'
 308                     { $$ = $2; }
 309                 | expr '*' expr
 310                     {
 311                       $$ = new_expr (exp_mult);
 312                       $$->val.binary.left = $1;
 313                       $$->val.binary.right = $3;
 314                     }
 315                 | expr kMUL_OP expr
 316                     {
 317                       $$ = new_expr ($2);
 318                       $$->val.binary.left = $1;
 319                       $$->val.binary.right = $3;
 320                     }
 321                 | expr kADD_OP expr
 322                     {
 323                       $$ = new_expr ($2);
 324                       $$->val.binary.left = $1;
 325                       $$->val.binary.right = $3;
 326                     }
 327                 | expr '&' expr
 328                     {
 329                       $$ = new_expr (exp_and);
 330                       $$->val.binary.left = $1;
 331                       $$->val.binary.right = $3;
 332                     }
 333                 | expr '|' expr
 334                     {
 335                       $$ = new_expr (exp_or);
 336                       $$->val.binary.left = $1;
 337                       $$->val.binary.right = $3;
 338                     }
 339                 | kNUM
 340                     {
 341                       $$ = new_expr (exp_num);
 342                       $$->val.num = $1;
 343                     }
 344                 | kID
 345                     {
 346                       $$ = new_expr (exp_id);
 347                       $$->val.str = $1;
 348                     }
 349                 | kSIZEOF_HEADERS
 350                     { $$ = new_expr (exp_sizeof_headers); }
 351                 | kPAGESIZE
 352                     { $$ = new_expr (exp_pagesize); }
 353                 ;
 354
 355 filename_id_list: filename_id_list comma_opt filename_id_listelem
 356                     {
 357                       $3->next = $1->next;
 358                       $$ = $1->next = $3;
 359                     }
 360                 | filename_id_listelem
 361                     { $$ = $1; }
 362                 ;
 363
 364 comma_opt:        ','
 365                 |
 366                 ;
 367
 368 filename_id_listelem: kGROUP '(' filename_id_list ')'
 369                     {
 370                       /* First little optimization.  If there is only one
 371                          file in the group don't do anything.  */
 372                       if ($3 != $3->next)
 373                         {
 374                           $3->next->group_start = 1;
 375                           $3->group_end = 1;
 376                         }
 377                       $$ = $3;
 378                     }
 379                 | kAS_NEEDED '(' filename_id_list ')'
 380                     { $$ = mark_as_needed ($3); }
 381                 | filename_id
 382                     { $$ = new_filename_listelem ($1); }
 383                 ;
 384
 385
 386 versionlist:      versionlist version
 387                     {
 388                       $2->next = $1->next;
 389                       $$ = $1->next = $2;
 390                     }
 391                 | version
 392                     { $$ = $1; }
 393                 ;
 394
 395 version:          '{' version_stmt_list '}' ';'
 396                     {
 397                       $2->versionname = "";
 398                       $2->parentname = NULL;
 399                       $$ = $2;
 400                     }
 401                 | filename_id '{' version_stmt_list '}' ';'
 402                     {
 403                       $3->versionname = $1;
 404                       $3->parentname = NULL;
 405                       $$ = $3;
 406                     }
 407                 | filename_id '{' version_stmt_list '}' filename_id ';'
 408                     {
 409                       $3->versionname = $1;
 410                       $3->parentname = $5;
 411                       $$ = $3;
 412                     }
 413                 ;
 414
 415 version_stmt_list:
 416                   version_stmt_list version_stmt
 417                     { $$ = merge_versions ($1, $2); }
 418                 | version_stmt
 419                     { $$ = $1; }
 420                 ;
 421
 422 version_stmt:     kGLOBAL filename_id_star_list
 423                     { $$ = new_version (NULL, $2); }
 424                 | kLOCAL filename_id_star_list
 425                     { $$ = new_version ($2, NULL); }
 426                 ;
 427
 428 filename_id_star_list:
 429                   filename_id_star_list filename_id_star ';'
 430                     {
 431                       struct id_list *newp = new_id_listelem ($2);
 432                       newp->next = $1->next;
 433                       $$ = $1->next = newp;
 434                     }
 435                 | filename_id_star ';'
 436                     { $$ = new_id_listelem ($1); }
 437                 ;
 438
 439 filename_id:      kFILENAME
 440                     { $$ = $1; }
 441                 | kID
 442                     { $$ = $1; }
 443                 ;
 444
 445 filename_id_star: filename_id
 446                     { $$ = $1; }
 447                 | '*'
 448                     { $$ = NULL; }
 449                 ;
 450
 451 %%
 452
 453 static void
 454 yyerror (const char *s)
 455 {
 456   error (0, 0, (ld_scan_version_script
 457                 ? gettext ("while reading version script '%s': %s at line %d")
 458                 : gettext ("while reading linker script '%s': %s at line %d")),
 459          ldin_fname, gettext (s), ldlineno);
 460 }
 461
 462
 463 static struct expression *
 464 new_expr (int tag)
 465 {
 466   struct expression *newp = (struct expression *)
 467     obstack_alloc (&ld_state.smem, sizeof (*newp));
 468
 469   newp->tag = tag;
 470   return newp;
 471 }
 472
 473
 474 static struct input_section_name *
 475 new_input_section_name (const char *name, bool sort_flag)
 476 {
 477   struct input_section_name *newp = (struct input_section_name *)
 478     obstack_alloc (&ld_state.smem, sizeof (*newp));
 479
 480   newp->name = name;
 481   newp->sort_flag = sort_flag;
 482   return newp;
 483 }
 484
 485
 486 static struct input_rule *
 487 new_input_rule (int tag)
 488 {
 489   struct input_rule *newp = (struct input_rule *)
 490     obstack_alloc (&ld_state.smem, sizeof (*newp));
 491
 492   newp->tag = tag;
 493   newp->next = newp;
 494   return newp;
 495 }
 496
 497
 498 static struct output_rule *
 499 new_output_rule (int tag)
 500 {
 501   struct output_rule *newp = (struct output_rule *)
 502     memset (obstack_alloc (&ld_state.smem, sizeof (*newp)),
 503             '\0', sizeof (*newp));
 504
 505   newp->tag = tag;
 506   newp->next = newp;
 507   return newp;
 508 }
 509
 510
 511 static struct assignment *
 512 new_assignment (const char *variable, struct expression *expression,
 513                 bool provide_flag)
 514 {
 515   struct assignment *newp = (struct assignment *)
 516     obstack_alloc (&ld_state.smem, sizeof (*newp));
 517
 518   newp->variable = variable;
 519   newp->expression = expression;
 520   newp->sym = NULL;
 521   newp->provide_flag = provide_flag;
 522
 523   /* Insert the symbol into a hash table.  We will later have to matc*/
 524   return newp;
 525 }
 526
 527
 528 static void
 529 new_segment (int mode, struct output_rule *output_rule)
 530 {
 531   struct output_segment *newp;
 532
 533   newp
 534     = (struct output_segment *) obstack_alloc (&ld_state.smem, sizeof (*newp));
 535   newp->mode = mode;
 536   newp->next = newp;
 537
 538   newp->output_rules = output_rule->next;
 539   output_rule->next = NULL;
 540
 541   /* Enqueue the output segment description.  */
 542   if (ld_state.output_segments == NULL)
 543     ld_state.output_segments = newp;
 544   else
 545     {
 546       newp->next = ld_state.output_segments->next;
 547       ld_state.output_segments = ld_state.output_segments->next = newp;
 548     }
 549
 550   /* If the output file should be stripped of all symbol set the flag
 551      in the structures of all output sections.  */
 552   if (mode == 0 && ld_state.strip == strip_all)
 553     {
 554       struct output_rule *runp;
 555
 556       for (runp = newp->output_rules; runp != NULL; runp = runp->next)
 557         if (runp->tag == output_section)
 558           runp->val.section.ignored = true;
 559     }
 560 }
 561
 562
 563 static struct filename_list *
 564 new_filename_listelem (const char *string)
 565 {
 566   struct filename_list *newp;
 567
 568   /* We use calloc and not the obstack since this object can be freed soon.  */
 569   newp = (struct filename_list *) xcalloc (1, sizeof (*newp));
 570   newp->name = string;
 571   newp->next = newp;
 572   return newp;
 573 }
 574
 575
 576 static struct filename_list *
 577 mark_as_needed (struct filename_list *listp)
 578 {
 579   struct filename_list *runp = listp;
 580   do
 581     {
 582       runp->as_needed = true;
 583       runp = runp->next;
 584     }
 585   while (runp != listp);
 586
 587   return listp;
 588 }
 589
 590
 591 static void
 592 add_inputfiles (struct filename_list *fnames)
 593 {
 594   assert (fnames != NULL);
 595
 596   if (ld_state.srcfiles == NULL)
 597     ld_state.srcfiles = fnames;
 598   else
 599     {
 600       struct filename_list *first = ld_state.srcfiles->next;
 601
 602       ld_state.srcfiles->next = fnames->next;
 603       fnames->next = first;
 604       ld_state.srcfiles->next = fnames;
 605     }
 606 }
 607
 608
 609 static _Bool
 610 special_char_p (const char *str)
 611 {
 612   while (*str != '\0')
 613     {
 614       if (__builtin_expect (*str == '*', 0)
 615           || __builtin_expect (*str == '?', 0)
 616           || __builtin_expect (*str == '[', 0))
 617         return true;
 618
 619       ++str;
 620     }
 621
 622   return false;
 623 }
 624
 625
 626 static struct id_list *
 627 new_id_listelem (const char *str)
 628 {
 629   struct id_list *newp;
 630
 631   newp = (struct id_list *) obstack_alloc (&ld_state.smem, sizeof (*newp));
 632   if (str == NULL)
 633     newp->u.id_type = id_all;
 634   else if (__builtin_expect (special_char_p (str), false))
 635     newp->u.id_type = id_wild;
 636   else
 637     newp->u.id_type = id_str;
 638   newp->id = str;
 639   newp->next = newp;
 640
 641   return newp;
 642 }
 643
 644
 645 static struct version *
 646 new_version (struct id_list *local, struct id_list *global)
 647 {
 648   struct version *newp;
 649
 650   newp = (struct version *) obstack_alloc (&ld_state.smem, sizeof (*newp));
 651   newp->next = newp;
 652   newp->local_names = local;
 653   newp->global_names = global;
 654   newp->versionname = NULL;
 655   newp->parentname = NULL;
 656
 657   return newp;
 658 }
 659
 660
 661 static struct version *
 662 merge_versions (struct version *one, struct version *two)
 663 {
 664   assert (two->local_names == NULL || two->global_names == NULL);
 665
 666   if (two->local_names != NULL)
 667     {
 668       if (one->local_names == NULL)
 669         one->local_names = two->local_names;
 670       else
 671         {
 672           two->local_names->next = one->local_names->next;
 673           one->local_names = one->local_names->next = two->local_names;
 674         }
 675     }
 676   else
 677     {
 678       if (one->global_names == NULL)
 679         one->global_names = two->global_names;
 680       else
 681         {
 682           two->global_names->next = one->global_names->next;
 683           one->global_names = one->global_names->next = two->global_names;
 684         }
 685     }
 686
 687   return one;
 688 }
 689
 690
 691 static void
 692 add_id_list (const char *versionname, struct id_list *runp, _Bool local)
 693 {
 694   struct id_list *lastp = runp;
 695
 696   if (runp == NULL)
 697     /* Nothing to do.  */
 698     return;
 699
 700   /* Convert into a simple single-linked list.  */
 701   runp = runp->next;
 702   assert (runp != NULL);
 703   lastp->next = NULL;
 704
 705   do
 706     if (runp->u.id_type == id_str)
 707       {
 708         struct id_list *curp;
 709         struct id_list *defp;
 710         unsigned long int hval = elf_hash (runp->id);
 711
 712         curp = runp;
 713         runp = runp->next;
 714
 715         defp = ld_version_str_tab_find (&ld_state.version_str_tab, hval, curp);
 716         if (defp != NULL)
 717           {
 718             /* There is already a version definition for this symbol.  */
 719             while (strcmp (defp->u.s.versionname, versionname) != 0)
 720               {
 721                 if (defp->next == NULL)
 722                   {
 723                     /* No version like this so far.  */
 724                     defp->next = curp;
 725                     curp->u.s.local = local;
 726                     curp->u.s.versionname = versionname;
 727                     curp->next = NULL;
 728                     defp = NULL;
 729                     break;
 730                   }
 731
 732                 defp = defp->next;
 733               }
 734
 735             if (defp != NULL && defp->u.s.local != local)
 736               error (EXIT_FAILURE, 0, versionname[0] == '\0'
 737                      ? gettext ("\
 738 symbol '%s' is declared both local and global for unnamed version")
 739                      : gettext ("\
 740 symbol '%s' is declared both local and global for version '%s'"),
 741                      runp->id, versionname);
 742           }
 743         else
 744           {
 745             /* This is the first version definition for this symbol.  */
 746             ld_version_str_tab_insert (&ld_state.version_str_tab, hval, curp);
 747
 748             curp->u.s.local = local;
 749             curp->u.s.versionname = versionname;
 750             curp->next = NULL;
 751           }
 752       }
 753     else if (runp->u.id_type == id_all)
 754       {
 755         if (local)
 756           {
 757             if (ld_state.default_bind_global)
 758               error (EXIT_FAILURE, 0,
 759                      gettext ("default visibility set as local and global"));
 760             ld_state.default_bind_local = true;
 761           }
 762         else
 763           {
 764             if (ld_state.default_bind_local)
 765               error (EXIT_FAILURE, 0,
 766                      gettext ("default visibility set as local and global"));
 767             ld_state.default_bind_global = true;
 768           }
 769
 770         runp = runp->next;
 771       }
 772     else
 773       {
 774         assert (runp->u.id_type == id_wild);
 775         /* XXX TBI */
 776         abort ();
 777       }
 778   while (runp != NULL);
 779 }
 780
 781
 782 static void
 783 add_versions (struct version *versions)
 784 {
 785   struct version *lastp = versions;
 786
 787   if (versions == NULL)
 788     return;
 789
 790   /* Convert into a simple single-linked list.  */
 791   versions = versions->next;
 792   assert (versions != NULL);
 793   lastp->next = NULL;
 794
 795   do
 796     {
 797       add_id_list (versions->versionname, versions->local_names, true);
 798       add_id_list (versions->versionname, versions->global_names, false);
 799
 800       versions = versions->next;
 801     }
 802   while (versions != NULL);
 803 }