/* A Memcheck test program for conditional loads and stores, as shown in do_conditional_{load,store}32. Program is run twice, once for loads and once for stores, only because each run generates 80 errors, and we want to see them all. Doing both loads and stores in each run runs into the problem that errors are more aggressively commoned up after the 100th, and so some that we want to see aren't shown. Splitting the run into two pieces avoids this. On ARM we hardwire genuine conditional loads and stores to be tested -- which is the real point of this test, since we are sure they will turn into IRLoadG/IRStoreG. On other platforms we make do with whatever gcc gives us for the equivalent C fragment. In both cases Memcheck's results should be identical -- at least in error counts; line numbers unfortunately will differ. Hence there are -arm and -non-arm expected output files. */ #include #include #include #include #include "../memcheck.h" typedef unsigned int UInt; typedef unsigned char Bool; #define False ((Bool)0) #define True ((Bool)1) static void make_undef ( void* addr, size_t len ) { (void) VALGRIND_MAKE_MEM_UNDEFINED(addr, len); } static void make_def ( void* addr, size_t len ) { (void) VALGRIND_MAKE_MEM_DEFINED(addr, len); } // Returns either |*src| or |alt|. __attribute__((noinline)) UInt do_conditional_load32 ( UInt* src, UInt alt, Bool b ) { UInt res; # if defined(__linux__) && defined(__arm__) __asm__ __volatile__( "mov r5, %2" "\n\t" // alt "tst %3, #0xFF" "\n\t" // b "it ne" "\n\t" "ldrne r5, [%1]" "\n\t" // src "mov %0, r5" "\n\t" // res : /*OUT*/"=r"(res) : /*IN*/"r"(src), "r"(alt), "r"(b) : /*TRASH*/ "r5","cc","memory" ); # else __asm__ __volatile__("" ::: "cc","memory"); res = b ? *src : alt; # endif // res might be undefined. Paint it as defined so the // caller can look at it without invoking further errors. make_def(&res, sizeof(res)); return res; } // Possibly writes |alt| to |*dst|, and returns the resulting // value of |*dst|. __attribute__((noinline)) UInt do_conditional_store32 ( UInt* dst, UInt alt, Bool b ) { # if defined(__linux__) && defined(__arm__) __asm__ __volatile__( "mov r5, %1" "\n\t" // alt "tst %2, #0xFF" "\n\t" // b "it ne" "\n\t" "strne r5, [%0]" "\n\t" // dst : /*OUT*/ : /*IN*/"r"(dst), "r"(alt), "r"(b) : /*TRASH*/ "r5","cc","memory" ); # else __asm__ __volatile__("" ::: "cc","memory"); if (b) *dst = alt; # endif /* Now we need to get hold of the value at *dst. But it might be unaddressible and/or undefined. Hence turn off error reporting when getting it. */ UInt res; VALGRIND_DISABLE_ERROR_REPORTING; res = *dst; VALGRIND_ENABLE_ERROR_REPORTING; make_def(&res, sizeof(res)); return res; } /* --- LOAD ----------------------------------------- LOAD --- */ /* --- LOAD ----------------------------------------- LOAD --- */ /* --- LOAD ----------------------------------------- LOAD --- */ /* For conditional loads, there are 64 combinations to test. cond: { defined-true, defined-false, undefined-true, undefined-false } D1 D0 U1 U0 x addr: { defined-valid, defined-invalid, undefined-valid, undefined-invalid } DV DI UV UI x alt: { defined, undefined } Da Ub x data: { defined, undefined } Dc Ud // a, b, c, d refer to actual values The general form of the test is: 1. Place data at *addr 2. return "cond ? *addr : alt" */ typedef enum { Cond_D1=10, Cond_D0, Cond_U1, Cond_U0 } Inp_Cond; typedef enum { Addr_DV=20, Addr_DI, Addr_UV, Addr_UI } Inp_Addr; typedef enum { Alt_Da=30, Alt_Ub } Inp_Alt; typedef enum { Data_Dc=40, Data_Ud } Inp_Data; typedef struct { Inp_Cond inp_Cond; Inp_Addr inp_Addr; Inp_Alt inp_Alt; Inp_Data inp_Data; char res; char defErr_Cond; char defErr_Addr; char addrErr; } TestCase; const TestCase loadCases[64] = { // ADDR ALT COND DATA Res // defErr-COND // defErr-ADDR // addrErr // In all of the next 16 cases, the load definitely happens // and |alt| is therefore irrelevant { Cond_D1, Addr_DV, Alt_Da, Data_Dc, 'C', 'N', 'N', 'N' }, // 0 { Cond_D1, Addr_DV, Alt_Da, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D1, Addr_DV, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D1, Addr_DV, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D1, Addr_DI, Alt_Da, Data_Dc, 'C', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Da, Data_Ud, 'D', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'Y' }, { Cond_D1, Addr_UV, Alt_Da, Data_Dc, 'C', 'N', 'Y', 'N' }, // 8 { Cond_D1, Addr_UV, Alt_Da, Data_Ud, 'D', 'N', 'Y', 'N' }, { Cond_D1, Addr_UV, Alt_Ub, Data_Dc, 'C', 'N', 'Y', 'N' }, { Cond_D1, Addr_UV, Alt_Ub, Data_Ud, 'D', 'N', 'Y', 'N' }, { Cond_D1, Addr_UI, Alt_Da, Data_Dc, 'C', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Da, Data_Ud, 'D', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Ub, Data_Dc, 'C', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Ub, Data_Ud, 'D', 'N', 'Y', 'Y' }, // In the next 16 cases, the load definitely does not happen, // so we just return |alt|. { Cond_D0, Addr_DV, Alt_Da, Data_Dc, 'A', 'N', 'N', 'N' }, // 16 { Cond_D0, Addr_DV, Alt_Da, Data_Ud, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_DV, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_DV, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Da, Data_Dc, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Da, Data_Ud, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Da, Data_Dc, 'A', 'N', 'N', 'N' }, // 24 { Cond_D0, Addr_UV, Alt_Da, Data_Ud, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Da, Data_Dc, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Da, Data_Ud, 'A', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'N' }, // ADDR ALT COND DATA Res // defErr-COND // defErr-ADDR // addrErr // In the next 16 cases, the load happens, but the condition // is undefined. This means that it should behave like the // first group of 16 cases, except that we should also get a // complaint about the definedness of the condition. { Cond_U1, Addr_DV, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'N' }, // 32 { Cond_U1, Addr_DV, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U1, Addr_DV, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U1, Addr_DV, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U1, Addr_DI, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'Y' }, { Cond_U1, Addr_UV, Alt_Da, Data_Dc, 'C', 'Y', 'Y', 'N' }, // 40 { Cond_U1, Addr_UV, Alt_Da, Data_Ud, 'D', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UV, Alt_Ub, Data_Dc, 'C', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UV, Alt_Ub, Data_Ud, 'D', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UI, Alt_Da, Data_Dc, 'C', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Da, Data_Ud, 'D', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Ub, Data_Dc, 'C', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Ub, Data_Ud, 'D', 'Y', 'Y', 'Y' }, // In this last group of 16 cases, the load does not happen, // but the condition is undefined. So we just return |alt|, // and also complain about the condition. Hence it's like the // second group of 16 cases except that we also get a complaint // about the condition. { Cond_U0, Addr_DV, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'N' }, // 48 { Cond_U0, Addr_DV, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_DV, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_DV, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'N' }, // 56 { Cond_U0, Addr_UV, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'N' } // 63 }; // Constant, corresponding to the test enums static Bool c_Cond_D1, c_Cond_D0, c_Cond_U1, c_Cond_U0; static UInt *c_Addr_DV, *c_Addr_DI, *c_Addr_UV, *c_Addr_UI; static UInt c_Alt_Da, c_Alt_Ub; static void setup_test_data ( Inp_Data inp_Data ) { c_Cond_D1 = c_Cond_U1 = True; c_Cond_D0 = c_Cond_U0 = False; make_undef(&c_Cond_U1, sizeof(c_Cond_U1)); make_undef(&c_Cond_U0, sizeof(c_Cond_U0)); c_Addr_DV = c_Addr_UV = malloc(4); c_Addr_DI = c_Addr_UI = malloc(4); // install test data at the given address UInt testd = inp_Data == Data_Dc ? 0xCCCCCCCC : 0xDDDDDDDD; *c_Addr_DV = *c_Addr_DI = testd; if (inp_Data == Data_Dc) { // it's already defined } else { make_undef(c_Addr_DV, 4); make_undef(c_Addr_DI, 4); } // make the invalid address invalid. This unfortunately loses // the definedness state of the data that is stored there. free(c_Addr_DI); // and set the definedness of the pointers themselves. make_undef(&c_Addr_UV, sizeof(c_Addr_UV)); make_undef(&c_Addr_UI, sizeof(c_Addr_UI)); // and set up alt c_Alt_Da = 0xAAAAAAAA; c_Alt_Ub = 0xBBBBBBBB; make_undef(&c_Alt_Ub, sizeof(c_Alt_Ub)); } static void do_test_case ( int caseNo, Bool isLoad, const TestCase* lc ) { fprintf(stderr, "\n-----------------------------------------------------------\n"); fprintf(stderr, "%s CASE %d\n", isLoad ? "LOAD" : "STORE", caseNo); // validate .. assert(Cond_D1 <= lc->inp_Cond && lc->inp_Cond <= Cond_U0); assert(Addr_DV <= lc->inp_Addr && lc->inp_Addr <= Addr_UI); assert(lc->inp_Alt == Alt_Da || lc->inp_Alt == Alt_Ub); assert(lc->inp_Data == Data_Dc || lc->inp_Data == Data_Ud); assert('A' <= lc->res && lc->res <= 'D'); assert(lc->defErr_Cond == 'Y' || lc->defErr_Cond == 'N'); assert(lc->defErr_Addr == 'Y' || lc->defErr_Addr == 'N'); assert(lc->addrErr == 'Y' || lc->addrErr == 'N'); // set up test data constants setup_test_data(lc->inp_Data); // and select constants for the test, depending on |lc| // Except, skip i_Data since setup_test_data takes care of it. Bool i_Cond; UInt* i_Addr; UInt i_Alt; switch (lc->inp_Cond) { case Cond_D1: i_Cond = c_Cond_D1; break; case Cond_D0: i_Cond = c_Cond_D0; break; case Cond_U1: i_Cond = c_Cond_U1; break; case Cond_U0: i_Cond = c_Cond_U0; break; default: assert(0); } switch (lc->inp_Addr) { case Addr_DV: i_Addr = c_Addr_DV; break; case Addr_DI: i_Addr = c_Addr_DI; break; case Addr_UV: i_Addr = c_Addr_UV; break; case Addr_UI: i_Addr = c_Addr_UI; break; default: assert(0); } switch (lc->inp_Alt) { case Alt_Da: i_Alt = c_Alt_Da; break; case Alt_Ub: i_Alt = c_Alt_Ub; break; default: assert(0); } // How many errors do we expect from this? UInt n_errs_exp = (lc->defErr_Cond == 'Y' ? 1 : 0) + (lc->defErr_Addr == 'Y' ? 1 : 0) + (lc->addrErr == 'Y' ? 1 : 0); UInt n_errs_act = VALGRIND_COUNT_ERRORS; UInt res_act; if (isLoad) { res_act = do_conditional_load32(i_Addr, i_Alt, i_Cond); } else { res_act = do_conditional_store32(i_Addr, i_Alt, i_Cond); } n_errs_act = VALGRIND_COUNT_ERRORS - n_errs_act; if (n_errs_act == n_errs_exp) { fprintf(stderr, "PASS: %u errors\n", n_errs_act); } else { fprintf(stderr, "FAIL: %u errors expected, %u actual\n", n_errs_exp, n_errs_act); } // What's the expected result value (actual loaded data?) UInt res_exp = 0; switch (lc->res) { case 'A': res_exp = 0xAAAAAAAA; break; case 'B': res_exp = 0xBBBBBBBB; break; case 'C': res_exp = 0xCCCCCCCC; break; case 'D': res_exp = 0xDDDDDDDD; break; default: assert(0); } if (res_act == res_exp) { fprintf(stderr, "PASS: correct result\n"); } else { fprintf(stderr, "FAIL: result: %08x expected, %08x actual\n", res_exp, res_act); } free(c_Addr_DV); } void do_test_case_steer ( void (*fn)(int,Bool,const TestCase*), int i, Bool isLd, const TestCase* tc ) { __asm__ __volatile__(""); if (i == 0) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 1) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 2) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 3) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 4) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 5) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 6) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 7) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 8) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 9) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 10) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 11) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 12) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 13) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 14) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 15) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 16) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 17) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 18) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 19) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 20) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 21) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 22) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 23) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 24) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 25) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 26) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 27) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 28) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 29) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 30) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 31) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 32) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 33) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 34) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 35) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 36) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 37) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 38) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 39) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 40) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 41) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 42) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 43) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 44) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 45) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 46) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 47) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 48) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 49) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 50) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 51) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 52) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 53) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 54) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 55) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 56) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 57) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 58) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 59) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 60) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 61) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 62) { fn(i,isLd,tc); return; }; __asm__ __volatile__(""); if (i == 63) { fn(i,isLd,tc); return; }; assert(0); } /* --- STORE --------------------------------------- STORE --- */ /* --- STORE --------------------------------------- STORE --- */ /* --- STORE --------------------------------------- STORE --- */ /* For conditional stores, there are 64 combinations to test. cond: { defined-true, defined-false, undefined-true, undefined-false } D1 D0 U1 U0 x addr: { defined-valid, defined-invalid, undefined-valid, undefined-invalid } DV DI UV UI x alt: { defined, undefined } Da Ub x data: { defined, undefined } Dc Ud // a, b, c, d refer to actual values The general form of the test is: 1. Place data at *addr 2. do "if (cond) *addr = alt" 3 return *addr Hence identical setup to the load cases, although the roles of data and alt are somewhat confusingly swapped. |data| here is the "didn't happen" result, and |alt| is the "did happen" result. */ const TestCase storeCases[64] = { // ADDR ALT COND DATA Res // defErr-COND // defErr-ADDR // addrErr // In all of the next 16 cases, the store definitely happens // and |data| is therefore irrelevant { Cond_D1, Addr_DV, Alt_Da, Data_Dc, 'A', 'N', 'N', 'N' }, // 0 { Cond_D1, Addr_DV, Alt_Da, Data_Ud, 'A', 'N', 'N', 'N' }, { Cond_D1, Addr_DV, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'N' }, { Cond_D1, Addr_DV, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'N' }, { Cond_D1, Addr_DI, Alt_Da, Data_Dc, 'A', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Da, Data_Ud, 'A', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Ub, Data_Dc, 'B', 'N', 'N', 'Y' }, { Cond_D1, Addr_DI, Alt_Ub, Data_Ud, 'B', 'N', 'N', 'Y' }, { Cond_D1, Addr_UV, Alt_Da, Data_Dc, 'A', 'N', 'Y', 'N' }, // 8 { Cond_D1, Addr_UV, Alt_Da, Data_Ud, 'A', 'N', 'Y', 'N' }, { Cond_D1, Addr_UV, Alt_Ub, Data_Dc, 'B', 'N', 'Y', 'N' }, { Cond_D1, Addr_UV, Alt_Ub, Data_Ud, 'B', 'N', 'Y', 'N' }, { Cond_D1, Addr_UI, Alt_Da, Data_Dc, 'A', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Da, Data_Ud, 'A', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Ub, Data_Dc, 'B', 'N', 'Y', 'Y' }, { Cond_D1, Addr_UI, Alt_Ub, Data_Ud, 'B', 'N', 'Y', 'Y' }, // In the next 16 cases, the store definitely does not happen, // so we just return |data|. { Cond_D0, Addr_DV, Alt_Da, Data_Dc, 'C', 'N', 'N', 'N' }, // 16 { Cond_D0, Addr_DV, Alt_Da, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_DV, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_DV, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Da, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Da, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_DI, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Da, Data_Dc, 'C', 'N', 'N', 'N' }, // 24 { Cond_D0, Addr_UV, Alt_Da, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_UV, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Da, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Da, Data_Ud, 'D', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Ub, Data_Dc, 'C', 'N', 'N', 'N' }, { Cond_D0, Addr_UI, Alt_Ub, Data_Ud, 'D', 'N', 'N', 'N' }, // ADDR ALT COND DATA Res // defErr-COND // defErr-ADDR // addrErr // In the next 16 cases, the store happens, but the condition // is undefined. This means that it should behave like the // first group of 16 cases, except that we should also get a // complaint about the definedness of the condition. { Cond_U1, Addr_DV, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'N' }, // 32 { Cond_U1, Addr_DV, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'N' }, { Cond_U1, Addr_DV, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'N' }, { Cond_U1, Addr_DV, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'N' }, { Cond_U1, Addr_DI, Alt_Da, Data_Dc, 'A', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Da, Data_Ud, 'A', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Ub, Data_Dc, 'B', 'Y', 'N', 'Y' }, { Cond_U1, Addr_DI, Alt_Ub, Data_Ud, 'B', 'Y', 'N', 'Y' }, { Cond_U1, Addr_UV, Alt_Da, Data_Dc, 'A', 'Y', 'Y', 'N' }, // 40 { Cond_U1, Addr_UV, Alt_Da, Data_Ud, 'A', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UV, Alt_Ub, Data_Dc, 'B', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UV, Alt_Ub, Data_Ud, 'B', 'Y', 'Y', 'N' }, { Cond_U1, Addr_UI, Alt_Da, Data_Dc, 'A', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Da, Data_Ud, 'A', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Ub, Data_Dc, 'B', 'Y', 'Y', 'Y' }, { Cond_U1, Addr_UI, Alt_Ub, Data_Ud, 'B', 'Y', 'Y', 'Y' }, // In this last group of 16 cases, the store does not happen, // but the condition is undefined. So we just return |data|, // and also complain about the condition. Hence it's like the // second group of 16 cases except that we also get a complaint // about the condition. { Cond_U0, Addr_DV, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'N' }, // 48 { Cond_U0, Addr_DV, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_DV, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_DV, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_DI, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'N' }, // 56 { Cond_U0, Addr_UV, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_UV, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Da, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Da, Data_Ud, 'D', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Ub, Data_Dc, 'C', 'Y', 'N', 'N' }, { Cond_U0, Addr_UI, Alt_Ub, Data_Ud, 'D', 'Y', 'N', 'N' } // 63 }; void usage ( char* pname ) { fprintf(stderr, "usage: %s [loads|stores]\n", pname); exit(1); } int main ( int argc, char** argv ) { UInt i, nCases; if (argc != 2) usage(argv[0]); Bool doLoad = False; if (0 == strcmp(argv[1], "loads")) { doLoad = True; } else if (0 == strcmp(argv[1], "stores")) { doLoad = False; } else usage(argv[0]); if (doLoad) { nCases = sizeof(loadCases) / sizeof(loadCases[0]); assert(nCases == 64); for (i = 0; i < nCases; i++) do_test_case_steer( do_test_case, i, True/*isLoad*/, &loadCases[i] ); } else { nCases = sizeof(storeCases) / sizeof(storeCases[0]); assert(nCases == 64); for (i = 0; i < nCases; i++) do_test_case_steer( do_test_case, i, False/*!isLoad*/, &storeCases[i] ); } return 0; }