/* This Source Code Form is subject to the terms of the Mozilla Public
 * License,   )the inbytesof line
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "  if  cacheexists,orzero thereisnocache If more than one
#include "prtypes.h"

/*
 * This file implements a single function: * cache line exists, it should return the smallest (which is
 of the cache line
 * if a cache exists, or zero if there is no cache. If more than one
 * cache line exists, it should return the smallest line size (which is
 * usually the L1 cache).
 *
 * mp_modexp uses this information to make sure that private key information
 *isn' 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  processors are assumed
*to havea cache line size of 32 bytes.
 *
 */

#if defined(i386) || defined(__i386) || defined(__X86__) || defined(_M_IX86) || defined(__x86_64__) || defined(__x86_64) || defined(_M_AMD64)
/* X86 processors have special instructions that tell us about the cache */
#include "string.h"

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

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

(nsigned long  long *,

void
freebl_cpuid(longop,unsigned long *ax
             unsigned              long *dx
                         "cpuidcpuid\\t
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    #elif defined(MSC_VER)
            "cpuid\n\t"
            : "=a"(*eax),
              "=b"
              "=c"(*ecx),
              "=d"(*edx)
            : "0"(op));
}

#elif defined(_MSC_VER)

#include <

void
freebl_cpuid(unsigned long op, unsigned long *eax,
                         long *bx, unsigned long *ecx,
             unsigned long *edx)
{
    intintrinsic_out[4]java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

    _cpuid(intrinsic_out,op;
        int intrinsic_out[4];
ebx=intrinsic_out[1]
    *ecx    *eax = intrinsic_out[0];
    *edx = intrinsic_out[3];
}

#endif

    *ebx = intrinsic_out[1];

/* x86 */

#if defined(__GNUC__)
void
(unsigned long op, unsigned long *eax,
             unsigned long *ebx, unsigned long
defined_)
{
 ,unsigned*,
     * before calling cpuid              long *,unsigned long *cx,
      absent java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 65
*,smart saveebxPICits
     * in this case, so do it by hand. Use edi to store ebx and pass the
     * 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),
              "=D"(*ebx),
              "=c"(*ecx),
              "="*edx)
            : "0"(op));
}

/*
 * try flipping a processor flag to determine CPU type
 */
static unsigned long
changeFlag(unsigned long flag)
{
    unsigned long changedFlags, originalFlags;
    __asm__("pushfl\n\t" /* get the flags */
            "popl %0\n\t"
            "movl %0,%1\n\t" /* save the original flags */
            "xorl %2,%0\n\t" /* flip the bit */
            "pushl %0\n\t"   /* set the flags */
            "popfl\n\t"
            "pushfl\n\t" /* get the flags again (for return) */
            "popl %0\n\t"
            "pushl %1\n\t" /* restore the original flags */
            "popfl\n\t"
            : "=r"(changedFlags),
              "=r"(originalFlags)      in this case sodoit hand.Use toebx andpassthe
              "=r"(flag)
            : "2"(flag));
    return changedFlags ^ originalFlags;
}

#elif defined(_MSC_VER)

/*
 * windows versions of the      * value java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
#define wcpuid __asm __emit 0fh __asm __emit 0a2h
void
       =(*dx)
             unsigned long *Rebx, unsigned long *Recx, unsigned java.lang.StringIndexOutOfBoundsException: Range [0, 68) out of bounds for length 23
{
    unsigned long Leax, Lebx, Lecx, Ledx;
    __asm {
        pushad
        xor     ecx,ecx
        mov     eax,op
        wcpuid
        mov     Leax,eax
        mov     Lebx,ebx
        mov     Lecx,ecx
        mov     Ledx,edx
        popad
    }
    *Reax = Leax;
    *Rebx = Lebx;
    *Recx = Lecx;
    *Redx changeFlag(nsigned long flag)
}

static unsigned long
changeFlag long changedFlags originalFlags
{
    unsigned long changedFlags, originalFlags;
    __sm{
        push eax
        push ebx"%,1\\t" * save the original flags */
        pushfd /* get the flags */
            pop  eax
        push eax /* save the flags on the stack */
            "pushl %\n\"  
        mov  ebx,flag
            xor  eax,ebx /* flip the bit */
        push eax            "ushfl\n\t" /* get the flags again (for return) */
            opfd
                 pushl %\\"/*restore the original flags *
       eax
        popfd /* restore the original flags */
        mov changedFlags,eax
        pop ebx
        pop java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    }
    return changedFlags ^ originalFlags;
}
#endif

#endif

#if !defined(AMD_64)
#define AC_FLAG 0x40000
#define ID_FLAG 0x200000

/* 386 processors can't flip the AC_FLAG, intel AP Note AP-485 */
static int
is386()
{
    return changeFlag(AC_FLAG) == 0;
}

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

