Update copyright to LGPL on all files
[dyninst.git] / symtabAPI / src / Object-nt.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  * Windows NT/2000 object files.
34  ************************************************************************/
35
36
37
38
39 #if !defined(_Object_nt_h_)
40 #define _Object_nt_h_
41
42
43
44 /************************************************************************
45  * header files.
46 ************************************************************************/
47
48 #include "common/h/Types.h"
49 #include <vector>
50 #include <string>
51 #include <algorithm>
52 #include "symtabAPI/h/symutil.h"
53
54 #include <stdio.h>
55 #include <stdlib.h>
56 #define WIN32_LEAN_AND_MEAN
57 #include <windows.h>
58 #include <assert.h>
59
60 #if !defined(__out_ecount_opt)
61 #define __out_ecount_opt(UNUSED)
62 #endif
63 #include <dbghelp.h>
64
65 using namespace std;
66 namespace Dyninst{
67 namespace SymtabAPI{
68
69 class ExceptionBlock;
70
71 /************************************************************************
72  * class Object
73 ************************************************************************/
74
75 class Object : public AObject
76 {
77         friend class Symtab;
78  public:
79     class intSymbol
80         {
81         private:
82             std::string name;
83             DWORD64 addr;
84             DWORD type;
85             DWORD linkage;
86             DWORD size;
87             Region *region;
88
89         public:
90             intSymbol( std::string _name,
91                        DWORD64 _addr,
92                        DWORD _type,
93                        DWORD _linkage,
94                        DWORD _size,
95                        Region *_region)
96                 : name(_name),
97                 addr(_addr),
98                 type(_type),
99                 size(_size),
100                 region(_region)
101                 {}
102
103             std::string GetName( void ) const          { return name; }
104             DWORD64 GetAddr( void ) const           { return addr; }
105             DWORD       GetSize( void ) const                           { return size; }
106             DWORD       GetType( void ) const                           { return type; }
107             DWORD       GetLinkage( void ) const                        { return linkage; }
108             Region *GetRegion( void ) const        { return region; }
109             void        SetSize( DWORD cb )                                     { size = cb; }
110
111             void DefineSymbol( dyn_hash_map<std::string, std::vector< Symbol *> >& syms,
112                                map<Symbol *, std::string> &symsToMods,
113                                const std::string& modName ) const;
114         };
115
116     class File
117         {
118         private:
119             std::string name;
120             std::vector<intSymbol*> syms;
121
122         public:
123             File( std::string _name = "" )
124                 : name(_name)
125                 {}
126
127             void AddSymbol( intSymbol* pSym )
128                 {
129                     syms.push_back( pSym );
130                 }
131
132             void DefineSymbols( dyn_hash_map<std::string, std::vector< Symbol *> >& syms,
133                                 map<Symbol *, std::string> &symsToMods,
134                                 const std::string& modName ) const;
135             std::string GetName( void ) const           { return name; }
136             const std::vector<intSymbol*>& GetSymbols( void )   const           { return syms; }
137         };
138
139     class Module
140         {
141         private:
142             std::string name;
143             DWORD64 baseAddr;
144             DWORD64 extent;
145             bool isDll;
146
147             std::vector<File *> files;
148             File* defFile;
149
150             void PatchSymbolSizes( const Object* obj,
151                                    const std::vector<intSymbol*>& allSyms ) const;
152
153         public:
154             Module( std::string name,
155                     DWORD64 baseAddr,
156                     DWORD64 extent = 0 );
157
158             File* GetDefaultFile( void )                        { return defFile; }
159             File* FindFile( std::string name );
160             void AddFile( File* pFile )                         { files.push_back( pFile ); }
161
162             void DefineSymbols( const Object* obj,
163                                 dyn_hash_map<std::string, std::vector< Symbol *> > & syms,
164                                 map<Symbol *, std::string> &symsToMods ) const;
165             void BuildSymbolMap( const Object* obj ) const; 
166
167             std::string GetName( void ) const            { return name; }
168             bool IsDll( void ) const                { return isDll; }
169             void SetIsDll( bool v )                 { isDll = v; }
170         };
171
172  private:
173     Module* curModule;
174
175  public:
176     SYMTAB_EXPORT Object(MappedFile *, MappedFile *, void (*)(const char *) = log_msg, bool alloc_syms = true);
177     SYMTAB_EXPORT Object(){};
178   
179     SYMTAB_EXPORT virtual ~Object( void );
180
181     SYMTAB_EXPORT bool isForwarded( Offset addr );
182     SYMTAB_EXPORT bool isEEL() const { return false; }
183     SYMTAB_EXPORT bool isText( const Offset addr ) const; 
184     SYMTAB_EXPORT Offset get_base_addr() const { return (Offset)mf->base_addr();} 
185     SYMTAB_EXPORT Module* GetCurrentModule( void )                                  { return curModule; }
186    
187     SYMTAB_EXPORT bool getCatchBlock(ExceptionBlock &b, Offset addr, unsigned size = 0) const;
188     SYMTAB_EXPORT unsigned int GetTextSectionId( void ) const         { return textSectionId;}
189     SYMTAB_EXPORT PIMAGE_NT_HEADERS   GetImageHeader( void ) const    { return peHdr; }
190     SYMTAB_EXPORT PVOID GetMapAddr( void ) const                      { return mf->base_addr(); }
191     SYMTAB_EXPORT Offset getEntryPoint( void ) const                { if (peHdr) return peHdr->OptionalHeader.AddressOfEntryPoint; return 0;}
192     //+ desc.loadAddr(); } //laodAddr is always zero in our fake address space.
193     // TODO. Change these later.
194     SYMTAB_EXPORT Offset getLoadAddress() const { return imageBase; }
195     SYMTAB_EXPORT Offset getEntryAddress() const { return getEntryPoint(); }
196     SYMTAB_EXPORT Offset getBaseAddress() const { return get_base_addr(); }
197     SYMTAB_EXPORT Offset getTOCoffset() const { return 0; }
198     SYMTAB_EXPORT ObjectType objType() const;
199     SYMTAB_EXPORT const char *interpreter_name() const { return NULL; }
200     SYMTAB_EXPORT dyn_hash_map <std::string, LineInformation> &getLineInfo();
201     SYMTAB_EXPORT void parseTypeInfo(Symtab *obj);
202    
203     SYMTAB_EXPORT void    ParseGlobalSymbol(PSYMBOL_INFO pSymInfo);
204     SYMTAB_EXPORT const std::vector<Offset> &getPossibleMains() const   { return possible_mains; }
205     SYMTAB_EXPORT void getModuleLanguageInfo(dyn_hash_map<std::string, supportedLanguages> *mod_langs);
206     SYMTAB_EXPORT bool emitDriver(Symtab *obj, std::string fName, 
207                 std::vector<Symbol *>&allSymbols, unsigned flag);
208         SYMTAB_EXPORT unsigned int getSecAlign() const {return SecAlignment;}
209          virtual char *mem_image() const 
210   {
211      assert(mf);
212      return (char *)mf->base_addr();
213   }
214
215 private:
216     SYMTAB_EXPORT void    ParseSymbolInfo( bool );
217     SYMTAB_EXPORT void    parseFileLineInfo(Symtab *, dyn_hash_map<std::string, LineInformation> &);
218     SYMTAB_EXPORT void    FindInterestingSections( bool );
219     Region *          findEnclosingRegion(const Offset where);
220
221     Offset baseAddr;     // location of this object in mutatee address space
222
223     Offset imageBase; // Virtual Address at which the binary is loaded in its address space
224
225     PIMAGE_NT_HEADERS   peHdr;      // PE file headers
226     PIMAGE_OPTIONAL_HEADER optHdr;
227         unsigned int SecAlignment; //Section Alignment
228
229         unsigned int textSectionId;             // id of .text segment (section)
230         unsigned int dataSectionId;             // id of .data segment (section)
231    
232         HANDLE  hProc;                                  // Process Handle
233     std::vector<Offset> possible_mains; //Addresses of functions that may be main
234 };
235
236 // In recent versions of the Platform SDK, the macros naming
237 // the value for the Flags field of the SYMBOL_INFO struct have
238 // names with a SYMFLAG_ prefix.  Older Platform SDKs, including
239 // the version that shipped with the Visual Studio .NET product
240 // (i.e., VC7), use names for these macros with a SYMF_ prefix.
241 // If we find we are using these older headers, we define the
242 // new-style names.
243 #if !defined(SYMFLAG_FUNCTION)
244 #  define SYMFLAG_FUNCTION      SYMF_FUNCTION
245 #  define SYMFLAG_LOCAL         SYMF_LOCAL
246 #  define SYMFLAG_PARAMETER     SYMF_PARAMETER
247 #  define SYMFLAG_EXPORT        SYMF_EXPORT
248 #endif // !defined(SYMFLAG_FUNCTION)
249
250 }//namespace Dyninst
251 }//namespace SymtabAPI
252
253 #endif /* !defined(_Object_nt_h_) */