Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / inst-winnt.C
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 // $Id: inst-winnt.C,v 1.31 2008/06/19 22:13:42 jaw Exp $
33
34 #include "dyninstAPI/src/os.h"
35 #include "dyninstAPI/src/dyninst.h"
36 #include "dyninstAPI/src/symtab.h"
37 #include "dyninstAPI/src/process.h"
38 #include "dyninstAPI/src/inst.h"
39 #include "dyninstAPI/src/instP.h"
40 #include "dyninstAPI/src/ast.h"
41 #include "dyninstAPI/src/util.h"
42 #include "common/h/stats.h"
43 #include "dyninstAPI/src/instPoint.h"
44
45 #include "Instruction.h"
46 #include "InstructionDecoder.h"
47 using namespace Dyninst::InstructionAPI;
48
49 #ifndef mips_unknown_ce2_11 //ccw 27 july 2000 : 29 mar 2001
50 //defined in inst-mips.C
51
52 //
53 // All costs are based on Measurements on a SPARC station 10/40.
54 //
55 void initPrimitiveCost()
56 {
57     /* Need to add code here to collect values for other machines */
58
59     // this doesn't really take any time
60     primitiveCosts["DYNINSTbreakPoint"] = 1;
61
62     // this happens before we start keeping time.
63     primitiveCosts["DYNINSTinit"] = 1;
64
65     primitiveCosts["DYNINSTprintCost"] = 1;
66
67     //
68     // I can't find DYNINSTincrementCounter or DYNINSTdecrementCounter
69     // I think they are not being used anywhere - naim
70     //
71     // isthmus acutal numbers from 7/3/94 -- jkh
72     // 240 ns
73     primitiveCosts["DYNINSTincrementCounter"] = 16;
74     // 240 ns
75     primitiveCosts["DYNINSTdecrementCounter"] = 16;
76
77     // Updated calculation of the cost for the following procedures.
78     // cost in cycles
79     // Values (in cycles) benchmarked on a Pentium II 450MHz
80     // Level 1 - Hardware Level
81     primitiveCosts["DYNINSTstartWallTimer"] = 151;
82     primitiveCosts["DYNINSTstopWallTimer"] = 165;
83
84     // Implementation still needs to be added to handle start/stop
85     // timer costs for multiple levels
86     /* Level 2 - Software Level
87     primitiveCosts["DYNINSTstartWallTimer"] = 797;
88     primitiveCosts["DYNINSTstopWallTimer"] = 807;
89     */
90     primitiveCosts["DYNINSTstartProcessTimer"] = 990;
91     primitiveCosts["DYNINSTstopProcessTimer"] = 1017;
92
93     // These happen async of the rest of the system.
94     primitiveCosts["DYNINSTalarmExpire"] = 3724;
95     primitiveCosts["DYNINSTsampleValues"] = 13;
96     primitiveCosts["DYNINSTreportTimer"] = 1380;
97     primitiveCosts["DYNINSTreportCounter"] = 1270;
98     primitiveCosts["DYNINSTreportCost"] = 1350;
99     primitiveCosts["DYNINSTreportNewTags"] = 837;
100 }
101 #endif
102
103  
104
105 // hasBeenBound: returns false
106 // dynamic linking not implemented on this platform
107 bool process::hasBeenBound(const relocationEntry &,int_function *&, Address ) {
108     return false;
109 }
110
111 // findCallee: returns false unless callee is already set in instPoint
112 // dynamic linking not implemented on this platform
113 int_function *instPoint::findCallee() 
114 {
115    // Already been bound
116    if (callee_) {
117       return callee_;
118    }  
119    if (ipType_ != callSite) {
120        return NULL;
121    }
122   
123    if (!isDynamic()) {
124       // We have a direct call but don't yet know the callee.
125       // This may be because we didn't see a symbol for a
126       // thunk in the ILT.
127       // (I.e., the call is 'call @ILT+<smallconstant>'
128       // and at @ILT+<smallconstant> there is a 'jmp <realfuncaddr>'
129       // instruction.
130       //
131       // We consider the callee to be the real function that
132       // is eventually called.
133       
134       // get the target address of the call
135         Expression::Ptr cft = insn()->getControlFlowTarget();
136         static Expression* theIP = new RegisterAST(r_EIP);
137         cft->bind(theIP, Result(s32, addr()));
138         Result r = cft->eval();
139                 assert(r.defined);
140                 Address callTarget = r.convert<Address>();
141                 parsing_printf(" **** instPoint::findCallee() callTarget = 0x%lx, insn = %s\n", callTarget, insn()->format().c_str());
142
143       // find code range that contains the target address
144       // TODO: optimize by checking callsite image first?
145       codeRange* cr = proc()->findOrigByAddr(callTarget);
146           if (cr == NULL) {
147          return NULL;
148           }
149       // if target address is a known function, return it
150       int_function* func = cr->is_function();
151       if (func != NULL) {
152          callee_ = func;
153          return func;
154       }
155       mapped_object *obj = cr->is_mapped_object();
156       if (obj == NULL)
157          return NULL;
158       
159       // get a "local" pointer to the call target instruction
160         static const unsigned max_insn_size = 16; // covers AMD64
161       const unsigned char *insnLocalAddr =
162         (unsigned char *)(proc()->getPtrToInstruction(callTarget));
163       InstructionDecoder d(insnLocalAddr, max_insn_size);
164       d.setMode(proc()->getAddressWidth() == 8);
165       Instruction::Ptr insn = d.decode();
166       if(insn && (insn->getCategory() == c_BranchInsn))
167       {
168           Expression::Ptr cft = insn->getControlFlowTarget();
169           static Expression* theIP = new RegisterAST(r_EIP);
170           cft->bind(theIP, Result(u64, callTarget));
171           Result r = cft->eval();
172           if(r.defined)
173           {
174               Address targAddr = r.convert<Address>();
175                                 parsing_printf(" **** instPoint::findCallee() targAddr = 0x%lx\n", targAddr);
176               int_function *target = proc()->findFuncByAddr(targAddr);
177               if(target)
178               {
179                   callee_ = target;
180                   return target;
181               }
182           }
183                   else
184                   {
185                           parsing_printf("WARNING: couldn't evaluate IAT jump at 0x%lx: %s\n", callTarget, insn->format().c_str());
186                   }
187       }
188    }
189    else
190    {
191       // An call that uses an indirect call instruction could be one
192       // of three things:
193       //
194       // 1. A call to a function within the same executable or DLL.  In 
195       //    this case, it could be a call through a function pointer in
196       //    memory or a register, or some other type of call.
197       //   
198       // 2. A call to a function in an implicitly-loaded DLL.  These are
199       //    indirect calls through an entry in the object's Import Address 
200       //    Table (IAT). An IAT entry is set to the address of the target 
201       //    when the DLL is loaded at process creation.
202       //
203       // 3. A call to a function in a delay-loaded DLL.  Like calls to 
204       //    implicitly-loaded DLLs, these are calls through an entry in the 
205       //    IAT.  However, for delay-loaded DLLs the IAT entry initially 
206       //    holds the address of a short code sequence that loads the DLL,
207       //    looks up the target function, patches the IAT entry with the 
208       //    address of the target function, and finally executes the target 
209       //    function.  After the first call, the IAT entry has been patched
210       //    and subsequent calls look the same as calls into an
211       //    implicitly-loaded DLL.
212       //
213       // Figure out what type of indirect call instruction this is
214       //
215       if(insn() && (insn()->getCategory() == c_CallInsn))
216       {
217           Expression::Ptr cft = insn()->getControlFlowTarget();
218           static Expression* theIP = new RegisterAST(r_EIP);
219           cft->bind(theIP, Result(u64, addr()));
220           Result r = cft->eval();
221           if(r.defined)
222           {
223               Address funcPtrAddress = r.convert<Address>();
224               assert( funcPtrAddress != ADDR_NULL );
225                   
226                 // obtain the target address from memory if it is available
227               Address targetAddr = ADDR_NULL;
228               proc()->readDataSpace( (const void*)funcPtrAddress, sizeof(Address),
229               &targetAddr, true );
230               if( targetAddr != ADDR_NULL )
231               {
232             
233             // see whether we already know anything about the target
234             // this may be the case with implicitly-loaded and delay-loaded
235             // DLLs, and it is possible with other types of indirect calls
236                   int_function *target = proc()->findFuncByAddr( targetAddr );
237                           
238             // we need to handle the delay-loaded function case specially,
239             // since we want the actual target function, not the temporary
240             // code sequence that handles delay loading
241                   if( (target != NULL) &&
242                        (!strncmp( target->prettyName().c_str(), "_imp_load_", 10 )) )
243                   {
244                // The target is named like a linker-generated
245                // code sequence for a call into a delay-loaded DLL.
246                       //
247                // Try to look up the function based on its name
248                // without the 
249                                   
250 #if READY
251                // check if the target is in the same module as the function
252                // containing the instPoint
253                // check whether the function pointer is in the IAT
254                if((funcPtrAddress >= something.iatBase) &&
255                   (funcPtrAddress <= (something.iatBase+something.iatLength)))
256 {
257                   // it is a call through the IAT, to a function in our
258                   // own module, so it is a call into a delay-loaded DLL
259                   // ??? how to handle this case
260 }
261 #else
262                // until we can detect the actual callee for delay-loaded
263                // DLLs, make sure that we don't report the linker-
264                // generated code sequence as the target
265                target = NULL;
266 #endif // READY
267                   }
268                   else {
269                       callee_ = target;
270                       return target;
271                   }
272               }
273                   }
274       }
275    }
276    return NULL;
277 }