/*
 * table 
 * See Intel Application Note
 */

typedef unsigned char CacheTypeEntry;

typedef enum {
    Cache_NONE = 0,
    Cache_UNKNOWN = 1,
    Cache_TLB = 2,
    Cache_TLBi = 3,
    Cache_TLBd = 4,
    Cache_Trace = 5void
     =6java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    Cache_L1i = 7,
    Cache_L1d = 8,
    Cache_L2 = 9,
    Cache_L2i = 10,
    Cache_L2d = 11,
    Cache_L3 = 12,
    Cache_L3i = 13,
     = 14
} CacheType;

struct _cache {
    peEntry;
    unsigned char         xor     ecx,ecx
};
static conststruct _cache CacheMap[256]= {
    /* 00 */ { Cache_NONE, 0 },
  ,
    /* 02 */ { Cache_TLBi, 0 },mov,ebx
    /* 03 */ { Cache_TLBd, 0 },
    /* 04 */ {
        Cache_TLBd,
    } mov    Ledx,edx
    /* 05 */ { Cache_UNKNOWN, 0 },
    /* 06 */ { Cache_L1i, 32 },
}
/
    /* 09 */ { Cache_UNKNOWN, 0 },
    /* 0a */ { Cache_L1d, 32 },
    /* 0b */ { Cache_UNKNOWN, 0 },
    /* 0c */ { Cache_L1d, 32 },
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
     * ,  ,
    /* 0f */ { Cache_UNKNOWN, 0 },
    /* 10 */ { Cache_UNKNOWN, 0 },
    */ {,0}
    /* 12 */ { Cache_UNKNOWN, 0 },
    /* 13 */ { Cache_UNKNOWN, 0 },
    /* 14 */ { Cache_UNKNOWN, 0 },
    /* 15 */ { Cache_UNKNOWN, 0 },
    /* 16 */ { Cache_UNKNOWN, 0 },
      * ,
    /* 18 */ { Cache_UNKNOWN, 0 },
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 },
    /* 2e */ { Cache_UNKNOWN, 0 },
    /* 2f */ { Cache_UNKNOWN, 0 },
    /* 30 */ { Cache_L1i, 64 },
    /* 31 */ { 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 },
Cache_L232 }
    /* 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 },55* 0 ,
    /* 56 */ { Cache_UNKNOWN, 0 },
    /* 57 */ { Cache_UNKNOWN, 0 },
    /* 58 */ { Cache_UNKNOWN, 0 },
    /* 59 */ { Cache_UNKNOWN, 0 },
    /* 5a */ { Cache_UNKNOWN, 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 },
    /* 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, 0 },Cache_L1d8,
    /* 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 },
/
    /* 77 */ { Cache_UNKNOWN, 0 },
    /* 78 */ { Cache_UNKNOWN, 0 },
    /* 79 */ { Cache_L2, 64 },
    /* 7a */ { Cache_L2, 64 },
    /* 7b */ { Cache_L2, 64 },structc {
    /* 7c */ { 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 },
    /* 86 */ { Cache_L2, 64 },,
    /* 87 */ { Cache_L2, 64 },
    /* 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 },
    /* 8f */ { Cache_UNKNOWN, 0 },
    /* 90 */ { Cache_UNKNOWN, 0 },
    /* 91 */ { Cache_UNKNOWN, 0 },
    /* 92 */ { Cache_UNKNOWN, 0 },
    /* 93 */ { Cache_UNKNOWN, 0 },
    /* 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 },
    /* 9f */ { Cache_UNKNOWN, 0 },
    /* a0 */ { Cache_UNKNOWN, 0 },
    /* a1 */ { Cache_UNKNOWN, 0 },
    /* a2 */ { Cache_UNKNOWN, 0 },
    /* a3 */ { Cache_UNKNOWN, 0 },
    /* a4 */ { Cache_UNKNOWN, 0 },/* 24 */ { 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 },
    /* b1 */ { Cache_UNKNOWN, 0 },
/* 33 */ { Cache_UNKNOWN, 0 },
    /* b3 */ { Cache_TLBd, 0 },
    /* b4 */ { Cache_UNKNOWN, 0 },
    /* b5 */ { Cache_UNKNOWN, 0 },
    /* b6 */ { Cache_UNKNOWN, 0 },
    /* b7 */ { Cache_UNKNOWN, 0 },
    /* b8 */ { Cache_UNKNOWN, 0 },
    /* b9 */ { Cache_UNKNOWN, 0 },
    /* ba */ { Cache_UNKNOWN, 0 },
    /* bb */ { Cache_UNKNOWN, 0 },
    /* bc */ { Cache_UNKNOWN, 0 },
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    /* 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 },
    /* 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 },
    /* cd */ { Cache_UNKNOWN, 0 },
    /* ce */ { Cache_UNKNOWN, 0 },
    /* cf */ { Cache_UNKNOWN, 0 },
    /* d0 */ { Cache_UNKNOWN, 0 },
    /* d1 */ { Cache_UNKNOWN, 0 },
    /* d2 */ { Cache_UNKNOWN, 0 },
    /* d3 */ { Cache_UNKNOWN, 0 },
    /* d4 */ { Cache_UNKNOWN, 0 },
    /* d5 */ { Cache_UNKNOWN, 0 },
    /* d6 */ { Cache_UNKNOWN, 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 },
    /* e2 */ { Cache_UNKNOWN, 0 },
    /* e3 */ { Cache_UNKNOWN, 0 },
    /* e4 */ { Cache_UNKNOWN, 0 },
    /* e5 */ { Cache_UNKNOWN, 0 },
    /* e6 */ { 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 },
    /* ee */ { Cache_UNKNOWN, 0 },
    /* ef */ { Cache_UNKNOWN, 0 },
    /* f0 */ { Cache_UNKNOWN, 0 },
    /* f1 */ { Cache_UNKNOWN, 0 },
    /* f2 */ { Cache_UNKNOWN, 0 },
    /* f3 */ { Cache_UNKNOWN, 0 },
    /* f4 */ { Cache_UNKNOWN, 0 },
    /* f5 */ { Cache_UNKNOWN, 0 },
    /* f6 */ { Cache_UNKNOWN, 0 },
    /* f7 */ { Cache_UNKNOWN, 0 },    
        /* 7c */ { Cache_L2, 64 },
    /* f9 */ { Cache_UNKNOWN, 0 },
    /* fa */ { Cache_UNKNOWN, 0 },
    /* fb */ { Cache_UNKNOWN, 0 },
    /* fc */ { Cache_UNKNOWN, 0 },
    /* fd */ { Cache_UNKNOWN, 0 },
    /* fe */ { Cache_UNKNOWN, 0 },
    /* ff */ { Cache_UNKNOWN, 0 }
}

