Support for conversion from Instruction API objects to Rose SgAsmInstruction objects...
[dyninst.git] / proccontrol / h / Generator.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 #if !defined (GENERATOR_H_)
31 #define GENERATOR_H_
32
33 #include "dyntypes.h"
34 #include "Decoder.h"
35 #include "PCErrors.h"
36
37 #include "common/src/dthread.h"
38 #include "util.h"
39
40 #include <set>
41 #include <map>
42 #include <string>
43
44 struct GeneratorMTInternals;
45 class int_process;
46
47 namespace Dyninst {
48 namespace ProcControlAPI {
49
50 class Process;
51 class ArchEvent;
52 class Event;
53 class Mailbox;
54
55 class PC_EXPORT Generator
56 {
57  public:
58    static Generator *getDefaultGenerator();
59    static void stopDefaultGenerator();
60    static bool startedAnyGenerator;
61    virtual bool getAndQueueEvent(bool block) = 0;
62    virtual ~Generator();
63    
64    typedef void (*gen_cb_func_t)();
65    static void registerNewEventCB(gen_cb_func_t func);
66    static void removeNewEventCB(gen_cb_func_t);
67    
68    void forceEventBlock();
69
70    //State tracking
71    typedef enum {
72       none,
73       initializing,
74       process_blocked,
75       system_blocked,
76       decoding,
77       statesync,
78       handling,
79       queueing,
80       error,
81       exiting
82    } state_t;
83    state_t state;
84    static const char* generatorStateStr(state_t);
85    virtual bool isExitingState();
86    virtual void setState(state_t newstate);
87    virtual state_t getState();
88
89  protected:
90    //Event handling
91    static std::map<Dyninst::PID, Process *> procs;
92    typedef std::set<Decoder *, decoder_cmp> decoder_set_t;
93    decoder_set_t decoders;
94
95    ArchEvent* m_Event;
96    virtual ArchEvent* getCachedEvent();
97    virtual void setCachedEvent(ArchEvent* ae);
98
99    //Misc
100    virtual bool hasLiveProc();
101    std::string name;
102    Generator(std::string name_);
103    bool getAndQueueEventInt(bool block);
104    static bool allStopped(int_process *proc, void *);
105
106    static std::set<gen_cb_func_t> CBs;
107    static Mutex<> *cb_lock;
108
109    //Public interface
110    //  Implemented by architectures
111    virtual bool initialize() = 0;
112    virtual bool canFastHandle() = 0;
113    virtual ArchEvent *getEvent(bool block) = 0;
114    virtual bool plat_skipGeneratorBlock();
115    //  Implemented by MT or ST
116    virtual bool processWait(bool block) = 0;
117
118    virtual bool plat_continue(ArchEvent* /*evt*/) { return true; }
119    virtual void wake(Dyninst::PID/* proc */, long long /* sequence */) {}
120
121    //  Optional interface for systems that want to return multiple events
122    virtual bool getMultiEvent(bool block, std::vector<ArchEvent *> &events);
123
124   private:
125    bool eventBlock_;
126 };
127
128 class PC_EXPORT GeneratorMT : public Generator
129 {
130  private:
131    GeneratorMTInternals *sync;
132    void main();
133 protected:
134         void lock();
135         void unlock();
136
137  public:
138    void launch(); //Launch thread
139    void start(); //Startup function for new thread
140    virtual void plat_start() {}
141    virtual bool plat_continue(ArchEvent* /*evt*/) { return true;}
142    GeneratorMTInternals *getInternals();
143
144    GeneratorMT(std::string name_);
145    virtual ~GeneratorMT();
146    virtual bool processWait(bool block);
147    virtual bool getAndQueueEvent(bool block);
148 };
149
150 class GeneratorST : public Generator
151 {
152  public:
153    GeneratorST(std::string name_);
154    virtual ~GeneratorST();
155    
156    virtual bool processWait(bool block);
157    virtual bool getAndQueueEvent(bool block);
158 };
159
160 }
161 }
162
163 #endif