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