1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
|
/*
class cl_mem: public cl_guiobj
{
public:
char *addr_format, *data_format;
ulong mask;
enum mem_class type;
char *class_name;
union {
void *mem;
uchar *umem8;
};
//class cl_memloc_coll *read_locs, *write_locs;
t_addr size;
int width; // in bits
class cl_uc *uc;
t_addr dump_finished;
public:
cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
class cl_uc *auc);
virtual ~cl_mem(void);
virtual int init(void);
virtual char *id_string(void);
virtual int get_cell_flag(t_addr //addr
) { return(CELL_NORMAL); }
virtual bool get_cell_flag(t_addr //addr
, int //flag
)
{ return(DD_FALSE); }
virtual void set_cell_flag(t_addr addr, bool set_to, int flag) {}
virtual t_mem read(t_addr addr);
virtual t_mem read(t_addr addr, enum hw_cath //skip
) {return(read(addr));}
virtual t_mem get(t_addr addr);
virtual t_mem write(t_addr addr, t_mem val);
virtual void set(t_addr addr, t_mem val);
virtual void set_bit1(t_addr addr, t_mem bits);
virtual void set_bit0(t_addr addr, t_mem bits);
virtual void write_bit1(t_addr addr, t_mem bits) { set_bit1(addr, bits); }
virtual void write_bit0(t_addr addr, t_mem bits) { set_bit0(addr, bits); }
virtual t_mem add(t_addr addr, long what);
virtual t_mem wadd(t_addr addr, long what) { return(add(addr, what)); }
virtual t_addr dump(t_addr start, t_addr stop, int bpl,
class cl_console *con);
virtual t_addr dump(class cl_console *con);
virtual bool search_next(bool case_sensitive,
t_mem *array, int len, t_addr *addr);
virtual class cl_cell *get_cell(t_addr addr) {return(0);}
virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
bool announce)
{ return(0); }
virtual void set_brk(t_addr //addr
, class cl_brk *//brk
) {}
virtual void del_brk(t_addr addr, class cl_brk *brk) {}
#ifdef STATISTIC
virtual unsigned long get_nuof_reads(void) {return(0);}
virtual unsigned long get_nuof_writes(void) {return(0);}
virtual void set_nuof_reads(unsigned long value) {}
virtual void set_nuof_writes(unsigned long value) {}
#endif
};
*/
/*
class cl_mapped_cell: public cl_cell
{
protected:
class cl_cell *real_cell;
public:
cl_mapped_cell(class cl_cell *realcell);
virtual ~cl_mapped_cell(void);
virtual t_mem read(void);
virtual t_mem read(enum hw_cath skip);
virtual t_mem get(void);
virtual t_mem write(t_mem val);
virtual t_mem set(t_mem val);
virtual t_mem add(long what);
virtual t_mem wadd(long what);
virtual void set_bit1(t_mem bits);
virtual void set_bit0(t_mem bits);
virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
virtual class cl_hw *get_hw(int ith);
virtual class cl_event_handler *get_event_handler(void);
};
*/
class cl_m: public cl_memory
{
protected:
class cl_cell **array;
class cl_cell *dummy;
t_addr bus_mask;
public:
//t_addr size;
enum mem_class type;
public:
cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
class cl_uc *auc);
cl_m(t_addr asize, int awidth);
virtual ~cl_m(void);
virtual int init(void);
virtual char *id_string(void);
virtual int get_cell_flag(t_addr addr);
virtual bool get_cell_flag(t_addr addr, int flag);
virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
virtual t_mem read(t_addr addr);
virtual t_mem read(t_addr addr, enum hw_cath skip);
virtual t_mem get(t_addr addr);
virtual t_mem write(t_addr addr, t_mem val);
virtual void set(t_addr addr, t_mem val);
virtual class cl_cell *get_cell(t_addr addr);
virtual void set_bit1(t_addr addr, t_mem bits);
virtual void set_bit0(t_addr addr, t_mem bits);
virtual void write_bit1(t_addr addr, t_mem bits);
virtual void write_bit0(t_addr addr, t_mem bits);
virtual t_mem add(t_addr addr, long what);
virtual t_mem wadd(t_addr addr, long what);
virtual bool search_next(bool case_sensitive,
t_mem *array, int len, t_addr *addr);
virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
bool announce);
virtual void set_brk(t_addr addr, class cl_brk *brk);
virtual void del_brk(t_addr addr, class cl_brk *brk);
#ifdef STATISTIC
virtual unsigned long get_nuof_reads(void);
virtual unsigned long get_nuof_writes(void);
virtual void set_nuof_reads(unsigned long value);
virtual void set_nuof_writes(unsigned long value);
#endif
};
class cl_normal_cell: public cl_cell
{
public:
t_mem data;
TYPE_UBYTE type; // See CELL_XXXX
//protected:
public:
cl_normal_cell(uchar awidth);
//virtual void destroy(void) {}
virtual TYPE_UBYTE get_type(void) { return(type); }
virtual void set_type(TYPE_UBYTE what) { type= what; }
virtual t_mem read(void) {
#ifdef STATISTIC
nuof_reads++;
#endif
return(data);
}
virtual t_mem read(enum hw_cath skip) { return(data); }
virtual t_mem get(void) { return(data); }
virtual t_mem write(t_mem val) {
data= val & mask;
#ifdef STATISTIC
nuof_writes++;
#endif
return(data);
}
virtual t_mem set(t_mem val) { return(data= val & mask); }
virtual t_mem add(long what);
virtual t_mem wadd(long what);
virtual void set_bit1(t_mem bits);
virtual void set_bit0(t_mem bits);
virtual class cl_cell *add_hw(class cl_hw *hw, int *ith)
{ return(0); }
virtual class cl_hw *get_hw(int ith) { return(0); }
//virtual class cl_brk *get_brk(void) { return(0); }
virtual class cl_event_handler *get_event_handler(void) { return(0); }
};
class cl_registered_cell: public cl_memory_cell
{
public:
//class cl_list *hws;
class cl_hw **hardwares;
int nuof_hws;
public:
cl_registered_cell(uchar awidth);
virtual ~cl_registered_cell(void);
//virtual void destroy(void);
virtual t_mem read(void);
virtual t_mem read(enum hw_cath skip);
virtual t_mem write(t_mem val);
virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
virtual class cl_hw *get_hw(int ith);
};
class cl_event_cell: public cl_normal_cell
{
protected:
class cl_event_handler *eh;
public:
cl_event_cell(uchar awidth, class cl_uc *auc);
virtual ~cl_event_cell(void);
virtual t_mem read(void);
virtual t_mem write(t_mem val);
//virtual void event(void);
//virtual class cl_brk *get_brk(void) { return(brk); }
virtual class cl_event_handler *get_event_handler(void) { return(eh); }
};
class cl_ev_reg_cell: public cl_registered_cell
{
protected:
class cl_event_handler *eh;
public:
cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
virtual ~cl_ev_reg_cell(void);
virtual t_mem read(void);
virtual t_mem write(t_mem val);
//virtual void event(void);
//virtual class cl_brk *get_brk(void) { return(brk); }
virtual class cl_event_handler *get_event_handler(void) { return(eh); }
};
/*
* 2nd version memory system
*/
class cl_cell: public cl_base
{
public:
cl_cell(void);
public:
virtual t_mem read(void)= 0;
virtual t_mem read(enum hw_cath skip)=0;
virtual t_mem get(void)=0;
virtual t_mem write(t_mem val)=0;
virtual t_mem set(t_mem val)=0;
virtual t_mem add(long what)=0;
virtual t_mem wadd(long what)=0;
virtual void set_bit1(t_mem bits)=0;
virtual void set_bit0(t_mem bits)=0;
virtual class cl_cell *add_hw(class cl_hw *hw, int *ith)=0;
virtual class cl_hw *get_hw(int ith)=0;
virtual class cl_event_handler *get_event_handler(void)=0;
};
/*
*/
class cl_event_handler: public cl_base
{
public:
class cl_list *read_bps, *write_bps;
class cl_uc *uc;
public:
cl_event_handler(class cl_uc *auc);
virtual ~cl_event_handler(void);
virtual void write(void);
virtual void read(void);
virtual int add_bp(class cl_brk *bp);
virtual int copy_from(class cl_event_handler *eh);
virtual bool del_bp(class cl_brk *bp);
};
|
