Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / pdwinnt.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 #include "common/h/std_namesp.h"
33 #include <iomanip>
34 #include <string>
35 #include "dyninstAPI/src/symtab.h"
36 #include "common/h/headers.h"
37 #include "dyninstAPI/src/os.h"
38 #include "dyninstAPI/src/dyn_lwp.h"
39 #include "dyninstAPI/src/process.h"
40 #include "dyninstAPI/src/addressSpace.h"
41 #include "dyninstAPI/src/dyn_thread.h"
42 #include "common/h/stats.h"
43 #include "common/h/Types.h"
44 #include "dyninstAPI/src/debug.h"
45 #include "dyninstAPI/src/instPoint.h"
46 #include "dyninstAPI/src/signalgenerator.h"
47 #include "dyninstAPI/src/signalhandler.h"
48 #include "dyninstAPI/src/debuggerinterface.h"
49 #include <psapi.h>
50 #include <windows.h>
51 #include "dyninstAPI/src/mapped_object.h"
52 #include "dyninstAPI/src/emit-x86.h"
53 #include "dyninstAPI/src/arch-x86.h"
54 #include "dyninstAPI/src/inst-x86.h"
55 #include "dyninstAPI/src/registerSpace.h"
56
57 #include "dyninstAPI/src/ast.h"
58
59 /* XXX This is only needed for emulating signals. */
60 #include "BPatch_thread.h"
61 #include "BPatch_process.h"
62 #include "nt_signal_emul.h"
63
64 #include "dyninstAPI/src/rpcMgr.h"
65
66 // prototypes of functions used in this file
67
68 void InitSymbolHandler( HANDLE hProcess );
69 void ReleaseSymbolHandler( HANDLE hProcess );
70 extern bool isValidAddress(AddressSpace *proc, Address where);
71
72 void printSysError(unsigned errNo) {
73     char buf[1000];
74     bool result = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, errNo, 
75                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
76                   buf, 1000, NULL);
77     if (!result) {
78         fprintf(stderr, "Couldn't print error message\n");
79         printSysError(GetLastError());
80     }
81     fprintf(stderr, "*** System error [%d]: %s\n", errNo, buf);
82     fflush(stderr);
83 }
84
85
86 // check if a file handle is for kernel32.dll
87 static bool kludge_isKernel32Dll(HANDLE fileHandle, std::string &kernel32Name) {
88     static DWORD IndxHigh, IndxLow;
89     static bool firstTime = true;
90     BY_HANDLE_FILE_INFORMATION info;
91     static std::string kernel32Name_;
92
93     if (firstTime) {
94        HANDLE kernel32H;
95        firstTime = false;
96        char sysRootDir[MAX_PATH+1];
97        if (GetSystemDirectory(sysRootDir, MAX_PATH) == 0)
98           assert(0);
99        kernel32Name_ = std::string(sysRootDir) + "\\kernel32.dll";
100        kernel32H = CreateFile(kernel32Name_.c_str(), GENERIC_READ, 
101                               FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);
102        assert(kernel32H);
103        if (!GetFileInformationByHandle(kernel32H, &info)) {
104           printSysError(GetLastError());
105           assert(0);
106        }
107        IndxHigh = info.nFileIndexHigh;
108        IndxLow = info.nFileIndexLow;
109        CloseHandle(kernel32H);
110     }
111
112     if (!GetFileInformationByHandle(fileHandle, &info))
113        return false;
114
115     if (info.nFileIndexHigh==IndxHigh && info.nFileIndexLow==IndxLow) {
116       kernel32Name = kernel32Name_;
117       return true;
118     }
119     return false;
120 }
121
122 /* 
123    Loading libDyninstRT.dll
124
125    We load libDyninstRT.dll dynamically, by inserting code into the
126    application to call LoadLibraryA. We don't use the inferior RPC
127    mechanism from class process because it already assumes that
128    libdyninst is loaded (it uses the inferior heap).
129    Instead, we use a simple inferior call mechanism defined below
130    to insert the code to call LoadLibraryA("libdyninstRT.dll").
131  */
132
133 Address loadDyninstDll(process *p, char Buffer[LOAD_DYNINST_BUF_SIZE]) {
134     return 0;
135 }
136
137 // osTraceMe is not needed in Windows NT
138 void OS::osTraceMe(void) {}
139
140 bool process::dumpImage(std::string outFile)
141 {
142   fprintf(stderr, "%s[%d]:  Sorry, dumpImage() not implemented for windows yet\n", FILE__, __LINE__);
143   fprintf(stderr, "\t cannot create '%s' as requested\n", outFile.c_str());
144   return false;
145 }
146
147 dyn_lwp *process::createRepresentativeLWP() {
148    representativeLWP = createFictionalLWP(0);
149    return representativeLWP;
150 }
151
152 static void hasIndex(process *, unsigned, void *data, void *result) 
153 {
154     *((int *) data) = (int) result;
155 }
156
157 // Thread creation
158 bool SignalHandler::handleThreadCreate(EventRecord &ev, bool &continueHint)
159 {
160    process *proc = ev.proc;
161    CONTEXT cont;
162    Address initial_func = 0, stack_top = 0;
163    BPatch_process *bproc = (BPatch_process *) ev.proc->up_ptr();
164    HANDLE lwpid = ev.info.u.CreateThread.hThread;
165    int_function *func = NULL;
166    int tid = ev.info.dwThreadId;
167    
168    //Create the lwp early on Windows
169    dyn_lwp *lwp = proc->createRealLWP((int) lwpid, (int) lwpid);
170    lwp->setFileHandle(lwpid);
171    lwp->setProcessHandle(proc->processHandle_);
172    lwp->attach();
173    ev.lwp = lwp;
174    proc->set_lwp_status(lwp, stopped);
175
176    continueHint = true;
177    if (proc->reachedBootstrapState(bootstrapped_bs)) 
178    {
179         //The process is already running when this thread was created.  It's at
180         //its initial entry point where we can read the initial function out of EAX
181         cont.ContextFlags = CONTEXT_FULL;
182         if (GetThreadContext(lwpid, &cont))
183         {
184             initial_func = cont.Eax;
185             stack_top = cont.Esp;           
186         }
187    }
188
189    if (initial_func) {
190      func = proc->findJumpTargetFuncByAddr(initial_func);
191    }
192
193    //Create the dyn_thread early as well.
194    dyn_thread *thr = new dyn_thread(proc, -1, lwp);
195    thr->update_tid(tid);
196    thr->update_start_pc(initial_func);
197    thr->update_start_func(func);
198    thr->update_stack_addr(stack_top);
199
200    if (func) {
201        proc->instrumentThreadInitialFunc(func);
202    }
203
204    return true;
205 }
206
207 bool SignalHandler::handleExecEntry(EventRecord &, bool &)
208 {
209   assert(0);
210   return false;
211 }
212
213 // Process creation
214 bool SignalHandler::handleProcessCreate(EventRecord &ev, bool &continueHint) 
215 {
216     process *proc = ev.proc;
217     
218     if(! proc)
219         return true;
220   
221     dyn_lwp *rep_lwp = proc->getRepresentativeLWP();
222     assert(rep_lwp);  // the process based lwp should already be set
223
224     //We're starting up, convert the representative lwp to a real one.
225     rep_lwp->set_lwp_id((int) rep_lwp->get_fd());
226     proc->real_lwps[rep_lwp->get_lwp_id()] = rep_lwp;
227     proc->representativeLWP = NULL;
228     if (proc->theRpcMgr)
229        proc->theRpcMgr->addLWP(rep_lwp);
230     
231     if (proc->threads.size() == 0) {
232         dyn_thread *t = new dyn_thread(proc, 
233                                        0, // POS (main thread is always 0)
234                                        rep_lwp);
235     }
236     else {
237         proc->threads[0]->update_tid(ev.info.dwThreadId);
238         proc->threads[0]->update_lwp(rep_lwp);
239     }
240
241     proc->set_status(stopped);
242    proc->setBootstrapState(begun_bs);
243    if (proc->insertTrapAtEntryPointOfMain()) {
244      startup_printf("%s[%d]:  attached to process, stepping to main\n", FILE__, __LINE__);
245    }
246    else {
247      proc->handleProcessExit();
248    }
249    continueHint = true;
250    return true;
251 }
252
253
254 bool CALLBACK printMods(PCSTR name, DWORD64 addr, PVOID unused) {
255     fprintf(stderr, " %s @ %llx\n", name, addr);
256     return true;
257 }
258
259 //Returns true if we need to 
260 bool SignalGenerator::SuspendThreadFromEvent(LPDEBUG_EVENT ev, dyn_lwp *lwp) {
261     HANDLE hlwp;
262     if (ev->dwDebugEventCode == CREATE_THREAD_DEBUG_EVENT) {
263         hlwp = ev->u.CreateThread.hThread;
264     }
265     else if (lwp) {
266         hlwp = lwp->get_fd();
267     }
268     else if (proc->getRepresentativeLWP()) {
269         hlwp = proc->getRepresentativeLWP()->get_fd();
270     }
271     else {
272                 return false;
273     }
274
275     int result = SuspendThread(hlwp);
276     if (result == -1) {
277         //Happens for thread exit events.
278         return false;        
279     }
280     return true;
281 }
282 // ccw 2 may 2001 win2k fixes
283 // when you launch a process to be debugged with win2k (as in createProcess)
284 // the system sends you back at least two debug events before starting the
285 // process.  a debug event is also sent back for every dll that is loaded
286 // prior to starting main(), these include ntdll.dll and kernel32.dll and any
287 // other dlls the process needs that are not loaded with an explicit call
288 // to LoadLibrary().
289 //
290 // dyninst catches the first debug event (CREATE_PROCESS) and initializes
291 // various process specific data structures.  dyninst catches the second
292 // debug event (an EXCEPTION_DEBUG_EVENT) and used this event as a trigger to
293 // put in the bit of code that forced the mutatee to load
294 // libdyninstAPI_RT.dll.  In win2k, this does not work.  The bit of code is
295 // run and the trailing DebugBreak is caught and handled but the Dll will not
296 // be loaded.  The EXCEPTION_DEBUG_EVENT must be handled and continued from
297 // before LoadLibrary will perform correctly.
298 //
299 // the fix for this is to handle this EXCEPTION_DEBUG_EVENT, and put a
300 // DebugBreak (0xcc) at the beginning of main() in the mutatee.  catching
301 // that DebugBreak allows dyninst to write in the bit of code used to load
302 // the libdyninstAPI_RT.dll.
303 //
304 // after this, dyninst previously instrumented the mutatee to force the
305 // execution of DYNINSTinit() in the dll.  in order to take out this bit of
306 // complexity, the DllMain() function in the dll, which is run upon loading
307 // the dll, is used to automatically call DYNINSTinit().
308 //
309 // DYNINSTinit() takes two parameters, a flag denoting how dyninst attached
310 // to this process and the pid of the mutator.  These are passed from the
311 // mutator to the mutatee by finding a variable in the dll and writing the
312 // correct values into the mutatee's address space.  When a Dll is loaded, a
313 // LOAD_DLL debug event is thrown before the execution of DllMain(), so
314 // dyninst catches this event, writes the necessary values into the mutatee
315 // memory, then lets DllMain() call DYNINSTinit().  the DebugBreak() at the
316 // end of DYNINSTinit() is now removed for NT/win2K
317 //
318 // the bit of code inserted to load the dll fires a DebugBreak() to signal
319 // that it is done. dyninst catches this, patches up the code that was used
320 // to load the dll, replaces what was overwritten in main() and resets the
321 // instruction pointer (EIP) to the beginning of main().
322 bool SignalGenerator::waitForEventsInternal(pdvector<EventRecord> &events) 
323 {
324   static bool first_signal = true;
325   DWORD milliseconds = INFINITE;
326   EventRecord ev;
327
328   waitingForOS_ = true;
329   __UNLOCK;
330   bool result = WaitForDebugEvent(&ev.info, milliseconds);
331   __LOCK;
332   waitingForOS_ = false;
333   if (!result)
334   {
335     DWORD err = GetLastError();
336     if ((WAIT_TIMEOUT == err) || (ERROR_SEM_TIMEOUT == err)) {
337       //  apparently INFINITE milliseconds returns with SEM_TIMEOUT
338       //  This may be a problem, but it doesn't seem to break anything.
339       ev.type = evtTimeout;
340       events.push_back(ev);
341       return true;
342     }else {
343       printSysError(err);
344       fprintf(stderr, "%s[%d]:  Unexpected error from WaitForDebugEvent: %d\n",
345               __FILE__, __LINE__, err);
346     }
347     stopThreadNextIter();
348     return false;
349   }
350
351   process *proc = process::findProcess(ev.info.dwProcessId);
352   if (proc == NULL) {
353      /* this case can happen when we create a process, but then are unable
354         to parse the symbol table, and so don't complete the creation of the
355         process. We just ignore the event here.  */
356      ContinueDebugEvent(ev.info.dwProcessId, ev.info.dwThreadId, DBG_CONTINUE);
357      ev.type = evtNullEvent;
358      events.push_back(ev);
359      return true;
360    }
361
362    ev.proc = proc;
363    dyn_thread *thr = proc->getThread(ev.info.dwThreadId);
364    ev.lwp = NULL;
365    if (thr) {
366        ev.lwp = thr->get_lwp();
367        proc->set_lwp_status(ev.lwp, stopped);
368    }
369    if (!ev.lwp && ev.proc->getRepresentativeLWP() &&
370        ev.info.dwDebugEventCode != CREATE_THREAD_DEBUG_EVENT) 
371    {
372        //Happens during process startup
373        ev.lwp = ev.proc->getRepresentativeLWP();
374        proc->set_lwp_status(ev.lwp, stopped);
375    }
376    if (!ev.lwp) {
377        //Happens during thread creation events
378        // the status will be set to stopped when we create
379        // the new lwp later.
380        ev.lwp = ev.proc->getInitialLwp();
381    }
382
383    signal_printf("[%s:%u] - Got event %d on %d (%d)\n", __FILE__, __LINE__, 
384            ev.info.dwDebugEventCode, ev.lwp->get_fd(), ev.info.dwThreadId);
385
386    Frame af = ev.lwp->getActiveFrame();
387    ev.address = (Address) af.getPC();
388
389    events.push_back(ev);
390    return true;
391 }
392
393 bool SignalGenerator::decodeEvents(pdvector<EventRecord> &events) {
394     bool result = true;
395     for (unsigned i=0; i<events.size(); i++) {
396         if (!decodeEvent(events[i]))
397             result = false;
398     }
399     return result;
400 }
401
402 bool SignalGenerator::decodeEvent(EventRecord &ev)
403 {
404    bool ret = false;
405    switch (ev.info.dwDebugEventCode) {
406      case EXCEPTION_DEBUG_EVENT:
407         //ev.type = evtException;
408         ev.what = ev.info.u.Exception.ExceptionRecord.ExceptionCode;
409         ret = decodeException(ev);
410         break;
411      case CREATE_THREAD_DEBUG_EVENT:
412         ev.type = evtThreadCreate;
413         ret = true;
414         break;
415      case CREATE_PROCESS_DEBUG_EVENT:
416         ev.type = evtProcessCreate;
417         ret = true;
418         break;
419      case EXIT_THREAD_DEBUG_EVENT:
420         ev.type = evtThreadExit;
421         requested_wait_until_active = true;
422         ret = true;
423         break;
424      case EXIT_PROCESS_DEBUG_EVENT:
425         ev.type = evtProcessExit;
426         ev.what = ev.info.u.ExitProcess.dwExitCode;
427         ev.status = statusNormal;
428         requested_wait_until_active = true;
429         ret = true;
430         break;
431      case LOAD_DLL_DEBUG_EVENT:
432         ev.type = evtLoadLibrary;
433         ev.what = SHAREDOBJECT_ADDED;
434         ret = true;
435         break;
436      case UNLOAD_DLL_DEBUG_EVENT:
437          signal_printf("WaitForDebugEvent returned UNLOAD_DLL_DEBUG_EVENT\n");
438          ev.type = evtUnloadLibrary;
439          ev.what = SHAREDOBJECT_REMOVED;
440          ret = true;
441          break;
442    case OUTPUT_DEBUG_STRING_EVENT:
443        ev.type = evtNullEvent;
444        if (ev.info.u.DebugString.fUnicode == false && ev.info.u.DebugString.nDebugStringLength > 0) {
445            int buflen = (ev.info.u.DebugString.nDebugStringLength < 512) ? 
446                ev.info.u.DebugString.nDebugStringLength : 512;
447            char *buf = (char*) malloc(buflen);
448            if (proc->readDataSpace(ev.info.u.DebugString.lpDebugStringData, 
449                                    buflen, buf, true)) {
450                signal_printf("Captured OUTPUT_DEBUG_STRING_EVENT, debug string = %s\n", buf);
451            }
452            free (buf);
453        }
454        break;
455      default: // RIP_EVENT or unknown event
456         fprintf(stderr, "%s[%d]:  WARN:  unknown debug event=0x%x\n", FILE__, __LINE__, ev.info.dwDebugEventCode);
457         ev.type = evtNullEvent;
458         ret = true;
459         break;
460    };
461
462    // Due to NT's odd method, we have to call pause_
463    // directly (a call to pause returns without doing anything
464    // pre-initialization)
465    if (!requested_wait_until_active) {
466       bool success = SuspendThreadFromEvent(&(ev.info), ev.lwp);
467       if (success) {
468          if (!ContinueDebugEvent(ev.info.dwProcessId, ev.info.dwThreadId, DBG_CONTINUE)) {
469            printf("ContinueDebugEvent failed\n");
470            printSysError(GetLastError());
471          }
472       }
473    }
474
475   return ret;
476 }
477
478 bool SignalGenerator::decodeBreakpoint(EventRecord &ev) 
479 {
480   char buf[128];
481   bool ret = false;
482   process *proc = ev.proc;
483
484   if (decodeIfDueToProcessStartup(ev)) {
485      ret = true;
486   }
487   else if (proc->getRpcMgr()->decodeEventIfDueToIRPC(ev)) {
488      signal_printf("%s[%d]:  BREAKPOINT due to RPC\n", FILE__, __LINE__);
489      ret = true;
490   }
491   else if (proc->trapMapping.definesTrapMapping(ev.address)) {
492      ev.type = evtInstPointTrap;
493      ret = true;
494   }
495   else if (decodeRTSignal(ev)) {
496       ret = true;
497   }
498   else {
499      ev.type = evtProcessStop;
500      ret = true;
501   }
502
503   signal_printf("%s[%d]:  decodeSigTrap for %s, state: %s\n",
504                 FILE__, __LINE__, ev.sprint_event(buf),
505                 proc->getBootstrapStateAsString().c_str());
506
507   return ret;
508 }
509
510 bool SignalGenerator::decodeException(EventRecord &ev) 
511 {
512    bool ret = false;
513    switch (ev.what) {
514      case EXCEPTION_BREAKPOINT: 
515         signal_printf("DECODE BREAKPOINT\n");
516         ret = decodeBreakpoint(ev);
517         break;
518      case EXCEPTION_ILLEGAL_INSTRUCTION:
519      case EXCEPTION_ACCESS_VIOLATION:
520      {
521          requested_wait_until_active = true;
522          ev.address = (eventAddress_t) ev.info.u.Exception.ExceptionRecord.ExceptionAddress;
523          // if it's a write access violation to an existing code range that was write-protected
524          if (ev.what == EXCEPTION_ACCESS_VIOLATION 
525              && ev.info.u.Exception.ExceptionRecord.ExceptionInformation[0] == 1) {
526              Address violationAddr = ev.info.u.Exception.ExceptionRecord.ExceptionInformation[1];
527              codeRange *range = ev.proc->findOrigByAddr(violationAddr);
528              if (range) {
529                  fprintf(stderr,"%s[%d] Program attempted to overwrite code at 0x%x\n", __FILE__,__LINE__, violationAddr);
530              }
531          }
532          // trigger callback if a signalHandlerCallback is registered
533          pdvector<CallbackBase *> sigCBs;
534          SignalHandlerCallback *sigHandlerCB = NULL;
535          if (getCBManager()->dispenseCallbacksMatching(evtSignalHandlerCB, sigCBs)
536              && ev.address != ((SignalHandlerCallback*)sigCBs[0])->getLastSigAddr()
537              && ((SignalHandlerCallback*)sigCBs[0])->handlesSignal(ev.what)) {
538              ev.type = evtSignalHandlerCB;
539          }
540          else {
541              Frame af = ev.lwp->getActiveFrame();
542              signal_printf("DECODE CRITICAL --  ILLEGAL INSN OR ACCESS VIOLATION\n");
543              ev.type = evtCritical;
544          }
545          ret = true;
546          break;
547      }
548      case EXCEPTION_SINGLE_STEP:
549          signal_printf("SINGLE STEP\n");
550          ev.type = evtDebugStep;
551          ev.address = (eventAddress_t) ev.info.u.Exception.ExceptionRecord.ExceptionAddress;
552          ret = true;
553          break;
554      default:
555          ev.address = (eventAddress_t) ev.info.u.Exception.ExceptionRecord.ExceptionAddress;
556          // see if a signalHandlerCallback is registered
557          pdvector<CallbackBase *> sigCBs;
558          SignalHandlerCallback *sigHandlerCB = NULL;
559          /*
560              for (unsigned i=0; i < sigCBs.size(); sigCBs++) {
561                   sigHandlerCB = dynamic_cast<SignalHandlerCallback *> sigCBs[i];
562                   if (sigHandlerCB != NULL && ev.addr == sigHandler->lastSigAddr()) {
563          */
564          if (getCBManager()->dispenseCallbacksMatching(evtSignalHandlerCB, sigCBs)
565              && ev.address != ((SignalHandlerCallback*)sigCBs[0])->getLastSigAddr()
566              && ((SignalHandlerCallback*)sigCBs[0])->handlesSignal(ev.what)) {
567              ev.type = evtSignalHandlerCB;
568          }
569          else {
570              ev.type = evtSignalled;
571          }
572          requested_wait_until_active = true;
573          ret = true;
574          break;
575    }
576    return ret;
577 }
578
579 bool SignalGeneratorCommon::decodeRTSignal_NP(EventRecord &ev, 
580                                               Address rt_arg, int status)
581 {
582     // windows uses ev.info for the DEBUG_EVENT struct, so we
583     // shanghai the fd field instead
584     ev.fd = (eventFileDesc_t) rt_arg;
585
586     switch(status) {
587     case DSE_snippetBreakpoint:
588         ev.type = evtProcessStop;
589         return true;
590     case DSE_stopThread: 
591         ev.type = evtStopThread;
592         return true; 
593     default:
594         assert(0);
595         return false;
596     }
597 }
598
599 bool SignalGenerator::decodeSyscall(EventRecord &) 
600 {
601     return false;
602 }
603
604 // already setup on this FD.
605 // disconnect from controlling terminal 
606 void OS::osDisconnect(void) {
607 }
608
609 bool process::setProcessFlags() {
610     return true;
611 }
612
613 bool process::unsetProcessFlags() {
614     return true;
615 }
616
617
618 /* continue a process that is stopped */
619 bool dyn_lwp::continueLWP_(int /*signalToContinueWith*/) {
620    unsigned count;
621    signal_printf("[%s:%u] - continuing %d\n", __FILE__, __LINE__, get_fd());
622    count = ResumeThread((HANDLE)get_fd());
623    if (count == (unsigned) -1) {
624       fprintf(stderr, "[%s:%u] - Couldn't resume thread\n", __FILE__, __LINE__);
625       printSysError(GetLastError());
626       return false;
627    } else
628       return true;
629 }
630
631
632 /*
633    terminate execution of a process
634  */
635 terminateProcStatus_t process::terminateProc_()
636 {
637     OS::osKill(getPid());
638     return terminateSucceeded;
639 }
640
641 /*
642    pause a process that is running
643 */
644 bool dyn_lwp::stop_() {
645    unsigned count = 0;
646    count = SuspendThread((HANDLE)get_fd());
647    if (count == (unsigned) -1)
648       return false;
649    else
650       return true;
651 }
652
653 bool process::dumpCore_(const std::string) {
654     return false;
655 }
656
657 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) {
658    return writeDataSpace(inTraced, sizeof(int), (caddr_t) &data);
659 }
660
661 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
662 {
663    return writeDataSpace(inTraced, amount, inSelf);
664 }
665
666 bool process::flushInstructionCache_(void *baseAddr, size_t size){ //ccw 25 june 2001
667    dyn_lwp *replwp = getInitialLwp();
668    return FlushInstructionCache((HANDLE)replwp->getProcessHandle(), baseAddr, size);
669 }
670
671 bool dyn_lwp::readTextSpace(void *inTraced, u_int amount, const void *inSelf) {
672    return readDataSpace(inTraced, amount, (void *)inSelf);
673 }
674
675 bool dyn_lwp::writeDataSpace(void *inTraced, u_int amount, const void *inSelf)
676 {
677     DWORD nbytes;
678     handleT procHandle = getProcessHandle();
679     bool res = WriteProcessMemory((HANDLE)procHandle, (LPVOID)inTraced, 
680                                   (LPVOID)inSelf, (DWORD)amount, &nbytes);
681     return res && (nbytes == amount);
682 }
683
684
685 bool dyn_lwp::readDataSpace(const void *inTraced, u_int amount, void *inSelf) {
686     DWORD nbytes;
687     handleT procHandle = getProcessHandle();
688     bool res = ReadProcessMemory((HANDLE)procHandle, (LPVOID)inTraced, 
689                                  (LPVOID)inSelf, (DWORD)amount, &nbytes);
690     return res && (nbytes == amount);
691 }
692
693 bool dyn_lwp::waitUntilStopped() {
694    return true;
695 }
696
697 bool process::waitUntilStopped() {
698    return true;
699 }
700
701 Frame dyn_lwp::getActiveFrame()
702 {
703   w32CONTEXT cont; //ccw 27 july 2000 : 29 mar 2001
704   
705   Address pc = 0, fp = 0, sp = 0;
706   
707   // we must set ContextFlags to indicate the registers we want returned,
708   // in this case, the control registers.
709   // The values for ContextFlags are defined in winnt.h
710   cont.ContextFlags = CONTEXT_CONTROL;
711   if (GetThreadContext((HANDLE)get_fd(), &cont))
712   {
713      fp = cont.Ebp;
714      pc = cont.Eip;
715      sp = cont.Esp;
716      return Frame(pc, fp, sp, proc_->getPid(), proc_, NULL, this, true);
717   }
718   printSysError(GetLastError());
719   return Frame();
720 }
721
722 bool Frame::setPC(Address newpc) {
723   fprintf(stderr, "Implement me! Changing frame PC from %x to %x\n",
724           pc_, newpc);
725   return false;
726 }
727
728 bool dyn_lwp::getRegisters_(struct dyn_saved_regs *regs, bool includeFP) {
729    // we must set ContextFlags to indicate the registers we want returned,
730    // in this case, the control registers.
731    // The values for ContextFlags are defined in winnt.h
732    regs->cont.ContextFlags = w32CONTEXT_FULL;//ccw 27 july 2000 : 29 mar 2001
733    handleT handle = get_fd();
734    if (!GetThreadContext((HANDLE)handle, &(regs->cont)))
735    {
736       return false;
737    }
738    return true;
739 }
740
741 void dyn_lwp::dumpRegisters()
742 {
743    dyn_saved_regs regs;
744    if (!getRegisters(&regs)) {
745      fprintf(stderr, "%s[%d]:  registers unavailable\n", FILE__, __LINE__);
746      return;
747    }
748 }
749
750 bool dyn_lwp::changePC(Address addr, struct dyn_saved_regs *regs)
751 {    
752   w32CONTEXT cont;//ccw 27 july 2000
753   if (!regs) {
754       cont.ContextFlags = w32CONTEXT_FULL;//ccw 27 july 2000 : 29 mar 2001
755       if (!GetThreadContext((HANDLE)get_fd(), &cont))
756       {
757           printf("GetThreadContext failed\n");
758           return false;
759       }
760   }
761   else {
762       memcpy(&cont, &(regs->cont), sizeof(w32CONTEXT));
763   }
764   cont.Eip = addr;
765   if (!SetThreadContext((HANDLE)get_fd(), &cont))
766   {
767     printf("SethreadContext failed\n");
768     return false;
769   }
770   return true;
771 }
772
773 bool dyn_lwp::restoreRegisters_(const struct dyn_saved_regs &regs, bool includeFP) {
774   if (!SetThreadContext((HANDLE)get_fd(), &(regs.cont)))
775   {
776     //printf("SetThreadContext failed\n");
777     return false;
778   }
779   return true;
780 }
781
782 bool process::isRunning_() const {
783     // TODO
784     return true;
785 }
786
787
788 std::string 
789 process::tryToFindExecutable(const std::string& iprogpath, int pid)
790 {
791     if( iprogpath.length() == 0 )
792     {
793         HANDLE hProc = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
794                                     FALSE,
795                                     pid );
796         if( hProc != NULL )
797         {
798             // look at the process' modules to see if we can get at an EXE
799             DWORD nMods = 32;
800             DWORD cb = nMods * sizeof(HMODULE);
801             DWORD cbNeeded = 0;
802             HMODULE* hMods = new HMODULE[cb];
803             BOOL epmRet = EnumProcessModules( hProc,
804                                                 hMods,
805                                                 cb,
806                                                 &cbNeeded );
807             if( !epmRet && (cbNeeded > cb) )
808             {
809                 // we didn't pass a large enough array in
810                 delete[] hMods;
811                 nMods = (cbNeeded / sizeof(HMODULE));
812                 cb = cbNeeded;
813                 hMods = new HMODULE[cb];
814
815                 epmRet = EnumProcessModules( hProc,
816                                                 hMods,
817                                                 cb,
818                                                 &cbNeeded );
819             }
820
821             if( epmRet )
822             {
823                 // we got modules
824                 // look for the EXE (always first item?)
825                 nMods = cbNeeded / sizeof(HMODULE);
826                 for( unsigned int i = 0; i < nMods; i++ )
827                 {
828                     char modName[MAX_PATH];
829
830                     BOOL gmfnRet = GetModuleFileNameEx( hProc,
831                                                         hMods[i],
832                                                         modName,
833                                                         MAX_PATH );
834                     if( gmfnRet )
835                     {
836                         // check if this is the EXE
837                         // TODO is this sufficient?
838                         // should we instead be recognizing the
839                         // "program" by some other criteria?
840                         unsigned int slen = strlen( modName );
841                         if( (modName[slen-4] == '.') &&
842                             ((modName[slen-3]=='E')||(modName[slen-3]=='e')) &&
843                             ((modName[slen-2]=='X')||(modName[slen-2]=='x')) &&
844                             ((modName[slen-1]=='E')||(modName[slen-1]=='e')) )
845                         {
846                             return modName;
847                             break;
848                         }
849                     }
850                 }
851             }
852
853             CloseHandle( hProc );
854         }
855     }
856     return iprogpath;
857 }
858
859 Address dyn_lwp::readRegister(Register reg)
860 {
861    w32CONTEXT *cont = new w32CONTEXT;//ccw 27 july 2000 : 29 mar 2001
862     if (!cont)
863         return NULL;
864     // we must set ContextFlags to indicate the registers we want returned,
865     // in this case, the control registers.
866     // The values for ContextFlags are defined in winnt.h
867     cont->ContextFlags = w32CONTEXT_FULL;//ccw 27 july 2000
868     if (!GetThreadContext((HANDLE)get_fd(), cont)) {
869       delete cont;
870           return NULL;
871     }
872     return cont->Eax;
873 }
874
875
876 void InitSymbolHandler( HANDLE hProcess )
877 {
878 }
879
880 void
881 ReleaseSymbolHandler( HANDLE hProcess )
882 {
883     if( !SymCleanup( hProcess ) )
884     {
885         // TODO how to report error?
886         fprintf( stderr, "failed to release symbol handler: %x\n",
887             GetLastError() );
888     }
889
890     CloseHandle(hProcess);
891 }
892
893 bool SignalGenerator::waitForStopInline()
894 {
895    return true;
896 }
897 /*****************************************************************************
898  * forkNewProcess: starts a new process, setting up trace and io links between
899  *                the new process and the daemon
900  * Returns true if succesfull.
901  * 
902  * Arguments:
903  *   file: file to execute
904  *   dir: working directory for the new process
905  *   argv: arguments to new process
906  *   inputFile: where to redirect standard input
907  *   outputFile: where to redirect standard output
908  *   traceLink: handle or file descriptor of trace link (read only)
909  *   ioLink: handle or file descriptor of io link (read only)
910  *   pid: process id of new process
911  *   tid: thread id for main thread (needed by WindowsNT)
912  *   procHandle: handle for new process (needed by WindowsNT)
913  *   thrHandle: handle for main thread (needed by WindowsNT)
914  ****************************************************************************/
915 bool SignalGenerator::forkNewProcess()
916 {
917     // create the child process    
918     std::string args;
919     for (unsigned ai=0; ai<argv_->size(); ai++) {
920        args += (*argv_)[ai];
921        args += " ";
922     }
923
924     STARTUPINFO stinfo;
925     memset(&stinfo, 0, sizeof(STARTUPINFO));
926     stinfo.cb = sizeof(STARTUPINFO);
927
928     /*to do: output redirection
929     //stinfo.hStdOutput = (HANDLE)ioLink;
930     stinfo.hStdOutput = (HANDLE)stdout_fd;
931     stinfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
932     stinfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
933     stinfo.dwFlags |= STARTF_USESTDHANDLES;
934     */
935     PROCESS_INFORMATION procInfo;
936     if (CreateProcess(file_.c_str(), (char *)args.c_str(), 
937                       NULL, NULL, TRUE,
938                       DEBUG_PROCESS /* | CREATE_NEW_CONSOLE */ | CREATE_SUSPENDED | DEBUG_ONLY_THIS_PROCESS ,
939                       NULL, dir_ == "" ? NULL : dir_.c_str(), 
940                       &stinfo, &procInfo)) 
941     {
942                   procHandle = (Word)procInfo.hProcess;
943                   thrHandle = (Word)procInfo.hThread;
944                   pid_ = (Word)procInfo.dwProcessId;
945                   tid = (Word)procInfo.dwThreadId;
946                   traceLink_ = -1;
947                   return true;    
948     }
949    
950    // Output failure message
951    LPVOID lpMsgBuf;
952
953    if (FormatMessage( 
954                      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
955                      NULL,
956                      GetLastError(),
957                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
958                      (LPTSTR) &lpMsgBuf,
959                      0,
960                      NULL 
961                      ) > 0) 
962     {
963       char *errorLine = (char *)malloc(strlen((char *)lpMsgBuf) +
964                                        file_.length() + 64);
965       if (errorLine != NULL) {
966          sprintf(errorLine, "Unable to start %s: %s\n", file_.c_str(),
967                  (char *)lpMsgBuf);
968          logLine(errorLine);
969          showErrorCallback(68, (const char *) errorLine);
970
971          free(errorLine);
972       }
973
974       // Free the buffer returned by FormatMsg
975       LocalFree(lpMsgBuf);    
976     } else {
977       char errorLine[512];
978       sprintf(errorLine, "Unable to start %s: unknown error\n",
979               file_.c_str());
980       logLine(errorLine);
981       showErrorCallback(68, (const char *) errorLine);
982     }
983
984    return false;
985 }
986
987 /*
988  * stripAtSuffix
989  *
990  * Strips off of a string any suffix that consists of an @ sign followed by
991  * decimal digits.
992  *
993  * str  The string to strip the suffix from.  The string is altered in place.
994  */
995 static void stripAtSuffix(char *str)
996 {
997     // many symbols have a name like foo@4, we must remove the @4
998     // just searching for an @ is not enough,
999     // as it may occur on other positions. We search for the last one
1000     // and check that it is followed only by digits.
1001     char *p = strrchr(str, '@');
1002     if (p) {
1003       char *q = p+1;
1004       strtoul(p+1, &q, 10);
1005       if (q > p+1 && *q == '\0') {
1006         *p = '\0';
1007       }
1008     }
1009 }
1010
1011 char *cplus_demangle(char *c, int, bool includeTypes) { 
1012     char buf[1000];
1013     if (c[0]=='_') {
1014        // VC++ 5.0 seems to decorate C symbols differently to C++ symbols
1015        // and the UnDecorateSymbolName() function provided by imagehlp.lib
1016        // doesn't manage (or want) to undecorate them, so it has to be done
1017        // manually, removing a leading underscore from functions & variables
1018        // and the trailing "$stuff" from variables (actually "$Sstuff")
1019        unsigned i;
1020        for (i=1; i<sizeof(buf) && c[i]!='$' && c[i]!='\0'; i++)
1021            buf[i-1]=c[i];
1022        buf[i-1]='\0';
1023        stripAtSuffix(buf);
1024        if (buf[0] == '\0') return 0; // avoid null names which seem to annoy Paradyn
1025        return P_strdup(buf);
1026     } else {
1027        if (includeTypes) {
1028           if (UnDecorateSymbolName(c, buf, 1000, UNDNAME_COMPLETE| UNDNAME_NO_ACCESS_SPECIFIERS|UNDNAME_NO_MEMBER_TYPE|UNDNAME_NO_MS_KEYWORDS)) {
1029             //   printf("Undecorate with types: %s = %s\n", c, buf);
1030             stripAtSuffix(buf);
1031             return P_strdup(buf);
1032           }
1033        }  else if (UnDecorateSymbolName(c, buf, 1000, UNDNAME_NAME_ONLY)) {
1034          //     else if (UnDecorateSymbolName(c, buf, 1000, UNDNAME_COMPLETE|UNDNAME_32_BIT_DECODE)) {
1035          //     printf("Undecorate: %s = %s\n", c, buf);
1036          stripAtSuffix(buf);          
1037          return P_strdup(buf);
1038        }
1039     }
1040     return 0;
1041 }
1042
1043 bool OS::osKill(int pid) {
1044     bool res;
1045     HANDLE h = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
1046     if (h == NULL) {
1047         return false;
1048     }
1049     res = TerminateProcess(h,0);
1050     CloseHandle(h);
1051     return res;
1052 }
1053
1054 bool SignalGeneratorCommon::getExecFileDescriptor(std::string filename,
1055                                     int pid,
1056                                     bool,
1057                                     int &status,
1058                                     fileDescriptor &desc)
1059 {
1060     assert(proc);
1061     dyn_lwp *rep_lwp = proc->getRepresentativeLWP();
1062     assert(rep_lwp);  // the process based lwp should already be set
1063
1064     if (proc->processHandle_ == INVALID_HANDLE_VALUE) {
1065
1066         if (!proc->wasCreatedViaAttach()) {
1067            int res = ResumeThread(proc->sh->getThreadHandle());
1068            if (res == -1) {
1069              fprintf(stderr, "%s[%d]:  could not resume thread here\n", FILE__, __LINE__);
1070              printSysError(GetLastError());
1071            }
1072         }
1073
1074        //  need to snarf up the next debug event, at which point we can get 
1075        //  a handle to the debugged process.
1076
1077        DEBUG_EVENT snarf_event;
1078        timed_out_retry:
1079
1080        if (!WaitForDebugEvent(&snarf_event, INFINITE))
1081        {
1082          fprintf(stderr, "%s[%d][%s]:  WaitForDebugEvent returned\n", 
1083                FILE__, __LINE__, getThreadStr(getExecThreadID()));
1084          DWORD err = GetLastError();
1085          if ((WAIT_TIMEOUT == err) || (ERROR_SEM_TIMEOUT == err)) {
1086            //  apparently INFINITE milliseconds returns with SEM_TIMEOUT
1087            //  This may be a problem, but it doesn't seem to break anything.
1088            goto timed_out_retry;
1089          }else {
1090            printSysError(err);
1091            fprintf(stderr, "%s[%d]:  Unexpected error from WaitForDebugEvent: %d\n",
1092                    __FILE__, __LINE__, err);
1093          }
1094          return false;
1095        }
1096
1097        //  Now snarf_event should have the right handles set...
1098
1099        proc->processHandle_ = snarf_event.u.CreateProcessInfo.hProcess;
1100        proc->mainFileHandle_ = snarf_event.u.CreateProcessInfo.hFile;
1101        proc->mainFileBase_ = (Address)snarf_event.u.CreateProcessInfo.lpBaseOfImage;
1102        proc->sh->thrHandle = (int) snarf_event.u.CreateProcessInfo.hThread;
1103        proc->sh->procHandle = (int) snarf_event.u.CreateProcessInfo.hProcess;
1104        char *imageName = (char *) snarf_event.u.CreateProcessInfo.lpImageName;
1105
1106        rep_lwp->setFileHandle(snarf_event.u.CreateProcessInfo.hThread);
1107        if (NULL == snarf_event.u.CreateProcessInfo.hThread)
1108          assert(0);
1109        rep_lwp->setProcessHandle(snarf_event.u.CreateProcessInfo.hProcess);
1110
1111        if (proc->threads.size() == 0) {
1112            dyn_thread *t = new dyn_thread(proc, 
1113                                           0, // POS (main thread is always 0)
1114                                           rep_lwp);
1115            t->update_tid(snarf_event.dwThreadId);
1116        }
1117     
1118        //This must be called on each process in order to use the 
1119        // symbol/line-info reading API
1120        bool result = SymInitialize(proc->processHandle_, NULL, FALSE);
1121        if (!result) {
1122            fprintf(stderr, "Couldn't SymInitialize\n");
1123            printSysError(GetLastError());
1124        } 
1125        DWORD64 iresult = SymLoadModule64(proc->processHandle_, proc->mainFileHandle_,
1126                                     imageName, NULL,
1127                                     (DWORD64) proc->mainFileBase_, 0);
1128        /*
1129        int res = ResumeThread((HANDLE) proc->sh->thrHandle);
1130        if (res == -1) {
1131           fprintf(stderr, "%s[%d]:  could not resume thread here\n", FILE__, __LINE__);
1132           printSysError(GetLastError());
1133        }
1134 */
1135        if (!ContinueDebugEvent(snarf_event.dwProcessId, 
1136                                snarf_event.dwThreadId, DBG_CONTINUE))
1137        {
1138          DebugBreak();
1139          printf("ContinueDebugEvent failed\n");
1140          printSysError(GetLastError());
1141          return false;
1142        }
1143
1144        proc->set_status(running);
1145     }
1146
1147     desc = fileDescriptor(filename.c_str(), 
1148                         (Address) 0,
1149                         (HANDLE) proc->processHandle_,
1150                         (HANDLE) proc->mainFileHandle_, 
1151                         false,
1152                         (Address) proc->mainFileBase_);
1153     return true;
1154 }
1155
1156
1157 bool getLWPIDs(pdvector <unsigned> &LWPids)
1158 {
1159   assert (0 && "Not implemented");
1160   return false;
1161 }
1162 //
1163 // This function retrieves the name of a DLL that has been
1164 // loaded in an inferior process.  On the desktop flavors
1165 // of Windows, the debug event that we get for loaded DLLs
1166 // includes the location of a pointer to the DLL's image name.
1167 // (Note the indirection.)  On Windows CE, the event contains
1168 // the location of the image name string, with no indirection.
1169 //
1170 // There are several complications to overcome when reading this string:
1171 //
1172 // 1.  There is no guarantee that the image name is available.
1173 //     In this case, the location in the debug event may be NULL,
1174 //     or the pointer in the inferior process' address space may be NULL.
1175 // 2.  The image name string may be either ASCII or Unicode.  Most of
1176 //     the Windows system DLLs have Unicode strings, but many user-built
1177 //     DLLs use single-byte strings.  If the string is Unicode, we need
1178 //     to copy it to our address space and convert it to a single-byte
1179 //     string because the rest of Paradyn/Dyninst has no clue what to
1180 //     do with Unicode strings.
1181 // 3.  We don't know how long the string is.  We have a loose upper
1182 //     bound in that we know it is not more than MAX_PATH characters.
1183 //     Unfortunately, the call we use to read from the inferior
1184 //     process' address space will return failure if we ask for more
1185 //     bytes than it can actually read (so we can't just issue a read
1186 //     for MAX_PATH characters).  Given this limitation, we have to
1187 //     try a read and check whether the read succeeded *and* whether
1188 //     we read the entire image name string.  If not, we have to adjust
1189 //     the amount we read and try again.
1190 //
1191 std::string GetLoadedDllImageName( process* p, const DEBUG_EVENT& ev )
1192 {
1193     char *msgText = NULL;
1194         std::string ret;
1195         void* pImageName = NULL;
1196
1197         if( ev.u.LoadDll.lpImageName != NULL )
1198         {
1199         msgText = new char[1024];       // buffer for error messages
1200             // On non-CE flavors of Windows, the address given in the debug
1201         // event struct is the address of a pointer to the DLL name string.
1202
1203         if( !p->readDataSpace( ev.u.LoadDll.lpImageName, 4, &pImageName, false ) )
1204         {
1205             sprintf( msgText, "Failed to read DLL image name pointer: %d\n",
1206             GetLastError() );
1207             logLine( msgText );
1208             }
1209     }
1210         if( pImageName != NULL )
1211         {
1212                 // we have the pointer to the DLL image name -
1213                 // now read the name
1214
1215                 // allocate a conservatively-sized buffer
1216                 char* buf = new char[(MAX_PATH + 1) * sizeof(WCHAR)];
1217                 WCHAR* wbuf = (WCHAR*)buf;
1218
1219                 // We don't know how long the image name actually is, but
1220                 // we do know that they tend not to be very long.
1221                 // Therefore, we use a scheme to try to minimize the number
1222                 // of reads needed to get the image name.
1223                 // We do reads within ranges, starting with [1,128] bytes,
1224                 // then [129,256] bytes, etc. up to MAX_PATH if necessary.
1225                 // Within each range, we do reads following a binary search
1226                 // algorithm.  For example, for the [1,128] range, we start
1227                 // by trying to read 128 bytes.  If that read fails, we
1228                 // try to half the number of bytes (i.e., 64).  If that
1229                 // read also fails, we continue to halve the read requests 
1230                 // until we find one that succeeds.
1231                 //
1232                 // When a read succeeds, we still may not have gotten the
1233                 // entire string.  So when reads start succeeding, we have to
1234                 // check the data we got for a null-terimated string.  If we didn't
1235                 // get the full string, we change the byte count to either
1236                 // move into the next higher range (if we were already reading
1237                 // the max within the current range) or we set it to a factor
1238                 // of 1.5 of the current byte count to try a value between the
1239                 // current succeeding read and one that had failed.
1240                 unsigned int loRead = 1;                // range boundaries
1241                 unsigned int hiRead = 128;
1242                 unsigned int cbRead = 128;              // number of bytes to read
1243                 unsigned int chunkRead = 64;    // amount to change cbRead if we fail
1244                                                                                 // we will not halve this before we read
1245                 bool gotString = false;
1246                 bool doneReading = false;
1247                 while( !doneReading )
1248                 {
1249                         // try the read with the current byte count
1250                         if( p->readDataSpace( pImageName, cbRead, buf, false ) )
1251                         {
1252                                 // the read succeeded - 
1253                                 // did we get the full string?
1254                                 if( ev.u.LoadDll.fUnicode )
1255                                 {
1256                                         unsigned int cbReadIdx = cbRead / sizeof(WCHAR);
1257                                         wbuf[cbReadIdx] = L'\0';
1258                                         WCHAR* nulp = wcschr( wbuf, L'\0' );
1259                                         assert( nulp != NULL );                 // because we just NULL-terminated the string
1260                                         gotString = (nulp != &(wbuf[cbReadIdx]));
1261                                 }
1262                                 else
1263                                 {
1264                                         buf[cbRead] = '\0';
1265                                         char* nulp = strchr( buf, '\0' );
1266                                         assert( nulp != NULL );                 // because we just NULL-terminated the string
1267                                         gotString = (nulp != &(buf[cbRead]));
1268                                 }
1269
1270                                 if( gotString )
1271                                 {
1272                                         doneReading = true;
1273                                 }
1274                                 else
1275                                 {
1276                                         // we didn't get the full string
1277                                         // we need to try a larger read
1278                                         if( cbRead == hiRead )
1279                                         {
1280                                                 // we were at the high end of the current range -
1281                                                 // move to the next range
1282                                                 loRead = hiRead + 1;
1283                                                 hiRead = loRead + 128 - 1;
1284                                                 chunkRead = 128;                                // we will halve this before we read again
1285                                                 if( loRead > (MAX_PATH * sizeof(WCHAR)) )
1286                                                 {
1287                                                         // we've tried every range but still failed
1288                                                         doneReading = true;
1289                                                 }
1290                                                 else
1291                                                 {
1292                                                         cbRead = hiRead;
1293                                                 }
1294                                         }
1295                                         else
1296                                         {
1297                                                 // we were within the current range -
1298                                                 // try something higher but still within the range
1299                                                 cbRead = cbRead + chunkRead;
1300                                         }
1301                                 }
1302                         }
1303                         else
1304                         {
1305                                 // the read failed -
1306                                 // we need to try a smaller read
1307                                 if( cbRead > loRead )
1308                                 {
1309                                         unsigned int nextRead = cbRead - chunkRead;
1310                                         if( nextRead == cbRead )
1311                                         {
1312                                                 // we can't subdivide any further
1313                                                 doneReading = true;
1314                                         }
1315                                         else
1316                                         {
1317                                                 cbRead = nextRead;
1318                                         }
1319                                 }
1320                                 else
1321                                 {
1322                                         // there are no smaller reads to try in this range,
1323                                         // and by induction, in any range.
1324                                         doneReading = true;
1325                                 }
1326                         }
1327
1328                         // update the amount that we use to change the read request
1329                         chunkRead /= 2;
1330                 }
1331
1332                 if( !gotString )
1333                 {
1334                         // this is a serious problem because some read 
1335                         // should've succeeded
1336                         sprintf( msgText, "Failed to read DLL image name - no read succeeded\n" );
1337                         logLine( msgText );
1338                 }
1339                 else
1340                 {
1341                         if( ev.u.LoadDll.fUnicode )
1342                         {
1343                                 // the DLL path is a Unicode string
1344                                 // we have to convert it to single-byte characters
1345                                 char* tmpbuf = new char[MAX_PATH];
1346
1347                                 WideCharToMultiByte(CP_ACP,             // code page to use (ANSI)
1348                                                                         0,                      // flags
1349                                                                         wbuf,           // Unicode string
1350                                                                         -1,                     // length of Unicode string (-1 => null-terminated)
1351                                                                         tmpbuf,         // destination buffer
1352                                                                         MAX_PATH,       // size of destionation buffer
1353                                                                         NULL,           // default for unmappable chars
1354                                                                         NULL);          // var to set when defaulting a char
1355
1356                                 // swap buffers so that buf points to the single-byte string
1357                                 // when we're out of this code block
1358                                 delete[] buf;
1359                                 buf = tmpbuf;
1360                         }
1361                         ret = buf;
1362                 }
1363
1364                 delete[] buf;
1365         }
1366         else
1367         {
1368                 // we were given an image name pointer, but it was NULL
1369                 // this happens for some system DLLs, and if we attach to
1370                 // the process instead of creating it ourselves.
1371                 // However, it is very important for us to know about kernel32.dll,
1372                 // so we check for it specially.
1373                 //
1374                 // This call only changes the string parameter if the indicated file is
1375                 // actually kernel32.dll.
1376                 if (kludge_isKernel32Dll(ev.u.LoadDll.hFile, ret))
1377             return ret;
1378
1379         //I'm embarassed to be writing this.  We didn't get a name for the image, 
1380         // but we did get a file handle.  According to MSDN, the best way to turn
1381         // a file handle into a file name is to map the file into the address space
1382         // (using the handle), then ask the OS what file we have mapped at that location.
1383         // I'm sad now.
1384         
1385         void *pmap = NULL;
1386         HANDLE fmap = CreateFileMapping(ev.u.LoadDll.hFile, NULL, 
1387                                         PAGE_READONLY, 0, 1, NULL);
1388         if (fmap) {
1389             pmap = MapViewOfFile(fmap, FILE_MAP_READ, 0, 0, 1);
1390             if (pmap) {   
1391                 char filename[MAX_PATH+1];
1392                 int result = GetMappedFileName(GetCurrentProcess(), pmap, filename, MAX_PATH);
1393                 if (result)
1394                     ret = std::string(filename);
1395                 UnmapViewOfFile(pmap);
1396             }
1397             CloseHandle(fmap);
1398         }
1399         }
1400
1401         if (ret.substr(0,7) == "\\Device") {
1402       HANDLE currentProcess = p->processHandle_;
1403       DWORD num_modules_needed;
1404       int errorCheck = EnumProcessModules(currentProcess,
1405                                           NULL,
1406                                           0,
1407                                           &num_modules_needed);
1408           num_modules_needed /= sizeof(HMODULE);
1409       HMODULE* loadedModules = new HMODULE[num_modules_needed];
1410       errorCheck = EnumProcessModules(currentProcess,
1411                                           loadedModules,
1412                                           sizeof(HMODULE)*num_modules_needed,
1413                                           &num_modules_needed);
1414       HMODULE* candidateModule = loadedModules; 
1415       while(candidateModule < loadedModules + num_modules_needed)
1416       {
1417          MODULEINFO candidateInfo;
1418          GetModuleInformation(currentProcess, *candidateModule, &candidateInfo,
1419                               sizeof(candidateInfo));
1420          if(ev.u.LoadDll.lpBaseOfDll == candidateInfo.lpBaseOfDll)
1421             break;
1422          candidateModule++;
1423       }
1424       if(candidateModule != loadedModules + num_modules_needed) 
1425       {
1426          TCHAR filename[MAX_PATH];
1427          if(GetModuleFileNameEx(currentProcess, *candidateModule, filename, MAX_PATH))
1428          {
1429             ret = filename;
1430          }
1431       }
1432       delete[] loadedModules;
1433
1434         }
1435         // cleanup
1436     if (msgText)
1437         delete[] msgText;
1438
1439         return ret;
1440 }
1441
1442 bool dyn_lwp::realLWP_attach_() {
1443    return true;
1444 }
1445
1446 bool dyn_lwp::representativeLWP_attach_() {
1447     if(proc_->wasCreatedViaAttach()) {
1448         if (!DebugActiveProcess(getPid())) {
1449             //printf("Error: DebugActiveProcess failed\n");
1450             return false;
1451         }
1452     }
1453     
1454     // We either created this process, or we have just attached it.
1455     // In either case, our descriptor already has a valid process handle.
1456     setProcessHandle(proc()->processHandle_);
1457     proc()->set_lwp_status(this, stopped);
1458
1459     return true;
1460 }
1461
1462 void dyn_lwp::realLWP_detach_()
1463 {
1464    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
1465    return;
1466 }
1467
1468 void dyn_lwp::representativeLWP_detach_()
1469 {
1470    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
1471    return;
1472 }
1473
1474 // Insert a breakpoint at the entry of main()
1475 bool process::insertTrapAtEntryPointOfMain() {
1476   mapped_object *aout = getAOut();
1477   Symtab *aout_obj = aout->parse_img()->getObject();
1478   pdvector<int_function *> funcs;
1479   Address min_addr = 0xffffffff;
1480   Address max_addr = 0x0;
1481   bool result;
1482   unsigned char oldbyte;
1483   const unsigned char trapInsn = 0xcc;
1484   startup_printf("[%s:%u] - Asked to insert bp at entry point of main\n", 
1485       __FILE__, __LINE__);
1486   
1487   if (main_function) {
1488           //Address addr = main_function->getAddress() - aout_obj->getBaseAddress()+ aout->getFileDesc().loadAddr();
1489      Address addr = main_function->getAddress();
1490      startup_printf("[%s:%u] - insertTrapAtEntryPointOfMain found main at %x\n",
1491                     __FILE__, __LINE__, addr);
1492      result = readDataSpace((void *) addr, sizeof(trapInsn), &oldbyte, false);
1493      if (!result) {
1494          fprintf(stderr, "Internal Error - Couldn't write breakpoint at top of main\n");
1495          return false;
1496      }
1497      assert (oldbyte != trapInsn);
1498      writeDataSpace((void *) addr, sizeof(trapInsn), (void *) &trapInsn);
1499      main_breaks[addr] = oldbyte;
1500      flushInstructionCache_((void *) addr, 1);
1501      return true;
1502   }
1503
1504
1505   if (max_addr >= min_addr)
1506     flushInstructionCache_( (void*)min_addr, max_addr - min_addr + 1 );
1507   return true;
1508 }
1509
1510 // True if we hit the trap at the entry of main
1511 bool process::trapAtEntryPointOfMain(dyn_lwp *lwp, Address trapAddr) {
1512     if (getBootstrapState() < begun_bs || getBootstrapState() > loadingRT_bs) return false;
1513     if (!main_breaks.defines(trapAddr)) return false;
1514
1515     startup_printf("[%s:%u] - Hit possible main breakpoint at %x:\n", __FILE__, __LINE__, trapAddr);
1516
1517     //Set the last function we hit as a possible main
1518     /*if (!main_function) {
1519        main_function = this->findFuncByAddr(trapAddr);
1520     }*/
1521     main_brk_addr = trapAddr;
1522
1523     return true;
1524 }
1525
1526 // Clean up after breakpoint in main() is hit
1527 bool process::handleTrapAtEntryPointOfMain(dyn_lwp *lwp)
1528 {
1529     //Remove this trap
1530     dictionary_hash<Address, unsigned char>::iterator iter = main_breaks.begin();
1531     Address min_addr = 0xffffffff;
1532     Address max_addr = 0x0;
1533     for (; iter != main_breaks.end(); iter++) {
1534         Address addr = iter.currkey();
1535         unsigned char value = *(iter);
1536
1537         bool result = writeDataSpace((void *) addr, sizeof(unsigned char), &value);
1538         if (!result) {
1539             fprintf(stderr, "Unexpected Error.  Couldn't remove breakpoint from "
1540                     "potential main at %x\n", addr);
1541             continue;   
1542         }
1543         if (max_addr < addr)
1544             max_addr = addr;
1545         if (min_addr > addr)
1546             min_addr = addr;
1547     }
1548     main_breaks.clear();
1549
1550     //Restore PC and flush instruction cache
1551     flushInstructionCache_((void *)min_addr, max_addr - min_addr + 1);
1552     lwp->changePC(main_brk_addr, NULL);
1553
1554     setBootstrapState(initialized_bs);
1555     return true;
1556 }
1557
1558 bool process::handleTrapAtLibcStartMain(dyn_lwp *)  { assert(0); return false; }
1559 bool process::instrumentLibcStartMain() { assert(0); return false; }
1560 bool process::decodeStartupSysCalls(EventRecord &) { assert(0); return false; }
1561 void process::setTraceSysCalls(bool) { assert(0); }
1562 void process::setTraceState(traceState_t) { assert(0); }
1563 bool process::getSysCallParameters(dyn_saved_regs *, long *, int) { assert(0); return false; }
1564 int process::getSysCallNumber(dyn_saved_regs *) { assert(0); return -1; }
1565 long process::getSysCallReturnValue(dyn_saved_regs *) { assert(0); return -1; }
1566 Address process::getSysCallProgramCounter(dyn_saved_regs *) { assert(0); return 0; }
1567 bool process::isMmapSysCall(int) { assert(0); return false; }
1568 Offset process::getMmapLength(int, dyn_saved_regs *) { assert(0); return 0; }
1569 Address process::getLibcStartMainParam(dyn_lwp *) { assert(0); return 0; }
1570
1571 bool AddressSpace::getDyninstRTLibName() {
1572     // Set the name of the dyninst RT lib
1573     if (dyninstRT_name.length() == 0) {
1574         // Get env variable
1575         if (getenv("DYNINSTAPI_RT_LIB") != NULL) {
1576             dyninstRT_name = getenv("DYNINSTAPI_RT_LIB");
1577         }
1578         else {
1579             std::string msg = std::string("Environment variable ") +
1580                std::string("DYNINSTAPI_RT_LIB") +
1581                std::string(" has not been defined");
1582             showErrorCallback(101, msg);
1583             return false;
1584         }
1585     }
1586     //Canonicalize name
1587     char *sptr = P_strdup(dyninstRT_name.c_str());
1588     for (unsigned i=0; i<strlen(sptr); i++)
1589        if (sptr[i] == '/') sptr[i] = '\\';
1590     dyninstRT_name = sptr;
1591     free(sptr);
1592            
1593     if (_access(dyninstRT_name.c_str(), 04)) {
1594         std::string msg = std::string("Runtime library ") + dyninstRT_name +
1595                        std::string(" does not exist or cannot be accessed!");
1596         showErrorCallback(101, msg);
1597         return false;
1598     }
1599
1600     return true;
1601 }
1602
1603
1604 // Load the dyninst library
1605 bool process::loadDYNINSTlib()
1606 {
1607     loadDyninstLibAddr = getAOut()->parse_img()->getObject()->getEntryOffset() + getAOut()->getBaseAddress();
1608     Address LoadLibAddr;
1609     int_symbol sym;
1610     
1611     dyn_lwp *lwp;
1612     lwp = getInitialLwp();
1613  /*   if (lwp->status() == running) {
1614        lwp->pauseLWP();
1615     }*/
1616
1617     if (!getSymbolInfo("_LoadLibraryA@4", sym) &&
1618         !getSymbolInfo("_LoadLibraryA", sym) &&
1619         !getSymbolInfo("LoadLibraryA", sym))
1620         {
1621             printf("unable to find function LoadLibrary\n");
1622             assert(0);
1623         }
1624     LoadLibAddr = sym.getAddr();
1625     assert(LoadLibAddr);
1626
1627     char ibuf[BYTES_TO_SAVE];
1628     memset(ibuf, '\0', BYTES_TO_SAVE);//ccw 25 aug 2000
1629     char *iptr = ibuf;
1630     strcpy(iptr, dyninstRT_name.c_str());
1631     
1632     // Code overview:
1633     // Dynininst library name
1634     //    Executable code begins here:
1635     // Push (address of dyninst lib name)
1636     // Call LoadLibrary
1637     // Pop (cancel push)
1638     // Trap
1639     
1640     // 4: give us plenty of room after the string to start instructions
1641     int instructionOffset = strlen(iptr) + 4;
1642     // Regenerate the pointer
1643     iptr = &(ibuf[instructionOffset]);
1644     
1645     // At this point, the buffer contains the name of the dyninst
1646     // RT lib. We now generate code to load this string into memory
1647     // via a call to LoadLibrary
1648     
1649     // push nameAddr ; 5 bytes
1650     *iptr++ = (char)0x68; 
1651     // Argument for push
1652     *(int *)iptr = loadDyninstLibAddr; // string at codeBase
1653     iptr += sizeof(int);
1654     
1655     int offsetFromBufferStart = (int)iptr - (int)ibuf;
1656     offsetFromBufferStart += 5; // Skip next instruction as well.
1657     // call LoadLibrary ; 5 bytes
1658     *iptr++ = (char)0xe8;
1659     
1660     // Jump offset is relative
1661     *(int *)iptr = LoadLibAddr - (loadDyninstLibAddr + 
1662                                   offsetFromBufferStart); // End of next instruction
1663     iptr += sizeof(int);
1664     
1665     
1666     // add sp, 4 (Pop)
1667     *iptr++ = (char)0x83; *iptr++ = (char)0xc4; *iptr++ = (char)0x04;
1668     
1669     // int3
1670     *iptr = (char)0xcc;
1671     
1672     int offsetToTrap = (int) iptr - (int) ibuf;
1673
1674     readDataSpace((void *)loadDyninstLibAddr, BYTES_TO_SAVE, savedCodeBuffer, false);
1675     writeDataSpace((void *)loadDyninstLibAddr, BYTES_TO_SAVE, ibuf);
1676     
1677     flushInstructionCache_((void *)loadDyninstLibAddr, BYTES_TO_SAVE);
1678     
1679     dyninstlib_brk_addr = loadDyninstLibAddr + offsetToTrap;
1680     
1681     savedRegs = new dyn_saved_regs;
1682
1683     bool status = lwp->getRegisters(savedRegs);
1684     assert(status == true);    
1685     lwp->changePC(loadDyninstLibAddr + instructionOffset, NULL);
1686     
1687     setBootstrapState(loadingRT_bs);
1688     return true;
1689 }
1690
1691
1692
1693 // Not used on NT. We'd have to rewrite the
1694 // prototype to take a PC. Handled inline.
1695 // True if trap is from dyninst load finishing
1696 bool process::trapDueToDyninstLib(dyn_lwp *lwp) 
1697 {
1698     if (!dyninstlib_brk_addr)
1699        return false;
1700     assert(lwp);
1701     Frame active = lwp->getActiveFrame();
1702     if (active.getPC() == dyninstlib_brk_addr ||
1703         (active.getPC()-1) == dyninstlib_brk_addr)
1704         return true;
1705     return false;
1706 }
1707
1708
1709
1710 // Cleanup after dyninst lib loaded
1711 bool process::loadDYNINSTlibCleanup(dyn_lwp *)
1712 {
1713     // First things first: 
1714     assert(savedRegs != NULL);
1715     getInitialLwp()->restoreRegisters(*savedRegs);
1716     delete savedRegs;
1717     savedRegs = NULL;
1718
1719     writeDataSpace((void *) loadDyninstLibAddr,
1720                    BYTES_TO_SAVE,
1721                    (void *)savedCodeBuffer);
1722
1723     flushInstructionCache_((void *)getAOut()->codeAbs(), BYTES_TO_SAVE);
1724
1725     dyninstlib_brk_addr = 0;
1726
1727     return true;
1728 }
1729
1730 void loadNativeDemangler() 
1731 {
1732     // ensure we load line number information when we load
1733     // modules, and give us mangled names
1734     DWORD dwOpts = SymGetOptions();
1735     dwOpts &= ~(SYMOPT_UNDNAME);
1736     dwOpts |= SYMOPT_LOAD_LINES;
1737     dwOpts &= ~(SYMOPT_DEFERRED_LOADS);
1738     SymSetOptions(dwOpts);
1739 }
1740
1741
1742 Frame dyn_thread::getActiveFrameMT() {
1743    return get_lwp()->getActiveFrame();
1744 }
1745
1746 bool process::determineLWPs(pdvector<unsigned> &lwp_ids)
1747 {
1748   dyn_lwp *lwp;
1749   unsigned index;
1750
1751   dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
1752   while (lwp_iter.next(index, lwp)) {
1753           if (!lwp->isDebuggerLWP()) {
1754       lwp_ids.push_back(lwp->get_lwp_id());
1755   }
1756   }
1757   return true;
1758 }
1759
1760 bool process::initMT()
1761 {
1762    return true;
1763 }
1764
1765 void dyninst_yield()
1766 {
1767     SwitchToThread();
1768 }
1769
1770 void OS::make_tempfile(char *name) {
1771 }
1772
1773 bool OS::execute_file(char *file) {
1774    STARTUPINFO s;
1775    PROCESS_INFORMATION proc;
1776    BOOL result;
1777
1778    ZeroMemory(&s, sizeof(s));
1779    ZeroMemory(&proc, sizeof(proc));
1780    s.cb = sizeof(s);
1781
1782    result = CreateProcess(NULL, file, NULL, NULL, FALSE, 0, NULL, NULL, 
1783                           &s, &proc);
1784    if (!result) {
1785       fprintf(stderr, "Couldn't create %s - Error %d\n", file, GetLastError());
1786       return false;
1787    }
1788
1789    WaitForSingleObject(proc.hProcess, INFINITE);
1790    CloseHandle(proc.hProcess);
1791    CloseHandle(proc.hThread);
1792    return true;
1793 }
1794
1795 void OS::unlink(char *file) {
1796    DeleteFile(file);
1797 }
1798
1799 #if !defined(TF_BIT)
1800 #define TF_BIT 0x100
1801 #endif
1802
1803 Address dyn_lwp::step_next_insn() {
1804    CONTEXT context;
1805    BOOL result;
1806
1807    singleStepping = true;
1808    context.ContextFlags = CONTEXT_FULL;
1809    result = GetThreadContext((HANDLE)get_fd(), &context);
1810    if(!result) {
1811       fprintf(stderr, "[%s:%u - step_next_insn] - Couldn't get thread context ", 
1812               __FILE__, __LINE__);
1813       return (Address) -1;
1814    }
1815
1816    context.ContextFlags = CONTEXT_FULL;
1817    context.EFlags |= TF_BIT ;
1818    if(!SetThreadContext((HANDLE)get_fd(), &context))
1819    if(!result) {
1820       fprintf(stderr, "[%s:%u - step_next_insn] - Couldn't set thread context ", 
1821               __FILE__, __LINE__);
1822       return (Address) -1;
1823    }
1824    
1825    continueLWP();
1826
1827    do {
1828       if(proc()->hasExited()) 
1829          return (Address) -1;
1830       proc()->sh->waitForEvent(evtDebugStep);
1831    } while (singleStepping);
1832
1833    return getActiveFrame().getPC();
1834 }
1835
1836 #if defined (cap_dynamic_heap)
1837 void process::inferiorMallocConstraints(Address near, Address &lo, Address &hi,
1838                                         inferiorHeapType /* type */ ) 
1839 {
1840 }
1841 #endif
1842
1843 /**
1844  stdcall:
1845    * C Naming - Name prefixed by a '_', followed by the name, then an '@',
1846      followed by number of bytes in arguments.  
1847      i.e. foo(int a, double b) = _foo@12
1848    * C++ Naming - __stdcall
1849    * Args - Arguments are passed on the stack.
1850    * Cleanup - Callee cleans up the stack before returning
1851  cdecl:
1852    * C Naming - Name prefixed by a '_'
1853    * C++ Naming - __cdecl in demangled name
1854    * Args - Arguments are passed on the stack.
1855    * Cleanup - Caller cleans up the stack after the return
1856  fastcall:
1857    * C Naming - Name prefixed by a '@', followed by the func name, then 
1858      another '@', followed by the number of bytes in the arguments.  i.e.
1859      foo(double a, int b, int c, int d) = @foo@20
1860    * C++ Naming - __fastcall in the mangled name
1861    * Args - First two arguments that are less than DWORD size are passed in ECX & EDX
1862    * Cleanup - Callee cleans up the stack before returning
1863  thiscall:
1864    * C Naming - NA
1865    * C++ Naming - __thiscall in the demangled name
1866    * 'this' parameter is passed in ECX, others are passed in the stack
1867    * Cleanup Callee cleans up the stack before returning
1868  **/
1869 callType int_function::getCallingConvention() {
1870     const char *name = symTabName().c_str();
1871     const int buffer_size = 1024;
1872     char buffer[buffer_size];
1873     const char *pos;
1874
1875     if (callingConv != unknown_call)
1876         return callingConv;
1877
1878     if (!name) {
1879         //Umm...
1880         return unknown_call;
1881     }
1882
1883     switch(name[0]) {
1884         case '?':
1885             //C++ Encoded symbol. Everything is stored in the C++ name 
1886             // mangling scheme
1887             UnDecorateSymbolName(name, buffer, buffer_size, 
1888                 UNDNAME_NO_ARGUMENTS | UNDNAME_NO_FUNCTION_RETURNS);
1889             if (strstr(buffer, "__thiscall")) {
1890                 callingConv = thiscall_call;
1891                 return callingConv;
1892             }
1893             if (strstr(buffer, "__fastcall")) {
1894                 callingConv = fastcall_call;
1895                 return callingConv;
1896             }
1897             if (strstr(buffer, "__stdcall")) {
1898                 callingConv = stdcall_call;
1899                 return callingConv;
1900             }
1901             if (strstr(buffer, "__cdecl")) {
1902                 callingConv = cdecl_call;
1903                 return callingConv;
1904             }
1905             break;
1906         case '_':
1907           //Check for stdcall or cdecl
1908           pos = strrchr(name, '@');
1909           if (pos) {
1910             callingConv = stdcall_call;
1911             return callingConv;
1912           }
1913           else {
1914             callingConv = cdecl_call;
1915             return callingConv;
1916           }
1917           break;
1918         case '@':
1919           //Should be a fast call
1920           pos = strrchr(name, '@');
1921           if (pos) {
1922              callingConv = fastcall_call;
1923              return callingConv;
1924           }
1925           break;
1926     }
1927
1928     //We have no idea what this call is.  We probably got an undecorated
1929     // name.  If the function doesn't clean up it's own stack (doesn't 
1930     // have a ret #) instruction, then it must be a cdecl call, as that's
1931     // the only type that doesn't clean its own stack.
1932     //If the function is part of a class, then it's most likely a thiscall,
1933     // although that could be incorrect for a static function.  
1934     //Otherwise let's guess that it's a stdcall.
1935     if (!ifunc()->cleansOwnStack()) {
1936         callingConv = cdecl_call;
1937     }
1938     else if (strstr(name, "::")) {
1939         callingConv = thiscall_call;
1940     }
1941     else {
1942         callingConv = stdcall_call;
1943     }
1944     return callingConv;
1945 }
1946
1947 static void emitNeededCallSaves(codeGen &gen, Register reg, pdvector<Register> &extra_saves);
1948 static void emitNeededCallRestores(codeGen &gen, pdvector<Register> &saves);
1949
1950 int EmitterIA32::emitCallParams(codeGen &gen, 
1951                               const pdvector<AstNodePtr> &operands,
1952                               int_function *target, 
1953                               pdvector<Register> &extra_saves, 
1954                               bool noCost)
1955 {
1956     callType call_conven = target->getCallingConvention();
1957     int estimatedFrameSize = 0;
1958     pdvector <Register> srcs;
1959     Register ecx_target = REG_NULL, edx_target = REG_NULL;
1960     Address unused = ADDR_NULL;
1961     const int num_operands = operands.size();
1962
1963     switch (call_conven) {
1964         case unknown_call:
1965         case cdecl_call:
1966         case stdcall_call:
1967           //Push all registers onto stack
1968           for (unsigned u = 0; u < operands.size(); u++) {
1969               Register src = REG_NULL;
1970               Address unused = ADDR_NULL;
1971               if (!operands[u]->generateCode_phase2( gen, false, unused, src)) assert(0);
1972               assert(src != REG_NULL);
1973               srcs.push_back(src);
1974           }
1975           break;
1976     case thiscall_call:
1977         //Allocate the ecx register for the 'this' parameter
1978         if (num_operands) {
1979             //result = gen.rs()->allocateSpecificRegister(gen, REGNUM_ECX, false);
1980             //if (!result) {
1981             //    emitNeededCallSaves(gen, REGNUM_ECX, extra_saves);
1982             //}
1983             if (!operands[0]->generateCode_phase2(gen, 
1984                                                   noCost, 
1985                                                   unused, ecx_target)) assert(0);
1986         }
1987         srcs.push_back(Null_Register);
1988         //Push other registers onto the stack
1989         for (unsigned u = 1; u < operands.size(); u++) {
1990               Register src = REG_NULL;
1991               Address unused = ADDR_NULL;
1992               if (!operands[u]->generateCode_phase2( gen, false, unused, src)) assert(0);
1993               assert(src != REG_NULL);
1994               srcs.push_back(src);
1995         }     
1996         break;
1997     case fastcall_call:
1998         if (num_operands) {
1999             //Allocate the ecx register for the first parameter
2000             //ecx_target = gen.rs()->allocateSpecificRegister(gen, REGNUM_ECX, false);
2001             //if (!ecx_target) {
2002             //    emitNeededCallSaves(gen, REGNUM_ECX, extra_saves);
2003             //}
2004         }
2005         if (num_operands > 1) {
2006             //Allocate the edx register for the second parameter
2007             //edx_target = gen.rs()->allocateSpecificRegister(gen, REGNUM_EDX, false);
2008             //if (!edx_target) {
2009             //    emitNeededCallSaves(gen, REGNUM_EDX, extra_saves);
2010             //}
2011         }
2012         if (num_operands) {
2013             if (!operands[0]->generateCode_phase2(gen, 
2014                                                   noCost, 
2015                                                   unused, ecx_target)) assert(0);
2016         }
2017         if (num_operands > 1) {
2018             if (!operands[1]->generateCode_phase2(gen, 
2019                                                   noCost, unused, edx_target)) assert(0);
2020         }
2021         srcs.push_back(Null_Register);
2022         srcs.push_back(Null_Register);
2023
2024         //Push other registers onto the stack
2025         for (unsigned u = 2; u < operands.size(); u++) {
2026               Register src = REG_NULL;
2027               Address unused = ADDR_NULL;
2028               if (!operands[u]->generateCode_phase2( gen, false, unused, src)) assert(0);
2029               assert(src != REG_NULL);
2030               srcs.push_back(src);
2031         }
2032         break;
2033     default:
2034         fprintf(stderr, "Internal error.  Unknown calling convention\n");
2035         assert(0);
2036     }
2037
2038     // push arguments in reverse order, last argument first
2039     // must use int instead of unsigned to avoid nasty underflow problem:
2040     for (int i=srcs.size() - 1; i >= 0; i--) {
2041        if (srcs[i] == Null_Register) continue;
2042            RealRegister r = gen.rs()->loadVirtual(srcs[i], gen);
2043            ::emitPush(r, gen);
2044        estimatedFrameSize += 4;
2045        if (operands[i]->decRefCount())
2046           gen.rs()->freeRegister(srcs[i]);
2047     }
2048
2049     if (ecx_target != REG_NULL) {
2050         //Store the parameter in ecx
2051                 gen.rs()->loadVirtualToSpecific(ecx_target, RealRegister(REGNUM_ECX), gen);
2052     }
2053
2054     if (edx_target != REG_NULL) {
2055                 gen.rs()->loadVirtualToSpecific(edx_target, RealRegister(REGNUM_EDX), gen);
2056     }
2057     return estimatedFrameSize;
2058 }
2059
2060 bool EmitterIA32::emitCallCleanup(codeGen &gen, int_function *target, 
2061                      int frame_size, pdvector<Register> &extra_saves)
2062 {
2063     callType call_conv = target->getCallingConvention();
2064     if ((call_conv == unknown_call || call_conv == cdecl_call) && frame_size)
2065     {
2066         //Caller clean-up
2067         emitOpRegImm(0, RealRegister(REGNUM_ESP), frame_size, gen); // add esp, frame_size        
2068     }
2069     gen.rs()->incStack(-1 * frame_size);
2070
2071     //Restore extra registers we may have saved when storing parameters in
2072     // specific registers
2073     //emitNeededCallRestores(gen, extra_saves);
2074     return 0;
2075 }
2076
2077 static void emitNeededCallSaves(codeGen &gen, Register regi, 
2078                            pdvector<Register> &extra_saves)
2079 {
2080     extra_saves.push_back(regi);
2081     switch (regi) {
2082         case REGNUM_EAX:
2083             emitSimpleInsn(PUSHEAX, gen);
2084             break;
2085         case REGNUM_EBX:
2086             emitSimpleInsn(PUSHEBX, gen);
2087             break;
2088         case REGNUM_ECX:
2089             emitSimpleInsn(PUSHECX, gen);
2090             break;
2091         case REGNUM_EDX:
2092             emitSimpleInsn(PUSHEDX, gen);
2093             break;
2094         case REGNUM_EDI:
2095             emitSimpleInsn(PUSHEDI, gen);
2096             break;
2097     }
2098 }
2099
2100 static void emitNeededCallRestores(codeGen &gen, pdvector<Register> &saves)
2101 {
2102     for (unsigned i=0; i<saves.size(); i++) {
2103       switch (saves[i]) {
2104           case REGNUM_EAX:
2105               emitSimpleInsn(POP_EAX, gen);
2106               break;
2107           case REGNUM_EBX:
2108               emitSimpleInsn(POP_EBX, gen);
2109               break;
2110           case REGNUM_ECX:
2111               emitSimpleInsn(POP_ECX, gen);
2112               break;
2113           case REGNUM_EDX:
2114               emitSimpleInsn(POP_EDX, gen);
2115               break;
2116           case REGNUM_EDI:
2117               emitSimpleInsn(POP_EDI, gen);
2118               break;
2119       }
2120     }
2121     saves.clear();
2122 }
2123
2124 bool SignalHandler::handleProcessExitPlat(EventRecord &ev, bool &continueHint) 
2125 {
2126     ReleaseSymbolHandler(ev.proc->processHandle_);
2127     continueHint = false;
2128     ev.proc->continueHandles.push_back(ev.info.dwThreadId);
2129     ev.proc->continueTypes.push_back(DBG_CONTINUE);
2130     return true;
2131 }
2132
2133 bool process::continueProc_(int sig) {
2134     unsigned index;
2135     dyn_lwp *lwp;
2136     if (representativeLWP) {
2137         representativeLWP->continueLWP(true);
2138     }
2139     dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
2140     while (lwp_iter.next(index, lwp)) {
2141         lwp->continueLWP(true);
2142     }
2143     return true;
2144 }
2145
2146 bool process::stop_(bool waitUntilStop) {
2147    unsigned index;
2148    dyn_lwp *lwp;
2149    if (representativeLWP) {
2150        representativeLWP->pauseLWP(true);
2151    }
2152    dictionary_hash_iter<unsigned, dyn_lwp *> lwp_iter(real_lwps);
2153    while (lwp_iter.next(index, lwp)) {
2154        lwp->pauseLWP(true);
2155    }
2156    return true;
2157 }
2158
2159 void process::deleteThread_(dyn_thread *thr) {
2160     int hand = thr->get_tid();
2161     int contType = DBG_CONTINUE;
2162
2163     continueHandles.push_back(hand);
2164     continueTypes.push_back(contType);
2165 }
2166
2167 bool SignalGeneratorCommon::postSignalHandler() {
2168     for (unsigned i=0; i<proc->continueHandles.size(); i++) {
2169         ContinueDebugEvent(proc->getPid(), proc->continueHandles[i], proc->continueTypes[i]);
2170     }
2171     proc->continueHandles.clear();
2172     proc->continueTypes.clear();
2173     return true;
2174 }
2175
2176 bool SignalHandler::forwardSigToProcess(EventRecord &ev, bool &continueHint) 
2177 {
2178    process *proc = ev.proc;
2179    int hand = (int) ev.info.dwThreadId;
2180
2181    proc->continueHandles.push_back(hand);
2182    proc->continueTypes.push_back(DBG_EXCEPTION_NOT_HANDLED);
2183    
2184    if (getExecThreadID() != sg->getThreadID()) {
2185       signal_printf("%s[%d][%s]:  signalling active process\n", 
2186                     FILE__, __LINE__, getThreadStr(getExecThreadID()));
2187       sg->requested_wait_until_active = false;
2188       sg->signalActiveProcess();
2189    }
2190    return true;
2191 }
2192
2193 bool SignalHandler::handleSignalHandlerCallback(EventRecord &ev)
2194 {
2195     process *proc = ev.proc;
2196     pdvector<CallbackBase *> cbs;
2197     if (!getCBManager()->dispenseCallbacksMatching(evtSignalHandlerCB, cbs)) {
2198         return false;
2199     }
2200     printf("Handling exception, excCode=0x%X\n",ev.what);
2201     Address tibPtr = ev.lwp->getThreadInfoBlockAddr();
2202     struct EXCEPTION_REGISTRATION handler;
2203     EXCEPTION_REGISTRATION *prevEvtReg=NULL;
2204     if (!proc->readDataSpace((void*)tibPtr,sizeof(Address),
2205                              (void*)&prevEvtReg,false)) {
2206         fprintf(stderr, "%s[%d]Error reading from TIB at 0x%x\n", 
2207                 FILE__, __LINE__,tibPtr);
2208         return false;
2209     }
2210     BPatch_Vector<Address> handlers;
2211     while(((long)prevEvtReg) != -1 && prevEvtReg != NULL) {
2212         if (!proc->readDataSpace((void*)prevEvtReg,sizeof(handler),
2213                                  &handler,false)) {
2214             fprintf(stderr, "%s[%d]Error reading from SEH chain at 0x%lx\n", 
2215                     FILE__, __LINE__,(long)prevEvtReg);
2216             return false;
2217         }
2218         prevEvtReg = handler.prev;
2219         if (!proc->findOrigByAddr((Address)prevEvtReg) &&
2220             !proc->findModByAddr((Address)prevEvtReg)) {
2221             signal_printf("EUREKA! Found handler at 0x%x while handling "
2222                    "exceptionCode=0x%X ... %s[%d]\n",
2223                    handler.handler, ev.what, FILE__,__LINE__);
2224             handlers.push_back(handler.handler);
2225         }
2226     }
2227     if (handlers.size() > 0) {
2228         // create instPoint at faulting instruction & trigger callback
2229         int_function *func = proc->findFuncByAddr(ev.address);
2230         instPoint *point = instPoint::createArbitraryInstPoint
2231             (ev.address, proc, func);
2232         if (!func || !point) {
2233             return false;
2234         }
2235         // cause callbacks registered for this event to be triggered, if any.
2236         if (((BPatch_process*)proc->up_ptr())->triggerSignalHandlerCB
2237             (point, func, ev.what, &handlers)) {
2238             return true;
2239         }
2240     }
2241     return true;
2242 }
2243
2244 SignalGenerator::SignalGenerator(char *idstr, std::string file, int pid)
2245     : SignalGeneratorCommon(idstr)
2246 {
2247     setupAttached(file, pid);
2248
2249
2250 void EventRecord::clear() {
2251     proc = NULL;
2252     lwp = NULL;
2253     type = evtUndefined;
2254     what = 0;
2255     status = statusUnknown;
2256     info.dwDebugEventCode = 0;
2257     info.dwProcessId = 0;
2258     info.dwThreadId = 0;
2259     address = 0;
2260     fd = 0;
2261 }
2262
2263 // Unix functions that aren't needed on Windows
2264 void DBICallbackBase::dbi_signalCompletion(CallbackBase *cbb) {}
2265 bool DBICallbackBase::execute() { return false; }
2266 bool DBICallbackBase::waitForCompletion() { return false; }
2267 bool PtraceCallback::execute_real() {return false;}
2268 bool ReadDataSpaceCallback::execute_real() {return false;}
2269 bool WaitPidNoBlockCallback::execute_real() {return false;}
2270 bool WriteDataSpaceCallback::execute_real() {return false;}
2271
2272 bool OS::executableExists(const std::string &file) {
2273    struct stat file_stat;
2274    int stat_result;
2275
2276    stat_result = stat(file.c_str(), &file_stat);
2277    if (stat_result == -1)
2278        stat_result = stat((file + std::string(".exe")).c_str(), &file_stat);
2279    return (stat_result != -1);
2280 }
2281
2282 int_function *dyn_thread::map_initial_func(int_function *ifunc) {
2283     if (!ifunc || strcmp(ifunc->prettyName().c_str(), "mainCRTStartup"))
2284         return ifunc;
2285
2286     //mainCRTStartup is not a real initial function.  Use main, if it exists.
2287     const pdvector<int_function *> *mains = proc->getAOut()->findFuncVectorByPretty("main");
2288     if (!mains || !mains->size())
2289         return ifunc;
2290     return (*mains)[0];
2291 }
2292
2293 bool process::instrumentThreadInitialFunc(int_function *f) {
2294     if (!f)
2295         return false;
2296
2297     for (unsigned i=0; i<initial_thread_functions.size(); i++) {
2298                 if (initial_thread_functions[i] == f) {
2299             return true;
2300     }
2301     }
2302     int_function *dummy_create = findOnlyOneFunction("DYNINST_dummy_create");
2303     if (!dummy_create)
2304     {
2305       return false;
2306     } 
2307
2308     pdvector<AstNodePtr> args;
2309     AstNodePtr call_dummy_create = AstNode::funcCallNode(dummy_create, args);
2310     const pdvector<instPoint *> &ips = f->funcEntries();
2311     for (unsigned j=0; j<ips.size(); j++)
2312     {
2313        miniTramp *mt;
2314        mt = ips[j]->instrument(call_dummy_create, callPreInsn, orderFirstAtPoint, false, 
2315                                false);
2316        if (!mt)
2317        {
2318           fprintf(stderr, "[%s:%d] - Couldn't instrument thread_create\n",
2319                   __FILE__, __LINE__);
2320        }
2321     }
2322     initial_thread_functions.push_back(f);
2323     return true;
2324 }
2325
2326 bool SignalHandler::handleProcessAttach(EventRecord &ev, bool &continueHint) {
2327     process *proc = ev.proc;
2328     proc->setBootstrapState(initialized_bs);
2329     
2330     dyn_lwp *rep_lwp = proc->getRepresentativeLWP();
2331     assert(rep_lwp);
2332
2333     //We're starting up, convert the representative lwp to a real one.
2334     rep_lwp->set_lwp_id((int) rep_lwp->get_fd());
2335     proc->real_lwps[rep_lwp->get_lwp_id()] = rep_lwp;
2336     proc->representativeLWP = NULL;
2337     if (proc->theRpcMgr)
2338        proc->theRpcMgr->addLWP(rep_lwp);
2339     continueHint = true;
2340
2341         ev.lwp->setDebuggerLWP(true);
2342     return true;
2343 }
2344
2345 bool process::hasPassedMain() 
2346 {
2347    return true;
2348 }
2349
2350 Address dyn_lwp::getThreadInfoBlockAddr()
2351 {
2352     if (threadInfoBlockAddr_) {
2353         return threadInfoBlockAddr_;
2354     }
2355     // use getRegisters to get value of the FS segment register
2356     dyn_saved_regs regs;
2357     if (!getRegisters(&regs)) {
2358         return 0;
2359     }
2360     // use the FS segment selector to look up the segment descriptor in the local descriptor table
2361     LDT_ENTRY segDesc;
2362         if (!GetThreadSelectorEntry(fd_, (DWORD)regs.cont.SegFs, &segDesc)) {
2363                 fprintf(stderr, "%s[%d] Failed to read segment register FS for thread 0x%x with FS index of 0x%x\n", 
2364                         FILE__,__LINE__,fd_,regs.cont.SegFs);
2365                 return 0;
2366         }
2367     // calculate the address of the TIB
2368     threadInfoBlockAddr_ = (Address) segDesc.BaseLow;
2369     Address tmp = (Address) segDesc.HighWord.Bytes.BaseMid;
2370     threadInfoBlockAddr_ = threadInfoBlockAddr_ | (tmp << (sizeof(WORD)*8));
2371     tmp = segDesc.HighWord.Bytes.BaseHi;
2372     threadInfoBlockAddr_ = threadInfoBlockAddr_ | (tmp << (sizeof(WORD)*8+8));
2373     return threadInfoBlockAddr_;
2374 }
2375
2376 bool process::setBeingDebuggedFlag(bool debuggerPresent) 
2377 {
2378     dyn_lwp *lwp = getInitialLwp();
2379     if (!lwp) {
2380         return false;
2381     }
2382     Address tibPtr = lwp->getThreadInfoBlockAddr();
2383     if (!tibPtr) {
2384         return false;
2385     }
2386     // read in address of PEB
2387     unsigned int pebPtr;
2388     if (!readDataSpace((void*)(tibPtr+48), getAddressWidth(),(void*)&pebPtr, false)) {
2389                 fprintf(stderr, "%s[%d] Failed to read address of Process Environment "
2390                         "Block at 0x%x, which is TIB + 0x30\n", FILE__,__LINE__,tibPtr+48);
2391         return false;
2392         }
2393     // read in processBeingDebugged flag
2394     unsigned int flagWord;
2395     if (!readDataSpace((void*)pebPtr, 4, (void*)&flagWord, true)) 
2396         return false;
2397     // write back value of processBeingDebugged, if necessary
2398     if (debuggerPresent && !(flagWord & 0x00ff0000)) {
2399         flagWord = flagWord | 0x00010000;
2400         if (!writeDataSpace((void*)pebPtr, 4, (void*)&flagWord)) 
2401             return false;
2402     } else if (!debuggerPresent && (flagWord & 0x00ff0000)) {
2403         flagWord = flagWord & 0xff00ffff;
2404         if (writeDataSpace((void*)pebPtr, 4, (void*)&flagWord)) 
2405             return false;
2406     }
2407     return true;
2408 }
2409
2410 bool process::startDebugger()
2411 {
2412    return false;
2413 }