Lines Matching defs:dynamic
31 /* Define a symbol in a dynamic linkage section. */
132 /* Create a strtab to hold the dynamic symbol names. */
151 /* Create some sections which will be filled in with dynamic linking
152 information. ABFD is an input file which requires dynamic sections
153 to be created. The dynamic sections take up virtual memory space
220 s = bfd_make_section_with_flags (abfd, ".dynamic", flags);
226 .dynamic section. We could set _DYNAMIC in a linker script, but we
227 only want to define it if we are, in fact, creating a .dynamic
228 section. We don't want to define it if there is no .dynamic
270 /* Create dynamic sections when linking against a dynamic object. */
325 by dynamic objects, are referenced by regular objects, and are
327 image and use a R_*_COPY reloc to tell the dynamic linker to
363 /* Record a new dynamic symbol. We record the dynamic symbols as we
367 going to output any dynamic symbols; in some cases we know that a
368 symbol should be in the dynamic symbol table, but only if there is
384 DSO. However, if ld.so honors st_other in the dynamic table,
408 /* Create a strtab to hold the dynamic symbol names. */
414 /* We don't put any version information in the dynamic string
440 /* Mark a symbol dynamic. */
450 if(h->dynamic || info->relocatable)
460 h->dynamic = 1;
464 this in case some dynamic object refers to this symbol. */
518 currently defined by a dynamic object, but not by a regular
527 currently defined by a dynamic object, but not by a regular object,
529 associated with the dynamic object any more. */
563 real symbol from the same dynamic object, make sure the real
564 symbol is also made into a dynamic symbol. */
576 /* Record a new local dynamic symbol. Returns 0 on failure, 1 on
638 /* Create a strtab to hold the dynamic symbol names. */
666 /* Return the dynindex of a local dynamic symbol. */
681 /* This function is used to renumber the dynamic symbols, if some of
725 /* Return true if the dynamic symbol for a given section should be
772 allocated local dynamic syms, followed by the rest of the global
823 a dynamic object, or when there is already a definition in a
824 dynamic object. The new symbol is described by NAME, SYM, PSEC,
830 change. We set POLD_ALIGNMENT if an old common symbol in a dynamic
882 /* This code is for coping with dynamic objects, and is only useful
941 dynamic object, which we do want to handle here. */
948 respectively, is from a dynamic object. */
971 /* When we try to create a default indirect symbol from the dynamic
974 if the existing regular definition won't be dynamic. */
1043 /* We need to remember if a symbol has a definition in a dynamic
1044 object or is weak in all dynamic objects. Internal and hidden
1045 visibility will make it unavailable to dynamic objects. */
1052 /* Check if this symbol is weak in all dynamic objects. If it
1053 is the first time we see it in a dynamic object, we mark
1066 definition from a dynamic object. */
1072 /* Make sure this symbol is dynamic. */
1075 recorded as dynamic.
1088 relocatable file and the old definition comes from a dynamic
1092 /* Handle the case where the old dynamic definition is
1104 /* Protected symbols will override the dynamic definition
1116 /* We have to hide it here since it was made dynamic
1118 copied from the old dynamic definition. */
1134 definition came from a dynamic object, it is still on the
1163 old symbol comes from a dynamic library, we treat the new one as
1165 file is treated as strong when the new symbol comes from a dynamic
1166 library. Further, an old weak symbol from a dynamic library is
1167 treated as strong if the new symbol is from a dynamic library.
1171 we warn properly when dynamic library symbols are overridden. */
1201 symbol, respectively, appears to be a common symbol in a dynamic
1204 which was resolved when the dynamic object was created. We want
1259 dynamic object, set the size of the symbol to the larger of the
1270 symbols defined in dynamic objects. */
1283 /* If we are looking at a dynamic object, and we have found a
1313 function in a dynamic object, and we don't want to warn about
1342 /* If the old symbol is from a dynamic object, and the new symbol is
1343 a definition which is not from a dynamic object, then the new
1345 always take precedence over symbols from dynamic objects, even if
1346 they are defined after the dynamic object in the link.
1383 was seen in a dynamic object. We must force the union to be
1406 /* If the presumed common symbol in the dynamic object is
1413 in the dynamic object. */
1434 /* Handle the case where we had a versioned symbol in a dynamic
1456 set DYNSYM if the new indirect symbol is dynamic. */
1477 bfd_boolean dynamic;
1510 dynamic = (abfd->flags & DYNAMIC) != 0;
1553 the symbol defined in the dynamic object.
1602 be dynamic. */
1605 if (! dynamic)
1671 must be dynamic. */
1674 if (! dynamic)
1693 /* This routine is used to export all defined symbols into the dynamic
1702 if (!eif->info->export_dynamic && !h->dynamic)
2347 /* Make weak undefined symbols in PIE dynamic. */
2376 an ELF dynamic object. */
2419 a dynamic object, and then later in a non-ELF regular object. */
2442 any dynamic object, then the linker will have allocated space for
2473 hide it from the dynamic linker. */
2482 /* If this is a weak defined symbol in a dynamic object, and we know
2483 the real definition in the dynamic object, copy interesting flags
2512 /* Make the backend pick a good value for a dynamic symbol. This is
2546 defined by a dynamic object, or is not referenced by a regular
2549 to the dynamic symbol table. FIXME: Do we normally need to worry
2550 about symbols which are defined by one dynamic object and
2580 from the dynamic object, but we do get the weak symbol. If the
2582 dynamic object changes the real symbol, we will not see that
2622 (_("warning: type and size of dynamic symbol `%s' are not defined"),
2636 /* Adjust the dynamic symbol, H, for copy in the dynamic bss section,
2730 /* If it was forced local, then clearly it's not dynamic. */
2764 /* If it isn't defined locally, then clearly it's dynamic. */
2768 /* Otherwise, the symbol is dynamic if binding rules don't tell
2795 resolve locally. The sym is either undefined or dynamic. */
2803 /* As do non-dynamic symbols. */
2807 /* At this point, we know the symbol is defined and dynamic. In an
2813 /* Now deal with defined dynamic symbols in shared libraries. Ones
2833 symbols be treated as dynamic symbols, even when we know that the
2834 dynamic linker will resolve them locally. */
2990 /* Add an entry to the .dynamic table. */
3009 s = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3027 /* Add a DT_NEEDED entry for this dynamic object if DO_IT is true,
3057 sdyn = bfd_get_section_by_name (hash_table->dynobj, ".dynamic");
3113 dynamic symbols. This is called via elf_link_hash_traverse. */
3147 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3150 /* Update all .dynamic entries referencing .dynstr strings. */
3177 /* Now update local dynamic symbols. */
3182 /* And the rest of dynamic symbols. */
3299 bfd_boolean dynamic;
3329 dynamic = FALSE;
3332 dynamic = TRUE;
3334 /* You can't use -r against a dynamic object. Also, there's no
3335 hope of using a dynamic object which does not exactly match
3378 if (dynamic)
3427 if (! dynamic)
3429 /* If we are creating a shared library, create all the dynamic
3452 /* ld --just-symbols and dynamic objects don't mix very well.
3458 /* If this dynamic lib was specified on the command line with
3462 on a dynamic lib, we don't want to add a DT_NEEDED entry for
3463 any dynamic library in DT_NEEDED tags in the dynamic lib at
3469 s = bfd_get_section_by_name (abfd, ".dynamic");
3595 /* We do not want to include any of the sections in a dynamic
3624 /* If we have already included this dynamic object in the
3626 particular dynamic object more than once. */
3631 /* If this is a dynamic object, we always link against the .dynsym
3632 symbol table, not the .symtab symbol table. The dynamic linker
3634 look at .symtab for a dynamic object. */
3636 if (! dynamic || elf_dynsymtab (abfd) == 0)
3674 if (dynamic)
3740 pointers into the symbol table, and dynamic symbol count. */
4078 if (dynamic
4086 a dynamic object, using the weakdef field. Later in this
4088 value. We only put non-function symbols from dynamic
4094 dynamic object, and we will be using that previous
4227 attribute with the one from a dynamic object. */
4230 dynamic);
4234 if (definition && !dynamic
4241 if (ELF_ST_VISIBILITY (isym->st_other) != 0 && !dynamic)
4264 the number of dynamic symbols we find. A dynamic symbol
4268 if (! dynamic)
4299 /* We don't want to make debug symbol dynamic. */
4312 if (definition && !dynamic)
4342 /* If the symbol already has a dynamic index, but
4515 dynamic objects, that's the only time we actually put anything on
4517 object refers to a symbol defined weakly in a dynamic object, the
4518 real symbol in the dynamic object is also put in the dynamic
4624 /* If the weak definition is in the list of dynamic
4633 /* If the real definition is in the list of dynamic
4636 dynamic loader might not merge the entries for the
4659 arrange for dynamic relocs. It is not required for the
4671 if (! dynamic
4707 if (! dynamic
5346 /* Set up the sizes and contents of the ELF dynamic sections. This is
5420 we're dynamic or not. */
5430 /* If there were no dynamic objects in the link, there is nothing to
5513 /* If we are supposed to export all symbols into the dynamic symbol
5516 || (info->executable && info->dynamic))
5608 /* Find all symbols which were defined in a dynamic object and make
5616 /* Add some entries to the .dynamic section. We fill in some of the
5618 now so that we know the final size of the .dynamic section. */
5715 /* The backend must work out the sizes of all the other dynamic
6162 Next come all of the back-end allocated local dynamic syms,
6184 the number of dynamic symbols in elf_link_add_object_symbols.
6398 /* Renumber dynamic symbols, populate .gnu.hash section. */
7345 /* Find a dynamic reloc section. */
7687 /* Return TRUE if the dynamic symbol SYM in ABFD is supported. */
7694 /* The gABI doesn't support dynamic symbols in output sections
7970 /* If we're stripping it, and it's not a dynamic symbol, there's
8192 /* If we're stripping it, then it was just a dynamic symbol, and
8328 /* If this is a dynamic object, we don't want to do anything here:
9306 bfd_boolean dynamic;
9340 dynamic = elf_hash_table (info)->dynamic_sections_created;
9352 if (! dynamic)
9890 if (dynamic
10065 if (dynamic && info->combreloc && dynobj != NULL)
10068 /* If we are linking against a dynamic object, or generating a
10069 shared library, finish up the dynamic linking information. */
10070 if (dynamic)
10074 /* Fix up .dynamic entries. */
10075 o = bfd_get_section_by_name (dynobj, ".dynamic");
10234 /* If we have created any dynamic sections, then output them. */
10245 /* Fix up .dynamic entries. */
10246 o = bfd_get_section_by_name (dynobj, ".dynamic");
10659 /* Remove the symbols that were in the swept sections from the dynamic