feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Botan: Fix compilation with 64-bit MSVC.

Browse Source 
Change-Id: I9d5e7c1e39c9536a33f6eb0d8f3e1002a2ed0a96
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@nokia.com>
This commit is contained in:
Christian Kandeler
2012-06-27 09:32:18 +02:00
parent fcc9ba4b99
commit 68237b9fdf
2 changed files with 60 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

456
src/libs/3rdparty/botan/botan.cpp vendored
View File

@@ -2556,78 +2556,32 @@ inline word word_add(word x, word y, word* carry)
*/ */
inline word word8_add2(word x[8], const word y[8], word carry) inline word word8_add2(word x[8], const word y[8], word carry)
{ {
__asm { x[0] = word_add(x[0], y[0], &carry);
mov edx,[x] x[1] = word_add(x[1], y[1], &carry);
mov esi,[y] x[2] = word_add(x[2], y[2], &carry);
xor eax,eax x[3] = word_add(x[3], y[3], &carry);
sub eax,[carry] //force CF=1 iff *carry==1 x[4] = word_add(x[4], y[4], &carry);
mov eax,[esi] x[5] = word_add(x[5], y[5], &carry);
adc [edx],eax x[6] = word_add(x[6], y[6], &carry);
mov eax,[esi+4] x[7] = word_add(x[7], y[7], &carry);
adc [edx+4],eax return carry;
mov eax,[esi+8]
adc [edx+8],eax
mov eax,[esi+12]
adc [edx+12],eax
mov eax,[esi+16]
adc [edx+16],eax
mov eax,[esi+20]
adc [edx+20],eax
mov eax,[esi+24]
adc [edx+24],eax
mov eax,[esi+28]
adc [edx+28],eax
sbb eax,eax
neg eax
}
} }
/* /*
* Eight Word Block Addition, Three Argument * Eight Word Block Addition, Three Argument
*/ */
inline word word8_add3(word z[8], const word x[8], const word y[8], word carry) inline word word8_add3(word z[8], const word x[8],
const word y[8], word carry)
{ {
__asm { z[0] = word_add(x[0], y[0], &carry);
mov edi,[x] z[1] = word_add(x[1], y[1], &carry);
mov esi,[y] z[2] = word_add(x[2], y[2], &carry);
mov ebx,[z] z[3] = word_add(x[3], y[3], &carry);
xor eax,eax z[4] = word_add(x[4], y[4], &carry);
sub eax,[carry] //force CF=1 iff *carry==1 z[5] = word_add(x[5], y[5], &carry);
mov eax,[edi] z[6] = word_add(x[6], y[6], &carry);
adc eax,[esi] z[7] = word_add(x[7], y[7], &carry);
mov [ebx],eax return carry;
mov eax,[edi+4]
adc eax,[esi+4]
mov [ebx+4],eax
mov eax,[edi+8]
adc eax,[esi+8]
mov [ebx+8],eax
mov eax,[edi+12]
adc eax,[esi+12]
mov [ebx+12],eax
mov eax,[edi+16]
adc eax,[esi+16]
mov [ebx+16],eax
mov eax,[edi+20]
adc eax,[esi+20]
mov [ebx+20],eax
mov eax,[edi+24]
adc eax,[esi+24]
mov [ebx+24],eax
mov eax,[edi+28]
adc eax,[esi+28]
mov [ebx+28],eax
sbb eax,eax
neg eax
}
} }
/* /*
@@ -2647,38 +2601,15 @@ inline word word_sub(word x, word y, word* carry)
*/ */
inline word word8_sub2(word x[8], const word y[8], word carry) inline word word8_sub2(word x[8], const word y[8], word carry)
{ {
__asm { x[0] = word_sub(x[0], y[0], &carry);
mov edi,[x] x[1] = word_sub(x[1], y[1], &carry);
mov esi,[y] x[2] = word_sub(x[2], y[2], &carry);
xor eax,eax x[3] = word_sub(x[3], y[3], &carry);
sub eax,[carry] //force CF=1 iff *carry==1 x[4] = word_sub(x[4], y[4], &carry);
mov eax,[edi] x[5] = word_sub(x[5], y[5], &carry);
sbb eax,[esi] x[6] = word_sub(x[6], y[6], &carry);
mov [edi],eax x[7] = word_sub(x[7], y[7], &carry);
mov eax,[edi+4] return carry;
sbb eax,[esi+4]
mov [edi+4],eax
mov eax,[edi+8]
sbb eax,[esi+8]
mov [edi+8],eax
mov eax,[edi+12]
sbb eax,[esi+12]
mov [edi+12],eax
mov eax,[edi+16]
sbb eax,[esi+16]
mov [edi+16],eax
mov eax,[edi+20]
sbb eax,[esi+20]
mov [edi+20],eax
mov eax,[edi+24]
sbb eax,[esi+24]
mov [edi+24],eax
mov eax,[edi+28]
sbb eax,[esi+28]
mov [edi+28],eax
sbb eax,eax
neg eax
}
} }
/* /*
@@ -2697,46 +2628,21 @@ inline word word8_sub2_rev(word x[8], const word y[8], word carry)
return carry; return carry;
} }
/* /*
* Eight Word Block Subtraction, Three Argument * Eight Word Block Subtraction, Three Argument
*/ */
inline word word8_sub3(word z[8], const word x[8], inline word word8_sub3(word z[8], const word x[8],
const word y[8], word carry) const word y[8], word carry)
{ {
__asm { z[0] = word_sub(x[0], y[0], &carry);
mov edi,[x] z[1] = word_sub(x[1], y[1], &carry);
mov esi,[y] z[2] = word_sub(x[2], y[2], &carry);
xor eax,eax z[3] = word_sub(x[3], y[3], &carry);
sub eax,[carry] //force CF=1 iff *carry==1 z[4] = word_sub(x[4], y[4], &carry);
mov ebx,[z] z[5] = word_sub(x[5], y[5], &carry);
mov eax,[edi] z[6] = word_sub(x[6], y[6], &carry);
sbb eax,[esi] z[7] = word_sub(x[7], y[7], &carry);
mov [ebx],eax return carry;
mov eax,[edi+4]
sbb eax,[esi+4]
mov [ebx+4],eax
mov eax,[edi+8]
sbb eax,[esi+8]
mov [ebx+8],eax
mov eax,[edi+12]
sbb eax,[esi+12]
mov [ebx+12],eax
mov eax,[edi+16]
sbb eax,[esi+16]
mov [ebx+16],eax
mov eax,[edi+20]
sbb eax,[esi+20]
mov [ebx+20],eax
mov eax,[edi+24]
sbb eax,[esi+24]
mov [ebx+24],eax
mov eax,[edi+28]
sbb eax,[esi+28]
mov [ebx+28],eax
sbb eax,eax
neg eax
}
} }
/* /*
@@ -2744,272 +2650,31 @@ inline word word8_sub3(word z[8], const word x[8],
*/ */
inline word word8_linmul2(word x[8], word y, word carry) inline word word8_linmul2(word x[8], word y, word carry)
{ {
__asm { x[0] = word_madd2(x[0], y, &carry);
mov esi,[x] x[1] = word_madd2(x[1], y, &carry);
mov eax,[esi] //load a x[2] = word_madd2(x[2], y, &carry);
mul [y] //edx(hi):eax(lo)=a*b x[3] = word_madd2(x[3], y, &carry);
add eax,[carry] //sum lo carry x[4] = word_madd2(x[4], y, &carry);
adc edx,0 //sum hi carry x[5] = word_madd2(x[5], y, &carry);
mov ecx,edx //store carry x[6] = word_madd2(x[6], y, &carry);
mov [esi],eax //load a x[7] = word_madd2(x[7], y, &carry);
return carry;
mov eax,[esi+4] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+4],eax //load a
mov eax,[esi+8] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+8],eax //load a
mov eax,[esi+12] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+12],eax //load a
mov eax,[esi+16] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+16],eax //load a
mov eax,[esi+20] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+20],eax //load a
mov eax,[esi+24] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [esi+24],eax //load a
mov eax,[esi+28] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov [esi+28],eax //load a
mov eax,edx //store carry
}
} }
/* /*
* Eight Word Block Linear Multiplication * Eight Word Block Linear Multiplication
*/ */
inline word word8_muladd(word z[8], const word x[8], inline word word8_linmul3(word z[8], const word x[8], word y, word carry)
word y, word carry)
{ {
__asm { z[0] = word_madd2(x[0], y, &carry);
mov esi,[x] z[1] = word_madd2(x[1], y, &carry);
mov ebx,[y] z[2] = word_madd2(x[2], y, &carry);
mov edi,[z] z[3] = word_madd2(x[3], y, &carry);
mov eax,[esi] //load a z[4] = word_madd2(x[4], y, &carry);
mul ebx //edx(hi):eax(lo)=a*b z[5] = word_madd2(x[5], y, &carry);
add eax,[carry] //sum lo carry z[6] = word_madd2(x[6], y, &carry);
adc edx,0 //sum hi carry z[7] = word_madd2(x[7], y, &carry);
add eax,[edi] //sum lo z return carry;
adc edx,0 //sum hi z
mov ecx,edx //carry for next block = hi z
mov [edi],eax //save lo z
mov eax,[esi+4]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+4]
adc edx,0
mov ecx,edx
mov [edi+4],eax
mov eax,[esi+8]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+8]
adc edx,0
mov ecx,edx
mov [edi+8],eax
mov eax,[esi+12]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+12]
adc edx,0
mov ecx,edx
mov [edi+12],eax
mov eax,[esi+16]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+16]
adc edx,0
mov ecx,edx
mov [edi+16],eax
mov eax,[esi+20]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+20]
adc edx,0
mov ecx,edx
mov [edi+20],eax
mov eax,[esi+24]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+24]
adc edx,0
mov ecx,edx
mov [edi+24],eax
mov eax,[esi+28]
mul ebx
add eax,ecx
adc edx,0
add eax,[edi+28]
adc edx,0
mov [edi+28],eax
mov eax,edx
}
}
inline word word8_linmul3(word z[4], const word x[4], word y, word carry)
{
__asm {
#if 0
//it's slower!!!
mov edx,[z]
mov eax,[x]
movd mm7,[y]
movd mm0,[eax]
movd mm1,[eax+4]
movd mm2,[eax+8]
pmuludq mm0,mm7
pmuludq mm1,mm7
pmuludq mm2,mm7
movd mm6,[carry]
paddq mm0,mm6
movd [edx],mm0
psrlq mm0,32
paddq mm1,mm0
movd [edx+4],mm1
movd mm3,[eax+12]
psrlq mm1,32
paddq mm2,mm1
movd [edx+8],mm2
pmuludq mm3,mm7
movd mm4,[eax+16]
psrlq mm2,32
paddq mm3,mm2
movd [edx+12],mm3
pmuludq mm4,mm7
movd mm5,[eax+20]
psrlq mm3,32
paddq mm4,mm3
movd [edx+16],mm4
pmuludq mm5,mm7
movd mm0,[eax+24]
psrlq mm4,32
paddq mm5,mm4
movd [edx+20],mm5
pmuludq mm0,mm7
movd mm1,[eax+28]
psrlq mm5,32
paddq mm0,mm5
movd [edx+24],mm0
pmuludq mm1,mm7
psrlq mm0,32
paddq mm1,mm0
movd [edx+28],mm1
psrlq mm1,32
movd eax,mm1
emms
#else
mov edi,[z]
mov esi,[x]
mov eax,[esi] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,[carry] //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi],eax //load a
mov eax,[esi+4] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+4],eax //load a
mov eax,[esi+8] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+8],eax //load a
mov eax,[esi+12] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+12],eax //load a
mov eax,[esi+16] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+16],eax //load a
mov eax,[esi+20] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+20],eax //load a
mov eax,[esi+24] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov ecx,edx //store carry
mov [edi+24],eax //load a
mov eax,[esi+28] //load a
mul [y] //edx(hi):eax(lo)=a*b
add eax,ecx //sum lo carry
adc edx,0 //sum hi carry
mov [edi+28],eax //load a
mov eax,edx //store carry
#endif
}
} }
/* /*
@@ -3058,6 +2723,7 @@ inline void word3_muladd_2(word* w2, word* w1, word* w0, word a, word b)
*w1 = word_add(*w1, b, &carry); *w1 = word_add(*w1, b, &carry);
*w2 = word_add(*w2, top, &carry); *w2 = word_add(*w2, top, &carry);
} }
#endif #endif
} }
@@ -4105,8 +3771,7 @@ AlgorithmIdentifier::AlgorithmIdentifier(const OID& alg_id,
if(option == USE_NULL_PARAM) if(option == USE_NULL_PARAM)
{ {
parameters += std::make_pair<const byte*, size_t>( parameters += std::pair<const byte*, size_t>(DER_NULL, sizeof(DER_NULL));
DER_NULL, sizeof(DER_NULL));
} }
} }
@@ -4122,8 +3787,7 @@ AlgorithmIdentifier::AlgorithmIdentifier(const std::string& alg_id,
if(option == USE_NULL_PARAM) if(option == USE_NULL_PARAM)
{ {
parameters += std::make_pair<const byte*, size_t>( parameters += std::pair<const byte*, size_t>(DER_NULL, sizeof(DER_NULL));
DER_NULL, sizeof(DER_NULL));
} }
} }

7
src/libs/3rdparty/botan/botan.h vendored
View File

@@ -66,7 +66,6 @@
#define BOTAN_GCC_VERSION 0 #define BOTAN_GCC_VERSION 0
#endif #endif
#define BOTAN_TARGET_ARCH_IS_X86_32
#define BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN #define BOTAN_TARGET_CPU_IS_LITTLE_ENDIAN
#define BOTAN_TARGET_CPU_IS_X86_FAMILY #define BOTAN_TARGET_CPU_IS_X86_FAMILY
#define BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK 1 #define BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK 1
@@ -10616,12 +10615,6 @@ inline u32bit reverse_bytes(u32bit val)
return val; return val;
#elif defined(_MSC_VER) && defined(BOTAN_TARGET_ARCH_IS_X86_32)
// Visual C++ inline asm for 32-bit x86, by Yves Jerschow
__asm mov eax, val;
__asm bswap eax;
#else #else
// Generic implementation // Generic implementation