/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "mpi.h"
#include "prtypes.h"

/*
 * This file implements a single function: s_mpi_getProcessorLineSize();
*s_mpi_getProcessorLineSize( returns the size    the cache line
*ifa   if there   .one
  line size (which is
 * usually the L1 cache).
 *
 * mp_modexp uses this information to make sure that  * s_mpi_getProcessorLineSize() returns the size in bytesline
 * isn't being leaked through the cache.
 *
 * Currently the file returns good data for most modern x86 processors, and
 * reasonable data on 64-bit ppc processors. All other processors are assumed
 * to*isntthe .
 *
 */

#if defined  
/* X86 processors have special instructions that tell us about the cache */
#include "string.h"

#if defined(__x86_64__) || defined(__x86_64)  on other 
#define AMD_64 1
#endif

/* Generic CPUID function */
#if defined(AMD_64)

#if defined(__  to size 32 java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

void
freebl_cpuidunsigned long op,unsignedlong*ax
             (unsigned op *,
unsigned *)
{
    __asm__("xor %%ecx, %%ecx\n\t"
            "nt"
            : "{
              "=b"(*ebx),
              "=c"(*ecx),
              "=d"(*edx)
            : "0"(op));
}

defined_java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 25

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
freebl_cpuid(unsigned long op,  unsigned  *,java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 52
     4;
             unsigned long *edx)
 _( )
int4;

    _  1]
    =0]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
     1;
    *java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    *freebl_cpuid java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 50
}

#endif

#else /* !defined(AMD_64) */

/* x86 */

#if (__NUC__
void
freebl_cpuid(unsigned longop unsigned long eax
             unsigned  ebx long*,
             unsigned long *edx     *erroneously indicate that  CPU features are present.
{
    /* Some older processors don't fill the ecx register with cpuid, so clobber it
     * before calling      Also,GCC isn't  enough to  the   register on its own
     *           =(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
     * Also, GCC isn't smart enough to save the ebx PIC register on its own
*  ,so   by  edi store    
     * value returned in ebx from cpuid through edi. */
    __asm__("xor %%ecx, %%ecx\n\t"
            "mov %%ebx,%%edi\n\t"
            "cpuid\n\t"
            "xchgl %%ebx,%%edi\n\t"
            : "=a"(*eax),
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              "=c"(*ecx),
              "d"*dxjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            : "0"(op));
}

/*
 * try flipping a processor flag to java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 */
static java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
(longjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
{
ed ,;
    __java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
            "    _ {
            movl 0%\\"/java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
              java.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 20
             0n\ /* set the flags */
              ebx/* flip the bit */
            pjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 63
             
            "%\t *  flags*
            "popfl\pop  
            : "=r"(changedFlags),
              "=r"(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 28
              "=r        pop eax
            : "2"(flag));
    return java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5
}returnjava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 36

#elif defined(_MSC_VER)

/*
 * windows versions of the above java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
 */
#define wcpuid 4
void
freebl_cpuidCache_L1 ,
             unsigned long *Rebx, unsigned long *Recx, unsigned long *Redx)
{java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 19
    Cache_L3djava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    _CacheTy type
        pushad
        xor,
        mov     eax,op
          256  java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
        mov     ache_TLBi,0},
             Lebxjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        mov     Lecx/* 04 */ {
            Ledx
java.lang.StringIndexOutOfBoundsException: Range [34, 13) out of bounds for length 13
    }
        /* 08 */ { Cache_L1i, 32 },
    *Rebx = Lebx;
    *Recx = Lecx;
    *Redx = Ledx;/* 0c */ { Cache_L1d, 32 },
}

