| |
| /* 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 <stdio.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <string.h> |
| |
| #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; |
| } |
