gdb/solib-darwin.c

   1 /* Handle Darwin shared libraries for GDB, the GNU Debugger.
   2
   3    Copyright (C) 2009-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program 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    This program is distributed in the hope that it will be useful,
  13    but 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 #include "defs.h"
  21
  22 #include "symtab.h"
  23 #include "bfd.h"
  24 #include "symfile.h"
  25 #include "objfiles.h"
  26 #include "gdbcore.h"
  27 #include "target.h"
  28 #include "inferior.h"
  29 #include "regcache.h"
  30 #include "gdbthread.h"
  31 #include "gdb_bfd.h"
  32
  33 #include "solist.h"
  34 #include "solib.h"
  35 #include "solib-svr4.h"
  36
  37 #include "bfd-target.h"
  38 #include "elf-bfd.h"
  39 #include "exec.h"
  40 #include "auxv.h"
  41 #include "mach-o.h"
  42 #include "mach-o/external.h"
  43
  44 struct gdb_dyld_image_info
  45 {
  46   /* Base address (which corresponds to the Mach-O header).  */
  47   CORE_ADDR mach_header;
  48   /* Image file path.  */
  49   CORE_ADDR file_path;
  50   /* st.m_time of image file.  */
  51   unsigned long mtime;
  52 };
  53
  54 /* Content of inferior dyld_all_image_infos structure.
  55    See /usr/include/mach-o/dyld_images.h for the documentation.  */
  56 struct gdb_dyld_all_image_infos
  57 {
  58   /* Version (1).  */
  59   unsigned int version;
  60   /* Number of images.  */
  61   unsigned int count;
  62   /* Image description.  */
  63   CORE_ADDR info;
  64   /* Notifier (function called when a library is added or removed).  */
  65   CORE_ADDR notifier;
  66 };
  67
  68 /* Current all_image_infos version.  */
  69 #define DYLD_VERSION_MIN 1
  70 #define DYLD_VERSION_MAX 15
  71
  72 /* Per PSPACE specific data.  */
  73 struct darwin_info
  74 {
  75   /* Address of structure dyld_all_image_infos in inferior.  */
  76   CORE_ADDR all_image_addr;
  77
  78   /* Gdb copy of dyld_all_info_infos.  */
  79   struct gdb_dyld_all_image_infos all_image;
  80 };
  81
  82 /* Per-program-space data key.  */
  83 static const struct program_space_data *solib_darwin_pspace_data;
  84
  85 static void
  86 darwin_pspace_data_cleanup (struct program_space *pspace, void *arg)
  87 {
  88   xfree (arg);
  89 }
  90
  91 /* Get the current darwin data.  If none is found yet, add it now.  This
  92    function always returns a valid object.  */
  93
  94 static struct darwin_info *
  95 get_darwin_info (void)
  96 {
  97   struct darwin_info *info;
  98
  99   info = (struct darwin_info *) program_space_data (current_program_space,
 100                                                     solib_darwin_pspace_data);
 101   if (info != NULL)
 102     return info;
 103
 104   info = XCNEW (struct darwin_info);
 105   set_program_space_data (current_program_space,
 106                           solib_darwin_pspace_data, info);
 107   return info;
 108 }
 109
 110 /* Return non-zero if the version in dyld_all_image is known.  */
 111
 112 static int
 113 darwin_dyld_version_ok (const struct darwin_info *info)
 114 {
 115   return info->all_image.version >= DYLD_VERSION_MIN
 116     && info->all_image.version <= DYLD_VERSION_MAX;
 117 }
 118
 119 /* Read dyld_all_image from inferior.  */
 120
 121 static void
 122 darwin_load_image_infos (struct darwin_info *info)
 123 {
 124   gdb_byte buf[24];
 125   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 126   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 127   int len;
 128
 129   /* If the structure address is not known, don't continue.  */
 130   if (info->all_image_addr == 0)
 131     return;
 132
 133   /* The structure has 4 fields: version (4 bytes), count (4 bytes),
 134      info (pointer) and notifier (pointer).  */
 135   len = 4 + 4 + 2 * TYPE_LENGTH (ptr_type);
 136   gdb_assert (len <= sizeof (buf));
 137   memset (&info->all_image, 0, sizeof (info->all_image));
 138
 139   /* Read structure raw bytes from target.  */
 140   if (target_read_memory (info->all_image_addr, buf, len))
 141     return;
 142
 143   /* Extract the fields.  */
 144   info->all_image.version = extract_unsigned_integer (buf, 4, byte_order);
 145   if (!darwin_dyld_version_ok (info))
 146     return;
 147
 148   info->all_image.count = extract_unsigned_integer (buf + 4, 4, byte_order);
 149   info->all_image.info = extract_typed_address (buf + 8, ptr_type);
 150   info->all_image.notifier = extract_typed_address
 151     (buf + 8 + TYPE_LENGTH (ptr_type), ptr_type);
 152 }
 153
 154 /* Link map info to include in an allocated so_list entry.  */
 155
 156 struct lm_info_darwin : public lm_info_base
 157 {
 158   /* The target location of lm.  */
 159   CORE_ADDR lm_addr = 0;
 160 };
 161
 162 /* Lookup the value for a specific symbol.  */
 163
 164 static CORE_ADDR
 165 lookup_symbol_from_bfd (bfd *abfd, const char *symname)
 166 {
 167   long storage_needed;
 168   asymbol **symbol_table;
 169   unsigned int number_of_symbols;
 170   unsigned int i;
 171   CORE_ADDR symaddr = 0;
 172
 173   storage_needed = bfd_get_symtab_upper_bound (abfd);
 174
 175   if (storage_needed <= 0)
 176     return 0;
 177
 178   symbol_table = (asymbol **) xmalloc (storage_needed);
 179   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 180
 181   for (i = 0; i < number_of_symbols; i++)
 182     {
 183       asymbol *sym = symbol_table[i];
 184
 185       if (strcmp (sym->name, symname) == 0
 186           && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
 187         {
 188           /* BFD symbols are section relative.  */
 189           symaddr = sym->value + sym->section->vma;
 190           break;
 191         }
 192     }
 193   xfree (symbol_table);
 194
 195   return symaddr;
 196 }
 197
 198 /* Return program interpreter string.  */
 199
 200 static char *
 201 find_program_interpreter (void)
 202 {
 203   char *buf = NULL;
 204
 205   /* If we have an exec_bfd, get the interpreter from the load commands.  */
 206   if (exec_bfd)
 207     {
 208       bfd_mach_o_load_command *cmd;
 209
 210       if (bfd_mach_o_lookup_command (exec_bfd,
 211                                      BFD_MACH_O_LC_LOAD_DYLINKER, &cmd) == 1)
 212         return cmd->command.dylinker.name_str;
 213     }
 214
 215   /* If we didn't find it, read from memory.
 216      FIXME: todo.  */
 217   return buf;
 218 }
 219
 220 /*  Not used.  I don't see how the main symbol file can be found: the
 221     interpreter name is needed and it is known from the executable file.
 222     Note that darwin-nat.c implements pid_to_exec_file.  */
 223
 224 static int
 225 open_symbol_file_object (int from_tty)
 226 {
 227   return 0;
 228 }
 229
 230 /* Build a list of currently loaded shared objects.  See solib-svr4.c.  */
 231
 232 static struct so_list *
 233 darwin_current_sos (void)
 234 {
 235   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 236   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 237   int ptr_len = TYPE_LENGTH (ptr_type);
 238   unsigned int image_info_size;
 239   struct so_list *head = NULL;
 240   struct so_list *tail = NULL;
 241   int i;
 242   struct darwin_info *info = get_darwin_info ();
 243
 244   /* Be sure image infos are loaded.  */
 245   darwin_load_image_infos (info);
 246
 247   if (!darwin_dyld_version_ok (info))
 248     return NULL;
 249
 250   image_info_size = ptr_len * 3;
 251
 252   /* Read infos for each solib.
 253      The first entry was rumored to be the executable itself, but this is not
 254      true when a large number of shared libraries are used (table expanded ?).
 255      We now check all entries, but discard executable images.  */
 256   for (i = 0; i < info->all_image.count; i++)
 257     {
 258       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 259       gdb_byte buf[image_info_size];
 260       CORE_ADDR load_addr;
 261       CORE_ADDR path_addr;
 262       struct mach_o_header_external hdr;
 263       unsigned long hdr_val;
 264       char *file_path;
 265       int errcode;
 266       struct so_list *newobj;
 267       struct cleanup *old_chain;
 268
 269       /* Read image info from inferior.  */
 270       if (target_read_memory (iinfo, buf, image_info_size))
 271         break;
 272
 273       load_addr = extract_typed_address (buf, ptr_type);
 274       path_addr = extract_typed_address (buf + ptr_len, ptr_type);
 275
 276       /* Read Mach-O header from memory.  */
 277       if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 278         break;
 279       /* Discard wrong magic numbers.  Shouldn't happen.  */
 280       hdr_val = extract_unsigned_integer
 281         (hdr.magic, sizeof (hdr.magic), byte_order);
 282       if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 283         continue;
 284       /* Discard executable.  Should happen only once.  */
 285       hdr_val = extract_unsigned_integer
 286         (hdr.filetype, sizeof (hdr.filetype), byte_order);
 287       if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 288         continue;
 289
 290       target_read_string (path_addr, &file_path,
 291                           SO_NAME_MAX_PATH_SIZE - 1, &errcode);
 292       if (errcode)
 293         break;
 294
 295       /* Create and fill the new so_list element.  */
 296       newobj = XCNEW (struct so_list);
 297       old_chain = make_cleanup (xfree, newobj);
 298
 299       lm_info_darwin *li = new lm_info_darwin;
 300       newobj->lm_info = li;
 301
 302       strncpy (newobj->so_name, file_path, SO_NAME_MAX_PATH_SIZE - 1);
 303       newobj->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
 304       strcpy (newobj->so_original_name, newobj->so_name);
 305       xfree (file_path);
 306       li->lm_addr = load_addr;
 307
 308       if (head == NULL)
 309         head = newobj;
 310       else
 311         tail->next = newobj;
 312       tail = newobj;
 313
 314       discard_cleanups (old_chain);
 315     }
 316
 317   return head;
 318 }
 319
 320 /* Check LOAD_ADDR points to a Mach-O executable header.  Return LOAD_ADDR
 321    in case of success, 0 in case of failure.  */
 322
 323 static CORE_ADDR
 324 darwin_validate_exec_header (CORE_ADDR load_addr)
 325 {
 326   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 327   struct mach_o_header_external hdr;
 328   unsigned long hdr_val;
 329
 330   /* Read Mach-O header from memory.  */
 331   if (target_read_memory (load_addr, (gdb_byte *) &hdr, sizeof (hdr) - 4))
 332     return 0;
 333
 334   /* Discard wrong magic numbers.  Shouldn't happen.  */
 335   hdr_val = extract_unsigned_integer
 336     (hdr.magic, sizeof (hdr.magic), byte_order);
 337   if (hdr_val != BFD_MACH_O_MH_MAGIC && hdr_val != BFD_MACH_O_MH_MAGIC_64)
 338     return 0;
 339
 340   /* Check executable.  */
 341   hdr_val = extract_unsigned_integer
 342     (hdr.filetype, sizeof (hdr.filetype), byte_order);
 343   if (hdr_val == BFD_MACH_O_MH_EXECUTE)
 344     return load_addr;
 345
 346   return 0;
 347 }
 348
 349 /* Get the load address of the executable using dyld list of images.
 350    We assume that the dyld info are correct (which is wrong if the target
 351    is stopped at the first instruction).  */
 352
 353 static CORE_ADDR
 354 darwin_read_exec_load_addr_from_dyld (struct darwin_info *info)
 355 {
 356   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 357   int ptr_len = TYPE_LENGTH (ptr_type);
 358   unsigned int image_info_size = ptr_len * 3;
 359   int i;
 360
 361   /* Read infos for each solib.  One of them should be the executable.  */
 362   for (i = 0; i < info->all_image.count; i++)
 363     {
 364       CORE_ADDR iinfo = info->all_image.info + i * image_info_size;
 365       gdb_byte buf[image_info_size];
 366       CORE_ADDR load_addr;
 367
 368       /* Read image info from inferior.  */
 369       if (target_read_memory (iinfo, buf, image_info_size))
 370         break;
 371
 372       load_addr = extract_typed_address (buf, ptr_type);
 373       if (darwin_validate_exec_header (load_addr) == load_addr)
 374         return load_addr;
 375     }
 376
 377   return 0;
 378 }
 379
 380 /* Get the load address of the executable when the PC is at the dyld
 381    entry point using parameter passed by the kernel (at SP). */
 382
 383 static CORE_ADDR
 384 darwin_read_exec_load_addr_at_init (struct darwin_info *info)
 385 {
 386   struct gdbarch *gdbarch = target_gdbarch ();
 387   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 388   int addr_size = gdbarch_addr_bit (gdbarch) / 8;
 389   ULONGEST load_ptr_addr;
 390   ULONGEST load_addr;
 391   gdb_byte buf[8];
 392
 393   /* Get SP.  */
 394   if (regcache_cooked_read_unsigned (get_current_regcache (),
 395                                      gdbarch_sp_regnum (gdbarch),
 396                                      &load_ptr_addr) != REG_VALID)
 397     return 0;
 398
 399   /* Read value at SP (image load address).  */
 400   if (target_read_memory (load_ptr_addr, buf, addr_size))
 401     return 0;
 402
 403   load_addr = extract_unsigned_integer (buf, addr_size, byte_order);
 404
 405   return darwin_validate_exec_header (load_addr);
 406 }
 407
 408 /* Return 1 if PC lies in the dynamic symbol resolution code of the
 409    run time loader.  */
 410
 411 static int
 412 darwin_in_dynsym_resolve_code (CORE_ADDR pc)
 413 {
 414   return 0;
 415 }
 416
 417 /* A wrapper for bfd_mach_o_fat_extract that handles reference
 418    counting properly.  This will either return NULL, or return a new
 419    reference to a BFD.  */
 420
 421 static gdb_bfd_ref_ptr
 422 gdb_bfd_mach_o_fat_extract (bfd *abfd, bfd_format format,
 423                             const bfd_arch_info_type *arch)
 424 {
 425   bfd *result = bfd_mach_o_fat_extract (abfd, format, arch);
 426
 427   if (result == NULL)
 428     return NULL;
 429
 430   if (result == abfd)
 431     gdb_bfd_ref (result);
 432   else
 433     gdb_bfd_mark_parent (result, abfd);
 434
 435   return gdb_bfd_ref_ptr (result);
 436 }
 437
 438 /* Extract dyld_all_image_addr when the process was just created, assuming the
 439    current PC is at the entry of the dynamic linker.  */
 440
 441 static void
 442 darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info)
 443 {
 444   char *interp_name;
 445   CORE_ADDR load_addr = 0;
 446
 447   /* This method doesn't work with an attached process.  */
 448   if (current_inferior ()->attach_flag)
 449     return;
 450
 451   /* Find the program interpreter.  */
 452   interp_name = find_program_interpreter ();
 453   if (!interp_name)
 454     return;
 455
 456   /* Create a bfd for the interpreter.  */
 457   gdb_bfd_ref_ptr dyld_bfd (gdb_bfd_open (interp_name, gnutarget, -1));
 458   if (dyld_bfd != NULL)
 459     {
 460       gdb_bfd_ref_ptr sub
 461         (gdb_bfd_mach_o_fat_extract (dyld_bfd.get (), bfd_object,
 462                                      gdbarch_bfd_arch_info (target_gdbarch ())));
 463       if (sub != NULL)
 464         dyld_bfd = sub;
 465       else
 466         dyld_bfd.release ();
 467     }
 468   if (dyld_bfd == NULL)
 469     return;
 470
 471   /* We find the dynamic linker's base address by examining
 472      the current pc (which should point at the entry point for the
 473      dynamic linker) and subtracting the offset of the entry point.  */
 474   load_addr = (regcache_read_pc (get_current_regcache ())
 475                - bfd_get_start_address (dyld_bfd.get ()));
 476
 477   /* Now try to set a breakpoint in the dynamic linker.  */
 478   info->all_image_addr =
 479     lookup_symbol_from_bfd (dyld_bfd.get (), "_dyld_all_image_infos");
 480
 481   if (info->all_image_addr == 0)
 482     return;
 483
 484   info->all_image_addr += load_addr;
 485 }
 486
 487 /* Extract dyld_all_image_addr reading it from
 488    TARGET_OBJECT_DARWIN_DYLD_INFO.  */
 489
 490 static void
 491 darwin_solib_read_all_image_info_addr (struct darwin_info *info)
 492 {
 493   gdb_byte buf[8];
 494   LONGEST len;
 495   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 496
 497   /* Sanity check.  */
 498   if (TYPE_LENGTH (ptr_type) > sizeof (buf))
 499     return;
 500
 501   len = target_read (&current_target, TARGET_OBJECT_DARWIN_DYLD_INFO, NULL,
 502                      buf, 0, TYPE_LENGTH (ptr_type));
 503   if (len <= 0)
 504     return;
 505
 506   /* The use of BIG endian is intended, as BUF is a raw stream of bytes.  This
 507       makes the support of remote protocol easier.  */
 508   info->all_image_addr = extract_unsigned_integer (buf, len, BFD_ENDIAN_BIG);
 509 }
 510
 511 /* Shared library startup support.  See documentation in solib-svr4.c.  */
 512
 513 static void
 514 darwin_solib_create_inferior_hook (int from_tty)
 515 {
 516   struct darwin_info *info = get_darwin_info ();
 517   CORE_ADDR load_addr;
 518
 519   info->all_image_addr = 0;
 520
 521   darwin_solib_read_all_image_info_addr (info);
 522
 523   if (info->all_image_addr == 0)
 524     darwin_solib_get_all_image_info_addr_at_init (info);
 525
 526   if (info->all_image_addr == 0)
 527     return;
 528
 529   darwin_load_image_infos (info);
 530
 531   if (!darwin_dyld_version_ok (info))
 532     {
 533       warning (_("unhandled dyld version (%d)"), info->all_image.version);
 534       return;
 535     }
 536
 537   /* Add the breakpoint which is hit by dyld when the list of solib is
 538      modified.  */
 539   create_solib_event_breakpoint (target_gdbarch (), info->all_image.notifier);
 540
 541   if (info->all_image.count != 0)
 542     {
 543       /* Possible relocate the main executable (PIE).  */
 544       load_addr = darwin_read_exec_load_addr_from_dyld (info);
 545     }
 546   else
 547     {
 548       /* Possible issue:
 549          Do not break on the notifier if dyld is not initialized (deduced from
 550          count == 0).  In that case, dyld hasn't relocated itself and the
 551          notifier may point to a wrong address.  */
 552
 553       load_addr = darwin_read_exec_load_addr_at_init (info);
 554     }
 555
 556   if (load_addr != 0 && symfile_objfile != NULL)
 557     {
 558       CORE_ADDR vmaddr;
 559
 560       /* Find the base address of the executable.  */
 561       vmaddr = bfd_mach_o_get_base_address (exec_bfd);
 562
 563       /* Relocate.  */
 564       if (vmaddr != load_addr)
 565         objfile_rebase (symfile_objfile, load_addr - vmaddr);
 566     }
 567 }
 568
 569 static void
 570 darwin_clear_solib (void)
 571 {
 572   struct darwin_info *info = get_darwin_info ();
 573
 574   info->all_image_addr = 0;
 575   info->all_image.version = 0;
 576 }
 577
 578 static void
 579 darwin_free_so (struct so_list *so)
 580 {
 581   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 582
 583   delete li;
 584 }
 585
 586 /* The section table is built from bfd sections using bfd VMAs.
 587    Relocate these VMAs according to solib info.  */
 588
 589 static void
 590 darwin_relocate_section_addresses (struct so_list *so,
 591                                    struct target_section *sec)
 592 {
 593   lm_info_darwin *li = (lm_info_darwin *) so->lm_info;
 594
 595   sec->addr += li->lm_addr;
 596   sec->endaddr += li->lm_addr;
 597
 598   /* Best effort to set addr_high/addr_low.  This is used only by
 599      'info sharedlibary'.  */
 600   if (so->addr_high == 0)
 601     {
 602       so->addr_low = sec->addr;
 603       so->addr_high = sec->endaddr;
 604     }
 605   if (sec->endaddr > so->addr_high)
 606     so->addr_high = sec->endaddr;
 607   if (sec->addr < so->addr_low)
 608     so->addr_low = sec->addr;
 609 }
 610 \f
 611 static struct block_symbol
 612 darwin_lookup_lib_symbol (struct objfile *objfile,
 613                           const char *name,
 614                           const domain_enum domain)
 615 {
 616   return (struct block_symbol) {NULL, NULL};
 617 }
 618
 619 static gdb_bfd_ref_ptr
 620 darwin_bfd_open (char *pathname)
 621 {
 622   char *found_pathname;
 623   int found_file;
 624
 625   /* Search for shared library file.  */
 626   found_pathname = solib_find (pathname, &found_file);
 627   if (found_pathname == NULL)
 628     perror_with_name (pathname);
 629
 630   /* Open bfd for shared library.  */
 631   gdb_bfd_ref_ptr abfd (solib_bfd_fopen (found_pathname, found_file));
 632
 633   gdb_bfd_ref_ptr res
 634     (gdb_bfd_mach_o_fat_extract (abfd.get (), bfd_object,
 635                                  gdbarch_bfd_arch_info (target_gdbarch ())));
 636   if (res == NULL)
 637     error (_("`%s': not a shared-library: %s"),
 638            bfd_get_filename (abfd.get ()), bfd_errmsg (bfd_get_error ()));
 639
 640   /* The current filename for fat-binary BFDs is a name generated
 641      by BFD, usually a string containing the name of the architecture.
 642      Reset its value to the actual filename.  */
 643   xfree (bfd_get_filename (res.get ()));
 644   res->filename = xstrdup (pathname);
 645
 646   return res;
 647 }
 648
 649 struct target_so_ops darwin_so_ops;
 650
 651 void
 652 _initialize_darwin_solib (void)
 653 {
 654   solib_darwin_pspace_data
 655     = register_program_space_data_with_cleanup (NULL,
 656                                                 darwin_pspace_data_cleanup);
 657
 658   darwin_so_ops.relocate_section_addresses = darwin_relocate_section_addresses;
 659   darwin_so_ops.free_so = darwin_free_so;
 660   darwin_so_ops.clear_solib = darwin_clear_solib;
 661   darwin_so_ops.solib_create_inferior_hook = darwin_solib_create_inferior_hook;
 662   darwin_so_ops.current_sos = darwin_current_sos;
 663   darwin_so_ops.open_symbol_file_object = open_symbol_file_object;
 664   darwin_so_ops.in_dynsym_resolve_code = darwin_in_dynsym_resolve_code;
 665   darwin_so_ops.lookup_lib_global_symbol = darwin_lookup_lib_symbol;
 666   darwin_so_ops.bfd_open = darwin_bfd_open;
 667 }