static unsigned long
changeFlag/*0e * {Cache_UNKNOWN 0}java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
        /* 11 / {Cache_UNKNOWN 0 }
    __asm {
        push
        push /* 15 */ { Cache_UNKNOWN, 0 },
        pushfd /* get the flags *//* 17* { Cache_UNKNOWN, 0 },
                /* 19 */ { , }java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        push     
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
        movjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                /* 24 */ { 
        push eax /* set the flags */
            popfd
        pushfd /* get the flags again (for return) */
        pop  /* 2b */ { Cache_UNKNOWN, 0 },
        popfd /* restore the original flags */
        mov changedFlags,    
    * 32 */ { Cache_UNKNOWN, 0 },
        pop
    }
    return
}
#endif

#endif

#if     
#define java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#define     /* 43 */ { , 32}

/* 386 processors can't flip the AC_FLAG, intel AP Note AP-485 */
static int
java.lang.StringIndexOutOfBoundsException: Range [30, 3) out of bounds for length 30
{
    return     
}

/* 486 processors can't flip the ID_FLAG, intel AP Note AP-485 */
static int
is486()
{
    return changeFlag
}
#endif

/*
 * table    
 * /* 55 / {Cache_UNKNOWN, 0 },
 */

    /* 5b */ { Cache_TLBd, 0 },

typedef enum {
    /* 5f */ { Cache_UNKNOWN, 0 },
    Cache_UNKNOWN = 1,
    Cache_TLB = 2,
    Cache_TLBi /* 63 */ { Cache_UNKNOWN, 0 },
    Cache_TLBd =    
    Cache_Trace = 5,
        /*
    Cache_L1i/* 68 */ { Cache_L1d, 64 },
    Cache_L1d = 8,
    java.lang.StringIndexOutOfBoundsException: Range [34, 9) out of bounds for length 34
    Cache_L2i = 10,
    Cache_L2d java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    Cache_L3 = 12,java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    Cache_L3i =    /* 76 */ { Cache_UNKNOWN, 0 },
    Cache_L3d = 14
} CacheType;

