← Back to branch summary

~ubuntu-branches/debian/sid/mame/sid

« back to all changes in this revision

Viewing changes to src/lib/lib7z/AesOpt.c

  • Committer: Package Import Robot
  • Author(s): Jordi Mallach, Emmanuel Kasper, Jordi Mallach
  • Date: 2012-06-05 20:02:23 UTC
  • mfrom: (0.3.1) (0.1.4)
  • Revision ID: package-import@ubuntu.com-20120605200223-gnlpogjrg6oqe9md
Tags: 0.146-1
[ Emmanuel Kasper ]
* New upstream release
* Drop patch to fix man pages section and patches to link with flac 
  and jpeg system lib: all this has been pushed upstream by Cesare Falco
* Add DM-Upload-Allowed: yes field.

[ Jordi Mallach ]
* Create a "gnu" TARGETOS stanza that defines NO_AFFINITY_NP.
* Stop setting TARGETOS to "unix" in d/rules. It should be autodetected,
  and set to the appropriate value.
* mame_manpage_section.patch: Change mame's manpage section to 6 (games),
  in the TH declaration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/lib7z/AesOpt.c
 
1
/* AesOpt.c -- Intel's AES
 
2
2009-11-23 : Igor Pavlov : Public domain */
 
3
 
 
4
#include "CpuArch.h"
 
5
 
 
6
#ifdef MY_CPU_X86_OR_AMD64
 
7
#if _MSC_VER >= 1500
 
8
#define USE_INTEL_AES
 
9
#endif
 
10
#endif
 
11
 
 
12
#ifdef USE_INTEL_AES
 
13
 
 
14
#include <wmmintrin.h>
 
15
 
 
16
void MY_FAST_CALL AesCbc_Encode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
 
17
{
 
18
  __m128i m = *p;
 
19
  for (; numBlocks != 0; numBlocks--, data++)
 
20
  {
 
21
    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
 
22
    const __m128i *w = p + 3;
 
23
    m = _mm_xor_si128(m, *data);
 
24
    m = _mm_xor_si128(m, p[2]);
 
25
    do
 
26
    {
 
27
      m = _mm_aesenc_si128(m, w[0]);
 
28
      m = _mm_aesenc_si128(m, w[1]);
 
29
      w += 2;
 
30
    }
 
31
    while (--numRounds2 != 0);
 
32
    m = _mm_aesenc_si128(m, w[0]);
 
33
    m = _mm_aesenclast_si128(m, w[1]);
 
34
    *data = m;
 
35
  }
 
36
  *p = m;
 
37
}
 
38
 
 
39
#define NUM_WAYS 3
 
40
 
 
41
#define AES_OP_W(op, n) { \
 
42
    const __m128i t = w[n]; \
 
43
    m0 = op(m0, t); \
 
44
    m1 = op(m1, t); \
 
45
    m2 = op(m2, t); \
 
46
    }
 
47
 
 
48
#define AES_DEC(n) AES_OP_W(_mm_aesdec_si128, n)
 
49
#define AES_DEC_LAST(n) AES_OP_W(_mm_aesdeclast_si128, n)
 
50
#define AES_ENC(n) AES_OP_W(_mm_aesenc_si128, n)
 
51
#define AES_ENC_LAST(n) AES_OP_W(_mm_aesenclast_si128, n)
 
52
 
 
53
void MY_FAST_CALL AesCbc_Decode_Intel(__m128i *p, __m128i *data, size_t numBlocks)
 
54
{
 
55
  __m128i iv = *p;
 
56
  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
 
57
  {
 
58
    UInt32 numRounds2 = *(const UInt32 *)(p + 1);
 
59
    const __m128i *w = p + numRounds2 * 2;
 
60
    __m128i m0, m1, m2;
 
61
    {
 
62
      const __m128i t = w[2];
 
63
      m0 = _mm_xor_si128(t, data[0]);
 
64
      m1 = _mm_xor_si128(t, data[1]);
 
65
      m2 = _mm_xor_si128(t, data[2]);
 
66
    }
 
67
    numRounds2--;
 
68
    do
 
69
    {
 
70
      AES_DEC(1)
 
71
      AES_DEC(0)
 
72
      w -= 2;
 
73
    }
 
74
    while (--numRounds2 != 0);
 
75
    AES_DEC(1)
 
76
    AES_DEC_LAST(0)
 
77
 
 
78
    {
 
79
      __m128i t;
 
80
      t = _mm_xor_si128(m0, iv); iv = data[0]; data[0] = t;
 
81
      t = _mm_xor_si128(m1, iv); iv = data[1]; data[1] = t;
 
82
      t = _mm_xor_si128(m2, iv); iv = data[2]; data[2] = t;
 
83
    }
 
84
  }
 
85
  for (; numBlocks != 0; numBlocks--, data++)
 
86
  {
 
87
    UInt32 numRounds2 = *(const UInt32 *)(p + 1);
 
88
    const __m128i *w = p + numRounds2 * 2;
 
89
    __m128i m = _mm_xor_si128(w[2], *data);
 
90
    numRounds2--;
 
91
    do
 
92
    {
 
93
      m = _mm_aesdec_si128(m, w[1]);
 
94
      m = _mm_aesdec_si128(m, w[0]);
 
95
      w -= 2;
 
96
    }
 
97
    while (--numRounds2 != 0);
 
98
    m = _mm_aesdec_si128(m, w[1]);
 
99
    m = _mm_aesdeclast_si128(m, w[0]);
 
100
 
 
101
    m = _mm_xor_si128(m, iv);
 
102
    iv = *data;
 
103
    *data = m;
 
104
  }
 
105
  *p = iv;
 
106
}
 