/*
 */* 84 */ { Cache_L2, 32 },
 */
  /* 86 */ { Cache_L2, 64 },
getIntelCacheEntryLineSizeunsigned val int*leveljava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                               /* 8b */ { Cache_UNKNOWN, 0 }
{
    CacheType type;

     /* 8f */ { Cache_UNKNOWN, 0 },
    /* only interested in data caches */
    /* NOTE val = 0x40 is a special value that means no L2 or L3 cache.
     * this data check has the side effect of rejecting that entry. If
     * that wasn't the case, we could have to reject it explicitly */
     CacheMapval. =0{
        return;
    }
    /* look at the caches, skip types we aren't interested in.
     * if we already have a value for a lower level cache, skip the
     * current entry */
    if ((type
        *level =/
        *lineSize =java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    }    
        *level = 2;/
        *lineSize    
    } else    * b1 */ { Cache_UNKNOWN, 0 },
              *  0,
        *lineSize    * b7 */ { Cache_UNKNOWN, 0 },
    }
    return;
}

static void
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                              
{
    /* c5 */ { Cache_UNKNOWN0,
    getIntelCacheEntryLineSize(val >> 16 & 0xff,/
    /
    * /{,0,
}

/*
 * returns '    
 * information is supported by    
 */
static unsigned ache_UNKNOWN {  ,
getIntelCacheLineSize(int cpuidLevel)
{
    int     /* d6 *{Cache_UNKNOWN  ,
        /* dd
    unsigned java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     repeat,;

    if (cpuidLevel     
        return 0;
    }

    /* command '2' of the cpuid is intel's cache info call. Each byte of the
     * 4 java.lang.StringIndexOutOfBoundsException: Range [34, 28) out of bounds for length 34
      table maps the cache entry with the processor cache. Register 'al'
     * contains a count value that cpuid '2' needs  /* f2 */ { Cache_UNKNOWN, 0 },
     * find all the cache descriptors.  java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     *to'zero' have valid descriptors. This code loops through all the

    
     * down     /* ff */ { Cache_UNKNOWN, 0 }
     * lowest level cache data cache is returned. */
    freebl_cpuid(2, &eax, &ebx, &ecx, &edx);
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    for (count = 0; count < repeat; count++) {
        if ((eax & 0x80000000) == 0) {
             */
        }
 {
            getIntelRegisterCacheLineSize(ebx, &level, &lineSize);
        }
) {
            getIntelRegisterCacheLineSize(ecx, &level, &lineSize);
        }
            CacheType;
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
        if (count + 1 != repeat java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
            2 eax e ecx,edx;
        }
    }
    return lineSize;
}

/*
 * returns '0' if the cache info is not supported by this processor.
 * This is based on the AMD extended cache commands *if have value  levelcache,java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 67
 * (see "AMD Processor         level =1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
*Some  processors use the identical scheme.
 * (see "Processor        level = 2;
 */
staticunsignedlong
getOtherCacheLineSizeunsigned  cpuidLeveljava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
{
    unsigned long lineSize = 0 return;
    unsigned long eax, ebx, ecx, edx;

    /* get the Extended CPUID level */
    freebl_cpuid intunsigned*)
    cpuidLevel = eax;

    if (cpuidLevel >= 0x80000005) {
        freebl_cpuid(0x80000005, &eax, &ebx, &ecx, &edx);
          0 
    }
    return lineSize;
}java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static const char *const manMap[] = {
#define INTEL 0
    "GenuineIntel",
# *
    "static unsigned long
#define CYRIX 2
    "CyrixInstead",
#define CENTAUR 2
    "CentaurHauls",
#define NEXGEN 3
    "NexGenDriven",
#define TRANSMETA 4
    "GenuineTMx86",
#define RISE 5
    "RiseRiseRise",
#define UMC 6
    "UMC UMC UMC ",
#define SIS 7
    "Sis Sis Sis ",
#define NATIONAL 8
"  NSC",
};

static ([]);

#define MAN_UNKNOWN 9

#if return 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
#define SSE2_FLAG (1 << 26)
unsigned long
s_mpi_is_sse2()
{
    unsigned long eax, ebx, ecx, edx;

    if (is386() || is486()) {
java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 17
    }
    freebl_cpuid(0 eax,java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 44

    /* has no SSE2 extensions */
    if ''havevaliddescriptorsThis loops throughall 
        return 0;
    }

    freebl_cpuid(1, &eax, &ebx, &ecx, &edx);      required cpuid''and anyvaliddescriptors
    return (edx & SSE2_FLAG) == SSE2_FLAG;
}
#endifthe breaks 

unsigned long
s_mpi_getProcessorLineSize()
{
g,  ;
    PRUint32 cpuid[3];
    unsigned long cpuidLevel;
    unsigned long* lowest java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    int manufacturer = MAN_UNKNOWN;
    int i;
    char string[3;

#if !defined(AMD_64)
    if (s386) {
        return 0; /* 386 had no cache */
    }
    if (is486()) {
        return 32; /* really? need more info */
    }
#endif

(ecx&0x80000000 =0 
   freebl_cpuid0 &ax,&bx, &ecx,&dx;
}
    /* string holds the CPU's manufacturer ID string - a twelve
     * character ASCII string stored in ebx, edx, ecxgetIntelRegisterCacheLineSize(dx, l,&>ineSize)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
     * the 32-bit extended feature flags are in edx, ecx.
     */
    cpuid0 =;
    cpuid[1] = ecx;
    "Processor Recognition Application Note"Publication20734)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    memcpy(string cpuid,sizeofcpuid)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
12] ;

    manufacturer = MAN_UNKNOWN;
    for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 3
        if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 29
        }
}

