1 1,168c1,187 2 < /* CpuArch.c -- CPU specific code 3 < 2010-10-26: Igor Pavlov : Public domain */ 4 < 5 < #include "CpuArch.h" 6 < 7 < #ifdef MY_CPU_X86_OR_AMD64 8 < 9 < #if (defined(_MSC_VER) && !defined(MY_CPU_AMD64)) || defined(__GNUC__) 10 < #define USE_ASM 11 < #endif 12 < 13 < #if defined(USE_ASM) && !defined(MY_CPU_AMD64) 14 < static UInt32 CheckFlag(UInt32 flag) 15 < { 16 < #ifdef _MSC_VER 17 < __asm pushfd; 18 < __asm pop EAX; 19 < __asm mov EDX, EAX; 20 < __asm xor EAX, flag; 21 < __asm push EAX; 22 < __asm popfd; 23 < __asm pushfd; 24 < __asm pop EAX; 25 < __asm xor EAX, EDX; 26 < __asm push EDX; 27 < __asm popfd; 28 < __asm and flag, EAX; 29 < #else 30 < __asm__ __volatile__ ( 31 < "pushf\n\t" 32 < "pop %%EAX\n\t" 33 < "movl %%EAX,%%EDX\n\t" 34 < "xorl %0,%%EAX\n\t" 35 < "push %%EAX\n\t" 36 < "popf\n\t" 37 < "pushf\n\t" 38 < "pop %%EAX\n\t" 39 < "xorl %%EDX,%%EAX\n\t" 40 < "push %%EDX\n\t" 41 < "popf\n\t" 42 < "andl %%EAX, %0\n\t": 43 < "=c" (flag) : "c" (flag)); 44 < #endif 45 < return flag; 46 < } 47 < #define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False; 48 < #else 49 < #define CHECK_CPUID_IS_SUPPORTED 50 < #endif 51 < 52 < static void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d) 53 < { 54 < #ifdef USE_ASM 55 < 56 < #ifdef _MSC_VER 57 < 58 < UInt32 a2, b2, c2, d2; 59 < __asm xor EBX, EBX; 60 < __asm xor ECX, ECX; 61 < __asm xor EDX, EDX; 62 < __asm mov EAX, function; 63 < __asm cpuid; 64 < __asm mov a2, EAX; 65 < __asm mov b2, EBX; 66 < __asm mov c2, ECX; 67 < __asm mov d2, EDX; 68 < 69 < *a = a2; 70 < *b = b2; 71 < *c = c2; 72 < *d = d2; 73 < 74 < #else 75 < 76 < __asm__ __volatile__ ( 77 < "cpuid" 78 < : "=a" (*a) , 79 < "=b" (*b) , 80 < "=c" (*c) , 81 < "=d" (*d) 82 < : "0" (function)) ; 83 < 84 < #endif 85 < 86 < #else 87 < 88 < int CPUInfo[4]; 89 < __cpuid(CPUInfo, function); 90 < *a = CPUInfo[0]; 91 < *b = CPUInfo[1]; 92 < *c = CPUInfo[2]; 93 < *d = CPUInfo[3]; 94 < 95 < #endif 96 < } 97 < 98 < Bool x86cpuid_CheckAndRead(Cx86cpuid *p) 99 < { 100 < CHECK_CPUID_IS_SUPPORTED 101 < MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]); 102 < MyCPUID(1, &p->ver, &p->b, &p->c, &p->d); 103 < return True; 104 < } 105 < 106 < static UInt32 kVendors[][3] = 107 < { 108 < { 0x756E6547, 0x49656E69, 0x6C65746E}, 109 < { 0x68747541, 0x69746E65, 0x444D4163}, 110 < { 0x746E6543, 0x48727561, 0x736C7561} 111 < }; 112 < 113 < int x86cpuid_GetFirm(const Cx86cpuid *p) 114 < { 115 < unsigned i; 116 < for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); i++) 117 < { 118 < const UInt32 *v = kVendors[i]; 119 < if (v[0] == p->vendor[0] && 120 < v[1] == p->vendor[1] && 121 < v[2] == p->vendor[2]) 122 < return (int)i; 123 < } 124 < return -1; 125 < } 126 < 127 < Bool CPU_Is_InOrder() 128 < { 129 < Cx86cpuid p; 130 < int firm; 131 < UInt32 family, model; 132 < if (!x86cpuid_CheckAndRead(&p)) 133 < return True; 134 < family = x86cpuid_GetFamily(&p); 135 < model = x86cpuid_GetModel(&p); 136 < firm = x86cpuid_GetFirm(&p); 137 < switch (firm) 138 < { 139 < case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && model == 0x100C)); 140 < case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA))); 141 < case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF)); 142 < } 143 < return True; 144 < } 145 < 146 < #if !defined(MY_CPU_AMD64) && defined(_WIN32) 147 < static Bool CPU_Sys_Is_SSE_Supported() 148 < { 149 < OSVERSIONINFO vi; 150 < vi.dwOSVersionInfoSize = sizeof(vi); 151 < if (!GetVersionEx(&vi)) 152 < return False; 153 < return (vi.dwMajorVersion >= 5); 154 < } 155 < #define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False; 156 < #else 157 < #define CHECK_SYS_SSE_SUPPORT 158 < #endif 159 < 160 < Bool CPU_Is_Aes_Supported() 161 < { 162 < Cx86cpuid p; 163 < CHECK_SYS_SSE_SUPPORT 164 < if (!x86cpuid_CheckAndRead(&p)) 165 < return False; 166 < return (p.c >> 25) & 1; 167 < } 168 < 169 < #endif 170 --- 171 > /* CpuArch.c -- CPU specific code 172 > 2010-10-26: Igor Pavlov : Public domain */ 173 > 174 > #include "CpuArch.h" 175 > 176 > #ifdef MY_CPU_X86_OR_AMD64 177 > 178 > #if (defined(_MSC_VER) && !defined(MY_CPU_AMD64)) || defined(__GNUC__) 179 > #define USE_ASM 180 > #endif 181 > 182 > #if defined(USE_ASM) && !defined(MY_CPU_AMD64) 183 > static UInt32 CheckFlag(UInt32 flag) 184 > { 185 > #ifdef _MSC_VER 186 > __asm pushfd; 187 > __asm pop EAX; 188 > __asm mov EDX, EAX; 189 > __asm xor EAX, flag; 190 > __asm push EAX; 191 > __asm popfd; 192 > __asm pushfd; 193 > __asm pop EAX; 194 > __asm xor EAX, EDX; 195 > __asm push EDX; 196 > __asm popfd; 197 > __asm and flag, EAX; 198 > #else 199 > __asm__ __volatile__ ( 200 > "pushf\n\t" 201 > "pop %%EAX\n\t" 202 > "movl %%EAX,%%EDX\n\t" 203 > "xorl %0,%%EAX\n\t" 204 > "push %%EAX\n\t" 205 > "popf\n\t" 206 > "pushf\n\t" 207 > "pop %%EAX\n\t" 208 > "xorl %%EDX,%%EAX\n\t" 209 > "push %%EDX\n\t" 210 > "popf\n\t" 211 > "andl %%EAX, %0\n\t": 212 > "=c" (flag) : "c" (flag): 213 > "%eax", "%edx" ); 214 > #endif 215 > return flag; 216 > } 217 > #define CHECK_CPUID_IS_SUPPORTED if (CheckFlag(1 << 18) == 0 || CheckFlag(1 << 21) == 0) return False; 218 > #else 219 > #define CHECK_CPUID_IS_SUPPORTED 220 > #endif 221 > 222 > static void MyCPUID(UInt32 function, UInt32 *a, UInt32 *b, UInt32 *c, UInt32 *d) 223 > { 224 > #ifdef USE_ASM 225 > 226 > #ifdef _MSC_VER 227 > 228 > UInt32 a2, b2, c2, d2; 229 > __asm xor EBX, EBX; 230 > __asm xor ECX, ECX; 231 > __asm xor EDX, EDX; 232 > __asm mov EAX, function; 233 > __asm cpuid; 234 > __asm mov a2, EAX; 235 > __asm mov b2, EBX; 236 > __asm mov c2, ECX; 237 > __asm mov d2, EDX; 238 > 239 > *a = a2; 240 > *b = b2; 241 > *c = c2; 242 > *d = d2; 243 > 244 > #else 245 > 246 > #if defined(MY_CPU_AMD64) 247 > 248 > __asm__ __volatile__ ( 249 > "mov %%rbx, %%rdi\n" 250 > "cpuid\n" 251 > "xchg %%rdi, %%rbx\n" 252 > : "=a" (*a) , 253 > "=D" (*b) , 254 > "=c" (*c) , 255 > "=d" (*d) 256 > : "0" (function)) ; 257 > 258 > #else 259 > 260 > __asm__ __volatile__ ( 261 > "mov %%ebx, %%edi\n" 262 > "cpuid\n" 263 > "xchg %%edi, %%ebx\n" 264 > : "=a" (*a) , 265 > "=D" (*b) , 266 > "=c" (*c) , 267 > "=d" (*d) 268 > : "0" (function)) ; 269 > 270 > #endif 271 > 272 > #endif 273 > 274 > #else 275 > 276 > int CPUInfo[4]; 277 > __cpuid(CPUInfo, function); 278 > *a = CPUInfo[0]; 279 > *b = CPUInfo[1]; 280 > *c = CPUInfo[2]; 281 > *d = CPUInfo[3]; 282 > 283 > #endif 284 > } 285 > 286 > Bool x86cpuid_CheckAndRead(Cx86cpuid *p) 287 > { 288 > CHECK_CPUID_IS_SUPPORTED 289 > MyCPUID(0, &p->maxFunc, &p->vendor[0], &p->vendor[2], &p->vendor[1]); 290 > MyCPUID(1, &p->ver, &p->b, &p->c, &p->d); 291 > return True; 292 > } 293 > 294 > static UInt32 kVendors[][3] = 295 > { 296 > { 0x756E6547, 0x49656E69, 0x6C65746E}, 297 > { 0x68747541, 0x69746E65, 0x444D4163}, 298 > { 0x746E6543, 0x48727561, 0x736C7561} 299 > }; 300 > 301 > int x86cpuid_GetFirm(const Cx86cpuid *p) 302 > { 303 > unsigned i; 304 > for (i = 0; i < sizeof(kVendors) / sizeof(kVendors[i]); i++) 305 > { 306 > const UInt32 *v = kVendors[i]; 307 > if (v[0] == p->vendor[0] && 308 > v[1] == p->vendor[1] && 309 > v[2] == p->vendor[2]) 310 > return (int)i; 311 > } 312 > return -1; 313 > } 314 > 315 > Bool CPU_Is_InOrder() 316 > { 317 > Cx86cpuid p; 318 > int firm; 319 > UInt32 family, model; 320 > if (!x86cpuid_CheckAndRead(&p)) 321 > return True; 322 > family = x86cpuid_GetFamily(&p); 323 > model = x86cpuid_GetModel(&p); 324 > firm = x86cpuid_GetFirm(&p); 325 > switch (firm) 326 > { 327 > case CPU_FIRM_INTEL: return (family < 6 || (family == 6 && model == 0x100C)); 328 > case CPU_FIRM_AMD: return (family < 5 || (family == 5 && (model < 6 || model == 0xA))); 329 > case CPU_FIRM_VIA: return (family < 6 || (family == 6 && model < 0xF)); 330 > } 331 > return True; 332 > } 333 > 334 > #if !defined(MY_CPU_AMD64) && defined(_WIN32) 335 > static Bool CPU_Sys_Is_SSE_Supported() 336 > { 337 > OSVERSIONINFO vi; 338 > vi.dwOSVersionInfoSize = sizeof(vi); 339 > if (!GetVersionEx(&vi)) 340 > return False; 341 > return (vi.dwMajorVersion >= 5); 342 > } 343 > #define CHECK_SYS_SSE_SUPPORT if (!CPU_Sys_Is_SSE_Supported()) return False; 344 > #else 345 > #define CHECK_SYS_SSE_SUPPORT 346 > #endif 347 > 348 > Bool CPU_Is_Aes_Supported() 349 > { 350 > Cx86cpuid p; 351 > CHECK_SYS_SSE_SUPPORT 352 > if (!x86cpuid_CheckAndRead(&p)) 353 > return False; 354 > return (p.c >> 25) & 1; 355 > } 356 > 357 > #endif 358