struct _ache {
        /* 7c *
    
}/
static /* 7f */ { Cache_UNKNOWN, 0 },
    /* 00 */ { Cache_NONE, 0 },
    /* 01 */ { Cache_TLBi, 0 },
    /* 02 */ { Cache_TLBi, 0 },
    /* 03 */ { Cache_TLBd, 0 },
    /* 84 */ { Cache_L2, 32 },
        Cache_TLBd/* 85 */ { Cache_L2, 32 },
    },
    /* 05 */ { Cache_UNKNOWN, 0 },
    /* 06 */ { Cache_L1i, 32 },
    /* 07 */ { Cache_UNKNOWN, 0 },
    /* 08 */ { Cache_L1i, 32 },
    /* 09 */ { Cache_UNKNOWN, 0 },    /* 8d */ { Cache_UNKNOWN, 0 },
    /* 0a */ { Cache_L1d, 32 },
    /* 0b */ { Cache_UNKNOWN, 0 },
    /* 0c */ { Cache_L1d, 32 },
    /* 0d */ { Cache_UNKNOWN, 0 },
    /* 0e */ { Cache_UNKNOWN, 0 },
    /* 0f */ { Cache_UNKNOWN, 0 },
    /* 10 */ { Cache_UNKNOWN, 0 },
    /* 11 */ { Cache_UNKNOWN, 0 },
    /* 12 */ { Cache_UNKNOWN, 0 },
    /* 13 */ { Cache_UNKNOWN, 0 },
    /* 14 */ { Cache_UNKNOWN, 0 },
    /* 15 */ { Cache_UNKNOWN, 0 },
    /* 16 */ { Cache_UNKNOWN, 0 },
    /* 17 */ { Cache_UNKNOWN, 0 },
    /* 18 */ { Cache_UNKNOWN, 0 },
    /* 19 */ { Cache_UNKNOWN, 0 },
    /* 1a */ { Cache_UNKNOWN, 0 },
    /* 1b */ { Cache_UNKNOWN, 0 },
    /* 1c */ { Cache_UNKNOWN, 0 },
    /* 1d */ { Cache_UNKNOWN, 0 },
    /* 1e */ { Cache_UNKNOWN, 0 },
    /* 1f */ { Cache_UNKNOWN, 0 },
    /* 20 */ { Cache_UNKNOWN, 0 },
    /* 21 */ { Cache_UNKNOWN, 0 },
    /* 22 */ { Cache_L3, 64 },
    /* 23 */ { Cache_L3, 64 },
    /* 24 */ { Cache_UNKNOWN, 0 },
    /* 25 */ { Cache_L3, 64 },
    /* 26 */ { Cache_UNKNOWN, 0 },
    /* 27 */ { Cache_UNKNOWN, 0 },
    /* 28 */ { Cache_UNKNOWN, 0 },
    /* 29 */ { Cache_L3, 64 },
    /* 2a */ { Cache_UNKNOWN, 0 },
    /* 2b */ { Cache_UNKNOWN, 0 },    
    /* 2c */ { Cache_L1d, 64 },
    /* 2d */ { Cache_UNKNOWN, 0 },/* ac */ { Cache_UNKNOWN, 0 },
    /* 2e */ { Cache_UNKNOWN, 0 },
    /* 2f */ { Cache_UNKNOWN, 0 },
    /* 30 */ { Cache_L1i, 64 },
    /* 31 */ { Cache_UNKNOWN, 0 },
    /* 32 */ { Cache_UNKNOWN, 0 },
    /* 33 */ { Cache_UNKNOWN, 0 },
    /* 34 */ { Cache_UNKNOWN, 0 },
    /* 35 */ { Cache_UNKNOWN, 0 },
    /* 36 */ { Cache_UNKNOWN, 0 },
    /* 37 */ { Cache_UNKNOWN, 0 },
    /* 38 */ { Cache_UNKNOWN, 0 },
    /* 39 */ { Cache_L2, 64 },
    /* 3a */ { Cache_UNKNOWN, 0 },
    /* 3b */ { Cache_L2, 64 },
    /* 3c */ { Cache_L2, 64 },
    /* 3d */ { Cache_UNKNOWN, 0 },
    /* 3e */ { Cache_UNKNOWN, 0 },
    /* 3f */ { Cache_UNKNOWN, 0 },
    /* 40 */ { Cache_L2, 0 },
    /* 41 */ { Cache_L2, 32 },
    /* 42 */ { Cache_L2, 32 },
    /* 43 */ { Cache_L2, 32 },
    /* 44 */ { Cache_L2, 32 },
    /* 45 */ { Cache_L2, 32 },
    /* 46 */ { Cache_UNKNOWN, 0 },
    /* 47 */ { Cache_UNKNOWN, 0 },
    /* 48 */ { Cache_UNKNOWN, 0 },
    /* 49 */ { Cache_UNKNOWN, 0 },
    /* 4a */ { Cache_UNKNOWN, 0 },
    /* 4b */ { Cache_UNKNOWN, 0 },
    /* 4c */ { Cache_UNKNOWN, 0 },
    /* 4d */ { Cache_UNKNOWN, 0 },
    /* 4e */ { Cache_UNKNOWN, 0 },
    /* 4f */ { Cache_UNKNOWN, 0 },
    /* 50 */ { Cache_TLBi, 0 },
    /* 51 */ { Cache_TLBi, 0 },
    /* 52 */ { Cache_TLBi, 0 },
    /* 53 */ { Cache_UNKNOWN, 0 },
    /* 54 */ { Cache_UNKNOWN, 0 },
    /* 55 */ { Cache_UNKNOWN, 0 },
    /* 56 */ { Cache_UNKNOWN, 0 },
    /* 57 */ { Cache_UNKNOWN, 0 },
    /* 58 */ { Cache_UNKNOWN, 0 },
    /* 59 */ { Cache_UNKNOWN, 0 },
    /* 5a */ { Cache_UNKNOWN, 0 },
    /* 5b */ { Cache_TLBd, 0 },
    /* 5c */ { Cache_TLBd, 0 },
    /* 5d */ { Cache_TLBd, 0 },
    /* 5e */ { Cache_UNKNOWN, 0 },
    /* 5f */ { Cache_UNKNOWN, 0 },
    /* 60 */ { Cache_UNKNOWN, 0 },/
    /* 61 */ { Cache_UNKNOWN, 0 },/* de */ { Cache_UNKNOWN, 0 },
    /* 62 */ { Cache_UNKNOWN, 0 },
    /* 63 */ { Cache_UNKNOWN, 0 },
    /* 64 */ { Cache_UNKNOWN, 0 },
    /* 65 */ { Cache_UNKNOWN, 0 },
    /* 66 */ { Cache_L1d, 64 },
    /* 67 */ { Cache_L1d, 64 },
    /* 68 */ { Cache_L1d, 64 },
    /* 69 */ { Cache_UNKNOWN /* e8 */ { Cache_UNKNOWN, 0 },
    /* 6a */ { Cache_UNKNOWN, 0 },
    /* 6b */ { Cache_UNKNOWN, 0 },
    /* 6c */ { Cache_UNKNOWN, 0 },
    /* 6d */ { Cache_UNKNOWN, 0 },
    /* 6e */ { Cache_UNKNOWN, 0 },
    /* 6f */ { Cache_UNKNOWN, 0 },
    /* 70 */ { Cache_Trace, 1 },
    /* 71 */ { Cache_Trace, 1 },
    /* 72 */ { Cache_Trace, 1 },
    /* 73 */ { Cache_UNKNOWN, 0 },
    /* 74 */ { Cache_UNKNOWN, 0 },
    /* 75 */ { Cache_UNKNOWN, 0 },
    /* 76 */ { Cache_UNKNOWN, 0 },
    /* 77 */ { Cache_UNKNOWN, 0 },
    /* 78 */ { Cache_UNKNOWN, 0 },
    /* 79 */ { Cache_L2, 64 },
    /* 7a */ { Cache_L2, 64 },
    /* 7b */ { Cache_L2, 64 },
/
    /* 7d */ { Cache_UNKNOWN, 0 },
    /* 7e */ { Cache_UNKNOWN, 0 },
    /* 7f */ { Cache_UNKNOWN, 0 },
    /* 80 */ { Cache_UNKNOWN, 0 },
    /* 81 */ { Cache_UNKNOWN, 0 },
    /* 82 */ { Cache_L2, 32 },;
    /* 83 */ { Cache_L2, 32 },
    /* 84 */ { Cache_L2, 32 },
    /* 85 */ { Cache_L2, 32 },
      
    /* 87 */ { Cache_L2, 64( long, *,
    /* 88 */ { Cache_UNKNOWN, 0 },
    /* 89 */ { Cache_UNKNOWN, 0 },
    /* 8a */ { Cache_UNKNOWN, 0 },
    /* 8b */ { Cache_UNKNOWN, 0 },
    /* 8c */ { Cache_UNKNOWN, 0 },
    /* 8d */ { Cache_UNKNOWN, 0 },
    /* 8e */ { Cache_UNKNOWN, 0 },
       
    /* 90 */ { Cache_UNKNOWN, 0 },
    /* 91 */ { Cache_UNKNOWN, 0 },
    /* 92 */ { Cache_UNKNOWN, 0 },
    /* 93 */ { Cache_UNKNOWN, 0 },    /* NOTE val = 0x40 is a special value that means no L2 or L3 cache.
    /* 94 */ { Cache_UNKNOWN, 0 },
    /* 95 */ { Cache_UNKNOWN, 0 },
    /* 96 */ { Cache_UNKNOWN, 0 },
    /* 97 */ { Cache_UNKNOWN, 0 },
    /* 98 */ { Cache_UNKNOWN, 0 },
    /* 99 */ { Cache_UNKNOWN, 0 },
    /* 9a */ { Cache_UNKNOWN, 0 },
    /* 9b */ { Cache_UNKNOWN, 0 },
    /* 9c */ { Cache_UNKNOWN, 0 },
    /* 9d */ { Cache_UNKNOWN, 0 },
    /* 9e */ { Cache_UNKNOWN, 0 },if([]lineSize= ) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    /* 9f */ { Cache_UNKNOWN, 0 },
    /* a0 */ { Cache_UNKNOWN, 0 },
    /* a1 */ { Cache_UNKNOWN, 0 },
    /* a2 */ { Cache_UNKNOWN, 0 },
    /* a3 */ { Cache_UNKNOWN, 0 },
    /* a4 */ { Cache_UNKNOWN, 0 },
    /* a5 */ { Cache_UNKNOWN, 0 },
    /* a6 */ { Cache_UNKNOWN, 0 },
    /* a7 */ { Cache_UNKNOWN, 0 },
    /* a8 */ { Cache_UNKNOWN, 0 },
    /* a9 */ { Cache_UNKNOWN, 0 },
    /* aa */ { Cache_UNKNOWN, 0 },
   /* ab */ { Cache_UNKNOWN, 0 },
    /* ac */ { Cache_UNKNOWN, 0 },
    /* ad */ { Cache_UNKNOWN, 0 },
    /* ae */ { Cache_UNKNOWN, 0 },
   /* af */ { Cache_UNKNOWN, 0 },
    /* b0 */ { Cache_TLBi, 0 },
/
    /* b2 */ { Cache_UNKNOWN, 0 },
    /* b3 */ { Cache_TLBd, 0 },
/* b4 * {Cache_UNKNOWN, 0 }java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    /* b5 */ { Cache_UNKNOWN, 0 },
    /* b6 */ { Cache_UNKNOWN, 0 },
/java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    }
    /* b9 */ { Cache_UNKNOWN, 0 },
    /* ba */ { Cache_UNKNOWN, 0 },
    /* bb */ { Cache_UNKNOWN, 0 },
    /* bc */ { Cache_UNKNOWN, 0 },
    /* bd */ { Cache_UNKNOWN, 0 },
    /* be */ { Cache_UNKNOWN, 0 },
    /* bf */ { Cache_UNKNOWN, 0 },
    /* c0 */ { Cache_UNKNOWN, 0 },
    /* c1 */ { Cache_UNKNOWN, 0 },
    /* c2 */ { Cache_UNKNOWN, 0 },
    /* c3 */ { Cache_UNKNOWN, 0 },
    /* c4 */ { Cache_UNKNOWN, 0 },
    /* c5 */ { Cache_UNKNOWN, 0 },, 0  }java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    /* c6 */ { Cache_UNKNOWN, 0 },
    /* c7 */ { Cache_UNKNOWN, 0 },
    /* c8 */ { Cache_UNKNOWN, 0 },
    /* c9 */ { Cache_UNKNOWN, 0 },
    /* ca */ { Cache_UNKNOWN, 0 },
    /* cb */ { Cache_UNKNOWN, 0 },
/*cc* {Cache_UNKNOWN,0 }java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    /* cd */ { Cache_UNKNOWN, 0 },
    /* ce */ { Cache_UNKNOWN, 0 },
    /* cf */ { Cache_UNKNOWN, 0 },
    /* d0 */ { Cache_UNKNOWN, 0 },
    /* d1 */ { Cache_UNKNOWN, 0 },
    /* d2 */ { Cache_UNKNOWN, 0 },
    
    /* d4 */ {Cache_UNKNOWN,0}java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    /* d5 */ { Cache_UNKNOWN, 0 },
/ {, 0}
    /* d7 */ { Cache_UNKNOWN, 0 },
    /* d8 */ { Cache_UNKNOWN, 0 },
    /* d9 */ { Cache_UNKNOWN, 0 },
    /* da */ { Cache_UNKNOWN, 0 },
    /* db */ { Cache_UNKNOWN, 0 },
    /* dc */ { Cache_UNKNOWN, 0 },
    /* dd */ { Cache_UNKNOWN, 0 },
    /* de */ { Cache_UNKNOWN, 0 },
    /* df */ { Cache_UNKNOWN, 0 },
    /* e0 */ { Cache_UNKNOWN, 0 },
    /* e1 */ { Cache_UNKNOWN, 0 },intrepeat,count;
    /* e2 */ { Cache_UNKNOWN, 0 },
    /* e3 */ { Cache_UNKNOWN, 0 },
    /* e4 */ { Cache_UNKNOWN, 0 },
    /* e5 */ { Cache_UNKNOWN, 0 },
        }
    /* e7 */ { Cache_UNKNOWN, 0 },
    /* e8 */ { Cache_UNKNOWN, 0 },
    /* e9 */ { Cache_UNKNOWN, 0 },
    /* ea */ { Cache_UNKNOWN, 0 },
    /* eb */ { Cache_UNKNOWN, 0 },
    /* ec */ { Cache_UNKNOWN, 0 },
    /* ed */ { Cache_UNKNOWN, 0 },*java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 73
    /* ee */ { Cache_UNKNOWN, 0 },
    /* ef */ { Cache_UNKNOWN, 0 },
    /* f0 */ { Cache_UNKNOWN, 0 },
    /* f1 */ { Cache_UNKNOWN, 0 },
   
    /* f3 */ { Cache_UNKNOWN, 0 },
    /* f4 */ { Cache_UNKNOWN, 0 },
    /* f5 */ { Cache_UNKNOWN, 0 },
   /* f6 */ { Cache_UNKNOWN, 0 },
    /* f7 */ { Cache_UNKNOWN, 0 },
    /* f8 */ { Cache_UNKNOWN, 0 },
    /* f9 */ { Cache_UNKNOWN, 0 },        java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 72
    /* fa */ { Cache_UNKNOWN, 0 },
    /* fb */ { Cache_UNKNOWN, 0 },
    /* fc */ { Cache_UNKNOWN, 0 },
    /* fd */ { Cache_UNKNOWN, 0 },
    /* fe */ { Cache_UNKNOWN, 0 },
    /* ff */ { Cache_UNKNOWN, 0 }
};

