Added some more #ifdef BPATCH_LIBRARYs to eliminate some Dyninst API
[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 #ifdef BPATCH_LIBRARY
55 #include "dyninstAPI_RT/h/rtinst.h"
56 #else
57 #include "rtinst/h/rtinst.h"
58 #endif
59 #include "dyninstAPI/src/util.h"
60 #include "util/h/String.h"
61 #include "util/h/vectorSet.h"
62 #include "util/h/Dictionary.h"
63 #include "util/h/Types.h"
64 #include "util/h/Timer.h"
65 #include "dyninstAPI/src/ast.h"
66 #include "dyninstAPI/src/os.h"
67 // #include "paradynd/src/main.h"
68 #include "paradynd/src/showerror.h"
69
70 #include "dyninstAPI/src/symtab.h" // internalSym
71
72 #ifdef SHM_SAMPLING
73 #include "paradynd/src/fastInferiorHeapMgr.h"
74 #include "paradynd/src/superTable.h"
75 #include "paradynd/src/hashTable.h"
76 #ifdef sparc_sun_sunos4_1_3
77 #include <kvm.h>
78 #include <sys/user.h>
79 #endif
80 #endif
81
82 #include "dyninstAPI/src/sharedobject.h"
83 #include "dyninstAPI/src/dynamiclinking.h"
84
85 extern unsigned activeProcesses; // number of active processes
86    // how about just processVec.size() instead?  At least, this should be made
87    // a (static) member vrble of class process
88
89 class resource;
90 class instPoint;
91 class instInstance;
92 class trampTemplate;
93 class pdThread;
94
95 // TODO a kludge - to prevent recursive includes
96 class image;
97
98 typedef enum { neonatal, running, stopped, exited } processState;
99 typedef enum { HEAPfree, HEAPallocated } heapStatus;
100 typedef enum { textHeap=0, dataHeap=1 } inferiorHeapType;
101 typedef vector<unsigned> unsigVecType;
102
103 const int LOAD_DYNINST_BUF_SIZE = 64;
104
105 class heapItem {
106  public:
107   heapItem() {
108     addr =0; length = 0; status = HEAPfree;
109   }
110   heapItem(const heapItem *h) {
111     addr = h->addr; length = h->length; status = h->status;
112   }
113   Address addr;
114   int length;
115   heapStatus status;
116 };
117
118 //
119 // an item on the heap that we are trying to free.
120 //
121 class disabledItem {
122  public:
123   disabledItem() { pointer = 0; }
124   disabledItem(unsigned iPointer, inferiorHeapType iHeapType, const vector<unsigVecType> &iPoints) : pointsToCheck(iPoints) {
125      pointer = iPointer;
126      whichHeap = iHeapType;
127   }
128   disabledItem(const disabledItem &src) : pointsToCheck(src.pointsToCheck) {
129     pointer = src.pointer; 
130     whichHeap = src.whichHeap;
131   }
132  ~disabledItem() {}
133   disabledItem &operator=(const disabledItem &src) {
134      if (&src == this) return *this; // the usual check for x=x
135
136      pointer = src.pointer;
137      whichHeap = src.whichHeap;
138      pointsToCheck = src.pointsToCheck;
139      return *this;
140   }
141   
142   unsigned getPointer() const {return pointer;}
143   inferiorHeapType getHeapType() const {return whichHeap;}
144   const vector<unsigVecType> &getPointsToCheck() const {return pointsToCheck;}
145   vector<unsigVecType> &getPointsToCheck() {return pointsToCheck;}
146
147  private:
148   unsigned pointer;                     // address in heap
149   inferiorHeapType whichHeap;           // which heap is it in
150   vector<unsigVecType> pointsToCheck;   // range of addrs to check
151 };
152
153
154 class inferiorHeap {
155  public:
156   inferiorHeap(): heapActive(addrHash16) {
157       freed = 0; disabledListTotalMem = 0; totalFreeMemAvailable = 0;
158 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
159       base = 0; size = 0;
160 #endif
161   }
162   inferiorHeap(const inferiorHeap &src);  // create a new heap that is a copy of src.
163                                           // used on fork.
164   dictionary_hash<unsigned, heapItem*> heapActive; // active part of heap 
165   vector<heapItem*> heapFree;           // free block of data inferior heap 
166   vector<disabledItem> disabledList;    // items waiting to be freed.
167   int disabledListTotalMem;             // total size of item waiting to free
168   int totalFreeMemAvailable;            // total free memory in the heap
169   int freed;                            // total reclaimed (over time)
170
171 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
172   Address base;                         // base of heap
173   int size;                             // size of heap
174 #endif /* BPATCH_SET_MUTATIONS_ACTIVE */
175 };
176
177 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
178 class mutationRecord {
179 public:
180     mutationRecord *next;
181     mutationRecord *prev;
182
183     Address     addr;
184     int         size;
185     void        *data;
186
187     mutationRecord(Address _addr, int _size, const void *_data);
188     ~mutationRecord();
189 };
190
191 class mutationList {
192 private:
193     mutationRecord      *head;
194     mutationRecord      *tail;
195 public:
196     mutationList() : head(NULL), tail(NULL) {};
197     ~mutationList();
198
199     void insertHead(Address addr, int size, const void *data);
200     void insertTail(Address addr, int size, const void *data);
201     mutationRecord *getHead() { return head; }
202     mutationRecord *getTail() { return tail; }
203 };
204 #endif /* BPATCH_SET_MUTATIONS_ACTIVE */
205
206 static inline unsigned ipHash(const instPoint * const &ip)
207 {
208   // assume all addresses are 4-byte aligned
209   unsigned result = (unsigned)ip;
210   result >>= 2;
211   return result;
212   // how about %'ing by a huge prime number?  Nah, x % y == x when x < y 
213   // so we don't want the number to be huge.
214 }
215
216
217 static inline unsigned instInstanceHash(instInstance * const &inst) {
218    unsigned result = (unsigned)inst;
219    result >>= 2;
220    return result; // how about %'ing by a huge prime number?
221 //  return ((unsigned)inst);
222 }
223
224 class Frame;
225
226 class process {
227  friend class ptraceKludge;
228 #ifdef BPATCH_LIBRARY
229  friend class BPatch_image;
230 #endif
231
232  public:
233   process(int iPid, image *iImage, int iTraceLink, int iIoLink
234 #ifdef SHM_SAMPLING
235           , key_t theShmSegKey,
236           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
237 #endif
238           );
239      // this is the "normal" ctor
240
241   process(int iPid, image *iSymbols,
242           int afterAttach, // 1 --> pause, 2 --> run, 0 --> leave as is
243           bool& success 
244 #ifdef SHM_SAMPLING
245           , key_t theShmSegKey,
246           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
247 #endif
248           );
249      // this is the "attach" ctor
250
251   process(const process &parentProc, int iPid, int iTrace_fd
252 #ifdef SHM_SAMPLING
253           , key_t theShmSegKey,
254           void *applShmSegPtr,
255           const vector<fastInferiorHeapMgr::oneHeapStats> &iShmHeapStats
256 #endif
257           );
258      // this is the "fork" ctor
259
260 #ifdef SHM_SAMPLING
261   void registerInferiorAttachedSegs(void *inferiorAttachedAtPtr);
262      // Where the inferior attached was left undefined in the constructor;
263      // this routine fills it in (tells paradynd where, in the inferior proc's addr
264      // space, the shm seg was attached.  The attaching was done in DYNINSTinit)
265 #endif
266
267   vector<Address> walkStack(bool noPause=false);
268
269   // 
270   // getActiveFrame and readDataFromFrame are platform dependant
271   //
272   bool getActiveFrame(int *fp, int *pc);
273   bool readDataFromFrame(int currentFP, int *previousFP, int *rtn, 
274                          bool uppermost=false);
275
276
277 #ifdef SHM_SAMPLING
278   time64 getInferiorProcessCPUtime();
279      // returns user+sys time from the u or proc area of the inferior process, which in
280      // turn is presumably obtained by mmapping it (sunos) or by using a /proc ioctl
281      // to obtain it (solaris).  It is hoped that the implementation would not have to
282      // pause the inferior process (and then unpause it) in order to obtain the result,
283      // since pausing and unpausing are extremely slow (I've seen ~70ms).
284 #endif
285
286   processState status() const { return status_;}
287   string getStatusAsString() const; // useful for debug printing etc.
288
289   void continueAfterNextStop() { continueAfterNextStop_ = true; }
290   void Exited();
291   void Stopped();
292
293   // the following 2 vrbles probably belong in a different class:
294   static string programName; // the name of paradynd (more specifically, its argv[0])
295   static vector<string> arg_list; // the arguments of paradynd
296   static string pdFlavor ;
297
298   bool findInternalSymbol(const string &name, bool warn, internalSym &ret_sym) const;
299
300   Address findInternalAddress(const string &name, bool warn, bool &err) const;
301
302   bool dumpImage();
303
304   bool symbol_info(const string &name, Symbol &ret) {
305      assert(symbols);
306      return symbols->symbol_info(name, ret);
307   }
308   image *getImage() const {
309      assert(symbols);
310      return symbols;
311   }
312
313   // this is only used on aix so far - naim
314   vector<int> getTOCoffsetInfo() const;
315
316  private:
317 #if defined(USES_LIBDYNINSTRT_SO)
318   unsigned char savedCodeBuffer[BYTES_TO_SAVE];
319 #endif
320   struct inferiorRPCtoDo {
321      // This structure keeps track of an inferiorRPC that we will start sometime
322      // in the (presumably near) future.  There is a different structure for RPCs
323      // which have been launched and which we're waiting to finish.  Don't confuse
324      // the two.
325
326      AstNode *action;
327      bool noCost; // if true, cost model isn't updated by generated code.
328      void (*callbackFunc)(process *, void *userData, unsigned result);
329      void *userData;
330      int mid;
331   };
332   vectorSet<inferiorRPCtoDo> RPCsWaitingToStart;
333   bool RPCs_waiting_for_syscall_to_complete;
334   void *save_exitset_ptr; // platform-specific (for now, just solaris;
335                           // it's actually a sysset_t*)
336                                                
337   struct inferiorRPCinProgress {
338      // This structure keeps track of an inferiorRPC that has been launched and
339      // for which we're waiting to complete.  Don't confuse with 'inferiorRPCtoDo',
340      // which is more of a wait queue of RPCs to start launching.
341      // Also note: It's only safe for 1 RPC to be in progress at a time.
342      // If you _really_ want to launch multiple RPCs at the same time, it's actually
343      // easy to do...just do one inferiorRPC with a sequenceNode AST! (neat, eh?)
344      // (Admittedly, that does confuse the semantics of callback functions.  So
345      // the official line remains: only 1 inferior RPC per process can be ongoing.)
346      void (*callbackFunc)(process *, void *userData, unsigned result);
347      void *userData;
348      
349      void *savedRegs; // crucial!
350
351      bool wasRunning; // were we running when we launched the inferiorRPC?
352
353      unsigned firstInstrAddr; // start location of temp tramp
354
355      unsigned stopForResultAddr;
356         // location of the TRAP or ILL which marks point where paradynd should grab the
357         // result register.  Undefined if no callback fn.
358      unsigned justAfter_stopForResultAddr; // undefined if no callback fn.
359      reg resultRegister; // undefined if no callback fn.
360
361      unsigned resultValue; // undefined until we stop-for-result, at which time we
362                            // fill this in.  The callback fn (which takes in this value)
363                            // isn't invoked until breakAddr (the final break)
364
365      unsigned breakAddr;
366         // location of the TRAP or ILL insn which marks the end of the inferiorRPC
367   };
368   vectorSet<inferiorRPCinProgress> currRunningRPCs;
369       // see para above for reason why this 'vector' can have at most 1 elem!
370
371  public:
372   bool dyninstLibAlreadyLoaded() { return hasLoadedDyninstLib; }
373   bool dyninstLibIsBeingLoaded() { return isLoadingDyninstLib; }
374   unsigned numOfActCounters_is;
375   unsigned numOfActProcTimers_is;
376   unsigned numOfActWallTimers_is; 
377   bool deferredContinueProc;
378   void updateActiveCT(bool flag, CTelementType type);
379   void cleanRPCreadyToLaunch(int mid);
380   void postRPCtoDo(AstNode *, bool noCost,
381                    void (*)(process *, void *, unsigned), void *, int);
382   bool existsRPCreadyToLaunch() const;
383   bool existsRPCinProgress() const;
384   bool launchRPCifAppropriate(bool wasRunning, bool finishingSysCall);
385      // returns true iff anything was launched.
386      // asynchronously launches iff RPCsWaitingToStart.size() > 0 AND
387      // if currRunningRPCs.size()==0 (the latter for safety)
388      // If we're gonna launch, then we'll stop the process (a necessity).
389      // Pass wasRunning as true iff you want the process  to continue after
390      // receiving the TRAP signifying completion of the RPC.
391   bool isRPCwaitingForSysCallToComplete() const {
392      return RPCs_waiting_for_syscall_to_complete;
393   }
394   void setRPCwaitingForSysCallToComplete(bool flag) {
395      RPCs_waiting_for_syscall_to_complete = flag;
396   }
397
398   bool handleTrapIfDueToRPC();
399      // look for curr PC reg value in 'trapInstrAddr' of 'currRunningRPCs'.  Return
400      // true iff found.  Also, if true is being returned, then additionally does
401      // a 'launchRPCifAppropriate' to fire off the next waiting RPC, if any.
402   bool changePC(unsigned addr);
403
404  private:
405   // The follwing 5 routines are implemented in an arch-specific .C file
406   bool emitInferiorRPCheader(void *, unsigned &base);
407   bool emitInferiorRPCtrailer(void *, unsigned &base,
408                               unsigned &breakOffset,
409                               bool stopForResult,
410                               unsigned &stopForResultOffset,
411                               unsigned &justAfter_stopForResultOffset);
412
413   unsigned createRPCtempTramp(AstNode *action,
414                               bool noCost, bool careAboutResult,
415                               unsigned &breakAddr,
416                               unsigned &stopForResultAddr,
417                               unsigned &justAfter_stopForResultAddr,
418                               reg &resultReg);
419
420   void *getRegisters();
421      // ptrace-GETREGS and ptrace-GETFPREGS (or /proc PIOCGREG and PIOCGFPREG).
422      // Result is returned in an opaque type which is allocated with new[]
423
424   bool changePC(unsigned addr,
425                 const void *savedRegs // returned by getRegisters()
426                 );
427
428   bool executingSystemCall();
429
430   bool restoreRegisters(void *buffer);
431      // input is the opaque type returned by getRegisters()
432
433   bool set_breakpoint_for_syscall_completion();
434   unsigned read_inferiorRPC_result_register(reg);
435
436  public:
437   void installBootstrapInst();
438   void installInstrRequests(const vector<instMapping*> &requests);
439  
440   // These member vrbles should be made private!
441   int traceLink;                /* pipe to transfer traces data over */
442   int ioLink;                   /* pipe to transfer stdout/stderr over */
443   processState status_;         /* running, stopped, etc. */
444   vector<pdThread *> threads;   /* threads belonging to this process */
445 #if defined(SHM_SAMPLING) && defined(MT_THREAD)
446   hashTable *threadMap;         /* mapping table for threads into superTable */
447 #endif
448   bool continueAfterNextStop_;
449   // on some platforms we use one heap for text and data so textHeapFree is not
450   // used.
451   bool splitHeaps;              /* are the inferior heap split I/D ? */
452   inferiorHeap  heaps[2];       /* the heaps text and data */
453   resource *rid;                /* handle to resource for this process */
454
455   /* map an inst point to its base tramp */
456   dictionary_hash<const instPoint*, trampTemplate *> baseMap;   
457
458   // the following 3 are used in perfStream.C
459   char buffer[2048];
460   unsigned bufStart;
461   unsigned bufEnd;
462
463   time64 wallTimeLastTrampSample;
464   time64 timeLastTrampSample;
465
466   bool reachedFirstBreak; // should be renamed 'reachedInitialTRAP'
467   bool reachedVeryFirstTrap; 
468
469   int getPid() const { return pid;}
470
471   bool heapIsOk(const vector<sym_data>&);
472   bool initDyninstLib();
473
474   void initInferiorHeap(bool textHeap);
475      // true --> text heap, else data heap
476
477 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
478   bool isAddrInHeap(Address addr) {
479             if ((addr >= heaps[dataHeap].base &&
480                  addr < heaps[dataHeap].base + heaps[dataHeap].size) ||
481                 (splitHeaps && addr >= heaps[textHeap].base &&
482                  addr < heaps[textHeap].base + heaps[textHeap].size))
483                 return true;
484             else
485                 return false;
486         };
487 #endif
488
489   bool writeDataSpace(void *inTracedProcess,
490                       int amount, const void *inSelf);
491   bool readDataSpace(const void *inTracedProcess, int amount,
492                      void *inSelf, bool displayErrMsg);
493
494   bool writeTextSpace(void *inTracedProcess, int amount, const void *inSelf);
495   bool writeTextWord(caddr_t inTracedProcess, int data);
496 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
497   bool readTextSpace(const void *inTracedProcess, int amount,
498                      const void *inSelf);
499 #endif
500   bool continueProc();
501 #ifdef BPATCH_LIBRARY
502   bool terminateProc() { return terminateProc_(); }
503 #endif
504   bool pause();
505
506   bool replaceFunctionCall(const instPoint *point,const function_base *newFunc);
507
508   bool dumpCore(const string coreFile);
509   bool detach(const bool paused); // why the param?
510   bool API_detach(const bool cont); // XXX Should eventually replace detach()
511   bool attach();
512
513 #if defined(USES_LIBDYNINSTRT_SO)
514   unsigned dyninstlib_brk_addr;
515   unsigned main_brk_addr;
516   bool dlopenDYNINSTlib();
517   bool trapDueToDyninstLib();
518   bool trapAtEntryPointOfMain();
519   bool wasCreatedViaAttach() { return createdViaAttach; }
520   void handleIfDueToDyninstLib();  
521   void insertTrapAtEntryPointOfMain();
522   void handleTrapAtEntryPointOfMain();
523 #endif
524
525   string getProcessStatus() const;
526
527   static string tryToFindExecutable(const string &progpath, int pid);
528       // os-specific implementation.  Returns empty string on failure.
529       // Otherwise, returns a full-path-name for the file.  Tries every
530       // trick to determine the full-path-name, even though "progpath" may
531       // be unspecified (empty string)
532
533   bool continueWithForwardSignal(int sig); // arch-specific implementation
534   
535   // forkProcess: this function should be called when a process we are tracing
536   // forks a child process.
537   // This function returns a new process object associated with the child.
538   // It also writes to "map" s.t. for each instInstance in the parent, we have the
539   // corresponding instInstance in the child.
540   static process *forkProcess(const process *parent, pid_t childPid,
541                               dictionary_hash<instInstance*,instInstance*> &map,
542                               int iTrace_fd
543 #ifdef SHM_SAMPLING
544                               ,key_t theKey,
545                               void *applAttachedAtPtr
546 #endif
547                               );
548
549   // get and set info. specifying if this is a dynamic executable
550   void setDynamicLinking(){ dynamiclinking = true;}
551   bool isDynamicallyLinked() { return (dynamiclinking); }
552
553   // handleIfDueToSharedObjectMapping: if a trap instruction was caused by
554   // a dlopen or dlclose event then return true
555   bool handleIfDueToSharedObjectMapping();
556
557   // handleStartProcess: this function is called when an appplication 
558   // starts executing.  It is used to insert instrumentation necessary
559   // to handle dynamic linking
560   bool handleStartProcess();
561
562   bool handleStopDueToExecEntry();
563
564 #if defined(USES_LIBDYNINSTRT_SO)
565   unsigned get_dlopen_addr() const;
566 #endif
567
568   // getSharedObjects: This routine is called before main() to get and
569   // process all shared objects that have been mapped into the process's
570   // address space
571   bool getSharedObjects();
572
573   // addASharedObject: This routine is called whenever a new shared object
574   // has been loaded by the run-time linker after the process starts running
575   // It processes the image, creates new resources
576   bool addASharedObject(shared_object &);
577
578   // return the list of dynamically linked libs
579   vector<shared_object *> *sharedObjects() { return shared_objects;  } 
580
581   // getMainFunction: returns the main function for this process
582   function_base *getMainFunction() const { return mainFunction; }
583
584   // findOneFunction: returns the function associated with function "func"
585   // and module "mod".  This routine checks both the a.out image and any
586   // shared object images for this function
587   function_base *findOneFunction(resource *func,resource *mod);
588
589 #ifndef BPATCH_LIBRARY
590   // returns all the functions in the module "mod" that are not excluded by
591   // exclude_lib or exclude_func
592   // return 0 on error.
593   vector<function_base *> *getIncludedFunctions(module *mod); 
594 #endif
595
596   // findOneFunction: returns the function associated with function "func_name"
597   // This routine checks both the a.out image and any shared object images 
598   // for this function
599   function_base *findOneFunction(const string &func_name);
600
601   // findOneFunctionFromAll: returns the function associated with function "func_name"
602   // This routine checks both the a.out image and any shared object images 
603   // for this function
604   function_base *findOneFunctionFromAll(const string &func_name);
605
606   // findFunctionIn: returns the function which contains this address
607   // This routine checks both the a.out image and any shared object images 
608   // for this function
609   function_base *findFunctionIn(Address adr);
610
611   // findModule: returns the module associated with "mod_name" 
612   // this routine checks both the a.out image and any shared object 
613   // images for this module
614   // if check_excluded is true it checks to see if the module is excluded
615   // and if it is it returns 0.  If check_excluded is false it doesn't check
616   module *findModule(const string &mod_name,bool check_excluded);
617
618   // getSymbolInfo:  get symbol info of symbol associated with name n
619   // this routine starts looking a.out for symbol and then in shared objects
620   // baseAddr is set to the base address of the object containing the symbol
621   bool getSymbolInfo(const string &n, Symbol &info, Address &baseAddr) const;
622
623   // getAllFunctions: returns a vector of all functions defined in the
624   // a.out and in the shared objects
625   vector<function_base *> *getAllFunctions();
626
627   // getAllModules: returns a vector of all modules defined in the
628   // a.out and in the shared objects
629   vector<module *> *getAllModules();
630
631 #ifndef BPATCH_LIBRARY
632   // getIncludedFunctions: returns a vector of all functions defined in the
633   // a.out and in shared objects that are not excluded by an mdl option 
634   vector<function_base *> *getIncludedFunctions();
635 #endif
636
637   // getIncludedModules: returns a vector of all functions defined in the
638   // a.out and in shared objects that are  not excluded by an mdl option
639   vector<module *> *getIncludedModules();
640
641   // getBaseAddress: sets baseAddress to the base address of the 
642   // image corresponding to which.  It returns true  if image is mapped
643   // in processes address space, otherwise it returns 0
644   bool getBaseAddress(const image *which, u_int &baseAddress) const;
645
646   // findCallee: finds the function called by the instruction corresponding
647   // to the instPoint "instr". If the function call has been bound to an
648   // address, then the callee function is returned in "target" and the
649   // instPoint "callee" data member is set to pt to callee's function_base.
650   // If the function has not yet been bound, then "target" is set to the
651   // function_base associated with the name of the target function (this is
652   // obtained by the PLT and relocation entries in the image), and the instPoint
653   // callee is not set.  If the callee function cannot be found, (ex. function
654   // pointers, or other indirect calls), it returns false.
655   // Returns false on error (ex. process doesn't contain this instPoint).
656   bool findCallee(instPoint &instr, function_base *&target);
657
658   // these routines are for testing, setting, and clearing the 
659   // waiting_for_resources flag, if this flag is true a process is not 
660   // started until all outstanding resourceInfoResponses have been received
661   void setWaitingForResources(){ waiting_for_resources = true; }
662   // called by perfStream.C on SIGSTOP if there are any
663   // resource::num_outstanding_creates,
664   // and process::handleStartProcess, also if there are any
665   // resource::num_outstanding_creates.
666   void clearWaitingForResources(){ waiting_for_resources = false; }
667   bool isWaitingForResources(){ return(waiting_for_resources); }
668
669   // findSignalHandler: if signal_handler is 0, then it checks all images
670   // associtated with this process for the signal handler function.
671   // Otherwise, the signal handler function has already been found
672   void findSignalHandler();
673
674   // continueProcessIfWaiting: if the waiting_for_resources flag
675   // is set then continue the process; in any event, clear that flag
676   void continueProcessIfWaiting(){
677       if(waiting_for_resources){
678           continueProc();
679       }
680       waiting_for_resources = false;
681   }
682
683   //  wasExeced: returns true is the process did an exec...this is set
684   //  in handleExec()
685   bool wasExeced(){ return execed_;}
686
687   void handleExec();
688   bool cleanUpInstrumentation(bool wasRunning); // called on exit (also exec?)
689   bool inExec;
690
691   string execFilePath;
692
693   int getProcFileDescriptor(){ return proc_fd;}
694
695   static int waitProcs(int *status);
696   const process *getParent() const {return parent;}
697
698 #if defined(hppa1_1_hp_hpux)
699   bool freeNotOK;
700 #endif
701
702 #ifdef SHM_SAMPLING
703   key_t getShmKeyUsed() const {return inferiorHeapMgr.getShmKey();}
704   bool doMajorShmSample(time64 currWallTime);
705   bool doMinorShmSample();
706
707   const fastInferiorHeapMgr &getShmHeapMgr() const {
708      return(inferiorHeapMgr);
709   }
710
711   unsigned getShmHeapTotalNumBytes() {
712      return inferiorHeapMgr.getHeapTotalNumBytes();
713   }
714
715   void *getObsCostLowAddrInApplicSpace() {
716      void *result = inferiorHeapMgr.getObsCostAddrInApplicSpace();
717      return result;
718   }
719   unsigned *getObsCostLowAddrInParadyndSpace() {
720      unsigned *result = inferiorHeapMgr.getObsCostAddrInParadyndSpace();
721      return result;
722   }
723   void processCost(unsigned obsCostLow,
724                    time64 wallTime, time64 processTime);
725
726
727 #ifdef sparc_sun_sunos4_1_3
728    static user *tryToMapChildUarea(int pid);
729 #endif
730
731 #endif /* shm_sampling */
732
733    bool isBootstrappedYet() const {
734       return hasBootstrapped;
735    }
736    bool extractBootstrapStruct(DYNINST_bootstrapStruct *);
737    int procStopFromDYNINSTinit();
738       // returns 0 if not processed, 1 for the usual processed case (process is
739       // now paused), or 2 for the processed-but-still-running-inferiorRPC case
740
741    void handleCompletionOfDYNINSTinit(bool fromAttach);
742       // called by above routine.  Reads bs_record from applic, takes action.
743
744    static void DYNINSTinitCompletionCallback(process *, void *, unsigned);
745       // inferiorRPC callback routine.
746
747 private:
748   // Since we don't define these, 'private' makes sure they're not used:
749   process(const process &); // copy ctor
750   process &operator=(const process &); // assign oper
751
752   bool hasBootstrapped;
753      // set to true when we get callback from inferiorRPC call to DYNINSTinit
754
755   // the following two variables are used when libdyninstRT is dynamically linked
756   // which currently is done only on the Windows NT platform.
757   // On other platforms the values are undefined
758   bool hasLoadedDyninstLib; // true iff dyninstlib has been loaded already
759   bool isLoadingDyninstLib; // true iff we are currently loading dyninst lib
760   
761   // the next two variables are used when we are loading dyninstlib -- currently
762   // Windows NT only
763   // They are used by the special inferior RPC that makes the call to load the
764   // library -- we use a special inferior RPC because the regular RPC assumes
765   // that the inferior heap already exists, which is not true if libdyninstRT
766   // has not been loaded yet.
767   char savedData[LOAD_DYNINST_BUF_SIZE];
768   void *savedRegs;
769
770
771   const process *parent;        /* parent of this process */
772   image *symbols;               /* information related to the process */
773   int pid;                      /* id of this process */
774
775 #ifdef SHM_SAMPLING
776   time64 previous; // This is being used to avoid time going backwards in
777                    // getInferiorProcessCPUtime. We can't use a static variable
778                    // inside this procedure because there is one previous for
779                    // each process - naim 5/28/97
780
781   // New components of the conceptual "inferior heap"
782   fastInferiorHeapMgr inferiorHeapMgr;
783
784   superTable theSuperTable;
785
786 #ifdef sparc_sun_sunos4_1_3
787   kvm_t *kvmHandle;
788   user *childUareaPtr;
789 #endif
790
791 #endif
792
793 public:
794 #ifdef SHM_SAMPLING
795   const superTable &getTable() const {
796      return theSuperTable;
797   }
798   superTable &getTable() {
799      return theSuperTable;
800   }
801 #endif
802   trampTableEntry trampTable[TRAMPTABLESZ];
803   unsigned trampTableItems;
804
805   unsigned currentPC() {
806     int pc, fp;
807     if (hasNewPC)
808       return currentPC_;
809     else if (getActiveFrame(&fp, &pc)) {
810       currentPC_ = (unsigned) pc;
811       return currentPC_;
812     }
813     else abort();
814     return 0;
815   }
816   void setNewPC(unsigned newPC) {
817     currentPC_ = newPC;
818     hasNewPC = true;
819   }
820
821   inline int costAddr()  const { return costAddr_; }  // why an integer?
822   void getObservedCostAddr();   
823
824 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
825    bool uninstallMutations();
826    bool reinstallMutations();
827 #endif /* BPATCH_SET_MUTATIONS_ACTIVE */
828
829 private:
830   bool createdViaAttach;
831      // set in the ctor.  True iff this process was created with an attach,
832      // as opposed to being fired up by paradynd.  On fork, has the value of
833      // the parent process.  On exec, no change.
834      // This vrble is important because it tells us what to do when we exit.
835      // If we created via attach, we should (presumably) detach but not fry
836      // the application; otherwise, a kill(pid, 9) is called for.
837   // the following 2 are defined only if 'createdViaAttach' is true; action is taken
838   // on these vrbles once DYNINSTinit completes.
839
840   bool wasRunningWhenAttached;
841   bool needToContinueAfterDYNINSTinit;
842
843   unsigned currentPC_;
844   bool hasNewPC;
845
846   // for processing observed cost (see method processCost())
847   int64 cumObsCost; // in cycles
848   unsigned lastObsCostLow; // in cycles
849
850   int costAddr_;  // why an integer?
851   bool execed_;  // true if this process does an exec...set in handleExec
852
853   // deal with system differences for ptrace
854   bool writeDataSpace_(void *inTracedProcess, int amount, const void *inSelf);
855   bool readDataSpace_(const void *inTracedProcess, int amount, void *inSelf);
856
857   bool writeTextWord_(caddr_t inTracedProcess, int data);
858   bool writeTextSpace_(void *inTracedProcess, int amount, const void *inSelf);
859 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
860   bool readTextSpace_(void *inTracedProcess, int amount, const void *inSelf);
861 #endif
862   bool pause_();
863   bool continueProc_();
864 #ifdef BPATCH_LIBRARY
865   bool terminateProc_();
866 #endif
867   bool dumpCore_(const string coreFile);
868   bool detach_();
869 #ifdef BPATCH_LIBRARY
870   bool API_detach_(const bool cont); // XXX Should eventually replace detach_()
871 #endif
872   bool attach_(); // low-level attach; called by attach() (formerly OS::osAttach())
873   bool stop_(); // formerly OS::osStop
874
875   // stops a process
876   bool loopUntilStopped();
877
878   // returns true iff ok to do a ptrace; false (and prints a warning) if not
879   bool checkStatus();
880
881   int proc_fd; // file descriptor for platforms that use /proc file system.
882
883   dynamic_linking *dyn;   // platform specific dynamic linking routines & data
884
885   bool dynamiclinking;   // if true this a.out has a .dynamic section
886   vector<shared_object *> *shared_objects;  // list of dynamically linked libs
887
888   // The set of all functions and modules from the shared objects that show
889   // up on the Where axis (both  instrumentable and uninstrumentable due to 
890   // exclude_lib or exclude_func),  and all the functions from the a.out that
891   // are between DYNINSTStart and DYNINSTend
892   // TODO: these lists for a.out functions and modules should be handled the 
893   // same way as for shared object functions and modules
894   vector<function_base *> *all_functions;
895   vector<module *> *all_modules;
896
897   // these are a restricted set of functions and modules which are those  
898   // from the a.out and shared objects that are instrumentable (not excluded 
899   // through the mdl "exclude_lib" or "exclude_func" option) 
900   // "excluded" now means never able to instrument
901   vector<module *> *some_modules;  
902   vector<function_base *> *some_functions; 
903   bool waiting_for_resources;  // true if waiting for resourceInfoResponse
904   pd_Function *signal_handler;  // signal handler function (for stack walking)
905
906   function_base *mainFunction;  // the main function for this process,
907                               // this is usually, but not always, main
908                                  
909
910   // needToAddALeafFrame: returns true if the between the current frame 
911   // and the next frame there is a leaf function (this occurs when the 
912   // current frame is the signal handler)
913   bool needToAddALeafFrame(Frame current_frame, Address &leaf_pc);
914
915   // hasBeenBound: returns true if the runtime linker has bound the
916   // function symbol corresponding to the relocation entry in at the address 
917   // specified by entry and base_addr.  If it has been bound, then the callee 
918   // function is returned in "target_pdf", else it returns false. 
919   bool hasBeenBound(const relocationEntry entry, pd_Function *&target_pdf, 
920                     Address base_addr) ;
921
922   // findpdFunctionIn: returns the function which contains this address
923   // This routine checks both the a.out image and any shared object images 
924   // for this function
925   pd_Function *findpdFunctionIn(Address adr);
926
927   bool isRunning_() const;
928      // needed to initialize the 'wasRunningWhenAttached' member vrble.  Determines
929      // whether the process is running by doing a low-level OS check, not by checking
930      // member vrbles like status_.  May assume that process::attach() has already run,
931      // but can't assume anything else.  May barf with a not-yet-implemented error on a
932      // given platform if the platform doesn't yet support attaching to a running process.
933      // But there's no reason why we shouldn't be able to implement this on any platform;
934      // after all, the output from the "ps" command can be used (T --> return false,
935      // S or R --> return true, other --> return ?)
936
937 #ifdef BPATCH_SET_MUTATIONS_ACTIVE
938    mutationList beforeMutationList, afterMutationList;
939
940    bool saveOriginalInstructions(Address addr, int size);
941    bool writeMutationList(mutationList &list);
942 #endif
943
944 #if defined(sparc_sun_solaris2_4) || defined(i386_unknown_solaris2_5)
945    // some very useful items gathered from /proc (initialized in attach() [solaris.C],
946    // as soon as /proc fd is opened)
947    string argv0; // argv[0] of program, at the time it started up
948    string pathenv; // path env var of program, at the time it started up
949    string cwdenv; // curr working directory of program, at the time it started up
950
951 //   string fullPathToExecutable_;
952       // very useful, especially on attach (need this to parse the symbol table)
953
954  public:
955    const string &getArgv0() const {return argv0;}
956    const string &getPathEnv() const {return pathenv;}
957    const string &getCwdEnv() const {return cwdenv;}
958 #endif
959 };
960
961 process *createProcess(const string file, vector<string> argv, vector<string> envp, const string dir);
962 bool attachProcess(const string &progpath, int pid, int afterAttach
963 #ifdef BPATCH_LIBRARY
964                    , process *&newProcess
965 #endif
966                   );
967
968 void handleProcessExit(process *p, int exitStatus);
969
970 unsigned inferiorMalloc(process *proc, int size, inferiorHeapType type);
971 void inferiorFree(process *proc, unsigned pointer, inferiorHeapType type,
972                   const vector<unsigVecType> &pointsToCheck);
973
974 extern resource *machineResource;
975
976 class Frame {
977   private:
978     int frame_;
979     int pc_;
980     bool uppermostFrame;
981
982   public:
983     Frame(process *);
984        // formerly getActiveStackFrameInfo
985
986     Frame(int theFrame, int thePc, bool theUppermost) {
987        frame_ = theFrame; pc_ = thePc;
988        uppermostFrame = theUppermost;
989     }
990
991     int getPC() const { return pc_; }
992     int getFramePtr(){ return frame_;}
993     bool isLastFrame() const { 
994         if ((pc_ == 0)||(frame_ == 0))
995             return(true);
996         else 
997             return(false); 
998     }
999
1000     Frame getPreviousStackFrameInfo(process *proc) const;
1001 };
1002
1003 extern vector<process *> processVec;
1004
1005 #endif