Move debuglink location processing from SymtabAPI to Elf_X, so that it's accessible...
[dyninst.git] / common / h / Elf_X.h
1 /*
2  * Copyright (c) 1996-2011 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #ifndef __ELF_X_H__
33 #define __ELF_X_H__
34
35 #include <elf.h>
36 #include <libelf.h>
37 #include <string>
38 #include "common/h/headers.h"
39
40 // Forward declarations
41 class Elf_X;
42 class Elf_X_Phdr;
43 class Elf_X_Shdr;
44 class Elf_X_Data;
45 class Elf_X_Versym;
46 class Elf_X_Verdaux;
47 class Elf_X_Verdef;
48 class Elf_X_Vernaux;
49 class Elf_X_Verneed;
50 class Elf_X_Options;
51 class Elf_X_Sym;
52 class Elf_X_Rel;
53 class Elf_X_Rela;
54 class Elf_X_RegInfo;
55 class Elf_32_RegInfo;
56 class Elf_64_RegInfo;
57 class Elf_X_Dyn;
58
59
60 // Wrappers to allow word-independant use of libelf routines.
61
62 // ------------------------------------------------------------------------
63 // Class Elf_X simulates the Elf(32|64)_Ehdr structure.
64 // Also works for ELF archives. 
65 class Elf_X {
66   public:
67     Elf_X();
68     Elf_X(int input, Elf_Cmd cmd, Elf_X *ref = NULL);
69     Elf_X(char *mem_image, size_t mem_size);
70
71     void end();
72
73     // Read Interface
74     Elf *e_elfp() const;
75     unsigned char *e_ident() const;
76     unsigned short e_type() const;
77     unsigned short e_machine() const;
78     unsigned long e_version() const;
79     unsigned long e_entry() const;
80     unsigned long e_phoff() const;
81     unsigned long e_shoff() const;
82     unsigned long e_flags() const;
83     unsigned short e_ehsize() const;
84     unsigned short e_phentsize() const;
85     unsigned short e_phnum() const;
86     unsigned short e_shentsize() const;
87     unsigned short e_shnum() const;
88     unsigned short e_shstrndx() const;
89     const char *e_rawfile(size_t &nbytes) const;
90
91     Elf_X *e_next(Elf_X *ref);
92     Elf_X *e_rand(unsigned offset);
93
94     // Write Interface
95     void e_ident(unsigned char *input);
96     void e_type(unsigned short input);
97     void e_machine(unsigned short input);
98     void e_version(unsigned long input);
99     void e_entry(unsigned long input);
100     void e_phoff(unsigned long input);
101     void e_shoff(unsigned long input);
102     void e_flags(unsigned long input);
103     void e_ehsize(unsigned short input);
104     void e_phentsize(unsigned short input);
105     void e_phnum(unsigned short input);
106     void e_shentsize(unsigned short input);
107     void e_shnum(unsigned short input);
108     void e_shstrndx(unsigned short input);
109
110     // Data Interface
111     bool isValid() const;
112     int wordSize() const;
113     Elf_X_Phdr get_phdr(unsigned int i = 0) const;
114     Elf_X_Shdr get_shdr(unsigned int i) const;
115
116     bool findDebugFile(std::string origfilename, std::string &output_name, char* &output_buffer, unsigned long &output_buffer_size);
117
118   protected:
119     Elf *elf;
120     Elf32_Ehdr *ehdr32;
121     Elf64_Ehdr *ehdr64;
122     Elf32_Phdr *phdr32;
123     Elf64_Phdr *phdr64;
124     int filedes;
125     bool is64;
126     bool isArchive;
127 };
128
129 // ------------------------------------------------------------------------
130 // Class Elf_X_Phdr simulates the Elf(32|64)_Phdr structure.
131 class Elf_X_Phdr {
132   public:
133     Elf_X_Phdr();
134     Elf_X_Phdr(bool is64_, void *input);
135
136     // Read Interface
137     unsigned long p_type() const;
138     unsigned long p_offset() const;
139     unsigned long p_vaddr() const;
140     unsigned long p_paddr() const;
141     unsigned long p_filesz() const;
142     unsigned long p_memsz() const;
143     unsigned long p_flags() const;
144     unsigned long p_align() const;
145
146     // Write Interface
147     void p_type(unsigned long input);
148     void p_offset(unsigned long input);
149     void p_vaddr(unsigned long input);
150     void p_paddr(unsigned long input);
151     void p_filesz(unsigned long input);
152     void p_memsz(unsigned long input);
153     void p_flags(unsigned long input);
154     void p_align(unsigned long input);
155
156     bool isValid() const;
157
158   private:
159     Elf32_Phdr *phdr32;
160     Elf64_Phdr *phdr64;
161     bool is64;
162 };
163
164 // ------------------------------------------------------------------------
165 // Class Elf_X_Shdr simulates the Elf(32|64)_Shdr structure.
166 class Elf_X_Shdr {
167     friend class Elf_X;
168
169   public:
170     Elf_X_Shdr();
171     Elf_X_Shdr(bool is64_, Elf_Scn *input);
172
173     // Read Interface
174     unsigned long sh_name() const;
175     unsigned long sh_type() const;
176     unsigned long sh_flags() const;
177     unsigned long sh_addr() const;
178     unsigned long sh_offset() const;
179     unsigned long sh_size() const;
180     unsigned long sh_link() const;
181     unsigned long sh_info() const;
182     unsigned long sh_addralign() const;
183     unsigned long sh_entsize() const;
184     bool isFromDebugFile() const;
185
186     // Write Interface
187     void sh_name(unsigned long input);
188     void sh_type(unsigned long input);
189     void sh_flags(unsigned long input);
190     void sh_addr(unsigned long input);
191     void sh_offset(unsigned long input);
192     void sh_size(unsigned long input);
193     void sh_link(unsigned long input);
194     void sh_info(unsigned long input);
195     void sh_addralign(unsigned long input);
196     void sh_entsize(unsigned long input);
197     void setDebugFile(bool b);
198
199     // Section Data Interface
200     Elf_X_Data get_data() const;
201
202     // For Sections with Multiple Data Sections
203     void first_data();
204     bool next_data();
205
206     bool isValid() const;
207     unsigned wordSize() const;
208     Elf_Scn *getScn() const;
209
210   protected:
211     Elf_Scn *scn;
212     Elf_Data *data;
213     Elf32_Shdr *shdr32;
214     Elf64_Shdr *shdr64;
215     bool is64;
216     bool fromDebugFile;
217     const Elf_X *_elf;
218 };
219
220 // ------------------------------------------------------------------------
221 // Class Elf_X_Data simulates the Elf_Data structure.
222 class Elf_X_Data {
223   public:
224     Elf_X_Data();
225     Elf_X_Data(bool is64_, Elf_Data *input);
226
227     // Read Interface
228     void *d_buf() const;
229     Elf_Type d_type() const;
230     unsigned int d_version() const;
231     size_t d_size() const;
232     off_t d_off() const;
233     size_t d_align() const;
234
235     // Write Interface
236     void d_buf(void *input);
237     void d_type(Elf_Type input);
238     void d_version(unsigned int input);
239     void d_size(unsigned int input);
240     void d_off(signed int input);
241     void d_align(unsigned int input);
242
243     // Data Interface
244     const char *get_string() const;
245     Elf_X_Dyn get_dyn();
246     Elf_X_Versym get_versyms();
247     Elf_X_Verneed *get_verNeedSym();
248     Elf_X_Verdef *get_verDefSym();
249
250     Elf_X_Rel get_rel();
251     Elf_X_Rela get_rela();
252     Elf_X_Sym get_sym();
253
254     bool isValid() const;
255
256   protected:
257     Elf_Data *data;
258     bool is64;
259 };
260
261 // ------------------------------------------------------------------------
262 // Class Elf_X_Versym simulates the SHT_GNU_versym structure.
263 class Elf_X_Versym {
264   public:
265     Elf_X_Versym();
266     Elf_X_Versym(bool is64_, Elf_Data *input);
267
268     // Read Interface
269     unsigned long get(int i) const;
270
271     // Meta-Info Interface
272     unsigned long count() const;
273     bool isValid() const;
274
275   protected:
276     Elf_Data *data;
277     Elf32_Half *versym32;
278     Elf64_Half *versym64;
279     bool is64;
280 };
281
282 // ------------------------------------------------------------------------
283 // Class Elf_X_Verdaux simulates the Elf(32|64)_Verdaux structure.
284 class Elf_X_Verdaux {
285   public:
286     Elf_X_Verdaux();
287     Elf_X_Verdaux(bool is64_, void *input);
288
289     // Read Interface
290     unsigned long vda_name() const;
291     unsigned long vda_next() const;
292     Elf_X_Verdaux *get_next() const;
293
294     // Meta-Info Interface
295     bool isValid() const;
296
297   protected:
298     void *data;
299     Elf32_Verdaux *verdaux32;
300     Elf64_Verdaux *verdaux64;
301     bool is64;
302 };
303
304 // ------------------------------------------------------------------------
305 // Class Elf_X_Verdef simulates the Elf(32|64)_Verdef structure.
306 class Elf_X_Verdef {
307   public:
308     Elf_X_Verdef();
309     Elf_X_Verdef(bool is64_, void *input);
310
311     // Read Interface
312     unsigned long vd_version() const;
313     unsigned long vd_flags() const;
314     unsigned long vd_ndx() const;
315     unsigned long vd_cnt() const;
316     unsigned long vd_hash() const;
317     unsigned long vd_aux() const;
318     unsigned long vd_next() const;
319     Elf_X_Verdaux *get_aux() const;
320     Elf_X_Verdef *get_next() const;
321
322     // Meta-Info Interface
323     bool isValid() const;
324    
325   protected:
326     void *data;
327     Elf32_Verdef *verdef32;
328     Elf64_Verdef *verdef64;
329     bool is64;
330 };
331
332 // ------------------------------------------------------------------------
333 // Class Elf_X_Vernaux simulates the Elf(32|64)_Vernaux structure.
334 class Elf_X_Vernaux {
335   public:
336     Elf_X_Vernaux();
337     Elf_X_Vernaux(bool is64_, void *input);
338
339     // Read Interface
340     unsigned long vna_hash() const;
341     unsigned long vna_flags() const;
342     unsigned long vna_other() const;
343     unsigned long vna_name() const;
344     unsigned long vna_next() const;
345     Elf_X_Vernaux *get_next() const;
346
347     // Meta-Info Interface
348     bool isValid() const;
349
350   protected:
351     void *data;
352     Elf32_Vernaux *vernaux32;
353     Elf64_Vernaux *vernaux64;
354     bool is64;
355 };
356
357 // ------------------------------------------------------------------------
358 // Class Elf_X_Verneed simulates the Elf(32|64)_Verneed structure.
359 class Elf_X_Verneed {
360   public:
361     Elf_X_Verneed();
362     Elf_X_Verneed(bool is64_, void *input);
363
364     // Read Interface
365     unsigned long vn_version() const;
366     unsigned long vn_cnt() const;
367     unsigned long vn_file() const;
368     unsigned long vn_aux() const;
369     unsigned long vn_next() const;
370     Elf_X_Vernaux *get_aux() const;
371     Elf_X_Verneed *get_next() const;
372
373     // Meta-Info Interface
374     bool isValid() const;
375
376   protected:
377     void *data;
378     Elf32_Verneed *verneed32;
379     Elf64_Verneed *verneed64;
380     bool is64;
381 };
382
383
384 // ------------------------------------------------------------------------
385 // Class Elf_X_Sym simulates the Elf(32|64)_Sym structure.
386 class Elf_X_Sym {
387   public:
388     Elf_X_Sym();
389     Elf_X_Sym(bool is64_, Elf_Data *input);
390
391     // Read Interface
392     unsigned long st_name(int i) const;
393     unsigned long st_value(int i) const;
394     unsigned long st_size(int i) const;
395     unsigned char st_info(int i) const;
396     unsigned char st_other(int i) const;
397     unsigned short st_shndx(int i) const;
398     unsigned char ST_BIND(int i) const;
399     unsigned char ST_TYPE(int i) const;
400     unsigned char ST_VISIBILITY(int i) const;
401     void *st_symptr(int i) const;
402     unsigned st_entsize() const;
403
404     // Write Interface
405     void st_name(int i, unsigned long input);
406     void st_value(int i, unsigned long input);
407     void st_size(int i, unsigned long input);
408     void st_info(int i, unsigned char input);
409     void st_other(int i, unsigned char input);
410     void st_shndx(int i, unsigned short input);
411
412     // Meta-Info Interface
413     unsigned long count() const;
414     bool isValid() const;
415
416   protected:
417     Elf_Data *data;
418     Elf32_Sym *sym32;
419     Elf64_Sym *sym64;
420     bool is64;
421 };
422
423 // ------------------------------------------------------------------------
424 // Class Elf_X_Rel simulates the Elf(32|64)_Rel structure.
425 class Elf_X_Rel {
426   public:
427    Elf_X_Rel();
428    Elf_X_Rel(bool is64_, Elf_Data *input);
429
430     // Read Interface
431     unsigned long r_offset(int i) const;
432     unsigned long r_info(int i) const;
433     unsigned long R_SYM(int i) const;
434     unsigned long R_TYPE(int i) const;
435
436     // Write Interface
437     void r_offset(int i, unsigned long input);
438     void r_info(int i, unsigned long input);
439
440     // Meta-Info Interface
441     unsigned long count() const;
442     bool isValid() const;
443
444   protected:
445     Elf_Data *data;
446     Elf32_Rel *rel32;
447     Elf64_Rel *rel64;
448     bool is64;
449 };
450
451 // ------------------------------------------------------------------------
452 // Class Elf_X_Rela simulates the Elf(32|64)_Rela structure.
453 class Elf_X_Rela {
454   public:
455     Elf_X_Rela();
456     Elf_X_Rela(bool is64_, Elf_Data *input);
457
458     // Read Interface
459     unsigned long r_offset(int i) const;
460     unsigned long r_info(int i) const;
461     signed   long r_addend(int i) const;
462     unsigned long R_SYM(int i) const;
463     unsigned long R_TYPE(int i) const;
464
465     // Write Interface
466     void r_offset(int i, unsigned long input);
467     void r_info(int i, unsigned long input);
468     void r_addend(int i, signed long input);
469
470     // Meta-Info Interface
471     unsigned long count() const;
472     bool isValid() const;
473
474   protected:
475     Elf_Data *data;
476     Elf32_Rela *rela32;
477     Elf64_Rela *rela64;
478     bool is64;
479 };
480
481 // ------------------------------------------------------------------------
482 // Class Elf_X_Dyn simulates the Elf(32|64)_Dyn structure.
483 class Elf_X_Dyn {
484   public:
485     Elf_X_Dyn();
486     Elf_X_Dyn(bool is64_, Elf_Data *input);
487
488     // Read Interface
489     signed long d_tag(int i) const;
490     unsigned long d_val(int i) const;
491     unsigned long d_ptr(int i) const;
492
493     // Write Interface
494     void d_tag(int i, signed long input);
495     void d_val(int i, unsigned long input);
496     void d_ptr(int i, unsigned long input);
497
498     // Meta-Info Interface
499     unsigned long count() const;
500     bool isValid() const;
501
502   protected:
503     Elf_Data *data;
504     Elf32_Dyn *dyn32;
505     Elf64_Dyn *dyn64;
506     bool is64;
507 };
508
509 #endif