gdb/testsuite/gdb.reverse/insn-reverse-x86.c

   1 /* This testcase is part of GDB, the GNU debugger.
   2
   3    Copyright 2017 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #include <cpuid.h>
  19 #include <stdint.h>
  20
  21 /* 0 if the CPU supports rdrand/rdseed and non-zero otherwise.  */
  22 static unsigned int supports_rdrand;
  23
  24 /* Returns non-zero if rdrand/rdseed instructions are supported and
  25    zero otherwise.  */
  26
  27 static unsigned int
  28 check_rdrand_support (void)
  29 {
  30   unsigned int rdrand_mask = (1 << 30);
  31   unsigned int eax, ebx, ecx, edx;
  32
  33   __get_cpuid (1, &eax, &ebx, &ecx, &edx);
  34   return ((ecx & rdrand_mask) == rdrand_mask);
  35 }
  36
  37 /* Test rdrand support for various output registers.  */
  38
  39 void
  40 rdrand (void)
  41 {
  42   /* Get a random number from the rdrand assembly instruction.  */
  43   register uint64_t number;
  44
  45   if (!supports_rdrand)
  46     return;
  47
  48   /* 16-bit random numbers.  */
  49   __asm__ volatile ("rdrand %%ax;" : "=r" (number));
  50   __asm__ volatile ("rdrand %%bx;" : "=r" (number));
  51   __asm__ volatile ("rdrand %%cx;" : "=r" (number));
  52   __asm__ volatile ("rdrand %%dx;" : "=r" (number));
  53
  54   __asm__ volatile ("mov %%di, %%ax;" : "=r" (number));
  55   __asm__ volatile ("rdrand %%di;" : "=r" (number));
  56   __asm__ volatile ("mov %%ax, %%di;" : "=r" (number));
  57
  58   __asm__ volatile ("mov %%si, %%ax;" : "=r" (number));
  59   __asm__ volatile ("rdrand %%si;" : "=r" (number));
  60   __asm__ volatile ("mov %%ax, %%si;" : "=r" (number));
  61
  62   __asm__ volatile ("mov %%bp, %%ax;" : "=r" (number));
  63   __asm__ volatile ("rdrand %%bp;" : "=r" (number));
  64   __asm__ volatile ("mov %%ax, %%bp;" : "=r" (number));
  65
  66   __asm__ volatile ("mov %%sp, %%ax;" : "=r" (number));
  67   __asm__ volatile ("rdrand %%sp;" : "=r" (number));
  68   __asm__ volatile ("mov %%ax, %%sp;" : "=r" (number));
  69
  70   __asm__ volatile ("rdrand %%r8w;" : "=r" (number));
  71   __asm__ volatile ("rdrand %%r9w;" : "=r" (number));
  72   __asm__ volatile ("rdrand %%r10w;" : "=r" (number));
  73   __asm__ volatile ("rdrand %%r11w;" : "=r" (number));
  74   __asm__ volatile ("rdrand %%r12w;" : "=r" (number));
  75   __asm__ volatile ("rdrand %%r13w;" : "=r" (number));
  76   __asm__ volatile ("rdrand %%r14w;" : "=r" (number));
  77   __asm__ volatile ("rdrand %%r15w;" : "=r" (number));
  78
  79   /* 32-bit random numbers.  */
  80   __asm__ volatile ("rdrand %%eax;" : "=r" (number));
  81   __asm__ volatile ("rdrand %%ebx;" : "=r" (number));
  82   __asm__ volatile ("rdrand %%ecx;" : "=r" (number));
  83   __asm__ volatile ("rdrand %%edx;" : "=r" (number));
  84
  85   __asm__ volatile ("mov %%rdi, %%rax;" : "=r" (number));
  86   __asm__ volatile ("rdrand %%edi;" : "=r" (number));
  87   __asm__ volatile ("mov %%rax, %%rdi;" : "=r" (number));
  88
  89   __asm__ volatile ("mov %%rsi, %%rax;" : "=r" (number));
  90   __asm__ volatile ("rdrand %%esi;" : "=r" (number));
  91   __asm__ volatile ("mov %%rax, %%rsi;" : "=r" (number));
  92
  93   __asm__ volatile ("mov %%rbp, %%rax;" : "=r" (number));
  94   __asm__ volatile ("rdrand %%ebp;" : "=r" (number));
  95   __asm__ volatile ("mov %%rax, %%rbp;" : "=r" (number));
  96
  97   __asm__ volatile ("mov %%rsp, %%rax;" : "=r" (number));
  98   __asm__ volatile ("rdrand %%esp;" : "=r" (number));
  99   __asm__ volatile ("mov %%rax, %%rsp;" : "=r" (number));
 100
 101   __asm__ volatile ("rdrand %%r8d;" : "=r" (number));
 102   __asm__ volatile ("rdrand %%r9d;" : "=r" (number));
 103   __asm__ volatile ("rdrand %%r10d;" : "=r" (number));
 104   __asm__ volatile ("rdrand %%r11d;" : "=r" (number));
 105   __asm__ volatile ("rdrand %%r12d;" : "=r" (number));
 106   __asm__ volatile ("rdrand %%r13d;" : "=r" (number));
 107   __asm__ volatile ("rdrand %%r14d;" : "=r" (number));
 108   __asm__ volatile ("rdrand %%r15d;" : "=r" (number));
 109
 110   /* 64-bit random numbers.  */
 111   __asm__ volatile ("rdrand %%rax;" : "=r" (number));
 112   __asm__ volatile ("rdrand %%rbx;" : "=r" (number));
 113   __asm__ volatile ("rdrand %%rcx;" : "=r" (number));
 114   __asm__ volatile ("rdrand %%rdx;" : "=r" (number));
 115
 116   __asm__ volatile ("mov %%rdi, %%rax;" : "=r" (number));
 117   __asm__ volatile ("rdrand %%rdi;" : "=r" (number));
 118   __asm__ volatile ("mov %%rax, %%rdi;" : "=r" (number));
 119
 120   __asm__ volatile ("mov %%rsi, %%rax;" : "=r" (number));
 121   __asm__ volatile ("rdrand %%rsi;" : "=r" (number));
 122   __asm__ volatile ("mov %%rax, %%rsi;" : "=r" (number));
 123
 124   __asm__ volatile ("mov %%rbp, %%rax;" : "=r" (number));
 125   __asm__ volatile ("rdrand %%rbp;" : "=r" (number));
 126   __asm__ volatile ("mov %%rax, %%rbp;" : "=r" (number));
 127
 128   __asm__ volatile ("mov %%rsp, %%rax;" : "=r" (number));
 129   __asm__ volatile ("rdrand %%rsp;" : "=r" (number));
 130   __asm__ volatile ("mov %%rax, %%rsp;" : "=r" (number));
 131
 132   __asm__ volatile ("rdrand %%r8;" : "=r" (number));
 133   __asm__ volatile ("rdrand %%r9;" : "=r" (number));
 134   __asm__ volatile ("rdrand %%r10;" : "=r" (number));
 135   __asm__ volatile ("rdrand %%r11;" : "=r" (number));
 136   __asm__ volatile ("rdrand %%r12;" : "=r" (number));
 137   __asm__ volatile ("rdrand %%r13;" : "=r" (number));
 138   __asm__ volatile ("rdrand %%r14;" : "=r" (number));
 139   __asm__ volatile ("rdrand %%r15;" : "=r" (number));
 140 }
 141
 142 /* Test rdseed support for various output registers.  */
 143
 144 void
 145 rdseed (void)
 146 {
 147   /* Get a random seed from the rdseed assembly instruction.  */
 148   register long seed;
 149
 150   if (!supports_rdrand)
 151     return;
 152
 153   /* 16-bit random seeds.  */
 154   __asm__ volatile ("rdseed %%ax;" : "=r" (seed));
 155   __asm__ volatile ("rdseed %%bx;" : "=r" (seed));
 156   __asm__ volatile ("rdseed %%cx;" : "=r" (seed));
 157   __asm__ volatile ("rdseed %%dx;" : "=r" (seed));
 158
 159   __asm__ volatile ("mov %%di, %%ax;" : "=r" (seed));
 160   __asm__ volatile ("rdseed %%di;" : "=r" (seed));
 161   __asm__ volatile ("mov %%ax, %%di;" : "=r" (seed));
 162
 163   __asm__ volatile ("mov %%si, %%ax;" : "=r" (seed));
 164   __asm__ volatile ("rdseed %%si;" : "=r" (seed));
 165   __asm__ volatile ("mov %%ax, %%si;" : "=r" (seed));
 166
 167   __asm__ volatile ("mov %%bp, %%ax;" : "=r" (seed));
 168   __asm__ volatile ("rdseed %%bp;" : "=r" (seed));
 169   __asm__ volatile ("mov %%ax, %%bp;" : "=r" (seed));
 170
 171   __asm__ volatile ("mov %%sp, %%ax;" : "=r" (seed));
 172   __asm__ volatile ("rdseed %%sp;" : "=r" (seed));
 173   __asm__ volatile ("mov %%ax, %%sp;" : "=r" (seed));
 174
 175   __asm__ volatile ("rdseed %%r8w;" : "=r" (seed));
 176   __asm__ volatile ("rdseed %%r9w;" : "=r" (seed));
 177   __asm__ volatile ("rdseed %%r10w;" : "=r" (seed));
 178   __asm__ volatile ("rdseed %%r11w;" : "=r" (seed));
 179   __asm__ volatile ("rdseed %%r12w;" : "=r" (seed));
 180   __asm__ volatile ("rdseed %%r13w;" : "=r" (seed));
 181   __asm__ volatile ("rdseed %%r14w;" : "=r" (seed));
 182   __asm__ volatile ("rdseed %%r15w;" : "=r" (seed));
 183
 184   /* 32-bit random seeds.  */
 185   __asm__ volatile ("rdseed %%eax;" : "=r" (seed));
 186   __asm__ volatile ("rdseed %%ebx;" : "=r" (seed));
 187   __asm__ volatile ("rdseed %%ecx;" : "=r" (seed));
 188   __asm__ volatile ("rdseed %%edx;" : "=r" (seed));
 189
 190   __asm__ volatile ("mov %%rdi, %%rax;" : "=r" (seed));
 191   __asm__ volatile ("rdseed %%edi;" : "=r" (seed));
 192   __asm__ volatile ("mov %%rax, %%rdi;" : "=r" (seed));
 193
 194   __asm__ volatile ("mov %%rsi, %%rax;" : "=r" (seed));
 195   __asm__ volatile ("rdseed %%esi;" : "=r" (seed));
 196   __asm__ volatile ("mov %%rax, %%rsi;" : "=r" (seed));
 197
 198   __asm__ volatile ("mov %%rbp, %%rax;" : "=r" (seed));
 199   __asm__ volatile ("rdseed %%ebp;" : "=r" (seed));
 200   __asm__ volatile ("mov %%rax, %%rbp;" : "=r" (seed));
 201
 202   __asm__ volatile ("mov %%rsp, %%rax;" : "=r" (seed));
 203   __asm__ volatile ("rdseed %%esp;" : "=r" (seed));
 204   __asm__ volatile ("mov %%rax, %%rsp;" : "=r" (seed));
 205
 206   __asm__ volatile ("rdseed %%r8d;" : "=r" (seed));
 207   __asm__ volatile ("rdseed %%r9d;" : "=r" (seed));
 208   __asm__ volatile ("rdseed %%r10d;" : "=r" (seed));
 209   __asm__ volatile ("rdseed %%r11d;" : "=r" (seed));
 210   __asm__ volatile ("rdseed %%r12d;" : "=r" (seed));
 211   __asm__ volatile ("rdseed %%r13d;" : "=r" (seed));
 212   __asm__ volatile ("rdseed %%r14d;" : "=r" (seed));
 213   __asm__ volatile ("rdseed %%r15d;" : "=r" (seed));
 214
 215   /* 64-bit random seeds.  */
 216   __asm__ volatile ("rdseed %%rax;" : "=r" (seed));
 217   __asm__ volatile ("rdseed %%rbx;" : "=r" (seed));
 218   __asm__ volatile ("rdseed %%rcx;" : "=r" (seed));
 219   __asm__ volatile ("rdseed %%rdx;" : "=r" (seed));
 220
 221   __asm__ volatile ("mov %%rdi, %%rax;" : "=r" (seed));
 222   __asm__ volatile ("rdseed %%rdi;" : "=r" (seed));
 223   __asm__ volatile ("mov %%rax, %%rdi;" : "=r" (seed));
 224
 225   __asm__ volatile ("mov %%rsi, %%rax;" : "=r" (seed));
 226   __asm__ volatile ("rdseed %%rsi;" : "=r" (seed));
 227   __asm__ volatile ("mov %%rax, %%rsi;" : "=r" (seed));
 228
 229   __asm__ volatile ("mov %%rbp, %%rax;" : "=r" (seed));
 230   __asm__ volatile ("rdseed %%rbp;" : "=r" (seed));
 231   __asm__ volatile ("mov %%rax, %%rbp;" : "=r" (seed));
 232
 233   __asm__ volatile ("mov %%rsp, %%rax;" : "=r" (seed));
 234   __asm__ volatile ("rdseed %%rsp;" : "=r" (seed));
 235   __asm__ volatile ("mov %%rax, %%rsp;" : "=r" (seed));
 236
 237   __asm__ volatile ("rdseed %%r8;" : "=r" (seed));
 238   __asm__ volatile ("rdseed %%r9;" : "=r" (seed));
 239   __asm__ volatile ("rdseed %%r10;" : "=r" (seed));
 240   __asm__ volatile ("rdseed %%r11;" : "=r" (seed));
 241   __asm__ volatile ("rdseed %%r12;" : "=r" (seed));
 242   __asm__ volatile ("rdseed %%r13;" : "=r" (seed));
 243   __asm__ volatile ("rdseed %%r14;" : "=r" (seed));
 244   __asm__ volatile ("rdseed %%r15;" : "=r" (seed));
 245 }
 246
 247 /* Initialize arch-specific bits.  */
 248
 249 static void
 250 initialize (void)
 251 {
 252   /* Initialize supported features.  */
 253   supports_rdrand = check_rdrand_support ();
 254 }
 255
 256 /* Functions testing instruction decodings.  GDB will test all of these.  */
 257 static testcase_ftype testcases[] =
 258 {
 259   rdrand,
 260   rdseed
 261 };