Initialize thrd in a new FrameNode ctor
[dyninst.git] / stackwalk / src / bluegene-swk.h
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #ifndef BLUEGENE_SWK_H
32 #define BLUEGENE_SWK_H
33
34 #include <algorithm>
35 #include "procstate.h"
36 #include "stl_utils.h"
37
38 #ifndef os_bg_ion
39 #error "ERROR: bluegene-swk.h is only for BlueGene ION builds."
40 #endif // os_bg_ion
41
42 // TODO: these bg debugger headers could be merged w/ifdefs in the headers.
43 // TODO: this would make things a little less nasty here.
44 #if   defined(os_bgl)
45 #include "external/bluegene/bgl-debugger-interface.h"
46 #elif defined (os_bgp)
47 #include "external/bluegene/bgp-debugger-interface.h"
48 #else
49 #error "ERROR: No suitable debug interface for this BG ION."
50 #endif
51
52 #define SINGLE_STEP_SIG 32064
53
54 #if !defined(BG_READCACHE_SIZE)
55 #define BG_READCACHE_SIZE 2048
56 #endif
57
58 namespace DebuggerInterface {
59   class DebugEvent;
60 }
61
62 namespace Dyninst {
63   namespace Stackwalker {
64     
65     ///
66     /// This is a base class for the BlueGene 3rd-party stackwalkers.  
67     /// 
68     /// Common functionality is implemented here, and subclasses should
69     /// provide other features such as threads and dynamic library handling.
70     ///
71     class ProcDebugBG : public ProcDebug {
72     protected:
73       virtual bool debug_continue(ThreadState *);
74       virtual bool version_msg();
75       virtual bool debug_waitfor_version_msg();
76       virtual bool debug_handle_event(DebugEvent ev);
77       virtual bool debug_handle_signal(DebugEvent *ev);
78       virtual bool debug_attach(ThreadState *);
79       virtual bool debug_pause(ThreadState *);
80       virtual bool debug_continue_with(ThreadState *, long sig);
81       virtual bool debug_version_msg();
82
83       // default implementation: this is a no-op.  Subclasses should override.
84       virtual bool pollForNewThreads();
85
86       // unsupported -- stub will fail!
87       virtual bool debug_create(std::string, const std::vector<std::string> &);
88
89       ///
90       /// This implements basic BG debugger event -> stackwalker event translation.  It's
91       /// called by the BG implementation of ProcDebug::debug_get_event().
92       /// 
93       /// Subclasses (future BG architecture implementations) should override to handle new 
94       /// event types, then delegate here to handle old ones.
95       ///
96       friend DebugEvent ProcDebug::debug_get_event(bool);
97       virtual void translate_event(const DebuggerInterface::BG_Debugger_Msg& msg, 
98                                    DebugEvent& ev);
99
100       /// BG currently has no asynchronous thread control, so the threads are stopped and
101       /// continued all together.  This applies operations to all threads.
102       template<class Functor> void for_all_threads(Functor f) {
103         for_each(threads.begin(), threads.end(), do_to_second(f));
104       }
105
106     public:
107       virtual bool detach(bool leave_stopped);
108       virtual bool getThreadIds(std::vector<Dyninst::THR_ID> &threads);
109       virtual bool getDefaultThread(Dyninst::THR_ID &default_tid);
110       virtual unsigned getAddressWidth();
111       virtual bool getRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal &val);
112       virtual bool setRegValue(Dyninst::MachRegister reg, Dyninst::THR_ID thread, Dyninst::MachRegisterVal val);
113       virtual bool readMem(void *dest, Dyninst::Address source, size_t size);
114       virtual bool isLibraryTrap(Dyninst::THR_ID thrd);
115       virtual bool cleanOnDetach();
116     protected:
117       ProcDebugBG(Dyninst::PID pid, std::string exe);
118       virtual ~ProcDebugBG();
119
120       /// Creation function for making platform-specific ProcDebugBG
121       /// Need to include an implementation of this in any build that includes 
122       /// ProcDebugBG.
123       static ProcDebug *createProcDebugBG(PID pid, std::string executable);
124
125       /// Clears this process's memory read cache along with register caches 
126       /// from all of its threads.
127       virtual void clear_cache();
128
129       // Protected Data
130       DebuggerInterface::BG_Debugger_Msg::DataArea *mem_data;    // data from memory reads.
131
132       unsigned char *read_cache;
133       Dyninst::Address read_cache_start;
134       unsigned read_cache_size;
135       bool detached;
136       bool write_ack;
137       bool wrote_trap;
138     };
139
140     // helper for dealing with filehandles
141     bool bg_fdHasData(int fd);
142
143     //
144     // Like a regular ThreadState, but with a per-thread register cache.
145     // Also porvides ability to set thread id to account for the way the 
146     // BG debug interface handles threads.
147     //
148     class BGThreadState : public ThreadState {
149     private:
150       friend class ProcDebug;
151       void setTid(Dyninst::THR_ID id) { tid = id; }
152
153     public:
154       BGThreadState(ProcDebug *parent, Dyninst::THR_ID id) 
155         : ThreadState(parent, id), gprs_set(false) 
156       { }
157
158       virtual ~BGThreadState() { }
159
160       DebuggerInterface::BG_GPRSet_t gprs;   // Per-thread register cache.
161       bool gprs_set;                         // Valid flag for register cache.
162       bool write_ack;
163     };
164
165     /// Copy one thread's state to another.  
166     void copy_thread_state(ThreadState *source, ThreadState *dest);
167
168   } // Stackwalker
169 } // Dyninst
170
171 #endif // BLUEGENE_SWK_H