URL https://opencores.org/ocsvn/adv_debug_sys/adv_debug_sys/trunk

Subversion Repositories adv_debug_sys

[/] [adv_debug_sys/] [trunk/] [Software/] [AdvancedWatchpointControl/] [src/] [advancedWatchpointControl/] [registerInterpreter.java] - Blame information for rev 51

Go to most recent revision | Details | Compare with Previous | View Log


// This class wraps the basic register set cache.  It adds
// convenience methods so that the UI classes do not need to
// interpret the various bit meanings in the registers.
 
package advancedWatchpointControl;
 
 
public class registerInterpreter {
 
        public enum compareSource  { DISABLED, INSTR_FETCH_ADDR, LOAD_ADDR, STORE_ADDR, LOAD_DATA, STORE_DATA,
                LOAD_STORE_ADDR, LOAD_STORE_DATA }
        public enum compareType  { MASKED, EQ, LT, LE, GT, GE, NE }
        public enum chainType { NONE, AND, OR }
 
        private targetDebugRegisterSet registers;
 
        public registerInterpreter(targetDebugRegisterSet regs) {
                registers = regs;
        }
 
 
        public boolean isWPImplemented(int whichWP) {
                long exists = registers.getDCR(whichWP) & 0x1;
                if(exists != 0) return true;
                else return false;
        }
 
        public boolean getWPBreakEnabled(int whichWP) {
                long enabled = (registers.getDMR2() >> (12+whichWP)) & 0x1;
                if(enabled != 0) return true;
                else return false;
        }
 
        public void setWPBreakEnabled(int whichWP, boolean enabled) {
                long maskval = 0x1 << (12+whichWP);
                if(enabled) {
                        registers.setDMR2(registers.getDMR2() | maskval);
                }
                else {
                        registers.setDMR2(registers.getDMR2() & (~maskval));
                }
        }
 
        public compareSource getWPCompareSource(int whichWP) {
                int src = (int)((registers.getDCR(whichWP) >> 5) & 0x7);
                compareSource ret = compareSource.DISABLED;
                switch(src) {
                        case 0:
                                ret = compareSource.DISABLED;
                                break;
                        case 1:
                                ret = compareSource.INSTR_FETCH_ADDR;
                                break;
                        case 2:
                                ret = compareSource.LOAD_ADDR;
                                break;
                        case  3:
                                ret = compareSource.STORE_ADDR;
                                break;
                        case  4:
                                ret = compareSource.LOAD_DATA;
                                break;
                        case  5:
                                ret = compareSource.STORE_DATA;
                                break;
                        case  6:
                                ret = compareSource.LOAD_STORE_ADDR;
                                break;
                        case  7:
                                ret = compareSource.LOAD_STORE_DATA;
                                break;
                }
                return ret;
        }
 
        public void setWPCompareSource(int whichWP, compareSource src) {
                long val = 0;
                switch(src) {
                case DISABLED:
                        val = 0;
                        break;
                case INSTR_FETCH_ADDR:
                        val = 1;
                        break;
                case LOAD_ADDR:
                        val = 2;
                        break;
                case STORE_ADDR:
                        val = 3;
                        break;
                case LOAD_DATA:
                        val = 4;
                        break;
                case STORE_DATA:
                        val = 5;
                        break;
                case LOAD_STORE_ADDR:
                        val = 6;
                        break;
                case LOAD_STORE_DATA:
                        val = 7;
                        break;
                }
                val = val << 5;
                long mask = 7 << 5;
                long tmp = registers.getDCR(whichWP) & (~mask);
                tmp |= val;
                registers.setDCR(whichWP, val);
        }
 
        public compareType getWPCompareType(int whichWP) {
                int src = (int)((registers.getDCR(whichWP) >> 1) & 0x7);
                compareType ret = compareType.MASKED;
                switch(src) {
                        case 0:
                                ret = compareType.MASKED;
                                break;
                        case 1:
                                ret = compareType.EQ;
                                break;
                        case 2:
                                ret = compareType.LT;
                                break;
                        case  3:
                                ret = compareType.LE;
                                break;
                        case  4:
                                ret = compareType.GT;
                                break;
                        case  5:
                                ret = compareType.GE;
                                break;
                        case  6:
                                ret = compareType.NE;
                                break;
                }
                return ret;
        }
 