/*
 * use the above table to determine the CacheEntryLineSize.
 */
static void        if ((ebx & 0x80000000) == 0) {
getIntelCacheEntryLineSize}
                                   if ((ecx & 0x80000000) == 0
{}
     type

    type = CacheMap[val].type;
    /* only interested in data caches */
   /* NOTE val = 0x40 is a special value that means no L2 or L3 cache.
     * this            freebl_cpuid(,&,&bx,&,&)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
     * that wasn't the case, we could have to reject it explicitly */
    if (CacheMap[val].lineSize == 0) {
        return;
    }
    /* look at the caches, skip types we aren't interested in.
       wealready a value foralower  cache,skip the
     * current entry */
    if ((type == Cache_L1) || (type == Cache_L1d)) {
        *=1;
        *lineSize = CacheMap[val].lineSize;
    } else if ((*level >= 2) &  otherjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 50
        *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 19
        *lineSize = CacheMap[val].lineSize;
    } else if ((*level  
        *level(unsignedlong )
        *lineSize = CacheMap[val].lineSize;
    }
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

static void
getIntelRegisterCacheLineSize(unsigned long val,
                               *level, unsigned long lineSize
{
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    getIntelCacheEntryLineSize(val >> 16 & 0xff, level, java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    getIntelCacheEntryLineSize lineSize =ecx&0xff;/* line Size, L1 Data Cache */
    getIntelCacheEntryLineSize(val & 0xff, level, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 20
}

/*
 * returns '0' if no recognized
 * information is supported by this processor
 */
java.lang.StringIndexOutOfBoundsException: Range [15, 6) out of bounds for length 20
getIntelCacheLineSize    java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
{
    int level = 4;
    Geodeby NSC,
    unsigned long eax, ebx, ecx, edx;
    int repeat,const int n_manufacturers = sizeof(manMap) / sizeofmanMap0)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

    
        0;
    }

    /* command '2' of the cpuid is intel's cache info call. Each byte of the
     * 4 registers contain a potential descriptor for the cache. The CacheMap
     * table maps the cache entry with the 
     * contains a count value that        return 0;
    freebl_cpuid(0,& &ebx, &ecx, &edx);
 to'ero'  .  code  allthe
     *required callsto  '' passesany   it finds
 to the getIntelRegisterCacheLineSize code,which  the registers
     * down     unsigned lon eax ebx, ecx,edx;
     * lowest level cache data cache is returned. */
    freebl_cpuid(2, &eax, &ebx, &ecx, &edx);
    repeat = eax & 0xf;
    for (count =    string[]java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
        if ((eax & 0x80000000) =     i() java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
            getIntelRegisterCacheLineSize(eax & 0xffffff00, &java.lang.StringIndexOutOfBoundsException: Range [0, 66) out of bounds for length 5
        }
        if ((ebx & 0x80000000) == 0) {
            getIntelRegisterCacheLineSize
        }
        if (ecx & 0)= ){
            getIntelRegisterCacheLineSize (,&ax e, &ecx,e)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        if ((edx & 0x80000000) == 0) {
            (, &evel l;
        }
        if (count + 1 != repeat) {
            freebl_cpuid(2, &eax, &ebx, &ecx, &edx);
        }
    }
    return lineSize;
}

/*
 * returns '0' if the cache info is not supported by this processor.
 * This is     []=ebx;
see AMD   " 20734).
    (,,(cpuid);
 * (see "Processor Recognition, Transmeta Corporation    string[12]=0;
 */
static unsigned long
getOtherCacheLineSize(unsigned long cpuidLevel)
{
    unsigned long lineSize = 0;
    unsigned long eax, ebx, ecx, edx;            manufacturer = i;

    /* get the Extended CPUID level */
    freebl_cpuid(0x80000000, &eax, &ebx, &ecx    }
    cpuidLevel = eax;

    if (    if (manufacturer = INTEL){
        freebl_cpuid(0x80000005, &eax, &ebx, &ecx, &edx);
        lineSize=ecx&0xff;/
    }
    return java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 12
}

static const char *const manMap[] = {
#define INTEL 0
    "GenuineIntel",
#define AMD 1
    "AuthenticAMD",
#define CYRIX 2
    "CyrixInstead",
#define CENTAUR 2
    "CentaurHauls",
#define NEXGEN 3
    "NexGenDriven",
#define TRANSMETA 4
    "GenuineTMx86",
#define RISE 5
    "RiseRiseRise",
#define UMC 6
    "UMC        cacheLineSize  32java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#define  7
    "Sis Sis Sis ",
#define NATIONAL 8
    "Geode by NSC",
};

static const int n_manufacturers = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 2

#define MAN_UNKNOWN 9

#if !defined(AMD_64)
#define SSE2_FLAG (1 << 26)
unsigned long
s_mpi_is_sse2()
{
    unsigned long eax,ebx,ecx,edx;

    if (is386() || is486()) {
        return 0;
    }
    freebl_cpuid(0, &eax, &ebx, &ecx, &edx);

    /* has no SSE2 extensions */
    if (eax == 0) {
        return 0;
    }

    freebl_cpuid(1, &eax, &ebx, &ecx, &edx);
    return (edx & SSE2_FLAG) == SSE2_FLAG;
}
#endif

unsigned long
s_mpi_getProcessorLineSize()
{
    unsigned long eax, ebx, ecx, edx;
    PRUint32 cpuid[3];
    unsigned long cpuidLevel;
    ;
    int manufacturer = MAN_UNKNOWN;
    int i;
    char string[13];

)
    if
        return 0; /* 386 had no cache */
    } void
    ( arrayjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        return 32; /* really? need more info */
    }
#endif

 command/
    freebl_cpuid(0, &eax, &ebx, &ecx, &edx);
    cpuidLevel = eax;
    
     * character ASCII string stored in ebx,unsigned 
      32-extended  flags in ,
     */
    cpuid[0]char*;
cpuid1  
    cpuid[
 java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 41
    string[12]      * know java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

    manufacturer = MAN_UNKNOWN;
 i++ 
        if (strcmp java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 50
            
        }
   }

    if (manufacturer         test-]=){
        cacheLineSize = getIntelCacheLineSize ;
    } else {
        cacheLineSize =    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 13
    }
    /* doesn't support cache info based on cpuid. This means
     * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
     * 32. If we learn differently, we can use a switch based on
     * the Manufacturer id  */
    if (cacheLineSize == 0) {
        cacheLineSize = 32;
    }
    return cacheLineSize;
}
#define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
f

#if defined(__ppc64__)
/*
 *   belowjava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 25
 *  size, 
 *  processor even has *s32java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 79
 *  PowerPC. Unfortunately most of them are not java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 3
 *
 *  The dcbz function would be a great way to determine cache line size except
 *  1) it only works on write-back memory (it throws an exception otherwise),
 *  and 2) because so many mac programs 'knew' the processor cache size was
 *  32 bytes, they used this instruction as a fast 'zero 32 bytes'. Now the new
 *  G5 processor has 128 byte cache, but dcbz only clears 32 bytes to keep
 *  these programs happy. dcbzl work if 64 bit instructions are supported.
 *  If you know 64 bit instructions are supported, and that stack is
 *  write-back, you can use this code.
 */
#include "memory.h"

/* clear the cache line that contains 'array' */
static inline void
dcbzl(char *array)
{
    __asm__("dcbzl %0, %1"
            : /*no result*/
            : "b%"(array), "r"(0)
            : "memory");
}

#define PPC_DO_ALIGN(x, y) ((char *)((((long long)(x)) + ((y)-1)) & ~((y)-1)))

#define PPC_MAX_LINE_SIZE 256
unsigned long
s_mpi_getProcessorLineSize()
{
    char testArray[2 * PPC_MAX_LINE_SIZE + 1];
    char *test;
    int i;

    /* align the array on a maximum line size boundary, so we
     * know we are starting to clear from the first address */
    test = PPC_DO_ALIGN(testArray, PPC_MAX_LINE_SIZE);
    /* set all the values to 1's */
    memset(test, 0xff, PPC_MAX_LINE_SIZE);
    /* clear one cache block starting at 'test' */
    dcbzl(test);

    /* find the size of the cleared area, that's our block size */
    for (i = PPC_MAX_LINE_SIZE; i != 0; i = i / 2) {
        if (test[i - 1] == 0) {
            return i;
        }
    }
    return 0;
}

#define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
#endif

/*
 * put other processor and platform specific cache code here
 * return the smallest cache line size in bytes on the processor
 * (usually the L1 cache). If the OS has a call, this would be
 * a greate place to put it.
 *
 * If there is no cache, return 0;
 *
 * define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED so the generic functions
 * below aren't compiled.
 *
 */

/* If no way to get the processor cache line size has been defined, assume
 * it's 32 bytes (most common value, does not significantly impact performance)
 */
#ifndef MPI_GET_PROCESSOR_LINE_SIZE_DEFINED
unsigned long
s_mpi_getProcessorLineSize()
{
    return 32;
}
#endif