Changes for Windows NT port; added flags for loading libdyninst dynamically
[dyninst.git] / dyninstAPI / 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 "dyninstAPI/src/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 "dyninstAPI/src/ast.h"
62 #include "dyninstAPI/src/os.h"
63 // #include "paradynd/src/main.h"
64 #include "paradynd/src/showerror.h"
65
66 #include "dyninstAPI/src/symtab.h" // internalSym
67
68 #ifdef SHM_SAMPLING
69 #include "paradynd/src/fastInferiorHeapMgr.h"
70 #include "paradynd/src/superTable.h"
71 #include "paradynd/src/hashTable.h"
72 #ifdef sparc_sun_sunos4_1_3
73 #include <kvm.h>
74 #include <sys/user.h>
75 #endif
76 #endif
77
78 #include "dyninstAPI/src/sharedobject.h"
79 #include "dyninstAPI/src/dynamiclinking.h"
80
81 extern unsigned activeProcesses; // number of active processes
82    // how about just processVec.size() instead?  At least, this should be made
83    // a (static) member vrble of class process
84
85 class resource;
86 class instPoint;
87 class instInstance;
88 class trampTemplate;
89 class pdThread;
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(const 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 Frame;
183
184 class process {
185  friend class ptraceKludge;
186 #ifdef BPATCH_LIBRARY
187  friend class BPatch_image;
188 #endif
189
190  public:
191   process(int iPid, image *iImage, int iTraceLink, int iIoLink
192 #ifdef SHM_SAMPLING
193           , key_t theShmSegKey,
194           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
195 #endif
196           );
197      // this is the "normal" ctor
198
199   process(int iPid, image *iSymbols,
200           int afterAttach // 1 --> pause, 2 --> run, 0 --> leave as is
201 #ifdef SHM_SAMPLING
202           , key_t theShmSegKey,
203           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
204 #endif
205           );
206      // this is the "attach" ctor
207
208   process(const process &parentProc, int iPid, int iTrace_fd
209 #ifdef SHM_SAMPLING
210           , key_t theShmSegKey,
211           void *applShmSegPtr,
212           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
213 #endif
214           );
215      // this is the "fork" ctor
216
217 #ifdef SHM_SAMPLING
218   void registerInferiorAttachedSegs(void *inferiorAttachedAtPtr);
219      // Where the inferior attached was left undefined in the constructor;
220      // this routine fills it in (tells paradynd where, in the inferior proc's addr
221      // space, the shm seg was attached.  The attaching was done in DYNINSTinit)
222 #endif
223
224   vector<Address> walkStack(bool noPause=false);
225
226   // 
227   // getActiveFrame and readDataFromFrame are platform dependant
228   //
229   bool getActiveFrame(int *fp, int *pc);
230   bool readDataFromFrame(int currentFP, int *previousFP, int *rtn, 
231                          bool uppermost=false);
232
233
234 #ifdef SHM_SAMPLING
235   time64 getInferiorProcessCPUtime() const;
236      // returns user+sys time from the u or proc area of the inferior process, which in
237      // turn is presumably obtained by mmapping it (sunos) or by using a /proc ioctl
238      // to obtain it (solaris).  It is hoped that the implementation would not have to
239      // pause the inferior process (and then unpause it) in order to obtain the result,
240      // since pausing and unpausing are extremely slow (I've seen ~70ms).
241 #endif
242
243   processState status() const { return status_;}
244   string getStatusAsString() const; // useful for debug printing etc.
245
246   void continueAfterNextStop() { continueAfterNextStop_ = true; }
247   void Exited();
248   void Stopped();
249
250   // the following 2 vrbles probably belong in a different class:
251   static string programName; // the name of paradynd (more specifically, its argv[0])
252   static vector<string> arg_list; // the arguments of paradynd
253   static string pdFlavor ;
254
255   bool findInternalSymbol(const string &name, bool warn, internalSym &ret_sym) const;
256
257   Address findInternalAddress(const string &name, bool warn, bool &err) const;
258
259   bool dumpImage();
260
261   bool symbol_info(const string &name, Symbol &ret) {
262      assert(symbols);
263      return symbols->symbol_info(name, ret);
264   }
265   image *getImage() const {
266      assert(symbols);
267      return symbols;
268   }
269
270  private:
271   struct inferiorRPCtoDo {
272      // This structure keeps track of an inferiorRPC that we will start sometime
273      // in the (presumably near) future.  There is a different structure for RPCs
274      // which have been launched and which we're waiting to finish.  Don't confuse
275      // the two.
276
277      AstNode *action;
278      bool noCost; // if true, cost model isn't updated by generated code.
279      void (*callbackFunc)(process *, void *userData, unsigned result);
280      void *userData;
281   };
282   vectorSet<inferiorRPCtoDo> RPCsWaitingToStart;
283
284   struct inferiorRPCinProgress {
285      // This structure keeps track of an inferiorRPC that has been launched and
286      // for which we're waiting to complete.  Don't confuse with 'inferiorRPCtoDo',
287      // which is more of a wait queue of RPCs to start launching.
288      // Also note: It's only safe for 1 RPC to be in progress at a time.
289      // If you _really_ want to launch multiple RPCs at the same time, it's actually
290      // easy to do...just do one inferiorRPC with a sequenceNode AST! (neat, eh?)
291      // (Admittedly, that does confuse the semantics of callback functions.  So
292      // the official line remains: only 1 inferior RPC per process can be ongoing.)
293      void (*callbackFunc)(process *, void *userData, unsigned result);
294      void *userData;
295      
296      void *savedRegs; // crucial!
297
298      bool wasRunning; // were we running when we launched the inferiorRPC?
299
300      unsigned firstInstrAddr; // start location of temp tramp
301
302      unsigned stopForResultAddr;
303         // location of the TRAP or ILL which marks point where paradynd should grab the
304         // result register.  Undefined if no callback fn.
305      unsigned justAfter_stopForResultAddr; // undefined if no callback fn.
306      reg resultRegister; // undefined if no callback fn.
307
308      unsigned resultValue; // undefined until we stop-for-result, at which time we
309                            // fill this in.  The callback fn (which takes in this value)
310                            // isn't invoked until breakAddr (the final break)
311
312      unsigned breakAddr;
313         // location of the TRAP or ILL insn which marks the end of the inferiorRPC
314   };
315   vectorSet<inferiorRPCinProgress> currRunningRPCs;
316       // see para above for reason why this 'vector' can have at most 1 elem!
317
318  public:
319   unsigned numOfActCounters_is;
320   unsigned numOfActProcTimers_is;
321   unsigned numOfActWallTimers_is; 
322   bool deferredContinueProc;
323   void updateActiveCT(bool flag, CTelementType type);
324   void postRPCtoDo(AstNode *, bool noCost,
325                    void (*)(process *, void *, unsigned), void *);
326   bool existsRPCreadyToLaunch() const;
327   bool existsRPCinProgress() const;
328   bool launchRPCifAppropriate(bool wasRunning);
329      // returns true iff anything was launched.
330      // asynchronously launches iff RPCsWaitingToStart.size() > 0 AND
331      // if currRunningRPCs.size()==0 (the latter for safety)
332      // If we're gonna launch, then we'll stop the process (a necessity).
333      // Pass wasRunning as true iff you want the process  to continue after
334      // receiving the TRAP signifying completion of the RPC.
335
336   bool handleTrapIfDueToRPC();
337      // look for curr PC reg value in 'trapInstrAddr' of 'currRunningRPCs'.  Return
338      // true iff found.  Also, if true is being returned, then additionally does
339      // a 'launchRPCifAppropriate' to fire off the next waiting RPC, if any.
340   bool changePC(unsigned addr);
341
342  private:
343   // The follwing 5 routines are implemented in an arch-specific .C file
344   bool emitInferiorRPCheader(void *, unsigned &base);
345   bool emitInferiorRPCtrailer(void *, unsigned &base,
346                               unsigned &breakOffset,
347                               bool stopForResult,
348                               unsigned &stopForResultOffset,
349                               unsigned &justAfter_stopForResultOffset);
350
351   unsigned createRPCtempTramp(AstNode *action,
352                               bool noCost, bool careAboutResult,
353                               unsigned &breakAddr,
354                               unsigned &stopForResultAddr,
355                               unsigned &justAfter_stopForResultAddr,
356                               reg &resultReg);
357
358   // The parameter syscall is only used for hpux platform right now
359   // Can "syscall" be embedded into the opaque type?
360   void *getRegisters(bool &syscall);
361      // ptrace-GETREGS and ptrace-GETFPREGS.  Result is returned in an opaque type
362      // which is allocated with new[]
363
364   bool changePC(unsigned addr,
365                 const void *savedRegs // returned by getRegisters()
366                 );
367
368   bool restoreRegisters(void *buffer);
369      // input is the opaque type returned by getRegisters()
370
371   unsigned read_inferiorRPC_result_register(reg);
372
373  public:
374   void installBootstrapInst();
375   void installInstrRequests(const vector<instMapping*> &requests);
376  
377   // These member vrbles should be made private!
378   int traceLink;                /* pipe to transfer traces data over */
379   int ioLink;                   /* pipe to transfer stdout/stderr over */
380   processState status_;         /* running, stopped, etc. */
381   vector<pdThread *> threads;   /* threads belonging to this process */
382 #if defined(SHM_SAMPLING)
383   hashTable *threadMap;         /* mapping table for threads into superTable */
384 #endif
385   bool continueAfterNextStop_;
386   // on some platforms we use one heap for text and data so textHeapFree is not
387   // used.
388   bool splitHeaps;              /* are the inferior heap split I/D ? */
389   inferiorHeap  heaps[2];       /* the heaps text and data */
390   resource *rid;                /* handle to resource for this process */
391
392   /* map an inst point to its base tramp */
393   dictionary_hash<const instPoint*, trampTemplate *> baseMap;   
394
395   // the following 3 are used in perfStream.C
396   char buffer[2048];
397   unsigned bufStart;
398   unsigned bufEnd;
399
400   time64 wallTimeLastTrampSample;
401   time64 timeLastTrampSample;
402
403   bool reachedFirstBreak; // should be renamed 'reachedInitialTRAP'
404
405   int getPid() const { return pid;}
406
407   bool heapIsOk(const vector<sym_data>&);
408   bool initDyninstLib();
409
410   void initInferiorHeap(bool textHeap);
411      // true --> text heap, else data heap
412
413   bool writeDataSpace(void *inTracedProcess,
414                       int amount, const void *inSelf);
415   bool readDataSpace(const void *inTracedProcess, int amount,
416                      void *inSelf, bool displayErrMsg);
417
418   bool writeTextSpace(void *inTracedProcess, int amount, const void *inSelf);
419   bool writeTextWord(caddr_t inTracedProcess, int data);
420   bool continueProc();
421   bool pause();
422
423   bool dumpCore(const string coreFile);
424   bool detach(const bool paused); // why the param?
425   bool attach();
426   string getProcessStatus() const;
427
428   static string tryToFindExecutable(const string &progpath, int pid);
429       // os-specific implementation.  Returns empty string on failure.
430       // Otherwise, returns a full-path-name for the file.  Tries every
431       // trick to determine the full-path-name, even though "progpath" may
432       // be unspecified (empty string)
433
434   bool continueWithForwardSignal(int sig); // arch-specific implementation
435   
436   // forkProcess: this function should be called when a process we are tracing
437   // forks a child process.
438   // This function returns a new process object associated with the child.
439   // It also writes to "map" s.t. for each instInstance in the parent, we have the
440   // corresponding instInstance in the child.
441   static process *forkProcess(const process *parent, pid_t childPid,
442                               dictionary_hash<instInstance*,instInstance*> &map,
443                               int iTrace_fd
444 #ifdef SHM_SAMPLING
445                               ,key_t theKey,
446                               void *applAttachedAtPtr
447 #endif
448                               );
449
450   // get and set info. specifying if this is a dynamic executable
451   void setDynamicLinking(){ dynamiclinking = true;}
452   bool isDynamicallyLinked() { return (dynamiclinking); }
453
454   // handleIfDueToSharedObjectMapping: if a trap instruction was caused by
455   // a dlopen or dlclose event then return true
456   bool handleIfDueToSharedObjectMapping();
457
458   // handleStartProcess: this function is called when an appplication 
459   // starts executing.  It is used to insert instrumentation necessary
460   // to handle dynamic linking
461   static bool handleStartProcess(process *pid);
462
463   bool handleStopDueToExecEntry();
464
465   // getSharedObjects: This routine is called before main() to get and
466   // process all shared objects that have been mapped into the process's
467   // address space
468   bool getSharedObjects();
469
470   // addASharedObject: This routine is called whenever a new shared object
471   // has been loaded by the run-time linker after the process starts running
472   // It processes the image, creates new resources
473   bool addASharedObject(shared_object &);
474
475   // return the list of dynamically linked libs
476   vector<shared_object *> *sharedObjects() { return shared_objects;  } 
477
478   // getMainFunction: returns the main function for this process
479   function_base *getMainFunction() const { return mainFunction; }
480
481   // findOneFunction: returns the function associated with function "func"
482   // and module "mod".  This routine checks both the a.out image and any
483   // shared object images for this function
484   function_base *findOneFunction(resource *func,resource *mod);
485
486   // findOneFunction: returns the function associated with function "func_name"
487   // This routine checks both the a.out image and any shared object images 
488   // for this function
489   function_base *findOneFunction(const string &func_name);
490
491   // findOneFunctionFromAll: returns the function associated with function "func_name"
492   // This routine checks both the a.out image and any shared object images 
493   // for this function
494   function_base *findOneFunctionFromAll(const string &func_name);
495
496   // findFunctionIn: returns the function which contains this address
497   // This routine checks both the a.out image and any shared object images 
498   // for this function
499   function_base *findFunctionIn(Address adr);
500
501   // findModule: returns the module associated with "mod_name" 
502   // this routine checks both the a.out image and any shared object 
503   // images for this module
504   module *findModule(const string &mod_name);
505
506   // getSymbolInfo:  get symbol info of symbol associated with name n
507   // this routine starts looking a.out for symbol and then in shared objects
508   // baseAddr is set to the base address of the object containing the symbol
509   bool getSymbolInfo(const string &n, Symbol &info, Address &baseAddr) const;
510
511   // getAllFunctions: returns a vector of all functions defined in the
512   // a.out and in the shared objects
513   vector<function_base *> *getAllFunctions();
514
515   // getAllModules: returns a vector of all modules defined in the
516   // a.out and in the shared objects
517   vector<module *> *getAllModules();
518
519   // getIncludedFunctions: returns a vector of all functions defined in the
520   // a.out and in shared objects that are not excluded by an mdl option 
521   vector<function_base *> *getIncludedFunctions();
522
523   // getIncludedModules: returns a vector of all functions defined in the
524   // a.out and in shared objects that are  not excluded by an mdl option
525   vector<module *> *getIncludedModules();
526
527   // getBaseAddress: sets baseAddress to the base address of the 
528   // image corresponding to which.  It returns true  if image is mapped
529   // in processes address space, otherwise it returns 0
530   bool getBaseAddress(const image *which, u_int &baseAddress) const;
531
532   // these routines are for testing, setting, and clearing the 
533   // waiting_for_resources flag, if this flag is true a process is not 
534   // started until all outstanding resourceInfoResponses have been received
535   void setWaitingForResources(){ waiting_for_resources = true; }
536   // called by perfStream.C on SIGSTOP if there are any
537   // resource::num_outstanding_creates,
538   // and process::handleStartProcess, also if there are any
539   // resource::num_outstanding_creates.
540   void clearWaitingForResources(){ waiting_for_resources = false; }
541   bool isWaitingForResources(){ return(waiting_for_resources); }
542
543   // findSignalHandler: if signal_handler is 0, then it checks all images
544   // associtated with this process for the signal handler function.
545   // Otherwise, the signal handler function has already been found
546   void findSignalHandler();
547
548   // continueProcessIfWaiting: if the waiting_for_resources flag
549   // is set then continue the process; in any event, clear that flag
550   void continueProcessIfWaiting(){
551       if(waiting_for_resources){
552           continueProc();
553       }
554       waiting_for_resources = false;
555   }
556
557   //  wasExeced: returns true is the process did an exec...this is set
558   //  in handleExec()
559   bool wasExeced(){ return execed_;}
560
561   void handleExec();
562   bool cleanUpInstrumentation(bool wasRunning); // called on exit (also exec?)
563   bool inExec;
564
565   string execFilePath;
566
567   int getProcFileDescriptor(){ return proc_fd;}
568
569   static int waitProcs(int *status);
570   const process *getParent() const {return parent;}
571
572 #if defined(hppa1_1_hp_hpux)
573   bool freeNotOK;
574 #endif
575
576 #ifdef SHM_SAMPLING
577   key_t getShmKeyUsed() const {return inferiorHeapMgr.getShmKey();}
578   bool doMajorShmSample(time64 currWallTime);
579   bool doMinorShmSample();
580
581   const fastInferiorHeapMgr &getShmHeapMgr() const {
582      return(inferiorHeapMgr);
583   }
584
585   unsigned getShmHeapTotalNumBytes() {
586      return inferiorHeapMgr.getHeapTotalNumBytes();
587   }
588
589   void *getObsCostLowAddrInApplicSpace() {
590      void *result = inferiorHeapMgr.getObsCostAddrInApplicSpace();
591      return result;
592   }
593   unsigned *getObsCostLowAddrInParadyndSpace() {
594      unsigned *result = inferiorHeapMgr.getObsCostAddrInParadyndSpace();
595      return result;
596   }
597   void processCost(unsigned obsCostLow,
598                    time64 wallTime, time64 processTime);
599
600
601 #ifdef sparc_sun_sunos4_1_3
602    static user *tryToMapChildUarea(int pid);
603 #endif
604
605 #endif /* shm_sampling */
606
607    bool isBootstrappedYet() const {
608       return hasBootstrapped;
609    }
610    bool extractBootstrapStruct(DYNINST_bootstrapStruct *);
611    int procStopFromDYNINSTinit();
612       // returns 0 if not processed, 1 for the usual processed case (process is
613       // now paused), or 2 for the processed-but-still-running-inferiorRPC case
614
615    void handleCompletionOfDYNINSTinit(bool fromAttach);
616       // called by above routine.  Reads bs_record from applic, takes action.
617
618    static void DYNINSTinitCompletionCallback(process *, void *, unsigned);
619       // inferiorRPC callback routine.
620
621 private:
622   // Since we don't define these, 'private' makes sure they're not used:
623   process(const process &); // copy ctor
624   process &operator=(const process &); // assign oper
625
626   bool hasBootstrapped;
627      // set to true when we get callback from inferiorRPC call to DYNINSTinit
628
629   // the following two variables are used when libdyninstRT is dynamically linked
630   // which currently is done only on the Windows NT platform.
631   // On other platforms the values are undefined
632   bool hasLoadedDyninstLib; // true iff dyninstlib has been loaded already
633   bool isLoadingDyninstLib; // true iff we are currently loading dyninst lib
634   
635   // the next two variables are used when we are loading dyninstlib -- currently
636   // Windows NT only
637   // They are used by the special inferior RPC that makes the call to load the
638   // library -- we use a special inferior RPC because the regular RPC assumes
639   // that the inferior heap already exists, which is not true if libdyninstRT
640   // has not been loaded yet.
641   char savedData[32];
642   void *savedRegs;
643
644
645   const process *parent;        /* parent of this process */
646   image *symbols;               /* information related to the process */
647   int pid;                      /* id of this process */
648
649 #ifdef SHM_SAMPLING
650   // New components of the conceptual "inferior heap"
651   fastInferiorHeapMgr inferiorHeapMgr;
652
653   superTable theSuperTable;
654
655 #ifdef sparc_sun_sunos4_1_3
656   kvm_t *kvmHandle;
657   user *childUareaPtr;
658 #endif
659
660 #endif
661
662 public:
663 #ifdef SHM_SAMPLING
664   const superTable &getTable() const {
665      return theSuperTable;
666   }
667   superTable &getTable() {
668      return theSuperTable;
669   }
670 #endif
671   trampTableEntry trampTable[TRAMPTABLESZ];
672   unsigned trampTableItems;
673
674   unsigned currentPC() {
675     int pc, fp;
676     if (hasNewPC)
677       return currentPC_;
678     else if (getActiveFrame(&fp, &pc)) {
679       currentPC_ = (unsigned) pc;
680       return currentPC_;
681     }
682     else abort();
683     return 0;
684   }
685   void setNewPC(unsigned newPC) {
686     currentPC_ = newPC;
687     hasNewPC = true;
688   }
689
690   inline int costAddr()  const { return costAddr_; }  // why an integer?
691   void getObservedCostAddr();   
692
693 private:
694   bool createdViaAttach;
695      // set in the ctor.  True iff this process was created with an attach,
696      // as opposed to being fired up by paradynd.  On fork, has the value of
697      // the parent process.  On exec, no change.
698      // This vrble is important because it tells us what to do when we exit.
699      // If we created via attach, we should (presumably) detach but not fry
700      // the application; otherwise, a kill(pid, 9) is called for.
701   // the following 2 are defined only if 'createdViaAttach' is true; action is taken
702   // on these vrbles once DYNINSTinit completes.
703
704   bool wasRunningWhenAttached;
705   bool needToContinueAfterDYNINSTinit;
706
707   unsigned currentPC_;
708   bool hasNewPC;
709
710   // for processing observed cost (see method processCost())
711   int64 cumObsCost; // in cycles
712   unsigned lastObsCostLow; // in cycles
713
714   int costAddr_;  // why an integer?
715   bool execed_;  // true if this process does an exec...set in handleExec
716
717   // deal with system differences for ptrace
718   bool writeDataSpace_(void *inTracedProcess, int amount, const void *inSelf);
719   bool readDataSpace_(const void *inTracedProcess, int amount, void *inSelf);
720
721   bool writeTextWord_(caddr_t inTracedProcess, int data);
722   bool writeTextSpace_(void *inTracedProcess, int amount, const void *inSelf);
723   bool pause_();
724   bool continueProc_();
725   bool dumpCore_(const string coreFile);
726   bool detach_();
727   bool attach_(); // low-level attach; called by attach() (formerly OS::osAttach())
728   bool stop_(); // formerly OS::osStop
729
730   // stops a process
731   bool loopUntilStopped();
732
733   // returns true iff ok to do a ptrace; false (and prints a warning) if not
734   bool checkStatus();
735
736   int proc_fd; // file descriptor for platforms that use /proc file system.
737
738   dynamic_linking *dyn;   // platform specific dynamic linking routines & data
739
740   bool dynamiclinking;   // if true this a.out has a .dynamic section
741   vector<shared_object *> *shared_objects;  // list of dynamically linked libs
742
743   // The set of all functions and modules in the a.out and in the shared objects
744   vector<function_base *> *all_functions;
745   vector<module *> *all_modules;
746   // these are a restricted set of functions and modules which are those  
747   // from shared objects that are not excluded through an mdl "exclude_library"
748   // option: these are used to satisfy foci that are not refined on the
749   // Code heirarchy
750   vector<module *> *some_modules;  
751   vector<function_base *> *some_functions; 
752   bool waiting_for_resources;  // true if waiting for resourceInfoResponse
753   pd_Function *signal_handler;  // signal handler function (for stack walking)
754
755   function_base *mainFunction;  // the main function for this process,
756                               // this is usually, but not always, main
757                                  
758
759   // needToAddALeafFrame: returns true if the between the current frame 
760   // and the next frame there is a leaf function (this occurs when the 
761   // current frame is the signal handler)
762   bool needToAddALeafFrame(Frame current_frame, Address &leaf_pc);
763
764   bool isRunning_() const;
765      // needed to initialize the 'wasRunningWhenAttached' member vrble.  Determines
766      // whether the process is running by doing a low-level OS check, not by checking
767      // member vrbles like status_.  May assume that process::attach() has already run,
768      // but can't assume anything else.  May barf with a not-yet-implemented error on a
769      // given platform if the platform doesn't yet support attaching to a running process.
770      // But there's no reason why we shouldn't be able to implement this on any platform;
771      // after all, the output from the "ps" command can be used (T --> return false,
772      // S or R --> return true, other --> return ?)
773
774 #if defined(sparc_sun_solaris2_4) || defined(i386_unknown_solaris2_5)
775    // some very useful items gathered from /proc (initialized in attach() [solaris.C],
776    // as soon as /proc fd is opened)
777    string argv0; // argv[0] of program, at the time it started up
778    string pathenv; // path env var of program, at the time it started up
779    string cwdenv; // curr working directory of program, at the time it started up
780
781 //   string fullPathToExecutable_;
782       // very useful, especially on attach (need this to parse the symbol table)
783
784  public:
785    const string &getArgv0() const {return argv0;}
786    const string &getPathEnv() const {return pathenv;}
787    const string &getCwdEnv() const {return cwdenv;}
788 #endif
789 };
790
791 process *createProcess(const string file, vector<string> argv, vector<string> envp, const string dir);
792 bool attachProcess(const string &progpath, int pid, int afterAttach);
793
794 void handleProcessExit(process *p, int exitStatus);
795
796 unsigned inferiorMalloc(process *proc, int size, inferiorHeapType type);
797 void inferiorFree(process *proc, unsigned pointer, inferiorHeapType type,
798                   const vector<unsigVecType> &pointsToCheck);
799
800 extern resource *machineResource;
801
802 class Frame {
803   private:
804     int frame_;
805     int pc_;
806     bool uppermostFrame;
807
808   public:
809     Frame(process *);
810        // formerly getActiveStackFrameInfo
811
812     Frame(int theFrame, int thePc, bool theUppermost) {
813        frame_ = theFrame; pc_ = thePc;
814        uppermostFrame = theUppermost;
815     }
816
817     int getPC() const { return pc_; }
818     int getFramePtr(){ return frame_;}
819     bool isLastFrame() const { 
820         if ((pc_ == 0)||(frame_ == 0))
821             return(true);
822         else 
823             return(false); 
824     }
825
826     Frame getPreviousStackFrameInfo(process *proc) const;
827 };
828
829 extern vector<process *> processVec;
830
831 #endif