        public void setWPCompareType(int whichWP, compareType type) {
                long val = 0;
                switch(type) {
                case MASKED:
                        val = 0;
                        break;
                case EQ:
                        val = 1;
                        break;
                case LT:
                        val = 2;
                        break;
                case LE:
                        val = 3;
                        break;
                case GT:
                        val = 4;
                        break;
                case GE:
                        val = 5;
                        break;
                case NE:
                        val = 6;
                        break;
 
                }
                val = val << 1;
                long mask = 7 << 1;
                long tmp = registers.getDCR(whichWP);
                tmp &= (~mask);
                tmp |= val;
                registers.setDCR(whichWP, tmp);
        }
 
        public boolean getWPSignedCompare(int whichWP) {
                long enabled = registers.getDCR(whichWP) & 0x10;
                if(enabled != 0) return true;
                else return false;
        }
 
        public void setWPSignedCompare(int whichWP, boolean signed) {
                long maskval = 0x10;
                long tmp = registers.getDCR(whichWP);
                if(signed) tmp |= maskval;
                else tmp &= (~maskval);
                registers.setDCR(whichWP, tmp);
        }
 
        public chainType getWPChainType(int whichWP) {
                int src = (int)((registers.getDMR1() >> (2*whichWP)) & 0x3);
                chainType ret = chainType.NONE;
                switch(src) {
                        case 0:
                                ret = chainType.NONE;
                                break;
                        case 1:
                                ret = chainType.AND;
                                break;
                        case 2:
                                ret = chainType.OR;
                                break;
                }
                return ret;
        }
 
        public void setWPChainType(int whichWP, chainType type) {
                long val = 0;
                switch(type) {
                case NONE:
                        val = 0;
                        break;
                case AND:
                        val = 1;
                        break;
                case OR:
                        val = 2;
                        break;
                }
                val = val << (2*whichWP);
                long mask = 3 << (2*whichWP);
                long tmp = registers.getDMR1() & (~mask);
                tmp |= val;
                registers.setDMR1(val);
        }
 
        public int getWPCounterAssign(int whichWP) {
                int val = (int)((registers.getDMR2() >> (2 + whichWP)) & 0x1);
                return val;
        }
 
        // Note that for this method, indexes 8 and 9 are valid
        // (they indicate counter 0 and counter 1, respectively).
        public void setWPCounterAssign(int whichWP, int counter) {
                long val = (counter & 0x1) << (2+whichWP);
                long mask = 0x1 << (2+whichWP);
                long tmp = registers.getDMR2();
                tmp &= (~mask);
                tmp |= val;
                registers.setDMR2(tmp);
        }
 
        public boolean didWPCauseBreak(int whichWP) {
                int val = (int)((registers.getDMR2() >> (22+whichWP)) & 0x1);
                if(val == 0) return false;
                else return true;
        }
 
        public boolean getCounterEnabled(int whichCounter) {
                int enabled = (int)((registers.getDMR2() >> (whichCounter&0x1)) & 0x1);
                if(enabled != 0) return true;
                else return false;
        }
 
 
        public void setCounterEnabled(int whichCounter, boolean enabled) {
                long maskval = 0x1 << (whichCounter & 0x1);
                long tmp = registers.getDMR2();
                if(enabled) tmp |= maskval;
                else tmp &= (~maskval);
                registers.setDMR2(tmp);
        }
 
 
        public boolean getCounterBreakEnabled(int whichCounter) {
                int enabled = (int)((registers.getDMR2() >> (20+whichCounter)) & 0x1);
                if(enabled != 0) return true;
                else return false;
        }
 
 
        public void setCounterBreakEnabled(int whichCounter, boolean enabled) {
                long maskval = 0x1 << (20+whichCounter);
                long tmp = registers.getDMR2();
                if(enabled) tmp |= maskval;
                else tmp &= (~maskval);
                registers.setDMR2(tmp);
        }
 
