Moving files to dyninstAPI directory - naim
[dyninst.git] / paradynd / src / process.h
1 /*
2  * Copyright (c) 1996 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 /*
43  * process.h - interface to manage a process in execution. A process is a kernel
44  *   visible unit with a seperate code and data space.  It might not be
45  *   the only unit running the code, but it is only one changed when
46  *   ptrace updates are applied to the text space.
47  *
48  */
49
50 #ifndef PROCESS_H
51 #define PROCESS_H
52
53 #include <stdio.h>
54 #include "rtinst/h/rtinst.h"
55 #include "util.h"
56 #include "util/h/String.h"
57 #include "util/h/vectorSet.h"
58 #include "util/h/Dictionary.h"
59 #include "util/h/Types.h"
60 #include "util/h/Timer.h"
61 #include "ast.h"
62 #include "os.h"
63 #include "main.h"
64 #include "dyninstRPC.xdr.h"
65 #include "showerror.h"
66
67 #include "symtab.h" // internalSym
68
69 #ifdef SHM_SAMPLING
70 #include "fastInferiorHeapMgr.h"
71 #include "fastInferiorHeap.h"
72 #include "fastInferiorHeapHKs.h"
73 #ifdef sparc_sun_sunos4_1_3
74 #include <kvm.h>
75 #include <sys/user.h>
76 #endif
77 #endif
78
79 #include "sharedobject.h"
80 #include "dynamiclinking.h"
81
82 extern unsigned activeProcesses; // number of active processes
83    // how about just processVec.size() instead?  At least, this should be made
84    // a (static) member vrble of class process
85
86 class resource;
87 class instPoint;
88 class instInstance;
89 class trampTemplate;
90
91 // TODO a kludge - to prevent recursive includes
92 class image;
93
94 typedef enum { neonatal, running, stopped, exited } processState;
95 typedef enum { HEAPfree, HEAPallocated } heapStatus;
96 typedef enum { textHeap=0, dataHeap=1 } inferiorHeapType;
97 typedef vector<unsigned> unsigVecType;
98
99 class heapItem {
100  public:
101   heapItem() {
102     addr =0; length = 0; status = HEAPfree;
103   }
104   heapItem(const heapItem *h) {
105     addr = h->addr; length = h->length; status = h->status;
106   }
107   Address addr;
108   int length;
109   heapStatus status;
110 };
111
112 //
113 // an item on the heap that we are trying to free.
114 //
115 class disabledItem {
116  public:
117   disabledItem() { pointer = 0; }
118   disabledItem(unsigned iPointer, inferiorHeapType iHeapType, const vector<unsigVecType> &iPoints) : pointsToCheck(iPoints) {
119      pointer = iPointer;
120      whichHeap = iHeapType;
121   }
122   disabledItem(const disabledItem &src) : pointsToCheck(src.pointsToCheck) {
123     pointer = src.pointer; 
124     whichHeap = src.whichHeap;
125   }
126  ~disabledItem() {}
127   disabledItem &operator=(const disabledItem &src) {
128      if (&src == this) return *this; // the usual check for x=x
129
130      pointer = src.pointer;
131      whichHeap = src.whichHeap;
132      pointsToCheck = src.pointsToCheck;
133      return *this;
134   }
135   
136   unsigned getPointer() const {return pointer;}
137   inferiorHeapType getHeapType() const {return whichHeap;}
138   const vector<unsigVecType> &getPointsToCheck() const {return pointsToCheck;}
139   vector<unsigVecType> &getPointsToCheck() {return pointsToCheck;}
140
141  private:
142   unsigned pointer;                     // address in heap
143   inferiorHeapType whichHeap;           // which heap is it in
144   vector<unsigVecType> pointsToCheck;   // range of addrs to check
145 };
146
147
148 class inferiorHeap {
149  public:
150   inferiorHeap(): heapActive(addrHash16) {
151       freed = 0; disabledListTotalMem = 0; totalFreeMemAvailable = 0;
152   }
153   inferiorHeap(const inferiorHeap &src);  // create a new heap that is a copy of src.
154                                           // used on fork.
155   dictionary_hash<unsigned, heapItem*> heapActive; // active part of heap 
156   vector<heapItem*> heapFree;           // free block of data inferior heap 
157   vector<disabledItem> disabledList;    // items waiting to be freed.
158   int disabledListTotalMem;             // total size of item waiting to free
159   int totalFreeMemAvailable;            // total free memory in the heap
160   int freed;                            // total reclaimed (over time)
161 };
162
163
164 static inline unsigned ipHash(instPoint * const &ip)
165 {
166   // assume all addresses are 4-byte aligned
167   unsigned result = (unsigned)ip;
168   result >>= 2;
169   return result;
170   // how about %'ing by a huge prime number?  Nah, x % y == x when x < y 
171   // so we don't want the number to be huge.
172 }
173
174
175 static inline unsigned instInstanceHash(instInstance * const &inst) {
176    unsigned result = (unsigned)inst;
177    result >>= 2;
178    return result; // how about %'ing by a huge prime number?
179 //  return ((unsigned)inst);
180 }
181
182 class Thread;
183 class Frame;
184
185 class process {
186  friend class ptraceKludge;
187
188  public:
189   process(int iPid, image *iImage, int iTraceLink, int iIoLink
190 #ifdef SHM_SAMPLING
191           , key_t theShmSegKey,
192           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
193 #endif
194           );
195      // this is the "normal" ctor
196
197   process(int iPid, image *iSymbols,
198           int afterAttach // 1 --> pause, 2 --> run, 0 --> leave as is
199 #ifdef SHM_SAMPLING
200           , key_t theShmSegKey,
201           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
202 #endif
203           );
204      // this is the "attach" ctor
205
206   process(const process &parentProc, int iPid, int iTrace_fd
207 #ifdef SHM_SAMPLING
208           , key_t theShmSegKey,
209           void *applShmSegPtr,
210           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
211 #endif
212           );
213      // this is the "fork" ctor
214
215 #ifdef SHM_SAMPLING
216   void registerInferiorAttachedSegs(void *inferiorAttachedAtPtr);
217      // Where the inferior attached was left undefined in the constructor;
218      // this routine fills it in (tells paradynd where, in the inferior proc's addr
219      // space, the shm seg was attached.  The attaching was done in DYNINSTinit)
220 #endif
221
222   vector<Address> walkStack(bool noPause=false);
223
224   // 
225   // getActiveFrame and readDataFromFrame are platform dependant
226   //
227   bool getActiveFrame(int *fp, int *pc);
228   bool readDataFromFrame(int currentFP, int *previousFP, int *rtn, 
229                          bool uppermost=false);
230
231
232 #ifdef SHM_SAMPLING
233   unsigned long long getInferiorProcessCPUtime() const;
234      // returns user+sys time from the u or proc area of the inferior process, which in
235      // turn is presumably obtained by mmapping it (sunos) or by using a /proc ioctl
236      // to obtain it (solaris).  It is hoped that the implementation would not have to
237      // pause the inferior process (and then unpause it) in order to obtain the result,
238      // since pausing and unpausing are extremely slow (I've seen ~70ms).
239 #endif
240
241   processState status() const { return status_;}
242   string getStatusAsString() const; // useful for debug printing etc.
243
244   void continueAfterNextStop() { continueAfterNextStop_ = true; }
245   void Exited();
246   void Stopped();
247
248   // the following 2 vrbles probably belong in a different class:
249   static string programName; // the name of paradynd (more specifically, its argv[0])
250   static vector<string> arg_list; // the arguments of paradynd
251
252   internalSym *findInternalSymbol(const string &name, bool warn) {
253      assert(symbols);
254      return symbols->findInternalSymbol(name, warn);
255   }
256   Address findInternalAddress(const string &name, bool warn, bool &err) const {
257      assert(symbols);
258      return symbols->findInternalAddress(name, warn, err);
259   }
260
261   bool dumpImage();
262
263   bool symbol_info(const string &name, Symbol &ret) {
264      assert(symbols);
265      return symbols->symbol_info(name, ret);
266   }
267   image *getImage() const {
268      assert(symbols);
269      return symbols;
270   }
271
272  private:
273   struct inferiorRPCtoDo {
274      // This structure keeps track of an inferiorRPC that we will start sometime
275      // in the (presumably near) future.  There is a different structure for RPCs
276      // which have been launched and which we're waiting to finish.  Don't confuse
277      // the two.
278
279      AstNode *action;
280      bool noCost; // if true, cost model isn't updated by generated code.
281      void (*callbackFunc)(process *, void *userData, unsigned result);
282      void *userData;
283   };
284   vectorSet<inferiorRPCtoDo> RPCsWaitingToStart;
285
286   struct inferiorRPCinProgress {
287      // This structure keeps track of an inferiorRPC that has been launched and
288      // for which we're waiting to complete.  Don't confuse with 'inferiorRPCtoDo',
289      // which is more of a wait queue of RPCs to start launching.
290      // Also note: It's only safe for 1 RPC to be in progress at a time.
291      // If you _really_ want to launch multiple RPCs at the same time, it's actually
292      // easy to do...just do one inferiorRPC with a sequenceNode AST! (neat, eh?)
293      // (Admittedly, that does confuse the semantics of callback functions.  So
294      // the official line remains: only 1 inferior RPC per process can be ongoing.)
295      void (*callbackFunc)(process *, void *userData, unsigned result);
296      void *userData;
297      
298      void *savedRegs; // crucial!
299
300      bool wasRunning; // were we running when we launched the inferiorRPC?
301
302      unsigned firstInstrAddr; // start location of temp tramp
303
304      unsigned stopForResultAddr;
305         // location of the TRAP or ILL which marks point where paradynd should grab the
306         // result register.  Undefined if no callback fn.
307      unsigned justAfter_stopForResultAddr; // undefined if no callback fn.
308      reg resultRegister; // undefined if no callback fn.
309
310      unsigned resultValue; // undefined until we stop-for-result, at which time we
311                            // fill this in.  The callback fn (which takes in this value)
312                            // isn't invoked until breakAddr (the final break)
313
314      unsigned breakAddr;
315         // location of the TRAP or ILL insn which marks the end of the inferiorRPC
316   };
317   vectorSet<inferiorRPCinProgress> currRunningRPCs;
318       // see para above for reason why this 'vector' can have at most 1 elem!
319
320  public:
321   bool deferredContinueProc;
322   void postRPCtoDo(AstNode *, bool noCost,
323                    void (*)(process *, void *, unsigned), void *);
324   bool existsRPCreadyToLaunch() const;
325   bool existsRPCinProgress() const;
326   bool launchRPCifAppropriate(bool wasRunning);
327      // returns true iff anything was launched.
328      // asynchronously launches iff RPCsWaitingToStart.size() > 0 AND
329      // if currRunningRPCs.size()==0 (the latter for safety)
330      // If we're gonna launch, then we'll stop the process (a necessity).
331      // Pass wasRunning as true iff you want the process  to continue after
332      // receiving the TRAP signifying completion of the RPC.
333
334   bool handleTrapIfDueToRPC();
335      // look for curr PC reg value in 'trapInstrAddr' of 'currRunningRPCs'.  Return
336      // true iff found.  Also, if true is being returned, then additionally does
337      // a 'launchRPCifAppropriate' to fire off the next waiting RPC, if any.
338
339  private:
340   // The follwing 5 routines are implemented in an arch-specific .C file
341   bool emitInferiorRPCheader(void *, unsigned &base);
342   bool emitInferiorRPCtrailer(void *, unsigned &base,
343                               unsigned &breakOffset,
344                               bool stopForResult,
345                               unsigned &stopForResultOffset,
346                               unsigned &justAfter_stopForResultOffset);
347
348   unsigned createRPCtempTramp(AstNode *action,
349                               bool noCost, bool careAboutResult,
350                               unsigned &breakAddr,
351                               unsigned &stopForResultAddr,
352                               unsigned &justAfter_stopForResultAddr,
353                               reg &resultReg);
354
355   // The parameter syscall is only used for hpux platform right now
356   // Can "syscall" be embedded into the opaque type?
357   void *getRegisters(bool &syscall);
358      // ptrace-GETREGS and ptrace-GETFPREGS.  Result is returned in an opaque type
359      // which is allocated with new[]
360
361   bool changePC(unsigned addr,
362                 const void *savedRegs // returned by getRegisters()
363                 );
364   bool changePC(unsigned addr);
365
366   bool restoreRegisters(void *buffer);
367      // input is the opaque type returned by getRegisters()
368
369   unsigned read_inferiorRPC_result_register(reg);
370
371  public:
372   void installBootstrapInst();
373   void installInstrRequests(const vector<instMapping*> &requests);
374  
375   // These member vrbles should be made private!
376   int traceLink;                /* pipe to transfer traces data over */
377   int ioLink;                   /* pipe to transfer stdout/stderr over */
378   processState status_;         /* running, stopped, etc. */
379   vector<Thread *> threads;     /* threads belonging to this process */
380   bool continueAfterNextStop_;
381   // on some platforms we use one heap for text and data so textHeapFree is not
382   // used.
383   bool splitHeaps;              /* are the inferior heap split I/D ? */
384   inferiorHeap  heaps[2];       /* the heaps text and data */
385   resource *rid;                /* handle to resource for this process */
386
387   /* map an inst point to its base tramp */
388   dictionary_hash<const instPoint*, trampTemplate *> baseMap;   
389
390   // the following 3 are used in perfStream.C
391   char buffer[2048];
392   unsigned bufStart;
393   unsigned bufEnd;
394
395   time64 wallTimeLastTrampSample;
396   time64 timeLastTrampSample;
397
398   bool reachedFirstBreak; // should be renamed 'reachedInitialTRAP'
399
400   int getPid() const { return pid;}
401
402   void initInferiorHeap(bool textHeap);
403      // true --> text heap, else data heap
404
405   bool writeDataSpace(void *inTracedProcess,
406                       int amount, const void *inSelf);
407   bool readDataSpace(const void *inTracedProcess, int amount,
408                      void *inSelf, bool displayErrMsg);
409
410   bool writeTextSpace(void *inTracedProcess, int amount, const void *inSelf);
411   bool writeTextWord(caddr_t inTracedProcess, int data);
412   bool continueProc();
413   bool pause();
414
415   bool dumpCore(const string coreFile);
416   bool detach(const bool paused); // why the param?
417   bool attach();
418   string getProcessStatus() const;
419
420   static string tryToFindExecutable(const string &progpath, int pid);
421       // os-specific implementation.  Returns empty string on failure.
422       // Otherwise, returns a full-path-name for the file.  Tries every
423       // trick to determine the full-path-name, even though "progpath" may
424       // be unspecified (empty string)
425
426   bool continueWithForwardSignal(int sig); // arch-specific implementation
427   
428   // forkProcess: this function should be called when a process we are tracing
429   // forks a child process.
430   // This function returns a new process object associated with the child.
431   // It also writes to "map" s.t. for each instInstance in the parent, we have the
432   // corresponding instInstance in the child.
433   static process *forkProcess(const process *parent, pid_t childPid,
434                               dictionary_hash<instInstance*,instInstance*> &map,
435                               int iTrace_fd
436 #ifdef SHM_SAMPLING
437                               ,key_t theKey,
438                               void *applAttachedAtPtr
439 #endif
440                               );
441
442   // get and set info. specifying if this is a dynamic executable
443   void setDynamicLinking(){ dynamiclinking = true;}
444   bool isDynamicallyLinked() { return (dynamiclinking); }
445
446   // handleStartProcess: this function is called when an appplication 
447   // starts executing.  It is used to insert instrumentation necessary
448   // to handle dynamic linking
449   static bool handleStartProcess(process *pid);
450
451   bool handleStopDueToExecEntry();
452
453   // getSharedObjects: This routine is called before main() to get and
454   // process all shared objects that have been mapped into the process's
455   // address space
456   bool getSharedObjects();
457
458   // addASharedObject: This routine is called whenever a new shared object
459   // has been loaded by the run-time linker after the process starts running
460   // It processes the image, creates new resources
461   bool addASharedObject(shared_object &);
462
463   // findOneFunction: returns the function associated with function "func"
464   // and module "mod".  This routine checks both the a.out image and any
465   // shared object images for this function
466   pdFunction *findOneFunction(resource *func,resource *mod);
467
468   // findOneFunction: returns the function associated with function "func_name"
469   // This routine checks both the a.out image and any shared object images 
470   // for this function
471   pdFunction *findOneFunction(const string &func_name);
472
473   // findFunctionIn: returns the function which contains this address
474   // This routine checks both the a.out image and any shared object images 
475   // for this function
476   pdFunction *findFunctionIn(Address adr);
477
478   // findModule: returns the module associated with "mod_name" 
479   // this routine checks both the a.out image and any shared object 
480   // images for this module
481   module *findModule(const string &mod_name);
482
483   // getSymbolInfo:  get symbol info of symbol associated with name n
484   // this routine starts looking a.out for symbol and then in shared objects
485   bool getSymbolInfo(string &n, Symbol &info);
486
487   // getAllFunctions: returns a vector of all functions defined in the
488   // a.out and in the shared objects
489   vector<pdFunction *> *getAllFunctions();
490
491   // getAllModules: returns a vector of all modules defined in the
492   // a.out and in the shared objects
493   vector<module *> *getAllModules();
494
495   // getIncludedFunctions: returns a vector of all functions defined in the
496   // a.out and in shared objects that are not excluded by an mdl option 
497   vector<pdFunction *> *getIncludedFunctions();
498
499   // getIncludedModules: returns a vector of all functions defined in the
500   // a.out and in shared objects that are  not excluded by an mdl option
501   vector<module *> *getIncludedModules();
502
503   // getBaseAddress: sets baseAddress to the base address of the 
504   // image corresponding to which.  It returns true  if image is mapped
505   // in processes address space, otherwise it returns 0
506   bool getBaseAddress(const image *which, u_int &baseAddress);
507
508   // these routines are for testing, setting, and clearing the 
509   // waiting_for_resources flag, if this flag is true a process is not 
510   // started until all outstanding resourceInfoResponses have been received
511   void setWaitingForResources(){ waiting_for_resources = true; }
512   // called by perfStream.C on SIGSTOP if there are any
513   // resource::num_outstanding_creates,
514   // and process::handleStartProcess, also if there are any
515   // resource::num_outstanding_creates.
516   void clearWaitingForResources(){ waiting_for_resources = false; }
517   bool isWaitingForResources(){ return(waiting_for_resources); }
518
519   // findSignalHandler: if signal_handler is 0, then it checks all images
520   // associtated with this process for the signal handler function.
521   // Otherwise, the signal handler function has already been found
522   void findSignalHandler();
523
524   // continueProcessIfWaiting: if the waiting_for_resources flag
525   // is set then continue the process; in any event, clear that flag
526   void continueProcessIfWaiting(){
527       if(waiting_for_resources){
528           continueProc();
529       }
530       waiting_for_resources = false;
531   }
532
533   //  wasExeced: returns true is the process did an exec...this is set
534   //  in handleExec()
535   bool wasExeced(){ return execed_;}
536
537   void handleExec();
538   bool cleanUpInstrumentation(bool wasRunning); // called on exit (also exec?)
539   bool inExec;
540
541   string execFilePath;
542
543   int getProcFileDescriptor(){ return proc_fd;}
544
545   static int waitProcs(int *status);
546   const process *getParent() const {return parent;}
547
548 #if defined(hppa1_1_hp_hpux)
549   bool freeNotOK;
550 #endif
551
552 #ifdef SHM_SAMPLING
553   key_t getShmKeyUsed() const {return inferiorHeapMgr.getShmKey();}
554   bool doMajorShmSample(unsigned long long currWallTime);
555   bool doMinorShmSample();
556
557   const fastInferiorHeap<intCounterHK, intCounter> &getInferiorIntCounters() const {
558      return inferiorIntCounters;
559   }
560   const fastInferiorHeap<wallTimerHK, tTimer> &getInferiorWallTimers() const {
561      return inferiorWallTimers;
562   }
563   const fastInferiorHeap<processTimerHK, tTimer> &getInferiorProcessTimers() const {
564      return inferiorProcessTimers;
565   }
566
567   fastInferiorHeap<intCounterHK, intCounter> &getInferiorIntCounters() {
568      return inferiorIntCounters;
569   }
570   fastInferiorHeap<wallTimerHK, tTimer> &getInferiorWallTimers() {
571      return inferiorWallTimers;
572   }
573   fastInferiorHeap<processTimerHK, tTimer> &getInferiorProcessTimers() {
574      return inferiorProcessTimers;
575   }
576
577   unsigned getShmHeapTotalNumBytes() {
578      return inferiorHeapMgr.getHeapTotalNumBytes();
579   }
580
581   void *getObsCostLowAddrInApplicSpace() {
582      void *result = inferiorHeapMgr.getObsCostAddrInApplicSpace();
583      return result;
584   }
585   unsigned *getObsCostLowAddrInParadyndSpace() {
586      unsigned *result = inferiorHeapMgr.getObsCostAddrInParadyndSpace();
587      return result;
588   }
589   void processCost(unsigned obsCostLow,
590                    unsigned long long wallTime, unsigned long long processTime);
591
592
593 #ifdef sparc_sun_sunos4_1_3
594    static user *tryToMapChildUarea(int pid);
595 #endif
596
597 #endif /* shm_sampling */
598
599    bool isBootstrappedYet() const {
600       return hasBootstrapped;
601    }
602    bool extractBootstrapStruct(DYNINST_bootstrapStruct *);
603    int procStopFromDYNINSTinit();
604       // returns 0 if not processed, 1 for the usual processed case (process is
605       // now paused), or 2 for the processed-but-still-running-inferiorRPC case
606
607    void handleCompletionOfDYNINSTinit(bool fromAttach);
608       // called by above routine.  Reads bs_record from applic, takes action.
609
610    static void DYNINSTinitCompletionCallback(process *, void *, unsigned);
611       // inferiorRPC callback routine.
612
613 private:
614   // Since we don't define these, 'private' makes sure they're not used:
615   process(const process &); // copy ctor
616   process &operator=(const process &); // assign oper
617
618   bool hasBootstrapped;
619      // set to true when we get callback from inferiorRPC call to DYNINSTinit
620
621   const process *parent;        /* parent of this proces */
622   image *symbols;               /* information related to the process */
623   int pid;                      /* id of this process */
624
625 #ifdef SHM_SAMPLING
626   // New components of the conceptual "inferior heap"
627   fastInferiorHeapMgr inferiorHeapMgr;
628   fastInferiorHeap<intCounterHK, intCounter> inferiorIntCounters;
629   fastInferiorHeap<wallTimerHK, tTimer>      inferiorWallTimers;
630   fastInferiorHeap<processTimerHK, tTimer>   inferiorProcessTimers;
631
632 #ifdef sparc_sun_sunos4_1_3
633   kvm_t *kvmHandle;
634   user *childUareaPtr;
635 #endif
636
637 #endif
638
639 public:
640   trampTableEntry trampTable[TRAMPTABLESZ];
641   unsigned trampTableItems;
642
643   unsigned currentPC() {
644     int pc, fp;
645     if (hasNewPC)
646       return currentPC_;
647     else if (getActiveFrame(&fp, &pc)) {
648       currentPC_ = (unsigned) pc;
649       return currentPC_;
650     }
651     else abort();
652     return 0;
653   }
654   void setNewPC(unsigned newPC) {
655     currentPC_ = newPC;
656     hasNewPC = true;
657   }
658
659   inline int costAddr()  const { return costAddr_; }  // why an integer?
660   void getObservedCostAddr();   
661
662 private:
663   bool createdViaAttach;
664      // set in the ctor.  True iff this process was created with an attach,
665      // as opposed to being fired up by paradynd.  On fork, has the value of
666      // the parent process.  On exec, no change.
667      // This vrble is important because it tells us what to do when we exit.
668      // If we created via attach, we should (presumably) detach but not fry
669      // the application; otherwise, a kill(pid, 9) is called for.
670   // the following 2 are defined only if 'createdViaAttach' is true; action is taken
671   // on these vrbles once DYNINSTinit completes.
672
673   bool wasRunningWhenAttached;
674   bool needToContinueAfterDYNINSTinit;
675
676   unsigned currentPC_;
677   bool hasNewPC;
678
679   // for processing observed cost (see method processCost())
680   unsigned long long cumObsCost; // in cycles
681   unsigned lastObsCostLow; // in cycles
682
683   int costAddr_;  // why an integer?
684   bool execed_;  // true if this process does an exec...set in handleExec
685
686   // deal with system differences for ptrace
687   bool writeDataSpace_(void *inTracedProcess, int amount, const void *inSelf);
688   bool readDataSpace_(const void *inTracedProcess, int amount, void *inSelf);
689
690   bool writeTextWord_(caddr_t inTracedProcess, int data);
691   bool writeTextSpace_(void *inTracedProcess, int amount, const void *inSelf);
692   bool pause_();
693   bool continueProc_();
694   bool dumpCore_(const string coreFile);
695   bool detach_();
696   bool attach_(); // low-level attach; called by attach() (formerly OS::osAttach())
697   bool stop_(); // formerly OS::osStop
698
699   // stops a process
700   bool loopUntilStopped();
701
702   // returns true iff ok to do a ptrace; false (and prints a warning) if not
703   bool checkStatus();
704
705   int proc_fd; // file descriptor for platforms that use /proc file system.
706
707   dynamic_linking *dyn;   // platform specific dynamic linking routines & data
708
709   bool dynamiclinking;   // if true this a.out has a .dynamic section
710   vector<shared_object *> *shared_objects;  // list of dynamically linked libs
711
712   // The set of all functions and modules in the a.out and in the shared objects
713   vector<pdFunction *> *all_functions;
714   vector<module *> *all_modules;
715   // these are a restricted set of functions and modules which are those  
716   // from shared objects that are not excluded through an mdl "exclude_library"
717   // option: these are used to satisfy foci that are not refined on the
718   // Code heirarchy
719   vector<module *> *some_modules;  
720   vector<pdFunction *> *some_functions; 
721   bool waiting_for_resources;  // true if waiting for resourceInfoResponse
722   pdFunction *signal_handler;  // signal handler function (for stack walking)
723
724   // needToAddALeafFrame: returns true if the between the current frame 
725   // and the next frame there is a leaf function (this occurs when the 
726   // current frame is the signal handler)
727   bool needToAddALeafFrame(Frame current_frame, Address &leaf_pc);
728
729   bool isRunning_() const;
730      // needed to initialize the 'wasRunningWhenAttached' member vrble.  Determines
731      // whether the process is running by doing a low-level OS check, not by checking
732      // member vrbles like status_.  May assume that process::attach() has already run,
733      // but can't assume anything else.  May barf with a not-yet-implemented error on a
734      // given platform if the platform doesn't yet support attaching to a running process.
735      // But there's no reason why we shouldn't be able to implement this on any platform;
736      // after all, the output from the "ps" command can be used (T --> return false,
737      // S or R --> return true, other --> return ?)
738
739 #if defined(sparc_sun_solaris2_4) || defined(i386_unknown_solaris2_5)
740    // some very useful items gathered from /proc (initialized in attach() [solaris.C],
741    // as soon as /proc fd is opened)
742    string argv0; // argv[0] of program, at the time it started up
743    string pathenv; // path env var of program, at the time it started up
744    string cwdenv; // curr working directory of program, at the time it started up
745
746 //   string fullPathToExecutable_;
747       // very useful, especially on attach (need this to parse the symbol table)
748
749  public:
750    const string &getArgv0() const {return argv0;}
751    const string &getPathEnv() const {return pathenv;}
752    const string &getCwdEnv() const {return cwdenv;}
753 #endif
754 };
755
756 process *createProcess(const string file, vector<string> argv, vector<string> envp, const string dir);
757 bool attachProcess(const string &progpath, int pid, int afterAttach);
758
759 void handleProcessExit(process *p, int exitStatus);
760
761 unsigned inferiorMalloc(process *proc, int size, inferiorHeapType type);
762 void inferiorFree(process *proc, unsigned pointer, inferiorHeapType type,
763                   const vector<unsigVecType> &pointsToCheck);
764
765 extern resource *machineResource;
766
767 class Frame {
768   private:
769     int frame_;
770     int pc_;
771     bool uppermostFrame;
772
773   public:
774     Frame(process *);
775        // formerly getActiveStackFrameInfo
776
777     Frame(int theFrame, int thePc, bool theUppermost) {
778        frame_ = theFrame; pc_ = thePc;
779        uppermostFrame = theUppermost;
780     }
781
782     int getPC() const { return pc_; }
783     int getFramePtr(){ return frame_;}
784     bool isLastFrame() const { 
785         if ((pc_ == 0)||(frame_ == 0))
786             return(true);
787         else 
788             return(false); 
789     }
790
791     Frame getPreviousStackFrameInfo(process *proc) const;
792 };
793
794 extern vector<process *> processVec;
795
796 #define CT_BLOCK_SIZE 300
797
798 class CT {
799   public:
800     CT(process *pproc) : CTvectorAddr(0), CTvectorSize(0), CTmapTable(CThash) 
801     { 
802       proc = pproc; 
803     }
804     unsigned size() { return(CTvectorSize); }
805     bool update(unsigned tableAddr);
806     void add(unsigned CTid, unsigned &position); 
807     void remove(unsigned CTid, unsigned position);
808     void dup(unsigned CTid, unsigned mid, Thread *thr, unsigned &position);
809     unsigned getCTmapId(unsigned mid) 
810     {
811       assert(CTmapTable.defines(mid));
812       return(CTmapTable[mid]); 
813     }
814     unsigned getCTusagePos(unsigned position) {
815       assert(position < CTusage.size()); 
816       return(CTusage[position]); 
817     }
818   private:
819     unsigned CTvectorAddr;
820     unsigned CTvectorSize;
821     dictionary_hash<unsigned, unsigned> CTmapTable;
822     vector<int> CTusage;
823     vector<int> CTfree;
824     process *proc;
825 };
826
827 class Thread {
828   public:
829     // This definition must be completed later when we get the result of a call
830     // to thr_self in the application. We are assuming that 
831     // 0 <= thr_self,tid < MAX_NUMBER_OF_THREADS - naim
832     Thread(process *pproc) : tid(0), pos(0), rid(NULL) 
833     { 
834       proc = pproc; 
835       ppid = pproc->getPid();
836       CTvector = new CT(proc);
837     }
838     Thread(process *proc_, int tid_, int pos_, resource *rid_ )
839     { 
840       proc = proc_; 
841       ppid = proc_->getPid();
842       tid = tid_;
843       pos = pos_;
844       rid = rid_;
845       CTvector = new CT(proc_);
846       //assert(tid>=0 && tid<MAX_NUMBER_OF_THREADS);
847     }
848     ~Thread() 
849     { 
850       delete CTvector;
851     }
852     int get_tid() { return(tid); }
853     unsigned get_pos() { return(pos); }
854     void update_tid(int id, int p) { tid = id; pos = p; }
855     int get_ppid() { return(ppid); }
856     resource *get_rid() { return(rid); }
857     process *get_proc() { return(proc); }
858     CT *CTvector;
859   private:
860     int tid;
861     int ppid;
862     int pos;
863     resource *rid;
864     process *proc;
865 };
866
867 #endif