/* 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;
}