        public boolean didCounterCauseBreak(int whichCounter) {
                int val = (int)((registers.getDMR2() >> (30+whichCounter)) & 0x1);
                if(val == 0) return false;
                else return true;
        }
 
        public int getCounterWatchValue(int whichCounter) {
                int val = 0;
                if(whichCounter == 0) val = (int)((registers.getDWCR0() >> 16) & 0xFFFF);
                else val = (int)((registers.getDWCR1() >> 16) & 0xFFFF);
                return val;
        }
 
        public void setCounterWatchValue(int whichCounter, int value) {
                long val = (value & 0xFFFF) << 16;
                long mask = 0x0000FFFF;
                long tmp;
                if(whichCounter == 0) {
                        tmp = registers.getDWCR0();
                        tmp &= mask;
                        tmp |= val;
                        registers.setDWCR0(tmp);
                } else {
                        tmp = registers.getDWCR1();
                        tmp &= mask;
                        tmp |= val;
                        registers.setDWCR1(tmp);
                }
        }
 
        public int getCounterCountValue(int whichCounter) {
                int val = 0;
                if(whichCounter == 0) val = (int)(registers.getDWCR0() & 0xFFFF);
                else val = (int)(registers.getDWCR1() & 0xFFFF);
                return val;
        }
 
        public void setCounterCountValue(int whichCounter, int value) {
                long val = value & 0xFFFF;
                long mask = 0xFFFF0000;
                long tmp;
                if(whichCounter == 0) {
                        tmp = registers.getDWCR0();
                        tmp &= mask;
                        tmp |= val;
                        registers.setDWCR0(tmp);
                } else {
                        tmp = registers.getDWCR1();
                        tmp &= mask;
                        tmp |= val;
                        registers.setDWCR1(tmp);
                }
        }
 
 
        public chainType getCounterChainType(int whichCounter) {
                int src = (int)((registers.getDMR1() >> (16+(2*whichCounter))) & 0x3);
                chainType ret = chainType.NONE;
                switch(src) {
                        case 0:
                                ret = chainType.NONE;
                                break;
                        case 1:
                                ret = chainType.AND;
                                break;
                        case 2:
                                ret = chainType.OR;
                                break;
                }
                return ret;
        }
 
        public void setCounterChainType(int whichCounter, chainType type) {
                long val = 0;
                switch(type) {
                case NONE:
                        val = 0;
                        break;
                case AND:
                        val = 1;
                        break;
                case OR:
                        val = 2;
                        break;
                }
                val = val << (16+(2*whichCounter));
                long mask = 3 << (16+(2*whichCounter));
                long tmp = registers.getDMR1();
                tmp &= (~mask);
                tmp |= val;
                registers.setDMR1(tmp);
        }
 
        public void setDVR(int which, long val) {
                registers.setDVR(which, val);
        }
 
        public long getDVR(int which) {
                return registers.getDVR(which);
        }
 
}

Browse

Tools

Subversion Repositories adv_debug_sys

[/] [adv_debug_sys/] [trunk/] [Software/] [AdvancedWatchpointControl/] [src/] [advancedWatchpointControl/] [registerInterpreter.java] - Blame information for rev 51

