none/tests/x86/x86locked.c

   1
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <assert.h>
   5
   6 #define VERBOSE 0
   7
   8 typedef  unsigned int            UInt;
   9 typedef  unsigned char           UChar;
  10 typedef  unsigned long long int  ULong;
  11 typedef  signed long long int    Long;
  12 typedef  signed int              Int;
  13 typedef  unsigned short          UShort;
  14 typedef  unsigned long           UWord;
  15 typedef  char                    HChar;
  16
  17 unsigned myrandom(void)
  18 {
  19    /* Simple multiply-with-carry random generator. */
  20    static unsigned m_w = 11;
  21    static unsigned m_z = 13;
  22
  23    m_z = 36969 * (m_z & 65535) + (m_z >> 16);
  24    m_w = 18000 * (m_w & 65535) + (m_w >> 16);
  25
  26    return (m_z << 16) + m_w;
  27 }
  28
  29 /////////////////////////////////////////////////////////////////
  30 // BEGIN crc32 stuff                                           //
  31 /////////////////////////////////////////////////////////////////
  32
  33 static const UInt crc32Table[256] = {
  34
  35    /*-- Ugly, innit? --*/
  36
  37    0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
  38    0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
  39    0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
  40    0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
  41    0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
  42    0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
  43    0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
  44    0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
  45    0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
  46    0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
  47    0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
  48    0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
  49    0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
  50    0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
  51    0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
  52    0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
  53    0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
  54    0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
  55    0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
  56    0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
  57    0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
  58    0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
  59    0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
  60    0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
  61    0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
  62    0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
  63    0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
  64    0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
  65    0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
  66    0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
  67    0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
  68    0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
  69    0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
  70    0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
  71    0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
  72    0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
  73    0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
  74    0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
  75    0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
  76    0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
  77    0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
  78    0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
  79    0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
  80    0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
  81    0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
  82    0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
  83    0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
  84    0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
  85    0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
  86    0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
  87    0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
  88    0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
  89    0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
  90    0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
  91    0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
  92    0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
  93    0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
  94    0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
  95    0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
  96    0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
  97    0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
  98    0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
  99    0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
 100    0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
 101 };
 102
 103 #define UPDATE_CRC(crcVar,cha)                 \
 104 {                                              \
 105    crcVar = (crcVar << 8) ^                    \
 106             crc32Table[(crcVar >> 24) ^        \
 107                        ((UChar)cha)];          \
 108 }
 109
 110 static UInt crcBytes ( UChar* bytes, UWord nBytes, UInt crcIn )
 111 {
 112    UInt crc = crcIn;
 113    while (nBytes >= 4) {
 114       UPDATE_CRC(crc, bytes[0]);
 115       UPDATE_CRC(crc, bytes[1]);
 116       UPDATE_CRC(crc, bytes[2]);
 117       UPDATE_CRC(crc, bytes[3]);
 118       bytes += 4;
 119       nBytes -= 4;
 120    }
 121    while (nBytes >= 1) {
 122       UPDATE_CRC(crc, bytes[0]);
 123       bytes += 1;
 124       nBytes -= 1;
 125    }
 126    return crc;
 127 }
 128
 129 static UInt crcFinalise ( UInt crc ) {
 130    return ~crc;
 131 }
 132
 133 ////////
 134
 135 static UInt theCRC = 0xFFFFFFFF;
 136
 137 static HChar outBuf[1024];
 138 // take output that's in outBuf, length as specified, and
 139 // update the running crc.
 140 static void send ( int nbytes )
 141 {
 142    assert( ((unsigned int)nbytes) < sizeof(outBuf)-1);
 143    assert(outBuf[nbytes] == 0);
 144    theCRC = crcBytes( (UChar*)&outBuf[0], nbytes, theCRC );
 145    if (VERBOSE) printf("SEND %08x %s", theCRC, outBuf);
 146 }
 147
 148
 149 /////////////////////////////////////////////////////////////////
 150 // END crc32 stuff                                             //
 151 /////////////////////////////////////////////////////////////////
 152
 153 #if 0
 154
 155 // full version
 156 #define NVALS 57
 157
 158 static unsigned int val[NVALS]
 159     = { 0x00, 0x01, 0x02, 0x03,
 160         0x3F, 0x40, 0x41,
 161         0x7E, 0x7F, 0x80, 0x81, 0x82,
 162         0xBF, 0xC0, 0xC1,
 163         0xFC, 0xFD, 0xFE, 0xFF,
 164
 165         0xFF00, 0xFF01, 0xFF02, 0xFF03,
 166         0xFF3F, 0xFF40, 0xFF41,
 167         0xFF7E, 0xFF7F, 0xFF80, 0xFF81, 0xFF82,
 168         0xFFBF, 0xFFC0, 0xFFC1,
 169         0xFFFC, 0xFFFD, 0xFFFE, 0xFFFF,
 170
 171         0xFFFFFF00, 0xFFFFFF01, 0xFFFFFF02, 0xFFFFFF03,
 172         0xFFFFFF3F, 0xFFFFFF40, 0xFFFFFF41,
 173         0xFFFFFF7E, 0xFFFFFF7F, 0xFFFFFF80, 0xFFFFFF81, 0xFFFFFF82,
 174         0xFFFFFFBF, 0xFFFFFFC0, 0xFFFFFFC1,
 175         0xFFFFFFFC, 0xFFFFFFFD, 0xFFFFFFFE, 0xFFFFFFFF
 176       };
 177
 178 #else
 179
 180 // shortened version, for use as valgrind regtest
 181 #define NVALS 27
 182
 183 static unsigned int val[NVALS]
 184     = { 0x00, 0x01,
 185         0x3F, 0x40,
 186         0x7F, 0x80,
 187         0xBF, 0xC0,
 188         0xFF,
 189
 190         0xFF00, 0xFF01,
 191         0xFF3F, 0xFF40,
 192         0xFF7F, 0xFF80,
 193         0xFFBF, 0xFFC0,
 194         0xFFFF,
 195
 196         0xFFFFFF00, 0xFFFFFF01,
 197         0xFFFFFF3F, 0xFFFFFF40,
 198         0xFFFFFF7F, 0xFFFFFF80,
 199         0xFFFFFFBF, 0xFFFFFFC0,
 200         0xFFFFFFFF
 201       };
 202
 203 #endif
 204
 205 /////////////////////////////////////
 206
 207 #define CC_C    0x0001
 208 #define CC_P    0x0004
 209 #define CC_A    0x0010
 210 #define CC_Z    0x0040
 211 #define CC_S    0x0080
 212 #define CC_O    0x0800
 213
 214 #define CC_MASK (CC_C | CC_P | CC_A | CC_Z | CC_S | CC_O)
 215
 216 #define GEN_do_locked_G_E(_name,_eax)   \
 217   \
 218   __attribute__((noinline)) void do_locked_G_E_##_name ( void )  \
 219   {   \
 220     volatile int e_val, g_val, e_val_before;   \
 221     int o, s, z, a, c, p, v1, v2, flags_in;   \
 222     int block[4];   \
 223     \
 224     for (v1 = 0; v1 < NVALS; v1++) {   \
 225     for (v2 = 0; v2 < NVALS; v2++) {   \
 226     \
 227     for (o = 0; o < 2; o++) {   \
 228     for (s = 0; s < 2; s++) {   \
 229     for (z = 0; z < 2; z++) {   \
 230     for (a = 0; a < 2; a++) {   \
 231     for (c = 0; c < 2; c++) {   \
 232     for (p = 0; p < 2; p++) {   \
 233       \
 234       flags_in = (o ? CC_O : 0)   \
 235                | (s ? CC_S : 0)   \
 236                | (z ? CC_Z : 0)   \
 237                | (a ? CC_A : 0)   \
 238                | (c ? CC_C : 0)   \
 239                | (p ? CC_P : 0);   \
 240       \
 241       g_val = val[v1];   \
 242       e_val = val[v2];   \
 243       e_val_before = e_val;   \
 244       \
 245       block[0] = flags_in;   \
 246       block[1] = g_val;   \
 247       block[2] = (int)(long)&e_val;   \
 248       block[3] = 0;   \
 249       __asm__ __volatile__(   \
 250           "movl 0(%0), %%eax\n\t"   \
 251           "pushl %%eax\n\t"   \
 252           "popfl\n\t"   \
 253           "movl 4(%0), %%eax\n\t"   \
 254           "movl 8(%0), %%ebx\n\t"   \
 255           "lock; " #_name " %%" #_eax ",(%%ebx)\n\t"   \
 256           "pushfl\n\t"   \
 257           "popl %%eax\n\t"   \
 258           "movl %%eax, 12(%0)\n\t"   \
 259           : : "r"(&block[0]) : "eax","ebx","cc","memory"   \
 260       );   \
 261       \
 262       send( \
 263          sprintf(outBuf,                                        \
 264                  "%s G=%08x E=%08x CCIN=%08x -> E=%08x CCOUT=%08x\n", \
 265                  #_name, g_val, e_val_before, flags_in,   \
 266                  e_val, block[3] & CC_MASK) );            \
 267       \
 268     }}}}}}   \
 269     \
 270     }}   \
 271   }
 272
 273 GEN_do_locked_G_E(addb,al)
 274 GEN_do_locked_G_E(addw,ax)
 275 GEN_do_locked_G_E(addl,eax)
 276
 277 GEN_do_locked_G_E(orb, al)
 278 GEN_do_locked_G_E(orw, ax)
 279 GEN_do_locked_G_E(orl, eax)
 280
 281 GEN_do_locked_G_E(adcb,al)
 282 GEN_do_locked_G_E(adcw,ax)
 283 GEN_do_locked_G_E(adcl,eax)
 284
 285 GEN_do_locked_G_E(sbbb,al)
 286 GEN_do_locked_G_E(sbbw,ax)
 287 GEN_do_locked_G_E(sbbl,eax)
 288
 289 GEN_do_locked_G_E(andb,al)
 290 GEN_do_locked_G_E(andw,ax)
 291 GEN_do_locked_G_E(andl,eax)
 292
 293 GEN_do_locked_G_E(subb,al)
 294 GEN_do_locked_G_E(subw,ax)
 295 GEN_do_locked_G_E(subl,eax)
 296
 297 GEN_do_locked_G_E(xorb,al)
 298 GEN_do_locked_G_E(xorw,ax)
 299 GEN_do_locked_G_E(xorl,eax)
 300
 301
 302
 303
 304 #define GEN_do_locked_imm_E(_name,_eax,_imm)        \
 305   \
 306   __attribute__((noinline)) void do_locked_imm_E_##_name##_##_imm ( void )  \
 307   {   \
 308     volatile int e_val, e_val_before;   \
 309     int o, s, z, a, c, p, v2, flags_in;   \
 310     int block[3];   \
 311     \
 312     for (v2 = 0; v2 < NVALS; v2++) {   \
 313     \
 314     for (o = 0; o < 2; o++) {   \
 315     for (s = 0; s < 2; s++) {   \
 316     for (z = 0; z < 2; z++) {   \
 317     for (a = 0; a < 2; a++) {   \
 318     for (c = 0; c < 2; c++) {   \
 319     for (p = 0; p < 2; p++) {   \
 320       \
 321       flags_in = (o ? CC_O : 0)   \
 322                | (s ? CC_S : 0)   \
 323                | (z ? CC_Z : 0)   \
 324                | (a ? CC_A : 0)   \
 325                | (c ? CC_C : 0)   \
 326                | (p ? CC_P : 0);   \
 327       \
 328       e_val = val[v2];   \
 329       e_val_before = e_val;   \
 330       \
 331       block[0] = flags_in;   \
 332       block[1] = (int)(long)&e_val;   \
 333       block[2] = 0;   \
 334       __asm__ __volatile__(   \
 335           "movl 0(%0), %%eax\n\t"   \
 336           "pushl %%eax\n\t"   \
 337           "popfl\n\t"   \
 338           "movl 4(%0), %%ebx\n\t"   \
 339           "lock; " #_name " $" #_imm ",(%%ebx)\n\t"   \
 340           "pushfl\n\t"   \
 341           "popl %%eax\n\t"   \
 342           "movl %%eax, 8(%0)\n\t"   \
 343           : : "r"(&block[0]) : "eax","ebx","cc","memory"   \
 344       );   \
 345       \
 346       send( \
 347         sprintf(outBuf, \
 348              "%s I=%s E=%08x CCIN=%08x -> E=%08x CCOUT=%08x\n",       \
 349              #_name, #_imm, e_val_before, flags_in,         \
 350                 e_val, block[2] & CC_MASK) );               \
 351       \
 352     }}}}}}   \
 353     \
 354     }   \
 355   }
 356
 357 GEN_do_locked_imm_E(addb,al,0x7F)
 358 GEN_do_locked_imm_E(addb,al,0xF1)
 359 GEN_do_locked_imm_E(addw,ax,0x7E)
 360 GEN_do_locked_imm_E(addw,ax,0x9325)
 361 GEN_do_locked_imm_E(addl,eax,0x7D)
 362 GEN_do_locked_imm_E(addl,eax,0x31415927)
 363
 364 GEN_do_locked_imm_E(orb,al,0x7F)
 365 GEN_do_locked_imm_E(orb,al,0xF1)
 366 GEN_do_locked_imm_E(orw,ax,0x7E)
 367 GEN_do_locked_imm_E(orw,ax,0x9325)
 368 GEN_do_locked_imm_E(orl,eax,0x7D)
 369 GEN_do_locked_imm_E(orl,eax,0x31415927)
 370
 371 GEN_do_locked_imm_E(adcb,al,0x7F)
 372 GEN_do_locked_imm_E(adcb,al,0xF1)
 373 GEN_do_locked_imm_E(adcw,ax,0x7E)
 374 GEN_do_locked_imm_E(adcw,ax,0x9325)
 375 GEN_do_locked_imm_E(adcl,eax,0x7D)
 376 GEN_do_locked_imm_E(adcl,eax,0x31415927)
 377
 378 GEN_do_locked_imm_E(sbbb,al,0x7F)
 379 GEN_do_locked_imm_E(sbbb,al,0xF1)
 380 GEN_do_locked_imm_E(sbbw,ax,0x7E)
 381 GEN_do_locked_imm_E(sbbw,ax,0x9325)
 382 GEN_do_locked_imm_E(sbbl,eax,0x7D)
 383 GEN_do_locked_imm_E(sbbl,eax,0x31415927)
 384
 385 GEN_do_locked_imm_E(andb,al,0x7F)
 386 GEN_do_locked_imm_E(andb,al,0xF1)
 387 GEN_do_locked_imm_E(andw,ax,0x7E)
 388 GEN_do_locked_imm_E(andw,ax,0x9325)
 389 GEN_do_locked_imm_E(andl,eax,0x7D)
 390 GEN_do_locked_imm_E(andl,eax,0x31415927)
 391
 392 GEN_do_locked_imm_E(subb,al,0x7F)
 393 GEN_do_locked_imm_E(subb,al,0xF1)
 394 GEN_do_locked_imm_E(subw,ax,0x7E)
 395 GEN_do_locked_imm_E(subw,ax,0x9325)
 396 GEN_do_locked_imm_E(subl,eax,0x7D)
 397 GEN_do_locked_imm_E(subl,eax,0x31415927)
 398
 399 GEN_do_locked_imm_E(xorb,al,0x7F)
 400 GEN_do_locked_imm_E(xorb,al,0xF1)
 401 GEN_do_locked_imm_E(xorw,ax,0x7E)
 402 GEN_do_locked_imm_E(xorw,ax,0x9325)
 403 GEN_do_locked_imm_E(xorl,eax,0x7D)
 404 GEN_do_locked_imm_E(xorl,eax,0x31415927)
 405
 406 #define GEN_do_locked_unary_E(_name,_eax)        \
 407   \
 408   __attribute__((noinline)) void do_locked_unary_E_##_name ( void )  \
 409   {   \
 410     volatile int e_val, e_val_before;   \
 411     int o, s, z, a, c, p, v2, flags_in;   \
 412     int block[3];   \
 413     \
 414     for (v2 = 0; v2 < NVALS; v2++) {   \
 415     \
 416     for (o = 0; o < 2; o++) {   \
 417     for (s = 0; s < 2; s++) {   \
 418     for (z = 0; z < 2; z++) {   \
 419     for (a = 0; a < 2; a++) {   \
 420     for (c = 0; c < 2; c++) {   \
 421     for (p = 0; p < 2; p++) {   \
 422       \
 423       flags_in = (o ? CC_O : 0)   \
 424                | (s ? CC_S : 0)   \
 425                | (z ? CC_Z : 0)   \
 426                | (a ? CC_A : 0)   \
 427                | (c ? CC_C : 0)   \
 428                | (p ? CC_P : 0);   \
 429       \
 430       e_val = val[v2];   \
 431       e_val_before = e_val;   \
 432       \
 433       block[0] = flags_in;   \
 434       block[1] = (int)(long)&e_val;   \
 435       block[2] = 0;   \
 436       __asm__ __volatile__(   \
 437           "movl 0(%0), %%eax\n\t"   \
 438           "pushl %%eax\n\t"   \
 439           "popfl\n\t"   \
 440           "movl 4(%0), %%ebx\n\t"   \
 441           "lock; " #_name " (%%ebx)\n\t"   \
 442           "pushfl\n\t"   \
 443           "popl %%eax\n\t"   \
 444           "movl %%eax, 8(%0)\n\t"   \
 445           : : "r"(&block[0]) : "eax","ebx","cc","memory"   \
 446       );   \
 447       \
 448       send( \
 449          sprintf(outBuf, \
 450                 "%s E=%08x CCIN=%08x -> E=%08x CCOUT=%08x\n",   \
 451              #_name, e_val_before, flags_in,         \
 452                 e_val, block[2] & CC_MASK));         \
 453       \
 454     }}}}}}   \
 455     \
 456     }   \
 457   }
 458
 459 GEN_do_locked_unary_E(decb,al)
 460 GEN_do_locked_unary_E(decw,ax)
 461 GEN_do_locked_unary_E(decl,eax)
 462
 463 GEN_do_locked_unary_E(incb,al)
 464 GEN_do_locked_unary_E(incw,ax)
 465 GEN_do_locked_unary_E(incl,eax)
 466
 467 GEN_do_locked_unary_E(negb,al)
 468 GEN_do_locked_unary_E(negw,ax)
 469 GEN_do_locked_unary_E(negl,eax)
 470
 471 GEN_do_locked_unary_E(notb,al)
 472 GEN_do_locked_unary_E(notw,ax)
 473 GEN_do_locked_unary_E(notl,eax)
 474
 475
 476 /////////////////////////////////////////////////////////////////
 477
 478 unsigned int btsl_mem ( UChar* base, int bitno )
 479 {
 480    unsigned char res;
 481    __asm__
 482    __volatile__("lock; btsl\t%2, %0\n\t"
 483                 "setc\t%1"
 484                 : "=m" (*base), "=q" (res)
 485                 : "r" (bitno));
 486    /* Pretty meaningless to dereference base here, but that's what you
 487       have to do to get a btsl insn which refers to memory starting at
 488       base. */
 489    return res;
 490 }
 491 unsigned int btsw_mem ( UChar* base, int bitno )
 492 {
 493    unsigned char res;
 494    __asm__
 495    __volatile__("lock; btsw\t%w2, %0\n\t"
 496                 "setc\t%1"
 497                 : "=m" (*base), "=q" (res)
 498                 : "r" (bitno));
 499    return res;
 500 }
 501
 502 unsigned int btrl_mem ( UChar* base, int bitno )
 503 {
 504    unsigned char res;
 505    __asm__
 506    __volatile__("lock; btrl\t%2, %0\n\t"
 507                 "setc\t%1"
 508                 : "=m" (*base), "=q" (res)
 509                 : "r" (bitno));
 510    return res;
 511 }
 512 unsigned int btrw_mem ( UChar* base, int bitno )
 513 {
 514    unsigned char res;
 515    __asm__
 516    __volatile__("lock; btrw\t%w2, %0\n\t"
 517                 "setc\t%1"
 518                 : "=m" (*base), "=q" (res)
 519                 : "r" (bitno));
 520    return res;
 521 }
 522
 523 unsigned int btcl_mem ( UChar* base, int bitno )
 524 {
 525    unsigned char res;
 526    __asm__
 527    __volatile__("lock; btcl\t%2, %0\n\t"
 528                 "setc\t%1"
 529                 : "=m" (*base), "=q" (res)
 530                 : "r" (bitno));
 531    return res;
 532 }
 533 unsigned int btcw_mem ( UChar* base, int bitno )
 534 {
 535    unsigned char res;
 536    __asm__
 537    __volatile__("lock; btcw\t%w2, %0\n\t"
 538                 "setc\t%1"
 539                 : "=m" (*base), "=q" (res)
 540                 : "r" (bitno));
 541    return res;
 542 }
 543
 544 unsigned int btl_mem ( UChar* base, int bitno )
 545 {
 546    unsigned char res;
 547    __asm__
 548    __volatile__("btl\t%2, %0\n\t"
 549                 "setc\t%1"
 550                 : "=m" (*base), "=q" (res)
 551                 : "r" (bitno)
 552                 : "cc", "memory");
 553    return res;
 554 }
 555 unsigned int btw_mem ( UChar* base, int bitno )
 556 {
 557    unsigned char res;
 558    __asm__
 559    __volatile__("btw\t%w2, %0\n\t"
 560                 "setc\t%1"
 561                 : "=m" (*base), "=q" (res)
 562                 : "r" (bitno));
 563    return res;
 564 }
 565
 566 ULong rol1 ( ULong x )
 567 {
 568   return (x << 1) | (x >> 63);
 569 }
 570
 571 void do_bt_G_E_tests ( void )
 572 {
 573    UInt   n, bitoff, op;
 574    UInt   c;
 575    UChar* block;
 576    ULong  carrydep, res;;
 577
 578    /*------------------------ MEM-L -----------------------*/
 579
 580    carrydep = 0;
 581    block = calloc(200,1);
 582    block += 100;
 583    /* Valid bit offsets are -800 .. 799 inclusive. */
 584
 585    for (n = 0; n < 10000; n++) {
 586       bitoff = (myrandom() % 1600) - 800;
 587       op = myrandom() % 4;
 588       c = 2;
 589       switch (op) {
 590          case 0: c = btsl_mem(block, bitoff); break;
 591          case 1: c = btrl_mem(block, bitoff); break;
 592          case 2: c = btcl_mem(block, bitoff); break;
 593          case 3: c = btl_mem(block, bitoff); break;
 594       }
 595       c &= 255;
 596       assert(c == 0 || c == 1);
 597       carrydep = c ? (rol1(carrydep) ^ (Long)(Int)bitoff) : carrydep;
 598    }
 599
 600    /* Compute final result */
 601    block -= 100;
 602    res = 0;
 603    for (n = 0; n < 200; n++) {
 604       UChar ch = block[n];
 605       /* printf("%d ", (int)block[n]); */
 606       res = rol1(res) ^ (ULong)ch;
 607    }
 608
 609    send( sprintf(outBuf,
 610                  "bt{s,r,c}l: final res 0x%llx, carrydep 0x%llx\n",
 611                  res, carrydep ));
 612    free(block);
 613
 614    /*------------------------ MEM-W -----------------------*/
 615
 616    carrydep = 0;
 617    block = calloc(200,1);
 618    block += 100;
 619    /* Valid bit offsets are -800 .. 799 inclusive. */
 620
 621    for (n = 0; n < 10000; n++) {
 622       bitoff = (myrandom() % 1600) - 800;
 623       op = myrandom() % 4;
 624       c = 2;
 625       switch (op) {
 626          case 0: c = btsw_mem(block, bitoff); break;
 627          case 1: c = btrw_mem(block, bitoff); break;
 628          case 2: c = btcw_mem(block, bitoff); break;
 629          case 3: c = btw_mem(block, bitoff); break;
 630       }
 631       c &= 255;
 632       assert(c == 0 || c == 1);
 633       carrydep = c ? (rol1(carrydep) ^ (Long)(Int)bitoff) : carrydep;
 634    }
 635
 636    /* Compute final result */
 637    block -= 100;
 638    res = 0;
 639    for (n = 0; n < 200; n++) {
 640       UChar ch = block[n];
 641       /* printf("%d ", (int)block[n]); */
 642       res = rol1(res) ^ (ULong)ch;
 643    }
 644
 645    send( sprintf(outBuf,
 646                  "bt{s,r,c}w: final res 0x%llx, carrydep 0x%llx\n",
 647                  res, carrydep ));
 648    free(block);
 649 }
 650
 651
 652 /////////////////////////////////////////////////////////////////
 653
 654 /* Given a word, do bt/bts/btr/btc on bits 0, 1, 2 and 3 of it, and
 655    also reconstruct the original bits 0, 1, 2, 3 by looking at the
 656    carry flag.  Returned result has mashed bits 0-3 at the bottom and
 657    the reconstructed original bits 0-3 as 4-7. */
 658
 659 UInt mash_mem_L ( UInt* origp )
 660 {
 661   UInt reconstructed, mashed;
 662   __asm__ __volatile__ (
 663      "movl %2, %%edx\n\t"
 664      ""
 665      "movl $0, %%eax\n\t"
 666      "\n\t"
 667      "btl  $0, (%%edx)\n\t"
 668      "setb %%cl\n\t"
 669      "movzbl %%cl, %%ecx\n\t"
 670      "orl %%ecx, %%eax\n\t"
 671      "\n\t"
 672      "lock; btsl $1, (%%edx)\n\t"
 673      "setb %%cl\n\t"
 674      "movzbl %%cl, %%ecx\n\t"
 675      "shll $1, %%ecx\n\t"
 676      "orl %%ecx, %%eax\n\t"
 677      "\n\t"
 678      "lock; btrl $2, (%%edx)\n\t"
 679      "setb %%cl\n\t"
 680      "movzbl %%cl, %%ecx\n\t"
 681      "shll $2, %%ecx\n\t"
 682      "orl %%ecx, %%eax\n\t"
 683      "\n\t"
 684      "lock; btcl $3, (%%edx)\n\t"
 685      "setb %%cl\n\t"
 686      "movzbl %%cl, %%ecx\n\t"
 687      "shll $3, %%ecx\n\t"
 688      "orl %%ecx, %%eax\n\t"
 689      "\n\t"
 690      "movl %%eax, %0\n\t"
 691      "movl (%%edx), %1"
 692
 693      : "=r" (reconstructed), "=r" (mashed)
 694      : "r" (origp)
 695      : "eax", "ecx", "edx", "cc");
 696   return (mashed & 0xF) | ((reconstructed & 0xF) << 4);
 697 }
 698
 699 UInt mash_mem_W ( UShort* origp )
 700 {
 701   UInt reconstructed, mashed;
 702   __asm__ __volatile__ (
 703      "movl %2, %%edx\n\t"
 704      ""
 705      "movl $0, %%eax\n\t"
 706      "\n\t"
 707      "btw  $0, (%%edx)\n\t"
 708      "setb %%cl\n\t"
 709      "movzbl %%cl, %%ecx\n\t"
 710      "orl %%ecx, %%eax\n\t"
 711      "\n\t"
 712      "lock; btsw $1, (%%edx)\n\t"
 713      "setb %%cl\n\t"
 714      "movzbl %%cl, %%ecx\n\t"
 715      "shll $1, %%ecx\n\t"
 716      "orl %%ecx, %%eax\n\t"
 717      "\n\t"
 718      "lock; btrw $2, (%%edx)\n\t"
 719      "setb %%cl\n\t"
 720      "movzbl %%cl, %%ecx\n\t"
 721      "shll $2, %%ecx\n\t"
 722      "orl %%ecx, %%eax\n\t"
 723      "\n\t"
 724      "lock; btcw $3, (%%edx)\n\t"
 725      "setb %%cl\n\t"
 726      "movzbl %%cl, %%ecx\n\t"
 727      "shll $3, %%ecx\n\t"
 728      "orl %%ecx, %%eax\n\t"
 729      "\n\t"
 730      "movl %%eax, %0\n\t"
 731      "movzwl (%%edx), %1"
 732
 733      : "=r" (reconstructed), "=r" (mashed)
 734      : "r" (origp)
 735      : "eax", "ecx", "edx", "cc");
 736   return (mashed & 0xF) | ((reconstructed & 0xF) << 4);
 737 }
 738
 739
 740 void do_bt_imm_E_tests( void )
 741 {
 742   int i;
 743   UInt*   iil = malloc(sizeof(UInt));
 744   UShort* iiw = malloc(sizeof(UShort));
 745   for (i = 0; i < 0x10; i++) {
 746     *iil = i;
 747     *iiw = i;
 748     send( sprintf(outBuf, "0x%x -> 0x%02x 0x%02x\n", i,
 749                   mash_mem_L(iil), mash_mem_W(iiw)));
 750   }
 751   free(iil);
 752   free(iiw);
 753 }
 754
 755
 756
 757 /////////////////////////////////////////////////////////////////
 758
 759 int main ( void )
 760 {
 761   do_locked_G_E_addb();
 762   do_locked_G_E_addw();
 763   do_locked_G_E_addl();
 764
 765   do_locked_G_E_orb();
 766   do_locked_G_E_orw();
 767   do_locked_G_E_orl();
 768
 769   do_locked_G_E_adcb();
 770   do_locked_G_E_adcw();
 771   do_locked_G_E_adcl();
 772
 773   do_locked_G_E_sbbb();
 774   do_locked_G_E_sbbw();
 775   do_locked_G_E_sbbl();
 776
 777   do_locked_G_E_andb();
 778   do_locked_G_E_andw();
 779   do_locked_G_E_andl();
 780
 781   do_locked_G_E_subb();
 782   do_locked_G_E_subw();
 783   do_locked_G_E_subl();
 784
 785   do_locked_G_E_xorb();
 786   do_locked_G_E_xorw();
 787   do_locked_G_E_xorl();
 788   //21
 789   do_locked_imm_E_addb_0x7F();
 790   do_locked_imm_E_addb_0xF1();
 791   do_locked_imm_E_addw_0x7E();
 792   do_locked_imm_E_addw_0x9325();
 793   do_locked_imm_E_addl_0x7D();
 794   do_locked_imm_E_addl_0x31415927();
 795
 796   do_locked_imm_E_orb_0x7F();
 797   do_locked_imm_E_orb_0xF1();
 798   do_locked_imm_E_orw_0x7E();
 799   do_locked_imm_E_orw_0x9325();
 800   do_locked_imm_E_orl_0x7D();
 801   do_locked_imm_E_orl_0x31415927();
 802
 803   do_locked_imm_E_adcb_0x7F();
 804   do_locked_imm_E_adcb_0xF1();
 805   do_locked_imm_E_adcw_0x7E();
 806   do_locked_imm_E_adcw_0x9325();
 807   do_locked_imm_E_adcl_0x7D();
 808   do_locked_imm_E_adcl_0x31415927();
 809
 810   do_locked_imm_E_sbbb_0x7F();
 811   do_locked_imm_E_sbbb_0xF1();
 812   do_locked_imm_E_sbbw_0x7E();
 813   do_locked_imm_E_sbbw_0x9325();
 814   do_locked_imm_E_sbbl_0x7D();
 815   do_locked_imm_E_sbbl_0x31415927();
 816
 817   do_locked_imm_E_andb_0x7F();
 818   do_locked_imm_E_andb_0xF1();
 819   do_locked_imm_E_andw_0x7E();
 820   do_locked_imm_E_andw_0x9325();
 821   do_locked_imm_E_andl_0x7D();
 822   do_locked_imm_E_andl_0x31415927();
 823
 824   do_locked_imm_E_subb_0x7F();
 825   do_locked_imm_E_subb_0xF1();
 826   do_locked_imm_E_subw_0x7E();
 827   do_locked_imm_E_subw_0x9325();
 828   do_locked_imm_E_subl_0x7D();
 829   do_locked_imm_E_subl_0x31415927();
 830
 831   do_locked_imm_E_xorb_0x7F();
 832   do_locked_imm_E_xorb_0xF1();
 833   do_locked_imm_E_xorw_0x7E();
 834   do_locked_imm_E_xorw_0x9325();
 835   do_locked_imm_E_xorl_0x7D();
 836   do_locked_imm_E_xorl_0x31415927();
 837   // 63
 838   do_locked_unary_E_decb();
 839   do_locked_unary_E_decw();
 840   do_locked_unary_E_decl();
 841
 842   do_locked_unary_E_incb();
 843   do_locked_unary_E_incw();
 844   do_locked_unary_E_incl();
 845
 846   do_locked_unary_E_negb();
 847   do_locked_unary_E_negw();
 848   do_locked_unary_E_negl();
 849
 850   do_locked_unary_E_notb();
 851   do_locked_unary_E_notw();
 852   do_locked_unary_E_notl();
 853   // 75
 854   do_bt_G_E_tests();
 855   // 81
 856   do_bt_imm_E_tests();
 857   // 87
 858   // So there should be 87 lock-prefixed instructions in the
 859   // disassembly of this compilation unit.
 860   // confirm with
 861   // objdump -d ./x86locked | grep lock | grep -v do_lock | grep -v elf32 | wc
 862
 863   { UInt crcExpd = 0xB2D75045;
 864     theCRC = crcFinalise( theCRC );
 865     if (theCRC == crcExpd) {
 866        printf("x86locked: PASS: CRCs actual 0x%08X expected 0x%08X\n",
 867               theCRC, crcExpd);
 868     } else {
 869        printf("x86locked: FAIL: CRCs actual 0x%08X expected 0x%08X\n",
 870               theCRC, crcExpd);
 871        printf("x86locked: set #define VERBOSE 1 to diagnose\n");
 872     }
 873   }
 874
 875   return 0;
 876 }