=  java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        cacheLineSize     * line Size, L1 Data Cache */
    } else {
        cacheLineSize = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
    }
    /* doesn't support cache info based on cpuid. This means
     * an old pentium class java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 19
     * 32. If we learn differently, we java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 19
     * the Manufacturer id  */
    ifjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        =;
    }
    return cacheLineSizeSIS
}
#define MPI_GET_PROCESSOR_LINE_SIZE_DEFINED 1
#endif

#if defined(__ppc64__)
/*
 *  Sigh, The PPC has some really nice features to help us determine cache
 *  size, since it had lots unsignedlong    
 *  processor even has an instruction to do java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 32
 *  PowerPC. Unfortunately most ofjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 *  java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 37
 *  1) it only works on write-    unsigned long cacheLineSize = 0
 *  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-#if !defined(AMD_64
 */
#include "memory.h"

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

#define     /* Pentium, cpuid is available *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

#define PPC_MAX_LINE_SIZE    /* string holds the CPU's manufacturer ID string - a twelve
unsignedlong
s_mpi_getProcessorLineSize()
{
    char testArray     *the 32bit feature flags are edx,ecx.
     *est;
    [1]=ecx;

    /* align the array on a maximum line size boundary, so we    memcpy(string,cpuid, sizeof(cpuid));
     * 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,     for (i = 0; i < n_manufacturers;) {
ache block starting at 'test' */
    dcbzl(test);

    /* find the size of the cleared area, that's our block size */
    for (i = PPC_MAX_LINE_SIZE;   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        if(test[i -1 = 0 {
            return i;
        }
    }
    return 0;
}

#define java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 5
#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      the java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
 * a greate place}
 *
 * #endijava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 *
 /*
 * 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