Line No.	Rev	Author	Line
1	51	nyawn	`// This class wraps the basic register set cache. It adds`
2			`// convenience methods so that the UI classes do not need to`
3			`// interpret the various bit meanings in the registers.`
4
5			`package advancedWatchpointControl;`
6
7
8			`public class registerInterpreter {`
9
10			`public enum compareSource { DISABLED, INSTR_FETCH_ADDR, LOAD_ADDR, STORE_ADDR, LOAD_DATA, STORE_DATA,`
11			`LOAD_STORE_ADDR, LOAD_STORE_DATA }`
12			`public enum compareType { MASKED, EQ, LT, LE, GT, GE, NE }`
13			`public enum chainType { NONE, AND, OR }`
14
15			`private targetDebugRegisterSet registers;`
16
17			`public registerInterpreter(targetDebugRegisterSet regs) {`
18			`registers = regs;`
19			`}`
20
21
22			`public boolean isWPImplemented(int whichWP) {`
23			`long exists = registers.getDCR(whichWP) & 0x1;`
24			`if(exists != 0) return true;`
25			`else return false;`
26			`}`
27
28			`public boolean getWPBreakEnabled(int whichWP) {`
29			`long enabled = (registers.getDMR2() >> (12+whichWP)) & 0x1;`
30			`if(enabled != 0) return true;`
31			`else return false;`
32			`}`
33
34			`public void setWPBreakEnabled(int whichWP, boolean enabled) {`
35			`long maskval = 0x1 << (12+whichWP);`
36			`if(enabled) {`
37			`registers.setDMR2(registers.getDMR2() \| maskval);`
38			`}`
39			`else {`
40			`registers.setDMR2(registers.getDMR2() & (~maskval));`
41			`}`
42			`}`
43
44			`public compareSource getWPCompareSource(int whichWP) {`
45			`int src = (int)((registers.getDCR(whichWP) >> 5) & 0x7);`
46			`compareSource ret = compareSource.DISABLED;`
47			`switch(src) {`
48			`case 0:`
49			`ret = compareSource.DISABLED;`
50			`break;`
51			`case 1:`
52			`ret = compareSource.INSTR_FETCH_ADDR;`
53			`break;`
54			`case 2:`
55			`ret = compareSource.LOAD_ADDR;`
56			`break;`
57			`case 3:`
58			`ret = compareSource.STORE_ADDR;`
59			`break;`
60			`case 4:`
61			`ret = compareSource.LOAD_DATA;`
62			`break;`
63			`case 5:`
64			`ret = compareSource.STORE_DATA;`
65			`break;`
66			`case 6:`
67			`ret = compareSource.LOAD_STORE_ADDR;`
68			`break;`
69			`case 7:`
70			`ret = compareSource.LOAD_STORE_DATA;`
71			`break;`
72			`}`
73			`return ret;`
74			`}`
75
76			`public void setWPCompareSource(int whichWP, compareSource src) {`
77			`long val = 0;`
78			`switch(src) {`
79			`case DISABLED:`
80			`val = 0;`
81			`break;`
82			`case INSTR_FETCH_ADDR:`
83			`val = 1;`
84			`break;`
85			`case LOAD_ADDR:`
86			`val = 2;`
87			`break;`
88			`case STORE_ADDR:`
89			`val = 3;`
90			`break;`
91			`case LOAD_DATA:`
92			`val = 4;`
93			`break;`
94			`case STORE_DATA:`
95			`val = 5;`
96			`break;`
97			`case LOAD_STORE_ADDR:`
98			`val = 6;`
99			`break;`
100			`case LOAD_STORE_DATA:`
101			`val = 7;`
102			`break;`
103			`}`
104			`val = val << 5;`
105			`long mask = 7 << 5;`
106			`long tmp = registers.getDCR(whichWP) & (~mask);`
107			`tmp \|= val;`
108			`registers.setDCR(whichWP, val);`
109			`}`
110
111			`public compareType getWPCompareType(int whichWP) {`
112			`int src = (int)((registers.getDCR(whichWP) >> 1) & 0x7);`
113			`compareType ret = compareType.MASKED;`
114			`switch(src) {`
115			`case 0:`
116			`ret = compareType.MASKED;`
117			`break;`
118			`case 1:`
119			`ret = compareType.EQ;`
120			`break;`
121			`case 2:`
122			`ret = compareType.LT;`
123			`break;`
124			`case 3:`
125			`ret = compareType.LE;`
126			`break;`
127			`case 4:`
128			`ret = compareType.GT;`
129			`break;`
130			`case 5:`
131			`ret = compareType.GE;`
132			`break;`
133			`case 6:`
134			`ret = compareType.NE;`
135			`break;`
136			`}`
137			`return ret;`
138			`}`
139
140			`public void setWPCompareType(int whichWP, compareType type) {`
141			`long val = 0;`
142			`switch(type) {`
143			`case MASKED:`
144			`val = 0;`
145			`break;`
146			`case EQ:`
147			`val = 1;`
148			`break;`
149			`case LT:`
150			`val = 2;`
151			`break;`
152			`case LE:`
153			`val = 3;`
154			`break;`
155			`case GT:`
156			`val = 4;`
157			`break;`
158			`case GE:`
159			`val = 5;`
160			`break;`
161			`case NE:`
162			`val = 6;`
163			`break;`
164
165			`}`
166			`val = val << 1;`
167			`long mask = 7 << 1;`
168			`long tmp = registers.getDCR(whichWP);`
169			`tmp &= (~mask);`
170			`tmp \|= val;`
171			`registers.setDCR(whichWP, tmp);`
172			`}`
173
174			`public boolean getWPSignedCompare(int whichWP) {`
175			`long enabled = registers.getDCR(whichWP) & 0x10;`
176			`if(enabled != 0) return true;`
177			`else return false;`
178			`}`
179
180			`public void setWPSignedCompare(int whichWP, boolean signed) {`
181			`long maskval = 0x10;`
182			`long tmp = registers.getDCR(whichWP);`
183			`if(signed) tmp \|= maskval;`
184			`else tmp &= (~maskval);`
185			`registers.setDCR(whichWP, tmp);`
186			`}`
187
188			`public chainType getWPChainType(int whichWP) {`
189			`int src = (int)((registers.getDMR1() >> (2*whichWP)) & 0x3);`
190			`chainType ret = chainType.NONE;`
191			`switch(src) {`
192			`case 0:`
193			`ret = chainType.NONE;`
194			`break;`
195			`case 1:`
196			`ret = chainType.AND;`
197			`break;`
198			`case 2:`
199			`ret = chainType.OR;`
200			`break;`
201			`}`
202			`return ret;`
203			`}`
204
205			`public void setWPChainType(int whichWP, chainType type) {`
206			`long val = 0;`
207			`switch(type) {`
208			`case NONE:`
209			`val = 0;`
210			`break;`
211			`case AND:`
212			`val = 1;`
213			`break;`
214			`case OR:`
215			`val = 2;`
216			`break;`
217			`}`
218			`val = val << (2*whichWP);`
219			`long mask = 3 << (2*whichWP);`
220			`long tmp = registers.getDMR1() & (~mask);`
221			`tmp \|= val;`
222			`registers.setDMR1(val);`
223			`}`
224
225			`public int getWPCounterAssign(int whichWP) {`
226			`int val = (int)((registers.getDMR2() >> (2 + whichWP)) & 0x1);`
227			`return val;`
228			`}`
229
230			`// Note that for this method, indexes 8 and 9 are valid`
231			`// (they indicate counter 0 and counter 1, respectively).`
232			`public void setWPCounterAssign(int whichWP, int counter) {`
233			`long val = (counter & 0x1) << (2+whichWP);`
234			`long mask = 0x1 << (2+whichWP);`
235			`long tmp = registers.getDMR2();`
236			`tmp &= (~mask);`
237			`tmp \|= val;`
238			`registers.setDMR2(tmp);`
239			`}`
240
241			`public boolean didWPCauseBreak(int whichWP) {`
242			`int val = (int)((registers.getDMR2() >> (22+whichWP)) & 0x1);`
243			`if(val == 0) return false;`
244			`else return true;`
245			`}`
246
247			`public boolean getCounterEnabled(int whichCounter) {`
248			`int enabled = (int)((registers.getDMR2() >> (whichCounter&0x1)) & 0x1);`
249			`if(enabled != 0) return true;`
250			`else return false;`
251			`}`
252
253
254			`public void setCounterEnabled(int whichCounter, boolean enabled) {`
255			`long maskval = 0x1 << (whichCounter & 0x1);`
256			`long tmp = registers.getDMR2();`
257			`if(enabled) tmp \|= maskval;`
258			`else tmp &= (~maskval);`
259			`registers.setDMR2(tmp);`
260			`}`
261
262
263			`public boolean getCounterBreakEnabled(int whichCounter) {`
264			`int enabled = (int)((registers.getDMR2() >> (20+whichCounter)) & 0x1);`
265			`if(enabled != 0) return true;`
266			`else return false;`
267			`}`
268
269
270			`public void setCounterBreakEnabled(int whichCounter, boolean enabled) {`
271			`long maskval = 0x1 << (20+whichCounter);`
272			`long tmp = registers.getDMR2();`
273			`if(enabled) tmp \|= maskval;`
274			`else tmp &= (~maskval);`
275			`registers.setDMR2(tmp);`
276			`}`
277
278			`public boolean didCounterCauseBreak(int whichCounter) {`
279			`int val = (int)((registers.getDMR2() >> (30+whichCounter)) & 0x1);`
280			`if(val == 0) return false;`
281			`else return true;`
282			`}`
283
284			`public int getCounterWatchValue(int whichCounter) {`
285			`int val = 0;`
286			`if(whichCounter == 0) val = (int)((registers.getDWCR0() >> 16) & 0xFFFF);`
287			`else val = (int)((registers.getDWCR1() >> 16) & 0xFFFF);`
288			`return val;`
289			`}`
290
291			`public void setCounterWatchValue(int whichCounter, int value) {`
292			`long val = (value & 0xFFFF) << 16;`
293			`long mask = 0x0000FFFF;`
294			`long tmp;`
295			`if(whichCounter == 0) {`
296			`tmp = registers.getDWCR0();`
297			`tmp &= mask;`
298			`tmp \|= val;`
299			`registers.setDWCR0(tmp);`
300			`} else {`
301			`tmp = registers.getDWCR1();`
302			`tmp &= mask;`
303			`tmp \|= val;`
304			`registers.setDWCR1(tmp);`
305			`}`
306			`}`
307
308			`public int getCounterCountValue(int whichCounter) {`
309			`int val = 0;`
310			`if(whichCounter == 0) val = (int)(registers.getDWCR0() & 0xFFFF);`
311			`else val = (int)(registers.getDWCR1() & 0xFFFF);`
312			`return val;`
313			`}`
314
315			`public void setCounterCountValue(int whichCounter, int value) {`
316			`long val = value & 0xFFFF;`
317			`long mask = 0xFFFF0000;`
318			`long tmp;`
319			`if(whichCounter == 0) {`
320			`tmp = registers.getDWCR0();`
321			`tmp &= mask;`
322			`tmp \|= val;`
323			`registers.setDWCR0(tmp);`
324			`} else {`
325			`tmp = registers.getDWCR1();`
326			`tmp &= mask;`
327			`tmp \|= val;`
328			`registers.setDWCR1(tmp);`
329			`}`
330			`}`
331
332
333			`public chainType getCounterChainType(int whichCounter) {`
334			`int src = (int)((registers.getDMR1() >> (16+(2*whichCounter))) & 0x3);`
335			`chainType ret = chainType.NONE;`
336			`switch(src) {`
337			`case 0:`
338			`ret = chainType.NONE;`
339			`break;`
340			`case 1:`
341			`ret = chainType.AND;`
342			`break;`
343			`case 2:`
344			`ret = chainType.OR;`
345			`break;`
346			`}`
347			`return ret;`
348			`}`
349
350			`public void setCounterChainType(int whichCounter, chainType type) {`
351			`long val = 0;`
352			`switch(type) {`
353			`case NONE:`
354			`val = 0;`
355			`break;`
356			`case AND:`
357			`val = 1;`
358			`break;`
359			`case OR:`
360			`val = 2;`
361			`break;`
362			`}`
363			`val = val << (16+(2*whichCounter));`
364			`long mask = 3 << (16+(2*whichCounter));`
365			`long tmp = registers.getDMR1();`
366			`tmp &= (~mask);`
367			`tmp \|= val;`
368			`registers.setDMR1(tmp);`
369			`}`
370
371			`public void setDVR(int which, long val) {`
372			`registers.setDVR(which, val);`
373			`}`
374
375			`public long getDVR(int which) {`
376			`return registers.getDVR(which);`
377			`}`
378
379			`}`