1 /* BFD library support routines for constructors
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
4 Hacked by Steve Chamberlain of Cygnus Support. With some help from
8 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
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
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.
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
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.
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
67 The asymbol of the contructor entry point contains all the
68 information necessary to call the function.
71 The type of symbol, i.e., is it a constructor, a destructor or
72 something else someone dreamed up to make our lives difficult.
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
81 These sections are marked with a special bit
82 (<<SEC_CONSTRUCTOR>>) which the linker notices and do with
98 void bfd_constructor_entry(bfd *abfd,
99 asymbol **symbol_ptr_ptr,
104 This function is called with an a symbol describing the
105 function to be called, an string which descibes the xtor type,
106 e.g., 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
115 void DEFUN(bfd_constructor_entry
,(abfd
, symbol_ptr_ptr
, type
),
117 asymbol
**symbol_ptr_ptr AND
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;
129 /* Create a relocation into the section which references the entry
132 arelent_chain
*reloc
= (arelent_chain
*)bfd_alloc(abfd
,
133 sizeof(arelent_chain
));
135 /* reloc->relent.section = (asection *)NULL;*/
136 reloc
->relent
.addend
= 0;
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
++;
This page took 0.031836 seconds and 4 git commands to generate.