?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- added release tag for 2.3.6 to user doc
[bochs-mirror.git] / misc / test-access-check.cc
blob22af4ab04a7e8632c9773efc80af7e0592cc3a30
1 /////////////////////////////////////////////////////////////////////////
2 //
3 // test-access-check.cc
4 // $Id: test-access-check.cc,v 1.3 2001/10/03 13:10:38 bdenney Exp $
5 // by Bryce Denney
6 //
7 // This whole program is intended to test just a few lines in
8 // cpu/access.cc, where it checks if a memory access goes over the
9 // segment limits.
10 //
11 // NOTE: The variable called limit is actually "limit_scaled" in the
12 // bochs code. Limit_scaled is equal to the limit when granularity is 0,
13 // and equal to (limit << 12) | 0xfff when granularity is 1.
14 //
15 // Compile with:
16 // cc -I. -Iinstrument/stubs -o test-access-check misc/test-access-check.cc
17 // Then run "test-access-check" and see how it goes. If mismatches=0,
18 // the rule is good.
19 //
20 ///////////////////////////////////////////////////////////////////////////////
21
22 #include <bochs.h>
23
24 // rule1 is the original rule used in Bochs from 2000-03-25. It has bad
25 // overflow problems.
26 int rule1 (Bit32u limit, Bit32u length, Bit32u offset);
27
28 // rule2 is Bryce's first try, which turned out to have bad underflow problems
29 // instead.
30 int rule2 (Bit32u limit, Bit32u length, Bit32u offset);
31
32 // rule3 is Bryce's second try, which as far as he knows works for all
33 // cases.
34 int rule3 (Bit32u limit, Bit32u length, Bit32u offset);
35
36 // edit this to test other rules.
37 #define TEST_RULE rule3
38
39 typedef struct {
40 Bit32u limit, length, offset, the_answer;
41 } TestStruct;
42
43 TestStruct tests[] = {
44 // limit length offset exception
45 {0x0a, 4, 0, 0},
46 {0x0a, 4, 1, 0},
47 {0x0a, 4, 2, 0},
48 {0x0a, 4, 3, 0},
49 {0x0a, 4, 4, 0},
50 {0x0a, 4, 5, 0},
51 {0x0a, 4, 6, 0},
52 {0x0a, 4, 7, 0},
53 {0x0a, 4, 8, 1},
54 {0x0a, 4, 9, 1},
55 {0x0a, 4, 0x0a, 1},
56 {0x0a, 4, 0x0b, 1},
57 {0x0a, 4, 0x0c, 1},
58 {0x0a, 4, 0xfffffffd, 1},
59 {0x0a, 4, 0xfffffffe, 1},
60 {0x0a, 4, 0xffffffff, 1},
61 {0x0a, 2, 0, 0},
62 {0x0a, 2, 1, 0},
63 {0x0a, 2, 2, 0},
64 {0x0a, 2, 3, 0},
65 {0x0a, 2, 4, 0},
66 {0x0a, 2, 5, 0},
67 {0x0a, 2, 6, 0},
68 {0x0a, 2, 7, 0},
69 {0x0a, 2, 8, 0},
70 {0x0a, 2, 9, 0},
71 {0x0a, 2, 0x0a, 1},
72 {0x0a, 2, 0x0b, 1},
73 {0x0a, 2, 0x0c, 1},
74 {0x0a, 2, 0xfffffffd, 1},
75 {0x0a, 2, 0xfffffffe, 1},
76 {0x0a, 2, 0xffffffff, 1},
77 {0x0a, 1, 0, 0},
78 {0x0a, 1, 1, 0},
79 {0x0a, 1, 2, 0},
80 {0x0a, 1, 3, 0},
81 {0x0a, 1, 4, 0},
82 {0x0a, 1, 5, 0},
83 {0x0a, 1, 6, 0},
84 {0x0a, 1, 7, 0},
85 {0x0a, 1, 8, 0},
86 {0x0a, 1, 9, 0},
87 {0x0a, 1, 0x0a, 0},
88 {0x0a, 1, 0x0b, 1},
89 {0x0a, 1, 0x0c, 1},
90 //
91 // try a few near the common 0xffff boundary
92 //
93 {0xffff, 1, 0, 0},
94 {0xffff, 1, 0x100, 0},
95 {0xffff, 1, 0x1000, 0},
96 {0xffff, 1, 0x8000, 0},
97 {0xffff, 1, 0xf000, 0},
98 {0xffff, 1, 0xfff0, 0},
99 {0xffff, 1, 0xfff1, 0},
100 {0xffff, 1, 0xfff2, 0},
101 {0xffff, 1, 0xfff3, 0},
102 {0xffff, 1, 0xfff4, 0},
103 {0xffff, 1, 0xfff5, 0},
104 {0xffff, 1, 0xfff6, 0},
105 {0xffff, 1, 0xfff7, 0},
106 {0xffff, 1, 0xfff8, 0},
107 {0xffff, 1, 0xfff9, 0},
108 {0xffff, 1, 0xfffa, 0},
109 {0xffff, 1, 0xfffb, 0},
110 {0xffff, 1, 0xfffc, 0},
111 {0xffff, 1, 0xfffd, 0},
112 {0xffff, 1, 0xfffe, 0},
113 {0xffff, 1, 0xffff, 0},
114 {0xffff, 1, 0x10000, 1},
115 {0xffff, 1, 0x10001, 1},
116 {0xffff, 1, 0x10002, 1},
117 {0xffff, 1, 0x10021, 1},
118 {0xffff, 1, 0x40001, 1},
119 {0xffff, 1, 0xffffffff, 1},
120 //
121 // near 0xffff, length 2
122 //
123 {0xffff, 2, 0, 0},
124 {0xffff, 2, 0x100, 0},
125 {0xffff, 2, 0x1000, 0},
126 {0xffff, 2, 0x8000, 0},
127 {0xffff, 2, 0xf000, 0},
128 {0xffff, 2, 0xfff0, 0},
129 {0xffff, 2, 0xfff1, 0},
130 {0xffff, 2, 0xfff2, 0},
131 {0xffff, 2, 0xfff3, 0},
132 {0xffff, 2, 0xfff4, 0},
133 {0xffff, 2, 0xfff5, 0},
134 {0xffff, 2, 0xfff6, 0},
135 {0xffff, 2, 0xfff7, 0},
136 {0xffff, 2, 0xfff8, 0},
137 {0xffff, 2, 0xfff9, 0},
138 {0xffff, 2, 0xfffa, 0},
139 {0xffff, 2, 0xfffb, 0},
140 {0xffff, 2, 0xfffc, 0},
141 {0xffff, 2, 0xfffd, 0},
142 {0xffff, 2, 0xfffe, 0},
143 {0xffff, 2, 0xffff, 1},
144 {0xffff, 2, 0x10000, 1},
145 {0xffff, 2, 0x10001, 1},
146 {0xffff, 2, 0x10002, 1},
147 {0xffff, 2, 0x10021, 1},
148 {0xffff, 2, 0x40001, 1},
149 {0xffff, 2, 0xffffffff, 1},
150 //
151 // near 0xffff, length 4
152 //
153 {0xffff, 4, 0, 0},
154 {0xffff, 4, 0x100, 0},
155 {0xffff, 4, 0x1000, 0},
156 {0xffff, 4, 0x8000, 0},
157 {0xffff, 4, 0xf000, 0},
158 {0xffff, 4, 0xfff0, 0},
159 {0xffff, 4, 0xfff1, 0},
160 {0xffff, 4, 0xfff2, 0},
161 {0xffff, 4, 0xfff3, 0},
162 {0xffff, 4, 0xfff4, 0},
163 {0xffff, 4, 0xfff5, 0},
164 {0xffff, 4, 0xfff6, 0},
165 {0xffff, 4, 0xfff7, 0},
166 {0xffff, 4, 0xfff8, 0},
167 {0xffff, 4, 0xfff9, 0},
168 {0xffff, 4, 0xfffa, 0},
169 {0xffff, 4, 0xfffb, 0},
170 {0xffff, 4, 0xfffc, 0},
171 {0xffff, 4, 0xfffd, 1},
172 {0xffff, 4, 0xfffe, 1},
173 {0xffff, 4, 0xffff, 1},
174 {0xffff, 4, 0x10000, 1},
175 {0xffff, 4, 0x10001, 1},
176 {0xffff, 4, 0x10002, 1},
177 {0xffff, 4, 0x10021, 1},
178 {0xffff, 4, 0x40001, 1},
179 {0xffff, 4, 0xffffffff, 1},
180 //
181 // now a few near the max limit 0xffffffff
182 //
183 {0xffffffff, 1, 0, 0},
184 {0xffffffff, 1, 0x100, 0},
185 {0xffffffff, 1, 0x1000, 0},
186 {0xffffffff, 1, 0x8000, 0},
187 {0xffffffff, 1, 0xf000, 0},
188 {0xffffffff, 1, 0xfff0, 0},
189 {0xffffffff, 1, 0xfff1, 0},
190 {0xffffffff, 1, 0xfff2, 0},
191 {0xffffffff, 1, 0xfff3, 0},
192 {0xffffffff, 1, 0xfff4, 0},
193 {0xffffffff, 1, 0xfff5, 0},
194 {0xffffffff, 1, 0xfff6, 0},
195 {0xffffffff, 1, 0xfff7, 0},
196 {0xffffffff, 1, 0xfff8, 0},
197 {0xffffffff, 1, 0xfff9, 0},
198 {0xffffffff, 1, 0xfffa, 0},
199 {0xffffffff, 1, 0xfffb, 0},
200 {0xffffffff, 1, 0xfffc, 0},
201 {0xffffffff, 1, 0xfffd, 0},
202 {0xffffffff, 1, 0xfffe, 0},
203 {0xffffffff, 1, 0xffff, 0},
204 {0xffffffff, 1, 0x10000, 0},
205 {0xffffffff, 1, 0x10001, 0},
206 {0xffffffff, 1, 0x10002, 0},
207 {0xffffffff, 1, 0x10021, 0},
208 {0xffffffff, 1, 0x40001, 0},
209 {0xffffffff, 1, 0xfffffff0, 0},
210 {0xffffffff, 1, 0xfffffff9, 0},
211 {0xffffffff, 1, 0xfffffffa, 0},
212 {0xffffffff, 1, 0xfffffffb, 0},
213 {0xffffffff, 1, 0xfffffffc, 0},
214 {0xffffffff, 1, 0xfffffffd, 0},
215 {0xffffffff, 1, 0xfffffffe, 0},
216 {0xffffffff, 1, 0xffffffff, 0},
217 {0xffffffff, 1, 0x00000000, 0},
218 {0xffffffff, 1, 0x00000001, 0},
219 {0xffffffff, 1, 0x00000002, 0},
220 {0xffffffff, 1, 0x00000003, 0},
221 {0xffffffff, 1, 0x00000004, 0},
222 {0xffffffff, 1, 0x00000005, 0},
223 //
224 // repeat with length 2
225 //
226 {0xffffffff, 2, 0, 0},
227 {0xffffffff, 2, 0x100, 0},
228 {0xffffffff, 2, 0x1000, 0},
229 {0xffffffff, 2, 0x8000, 0},
230 {0xffffffff, 2, 0xf000, 0},
231 {0xffffffff, 2, 0xfff0, 0},
232 {0xffffffff, 2, 0xfff1, 0},
233 {0xffffffff, 2, 0xfff2, 0},
234 {0xffffffff, 2, 0xfff3, 0},
235 {0xffffffff, 2, 0xfff4, 0},
236 {0xffffffff, 2, 0xfff5, 0},
237 {0xffffffff, 2, 0xfff6, 0},
238 {0xffffffff, 2, 0xfff7, 0},
239 {0xffffffff, 2, 0xfff8, 0},
240 {0xffffffff, 2, 0xfff9, 0},
241 {0xffffffff, 2, 0xfffa, 0},
242 {0xffffffff, 2, 0xfffb, 0},
243 {0xffffffff, 2, 0xfffc, 0},
244 {0xffffffff, 2, 0xfffd, 0},
245 {0xffffffff, 2, 0xfffe, 0},
246 {0xffffffff, 2, 0xffff, 0},
247 {0xffffffff, 2, 0x10000, 0},
248 {0xffffffff, 2, 0x10001, 0},
249 {0xffffffff, 2, 0x10002, 0},
250 {0xffffffff, 2, 0x10021, 0},
251 {0xffffffff, 2, 0x40001, 0},
252 {0xffffffff, 2, 0xfffffff0, 0},
253 {0xffffffff, 2, 0xfffffff9, 0},
254 {0xffffffff, 2, 0xfffffffa, 0},
255 {0xffffffff, 2, 0xfffffffb, 0},
256 {0xffffffff, 2, 0xfffffffc, 0},
257 {0xffffffff, 2, 0xfffffffd, 0},
258 {0xffffffff, 2, 0xfffffffe, 0},
259 {0xffffffff, 2, 0xffffffff, 1},
260 {0xffffffff, 2, 0x00000000, 0},
261 {0xffffffff, 2, 0x00000001, 0},
262 {0xffffffff, 2, 0x00000002, 0},
263 {0xffffffff, 2, 0x00000003, 0},
264 {0xffffffff, 2, 0x00000004, 0},
265 {0xffffffff, 2, 0x00000005, 0},
266 //
267 // repeat with length 4
268 //
269 {0xffffffff, 4, 0, 0},
270 {0xffffffff, 4, 0x100, 0},
271 {0xffffffff, 4, 0x1000, 0},
272 {0xffffffff, 4, 0x8000, 0},
273 {0xffffffff, 4, 0xf000, 0},
274 {0xffffffff, 4, 0xfff0, 0},
275 {0xffffffff, 4, 0xfff1, 0},
276 {0xffffffff, 4, 0xfff2, 0},
277 {0xffffffff, 4, 0xfff3, 0},
278 {0xffffffff, 4, 0xfff4, 0},
279 {0xffffffff, 4, 0xfff5, 0},
280 {0xffffffff, 4, 0xfff6, 0},
281 {0xffffffff, 4, 0xfff7, 0},
282 {0xffffffff, 4, 0xfff8, 0},
283 {0xffffffff, 4, 0xfff9, 0},
284 {0xffffffff, 4, 0xfffa, 0},
285 {0xffffffff, 4, 0xfffb, 0},
286 {0xffffffff, 4, 0xfffc, 0},
287 {0xffffffff, 4, 0xfffd, 0},
288 {0xffffffff, 4, 0xfffe, 0},
289 {0xffffffff, 4, 0xffff, 0},
290 {0xffffffff, 4, 0x10000, 0},
291 {0xffffffff, 4, 0x10001, 0},
292 {0xffffffff, 4, 0x10002, 0},
293 {0xffffffff, 4, 0x10021, 0},
294 {0xffffffff, 4, 0x40001, 0},
295 {0xffffffff, 4, 0xfffffff0, 0},
296 {0xffffffff, 4, 0xfffffff9, 0},
297 {0xffffffff, 4, 0xfffffffa, 0},
298 {0xffffffff, 4, 0xfffffffb, 0},
299 {0xffffffff, 4, 0xfffffffc, 0},
300 {0xffffffff, 4, 0xfffffffd, 1},
301 {0xffffffff, 4, 0xfffffffe, 1},
302 {0xffffffff, 4, 0xffffffff, 1},
303 {0xffffffff, 4, 0x00000000, 0},
304 {0xffffffff, 4, 0x00000001, 0},
305 {0xffffffff, 4, 0x00000002, 0},
306 {0xffffffff, 4, 0x00000003, 0},
307 {0xffffffff, 4, 0x00000004, 0},
308 {0xffffffff, 4, 0x00000005, 0},
309 //
310 // now make some underflow cases to disprove my new rule
311 //
312 {1, 1, 0, 0},
313 {1, 1, 1, 0},
314 {1, 1, 2, 1},
315 {1, 1, 3, 1},
316 {1, 1, 4, 1},
317 {1, 1, 0xfffffffc, 1},
318 {1, 1, 0xfffffffd, 1},
319 {1, 1, 0xfffffffe, 1},
320 {1, 1, 0xffffffff, 1},
321 {1, 2, 0, 0},
322 {1, 2, 1, 1},
323 {1, 2, 2, 1},
324 {1, 2, 3, 1},
325 {1, 2, 4, 1},
326 {1, 2, 0xfffffffc, 1},
327 {1, 2, 0xfffffffd, 1},
328 {1, 2, 0xfffffffe, 1},
329 {1, 2, 0xffffffff, 1},
330 {1, 4, 0, 1},
331 {1, 4, 1, 1},
332 {1, 4, 2, 1},
333 {1, 4, 3, 1},
334 {1, 4, 4, 1},
335 {1, 4, 0xfffffffc, 1},
336 {1, 4, 0xfffffffd, 1},
337 {1, 4, 0xfffffffe, 1},
338 {1, 4, 0xffffffff, 1}
339 };
340
341 int main () {
342 int total=0, mismatches=0;
343 int t;
344 for (t=0; t<sizeof(tests)/sizeof(tests[0]); t++) {
345 TestStruct *ts = &tests[t];
346 int my_answer = TEST_RULE (ts->limit, ts->length, ts->offset);
347 printf ("limit=%x len=%x offset=%x exception=%x %s\n",
348 ts->limit,
349 ts->length,
350 ts->offset,
351 my_answer,
352 (ts->the_answer==my_answer) ? "" : "MISMATCH");
353 if (ts->the_answer!=my_answer) mismatches++;
354 total++;
355 }
356 printf ("mismatches=%d\n", mismatches);
357 printf ("total=%d\n", total);
358 }
359
360 int rule1 (Bit32u limit, Bit32u length, Bit32u offset)
361 {
362 if ((offset + length - 1) > limit) return 1;
363 return 0;
364 }
365
366 int rule2 (Bit32u limit, Bit32u length, Bit32u offset)
367 {
368 if (offset > (limit - length + 1)) return 1;
369 return 0;
370 }
371
372 int rule3 (Bit32u limit, Bit32u length, Bit32u offset)
373 {
374 if (offset > (limit - length + 1) || (length-1 > limit)) {
375 return 1;
376 }
377 return 0;
378 }
Mirror of Bochs CVS