| 1 | /* BFD library support routines for constructors |
| 2 | Copyright (C) 1990-1991 Free Software Foundation, Inc. |
| 3 | |
| 4 | Hacked by Steve Chamberlain of Cygnus Support. With some help from |
| 5 | Judy Chamberlain too. |
| 6 | |
| 7 | |
| 8 | This file is part of BFD, the Binary File Descriptor library. |
| 9 | |
| 10 | This program is free software; you can redistribute it and/or modify |
| 11 | it under the terms of the GNU General Public License as published by |
| 12 | the Free Software Foundation; either version 2 of the License, or |
| 13 | (at your option) any later version. |
| 14 | |
| 15 | This program is distributed in the hope that it will be useful, |
| 16 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 17 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 18 | GNU General Public License for more details. |
| 19 | |
| 20 | You should have received a copy of the GNU General Public License |
| 21 | along with this program; if not, write to the Free Software |
| 22 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| 23 | |
| 24 | /* |
| 25 | SECTION |
| 26 | Constructors |
| 27 | |
| 28 | Classes in C++ have 'constructors' and 'destructors'. These |
| 29 | are functions which are called automatically by the language |
| 30 | whenever data of a class is created or destroyed. Class data |
| 31 | which is static data may also be have a type which requires |
| 32 | 'construction', the contructor must be called before the data |
| 33 | can be referenced, so the contructor must be called before the |
| 34 | program begins. |
| 35 | |
| 36 | The common solution to this problem is for the compiler to |
| 37 | call a magic function as the first statement <<main>>. |
| 38 | This magic function, (often called <<__main>>) runs around |
| 39 | calling the constructors for all the things needing it. |
| 40 | |
| 41 | With COFF the compile has a bargain with the linker et al. |
| 42 | All constructors are given strange names, for example |
| 43 | <<__GLOBAL__$I$foo>> might be the label of a contructor for |
| 44 | the class @var{foo}. The solution on unfortunate systems |
| 45 | (most system V machines) is to perform a partial link on all |
| 46 | the .o files, do an <<nm>> on the result, run <<awk>> or some |
| 47 | such over the result looking for strange <<__GLOBAL__$>> |
| 48 | symbols, generate a C program from this, compile it and link |
| 49 | with the partially linked input. This process is usually |
| 50 | called <<collect>>. |
| 51 | |
| 52 | Some versions of <<a.out>> use something called the |
| 53 | <<set_vector>> mechanism. The constructor symbols are output |
| 54 | from the compiler with a special stab code saying that they |
| 55 | are constructors, and the linker can deal with them directly. |
| 56 | |
| 57 | BFD allows applications (ie the linker) to deal with |
| 58 | constructor information independently of their external |
| 59 | implimentation by providing a set of entry points for the |
| 60 | indiviual object back ends to call which maintains a database |
| 61 | of the contructor information. The application can |
| 62 | interrogate the database to find out what it wants. The |
| 63 | construction data essential for the linker to be able to |
| 64 | perform its job are: |
| 65 | |
| 66 | o asymbol - |
| 67 | The asymbol of the contructor entry point contains all the |
| 68 | information necessary to call the function. |
| 69 | |
| 70 | o table id - |
| 71 | The type of symbol, ie is it a contructor, a destructor or |
| 72 | something else someone dreamed up to make our lives difficult. |
| 73 | |
| 74 | This module takes this information and then builds extra |
| 75 | sections attached to the bfds which own the entry points. It |
| 76 | creates these sections as if they were tables of pointers to |
| 77 | the entry points, and builds relocation entries to go with |
| 78 | them so that the tables can be relocated along with the data |
| 79 | they reference. |
| 80 | |
| 81 | These sections are marked with a special bit |
| 82 | (<<SEC_CONSTRUCTOR>>) which the linker notices and do with |
| 83 | what it wants. |
| 84 | |
| 85 | */ |
| 86 | |
| 87 | #include <bfd.h> |
| 88 | #include <sysdep.h> |
| 89 | #include <libbfd.h> |
| 90 | |
| 91 | |
| 92 | |
| 93 | /* |
| 94 | INTERNAL_FUNCTION |
| 95 | bfd_constructor_entry |
| 96 | |
| 97 | SYNOPSIS |
| 98 | void bfd_constructor_entry(bfd *abfd, |
| 99 | asymbol **symbol_ptr_ptr, |
| 100 | CONST char*type); |
| 101 | |
| 102 | |
| 103 | DESCRIPTION |
| 104 | This function is called with an a symbol describing the |
| 105 | function to be called, an string which descibes the xtor type, |
| 106 | eg something like "CTOR" or "DTOR" would be fine. And the bfd |
| 107 | which owns the function. Its duty is to create a section |
| 108 | called "CTOR" or "DTOR" or whatever if the bfd doesn't already |
| 109 | have one, and grow a relocation table for the entry points as |
| 110 | they accumulate. |
| 111 | |
| 112 | */ |
| 113 | |
| 114 | |
| 115 | void DEFUN(bfd_constructor_entry,(abfd, symbol_ptr_ptr, type), |
| 116 | bfd *abfd AND |
| 117 | asymbol **symbol_ptr_ptr AND |
| 118 | CONST char *type) |
| 119 | |
| 120 | { |
| 121 | /* Look up the section we're using to store the table in */ |
| 122 | asection *rel_section = bfd_get_section_by_name (abfd, type); |
| 123 | if (rel_section == (asection *)NULL) { |
| 124 | rel_section = bfd_make_section (abfd, type); |
| 125 | rel_section->flags = SEC_CONSTRUCTOR; |
| 126 | rel_section->alignment_power = 2; |
| 127 | } |
| 128 | |
| 129 | /* Create a relocation into the section which references the entry |
| 130 | point */ |
| 131 | { |
| 132 | arelent_chain *reloc = (arelent_chain *)bfd_alloc(abfd, |
| 133 | sizeof(arelent_chain)); |
| 134 | |
| 135 | /* reloc->relent.section = (asection *)NULL;*/ |
| 136 | reloc->relent.addend = 0; |
| 137 | |
| 138 | reloc->relent.sym_ptr_ptr = symbol_ptr_ptr; |
| 139 | reloc->next = rel_section->constructor_chain; |
| 140 | rel_section->constructor_chain = reloc; |
| 141 | reloc->relent.address = rel_section->_cooked_size; |
| 142 | /* ask the cpu which howto to use */ |
| 143 | reloc->relent.howto = bfd_reloc_type_lookup(abfd, BFD_RELOC_CTOR); |
| 144 | rel_section->_cooked_size += sizeof(int *); |
| 145 | rel_section->reloc_count++; |
| 146 | } |
| 147 | |
| 148 | } |