Redid static ctor/dtor handling to be compatible with init_array/fini_array as well...
[dyninst.git] / symtabAPI / src / LinkMap.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #if !defined(_Link_Map_h_)
32 #define _Link_Map_h_
33
34 #include "Symtab.h"
35 #include "Region.h"
36 #include "Symbol.h"
37 #include "Function.h"
38
39 #include <deque>
40 #include <map>
41 #include <vector>
42 using namespace std;
43
44 namespace Dyninst{
45 namespace SymtabAPI{
46
47 template <typename T>
48 struct CtorComp
49 {
50   bool operator()(T lhs, T rhs)
51   {
52     static std::string first_ctor_name("RTstatic_ctors_dtors_begin.c.o");
53     static std::string last_ctor_name("RTstatic_ctors_dtors_end.c.o");
54     if(lhs->symtab()->name() == first_ctor_name) return true;
55     if(rhs->symtab()->name() == first_ctor_name) return false;
56     if(lhs->symtab()->name() == last_ctor_name) return false;
57     if(rhs->symtab()->name() == last_ctor_name) return true;
58     return true;
59   }
60   
61 };
62  
63  
64  
65
66 /*
67  * A data structure that holds all the information necessary to perform a
68  * static link once all the relocatable files have been copied into a new data
69  * block
70  */
71 class LinkMap {
72     public:
73         LinkMap();
74         ~LinkMap();
75
76         // A pair representing an allocation for a Region
77         // The first Offset is the amount of padding before the Region
78         // The second Offset is the offset of the location in the allocatedData
79         typedef pair<Offset, Offset> AllocPair;
80
81         // prints the LinkMap (really for debugging purposes)
82         // uses globalOffset as the location of allocatedData in the target
83         void print(Offset globalOffset);
84         void printAll(ostream &os, Offset globalOffset);
85         void printBySymtab(ostream &os, vector<Symtab *> &symtabs, Offset globalOffset);
86         void printRegions(ostream &os, deque<Region *> &regions, Offset globalOffset);
87         void printRegion(ostream &os, Region *region, Offset globalOffset);
88         void printRegionFromInfo(ostream &os, Region *region, Offset regionOffset, Offset padding);
89         
90         friend ostream & operator<<(ostream &os, LinkMap &lm);
91
92         // Data Members
93         // all other members describe this block of data
94         char *allocatedData; 
95         Offset allocatedSize;
96
97         // map of Regions placed in allocatedData
98         map<Region *, AllocPair> regionAllocs;
99
100         // Keep track of the dynamically allocated COMMON symbol Region
101         Region *commonStorage;
102
103         // new Region info
104         // Offset -> offset in allocatedData
105         // Size -> size of Region
106         // Regions -> existing Regions which make up this Region
107
108         // new bss Region info
109         Offset bssRegionOffset;
110         Offset bssSize;
111         Offset bssRegionAlign;
112         deque<Region *> bssRegions;
113
114         // new data Region info
115         Offset dataRegionOffset;
116         Offset dataSize;
117         Offset dataRegionAlign;
118         deque<Region *> dataRegions;
119         
120         // Stub code region
121         Offset stubRegionOffset;
122         Offset stubSize;
123         std::map<Symbol *, Offset> stubMap;
124
125         // new code Region info
126         Offset codeRegionOffset;
127         Offset codeSize;
128         Offset codeRegionAlign;
129         deque<Region *> codeRegions;
130         
131         // new TLS Region info
132         Offset tlsRegionOffset;
133         Offset tlsSize;
134         Offset tlsRegionAlign;
135         deque<Region *> tlsRegions;
136         vector<Symbol *> tlsSymbols;
137
138         // new GOT Region info
139         Offset gotRegionOffset;
140         Offset gotSize;
141         Offset gotRegionAlign;
142              vector<pair<Symbol *, Offset> >gotSymbolTable;
143         map <Symbol *, Offset> gotSymbols;
144         deque<Region *> gotRegions;
145
146         Symtab *ctorDtorHandler;
147
148         // new constructor Region info
149         Offset ctorRegionOffset;
150         Offset ctorSize;
151         Offset ctorRegionAlign;
152         Region *originalCtorRegion;
153         set<Region *, CtorComp<Region*> > newCtorRegions;
154
155         // new destructor Region info
156         Offset dtorRegionOffset;
157         Offset dtorSize;
158         Offset dtorRegionAlign;
159         Region *originalDtorRegion;
160         set<Region *, CtorComp<Region*> > newDtorRegions;
161
162         // Keep track of changes made to symbols and relocations
163         vector< pair<Symbol *, Offset> > origSymbols;
164         vector< pair<relocationEntry *, Symbol *> > origRels;
165
166         // GNU extension: indirect functions and IRELATIV relocations
167         // We basically create mini-PLT entries for load-time 
168         // decisions of which function to call
169         Offset pltRegionOffset;
170         Offset pltSize;
171         Offset pltRegionAlign;
172         // First Offset: offset of the PLT stub. 
173         // Second Offset: offset of the GOT entry referenced by the stub. 
174         std::map<Symbol *, std::pair<Offset, Offset> > pltEntries;
175         std::map<Symbol *, Offset> pltEntriesInGOT;
176
177         // GNU extension: create a new rel section
178         Offset relRegionOffset;
179         Offset relSize;
180         Offset relRegionAlign;
181         // With a GOT-equivalent
182         Offset relGotRegionOffset;
183         Offset relGotSize;
184         Offset relGotRegionAlign;
185 };
186
187 } // SymtabAPI
188 } // Dyninst
189
190 #endif