none/tests/arm/v8memory_a.c

   1
   2 /*
   3 gcc -g -o v8memory_a -march=armv8-a -mfpu=crypto-neon-fp-armv8 \
   4    none/tests/arm/v8memory.c -I. -Wall -marm
   5
   6 gcc -g -o v8memory_t -march=armv8-a -mfpu=crypto-neon-fp-armv8 \
   7    none/tests/arm/v8memory.c -I. -Wall -mthumb
   8 */
   9
  10 /* These tests unfortunately are unable to check the relative
  11    placement (or, even, presence) of the required memory fences
  12    relative to the store/load required.  They only verify the
  13    data-movement component. */
  14
  15 #include <stdio.h>
  16 #include <malloc.h>  // memalign
  17 #include <string.h>  // memset
  18 #include "tests/malloc.h"
  19 #include <assert.h>
  20
  21 typedef  unsigned char           UChar;
  22 typedef  unsigned short int      UShort;
  23 typedef  unsigned int            UInt;
  24 typedef  signed int              Int;
  25 typedef  unsigned char           UChar;
  26 typedef  signed long long int    Long;
  27 typedef  unsigned long long int  ULong;
  28
  29 typedef  unsigned char           Bool;
  30 #define False ((Bool)0)
  31 #define True  ((Bool)1)
  32
  33 static inline UChar randUChar ( void )
  34 {
  35    static UInt seed = 90210; // Somewhere in Beverly Hills, allegedly.
  36    seed = 1103515245 * seed + 12345;
  37    return (seed >> 17) & 0xFF;
  38 }
  39
  40 static UInt randUInt ( void )
  41 {
  42    Int i;
  43    UInt r = 0;
  44    for (i = 0; i < 4; i++) {
  45       r = (r << 8) | (UInt)(0xFF & randUChar());
  46    }
  47    return r;
  48 }
  49
  50 static void show_block_xor ( UChar* block1, UChar* block2, Int n )
  51 {
  52    Int i;
  53    printf("  ");
  54    for (i = 0; i < n; i++) {
  55       if (i > 0 && 0 == (i & 15)) printf("\n  ");
  56       if (0 == (i & 15)) printf("[%3d]  ", i);
  57       UInt diff = 0xFF & (UInt)(block1[i] - block2[i]);
  58       if (diff == 0)
  59          printf(".. ");
  60       else
  61          printf("%02x ", diff);
  62    }
  63    printf("\n");
  64 }
  65
  66
  67 // INSN may mention the following regs as containing load/store data:
  68 //      r2 r3 r6 r9
  69 // INSN must mention the following reg as containing the EA: r10
  70 //
  71 // INSN can use r4 and r5 as scratch
  72 //
  73 // In: rand: memory area (128 bytes), r2, r3, r6, r9
  74 //       r10 pointing to middle of memory area
  75 //
  76 // Out: memory area, r2, r3, r6, r9, r10
  77 //
  78 // What is printed out: the XOR of the new and old versions of the
  79 // following:
  80 //    the memory area
  81 //    r2, r3 r6 r9 r10
  82
  83 #define MEM_TEST(INSN) { \
  84   int i; \
  85   const int N = 128; \
  86   UChar* area1 = memalign16(N); \
  87   UChar* area2 = memalign16(N); \
  88   for (i = 0; i < N; i++) area1[i] = area2[i] = randUChar(); \
  89   UInt block1[5]; \
  90   UInt block2[5]; \
  91   /* 0:r2    1:r3    2:r6    3:r9    4:r10 */ \
  92   for (i = 0; i < 5; i++) block1[i] = block2[i] = randUInt(); \
  93   block1[4] = block2[4] = (UInt)(&area1[N/2]); \
  94   __asm__ __volatile__( \
  95     "ldr r2,  [%0, #0]  ; " \
  96     "ldr r3,  [%0, #4]  ; " \
  97     "ldr r6,  [%0, #8]  ; " \
  98     "ldr r9,  [%0, #12] ; " \
  99     "ldr r10, [%0, #16] ; " \
 100     INSN " ; " \
 101     "str r2,  [%0, #0]  ; " \
 102     "str r3,  [%0, #4]  ; " \
 103     "str r6,  [%0, #8]  ; " \
 104     "str r9,  [%0, #12] ; " \
 105     "str r10, [%0, #16] ; " \
 106     : : "r"(&block1[0]) : "r2", "r3", "r4", "r5", "r6", "r9", "r10", \
 107         "memory", "cc" \
 108   ); \
 109   printf("%s  with  r10 = middle_of_block\n", INSN); \
 110   show_block_xor(&area1[0], &area2[0], N); \
 111   printf("  %08x  r2  (xor, data intreg #1)\n", block1[0] ^ block2[0]); \
 112   printf("  %08x  r3  (xor, data intreg #2)\n", block1[1] ^ block2[1]); \
 113   printf("  %08x  r6  (xor, data intreg #3)\n", block1[2] ^ block2[2]); \
 114   printf("  %08x  r9  (xor, data intreg #4)\n", block1[3] ^ block2[3]); \
 115   printf("  %08x  r10 (xor, addr intreg #1)\n", block1[4] ^ block2[4]); \
 116   printf("\n"); \
 117   free(area1); free(area2); \
 118   }
 119
 120
 121 int main ( void )
 122 {
 123    ////////////////////////////////////////////////////////////////
 124    printf("LDA{,B,H} (reg)\n\n");
 125    MEM_TEST("lda  r6, [r10]")
 126    MEM_TEST("ldab r9, [r10]")
 127    MEM_TEST("ldah r3, [r10]")
 128
 129    ////////////////////////////////////////////////////////////////
 130    printf("STL{,B,H} (reg)\n\n");
 131    MEM_TEST("stl  r6, [r10]")
 132    MEM_TEST("stlb r9, [r10]")
 133    MEM_TEST("stlh r3, [r10]")
 134
 135    ////////////////////////////////////////////////////////////////
 136    printf("LDAEX{,B,H,D} (reg)\n\n");
 137    MEM_TEST("ldaex  r6, [r10]")
 138    MEM_TEST("ldaexb r9, [r10]")
 139    MEM_TEST("ldaexh r3, [r10]")
 140    MEM_TEST("ldaexd r2, r3, [r10]")
 141
 142    ////////////////////////////////////////////////////////////////
 143    // These verify that stlex* do notice a cleared (missing) reservation.
 144    printf("STLEX{,B,H,D} (reg) -- expected to fail\n\n");
 145    MEM_TEST("clrex; stlex  r9, r6, [r10]")
 146    MEM_TEST("clrex; stlexb r9, r6, [r10]")
 147    MEM_TEST("clrex; stlexh r9, r3, [r10]")
 148    MEM_TEST("clrex; stlexd r9, r2, r3, [r10]")
 149
 150    ////////////////////////////////////////////////////////////////
 151    // These verify that stlex* do notice a successful reservation.
 152    // By using ldaex* to create the reservation in the first place,
 153    // they also verify that ldaex* actually create a reservation.
 154    printf("STLEX{,B,H,D} (reg) -- expected to succeed\n\n");
 155    MEM_TEST("ldaex  r2, [r10] ; stlex  r9, r6, [r10]")
 156    MEM_TEST("ldaexb r2, [r10] ; stlexb r9, r6, [r10]")
 157    MEM_TEST("ldaexh r2, [r10] ; stlexh r9, r3, [r10]")
 158    MEM_TEST("mov r4, r2 ; mov r5, r3 ; " // preserve r2/r3 around the ldrexd
 159             "ldaexd r2, r3, [r10] ; "
 160             "mov r2, r4 ; mov r3, r5 ; "
 161             "stlexd r9, r2, r3, [r10]")
 162
 163    return 0;
 164 }