gdb/osabi.c

   1 /* OS ABI variant handling for GDB.
   2
   3    Copyright (C) 2001, 2002, 2003, 2004, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22
  23 #include "gdb_assert.h"
  24 #include "gdb_string.h"
  25
  26 #include "osabi.h"
  27 #include "arch-utils.h"
  28 #include "gdbcmd.h"
  29 #include "command.h"
  30
  31 #include "elf-bfd.h"
  32
  33 #ifndef GDB_OSABI_DEFAULT
  34 #define GDB_OSABI_DEFAULT GDB_OSABI_UNKNOWN
  35 #endif
  36
  37 /* State for the "set osabi" command.  */
  38 static enum { osabi_auto, osabi_default, osabi_user } user_osabi_state;
  39 static enum gdb_osabi user_selected_osabi;
  40 static const char *gdb_osabi_available_names[GDB_OSABI_INVALID + 3] = {
  41   "auto",
  42   "default",
  43   "none",
  44   NULL
  45 };
  46 static const char *set_osabi_string;
  47
  48 /* This table matches the indices assigned to enum gdb_osabi.  Keep
  49    them in sync.  */
  50 static const char * const gdb_osabi_names[] =
  51 {
  52   "none",
  53
  54   "SVR4",
  55   "GNU/Hurd",
  56   "Solaris",
  57   "OSF/1",
  58   "GNU/Linux",
  59   "FreeBSD a.out",
  60   "FreeBSD ELF",
  61   "NetBSD a.out",
  62   "NetBSD ELF",
  63   "OpenBSD ELF",
  64   "Windows CE",
  65   "DJGPP",
  66   "Irix",
  67   "Interix",
  68   "HP/UX ELF",
  69   "HP/UX SOM",
  70
  71   "QNX Neutrino",
  72
  73   "Cygwin",
  74   "AIX",
  75   "DICOS",
  76   "Darwin",
  77
  78   "<invalid>"
  79 };
  80
  81 const char *
  82 gdbarch_osabi_name (enum gdb_osabi osabi)
  83 {
  84   if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
  85     return gdb_osabi_names[osabi];
  86
  87   return gdb_osabi_names[GDB_OSABI_INVALID];
  88 }
  89
  90 /* Handler for a given architecture/OS ABI pair.  There should be only
  91    one handler for a given OS ABI each architecture family.  */
  92 struct gdb_osabi_handler
  93 {
  94   struct gdb_osabi_handler *next;
  95   const struct bfd_arch_info *arch_info;
  96   enum gdb_osabi osabi;
  97   void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
  98 };
  99
 100 static struct gdb_osabi_handler *gdb_osabi_handler_list;
 101
 102 void
 103 gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
 104                         enum gdb_osabi osabi,
 105                         void (*init_osabi)(struct gdbarch_info,
 106                                            struct gdbarch *))
 107 {
 108   struct gdb_osabi_handler **handler_p;
 109   const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
 110   const char **name_ptr;
 111
 112   /* Registering an OS ABI handler for "unknown" is not allowed.  */
 113   if (osabi == GDB_OSABI_UNKNOWN)
 114     {
 115       internal_error
 116         (__FILE__, __LINE__,
 117          _("gdbarch_register_osabi: An attempt to register a handler for "
 118          "OS ABI \"%s\" for architecture %s was made.  The handler will "
 119          "not be registered"),
 120          gdbarch_osabi_name (osabi),
 121          bfd_printable_arch_mach (arch, machine));
 122       return;
 123     }
 124
 125   gdb_assert (arch_info);
 126
 127   for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
 128        handler_p = &(*handler_p)->next)
 129     {
 130       if ((*handler_p)->arch_info == arch_info
 131           && (*handler_p)->osabi == osabi)
 132         {
 133           internal_error
 134             (__FILE__, __LINE__,
 135              _("gdbarch_register_osabi: A handler for OS ABI \"%s\" "
 136              "has already been registered for architecture %s"),
 137              gdbarch_osabi_name (osabi),
 138              arch_info->printable_name);
 139           /* If user wants to continue, override previous definition.  */
 140           (*handler_p)->init_osabi = init_osabi;
 141           return;
 142         }
 143     }
 144
 145   (*handler_p)
 146     = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
 147   (*handler_p)->next = NULL;
 148   (*handler_p)->arch_info = arch_info;
 149   (*handler_p)->osabi = osabi;
 150   (*handler_p)->init_osabi = init_osabi;
 151
 152   /* Add this OS ABI to the list of enum values for "set osabi", if it isn't
 153      already there.  */
 154   for (name_ptr = gdb_osabi_available_names; *name_ptr; name_ptr ++)
 155     {
 156       if (*name_ptr == gdbarch_osabi_name (osabi))
 157         return;
 158     }
 159   *name_ptr++ = gdbarch_osabi_name (osabi);
 160   *name_ptr = NULL;
 161 }
 162 \f
 163
 164 /* Sniffer to find the OS ABI for a given file's architecture and flavour.
 165    It is legal to have multiple sniffers for each arch/flavour pair, to
 166    disambiguate one OS's a.out from another, for example.  The first sniffer
 167    to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
 168    be careful to claim a file only if it knows for sure what it is.  */
 169 struct gdb_osabi_sniffer
 170 {
 171   struct gdb_osabi_sniffer *next;
 172   enum bfd_architecture arch;   /* bfd_arch_unknown == wildcard */
 173   enum bfd_flavour flavour;
 174   enum gdb_osabi (*sniffer)(bfd *);
 175 };
 176
 177 static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
 178
 179 void
 180 gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
 181                                 enum bfd_flavour flavour,
 182                                 enum gdb_osabi (*sniffer_fn)(bfd *))
 183 {
 184   struct gdb_osabi_sniffer *sniffer;
 185
 186   sniffer =
 187     (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
 188   sniffer->arch = arch;
 189   sniffer->flavour = flavour;
 190   sniffer->sniffer = sniffer_fn;
 191
 192   sniffer->next = gdb_osabi_sniffer_list;
 193   gdb_osabi_sniffer_list = sniffer;
 194 }
 195 \f
 196
 197 enum gdb_osabi
 198 gdbarch_lookup_osabi (bfd *abfd)
 199 {
 200   struct gdb_osabi_sniffer *sniffer;
 201   enum gdb_osabi osabi, match;
 202   int match_specific;
 203
 204   /* If we aren't in "auto" mode, return the specified OS ABI.  */
 205   if (user_osabi_state == osabi_user)
 206     return user_selected_osabi;
 207
 208   /* If we don't have a binary, return the default OS ABI (if set) or
 209      unknown (otherwise).  */
 210   if (abfd == NULL)
 211     return GDB_OSABI_DEFAULT;
 212
 213   match = GDB_OSABI_UNKNOWN;
 214   match_specific = 0;
 215
 216   for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
 217        sniffer = sniffer->next)
 218     {
 219       if ((sniffer->arch == bfd_arch_unknown /* wildcard */
 220            || sniffer->arch == bfd_get_arch (abfd))
 221           && sniffer->flavour == bfd_get_flavour (abfd))
 222         {
 223           osabi = (*sniffer->sniffer) (abfd);
 224           if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
 225             {
 226               internal_error
 227                 (__FILE__, __LINE__,
 228                  _("gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
 229                  "for architecture %s flavour %d"),
 230                  (int) osabi,
 231                  bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 232                  (int) bfd_get_flavour (abfd));
 233             }
 234           else if (osabi != GDB_OSABI_UNKNOWN)
 235             {
 236               /* A specific sniffer always overrides a generic sniffer.
 237                  Croak on multiple match if the two matches are of the
 238                  same class.  If the user wishes to continue, we'll use
 239                  the first match.  */
 240               if (match != GDB_OSABI_UNKNOWN)
 241                 {
 242                   if ((match_specific && sniffer->arch != bfd_arch_unknown)
 243                    || (!match_specific && sniffer->arch == bfd_arch_unknown))
 244                     {
 245                       internal_error
 246                         (__FILE__, __LINE__,
 247                          _("gdbarch_lookup_osabi: multiple %sspecific OS ABI "
 248                          "match for architecture %s flavour %d: first "
 249                          "match \"%s\", second match \"%s\""),
 250                          match_specific ? "" : "non-",
 251                          bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
 252                          (int) bfd_get_flavour (abfd),
 253                          gdbarch_osabi_name (match),
 254                          gdbarch_osabi_name (osabi));
 255                     }
 256                   else if (sniffer->arch != bfd_arch_unknown)
 257                     {
 258                       match = osabi;
 259                       match_specific = 1;
 260                     }
 261                 }
 262               else
 263                 {
 264                   match = osabi;
 265                   if (sniffer->arch != bfd_arch_unknown)
 266                     match_specific = 1;
 267                 }
 268             }
 269         }
 270     }
 271
 272   /* If we didn't find a match, but a default was specified at configure
 273      time, return the default.  */
 274   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN && match == GDB_OSABI_UNKNOWN)
 275     return GDB_OSABI_DEFAULT;
 276   else
 277     return match;
 278 }
 279
 280
 281 /* Return non-zero if architecture A can run code written for
 282    architecture B.  */
 283 static int
 284 can_run_code_for (const struct bfd_arch_info *a, const struct bfd_arch_info *b)
 285 {
 286   /* BFD's 'A->compatible (A, B)' functions return zero if A and B are
 287      incompatible.  But if they are compatible, it returns the 'more
 288      featureful' of the two arches.  That is, if A can run code
 289      written for B, but B can't run code written for A, then it'll
 290      return A.
 291
 292      struct bfd_arch_info objects are singletons: that is, there's
 293      supposed to be exactly one instance for a given machine.  So you
 294      can tell whether two are equivalent by comparing pointers.  */
 295   return (a == b || a->compatible (a, b) == a);
 296 }
 297
 298
 299 void
 300 gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
 301 {
 302   struct gdb_osabi_handler *handler;
 303
 304   if (info.osabi == GDB_OSABI_UNKNOWN)
 305     {
 306       /* Don't complain about an unknown OSABI.  Assume the user knows
 307          what they are doing.  */
 308       return;
 309     }
 310
 311   for (handler = gdb_osabi_handler_list; handler != NULL;
 312        handler = handler->next)
 313     {
 314       if (handler->osabi != info.osabi)
 315         continue;
 316
 317       /* If the architecture described by ARCH_INFO can run code for
 318          the architcture we registered the handler for, then the
 319          handler is applicable.  Note, though, that if the handler is
 320          for an architecture that is a superset of ARCH_INFO, we can't
 321          use that --- it would be perfectly correct for it to install
 322          gdbarch methods that refer to registers / instructions /
 323          other facilities ARCH_INFO doesn't have.
 324
 325          NOTE: kettenis/20021027: There may be more than one machine
 326          type that is compatible with the desired machine type.  Right
 327          now we simply return the first match, which is fine for now.
 328          However, we might want to do something smarter in the future.  */
 329       /* NOTE: cagney/2003-10-23: The code for "a can_run_code_for b"
 330          is implemented using BFD's compatible method (a->compatible
 331          (b) == a -- the lowest common denominator between a and b is
 332          a).  That method's definition of compatible may not be as you
 333          expect.  For instance the test "amd64 can run code for i386"
 334          (or more generally "64-bit ISA can run code for the 32-bit
 335          ISA").  BFD doesn't normally consider 32-bit and 64-bit
 336          "compatible" so it doesn't succeed.  */
 337       if (can_run_code_for (info.bfd_arch_info, handler->arch_info))
 338         {
 339           (*handler->init_osabi) (info, gdbarch);
 340           return;
 341         }
 342     }
 343
 344   warning
 345     ("A handler for the OS ABI \"%s\" is not built into this configuration\n"
 346      "of GDB.  Attempting to continue with the default %s settings.\n",
 347      gdbarch_osabi_name (info.osabi),
 348      info.bfd_arch_info->printable_name);
 349 }
 350 \f
 351 /* Limit on the amount of data to be read.  */
 352 #define MAX_NOTESZ      128
 353
 354 /* Return non-zero if NOTE matches NAME, DESCSZ and TYPE.  */
 355
 356 static int
 357 check_note (bfd *abfd, asection *sect, const char *note,
 358             const char *name, unsigned long descsz, unsigned long type)
 359 {
 360   unsigned long notesz;
 361
 362   /* Calculate the size of this note.  */
 363   notesz = strlen (name) + 1;
 364   notesz = ((notesz + 3) & ~3);
 365   notesz += descsz;
 366   notesz = ((notesz + 3) & ~3);
 367
 368   /* If this assertion triggers, increase MAX_NOTESZ.  */
 369   gdb_assert (notesz <= MAX_NOTESZ);
 370
 371   /* Check whether SECT is big enough to comtain the complete note.  */
 372   if (notesz > bfd_section_size (abfd, sect))
 373     return 0;
 374
 375   /* Check the note name.  */
 376   if (bfd_h_get_32 (abfd, note) != (strlen (name) + 1)
 377       || strcmp (note + 12, name) != 0)
 378     return 0;
 379
 380   /* Check the descriptor size.  */
 381   if (bfd_h_get_32 (abfd, note + 4) != descsz)
 382     return 0;
 383
 384   /* Check the note type.  */
 385   if (bfd_h_get_32 (abfd, note + 8) != type)
 386     return 0;
 387
 388   return 1;
 389 }
 390
 391 /* Generic sniffer for ELF flavoured files.  */
 392
 393 void
 394 generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
 395 {
 396   enum gdb_osabi *osabi = obj;
 397   const char *name;
 398   unsigned int sectsize;
 399   char *note;
 400
 401   name = bfd_get_section_name (abfd, sect);
 402   sectsize = bfd_section_size (abfd, sect);
 403
 404   /* Limit the amount of data to read.  */
 405   if (sectsize > MAX_NOTESZ)
 406     sectsize = MAX_NOTESZ;
 407
 408   note = alloca (sectsize);
 409   bfd_get_section_contents (abfd, sect, note, 0, sectsize);
 410
 411   /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
 412   if (strcmp (name, ".note.ABI-tag") == 0)
 413     {
 414       /* GNU.  */
 415       if (check_note (abfd, sect, note, "GNU", 16, NT_GNU_ABI_TAG))
 416         {
 417           unsigned int abi_tag = bfd_h_get_32 (abfd, note + 16);
 418
 419           switch (abi_tag)
 420             {
 421             case GNU_ABI_TAG_LINUX:
 422               *osabi = GDB_OSABI_LINUX;
 423               break;
 424
 425             case GNU_ABI_TAG_HURD:
 426               *osabi = GDB_OSABI_HURD;
 427               break;
 428
 429             case GNU_ABI_TAG_SOLARIS:
 430               *osabi = GDB_OSABI_SOLARIS;
 431               break;
 432
 433             case GNU_ABI_TAG_FREEBSD:
 434               *osabi = GDB_OSABI_FREEBSD_ELF;
 435               break;
 436
 437             case GNU_ABI_TAG_NETBSD:
 438               *osabi = GDB_OSABI_NETBSD_ELF;
 439               break;
 440
 441             default:
 442               internal_error (__FILE__, __LINE__, _("\
 443 generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d"),
 444                               abi_tag);
 445             }
 446           return;
 447         }
 448
 449       /* FreeBSD.  */
 450       if (check_note (abfd, sect, note, "FreeBSD", 4, NT_FREEBSD_ABI_TAG))
 451         {
 452           /* There is no need to check the version yet.  */
 453           *osabi = GDB_OSABI_FREEBSD_ELF;
 454           return;
 455         }
 456
 457       return;
 458     }
 459
 460   /* .note.netbsd.ident notes, used by NetBSD.  */
 461   if (strcmp (name, ".note.netbsd.ident") == 0
 462       && check_note (abfd, sect, note, "NetBSD", 4, NT_NETBSD_IDENT))
 463     {
 464       /* There is no need to check the version yet.  */
 465       *osabi = GDB_OSABI_NETBSD_ELF;
 466       return;
 467     }
 468
 469   /* .note.openbsd.ident notes, used by OpenBSD.  */
 470   if (strcmp (name, ".note.openbsd.ident") == 0
 471       && check_note (abfd, sect, note, "OpenBSD", 4, NT_OPENBSD_IDENT))
 472     {
 473       /* There is no need to check the version yet.  */
 474       *osabi = GDB_OSABI_OPENBSD_ELF;
 475       return;
 476     }
 477
 478   /* .note.netbsdcore.procinfo notes, used by NetBSD.  */
 479   if (strcmp (name, ".note.netbsdcore.procinfo") == 0)
 480     {
 481       *osabi = GDB_OSABI_NETBSD_ELF;
 482       return;
 483     }
 484 }
 485
 486 static enum gdb_osabi
 487 generic_elf_osabi_sniffer (bfd *abfd)
 488 {
 489   unsigned int elfosabi;
 490   enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
 491
 492   elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
 493
 494   switch (elfosabi)
 495     {
 496     case ELFOSABI_NONE:
 497       /* When the EI_OSABI field in the ELF header is ELFOSABI_NONE
 498          (0), then the ELF structures in the file are conforming to
 499          the base specification for that machine (there are no
 500          OS-specific extensions).  In order to determine the real OS
 501          in use we must look for OS-specific notes.  */
 502       bfd_map_over_sections (abfd,
 503                              generic_elf_osabi_sniff_abi_tag_sections,
 504                              &osabi);
 505       break;
 506
 507     case ELFOSABI_FREEBSD:
 508       osabi = GDB_OSABI_FREEBSD_ELF;
 509       break;
 510
 511     case ELFOSABI_NETBSD:
 512       osabi = GDB_OSABI_NETBSD_ELF;
 513       break;
 514
 515     case ELFOSABI_LINUX:
 516       osabi = GDB_OSABI_LINUX;
 517       break;
 518
 519     case ELFOSABI_HURD:
 520       osabi = GDB_OSABI_HURD;
 521       break;
 522
 523     case ELFOSABI_SOLARIS:
 524       osabi = GDB_OSABI_SOLARIS;
 525       break;
 526
 527     case ELFOSABI_HPUX:
 528       /* For some reason the default value for the EI_OSABI field is
 529          ELFOSABI_HPUX for all PA-RISC targets (with the exception of
 530          GNU/Linux).  We use HP-UX ELF as the default, but let any
 531          OS-specific notes override this.  */
 532       osabi = GDB_OSABI_HPUX_ELF;
 533       bfd_map_over_sections (abfd,
 534                              generic_elf_osabi_sniff_abi_tag_sections,
 535                              &osabi);
 536       break;
 537     }
 538
 539   if (osabi == GDB_OSABI_UNKNOWN)
 540     {
 541       /* The FreeBSD folks have been naughty; they stored the string
 542          "FreeBSD" in the padding of the e_ident field of the ELF
 543          header to "brand" their ELF binaries in FreeBSD 3.x.  */
 544       if (memcmp (&elf_elfheader (abfd)->e_ident[8],
 545                   "FreeBSD", sizeof ("FreeBSD")) == 0)
 546         osabi = GDB_OSABI_FREEBSD_ELF;
 547     }
 548
 549   return osabi;
 550 }
 551 \f
 552 static void
 553 set_osabi (char *args, int from_tty, struct cmd_list_element *c)
 554 {
 555   struct gdbarch_info info;
 556
 557   if (strcmp (set_osabi_string, "auto") == 0)
 558     user_osabi_state = osabi_auto;
 559   else if (strcmp (set_osabi_string, "default") == 0)
 560     {
 561       user_selected_osabi = GDB_OSABI_DEFAULT;
 562       user_osabi_state = osabi_user;
 563     }
 564   else if (strcmp (set_osabi_string, "none") == 0)
 565     {
 566       user_selected_osabi = GDB_OSABI_UNKNOWN;
 567       user_osabi_state = osabi_user;
 568     }
 569   else
 570     {
 571       int i;
 572       for (i = 1; i < GDB_OSABI_INVALID; i++)
 573         if (strcmp (set_osabi_string, gdbarch_osabi_name (i)) == 0)
 574           {
 575             user_selected_osabi = i;
 576             user_osabi_state = osabi_user;
 577             break;
 578           }
 579       if (i == GDB_OSABI_INVALID)
 580         internal_error (__FILE__, __LINE__,
 581                         _("Invalid OS ABI \"%s\" passed to command handler."),
 582                         set_osabi_string);
 583     }
 584
 585   /* NOTE: At some point (true multiple architectures) we'll need to be more
 586      graceful here.  */
 587   gdbarch_info_init (&info);
 588   if (! gdbarch_update_p (info))
 589     internal_error (__FILE__, __LINE__, _("Updating OS ABI failed."));
 590 }
 591
 592 static void
 593 show_osabi (struct ui_file *file, int from_tty, struct cmd_list_element *c,
 594             const char *value)
 595 {
 596   if (user_osabi_state == osabi_auto)
 597     fprintf_filtered (file,
 598                       _("The current OS ABI is \"auto\" (currently \"%s\").\n"),
 599                       gdbarch_osabi_name (gdbarch_osabi (current_gdbarch)));
 600   else
 601     fprintf_filtered (file, _("The current OS ABI is \"%s\".\n"),
 602                       gdbarch_osabi_name (user_selected_osabi));
 603
 604   if (GDB_OSABI_DEFAULT != GDB_OSABI_UNKNOWN)
 605     fprintf_filtered (file, _("The default OS ABI is \"%s\".\n"),
 606                       gdbarch_osabi_name (GDB_OSABI_DEFAULT));
 607 }
 608 \f
 609 extern initialize_file_ftype _initialize_gdb_osabi; /* -Wmissing-prototype */
 610
 611 void
 612 _initialize_gdb_osabi (void)
 613 {
 614   struct cmd_list_element *c;
 615
 616   if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
 617     internal_error
 618       (__FILE__, __LINE__,
 619        _("_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent"));
 620
 621   /* Register a generic sniffer for ELF flavoured files.  */
 622   gdbarch_register_osabi_sniffer (bfd_arch_unknown,
 623                                   bfd_target_elf_flavour,
 624                                   generic_elf_osabi_sniffer);
 625
 626   /* Register the "set osabi" command.  */
 627   add_setshow_enum_cmd ("osabi", class_support, gdb_osabi_available_names,
 628                         &set_osabi_string, _("\
 629 Set OS ABI of target."), _("\
 630 Show OS ABI of target."), NULL,
 631                         set_osabi,
 632                         show_osabi,
 633                         &setlist, &showlist);
 634   user_osabi_state = osabi_auto;
 635 }