Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / dyninst / test_mem_util.c
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 /* FIXME Remove assert() calls from this file, then remove this #include */
32 #include <assert.h>
33 #include <string.h>
34
35 #include "../src/dyninst/test_mem_util.h"
36 #include "../src/mutatee_util.h"
37
38 /* Sun Forte/WorkShop cc releases older than 6.2 do not like these defines: */
39 /* (macro versions of these calls are in test_mem_util.h) */
40 #if defined(__SUNPRO_C) && (__SUNPRO_C < 0x530)
41 void passorfail(int i, int p, char* d, char* r)
42 {
43   if(p) {
44     logerror("Passed test #%d (%s)\n", (i), (d));
45     passedTest[(i)] = TRUE;
46   } else {
47     logerror("\n**Failed** test #%d (%s): %s\n", (i), (d), (r));
48   }
49 }
50
51 void skiptest(int i, char* d)
52 {
53   logerror("Skipping test #%d (%s)\n", (i), (d));
54   logerror("    not implemented on this platform\n");
55   passedTest[(i)] = TRUE;
56 }
57 #endif
58
59 int result_of_loadsnstores;
60
61 unsigned int loadCnt = 0;
62 unsigned int storeCnt = 0;
63 unsigned int prefeCnt = 0;
64 unsigned int accessCnt = 0;
65
66 unsigned int accessCntEA = 0;
67 unsigned int accessCntBC = 0;
68 int doomEA = 0;
69 int doomBC = 0;
70 void* eaList[1000];
71 unsigned int bcList[1000];
72 void* eaExp[1000];
73
74 unsigned int accessCntEAcc = 0;
75 unsigned int accessCntBCcc = 0;
76 int doomEAcc = 0;
77 int doomBCcc = 0;
78 void* eaListCC[1000];
79 unsigned int bcListCC[1000];
80 void* eaExpCC[1000];
81 unsigned int bcExpCC[1000];
82
83 #ifdef sparc_sun_solaris2_4_test
84 /* const */ unsigned int loadExp=15;
85 /* const */ unsigned int storeExp=13;
86 /* const */ unsigned int prefeExp=2;
87 /* const */ unsigned int accessExp=26;
88 /* const */ unsigned int accessExpCC=26;
89
90 unsigned int bcExp[] = { 4,1,2,8,4,1,1,  4,8,4,  4,4,8,8,16,
91                          0,0,  1,2,4,8,  4,8,16,4,8 };
92
93 int eaExpOffset[] =    { 0,3,2,0,0,3,3,  0,0,0,  0,0,0,0,0,
94                          0,0,  7,6,4,0,  0,0,0,4,0 };
95
96 /* _inline */ void init_test_data()
97 {
98   int i=0;
99
100   /*
101   dprintf("&divarw = %p\n", &divarw);
102   dprintf("&dfvars = %p\n", &dfvars);
103   dprintf("&dfvard = %p\n", &dfvard);
104   dprintf("&dfvarq = %p\n", &dfvarq);
105   */
106
107   for(; i<10; ++i)
108     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
109
110   for(; i<12; ++i)
111     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
112
113   for(; i<14; ++i)
114     eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
115
116   for(; i<17; ++i)
117     eaExp[i] = (void*)((unsigned long)&dfvarq + eaExpOffset[i]);
118
119   for(; i<21; ++i)
120     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
121
122   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
123   ++i;
124
125   eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
126   ++i;
127
128   eaExp[i] = (void*)((unsigned long)&dfvarq + eaExpOffset[i]);
129   ++i;
130
131   for(; i<26; ++i)
132     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
133
134   /* Duplicate the stream for cc */
135   for(i=0; i<accessExp; ++i) {
136     eaExpCC[i] = eaExp[i];
137     bcExpCC[i] = bcExp[i];
138   }
139 }
140 #endif /* defined(sparc_sun_solaris2_4_test) */
141
142 #ifdef rs6000_ibm_aix4_1_test
143 const unsigned int loadExp=41;
144 const unsigned int storeExp=32;
145 const unsigned int prefeExp=0;
146 const unsigned int accessExp=73;
147 const unsigned int accessExpCC=73;
148
149 unsigned int bcExp[] = { 4,  1,1,1,1,  2,2,2,2,  2,2,2,2,  4,4,4,4,
150                          4,4,4,  8,8,8,8,  1,1,1,1,  2,2,2,2,
151                          4,4,4,4,  8,8,8,8,  2,4,2,4,  76,76,24,20,
152                          20,20,  4,4,8,8,  4,  4,4,4,4,  4,  8,8,8,8,
153                          4,4,4,4,  8,8,8,8,  4 };
154
155 int eaExpOffset[] =    { 0, 17,3,1,2,  0,4,2,0,  2,2,2,2,  0,4,4,4,
156                          4,12,2,  0,0,0,0,  3,1,1,1,  2,6,2,2,
157                          0,4,4,4,  0,0,0,0,  0,0,0,0,  -76,-76,-24,-24,
158                          -20,-20,    0,0,0,0,  0,  0,4,0,4,  0,  0,8,8,8,
159                          4,4,0,0,  0,8,8,8,  0 };
160
161 /* _inline */ void init_test_data()
162 {
163   int i;
164
165   void *toc = gettoc();
166   void *sp  = getsp(1,2,3);
167
168   dprintf("&divarw = %p\n", &divarw);
169   dprintf("&dfvars = %p\n", &dfvars);
170   dprintf("&dfvard = %p\n", &dfvard);
171
172   dprintf("toc = %p\n", toc);
173   dprintf("sp = %p\n", sp);
174
175   eaExp[0] = toc; /* assuming that TOC entries are not reordered */
176
177   for(i=1; i<44; ++i)
178     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
179
180   for(i=44; i<50; ++i)
181     eaExp[i] = (void*)((unsigned long)sp + eaExpOffset[i]);; /* SP */
182   
183   for(i=50; i<54; ++i)
184     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
185
186   eaExp[54] = (void*)((unsigned long)toc + sizeof(void*)); /* TOC */
187
188   for(i=55; i<59; ++i)
189     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
190
191   eaExp[59] = (void*)((unsigned long)toc + 2*sizeof(void*)); /* TOC */
192
193   for(i=60; i<64; ++i)
194     eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
195
196   for(i=64; i<68; ++i)
197     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
198
199   for(i=68; i<72; ++i)
200     eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
201   
202   eaExp[72] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
203
204
205   /* Duplicate the stream for cc */
206   for(i=0; i<accessExp; ++i) {
207     eaExpCC[i] = eaExp[i];
208     bcExpCC[i] = bcExp[i];
209   }
210 }
211 #endif /* defined(rs6000_ibm_aix4_1_test) */
212
213 #if defined(i386_unknown_linux2_0_test)
214 unsigned int loadExp=67;
215 unsigned int storeExp=27;
216 unsigned int prefeExp=2;
217 unsigned int accessExp=94;
218 unsigned int accessExpCC=93;
219 const struct reduction mmxRed = { 2, 1, 0, 3, 49 };
220 const struct reduction sseRed = { 2, 0, 1, 3, 53 };
221 const struct reduction sse2Red = { 2, 0, 0, 2, 57 };
222 const struct reduction amdRed = { 2, 0, 1, 3, 60 };
223
224 const struct reduction ccRed = { 0, 0, 0, 1, 87 };
225
226 #else
227 #if defined(i386_unknown_nt4_0_test)
228 unsigned int loadExp=67;
229 unsigned int storeExp=31;
230 unsigned int prefeExp=2;
231 unsigned int accessExp=95;
232 unsigned int accessExpCC=94;
233
234 const struct reduction mmxRed = { 2, 1, 0, 3, 50 };
235 const struct reduction sseRed = { 2, 0, 1, 3, 55 };
236 const struct reduction sse2Red = { 2, 0, 0, 2, 60 };
237 const struct reduction amdRed = { 2, 0, 1, 3, 64 };
238
239 const struct reduction ccRed = { 0, 0, 0, 1, 91 };
240 #endif
241 #endif
242
243 #if defined(i386_unknown_linux2_0_test) \
244  || defined(i386_unknown_nt4_0_test)
245
246
247 int eaExpOffset[] =    { /* 0-3 */ 0,0,0,0,
248                          /* 4-10 */ 0,0,0,0,0,0,0,
249                          /* 11-17 */ 4,8,4,8,4,8,4,
250                          /* 18 */ 0,
251                          /* 19-25 */ 0,4,8,12,0,4,8,
252                          /* 26-34 */ 12,0,8,8,8,0,4,8,4,
253                          /* 35 */ 0,
254                          /* 36-47 */ 4,4,4,0,4,0,4,8,0,0,4,0,
255                          /* 48 */ 0,
256 #if defined(i386_unknown_nt4_0_test)
257                                                 0,
258 #endif
259                                                  /* 49 */ 0,
260                          /* 50-51 */ 8,0,
261                          /* 52 */ 0,
262 #if defined(i386_unknown_nt4_0_test)
263                                                 0,
264 #endif
265                          /* 53-55 */ 0,0,0,
266                          /* 56 */ 0,
267 #if defined(i386_unknown_nt4_0_test)
268                                                 0,
269 #endif
270                          /* 57-58 */ 0,0,
271                          /* 59 */ 0,
272 #if defined(i386_unknown_nt4_0_test)
273                                                 0,
274 #endif
275                          /* 60-62 */ 0,8,0,
276                          /* 63-69 */ 0,12,0,0,0,44,25,
277                          /* 70-75 */ 0,0,0,0,4,8,
278                          /* 76-81 */ 0,0,0,2,4,8,
279                          /* 82-83 */ 0,0,
280                          /* 84-85 */ 0,0,
281                          /* 86-88 */ 0,4,8,
282                          /* 89-90 */ 0,0 };
283
284 unsigned int bcExp[] = { 4,4,4,4,  4,4,4,4,4,4,4,  4,4,4,4,4,4,4,  4,
285                          4,4,4,4,4,4,4,   4,4,4,4,4,4,4,4,4,   4,  4,4,1,1,4,4,4,4,4,1,4,4, 4,
286 #if defined(i386_unknown_nt4_0_test)
287                                         4,
288 #endif
289                          4,8,8, 4, 
290 #if defined(i386_unknown_nt4_0_test)
291                                         4,
292 #endif
293                                                  
294                                                  16,4,0, 4, 
295 #if defined(i386_unknown_nt4_0_test)
296                                         4,
297 #endif
298                                                  16,8, 4, 
299 #if defined(i386_unknown_nt4_0_test)
300                                         4,
301 #endif
302                                                  8,8,0,  12,4,16,16,49,4,4,  4,8,10,2,4,8,
303                          4,8,10,2,4,8, 2,2,  28,28,  4,4,4,  4,4,4, 4,4, 4,4,4 };
304
305 void reduce(const struct reduction x)
306 {
307   unsigned int i;
308
309   loadExp  -= x.loadRed;
310   storeExp -= x.storeRed;
311   prefeExp -= x.prefeRed;
312
313   for(i=x.axsShift; i<accessExp; ++i)
314     eaExp[i] = eaExp[i+x.axsRed];
315
316   for(i=x.axsShift; i<accessExp; ++i)
317     bcExp[i] = bcExp[i+x.axsRed];
318
319   for(i=x.axsShift; i<accessExpCC; ++i)
320     eaExpCC[i] = eaExpCC[i+x.axsRed];
321
322   for(i=x.axsShift; i<accessExpCC; ++i)
323     bcExpCC[i] = bcExpCC[i+x.axsRed];
324
325   accessExp -= x.axsRed;
326   accessExpCC -= x.axsRed;
327 }
328
329 void reduceCC(const struct reduction x)
330 {
331   unsigned int i;
332
333   for(i=x.axsShift; i<accessExpCC; ++i)
334     eaExpCC[i] = eaExpCC[i+x.axsRed];
335
336   for(i=x.axsShift; i<accessExpCC; ++i)
337     bcExpCC[i] = bcExpCC[i+x.axsRed];
338
339   accessExpCC -= x.axsRed;
340 }
341
342
343 void init_test_data()
344 {
345   int caps, i;
346
347   dprintf("&divarw = %p\n", &divarw);
348   dprintf("&dfvars = %p\n", &dfvars);
349   dprintf("&dfvard = %p\n", &dfvard);
350   dprintf("&dfvart = %p\n", &dfvart);
351   dprintf("&dlarge = %p\n", &dlarge);
352
353 #if defined(i386_unknown_nt4_0_test)
354   for(i=4; i<15; ++i)
355     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]); /* skip ebp for now */
356   for(i=16; i<18; ++i)
357     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
358   for(i=19; i<26; ++i)
359     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
360   i=26;
361   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
362   for(i=28; i<35; ++i)
363     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
364   for(i=36; i<48; ++i)
365     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
366   /* skip call @ i=48 (access 49)*/
367   /* skip call @ i=49 (access 50)*/
368   for(i=50; i<53; ++i)
369     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
370   /* skip call @ i=53 (access 54) */
371   /* skip call @ i=54 (access 55) */
372   for(i=55; i<57; ++i)
373     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
374   i=57;
375   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
376   /* skip call @ i=58 (access 59)*/
377   /* skip call @ i=59 (access 60)*/
378   for(i=60; i<62; ++i)
379     eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
380   /* skip call @ i = 62 (access 63)*/
381   /* skip call @ i = 63 (access 64)*/
382   for(i=64; i<66; ++i)
383     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
384   i=66;
385   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
386   for(i=67; i<70; ++i)
387     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
388   i=70; /* 2nd of mov */
389   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
390   for(i=71; i<74; ++i) /* scas, cmps */
391     eaExp[i] = (void*)((unsigned long)&dlarge + eaExpOffset[i]);
392   i=74;
393   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
394   i=75;
395   eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
396   i=76;
397   eaExp[i] = (void*)((unsigned long)&dfvart + eaExpOffset[i]);
398   for(i=77; i<80; ++i)
399     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
400   i=80;
401   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
402   i=81;
403   eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
404   i=82;
405   eaExp[i] = (void*)((unsigned long)&dfvart + eaExpOffset[i]);
406   for(i=83; i<88; ++i)
407     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
408   for(i=88; i<90; ++i)
409     eaExp[i] = (void*)((unsigned long)&dlarge + eaExpOffset[i]);
410   for(i=90; i<93; ++i)
411     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
412 #else
413   for(i=4; i<15; ++i)
414     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]); /* skip ebp for now */
415   for(i=16; i<18; ++i)
416     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
417   for(i=19; i<26; ++i)
418     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
419   i=26;
420   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
421   for(i=28; i<35; ++i)
422     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
423   for(i=36; i<48; ++i)
424     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
425   /* skip call @ i=48 (access 49)*/
426   for(i=49; i<52; ++i)
427     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
428   /* skip call @ i=52 (access 53)*/
429   for(i=53; i<55; ++i)
430     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
431   i=55;
432   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
433   /* skip call @ i=56 (access 57)*/
434   for(i=57; i<59; ++i)
435     eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
436   /* skip call @ i = 59 (access 60)*/
437   for(i=60; i<62; ++i)
438     eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
439   i=62;
440   eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
441   for(i=63; i<66; ++i)
442     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
443   i=66; /* 2nd of mov */
444   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
445   for(i=67; i<70; ++i) /* scas, cmps */
446     eaExp[i] = (void*)((unsigned long)&dlarge + eaExpOffset[i]);
447   i=70;
448   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
449   i=71;
450   eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
451   i=72;
452   eaExp[i] = (void*)((unsigned long)&dfvart + eaExpOffset[i]);
453   for(i=73; i<76; ++i)
454     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
455   i=76;
456   eaExp[i] = (void*)((unsigned long)&dfvars + eaExpOffset[i]);
457   i=77;
458   eaExp[i] = (void*)((unsigned long)&dfvard + eaExpOffset[i]);
459   i=78;
460   eaExp[i] = (void*)((unsigned long)&dfvart + eaExpOffset[i]);
461   for(i=79; i<84; ++i)
462     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
463   for(i=84; i<86; ++i)
464     eaExp[i] = (void*)((unsigned long)&dlarge + eaExpOffset[i]);
465   for(i=86; i<89; ++i)
466     eaExp[i] = (void*)((unsigned long)&divarw + eaExpOffset[i]);
467   /* Duplicate & reduce the stream for cc */
468 #endif
469   for(i=0; i<accessExp; ++i) {
470     eaExpCC[i] = eaExp[i];
471     bcExpCC[i] = bcExp[i];
472   }
473
474   reduceCC(ccRed);
475
476   /* Order of reductions matters! It must be right to left. */
477
478   caps = amd_features();
479   if(!(caps & CAP_3DNOW))
480     reduce(amdRed);
481   caps = ia32features();
482   if(!(caps & CAP_SSE2))
483     reduce(sse2Red);
484   if(!(caps & CAP_SSE))
485     reduce(sseRed);
486   if(!(caps & CAP_MMX))
487     reduce(mmxRed);
488
489   /*fprintf(stderr, "eaExp at call 1 (access 49) = 0x%lx\n", eaExp[48]);
490   fprintf(stderr, "eaExp at call 2 (access 53) = 0x%lx\n", eaExp[52]);
491   fprintf(stderr, "eaExp at call 3 (access 56) = 0x%lx\n", eaExp[56]);
492   fprintf(stderr, "eaExp at call 4 (access 60) = 0x%lx\n", eaExp[59]);*/
493
494 }
495 #endif /* defined(i386_unknown_linux2_0_test) || defined(i386_unknown_nt4_0_test) */
496
497 #ifdef x86_64_unknown_linux2_4_test
498 unsigned int loadExp = 75;
499 unsigned int storeExp = 25;
500 unsigned int prefeExp = 2;
501 unsigned int accessExp = 98;
502 unsigned int accessExpCC = 97;
503
504 int eaExpOffset[] =    { 0,0,0,0,0,0,0,                             /* 7 initial stack pushes (EA not checked) */
505                          0,0,0,0,0,0,0,0,0,0,0,0,0,                 /* 13 mod=0 loads */
506                          4,8,-4,-8,4,8,-4,-8,4,8,-4,-8,127,-128,    /* 14 mod=1 loads */
507                          12,0,8,8,8,0,4,8,4,                        /* 9 SIB tests (same as x86) */
508                          4,4,4,0,4,0,4,8,0,4,0,0,                   /* 11 semantic tests (one has two accesses) */
509                          0,8,0,                                     /* 3 MMX tests */
510                          0,0,0,                                     /* 3 SSE tests */
511                          0,0,                                       /* 2 SSE2 tests */
512                          0,8,0,                                     /* 3 3DNow! tests */
513                          0,12,0,0,0,44,25,                          /* 5 REP tests (two have two accesses each) */
514                          0,0,0,0,4,8,                               /* x87 */
515                          0,0,0,2,4,8,
516                          0,0,
517                          0,0,
518                          0,4,8,                                     /* conditional moves */
519                          0,0,0,0,0,0,                               /* 6 final stack pops */
520                          0,0                                        /* leave and return */
521 };
522
523 unsigned int bcExp[] = { 8,8,8,8,8,8,8,                  /* 7 initial stack pushes */
524                          4,8,4,8,4,8,4,8,4,8,4,8,4,      /* 13 mod=0 loads */
525                          4,8,4,8,4,8,4,8,4,8,4,8,4,8,    /* 14 mod=1 loads */
526                          4,8,4,8,4,8,4,8,4,              /* 9 SIB tests */
527                          4,4,1,1,4,4,4,4,4,4,4,4,        /* 11 semantic tests (one has two accesses) */
528                          8,8,8,                          /* 3 MMX tests */                      
529                          16,4,0,                         /* 3 SSE tests */
530                          16,8,                           /* 2 SSE2 tests */
531                          8,8,0,                          /* 3 3DNow! tests */
532                          12,16,16,16,49,4,4,             /* 5 REP tests (two have two accesses each) */
533                          4,8,10,2,4,8,                   /* x87 */
534                          4,8,10,2,4,8,
535                          2,2,
536                          28,28,
537                          4,4,4,                          /* conditional moves */
538                          8,8,8,8,8,8,                    /* 6 final stack pops */
539                          8,8                             /* leave and return */
540 };
541
542 int divarw;
543 float dfvars;
544 double dfvard;
545 long double dfvart;
546 char dlarge[512] = "keep the interface small and easy to understand.";
547
548 /* FIXME Remove calls to assert() from this function */
549 void init_test_data()
550 {
551   int i;
552
553   dprintf("&divarw = %p\n", &divarw);
554   dprintf("&dfvars = %p\n", &dfvars);
555   dprintf("&dfvard = %p\n", &dfvard);
556   dprintf("&dfvart = %p\n", &dfvart);
557   dprintf("&dlarge = %p\n", &dlarge);
558
559   // we do not check the effective address for stack accesses,
560   // since it depends on the stack pointer,
561   // so we skip the initial 6 pushes
562   i = 7;
563
564   // ModRM and SIB loads and semantic tests (there are 54, but one has two accesses)
565   for (; i < 55; i++)
566       eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]);
567   
568   // the 12th is a load from [RIP + 1]
569   eaExp[11] = rip_relative_load_address;
570
571   // the 36th access uses RSP
572   eaExp[35] = 0;
573
574   // MMX
575   assert(i == 55);
576   for (; i < 58; i++)
577       eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]);
578
579   // SSE
580   assert(i == 58);
581   for (; i < 60; i++)
582       eaExp[i] = (void *)((unsigned long)&dfvart + eaExpOffset[i]);
583   assert(i == 60);
584   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++; // the prefetch
585
586   // SSE2
587   assert(i == 61);
588   for (; i < 63; i++)
589       eaExp[i] = (void *)((unsigned long)&dfvart + eaExpOffset[i]);
590
591   // 3DNow!
592   assert(i == 63);
593   for (; i < 65; i++)
594       eaExp[i] = (void *)((unsigned long)&dfvard + eaExpOffset[i]);
595   assert(i == 65);
596   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
597
598   // REP prefixes
599   assert(i == 66);
600   for (; i < 69; i++)
601       eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]);
602   assert(i == 69);
603   eaExp[i] = (void *)((unsigned long)&dfvars + eaExpOffset[i]); i++;
604   for (; i < 73; i++)
605       eaExp[i] = (void *)((unsigned long)&dlarge + eaExpOffset[i]);
606
607   // x87
608   assert(i == 73);
609   eaExp[i] = (void *)((unsigned long)&dfvars + eaExpOffset[i]); i++;
610   eaExp[i] = (void *)((unsigned long)&dfvard + eaExpOffset[i]); i++;
611   eaExp[i] = (void *)((unsigned long)&dfvart + eaExpOffset[i]); i++;
612   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
613   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
614   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
615
616   eaExp[i] = (void *)((unsigned long)&dfvars + eaExpOffset[i]); i++;
617   eaExp[i] = (void *)((unsigned long)&dfvard + eaExpOffset[i]); i++;
618   eaExp[i] = (void *)((unsigned long)&dfvart + eaExpOffset[i]); i++;
619   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
620   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
621   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
622
623   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
624   eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]); i++;
625
626   eaExp[i] = (void *)((unsigned long)&dlarge + eaExpOffset[i]); i++;
627    eaExp[i] = (void *)((unsigned long)&dlarge + eaExpOffset[i]); i++;
628
629   // conditional moves
630   assert(i == 89);
631   for (; i < 92; i++)
632       eaExp[i] = (void *)((unsigned long)&divarw + eaExpOffset[i]);
633
634   // duplicate stream for CC (except the second-to-last item)
635   for(i = 0; i < 90 ; i++) {
636     eaExpCC[i] = eaExp[i];
637     bcExpCC[i] = bcExp[i];
638   }
639   assert(i == 90);
640   eaExpCC[i] = eaExp[i+1];
641   bcExpCC[i] = bcExp[i+1];
642   for(i = 91; i < 97; i++)
643       bcExpCC[i] = bcExp[i+1];
644 }
645 #endif /* defined(x86_64_unknown_linux2_4_test) */
646
647 #ifdef ia64_unknown_linux2_4_test
648 unsigned int bcExp[] = { 8, 8, 8,  8, 8, 8,  8, 16, 16, 0, 0, 0 };
649 unsigned int bcExpCC_init[] = { 8, 8, 8,  8, 8, 8,  8, 16, 16, 0, 0, 0 };
650
651 void init_test_data()
652 {
653   memcpy(bcExpCC, bcExpCC_init, sizeof (bcExpCC_init));
654 }
655 #endif /* defined(ia64_unknown_linux2_4_test) */
656
657 #ifdef mips_sgi_irix6_4_test
658 long loadsnstores(long x, long y, long z)
659 {
660   return x + y + z;
661 }
662
663 unsigned int bcExp[] = { 0 };
664
665 void init_test_data()
666 {
667 }
668 #endif /* defined(mips_sgi_irix6_4_test) */
669
670 #ifdef alpha_dec_osf4_0_test
671 long loadsnstores(long x, long y, long z)
672 {
673   return x + y + z;
674 }
675
676 unsigned int bcExp[] = { 0 };
677
678 void init_test_data()
679 {
680 }
681 #endif /* defined(alpha_dec_osf4_0_test) */
682
683 #if defined(arch_power_test) && defined(os_linux_test)
684
685 long loadsnstores(long x, long y, long z)
686 {
687   return x + y + z;
688 }
689
690 unsigned int bcExp[] = { 0 };
691
692 void init_test_data()
693 {
694 }
695 #endif /* power linux */
696
697 /* functions called by the simple instrumentation points */
698 void countLoad() {
699   ++loadCnt;
700 }
701
702 void countStore()
703 {
704   ++storeCnt;
705 }
706
707 void countPrefetch()
708 {
709   ++prefeCnt;
710 }
711
712 void countAccess()
713 {
714   ++accessCnt;
715 }
716
717 int validateEA(void* ea1[], void* ea2[], unsigned int n)
718 {
719   int ok = 1;
720   unsigned int i=0;
721
722   for(; i<n; ++i) {
723     ok = (ok && ((ea1[i] == ea2[i]) || ea1[i] == NULL));
724     if(!ok) {
725       logerror("EA Validation failed at access #%u. Expecting: %p. Got: %p.\n",
726               i+1, ea1[i], ea2[i]);
727       return 0;
728     }
729   }
730   return 1;
731 }
732
733 int validateBC(unsigned int bc1[], unsigned int bc2[], unsigned int n)
734 {
735   int ok = 1;
736   unsigned int i=0;
737
738   for(; i<n; ++i) {
739     ok = (ok && (bc1[i] == bc2[i]));
740     if(!ok) {
741       logerror("BC Validation failed at access #%d. Expecting: %d. Got: %d.\n",
742               i+1, bc1[i], bc2[i]);
743       return 0;
744     }
745   }
746   return 1;
747 }
748
749 /* functions called by the effective address/byte count instrumentation points */
750 void listEffAddr(void* addr)
751 {
752   if(accessCntEA < accessExp)
753     eaList[accessCntEA] = addr;
754   else
755     doomEA = 1;
756   accessCntEA++;
757   dprintf("EA[%d]:%p\n", accessCntEA, addr);
758 }
759
760 void listByteCnt(unsigned int count)
761 {
762   if(accessCntBC < accessExp)
763     bcList[accessCntBC] = count;
764   else
765     doomBC = 1;
766   accessCntBC++;
767   dprintf("BC[%d]:%d\n", accessCntBC, count);
768 }
769
770
771 void listEffAddrCC(void* addr)
772 {
773   if(accessCntEAcc < accessExpCC)
774     eaListCC[accessCntEAcc] = addr;
775   else
776     doomEAcc = 1;
777   accessCntEAcc++;
778   dprintf("?A[%d]:%p\n", accessCntEAcc, addr);
779 }
780
781 void listByteCntCC(unsigned int count)
782 {
783   if(accessCntBCcc < accessExpCC)
784     bcListCC[accessCntBCcc] = count;
785   else
786     doomBCcc = 1;
787   accessCntBCcc++;
788   dprintf("?C[%d]:%d\n", accessCntBCcc, count);
789 }