Back to index

cell-binutils  2.17cvs20070401
Classes | Functions | Variables
ldctor.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  set_info
struct  set_element

Functions

void ldctor_add_set_entry (struct bfd_link_hash_entry *, bfd_reloc_code_real_type, const char *, asection *, bfd_vma)
void ldctor_build_sets (void)

Variables

lang_statement_list_type constructor_list
bfd_boolean constructors_sorted
struct set_infosets

Class Documentation

struct set_info

Definition at line 35 of file ldctor.h.

Collaboration diagram for set_info:
Class Members
size_t count
struct set_element * elements
struct bfd_link_hash_entry * h
struct set_info * next
bfd_reloc_code_real_type reloc
struct set_element

Definition at line 43 of file ldctor.h.

Collaboration diagram for set_element:
Class Members
const char * name
struct set_element * next
asection * section
bfd_vma value

Function Documentation

Definition at line 56 of file ldctor.c.

{
  struct set_info *p;
  struct set_element *e;
  struct set_element **epp;

  for (p = sets; p != NULL; p = p->next)
    if (p->h == h)
      break;

  if (p == NULL)
    {
      p = xmalloc (sizeof (struct set_info));
      p->next = sets;
      sets = p;
      p->h = h;
      p->reloc = reloc;
      p->count = 0;
      p->elements = NULL;
    }
  else
    {
      if (p->reloc != reloc)
       {
         einfo (_("%P%X: Different relocs used in set %s\n"),
               h->root.string);
         return;
       }

      /* Don't permit a set to be constructed from different object
         file formats.  The same reloc may have different results.  We
         actually could sometimes handle this, but the case is
         unlikely to ever arise.  Sometimes constructor symbols are in
         unusual sections, such as the absolute section--this appears
         to be the case in Linux a.out--and in such cases we just
         assume everything is OK.  */
      if (p->elements != NULL
         && section->owner != NULL
         && p->elements->section->owner != NULL
         && strcmp (bfd_get_target (section->owner),
                   bfd_get_target (p->elements->section->owner)) != 0)
       {
         einfo (_("%P%X: Different object file formats composing set %s\n"),
               h->root.string);
         return;
       }
    }

  e = xmalloc (sizeof (struct set_element));
  e->next = NULL;
  e->name = name;
  e->section = section;
  e->value = value;

  for (epp = &p->elements; *epp != NULL; epp = &(*epp)->next)
    ;
  *epp = e;

  ++p->count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ldctor_build_sets ( void  )

Definition at line 198 of file ldctor.c.

{
  static bfd_boolean called;
  lang_statement_list_type *old;
  bfd_boolean header_printed;
  struct set_info *p;

  /* The emulation code may call us directly, but we only want to do
     this once.  */
  if (called)
    return;
  called = TRUE;

  if (constructors_sorted)
    {
      for (p = sets; p != NULL; p = p->next)
       {
         int c, i;
         struct set_element *e;
         struct set_element **array;

         if (p->elements == NULL)
           continue;

         c = 0;
         for (e = p->elements; e != NULL; e = e->next)
           ++c;

         array = xmalloc (c * sizeof *array);

         i = 0;
         for (e = p->elements; e != NULL; e = e->next)
           {
             array[i] = e;
             ++i;
           }

         qsort (array, c, sizeof *array, ctor_cmp);

         e = array[0];
         p->elements = e;
         for (i = 0; i < c - 1; i++)
           array[i]->next = array[i + 1];
         array[i]->next = NULL;

         free (array);
       }
    }

  old = stat_ptr;
  stat_ptr = &constructor_list;

  lang_list_init (stat_ptr);

  header_printed = FALSE;
  for (p = sets; p != NULL; p = p->next)
    {
      struct set_element *e;
      reloc_howto_type *howto;
      int reloc_size, size;

      /* If the symbol is defined, we may have been invoked from
        collect, and the sets may already have been built, so we do
        not do anything.  */
      if (p->h->type == bfd_link_hash_defined
         || p->h->type == bfd_link_hash_defweak)
       continue;

      /* For each set we build:
          set:
            .long number_of_elements
            .long element0
            ...
            .long elementN
            .long 0
        except that we use the right size instead of .long.  When
        generating relocatable output, we generate relocs instead of
        addresses.  */
      howto = bfd_reloc_type_lookup (output_bfd, p->reloc);
      if (howto == NULL)
       {
         if (link_info.relocatable)
           {
             einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
                   bfd_get_target (output_bfd),
                   bfd_get_reloc_code_name (p->reloc),
                   p->h->root.string);
             continue;
           }

         /* If this is not a relocatable link, all we need is the
            size, which we can get from the input BFD.  */
         if (p->elements->section->owner != NULL)
           howto = bfd_reloc_type_lookup (p->elements->section->owner,
                                      p->reloc);
         if (howto == NULL)
           {
             einfo (_("%P%X: %s does not support reloc %s for set %s\n"),
                   bfd_get_target (p->elements->section->owner),
                   bfd_get_reloc_code_name (p->reloc),
                   p->h->root.string);
             continue;
           }
       }

      reloc_size = bfd_get_reloc_size (howto);
      switch (reloc_size)
       {
       case 1: size = BYTE; break;
       case 2: size = SHORT; break;
       case 4: size = LONG; break;
       case 8:
         if (howto->complain_on_overflow == complain_overflow_signed)
           size = SQUAD;
         else
           size = QUAD;
         break;
       default:
         einfo (_("%P%X: Unsupported size %d for set %s\n"),
               bfd_get_reloc_size (howto), p->h->root.string);
         size = LONG;
         break;
       }

      lang_add_assignment (exp_assop ('=', ".",
                                  exp_unop (ALIGN_K,
                                          exp_intop (reloc_size))));
      lang_add_assignment (exp_assop ('=', p->h->root.string,
                                  exp_nameop (NAME, ".")));
      lang_add_data (size, exp_intop (p->count));

      for (e = p->elements; e != NULL; e = e->next)
       {
         if (config.map_file != NULL)
           {
             int len;

             if (! header_printed)
              {
                minfo (_("\nSet                 Symbol\n\n"));
                header_printed = TRUE;
              }

             minfo ("%s", p->h->root.string);
             len = strlen (p->h->root.string);

             if (len >= 19)
              {
                print_nl ();
                len = 0;
              }
             while (len < 20)
              {
                print_space ();
                ++len;
              }

             if (e->name != NULL)
              minfo ("%T\n", e->name);
             else
              minfo ("%G\n", e->section->owner, e->section, e->value);
           }

         /* Need SEC_KEEP for --gc-sections.  */
         if (! bfd_is_abs_section (e->section))
           e->section->flags |= SEC_KEEP;

         if (link_info.relocatable)
           lang_add_reloc (p->reloc, howto, e->section, e->name,
                         exp_intop (e->value));
         else
           lang_add_data (size, exp_relop (e->section, e->value));
       }

      lang_add_data (size, exp_intop (0));
    }

  stat_ptr = old;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 38 of file ldctor.c.

Definition at line 43 of file ldctor.c.

Definition at line 46 of file ldctor.c.