107
 
 
108
void MY_FAST_CALL AesCtr_Code_Intel(__m128i *p, __m128i *data, size_t numBlocks)
 
109
{
 
110
  __m128i ctr = *p;
 
111
  __m128i one;
 
112
  one.m128i_u64[0] = 1;
 
113
  one.m128i_u64[1] = 0;
 
114
  for (; numBlocks >= NUM_WAYS; numBlocks -= NUM_WAYS, data += NUM_WAYS)
 
115
  {
 
116
    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
 
117
    const __m128i *w = p;
 
118
    __m128i m0, m1, m2;
 
119
    {
 
120
      const __m128i t = w[2];
 
121
      ctr = _mm_add_epi64(ctr, one); m0 = _mm_xor_si128(ctr, t);
 
122
      ctr = _mm_add_epi64(ctr, one); m1 = _mm_xor_si128(ctr, t);
 
123
      ctr = _mm_add_epi64(ctr, one); m2 = _mm_xor_si128(ctr, t);
 
124
    }
 
125
    w += 3;
 
126
    do
 
127
    {
 
128
      AES_ENC(0)
 
129
      AES_ENC(1)
 
130
      w += 2;
 
131
    }
 
132
    while (--numRounds2 != 0);
 
133
    AES_ENC(0)
 
134
    AES_ENC_LAST(1)
 
135
    data[0] = _mm_xor_si128(data[0], m0);
 
136
    data[1] = _mm_xor_si128(data[1], m1);
 
137
    data[2] = _mm_xor_si128(data[2], m2);
 
138
  }
 
139
  for (; numBlocks != 0; numBlocks--, data++)
 
140
  {
 
141
    UInt32 numRounds2 = *(const UInt32 *)(p + 1) - 1;
 
142
    const __m128i *w = p;
 
143
    __m128i m;
 
144
    ctr = _mm_add_epi64(ctr, one);
 
145
    m = _mm_xor_si128(ctr, p[2]);
 
146
    w += 3;
 
147
    do
 
148
    {
 
149
      m = _mm_aesenc_si128(m, w[0]);
 
150
      m = _mm_aesenc_si128(m, w[1]);
 
151
      w += 2;
 
152
    }
 
153
    while (--numRounds2 != 0);
 
154
    m = _mm_aesenc_si128(m, w[0]);
 
155
    m = _mm_aesenclast_si128(m, w[1]);
 
156
    *data = _mm_xor_si128(*data, m);
 
157
  }
 
158
  *p = ctr;
 
159
}
 
160
 
 
161
#else
 
162
 
 
163
void MY_FAST_CALL AesCbc_Encode(UInt32 *ivAes, Byte *data, size_t numBlocks);
 
164
void MY_FAST_CALL AesCbc_Decode(UInt32 *ivAes, Byte *data, size_t numBlocks);
 
165
void MY_FAST_CALL AesCtr_Code(UInt32 *ivAes, Byte *data, size_t numBlocks);
 
166
 
 
167
void MY_FAST_CALL AesCbc_Encode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
 
168
{
 
169
  AesCbc_Encode(p, data, numBlocks);
 
170
}
 
171
 
 
172
void MY_FAST_CALL AesCbc_Decode_Intel(UInt32 *p, Byte *data, size_t numBlocks)
 
173
{
 
174
  AesCbc_Decode(p, data, numBlocks);
 
175
}
 
176
 
 
177
void MY_FAST_CALL AesCtr_Code_Intel(UInt32 *p, Byte *data, size_t numBlocks)
 
178
{
 
179
  AesCtr_Code(p, data, numBlocks);
 
180
}
 
181
 
 
182
#endif