home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / bfdlink.h < prev    next >
Encoding:
C/C++ Source or Header  |  2003-12-15  |  22.3 KB  |  561 lines
  1. /* bfdlink.h -- header file for BFD link routines
  2.    Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
  3.    Free Software Foundation, Inc.
  4.    Written by Steve Chamberlain and Ian Lance Taylor, Cygnus Support.
  5.  
  6. This file is part of BFD, the Binary File Descriptor library.
  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 2 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, write to the Free Software
  20. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21.  
  22. #ifndef BFDLINK_H
  23. #define BFDLINK_H
  24.  
  25. /* Which symbols to strip during a link.  */
  26. enum bfd_link_strip
  27. {
  28.   strip_none,        /* Don't strip any symbols.  */
  29.   strip_debugger,    /* Strip debugging symbols.  */
  30.   strip_some,        /* keep_hash is the list of symbols to keep.  */
  31.   strip_all        /* Strip all symbols.  */
  32. };
  33.  
  34. /* Which local symbols to discard during a link.  This is irrelevant
  35.    if strip_all is used.  */
  36. enum bfd_link_discard
  37. {
  38.   discard_sec_merge,    /* Discard local temporary symbols in SEC_MERGE
  39.                sections.  */
  40.   discard_none,        /* Don't discard any locals.  */
  41.   discard_l,        /* Discard local temporary symbols.  */
  42.   discard_all        /* Discard all locals.  */
  43. };
  44.  
  45. /* These are the possible types of an entry in the BFD link hash
  46.    table.  */
  47.  
  48. enum bfd_link_hash_type
  49. {
  50.   bfd_link_hash_new,        /* Symbol is new.  */
  51.   bfd_link_hash_undefined,    /* Symbol seen before, but undefined.  */
  52.   bfd_link_hash_undefweak,    /* Symbol is weak and undefined.  */
  53.   bfd_link_hash_defined,    /* Symbol is defined.  */
  54.   bfd_link_hash_defweak,    /* Symbol is weak and defined.  */
  55.   bfd_link_hash_common,        /* Symbol is common.  */
  56.   bfd_link_hash_indirect,    /* Symbol is an indirect link.  */
  57.   bfd_link_hash_warning        /* Like indirect, but warn if referenced.  */
  58. };
  59.  
  60. /* The linking routines use a hash table which uses this structure for
  61.    its elements.  */
  62.  
  63. struct bfd_link_hash_entry
  64. {
  65.   /* Base hash table entry structure.  */
  66.   struct bfd_hash_entry root;
  67.   /* Type of this entry.  */
  68.   enum bfd_link_hash_type type;
  69.  
  70.   /* Undefined and common symbols are kept in a linked list through
  71.      this field.  This field is not in the union because that would
  72.      force us to remove entries from the list when we changed their
  73.      type, which would force the list to be doubly linked, which would
  74.      waste more memory.  When an undefined or common symbol is
  75.      created, it should be added to this list, the head of which is in
  76.      the link hash table itself.  As symbols are defined, they need
  77.      not be removed from the list; anything which reads the list must
  78.      doublecheck the symbol type.
  79.  
  80.      Weak symbols are not kept on this list.
  81.  
  82.      Defined and defweak symbols use this field as a reference marker.
  83.      If the field is not NULL, or this structure is the tail of the
  84.      undefined symbol list, the symbol has been referenced.  If the
  85.      symbol is undefined and becomes defined, this field will
  86.      automatically be non-NULL since the symbol will have been on the
  87.      undefined symbol list.  */
  88.   struct bfd_link_hash_entry *next;
  89.   /* A union of information depending upon the type.  */
  90.   union
  91.     {
  92.       /* Nothing is kept for bfd_hash_new.  */
  93.       /* bfd_link_hash_undefined, bfd_link_hash_undefweak.  */
  94.       struct
  95.     {
  96.       bfd *abfd;        /* BFD symbol was found in.  */
  97.     } undef;
  98.       /* bfd_link_hash_defined, bfd_link_hash_defweak.  */
  99.       struct
  100.     {
  101.       bfd_vma value;    /* Symbol value.  */
  102.       asection *section;    /* Symbol section.  */
  103.     } def;
  104.       /* bfd_link_hash_indirect, bfd_link_hash_warning.  */
  105.       struct
  106.     {
  107.       struct bfd_link_hash_entry *link;    /* Real symbol.  */
  108.       const char *warning;    /* Warning (bfd_link_hash_warning only).  */
  109.     } i;
  110.       /* bfd_link_hash_common.  */
  111.       struct
  112.     {
  113.       /* The linker needs to know three things about common
  114.              symbols: the size, the alignment, and the section in
  115.              which the symbol should be placed.  We store the size
  116.              here, and we allocate a small structure to hold the
  117.              section and the alignment.  The alignment is stored as a
  118.              power of two.  We don't store all the information
  119.              directly because we don't want to increase the size of
  120.              the union; this structure is a major space user in the
  121.              linker.  */
  122.       bfd_size_type size;    /* Common symbol size.  */
  123.       struct bfd_link_hash_common_entry
  124.         {
  125.           unsigned int alignment_power;    /* Alignment.  */
  126.           asection *section;        /* Symbol section.  */
  127.         } *p;
  128.     } c;
  129.     } u;
  130. };
  131.  
  132. /* This is the link hash table.  It is a derived class of
  133.    bfd_hash_table.  */
  134.  
  135. struct bfd_link_hash_table
  136. {
  137.   /* The hash table itself.  */
  138.   struct bfd_hash_table table;
  139.   /* The back end which created this hash table.  This indicates the
  140.      type of the entries in the hash table, which is sometimes
  141.      important information when linking object files of different
  142.      types together.  */
  143.   const bfd_target *creator;
  144.   /* A linked list of undefined and common symbols, linked through the
  145.      next field in the bfd_link_hash_entry structure.  */
  146.   struct bfd_link_hash_entry *undefs;
  147.   /* Entries are added to the tail of the undefs list.  */
  148.   struct bfd_link_hash_entry *undefs_tail;
  149. };
  150.  
  151. /* Look up an entry in a link hash table.  If FOLLOW is true, this
  152.    follows bfd_link_hash_indirect and bfd_link_hash_warning links to
  153.    the real symbol.  */
  154. extern struct bfd_link_hash_entry *bfd_link_hash_lookup
  155.   PARAMS ((struct bfd_link_hash_table *, const char *, boolean create,
  156.        boolean copy, boolean follow));
  157.  
  158. /* Look up an entry in the main linker hash table if the symbol might
  159.    be wrapped.  This should only be used for references to an
  160.    undefined symbol, not for definitions of a symbol.  */
  161.  
  162. extern struct bfd_link_hash_entry *bfd_wrapped_link_hash_lookup
  163.   PARAMS ((bfd *, struct bfd_link_info *, const char *, boolean, boolean,
  164.        boolean));
  165.  
  166. /* Traverse a link hash table.  */
  167. extern void bfd_link_hash_traverse
  168.   PARAMS ((struct bfd_link_hash_table *,
  169.        boolean (*) (struct bfd_link_hash_entry *, PTR),
  170.        PTR));
  171.  
  172. /* Add an entry to the undefs list.  */
  173. extern void bfd_link_add_undef
  174.   PARAMS ((struct bfd_link_hash_table *, struct bfd_link_hash_entry *));
  175.  
  176. /* This structure holds all the information needed to communicate
  177.    between BFD and the linker when doing a link.  */
  178.  
  179. struct bfd_link_info
  180. {
  181.   /* Function callbacks.  */
  182.   const struct bfd_link_callbacks *callbacks;
  183.   /* true if BFD should generate a relocateable object file.  */
  184.   boolean relocateable;
  185.   /* true if BFD should generate relocation information in the final executable.  */
  186.   boolean emitrelocations;
  187.   /* true if BFD should generate a "task linked" object file,
  188.      similar to relocatable but also with globals converted to statics. */
  189.   boolean task_link;
  190.   /* true if BFD should generate a shared object.  */
  191.   boolean shared;
  192.   /* true if BFD should pre-bind symbols in a shared object.  */
  193.   boolean symbolic;
  194.   /* true if BFD should export all symbols in the dynamic symbol table
  195.      of an executable, rather than only those used.  */
  196.   boolean export_dynamic;
  197.   /* true if shared objects should be linked directly, not shared.  */
  198.   boolean static_link;
  199.   /* true if the output file should be in a traditional format.  This
  200.      is equivalent to the setting of the BFD_TRADITIONAL_FORMAT flag
  201.      on the output file, but may be checked when reading the input
  202.      files.  */
  203.   boolean traditional_format;
  204.   /* true if we want to produced optimized output files.  This might
  205.      need much more time and therefore must be explicitly selected.  */
  206.   boolean optimize;
  207.   /* true if BFD should generate errors for undefined symbols
  208.      even if generating a shared object.  */
  209.   boolean no_undefined;
  210.   /* true if BFD should allow undefined symbols in shared objects even
  211.      when no_undefined is set to disallow undefined symbols.  The net
  212.      result will be that undefined symbols in regular objects will
  213.      still trigger an error, but undefined symbols in shared objects
  214.      will be ignored.  The implementation of no_undefined makes the
  215.      assumption that the runtime linker will choke on undefined
  216.      symbols.  However there is at least one system (BeOS) where
  217.      undefined symbols in shared libraries is normal since the kernel
  218.      patches them at load time to select which function is most
  219.      appropriate for the current architecture.  I.E. dynamically
  220.      select an appropriate memset function.  Apparently it is also
  221.      normal for HPPA shared libraries to have undefined symbols.  */
  222.   boolean allow_shlib_undefined;
  223.   /* Which symbols to strip.  */
  224.   enum bfd_link_strip strip;
  225.   /* Which local symbols to discard.  */
  226.   enum bfd_link_discard discard;
  227.   /* true if symbols should be retained in memory, false if they
  228.      should be freed and reread.  */
  229.   boolean keep_memory;
  230.   /* The list of input BFD's involved in the link.  These are chained
  231.      together via the link_next field.  */
  232.   bfd *input_bfds;
  233.   /* If a symbol should be created for each input BFD, this is section
  234.      where those symbols should be placed.  It must be a section in
  235.      the output BFD.  It may be NULL, in which case no such symbols
  236.      will be created.  This is to support CREATE_OBJECT_SYMBOLS in the
  237.      linker command language.  */
  238.   asection *create_object_symbols_section;
  239.   /* Hash table handled by BFD.  */
  240.   struct bfd_link_hash_table *hash;
  241.   /* Hash table of symbols to keep.  This is NULL unless strip is
  242.      strip_some.  */
  243.   struct bfd_hash_table *keep_hash;
  244.   /* true if every symbol should be reported back via the notice
  245.      callback.  */
  246.   boolean notice_all;
  247.   /* Hash table of symbols to report back via the notice callback.  If
  248.      this is NULL, and notice_all is false, then no symbols are
  249.      reported back.  */
  250.   struct bfd_hash_table *notice_hash;
  251.   /* Hash table of symbols which are being wrapped (the --wrap linker
  252.      option).  If this is NULL, no symbols are being wrapped.  */
  253.   struct bfd_hash_table *wrap_hash;
  254.   /* If a base output file is wanted, then this points to it */
  255.   PTR base_file;
  256.  
  257.   /* If non-zero, specifies that branches which are problematic for the
  258.   MPC860 C0 (or earlier) should be checked for and modified.  It gives the
  259.   number of bytes that should be checked at the end of each text page. */
  260.   int mpc860c0;
  261.  
  262.   /* The function to call when the executable or shared object is
  263.      loaded.  */
  264.   const char *init_function;
  265.   /* The function to call when the executable or shared object is
  266.      unloaded.  */
  267.   const char *fini_function;
  268.  
  269.   /* true if the new ELF dynamic tags are enabled. */ 
  270.   boolean new_dtags;
  271.  
  272.   /* May be used to set DT_FLAGS for ELF. */
  273.   bfd_vma flags;
  274.  
  275.   /* May be used to set DT_FLAGS_1 for ELF. */
  276.   bfd_vma flags_1;
  277. };
  278.  
  279. /* This structures holds a set of callback functions.  These are
  280.    called by the BFD linker routines.  The first argument to each
  281.    callback function is the bfd_link_info structure being used.  Each
  282.    function returns a boolean value.  If the function returns false,
  283.    then the BFD function which called it will return with a failure
  284.    indication.  */
  285.  
  286. struct bfd_link_callbacks
  287. {
  288.   /* A function which is called when an object is added from an
  289.      archive.  ABFD is the archive element being added.  NAME is the
  290.      name of the symbol which caused the archive element to be pulled
  291.      in.  */
  292.   boolean (*add_archive_element) PARAMS ((struct bfd_link_info *,
  293.                       bfd *abfd,
  294.                       const char *name));
  295.   /* A function which is called when a symbol is found with multiple
  296.      definitions.  NAME is the symbol which is defined multiple times.
  297.      OBFD is the old BFD, OSEC is the old section, OVAL is the old
  298.      value, NBFD is the new BFD, NSEC is the new section, and NVAL is
  299.      the new value.  OBFD may be NULL.  OSEC and NSEC may be
  300.      bfd_com_section or bfd_ind_section.  */
  301.   boolean (*multiple_definition) PARAMS ((struct bfd_link_info *,
  302.                       const char *name,
  303.                       bfd *obfd,
  304.                       asection *osec,
  305.                       bfd_vma oval,
  306.                       bfd *nbfd,
  307.                       asection *nsec,
  308.                       bfd_vma nval));
  309.   /* A function which is called when a common symbol is defined
  310.      multiple times.  NAME is the symbol appearing multiple times.
  311.      OBFD is the BFD of the existing symbol; it may be NULL if this is
  312.      not known.  OTYPE is the type of the existing symbol, which may
  313.      be bfd_link_hash_defined, bfd_link_hash_defweak,
  314.      bfd_link_hash_common, or bfd_link_hash_indirect.  If OTYPE is
  315.      bfd_link_hash_common, OSIZE is the size of the existing symbol.
  316.      NBFD is the BFD of the new symbol.  NTYPE is the type of the new
  317.      symbol, one of bfd_link_hash_defined, bfd_link_hash_common, or
  318.      bfd_link_hash_indirect.  If NTYPE is bfd_link_hash_common, NSIZE
  319.      is the size of the new symbol.  */
  320.   boolean (*multiple_common) PARAMS ((struct bfd_link_info *,
  321.                       const char *name,
  322.                       bfd *obfd,
  323.                       enum bfd_link_hash_type otype,
  324.                       bfd_vma osize,
  325.                       bfd *nbfd,
  326.                       enum bfd_link_hash_type ntype,
  327.                       bfd_vma nsize));
  328.   /* A function which is called to add a symbol to a set.  ENTRY is
  329.      the link hash table entry for the set itself (e.g.,
  330.      __CTOR_LIST__).  RELOC is the relocation to use for an entry in
  331.      the set when generating a relocateable file, and is also used to
  332.      get the size of the entry when generating an executable file.
  333.      ABFD, SEC and VALUE identify the value to add to the set.  */
  334.   boolean (*add_to_set) PARAMS ((struct bfd_link_info *,
  335.                  struct bfd_link_hash_entry *entry,
  336.                  bfd_reloc_code_real_type reloc,
  337.                  bfd *abfd, asection *sec, bfd_vma value));
  338.   /* A function which is called when the name of a g++ constructor or
  339.      destructor is found.  This is only called by some object file
  340.      formats.  CONSTRUCTOR is true for a constructor, false for a
  341.      destructor.  This will use BFD_RELOC_CTOR when generating a
  342.      relocateable file.  NAME is the name of the symbol found.  ABFD,
  343.      SECTION and VALUE are the value of the symbol.  */
  344.   boolean (*constructor) PARAMS ((struct bfd_link_info *,
  345.                   boolean constructor,
  346.                   const char *name, bfd *abfd, asection *sec,
  347.                   bfd_vma value));
  348.   /* A function which is called to issue a linker warning.  For
  349.      example, this is called when there is a reference to a warning
  350.      symbol.  WARNING is the warning to be issued.  SYMBOL is the name
  351.      of the symbol which triggered the warning; it may be NULL if
  352.      there is none.  ABFD, SECTION and ADDRESS identify the location
  353.      which trigerred the warning; either ABFD or SECTION or both may
  354.      be NULL if the location is not known.  */
  355.   boolean (*warning) PARAMS ((struct bfd_link_info *,
  356.                   const char *warning, const char *symbol,
  357.                   bfd *abfd, asection *section,
  358.                   bfd_vma address));
  359.   /* A function which is called when a relocation is attempted against
  360.      an undefined symbol.  NAME is the symbol which is undefined.
  361.      ABFD, SECTION and ADDRESS identify the location from which the
  362.      reference is made. FATAL indicates whether an undefined symbol is
  363.      a fatal error or not. In some cases SECTION may be NULL.  */
  364.   boolean (*undefined_symbol) PARAMS ((struct bfd_link_info *,
  365.                        const char *name, bfd *abfd,
  366.                        asection *section,
  367.                        bfd_vma address,
  368.                        boolean fatal));
  369.   /* A function which is called when a reloc overflow occurs.  NAME is
  370.      the name of the symbol or section the reloc is against,
  371.      RELOC_NAME is the name of the relocation, and ADDEND is any
  372.      addend that is used.  ABFD, SECTION and ADDRESS identify the
  373.      location at which the overflow occurs; if this is the result of a
  374.      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
  375.      ABFD will be NULL.  */
  376.   boolean (*reloc_overflow) PARAMS ((struct bfd_link_info *,
  377.                      const char *name,
  378.                      const char *reloc_name, bfd_vma addend,
  379.                      bfd *abfd, asection *section,
  380.                      bfd_vma address));
  381.   /* A function which is called when a dangerous reloc is performed.
  382.      The canonical example is an a29k IHCONST reloc which does not
  383.      follow an IHIHALF reloc.  MESSAGE is an appropriate message.
  384.      ABFD, SECTION and ADDRESS identify the location at which the
  385.      problem occurred; if this is the result of a
  386.      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
  387.      ABFD will be NULL.  */
  388.   boolean (*reloc_dangerous) PARAMS ((struct bfd_link_info *,
  389.                       const char *message,
  390.                       bfd *abfd, asection *section,
  391.                       bfd_vma address));
  392.   /* A function which is called when a reloc is found to be attached
  393.      to a symbol which is not being written out.  NAME is the name of
  394.      the symbol.  ABFD, SECTION and ADDRESS identify the location of
  395.      the reloc; if this is the result of a
  396.      bfd_section_reloc_link_order or bfd_symbol_reloc_link_order, then
  397.      ABFD will be NULL.  */
  398.   boolean (*unattached_reloc) PARAMS ((struct bfd_link_info *,
  399.                        const char *name,
  400.                        bfd *abfd, asection *section,
  401.                        bfd_vma address));
  402.   /* A function which is called when a symbol in notice_hash is
  403.      defined or referenced.  NAME is the symbol.  ABFD, SECTION and
  404.      ADDRESS are the value of the symbol.  If SECTION is
  405.      bfd_und_section, this is a reference.  */
  406.   boolean (*notice) PARAMS ((struct bfd_link_info *, const char *name,
  407.                  bfd *abfd, asection *section, bfd_vma address));
  408. };
  409.  
  410. /* The linker builds link_order structures which tell the code how to
  411.    include input data in the output file.  */
  412.  
  413. /* These are the types of link_order structures.  */
  414.  
  415. enum bfd_link_order_type
  416. {
  417.   bfd_undefined_link_order,    /* Undefined.  */
  418.   bfd_indirect_link_order,    /* Built from a section.  */
  419.   bfd_fill_link_order,        /* Fill with a 16 bit constant.  */
  420.   bfd_data_link_order,        /* Set to explicit data.  */
  421.   bfd_section_reloc_link_order,    /* Relocate against a section.  */
  422.   bfd_symbol_reloc_link_order    /* Relocate against a symbol.  */
  423. };
  424.  
  425. /* This is the link_order structure itself.  These form a chain
  426.    attached to the section whose contents they are describing.  */
  427.  
  428. struct bfd_link_order 
  429. {
  430.   /* Next link_order in chain.  */
  431.   struct bfd_link_order *next;
  432.   /* Type of link_order.  */
  433.   enum bfd_link_order_type type;
  434.   /* Offset within output section.  */
  435.   bfd_vma offset;  
  436.   /* Size within output section.  */
  437.   bfd_size_type size;
  438.   /* Type specific information.  */
  439.   union 
  440.     {
  441.       struct 
  442.     {
  443.       /* Section to include.  If this is used, then
  444.          section->output_section must be the section the
  445.          link_order is attached to, section->output_offset must
  446.          equal the link_order offset field, and section->_raw_size
  447.          must equal the link_order size field.  Maybe these
  448.          restrictions should be relaxed someday.  */
  449.       asection *section;
  450.     } indirect;
  451.       struct
  452.     {
  453.       /* Value to fill with.  */
  454.       unsigned int value;
  455.     } fill;
  456.       struct
  457.     {
  458.       /* Data to put into file.  The size field gives the number
  459.          of bytes which this field points to.  */
  460.       bfd_byte *contents;
  461.     } data;
  462.       struct
  463.     {
  464.       /* Description of reloc to generate.  Used for
  465.          bfd_section_reloc_link_order and
  466.          bfd_symbol_reloc_link_order.  */
  467.       struct bfd_link_order_reloc *p;
  468.     } reloc;
  469.     } u;
  470. };
  471.  
  472. /* A linker order of type bfd_section_reloc_link_order or
  473.    bfd_symbol_reloc_link_order means to create a reloc against a
  474.    section or symbol, respectively.  This is used to implement -Ur to
  475.    generate relocs for the constructor tables.  The
  476.    bfd_link_order_reloc structure describes the reloc that BFD should
  477.    create.  It is similar to a arelent, but I didn't use arelent
  478.    because the linker does not know anything about most symbols, and
  479.    any asymbol structure it creates will be partially meaningless.
  480.    This information could logically be in the bfd_link_order struct,
  481.    but I didn't want to waste the space since these types of relocs
  482.    are relatively rare.  */
  483.  
  484. struct bfd_link_order_reloc
  485. {
  486.   /* Reloc type.  */
  487.   bfd_reloc_code_real_type reloc;
  488.  
  489.   union
  490.     {
  491.       /* For type bfd_section_reloc_link_order, this is the section
  492.      the reloc should be against.  This must be a section in the
  493.      output BFD, not any of the input BFDs.  */
  494.       asection *section;
  495.       /* For type bfd_symbol_reloc_link_order, this is the name of the
  496.      symbol the reloc should be against.  */
  497.       const char *name;
  498.     } u;
  499.  
  500.   /* Addend to use.  The object file should contain zero.  The BFD
  501.      backend is responsible for filling in the contents of the object
  502.      file correctly.  For some object file formats (e.g., COFF) the
  503.      addend must be stored into in the object file, and for some
  504.      (e.g., SPARC a.out) it is kept in the reloc.  */
  505.   bfd_vma addend;
  506. };
  507.  
  508. /* Allocate a new link_order for a section.  */
  509. extern struct bfd_link_order *bfd_new_link_order PARAMS ((bfd *, asection *));
  510.  
  511. /* These structures are used to describe version information for the
  512.    ELF linker.  These structures could be manipulated entirely inside
  513.    BFD, but it would be a pain.  Instead, the regular linker sets up
  514.    these structures, and then passes them into BFD.  */
  515.  
  516. /* Regular expressions for a version.  */
  517.  
  518. struct bfd_elf_version_expr
  519. {
  520.   /* Next regular expression for this version.  */
  521.   struct bfd_elf_version_expr *next;
  522.   /* Regular expression.  */
  523.   const char *pattern;
  524.   /* Matching function.  */
  525.   int (*match) PARAMS((struct bfd_elf_version_expr *, const char *));
  526. };
  527.  
  528. /* Version dependencies.  */
  529.  
  530. struct bfd_elf_version_deps
  531. {
  532.   /* Next dependency for this version.  */
  533.   struct bfd_elf_version_deps *next;
  534.   /* The version which this version depends upon.  */
  535.   struct bfd_elf_version_tree *version_needed;
  536. };
  537.  
  538. /* A node in the version tree.  */
  539.  
  540. struct bfd_elf_version_tree
  541. {
  542.   /* Next version.  */
  543.   struct bfd_elf_version_tree *next;
  544.   /* Name of this version.  */
  545.   const char *name;
  546.   /* Version number.  */
  547.   unsigned int vernum;
  548.   /* Regular expressions for global symbols in this version.  */
  549.   struct bfd_elf_version_expr *globals;
  550.   /* Regular expressions for local symbols in this version.  */
  551.   struct bfd_elf_version_expr *locals;
  552.   /* List of versions which this version depends upon.  */
  553.   struct bfd_elf_version_deps *deps;
  554.   /* Index of the version name.  This is used within BFD.  */
  555.   unsigned int name_indx;
  556.   /* Whether this version tree was used.  This is used within BFD.  */
  557.   int used;
  558. };
  559.  
  560. #endif
  561.