Update copyright to LGPL on all files
[dyninst.git] / symtabAPI / src / Object-xcoff.h
1 /*
2  * Copyright (c) 1996-2009 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 /************************************************************************
33  * AIX object files.
34  * $Id: Object-xcoff.h,v 1.24 2008/07/01 19:26:43 legendre Exp $
35 ************************************************************************/
36
37
38 #if !defined(_Object_aix_h_)
39 #define _Object_aix_h_
40
41 /************************************************************************
42  * header files.
43 ************************************************************************/
44
45 #include "common/h/headers.h"
46 //#include <common/h/Line.h>
47 #include "symtabAPI/h/Symbol.h"
48 #include "symtabAPI/h/Symtab.h"
49 #include "common/h/Types.h"
50
51 #include <string>
52 #include <vector>
53
54 using namespace std;
55 using namespace __gnu_cxx;
56
57 extern "C" {
58 #include <a.out.h>
59 };
60
61 #include <fcntl.h>
62 #include <stdlib.h>
63 #include <unistd.h>
64
65 #include <sys/types.h>
66 #include <sys/mman.h>
67 #include <sys/stat.h>
68
69 #define __AR_BIG__
70 #define __AR_SMALL__
71 #include <ar.h>
72
73 namespace Dyninst {
74 namespace SymtabAPI {
75
76 class fileOpener;
77
78 // Object to represent both the 32-bit and 64-bit archive headers
79 // for ar files (libraries)
80 class xcoffArchive {
81  public:
82   xcoffArchive (fileOpener *f) : member_name(0), fo_(f) {}
83   virtual ~xcoffArchive () {}
84   
85   virtual int read_arhdr() = 0;
86   virtual int read_mbrhdr() = 0;
87
88   unsigned long long aout_offset;
89   unsigned long long next_offset;
90   char *member_name;
91   int member_len;
92  protected:
93   unsigned long long first_offset;
94   unsigned long long last_offset;
95
96   fileOpener *fo_;
97 };
98
99 class xcoffArchive_32 : private xcoffArchive {
100  public:
101   xcoffArchive_32 (fileOpener *file) : xcoffArchive(file) {};
102   ~xcoffArchive_32 () {if (member_name) free(member_name);};
103   virtual int read_arhdr();
104   virtual int read_mbrhdr();
105
106  private:
107   struct fl_hdr filehdr;
108   struct ar_hdr memberhdr;
109 };
110
111 class xcoffArchive_64 : private xcoffArchive {
112  public:
113   xcoffArchive_64 (fileOpener *file) : xcoffArchive(file) {};
114   ~xcoffArchive_64 () {if (member_name) free(member_name);};
115   virtual int read_arhdr();
116   virtual int read_mbrhdr();
117
118  private:
119   struct fl_hdr_big filehdr;
120   struct ar_hdr_big memberhdr;
121 };
122
123 // We want to mmap a file once, then go poking around inside it. So we
124 // need to tie a few things together.
125
126 class fileOpener {
127  public:
128     static std::vector<fileOpener *> openedFiles;
129     static fileOpener *openFile(const std::string &file);
130     static fileOpener *openFile(void *ptr, unsigned size);
131     
132     void closeFile();
133
134 #if 0
135     fileOpener(const std::string &file) : refcount_(1), 
136         file_(file), fd_(0), 
137         size_(0), mmapStart_(NULL),
138         offset_(0) {}
139 #endif
140
141     fileOpener(void *ptr, unsigned size) : refcount_(1), 
142         file_(""), fd_(0), 
143         size_(size), mmapStart_(ptr),
144         offset_(0) {}
145         
146     ~fileOpener();
147
148 #if  0
149     bool open();
150     bool mmap();
151     bool unmap();
152     bool close();
153 #endif
154
155     bool pread(void *buf, unsigned size, unsigned offset);
156     bool read(void *buf, unsigned size);
157     bool seek(int offset);
158     bool set(unsigned addr);
159     // No write :)
160     // Get me a pointer into the mapped area
161     void *ptr() const;
162     void *getPtrAtOffset(unsigned offset) const;
163     
164     const std::string &file() const { return file_; }
165     int fd() const { return fd_; }
166     unsigned size() const { return size_; }
167     void *mem_image() const { return mmapStart_; }
168     void set_file(std::string f) { file_ = f; }
169
170  private:
171     int refcount_;
172     std::string file_;
173     int fd_;
174     unsigned size_;
175     void *mmapStart_;
176
177     // Where were we last reading?
178     unsigned offset_;
179 };
180
181
182 class Symtab;
183
184 /************************************************************************
185  * class Object
186 ************************************************************************/
187
188 class Object : public AObject {
189    friend class Symtab;
190  public:
191     Object (const Object &);
192     Object&   operator= (const Object &);
193     Object(){}  
194     Object(MappedFile *, MappedFile *, void (*)(const char *) = log_msg, Offset off = 0, bool alloc_syms = true);
195     Object(MappedFile *, MappedFile *, dyn_hash_map<std::string, LineInformation> &, std::vector<Region *> &, 
196           void (*)(const char *) = log_msg, Offset off = 0);
197     Object(MappedFile *, MappedFile *, std::string &member_name, Offset offset, 
198             void (*)(const char *) = log_msg, void *base = NULL);
199     virtual ~Object ()
200     {
201 #if 0
202         if (fo_)
203             fo_->closeFile();
204 #endif
205     }
206     
207     Offset getTOCoffset() const { return toc_offset_; }
208
209     // AIX does some weirdness with addresses. We don't want to touch local
210     // symbols to get addresses right, but that means that the base address
211     // needs to have a small value added back in. On shared objects.
212     Offset data_reloc () const { return data_reloc_; }
213     Offset text_reloc () const { return text_reloc_; }
214     Offset bss_size () const { return bss_size_; }
215     
216     void get_stab_info(char *&stabstr, int &nstabs, void *&stabs, char *&stringpool) const;
217     
218     void get_line_info(int& nlines, char*& lines,unsigned long& fdptr) const {
219         nlines = nlines_;
220         lines = (char*) linesptr_; 
221         fdptr = linesfdptr_;
222     }
223
224     Offset getLoadAddress() const { return loadAddress_; }
225     Offset getEntryAddress() const { return entryAddress_; }
226     Offset getBaseAddress() const { return baseAddress_; }
227     void getModuleLanguageInfo(dyn_hash_map<std::string, supportedLanguages> *mod_langs);
228     const char *interpreter_name() const { return NULL; }
229 #if 0
230     dyn_hash_map<std::string, LineInformation > &getLineInfo() { 
231         parseFileLineInfo();
232         return lineInfo_; 
233     }
234 #endif
235     
236     ObjectType objType() const;
237     bool isEEL() const { return false; }
238
239     void parseTypeInfo(Symtab *obj);
240     bool emitDriver(Symtab *obj, string fName, std::vector<Symbol *>&allSymbols, unsigned flag);
241
242 #if 0
243     bool getRegValueAtFrame(Address pc, 
244                             Dyninst::MachRegister reg, 
245                             Dyninst::MachRegisterVal &reg_result,
246                             MemRegReader *reader);
247 #endif
248
249 private:
250
251     void load_object(bool alloc_syms);
252     void load_archive(bool is_aout, bool alloc_syms);
253         bool fillExceptionTable(struct exceptab *, unsigned int, bool, struct syment *);
254     void parse_aout(int offset, bool is_aout, bool alloc_syms);
255     void parseFileLineInfo(Symtab *, dyn_hash_map<std::string, LineInformation> &li);
256     void parseLineInformation(dyn_hash_map<std::string, LineInformation> &li, std::string * currentSourceFile,
257                                         char * symbolName,
258                                         SYMENT * sym,
259                                         Offset linesfdptr,
260                                         char * lines,
261                                         int nlines );
262                                                                                                                                                                                                                  
263     // We mmap big files and piece them out; this handles the mapping
264     // and reading and pointerage and...
265     fileOpener *fo_;
266
267     std::string member_;
268     Offset offset_;
269     Offset toc_offset_;
270     Offset data_reloc_;
271     Offset text_reloc_;
272     Offset bss_size_;
273
274     Offset   loadAddress_;      // The object may specify a load address
275                                     //   Set to 0 if it may load anywhere
276     Offset entryAddress_;
277     Offset baseAddress_;
278     
279         char *stringPool;
280
281     int  nstabs_;
282     int  nlines_;
283     void *stabstr_;
284     void *stabs_;
285     void *stringpool_;
286     void *linesptr_;
287     Offset linesfdptr_;
288     bool is64_;
289     dyn_hash_map<std::string, LineInformation > lineInfo_;
290 };
291
292 /* This class is only used in symtab.C; the only reason it's in
293    this header file is so that template0.C can include it to
294    instantiate pdvector< IncludeFileInfo >. */
295 class IncludeFileInfo {
296         public:
297                 unsigned int begin;
298                 unsigned int end;
299                 std::string name;
300
301                 IncludeFileInfo() : begin(0), end(0) {};
302                 IncludeFileInfo( int _begin, const char *_name ) : begin(_begin), end(0), name(_name) {};
303         };
304
305 }//namespace SymtabAPI
306
307 }//namespace Dyninst
308
309 char *P_cplus_demangle( const char * symbol, bool nativeCompiler, bool includeTypes );
310
311 #endif /* !defined(_Object_aix_h_) */