michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "mpi.h"
michael@0: 
michael@0: /*
michael@0:  * This file implements a single function: s_mpi_getProcessorLineSize();
michael@0:  * s_mpi_getProcessorLineSize() returns the size in bytes of the cache line
michael@0:  * if a cache exists, or zero if there is no cache. If more than one
michael@0:  * cache line exists, it should return the smallest line size (which is 
michael@0:  * usually the L1 cache).
michael@0:  *
michael@0:  * mp_modexp uses this information to make sure that private key information
michael@0:  * isn't being leaked through the cache.
michael@0:  *
michael@0:  * Currently the file returns good data for most modern x86 processors, and
michael@0:  * reasonable data on 64-bit ppc processors. All other processors are assumed
michael@0:  * to have a cache line size of 32 bytes unless modified by target.mk.
michael@0:  * 
michael@0:  */
michael@0: 
michael@0: #if defined(i386) || defined(__i386) || defined(__X86__) || defined (_M_IX86) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
michael@0: /* X86 processors have special instructions that tell us about the cache */
michael@0: #include "string.h"
michael@0: 
michael@0: #if defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
michael@0: #define AMD_64 1
michael@0: #endif
michael@0: 
michael@0: /* Generic CPUID function */
michael@0: #if defined(AMD_64)
michael@0: 
michael@0: #if defined(__GNUC__)
michael@0: 
michael@0: void freebl_cpuid(unsigned long op, unsigned long *eax, 
michael@0: 	                 unsigned long *ebx, unsigned long *ecx, 
michael@0:                          unsigned long *edx)
michael@0: {
michael@0: 	__asm__("cpuid\n\t"
michael@0: 		: "=a" (*eax),
michael@0: 		  "=b" (*ebx),
michael@0: 		  "=c" (*ecx),
michael@0: 		  "=d" (*edx)
michael@0: 		: "0" (op));
michael@0: }
michael@0: 
michael@0: #elif defined(_MSC_VER)
michael@0: 
michael@0: #include <intrin.h>
michael@0: 
michael@0: void freebl_cpuid(unsigned long op, unsigned long *eax, 
michael@0:            unsigned long *ebx, unsigned long *ecx, 
michael@0:            unsigned long *edx)
michael@0: {
michael@0:     int intrinsic_out[4];
michael@0: 
michael@0:     __cpuid(intrinsic_out, op);
michael@0:     *eax = intrinsic_out[0];
michael@0:     *ebx = intrinsic_out[1];
michael@0:     *ecx = intrinsic_out[2];
michael@0:     *edx = intrinsic_out[3];
michael@0: }
michael@0: 
michael@0: #endif
michael@0: 
michael@0: #else /* !defined(AMD_64) */
michael@0: 
michael@0: /* x86 */
michael@0: 
michael@0: #if defined(__GNUC__)
michael@0: void freebl_cpuid(unsigned long op, unsigned long *eax, 
michael@0: 	                 unsigned long *ebx, unsigned long *ecx, 
michael@0:                          unsigned long *edx)
michael@0: {
michael@0: /* sigh GCC isn't smart enough to save the ebx PIC register on it's own
michael@0:  * in this case, so do it by hand. Use edi to store ebx and pass the
michael@0:  * value returned in ebx from cpuid through edi. */
michael@0: 	__asm__("mov %%ebx,%%edi\n\t"
michael@0: 		  "cpuid\n\t"
michael@0: 		  "xchgl %%ebx,%%edi\n\t"
michael@0: 		: "=a" (*eax),
michael@0: 		  "=D" (*ebx),
michael@0: 		  "=c" (*ecx),
michael@0: 		  "=d" (*edx)
michael@0: 		: "0" (op));
michael@0: }
michael@0: 
michael@0: /*
michael@0:  * try flipping a processor flag to determine CPU type
michael@0:  */
michael@0: static unsigned long changeFlag(unsigned long flag)
michael@0: {
michael@0: 	unsigned long changedFlags, originalFlags;
michael@0: 	__asm__("pushfl\n\t"            /* get the flags */
michael@0: 	        "popl %0\n\t"
michael@0: 	        "movl %0,%1\n\t"	/* save the original flags */
michael@0: 	        "xorl %2,%0\n\t" 	/* flip the bit */
michael@0: 		"pushl %0\n\t"  	/* set the flags */
michael@0: 	        "popfl\n\t"
michael@0: 		"pushfl\n\t"		/* get the flags again (for return) */
michael@0: 		"popl %0\n\t"
michael@0: 		"pushl %1\n\t"		/* restore the original flags */
michael@0: 		 "popfl\n\t"
michael@0: 		: "=r" (changedFlags),
michael@0: 		  "=r" (originalFlags),
michael@0: 		  "=r" (flag)
michael@0: 		: "2" (flag));
michael@0: 	return changedFlags ^ originalFlags;
michael@0: }
michael@0: 
michael@0: #elif defined(_MSC_VER)
michael@0: 
michael@0: /*
michael@0:  * windows versions of the above assembler
michael@0:  */
michael@0: #define wcpuid __asm __emit 0fh __asm __emit 0a2h
michael@0: void freebl_cpuid(unsigned long op,    unsigned long *Reax, 
michael@0:     unsigned long *Rebx, unsigned long *Recx, unsigned long *Redx)
michael@0: {
michael@0:         unsigned long  Leax, Lebx, Lecx, Ledx;
michael@0:         __asm {
michael@0:         pushad
michael@0:         mov     eax,op
michael@0:         wcpuid
michael@0:         mov     Leax,eax
michael@0:         mov     Lebx,ebx
michael@0:         mov     Lecx,ecx
michael@0:         mov     Ledx,edx
michael@0:         popad
michael@0:         }
michael@0:         *Reax = Leax;
michael@0:         *Rebx = Lebx;
michael@0:         *Recx = Lecx;
michael@0:         *Redx = Ledx;
michael@0: }
michael@0: 
michael@0: static unsigned long changeFlag(unsigned long flag)
michael@0: {
michael@0: 	unsigned long changedFlags, originalFlags;
michael@0: 	__asm {
michael@0: 		push eax
michael@0: 		push ebx
michael@0: 		pushfd 	                /* get the flags */
michael@0: 	        pop  eax
michael@0: 		push eax		/* save the flags on the stack */
michael@0: 	        mov  originalFlags,eax  /* save the original flags */
michael@0: 		mov  ebx,flag
michael@0: 	        xor  eax,ebx            /* flip the bit */
michael@0: 		push eax                /* set the flags */
michael@0: 	        popfd
michael@0: 		pushfd                  /* get the flags again (for return) */
michael@0: 		pop  eax	
michael@0: 		popfd                   /* restore the original flags */
michael@0: 		mov changedFlags,eax
michael@0: 		pop ebx
michael@0: 		pop eax
michael@0: 	}
michael@0: 	return changedFlags ^ originalFlags;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: #endif
michael@0: 
michael@0: #if !defined(AMD_64)
michael@0: #define AC_FLAG 0x40000
michael@0: #define ID_FLAG 0x200000
michael@0: 
michael@0: /* 386 processors can't flip the AC_FLAG, intel AP Note AP-485 */
michael@0: static int is386()
michael@0: {
michael@0:     return changeFlag(AC_FLAG) == 0;
michael@0: }
michael@0: 
michael@0: /* 486 processors can't flip the ID_FLAG, intel AP Note AP-485 */
michael@0: static int is486()
michael@0: {
michael@0:     return changeFlag(ID_FLAG) == 0;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * table for Intel Cache.
michael@0:  * See Intel Application Note AP-485 for more information 
michael@0:  */
michael@0: 
michael@0: typedef unsigned char CacheTypeEntry;
michael@0: 
michael@0: typedef enum {
michael@0:     Cache_NONE    = 0,
michael@0:     Cache_UNKNOWN = 1,
michael@0:     Cache_TLB     = 2,
michael@0:     Cache_TLBi    = 3,
michael@0:     Cache_TLBd    = 4,
michael@0:     Cache_Trace   = 5,
michael@0:     Cache_L1      = 6,
michael@0:     Cache_L1i     = 7,
michael@0:     Cache_L1d     = 8,
michael@0:     Cache_L2      = 9 ,
michael@0:     Cache_L2i     = 10 ,
michael@0:     Cache_L2d     = 11 ,
michael@0:     Cache_L3      = 12 ,
michael@0:     Cache_L3i     = 13,
michael@0:     Cache_L3d     = 14
michael@0: } CacheType;
michael@0: 
michael@0: struct _cache {
michael@0:     CacheTypeEntry type;
michael@0:     unsigned char lineSize;
michael@0: };
michael@0: static const struct _cache CacheMap[256] = {
michael@0: /* 00 */ {Cache_NONE,    0   },
michael@0: /* 01 */ {Cache_TLBi,    0   },
michael@0: /* 02 */ {Cache_TLBi,    0   },
michael@0: /* 03 */ {Cache_TLBd,    0   },
michael@0: /* 04 */ {Cache_TLBd,        },
michael@0: /* 05 */ {Cache_UNKNOWN, 0   },
michael@0: /* 06 */ {Cache_L1i,     32  },
michael@0: /* 07 */ {Cache_UNKNOWN, 0   },
michael@0: /* 08 */ {Cache_L1i,     32  },
michael@0: /* 09 */ {Cache_UNKNOWN, 0   },
michael@0: /* 0a */ {Cache_L1d,     32  },
michael@0: /* 0b */ {Cache_UNKNOWN, 0   },
michael@0: /* 0c */ {Cache_L1d,     32  },
michael@0: /* 0d */ {Cache_UNKNOWN, 0   },
michael@0: /* 0e */ {Cache_UNKNOWN, 0   },
michael@0: /* 0f */ {Cache_UNKNOWN, 0   },
michael@0: /* 10 */ {Cache_UNKNOWN, 0   },
michael@0: /* 11 */ {Cache_UNKNOWN, 0   },
michael@0: /* 12 */ {Cache_UNKNOWN, 0   },
michael@0: /* 13 */ {Cache_UNKNOWN, 0   },
michael@0: /* 14 */ {Cache_UNKNOWN, 0   },
michael@0: /* 15 */ {Cache_UNKNOWN, 0   },
michael@0: /* 16 */ {Cache_UNKNOWN, 0   },
michael@0: /* 17 */ {Cache_UNKNOWN, 0   },
michael@0: /* 18 */ {Cache_UNKNOWN, 0   },
michael@0: /* 19 */ {Cache_UNKNOWN, 0   },
michael@0: /* 1a */ {Cache_UNKNOWN, 0   },
michael@0: /* 1b */ {Cache_UNKNOWN, 0   },
michael@0: /* 1c */ {Cache_UNKNOWN, 0   },
michael@0: /* 1d */ {Cache_UNKNOWN, 0   },
michael@0: /* 1e */ {Cache_UNKNOWN, 0   },
michael@0: /* 1f */ {Cache_UNKNOWN, 0   },
michael@0: /* 20 */ {Cache_UNKNOWN, 0   },
michael@0: /* 21 */ {Cache_UNKNOWN, 0   },
michael@0: /* 22 */ {Cache_L3,      64  },
michael@0: /* 23 */ {Cache_L3,      64  },
michael@0: /* 24 */ {Cache_UNKNOWN, 0   },
michael@0: /* 25 */ {Cache_L3,      64  },
michael@0: /* 26 */ {Cache_UNKNOWN, 0   },
michael@0: /* 27 */ {Cache_UNKNOWN, 0   },
michael@0: /* 28 */ {Cache_UNKNOWN, 0   },
michael@0: /* 29 */ {Cache_L3,      64  },
michael@0: /* 2a */ {Cache_UNKNOWN, 0   },
michael@0: /* 2b */ {Cache_UNKNOWN, 0   },
michael@0: /* 2c */ {Cache_L1d,     64  },
michael@0: /* 2d */ {Cache_UNKNOWN, 0   },
michael@0: /* 2e */ {Cache_UNKNOWN, 0   },
michael@0: /* 2f */ {Cache_UNKNOWN, 0   },
michael@0: /* 30 */ {Cache_L1i,     64  },
michael@0: /* 31 */ {Cache_UNKNOWN, 0   },
michael@0: /* 32 */ {Cache_UNKNOWN, 0   },
michael@0: /* 33 */ {Cache_UNKNOWN, 0   },
michael@0: /* 34 */ {Cache_UNKNOWN, 0   },
michael@0: /* 35 */ {Cache_UNKNOWN, 0   },
michael@0: /* 36 */ {Cache_UNKNOWN, 0   },
michael@0: /* 37 */ {Cache_UNKNOWN, 0   },
michael@0: /* 38 */ {Cache_UNKNOWN, 0   },
michael@0: /* 39 */ {Cache_L2,      64  },
michael@0: /* 3a */ {Cache_UNKNOWN, 0   },
michael@0: /* 3b */ {Cache_L2,      64  },
michael@0: /* 3c */ {Cache_L2,      64  },
michael@0: /* 3d */ {Cache_UNKNOWN, 0   },
michael@0: /* 3e */ {Cache_UNKNOWN, 0   },
michael@0: /* 3f */ {Cache_UNKNOWN, 0   },
michael@0: /* 40 */ {Cache_L2,      0   },
michael@0: /* 41 */ {Cache_L2,      32  },
michael@0: /* 42 */ {Cache_L2,      32  },
michael@0: /* 43 */ {Cache_L2,      32  },
michael@0: /* 44 */ {Cache_L2,      32  },
michael@0: /* 45 */ {Cache_L2,      32  },
michael@0: /* 46 */ {Cache_UNKNOWN, 0   },
michael@0: /* 47 */ {Cache_UNKNOWN, 0   },
michael@0: /* 48 */ {Cache_UNKNOWN, 0   },
michael@0: /* 49 */ {Cache_UNKNOWN, 0   },
michael@0: /* 4a */ {Cache_UNKNOWN, 0   },
michael@0: /* 4b */ {Cache_UNKNOWN, 0   },
michael@0: /* 4c */ {Cache_UNKNOWN, 0   },
michael@0: /* 4d */ {Cache_UNKNOWN, 0   },
michael@0: /* 4e */ {Cache_UNKNOWN, 0   },
michael@0: /* 4f */ {Cache_UNKNOWN, 0   },
michael@0: /* 50 */ {Cache_TLBi,    0   },
michael@0: /* 51 */ {Cache_TLBi,    0   },
michael@0: /* 52 */ {Cache_TLBi,    0   },
michael@0: /* 53 */ {Cache_UNKNOWN, 0   },
michael@0: /* 54 */ {Cache_UNKNOWN, 0   },
michael@0: /* 55 */ {Cache_UNKNOWN, 0   },
michael@0: /* 56 */ {Cache_UNKNOWN, 0   },
michael@0: /* 57 */ {Cache_UNKNOWN, 0   },
michael@0: /* 58 */ {Cache_UNKNOWN, 0   },
michael@0: /* 59 */ {Cache_UNKNOWN, 0   },
michael@0: /* 5a */ {Cache_UNKNOWN, 0   },
michael@0: /* 5b */ {Cache_TLBd,    0   },
michael@0: /* 5c */ {Cache_TLBd,    0   },
michael@0: /* 5d */ {Cache_TLBd,    0   },
michael@0: /* 5e */ {Cache_UNKNOWN, 0   },
michael@0: /* 5f */ {Cache_UNKNOWN, 0   },
michael@0: /* 60 */ {Cache_UNKNOWN, 0   },
michael@0: /* 61 */ {Cache_UNKNOWN, 0   },
michael@0: /* 62 */ {Cache_UNKNOWN, 0   },
michael@0: /* 63 */ {Cache_UNKNOWN, 0   },
michael@0: /* 64 */ {Cache_UNKNOWN, 0   },
michael@0: /* 65 */ {Cache_UNKNOWN, 0   },
michael@0: /* 66 */ {Cache_L1d,     64  },
michael@0: /* 67 */ {Cache_L1d,     64  },
michael@0: /* 68 */ {Cache_L1d,     64  },
michael@0: /* 69 */ {Cache_UNKNOWN, 0   },
michael@0: /* 6a */ {Cache_UNKNOWN, 0   },
michael@0: /* 6b */ {Cache_UNKNOWN, 0   },
michael@0: /* 6c */ {Cache_UNKNOWN, 0   },
michael@0: /* 6d */ {Cache_UNKNOWN, 0   },
michael@0: /* 6e */ {Cache_UNKNOWN, 0   },
michael@0: /* 6f */ {Cache_UNKNOWN, 0   },
michael@0: /* 70 */ {Cache_Trace,   1   },
michael@0: /* 71 */ {Cache_Trace,   1   },
michael@0: /* 72 */ {Cache_Trace,   1   },
michael@0: /* 73 */ {Cache_UNKNOWN, 0   },
michael@0: /* 74 */ {Cache_UNKNOWN, 0   },
michael@0: /* 75 */ {Cache_UNKNOWN, 0   },
michael@0: /* 76 */ {Cache_UNKNOWN, 0   },
michael@0: /* 77 */ {Cache_UNKNOWN, 0   },
michael@0: /* 78 */ {Cache_UNKNOWN, 0   },
michael@0: /* 79 */ {Cache_L2,      64  },
michael@0: /* 7a */ {Cache_L2,      64  },
michael@0: /* 7b */ {Cache_L2,      64  },
michael@0: /* 7c */ {Cache_L2,      64  },
michael@0: /* 7d */ {Cache_UNKNOWN, 0   },
michael@0: /* 7e */ {Cache_UNKNOWN, 0   },
michael@0: /* 7f */ {Cache_UNKNOWN, 0   },
michael@0: /* 80 */ {Cache_UNKNOWN, 0   },
michael@0: /* 81 */ {Cache_UNKNOWN, 0   },
michael@0: /* 82 */ {Cache_L2,      32  },
michael@0: /* 83 */ {Cache_L2,      32  },
michael@0: /* 84 */ {Cache_L2,      32  },
michael@0: /* 85 */ {Cache_L2,      32  },
michael@0: /* 86 */ {Cache_L2,      64  },
michael@0: /* 87 */ {Cache_L2,      64  },
michael@0: /* 88 */ {Cache_UNKNOWN, 0   },
michael@0: /* 89 */ {Cache_UNKNOWN, 0   },
michael@0: /* 8a */ {Cache_UNKNOWN, 0   },
michael@0: /* 8b */ {Cache_UNKNOWN, 0   },
michael@0: /* 8c */ {Cache_UNKNOWN, 0   },
michael@0: /* 8d */ {Cache_UNKNOWN, 0   },
michael@0: /* 8e */ {Cache_UNKNOWN, 0   },
michael@0: /* 8f */ {Cache_UNKNOWN, 0   },
michael@0: /* 90 */ {Cache_UNKNOWN, 0   },
michael@0: /* 91 */ {Cache_UNKNOWN, 0   },
michael@0: /* 92 */ {Cache_UNKNOWN, 0   },
michael@0: /* 93 */ {Cache_UNKNOWN, 0   },
michael@0: /* 94 */ {Cache_UNKNOWN, 0   },
michael@0: /* 95 */ {Cache_UNKNOWN, 0   },
michael@0: /* 96 */ {Cache_UNKNOWN, 0   },
michael@0: /* 97 */ {Cache_UNKNOWN, 0   },
michael@0: /* 98 */ {Cache_UNKNOWN, 0   },
michael@0: /* 99 */ {Cache_UNKNOWN, 0   },
michael@0: /* 9a */ {Cache_UNKNOWN, 0   },
michael@0: /* 9b */ {Cache_UNKNOWN, 0   },
michael@0: /* 9c */ {Cache_UNKNOWN, 0   },
michael@0: /* 9d */ {Cache_UNKNOWN, 0   },
michael@0: /* 9e */ {Cache_UNKNOWN, 0   },
michael@0: /* 9f */ {Cache_UNKNOWN, 0   },
michael@0: /* a0 */ {Cache_UNKNOWN, 0   },
michael@0: /* a1 */ {Cache_UNKNOWN, 0   },
michael@0: /* a2 */ {Cache_UNKNOWN, 0   },
michael@0: /* a3 */ {Cache_UNKNOWN, 0   },
michael@0: /* a4 */ {Cache_UNKNOWN, 0   },
michael@0: /* a5 */ {Cache_UNKNOWN, 0   },
michael@0: /* a6 */ {Cache_UNKNOWN, 0   },
michael@0: /* a7 */ {Cache_UNKNOWN, 0   },
michael@0: /* a8 */ {Cache_UNKNOWN, 0   },
michael@0: /* a9 */ {Cache_UNKNOWN, 0   },
michael@0: /* aa */ {Cache_UNKNOWN, 0   },
michael@0: /* ab */ {Cache_UNKNOWN, 0   },
michael@0: /* ac */ {Cache_UNKNOWN, 0   },
michael@0: /* ad */ {Cache_UNKNOWN, 0   },
michael@0: /* ae */ {Cache_UNKNOWN, 0   },
michael@0: /* af */ {Cache_UNKNOWN, 0   },
michael@0: /* b0 */ {Cache_TLBi,    0   },
michael@0: /* b1 */ {Cache_UNKNOWN, 0   },
michael@0: /* b2 */ {Cache_UNKNOWN, 0   },
michael@0: /* b3 */ {Cache_TLBd,    0   },
michael@0: /* b4 */ {Cache_UNKNOWN, 0   },
michael@0: /* b5 */ {Cache_UNKNOWN, 0   },
michael@0: /* b6 */ {Cache_UNKNOWN, 0   },
michael@0: /* b7 */ {Cache_UNKNOWN, 0   },
michael@0: /* b8 */ {Cache_UNKNOWN, 0   },
michael@0: /* b9 */ {Cache_UNKNOWN, 0   },
michael@0: /* ba */ {Cache_UNKNOWN, 0   },
michael@0: /* bb */ {Cache_UNKNOWN, 0   },
michael@0: /* bc */ {Cache_UNKNOWN, 0   },
michael@0: /* bd */ {Cache_UNKNOWN, 0   },
michael@0: /* be */ {Cache_UNKNOWN, 0   },
michael@0: /* bf */ {Cache_UNKNOWN, 0   },
michael@0: /* c0 */ {Cache_UNKNOWN, 0   },
michael@0: /* c1 */ {Cache_UNKNOWN, 0   },
michael@0: /* c2 */ {Cache_UNKNOWN, 0   },
michael@0: /* c3 */ {Cache_UNKNOWN, 0   },
michael@0: /* c4 */ {Cache_UNKNOWN, 0   },
michael@0: /* c5 */ {Cache_UNKNOWN, 0   },
michael@0: /* c6 */ {Cache_UNKNOWN, 0   },
michael@0: /* c7 */ {Cache_UNKNOWN, 0   },
michael@0: /* c8 */ {Cache_UNKNOWN, 0   },
michael@0: /* c9 */ {Cache_UNKNOWN, 0   },
michael@0: /* ca */ {Cache_UNKNOWN, 0   },
michael@0: /* cb */ {Cache_UNKNOWN, 0   },
michael@0: /* cc */ {Cache_UNKNOWN, 0   },
michael@0: /* cd */ {Cache_UNKNOWN, 0   },
michael@0: /* ce */ {Cache_UNKNOWN, 0   },
michael@0: /* cf */ {Cache_UNKNOWN, 0   },
michael@0: /* d0 */ {Cache_UNKNOWN, 0   },
michael@0: /* d1 */ {Cache_UNKNOWN, 0   },
michael@0: /* d2 */ {Cache_UNKNOWN, 0   },
michael@0: /* d3 */ {Cache_UNKNOWN, 0   },
michael@0: /* d4 */ {Cache_UNKNOWN, 0   },
michael@0: /* d5 */ {Cache_UNKNOWN, 0   },
michael@0: /* d6 */ {Cache_UNKNOWN, 0   },
michael@0: /* d7 */ {Cache_UNKNOWN, 0   },
michael@0: /* d8 */ {Cache_UNKNOWN, 0   },
michael@0: /* d9 */ {Cache_UNKNOWN, 0   },
michael@0: /* da */ {Cache_UNKNOWN, 0   },
michael@0: /* db */ {Cache_UNKNOWN, 0   },
michael@0: /* dc */ {Cache_UNKNOWN, 0   },
michael@0: /* dd */ {Cache_UNKNOWN, 0   },
michael@0: /* de */ {Cache_UNKNOWN, 0   },
michael@0: /* df */ {Cache_UNKNOWN, 0   },
michael@0: /* e0 */ {Cache_UNKNOWN, 0   },
michael@0: /* e1 */ {Cache_UNKNOWN, 0   },
michael@0: /* e2 */ {Cache_UNKNOWN, 0   },
michael@0: /* e3 */ {Cache_UNKNOWN, 0   },
michael@0: /* e4 */ {Cache_UNKNOWN, 0   },
michael@0: /* e5 */ {Cache_UNKNOWN, 0   },
michael@0: /* e6 */ {Cache_UNKNOWN, 0   },
michael@0: /* e7 */ {Cache_UNKNOWN, 0   },
michael@0: /* e8 */ {Cache_UNKNOWN, 0   },
michael@0: /* e9 */ {Cache_UNKNOWN, 0   },
michael@0: /* ea */ {Cache_UNKNOWN, 0   },
michael@0: /* eb */ {Cache_UNKNOWN, 0   },
michael@0: /* ec */ {Cache_UNKNOWN, 0   },
michael@0: /* ed */ {Cache_UNKNOWN, 0   },
michael@0: /* ee */ {Cache_UNKNOWN, 0   },
michael@0: /* ef */ {Cache_UNKNOWN, 0   },
michael@0: /* f0 */ {Cache_UNKNOWN, 0   },
michael@0: /* f1 */ {Cache_UNKNOWN, 0   },
michael@0: /* f2 */ {Cache_UNKNOWN, 0   },
michael@0: /* f3 */ {Cache_UNKNOWN, 0   },
michael@0: /* f4 */ {Cache_UNKNOWN, 0   },
michael@0: /* f5 */ {Cache_UNKNOWN, 0   },
michael@0: /* f6 */ {Cache_UNKNOWN, 0   },
michael@0: /* f7 */ {Cache_UNKNOWN, 0   },
michael@0: /* f8 */ {Cache_UNKNOWN, 0   },
michael@0: /* f9 */ {Cache_UNKNOWN, 0   },
michael@0: /* fa */ {Cache_UNKNOWN, 0   },
michael@0: /* fb */ {Cache_UNKNOWN, 0   },
michael@0: /* fc */ {Cache_UNKNOWN, 0   },
michael@0: /* fd */ {Cache_UNKNOWN, 0   },
michael@0: /* fe */ {Cache_UNKNOWN, 0   },
michael@0: /* ff */ {Cache_UNKNOWN, 0   }
michael@0: };
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * use the above table to determine the CacheEntryLineSize.
michael@0:  */
michael@0: static void
michael@0: getIntelCacheEntryLineSize(unsigned long val, int *level, 
michael@0: 						unsigned long *lineSize)
michael@0: {
michael@0:     CacheType type;
michael@0: 
michael@0:     type = CacheMap[val].type;
michael@0:     /* only interested in data caches */
michael@0:     /* NOTE val = 0x40 is a special value that means no L2 or L3 cache.
michael@0:      * this data check has the side effect of rejecting that entry. If
michael@0:      * that wasn't the case, we could have to reject it explicitly */
michael@0:     if (CacheMap[val].lineSize == 0) {
michael@0: 	return;
michael@0:     }
michael@0:     /* look at the caches, skip types we aren't interested in.
michael@0:      * if we already have a value for a lower level cache, skip the
michael@0:      * current entry */
michael@0:     if ((type == Cache_L1)|| (type == Cache_L1d)) {
michael@0: 	*level = 1;
michael@0: 	*lineSize = CacheMap[val].lineSize;
michael@0:     } else if ((*level >= 2) && ((type == Cache_L2) || (type == Cache_L2d))) {
michael@0: 	*level = 2;
michael@0: 	*lineSize = CacheMap[val].lineSize;
michael@0:     } else if ((*level >= 3) && ((type == Cache_L3) || (type == Cache_L3d))) {
michael@0: 	*level = 3;
michael@0: 	*lineSize = CacheMap[val].lineSize;
michael@0:     }
michael@0:     return;
michael@0: }
michael@0: 
michael@0: 
michael@0: static void
michael@0: getIntelRegisterCacheLineSize(unsigned long val, 
michael@0: 			int *level, unsigned long *lineSize)
michael@0: {
michael@0:     getIntelCacheEntryLineSize(val >> 24 & 0xff, level, lineSize);
michael@0:     getIntelCacheEntryLineSize(val >> 16 & 0xff, level, lineSize);
michael@0:     getIntelCacheEntryLineSize(val >> 8 & 0xff, level, lineSize);
michael@0:     getIntelCacheEntryLineSize(val & 0xff, level, lineSize);
michael@0: }
michael@0: 
michael@0: /*
michael@0:  * returns '0' if no recognized cache is found, or if the cache
michael@0:  * information is supported by this processor 
michael@0:  */
michael@0: static unsigned long
michael@0: getIntelCacheLineSize(int cpuidLevel)
michael@0: {
michael@0:     int level = 4;
michael@0:     unsigned long lineSize = 0;
michael@0:     unsigned long eax, ebx, ecx, edx;
michael@0:     int repeat, count;
michael@0: 
michael@0:     if (cpuidLevel < 2) {
michael@0: 	return 0;
michael@0:     }
michael@0: 
michael@0:     /* command '2' of the cpuid is intel's cache info call. Each byte of the
michael@0:      * 4 registers contain a potential descriptor for the cache. The CacheMap	
michael@0:      * table maps the cache entry with the processor cache. Register 'al'
michael@0:      * contains a count value that cpuid '2' needs to be called in order to 
michael@0:      * find all the cache descriptors. Only registers with the high bit set
michael@0:      * to 'zero' have valid descriptors. This code loops through all the
michael@0:      * required calls to cpuid '2' and passes any valid descriptors it finds
michael@0:      * to the getIntelRegisterCacheLineSize code, which breaks the registers
michael@0:      * down into their component descriptors. In the end the lineSize of the
michael@0:      * lowest level cache data cache is returned. */
michael@0:     freebl_cpuid(2, &eax, &ebx, &ecx, &edx);
michael@0:     repeat = eax & 0xf;
michael@0:     for (count = 0; count < repeat; count++) {
michael@0: 	if ((eax & 0x80000000) == 0) {
michael@0: 	    getIntelRegisterCacheLineSize(eax & 0xffffff00, &level, &lineSize);
michael@0: 	}
michael@0: 	if ((ebx & 0x80000000) == 0) {
michael@0: 	    getIntelRegisterCacheLineSize(ebx, &level, &lineSize);
michael@0: 	}
michael@0: 	if ((ecx & 0x80000000) == 0) {
michael@0: 	    getIntelRegisterCacheLineSize(ecx, &level, &lineSize);
michael@0: 	}
michael@0: 	if ((edx & 0x80000000) == 0) {
michael@0: 	    getIntelRegisterCacheLineSize(edx, &level, &lineSize);
michael@0: 	}
michael@0: 	if (count+1 != repeat) {
michael@0: 	    freebl_cpuid(2, &eax, &ebx, &ecx, &edx);
michael@0: 	}
michael@0:     }
michael@0:     return lineSize;
michael@0: }
michael@0: 
michael@0: /*
michael@0:  * returns '0' if the cache info is not supported by this processor.
michael@0:  * This is based on the AMD extended cache commands for cpuid. 
michael@0:  * (see "AMD Processor Recognition Application Note" Publication 20734).
michael@0:  * Some other processors use the identical scheme.
michael@0:  * (see "Processor Recognition, Transmeta Corporation").
michael@0:  */
michael@0: static unsigned long
michael@0: getOtherCacheLineSize(unsigned long cpuidLevel)
michael@0: {
michael@0:     unsigned long lineSize = 0;
michael@0:     unsigned long eax, ebx, ecx, edx;
michael@0: 
michael@0:     /* get the Extended CPUID level */
michael@0:     freebl_cpuid(0x80000000, &eax, &ebx, &ecx, &edx);
michael@0:     cpuidLevel = eax;
michael@0: 
michael@0:     if (cpuidLevel >= 0x80000005) {
michael@0: 	freebl_cpuid(0x80000005, &eax, &ebx, &ecx, &edx);
michael@0: 	lineSize = ecx & 0xff; /* line Size, L1 Data Cache */
michael@0:     }
michael@0:     return lineSize;
michael@0: }
michael@0: 
michael@0: static const char * const manMap[] = {
michael@0: #define INTEL     0
michael@0:     "GenuineIntel",
michael@0: #define AMD       1
michael@0:     "AuthenticAMD",
michael@0: #define CYRIX     2
michael@0:     "CyrixInstead",
michael@0: #define CENTAUR   2
michael@0:     "CentaurHauls",
michael@0: #define NEXGEN    3
michael@0:     "NexGenDriven",
michael@0: #define TRANSMETA 4
michael@0:     "GenuineTMx86",
michael@0: #define RISE      5
michael@0:     "RiseRiseRise",
michael@0: #define UMC       6
michael@0:     "UMC UMC UMC ",
michael@0: #define SIS       7
michael@0:     "Sis Sis Sis ",
michael@0: #define NATIONAL  8
michael@0:     "Geode by NSC",
michael@0: };
michael@0: 
michael@0: static const int n_manufacturers = sizeof(manMap)/sizeof(manMap[0]);
michael@0: 
michael@0: 
michael@0: #define MAN_UNKNOWN 9
michael@0: 
michael@0: #if !defined(AMD_64)
michael@0: #define SSE2_FLAG (1<<26)
michael@0: unsigned long
michael@0: s_mpi_is_sse2()
michael@0: {
michael@0:     unsigned long eax, ebx, ecx, edx;
michael@0:     int manufacturer = MAN_UNKNOWN;
michael@0:     int i;
michael@0:     char string[13];
michael@0: 
michael@0:     if (is386() || is486()) {
michael@0: 	return 0;
michael@0:     }
michael@0:     freebl_cpuid(0, &eax, &ebx, &ecx, &edx);
michael@0:     /* string holds the CPU's manufacturer ID string - a twelve
michael@0:      * character ASCII string stored in ebx, edx, ecx, and
michael@0:      * the 32-bit extended feature flags are in edx, ecx.
michael@0:      */
michael@0:     *(int *)string = ebx;
michael@0:     *(int *)&string[4] = (int)edx;
michael@0:     *(int *)&string[8] = (int)ecx;
michael@0:     string[12] = 0;
michael@0: 
michael@0:     /* has no SSE2 extensions */
michael@0:     if (eax == 0) {
michael@0: 	return 0;
michael@0:     }
michael@0: 
michael@0:     for (i=0; i < n_manufacturers; i++) {
michael@0: 	if ( strcmp(manMap[i],string) == 0) {
michael@0: 	    manufacturer = i;
michael@0: 	    break;
michael@0: 	}
michael@0:     }
michael@0: 
michael@0:     freebl_cpuid(1,&eax,&ebx,&ecx,&edx);
michael@0:     return (edx & SSE2_FLAG) == SSE2_FLAG;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: unsigned long
michael@0: s_mpi_getProcessorLineSize()
michael@0: {
michael@0:     unsigned long eax, ebx, ecx, edx;
michael@0:     unsigned long cpuidLevel;
michael@0:     unsigned long cacheLineSize = 0;
michael@0:     int manufacturer = MAN_UNKNOWN;
michael@0:     int i;
michael@0:     char string[65];
michael@0: 
michael@0: #if !defined(AMD_64)
michael@0:     if (is386()) {
michael@0: 	return 0; /* 386 had no cache */
michael@0:     } if (is486()) {
michael@0: 	return 32; /* really? need more info */
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     /* Pentium, cpuid command is available */
michael@0:     freebl_cpuid(0, &eax, &ebx, &ecx, &edx);
michael@0:     cpuidLevel = eax;
michael@0:     /* string holds the CPU's manufacturer ID string - a twelve
michael@0:      * character ASCII string stored in ebx, edx, ecx, and
michael@0:      * the 32-bit extended feature flags are in edx, ecx.
michael@0:      */
michael@0:     *(int *)string = ebx;
michael@0:     *(int *)&string[4] = (int)edx;
michael@0:     *(int *)&string[8] = (int)ecx;
michael@0:     string[12] = 0;
michael@0: 
michael@0:     manufacturer = MAN_UNKNOWN;
michael@0:     for (i=0; i < n_manufacturers; i++) {
michael@0: 	if ( strcmp(manMap[i],string) == 0) {
michael@0: 	    manufacturer = i;
michael@0: 	}
michael@0:     }
michael@0: 
michael@0:     if (manufacturer == INTEL) {
michael@0: 	cacheLineSize = getIntelCacheLineSize(cpuidLevel);
michael@0:     } else {
michael@0: 	cacheLineSize = getOtherCacheLineSize(cpuidLevel);
michael@0:     }
michael@0:     /* doesn't support cache info based on cpuid. This means
michael@0:      * an old pentium class processor, which have cache lines of
michael@0:      * 32. If we learn differently, we can use a switch based on
michael@0:      * the Manufacturer id  */
michael@0:     if (cacheLineSize == 0) {
michael@0: 	cacheLineSize = 32;
michael@0:     }
michael@0:     return cacheLineSize;
michael@0: }
michael@0: #define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
michael@0: #endif
michael@0: 
michael@0: #if defined(__ppc64__) 
michael@0: /*
michael@0:  *  Sigh, The PPC has some really nice features to help us determine cache
michael@0:  *  size, since it had lots of direct control functions to do so. The POWER
michael@0:  *  processor even has an instruction to do this, but it was dropped in
michael@0:  *  PowerPC. Unfortunately most of them are not available in user mode.
michael@0:  *
michael@0:  *  The dcbz function would be a great way to determine cache line size except
michael@0:  *  1) it only works on write-back memory (it throws an exception otherwise), 
michael@0:  *  and 2) because so many mac programs 'knew' the processor cache size was
michael@0:  *  32 bytes, they used this instruction as a fast 'zero 32 bytes'. Now the new
michael@0:  *  G5 processor has 128 byte cache, but dcbz only clears 32 bytes to keep
michael@0:  *  these programs happy. dcbzl work if 64 bit instructions are supported.
michael@0:  *  If you know 64 bit instructions are supported, and that stack is 
michael@0:  *  write-back, you can use this code.
michael@0:  */
michael@0: #include "memory.h"
michael@0: 
michael@0: /* clear the cache line that contains 'array' */
michael@0: static inline void dcbzl(char *array)
michael@0: {
michael@0: 	register char *a asm("r2") = array;
michael@0: 	__asm__ __volatile__( "dcbzl %0,r0" : "=r" (a): "0"(a) );
michael@0: }
michael@0: 
michael@0: 
michael@0: #define PPC_DO_ALIGN(x,y) ((char *)\
michael@0: 			((((long long) (x))+((y)-1))&~((y)-1)))
michael@0: 
michael@0: #define PPC_MAX_LINE_SIZE 256
michael@0: unsigned long
michael@0: s_mpi_getProcessorLineSize()
michael@0: {
michael@0:     char testArray[2*PPC_MAX_LINE_SIZE+1];
michael@0:     char *test;
michael@0:     int i;
michael@0: 
michael@0:     /* align the array on a maximum line size boundary, so we
michael@0:      * know we are starting to clear from the first address */
michael@0:     test = PPC_DO_ALIGN(testArray, PPC_MAX_LINE_SIZE); 
michael@0:     /* set all the values to 1's */
michael@0:     memset(test, 0xff, PPC_MAX_LINE_SIZE);
michael@0:     /* clear one cache block starting at 'test' */
michael@0:     dcbzl(test);
michael@0: 
michael@0:     /* find the size of the cleared area, that's our block size */
michael@0:     for (i=PPC_MAX_LINE_SIZE; i != 0; i = i/2) {
michael@0: 	if (test[i-1] == 0) {
michael@0: 	    return i;
michael@0: 	}
michael@0:     }
michael@0:     return 0;
michael@0: }
michael@0: 
michael@0: #define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
michael@0: #endif
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * put other processor and platform specific cache code here
michael@0:  * return the smallest cache line size in bytes on the processor 
michael@0:  * (usually the L1 cache). If the OS has a call, this would be
michael@0:  * a greate place to put it.
michael@0:  *
michael@0:  * If there is no cache, return 0;
michael@0:  * 
michael@0:  * define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED so the generic functions
michael@0:  * below aren't compiled.
michael@0:  *
michael@0:  */
michael@0: 
michael@0: 
michael@0: /* target.mk can define MPI_CACHE_LINE_SIZE if it's common for the family or 
michael@0:  * OS */
michael@0: #if defined(MPI_CACHE_LINE_SIZE) && !defined(MPI_GET_PROCESSOR_LINE_SIZE_DEFINED)
michael@0: 
michael@0: unsigned long
michael@0: s_mpi_getProcessorLineSize()
michael@0: {
michael@0:    return MPI_CACHE_LINE_SIZE;
michael@0: }
michael@0: #define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
michael@0: #endif
michael@0: 
michael@0: 
michael@0: /* If no way to get the processor cache line size has been defined, assume
michael@0:  * it's 32 bytes (most common value, does not significantly impact performance)
michael@0:  */ 
michael@0: #ifndef MPI_GET_PROCESSOR_LINE_SIZE_DEFINED
michael@0: unsigned long
michael@0: s_mpi_getProcessorLineSize()
michael@0: {
michael@0:    return 32;
michael@0: }
michael@0: #endif
michael@0: 
michael@0: #ifdef TEST_IT
michael@0: #include <stdio.h>
michael@0: 
michael@0: main()
michael@0: {
michael@0:     printf("line size = %d\n", s_mpi_getProcessorLineSize());
michael@0: } 
michael@0: #endif