src/trusted/validator/x86/decoder/generator/ncdecode_sse.c - Issue 625923004: Delete old x86 validator.

Side by Side Diff: src/trusted/validator/x86/decoder/generator/ncdecode_sse.c

Issue 625923004: Delete old x86 validator. (Closed) Base URL: svn://svn.chromium.org/native_client/trunk/src/native_client

Patch Set: Created 6 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

« src/trusted/validator/nacl.scons ('K') | « src/trusted/validator/x86/decoder/generator/ncdecode_onebyte.c ('k') | src/trusted/validator/x86/decoder/generator/ncdecode_st.h » ('j') | src/trusted/validator_x86/build.scons » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

OLD	NEW
	(Empty)
1 /*

2 * Copyright (c) 2012 The Native Client Authors. All rights reserved.

3 * Use of this source code is governed by a BSD-style license that be

4 * found in the LICENSE file.

5 */

6

7 /*

8 * Defines SSE instructions. Taken from:

9 * (1) Tables A-3 and A-4 of appendix "A2 - Opcode Encodings", in AMD

10 * document 24594-Rev.3.14-September 2007: "AMD64 Architecture

11 * Programmer's manual Volume 3: General-Purpose and System Instructions".

12 * (2) Table A-4 and A-5 of "appendix A.3", in Intel Document 253667-030US

13 * (March 2009): "Intel 64 and IA-32 Architectures Software Developer's

14 * Manual, Volume 2g: Instruction Set Reference, N-Z."

15 *

16 * Note: Invalid etries with f2 (REPNE) and f3 (REP) can be ommitted in

17 * the tables, because the corresponding entry without that prefix will

18 * be explicitly rejected (unless it is one of the special instructions

19 * that allow such prefixes).

20 */

21

22 #ifndef NACL_TRUSTED_BUT_NOT_TCB

23 #error("This file is not meant for use in the TCB")

24 #endif

25

26 #include "native_client/src/trusted/validator/x86/decoder/generator/ncdecode_for ms.h"

27 #include "native_client/src/trusted/validator/x86/decoder/generator/ncdecode_tab legen.h"

28

29 static void NaClDefBinarySseInsts(struct NaClSymbolTable* st) {

30 NaClDefPrefixInstChoices(Prefix0F, 0x12, 2);

31 NaClDefPrefixInstChoices(Prefix0F, 0x16, 2);

32 NaClDefPrefixInstChoices_32_64(Prefix660F, 0x6e, 1, 2);

33 NaClDefPrefixInstChoices_32_64(Prefix660F, 0x7e, 1, 2);

34 NaClDefine(" 0f3800: Pshufb $Pq, $Qq", NACLi_SSSE3, st, Binary);

35 NaClDefine(" 0f3801: Phaddw $Pq, $Qq", NACLi_SSSE3, st, Binary);

36 NaClDefine(" 0f3802: Phaddd $Pq, $Qq", NACLi_SSSE3, st, Binary);

37 NaClDefine(" 0f3803: Phaddsw $Pq, $Qq", NACLi_SSSE3, st, Binary);

38 NaClDefine(" 0f3804: Pmaddubsw $Pq, $Qq", NACLi_SSSE3, st, Binary);

39 NaClDefine(" 0f3805: Phsubw $Pq, $Qq", NACLi_SSSE3, st, Binary);

40 NaClDefine(" 0f3806: Phsubd $Pq, $Qq", NACLi_SSSE3, st, Binary);

41 NaClDefine(" 0f3807: Phsubsw $Pq, $Qq", NACLi_SSSE3, st, Binary);

42 NaClDefine(" 0f3808: Psignb $Pq $Qq", NACLi_SSSE3, st, Binary);

43 NaClDefine(" 0f3809: Psignw $Pq, $Qq", NACLi_SSSE3, st, Binary);

44 NaClDefine(" 0f380a: Psignd $Pq, $Qq", NACLi_SSSE3, st, Binary);

45 NaClDefine(" 0f380b: Pmulhrsw $Pq, $Qq", NACLi_SSSE3, st, Binary);

46 NaClDefIter(" 0f380c+@i: Invalid", 0, 15, NACLi_INVALID, st, Other);

47 NaClDefine(" 0f381c: Pabsb $Pq, $Qq", NACLi_SSSE3, st, Move);

48 NaClDefine(" 0f381d: Pabsw $Pq, $Qq", NACLi_SSSE3, st, Move);

49 NaClDefine(" 0f381e: Pabsd $Pq, $Qq", NACLi_SSSE3, st, Move);

50 NaClDefIter(" 0f381f+@i: Invalid", 0, 208, NACLi_INVALID, st, Other);

51 NaClDefine(" 0f38f0: Movbe $Gv, $Mv", NACLi_MOVBE, st, Move);

52 NaClDefine(" 0f38f1: Movbe $Mv, $Gv", NACLi_MOVBE, st, Move);

53 NaClDefIter(" 0f38f2+@i: Invalid", 0, 13, NACLi_INVALID, st, Other);

54 NaClDefine(" 660f3800: Pshufb $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

55 NaClDefine(" 660f3801: Phaddw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

56 NaClDefine(" 660f3802: Phaddd $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

57 NaClDefine(" 660f3803: Phaddsw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

58 NaClDefine(" 660f3804: Pmaddubsw $Vdq, $Wdq",NACLi_SSSE3, st, Binary);

59 NaClDefine(" 660f3805: Phsubw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

60 NaClDefine(" 660f3806: Phsubd $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

61 NaClDefine(" 660f3807: Phsubsw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

62 NaClDefine(" 660f3808: Psignb $Vdq $Wdq", NACLi_SSSE3, st, Binary);

63 NaClDefine(" 660f3809: Psignw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

64 NaClDefine(" 660f380a: Psignd $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

65 NaClDefine(" 660f380b: Pmulhrsw $Vdq, $Wdq", NACLi_SSSE3, st, Binary);

66 NaClDefIter("660f380C+@i: Invalid", 0, 3, NACLi_INVALID, st, Other);

67 NaClDefine(" 660f3810: Pblendvb $Vdq, $Wdq, %xmm0",

68 NACLi_SSE41, st, Binary);

69 NaClDefIter("660f3811+@i: Invalid", 0, 2, NACLi_INVALID, st, Other);

70 NaClDefine(" 660f3814: Blendvps $Vdq, $Wdq, %xmm0",

71 NACLi_SSE41, st, Binary);

72 NaClDefine(" 660f3815: Blendvpd $Vdq, $Wdq, %xmm0",

73 NACLi_SSE41, st, Binary);

74 NaClDefine(" 660f3816: Invalid", NACLi_INVALID, st, Other);

75 NaClDefine(" 660f3817: Ptest $Vdq, $Wdq", NACLi_SSE41, st, Compare);

76 NaClDefIter("660f3818+@i: Invalid", 0, 3, NACLi_INVALID, st, Other);

77 NaClDefine(" 660f381c: Pabsb $Vdq, $Wdq", NACLi_SSSE3, st, Move);

78 NaClDefine(" 660f381d: Pabsw $Vdq, $Wdq", NACLi_SSSE3, st, Move);

79 NaClDefine(" 660f381e: Pabsd $Vdq, $Wdq", NACLi_SSSE3, st, Move);

80 NaClDefine(" 660f381f: Invalid", NACLi_INVALID, st, Other);

81 NaClDefine(" 660f3820: Pmovsxbw $Vdq, $Udq/Mq",

82 NACLi_SSE41, st, Move);

83 NaClDefine(" 660f3821: Pmovsxbd $Vdq, $Udq/Md",

84 NACLi_SSE41, st, Move);

85 NaClDefine(" 660f3822: Pmovsxbq $Vdq, $Udq/Mw",

86 NACLi_SSE41, st, Move);

87 NaClDefine(" 660f3823: Pmovsxwd $Vdq, $Udq/Mq",

88 NACLi_SSE41, st, Move);

89 NaClDefine(" 660f3824: Pmovsxwq $Vdq, $Udq/Md",

90 NACLi_SSE41, st, Move);

91 NaClDefine(" 660f3825: Pmovsxdq $Vdq, $Udq/Mq",

92 NACLi_SSE41, st, Move);

93 NaClDefIter("660f3826+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

94 NaClDefine(" 660f3828: Pmuldq $Vdq, $Wdq", NACLi_SSE41, st, Binary);

95 NaClDefine(" 660f3829: Pcmpeqq $Vdq, $Wdq", NACLi_SSE41, st, Binary);

96 NaClDefine(" 660f382a: Movntdqa $Vdq, $Mdq", NACLi_SSE41, st, Move);

97 NaClDefine(" 660f382b: Packusdw $Vdq, $Wdq", NACLi_SSE41, st, Binary);

98 NaClDefIter("660f382c+@i: Invalid", 0, 3, NACLi_INVALID, st, Other);

99 NaClDefine(" 660f3830: Pmovzxbw $Vdq, $Udq/Mq",

100 NACLi_SSE41, st, Move);

101 NaClDefine(" 660f3831: Pmovzxbd $Vdq, $Udq/Md",

102 NACLi_SSE41, st, Move);

103 NaClDefine(" 660f3832: Pmovzxbq $Vdq, $Udq/Mw",

104 NACLi_SSE41, st, Move);

105 NaClDefine(" 660f3833: Pmovzxwd $Vdq, $Udq/Mq",

106 NACLi_SSE41, st, Move);

107 NaClDefine(" 660f3834: Pmovzxwq $Vdq, $Udq/Md",

108 NACLi_SSE41, st, Move);

109 NaClDefine(" 660f3835: Pmovzxdq $Vdq, $Udq/Mq",

110 NACLi_SSE41, st, Move);

111 NaClDefine(" 660f3836: Invalid", NACLi_INVALID, st, Other);

112 NaClDefine(" 660f3837: Pcmpgtq $Vdq, $Wdq", NACLi_SSE42, st, Binary);

113 NaClDefine(" 660f3838: Pminsb $Vdq, $Wdq", NACLi_SSE41, st, Binary);

114 NaClDefine(" 660f3839: Pminsd $Vdq, $Wdq", NACLi_SSE41, st, Binary);

115 NaClDefine(" 660f383a: Pminuw $Vdq, $Wdq", NACLi_SSE41, st, Binary);

116 NaClDefine(" 660f383b: Pminud $Vdq, $Wdq", NACLi_SSE41, st, Binary);

117 NaClDefine(" 660f383c: Pmaxsb $Vdq, $Wdq", NACLi_SSE41, st, Binary);

118 NaClDefine(" 660f383d: Pmaxsd $Vdq, $Wdq", NACLi_SSE41, st, Binary);

119 NaClDefine(" 660f383e: Pmaxuw $Vdq, $Wdq", NACLi_SSE41, st, Binary);

120 NaClDefine(" 660f383f: Pmaxud $Vdq, $Wdq", NACLi_SSE41, st, Binary);

121 NaClDefine(" 660f3840: Pmulld $Vdq, $Wdq", NACLi_SSE41, st, Binary);

122 NaClDefine(" 660f3841: Phminposuw $Vdq, $Wdq",

123 NACLi_SSE41, st, Binary);

124 NaClDefIter("660f3842+@i: Invalid", 0, 61, NACLi_INVALID, st, Other);

125 NaClDef_32(" 660f3880: Invept $Gd, $Mdq", NACLi_VMX, st, Uses);

126 NaClDef_64(" 660f3880: Invept $Gq, $Mdq", NACLi_VMX, st, Uses);

127 NaClDef_32(" 660f3881: Invvpid $Gd, $Mdq", NACLi_VMX, st, Uses);

128 NaClDef_64(" 660f3881: Invvpid $Gq, $Mdq", NACLi_VMX, st, Uses);

129 NaClDefIter("660f3882+@i: Invalid", 0, 109, NACLi_INVALID, st, Other);

130 NaClDefIter("660f38f2+@i: Invalid", 0, 13, NACLi_INVALID, st, Other);

131 NaClDefine(" f20f38f0: Crc32 $Gd, $Eb", NACLi_SSE42, st, Binary);

132 NaClDefine(" f20f38f1: Crc32 $Gd, $Ev", NACLi_SSE42, st, Binary);

133 NaClDefine(" 0f10: Movups $Vps, $Wps", NACLi_SSE, st, Move);

134 NaClDefine(" 0f11: Movups $Wps, $Vps", NACLi_SSE, st, Move);

135 NaClDefine(" 0f12: Movlps $Vps, $Mq", NACLi_SSE, st, Move);

136 NaClDefine(" 0f12: Movhlps $Vps, $VRq", NACLi_SSE, st, Move);

137 NaClDefine(" 0f13: Movlps $Mq, $Vps", NACLi_SSE, st, Move);

138 NaClDefine(" 0f14: Unpcklps $Vps, $Wq", NACLi_SSE, st, Binary);

139 NaClDefine(" 0f15: Unpckhps $Vps, $Wq", NACLi_SSE, st, Binary);

140 NaClDefine(" 0f16: Movhps $Vps, $Mq", NACLi_SSE, st, Move);

141 NaClDefine(" 0f16: Movlhps $Vps, $VRq", NACLi_SSE, st, Move);

142 NaClDefine(" 0f17: Movhps $Mq, $Vps", NACLi_SSE, st, Move);

143 NaClDefine(" f30f10: Movss $Vss, $Wss", NACLi_SSE, st, Move);

144 NaClDefine(" f30f11: Movss $Wss, $Vss", NACLi_SSE, st, Move);

145 NaClDefine(" f30f12: Movsldup $Vps, $Wps", NACLi_SSE3, st, Move);

146 NaClDefIter(" f30f13+@i: Invalid", 0, 2, NACLi_INVALID, st, Other);

147 NaClDefine(" f30f16: Movshdup $Vps, $Wps", NACLi_SSE3, st, Move);

148 NaClDefine(" f30f17: Invalid", NACLi_INVALID, st, Other);

149 NaClDefine(" 660f10: Movupd $Vpd, $Wpd", NACLi_SSE2, st, Move);

150 NaClDefine(" 660f11: Movupd $Wpd, $Vpd", NACLi_SSE2, st, Move);

151 NaClDefine(" 660f12: Movlpd $Vsd, $Mq", NACLi_SSE2, st, Move);

152 NaClDefine(" 660f13: Movlpd $Mq, $Vsd", NACLi_SSE2, st, Move);

153 NaClDefine(" 660f14: Unpcklpd $Vpd, $Wq", NACLi_SSE2, st, Binary);

154 NaClDefine(" 660f15: Unpckhpd $Vpd, $Wq", NACLi_SSE2, st, Binary);

155 NaClDefine(" 660f16: Movhpd $Vsd, $Mq", NACLi_SSE2, st, Move);

156 NaClDefine(" 660f17: Movhpd $Mq, $Vsd", NACLi_SSE2, st, Move);

157 NaClDefine(" f20f10: Movsd $Vsd, $Wsd", NACLi_SSE2, st, Move);

158 NaClDefine( "f20f11: Movsd $Wsd, $Vsd", NACLi_SSE2, st, Move);

159 NaClDefine(" f20f12: Movddup $Vpd, $Wsd", NACLi_SSE3, st, Move);

160 NaClDefine(" 0f28: Movaps $Vps, $Wps", NACLi_SSE, st, Move);

161 NaClDefine(" 0f29: Movaps $Wps, $Vps", NACLi_SSE, st, Move);

162 NaClDefine(" 0f2a: Cvtpi2ps $Vps, $Qq", NACLi_SSE, st, Move);

163 NaClDefine(" 0f2b: Movntps $Mdq, $Vps", NACLi_SSE, st, Move);

164 NaClDefine(" 0f2c: Cvttps2pi $Pq, $Wps", NACLi_SSE, st, Move);

165 NaClDefine(" 0f2d: Cvtps2pi $Pq, $Wps", NACLi_SSE, st, Move);

166 NaClDefine(" 0f2e: Ucomiss $Vss, $Wss", NACLi_SSE, st, Compare);

167 NaClDefine(" 0f2f: Comiss $Vps, $Wps", NACLi_SSE, st, Compare);

168 NaClDefIter(" f30f28+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

169 NaClDefine(" f30f2a: Cvtsi2ss $Vss, $Ed/q",NACLi_SSE, st, Move);

170 NaClDefine(" f30f2b: Movntss $Md, $Vss", NACLi_SSE4A, st, Move);

171 NaClDefine(" f30f2c: Cvttss2si $Gd/q, $Wss",

172 NACLi_SSE, st, Move);

173 NaClDefine(" f30f2d: Cvtss2si $Gd/q, $Wss",

174 NACLi_SSE, st, Move);

175 NaClDefIter(" f30f2e+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

176 NaClDefine(" 660f28: Movapd $Vpd, $Wpd", NACLi_SSE2, st, Move);

177 NaClDefine(" 660f29: Movapd $Wpd, $Vpd", NACLi_SSE2, st, Move);

178 NaClDefine(" 660f2a: Cvtpi2pd $Vpd, $Qq", NACLi_SSE2, st, Move);

179 NaClDefine(" 660f2b: Movntpd $Mdq, $Vpd", NACLi_SSE2, st, Move);

180 NaClDefine(" 660f2c: Cvttpd2pi $Pq, $Wpd",

181 NACLi_SSE2, st, Move);

182 NaClDefine(" 660f2d: Cvtpd2pi $Pq, $Wpd",

183 NACLi_SSE2, st, Move);

184 NaClDefine(" 660f2e: Ucomisd $Vsd, $Wsd", NACLi_SSE2, st, Compare);

185 NaClDefine(" 660f2f: Comisd $Vpd, $Wsd", NACLi_SSE2, st, Compare);

186 NaClDefIter(" f20f28+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

187 NaClDefine(" f20f2a: Cvtsi2sd $Vsd, $Ed/q",

188 NACLi_SSE2, st, Move);

189 NaClDefine(" f20f2b: Movntsd $Mq, $Vsd", NACLi_SSE4A, st, Move);

190 NaClDefine(" f20f2c: Cvttsd2si $Gd/q, $Wsd",

191 NACLi_SSE2, st, Move);

192 NaClDefine(" f20f2d: Cvtsd2si $Gd/q, $Wsd",

193 NACLi_SSE2, st, Move);

194 NaClDefIter(" f20f2e+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

195 NaClDefine(" 0f50: Movmskps $Gd, $VRps", NACLi_SSE, st, Move);

196 NaClDefine(" 0f51: Sqrtps $Vps, $Wps", NACLi_SSE, st, Move);

197 NaClDefine(" 0f52: Rsqrtps $Vps, $Wps", NACLi_SSE, st, Move);

198 NaClDefine(" 0f53: Rcpps $Vps, $Wps", NACLi_SSE, st, Move);

199 NaClDefine(" 0f54: Andps $Vps, $Wps", NACLi_SSE, st, Binary);

200 NaClDefine(" 0f55: Andnps $Vps, $Wps", NACLi_SSE, st, Binary);

201 NaClDefine(" 0f56: Orps $Vps, $Wps", NACLi_SSE, st, Binary);

202 NaClDefine(" 0f57: Xorps $Vps, $Wps", NACLi_SSE, st, Binary);

203 NaClDefine(" f30f50: Invalid", NACLi_INVALID, st, Other);

204 NaClDefine(" f30f51: Sqrtss $Vps, $Wps", NACLi_SSE, st, Move);

205 NaClDefine(" f30f52: Rsqrtss $Vss, $Wss", NACLi_SSE, st, Move);

206 NaClDefine(" f30f53: Rcpss $Vss, $Wss", NACLi_SSE, st, Move);

207 NaClDefIter(" f30f54+@i: Invalid", 0, 3, NACLi_INVALID, st, Other);

208 NaClDefine(" 660f50: Movmskpd $Gd, $VRpd", NACLi_SSE2, st, Move);

209 NaClDefine(" 660f51: Sqrtpd $Vps, $Wpd", NACLi_SSE2, st, Move);

210 NaClDefIter(" 660f52+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

211 NaClDefine(" 660f54: Andpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

212 NaClDefine(" 660f55: Andnpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

213 NaClDefine(" 660f56: Orpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

214 NaClDefine(" 660f57: Xorpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

215 NaClDefine(" f20f50: Invalid", NACLi_INVALID, st, Other);

216 NaClDefine(" f20f51: Sqrtsd $Vsd, $Wsd", NACLi_SSE2, st, Move);

217 NaClDefIter(" f20f52+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

218 NaClDefine(" 0f58: Addps $Vps, $Wps", NACLi_SSE, st, Binary);

219 NaClDefine(" 0f59: Mulps $Vps, $Wps", NACLi_SSE, st, Binary);

220 NaClDefine(" 0f5a: Cvtps2pd $Vpd, $Wps", NACLi_SSE2, st, Move);

221 NaClDefine(" 0f5b: Cvtdq2ps $Vps, $Wdq", NACLi_SSE2, st, Move);

222 NaClDefine(" 0f5c: Subps $Vps, $Wps", NACLi_SSE, st, Binary);

223 NaClDefine(" 0f5d: Minps $Vps, $Wps", NACLi_SSE, st, Binary);

224 NaClDefine(" 0f5e: Divps $Vps, $Wps", NACLi_SSE, st, Binary);

225 NaClDefine(" 0f5f: Maxps $Vps, $Wps", NACLi_SSE, st, Binary);

226 NaClDefine(" f30f58: Addss $Vss, $Wss", NACLi_SSE, st, Binary);

227 NaClDefine(" f30f59: Mulss $Vss, $Wss", NACLi_SSE, st, Binary);

228 NaClDefine(" f30f5a: Cvtss2sd $Vsd, $Wss", NACLi_SSE2, st, Move);

229 NaClDefine(" f30f5b: Cvttps2dq $Vdq, $Wps",

230 NACLi_SSE2, st, Move);

231 NaClDefine(" f30f5c: Subss $Vss, $Wss", NACLi_SSE, st, Binary);

232 NaClDefine(" f30f5d: Minss $Vss, $Wss", NACLi_SSE, st, Binary);

233 NaClDefine(" f30f5e: Divss $Vss, $Wss", NACLi_SSE, st, Binary);

234 NaClDefine(" f30f5f: Maxss $Vss, $Wss", NACLi_SSE, st, Binary);

235 NaClDefine(" 660f58: Addpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

236 NaClDefine(" 660f59: Mulpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

237 NaClDefine(" 660f5a: Cvtpd2ps $Vps, $Wpd", NACLi_SSE2, st, Move);

238 NaClDefine(" 660f5b: Cvtps2dq $Vdq, $Wps", NACLi_SSE2, st, Move);

239 NaClDefine(" 660f5c: Subpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

240 NaClDefine(" 660f5d: Minpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

241 NaClDefine(" 660f5e: Divpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

242 NaClDefine(" 660f5f: Maxpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

243 NaClDefine(" f20f58: Addsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

244 NaClDefine(" f20f59: Mulsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

245 NaClDefine(" f20f5a: Cvtsd2ss $Vss, $Wsd", NACLi_SSE2, st, Move);

246 NaClDefine(" f20f5b: Invalid", NACLi_INVALID, st, Other);

247 NaClDefine(" f20f5c: Subsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

248 NaClDefine(" f20f5d: Minsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

249 NaClDefine(" f20f5e: Divsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

250 NaClDefine(" f20f5f: Maxsd $Vsd, $Wsd", NACLi_SSE2, st, Binary);

251 NaClDefine(" 660f60: Punpcklbw $Vdq, $Wq", NACLi_SSE2, st, Binary);

252 NaClDefine(" 660f61: Punpcklwd $Vdq, $Wq", NACLi_SSE2, st, Binary);

253 NaClDefine(" 660f62: Punpckldq $Vdq, $Wq", NACLi_SSE2, st, Binary);

254 NaClDefine(" 660f63: Packsswb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

255 NaClDefine(" 660f64: Pcmpgtb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

256 NaClDefine(" 660f65: Pcmpgtw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

257 NaClDefine(" 660f66: Pcmpgtd $Vdq, $Wdq", NACLi_SSE2, st, Binary);

258 NaClDefine(" 660f67: Packuswb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

259 NaClDefIter(" f20f60+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

260 NaClDefIter(" f30f60+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

261 NaClDefIter(" f30f68+@i: Invalid", 0, 6, NACLi_INVALID, st, Other);

262 NaClDefine(" f30f6f: Movdqu $Vdq, $Wdq", NACLi_SSE2, st, Move);

263 NaClDefine(" 660f68: Punpckhbw $Vdq, $Wq", NACLi_SSE2, st, Binary);

264 NaClDefine(" 660f69: Punpckhwd $Vdq, $Wq", NACLi_SSE2, st, Binary);

265 NaClDefine(" 660f6a: Punpckhdq $Vdq, $Wq", NACLi_SSE2, st, Binary);

266 NaClDefine(" 660f6b: Packssdw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

267 NaClDefine(" 660f6c: Punpcklqdq $Vdq, $Wq",

268 NACLi_SSE2, st, Binary);

269 NaClDefine(" 660f6d: Punpckhqdq $Vdq, $Wq",

270 NACLi_SSE2, st, Binary);

271 NaClDefine(" 660f6e: Movd $Vdq, $Ed/q/d", NACLi_SSE2, st, Move);

272 NaClDef_64(" 660f6e: Movq $Vdq, $Ed/q/q", NACLi_SSE2, st, Move);

273 NaClDefine(" 660f6f: Movdqa $Vdq, $Wdq", NACLi_SSE2, st, Move);

274 NaClDefIter(" f20f68+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

275 NaClDefine(" 660f70: Pshufd $Vdq, $Wdq, $Ib",

276 NACLi_SSE2, st, Binary);

277 NaClDefIter(" 660f71/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

278 NaClDefine(" 660f71/2: Psrlw $VRdq, $Ib", NACLi_SSE2, st, Binary);

279 NaClDefine(" 660f71/3: Invalid", NACLi_INVALID, st, Other);

280 NaClDefine(" 660f71/4: Psraw $VRdq, $Ib", NACLi_SSE2, st, Binary);

281 NaClDefine(" 660f71/5: Invalid", NACLi_INVALID, st, Other);

282 NaClDefine(" 660f71/6: Psllw $VRdq, $Ib", NACLi_SSE2, st, Binary);

283 NaClDefine(" 660f71/7: Invalid", NACLi_INVALID, st, Other);

284 NaClDefIter(" 660f72/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

285 NaClDefine(" 660f72/2: Psrld $VRdq, $Ib", NACLi_SSE2, st, Binary);

286 NaClDefine(" 660f72/3: Invalid", NACLi_INVALID, st, Other);

287 NaClDefine(" 660f72/4: Psrad $VRdq, $Ib", NACLi_SSE2, st, Binary);

288 NaClDefine(" 660f72/5: Invalid", NACLi_INVALID, st, Other);

289 NaClDefine(" 660f72/6: Pslld $VRdq, $Ib", NACLi_SSE2, st, Binary);

290 NaClDefine(" 660f72/7: Invalid", NACLi_INVALID, st, Other);

291 NaClDefIter(" 660f73/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

292 NaClDefine(" 660f73/2: Psrlq $VRdq, $Ib", NACLi_SSE2, st, Binary);

293 NaClDefine(" 660f73/3: Psrldq $VRdq, $Ib", NACLi_SSE2, st, Binary);

294 NaClDefIter(" 660f73/@i: Invalid", 4, 5, NACLi_INVALID, st, Other);

295 NaClDefine(" 660f73/6: Psllq $VRdq, $Ib", NACLi_SSE2, st, Binary);

296 NaClDefine(" 660f73/7: Pslldq $VRdq, $Ib", NACLi_SSE2, st, Binary);

297 NaClDefine(" 660f74: Pcmpeqb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

298 NaClDefine(" 660f75: Pcmpeqw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

299 NaClDefine(" 660f76: Pcmpeqd $Vdq, $Wdq", NACLi_SSE2, st, Binary);

300 NaClDefine(" 660f77: Invalid", NACLi_INVALID, st, Other);

301 NaClDefine(" f20f70: Pshuflw $Vq, $Wq, $Ib",

302 NACLi_SSE2, st, Binary);

303 NaClDefIter(" f20f71+@i: Invalid", 0, 6, NACLi_INVALID, st, Other);

304 NaClDefine(" f30f70: Pshufhw $Vq, $Wq, $Ib",

305 NACLi_SSE2, st, Binary);

306 NaClDefIter(" f30f71+@i: Invalid", 0, 6, NACLi_INVALID, st, Other);

307 NaClBegDef(" 660f78/0: Extrq $Vdq, $Ib, $Ib",NACLi_SSE4A, st);

308 NaClAddOpFlags(0, NACL_OPFLAG(AllowGOperandWithOpcodeInModRm));

309 NaClEndDef( Nary);

310 NaClDefine(" 660f78/r: Invalid", NACLi_INVALID, st, Other);

311 NaClDefine(" 660f79: Extrq $Vdq, $VRdq", NACLi_SSE4A, st, Binary);

312 NaClDefIter(" 660f7a+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

313 NaClDefine(" 660f7c: Haddpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

314 NaClDefine(" 660f7d: Hsubpd $Vpd, $Wpd", NACLi_SSE2, st, Binary);

315 NaClDefine(" 660f7e: Movd $Ed/q/d, $Vd/q/d",

316 NACLi_SSE2, st, Move);

317 NaClDef_64(" 660f7e: Movq $Ed/q/q, $Vd/q/q",

318 NACLi_SSE2, st, Move);

319 NaClDefine(" 660f7f: Movdqa $Wdq, $Vdq", NACLi_SSE2, st, Move);

320 NaClDefine(" f20f78: Insertq $Vdq, $VRq, $Ib, $Ib",

321 NACLi_SSE4A, st, Nary);

322 NaClDefine(" f20f79: Insertq $Vdq, $VRdq", NACLi_SSE4A, st, Binary);

323 NaClDefIter(" f20f7a+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

324 NaClDefine(" f20f7c: Haddps $Vps, $Wps", NACLi_SSE3, st, Binary);

325 NaClDefine(" f20f7d: Hsubps $Vps, $Wps", NACLi_SSE3, st, Binary);

326 NaClDefIter(" f20f7e+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

327 NaClDefIter(" f30f78+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

328 NaClDefine(" f30f7e: Movq $Vq, $Wq", NACLi_SSE2, st, Move);

329 NaClDefine(" f30f7f: Movdqu $Wdq, $Vdq", NACLi_SSE2, st, Move);

330 NaClDefIter(" f20fb8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

331 NaClDefine(" f30fb8: Popcnt $Gv, $Ev", NACLi_POPCNT, st, Move);

332 NaClDefIter(" f30fb9+@i: Invalid", 0, 2, NACLi_INVALID, st, Other);

333 /* tzcnt is treated as a bsf on machines that don't have tzcnt.

334 * Hence, even though its conditional on NACLi_LZCNT, we act

335 * like it can be used on all processors.

336 */

337 NaClDefine(" f30fbc: Tzcnt $Gv, $Ev", NACLi_386, st, Move);

338 /* lzcnt is treated as a bsr on machines that don't have lzcnt.

339 * Hence, even though its conditional on NACLi_LZCNT, we act

340 * like it can be used on all processors.

341 */

342 NaClDefine(" f30fbd: Lzcnt $Gv, $Ev", NACLi_386, st, Move);

343 NaClDefIter(" f30fbe+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

344 NaClDefine(" 0fc2: Cmpps $Vps, $Wps, $Ib",

345 NACLi_SSE, st, Nary);

346 NaClDefine(" 0fc3: Movnti $Md/q $Gd/q", NACLi_SSE2, st, Move);

347 /* Note: Pinsrw follows Intel's table, not ADM, which uses:

348 * Pinsrw $Pq, $Ew, $Ib

349 */

350 NaClDefine(" 0fc4: Pinsrw $Pq, $Rd/q/Mw, $Ib",

351 NACLi_SSE, st, Nary);

352 NaClDefine(" 0fc5: Pextrw $Gd, $PRq, $Ib",

353 NACLi_SSE41, st, Move);

354 NaClDefine(" 0fc6: Shufps $Vps, $Wps, $Ib",

355 NACLi_SSE, st, Nary);

356 NaClDefine(" 660fc2: Cmppd $Vpd, $Wpd, $Ib",

357 NACLi_SSE2, st, Nary);

358 NaClDefine(" 660fc3: Invalid", NACLi_INVALID, st, Other);

359 /* Note: Pinsrw follows Intel's table, not ADM, which uses:

360 * Pinsrw $Vdq, $Ew, $Ib

361 */

362 NaClDefine(" 660fc4: Pinsrw $Vdq, $Rd/q/Mw, $Ib",

363 NACLi_SSE, st, Binary);

364 NaClDefine(" 660fc5: Pextrw $Gd $VRdq, $Ib",

365 NACLi_SSE41, st, Binary);

366 NaClDefine(" 660fc6: Shufpd $Vpd, $Wpd, $Ib",

367 NACLi_SSE2, st, Nary);

368 NaClDefine(" f20fc2: Cmpsd_xmm $Vsd, $Wsd, $Ib",

369 NACLi_SSE2, st, Nary);

370 NaClDefine(" f20fc3: Invalid", NACLi_INVALID, st, Other);

371 NaClDefine(" f20fc4: Invalid", NACLi_INVALID, st, Other);

372 NaClDefine(" f20fc5: Invalid", NACLi_INVALID, st, Other);

373 NaClDefine(" f20fc6: Invalid", NACLi_INVALID, st, Other);

374 NaClDefine(" f30fc2: Cmpss $Vss, $Wss, $Ib",

375 NACLi_SSE, st, Nary);

376 NaClDefine(" f30fc3: Invalid", NACLi_INVALID, st, Other);

377 NaClDefine(" f30fc4: Invalid", NACLi_INVALID, st, Other);

378 NaClDefine(" f30fc5: Invalid", NACLi_INVALID, st, Other);

379 NaClDefine(" f30fc6: Invalid", NACLi_INVALID, st, Other);

380 NaClDefine(" f20fd0: Addsubps $Vpd, $Wpd", NACLi_SSE3, st, Binary);

381 NaClDefIter(" f20fd1+@i: Invalid", 0, 4, NACLi_INVALID, st, Other);

382 NaClDefine(" f20fd6: Movdq2q $Pq, $VRq", NACLi_SSE2, st, Move);

383 NaClDefine(" f20fd7: Invalid", NACLi_INVALID, st, Other);

384 NaClDefIter(" f30fd0+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

385 NaClDefine(" f30fd6: Movq2dq $Vdq, $PRq", NACLi_SSE2, st, Move);

386 NaClDefine(" f30fd7: Invalid", NACLi_INVALID, st, Other);

387 NaClDefine(" 660fd0: Addsubpd $Vpd, $Wpd", NACLi_SSE3, st, Binary);

388 NaClDefine(" 660fd1: Psrlw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

389 NaClDefine(" 660fd2: Psrld $Vdq, $Wdq", NACLi_SSE2, st, Binary);

390 NaClDefine(" 660fd3: Psrlq $Vdq, $Wdq", NACLi_SSE2, st, Binary);

391 NaClDefine(" 660fd4: Paddq $Vdq, $Wdq", NACLi_SSE2, st, Binary);

392 NaClDefine(" 660fd5: Pmullw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

393 NaClDefine(" 660fd6: Movq $Wq, $Vq", NACLi_SSE2, st, Move);

394 NaClDefine(" 660fd7: Pmovmskb $Gd, $VRdq", NACLi_SSE2, st, Move);

395 NaClDefine(" 660fd8: Psubusb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

396 NaClDefine(" 660fd9: Psubusw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

397 NaClDefine(" 660fda: Pminub $Vdq, $Wdq", NACLi_SSE2, st, Binary);

398 NaClDefine(" 660fdb: Pand $Vdq, $Wdq", NACLi_SSE2, st, Binary);

399 NaClDefine(" 660fdc: Paddusb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

400 NaClDefine(" 660fdd: Paddusw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

401 NaClDefine(" 660fde: Pmaxub $Vdq, $Wdq", NACLi_SSE2, st, Binary);

402 NaClDefine(" 660fdf: Pandn $Vdq, $Wdq", NACLi_SSE2, st, Binary);

403 NaClDefIter(" f20fd8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

404 NaClDefIter(" f30fd8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

405 NaClDefine(" 660fe0: Pavgb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

406 NaClDefine(" 660fe1: Psraw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

407 NaClDefine(" 660fe2: Psrad $Vdq, $Wdq", NACLi_SSE2, st, Binary);

408 NaClDefine(" 660fe3: Pavgw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

409 NaClDefine(" 660fe4: Pmulhuw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

410 NaClDefine(" 660fe5: Pmulhw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

411 NaClDefine(" 660fe6: Cvttpd2dq $Vq, $Wdq", NACLi_SSE2, st, Move);

412 NaClDefine(" 660fe7: Movntdq $Mdq, $Vdq", NACLi_SSE2, st, Move);

413 NaClDefIter(" f30fe0+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

414 NaClDefine(" f30fe6: Cvtdq2pd $Vpd, $Wq", NACLi_SSE2, st, Move);

415 NaClDefine(" f30fe7: Invalid", NACLi_INVALID, st, Other);

416 NaClDefIter(" f20fe0+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

417 NaClDefine(" f20fe6: Cvtpd2dq $Vq, $Wpd", NACLi_SSE2, st, Move);

418 NaClDefine(" f20fe7: Invalid", NACLi_INVALID, st, Other);

419 NaClDefine(" 660fe8: Psubsb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

420 NaClDefine(" 660fe9: Psubsw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

421 NaClDefine(" 660fea: Pminsw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

422 NaClDefine(" 660feb: Por $Vdq, $Wdq", NACLi_SSE2, st, Binary);

423 NaClDefine(" 660fec: Paddsb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

424 NaClDefine(" 660fed: Paddsw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

425 NaClDefine(" 660fee: Pmaxsw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

426 NaClDefine(" 660fef: Pxor $Vdq, $Wdq", NACLi_SSE2, st, Binary);

427 NaClDefIter(" f20fe8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

428 NaClDefIter(" f30fe8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

429 NaClDefine(" 660ff0: Invalid", NACLi_INVALID, st, Other);

430 NaClDefine(" 660ff1: Psllw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

431 NaClDefine(" 660ff2: Pslld $Vdq, $Wdq", NACLi_SSE2, st, Binary);

432 NaClDefine(" 660ff3: Psllq $Vdq, $Wdq", NACLi_SSE2, st, Binary);

433 NaClDefine(" 660ff4: Pmuludq $Vdq, $Wdq", NACLi_SSE2, st, Binary);

434 NaClDefine(" 660ff5: Pmaddwd $Vdq, $Wdq", NACLi_SSE2, st, Binary);

435 NaClDefine(" 660ff6: Psadbw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

436 NaClDefine(" 660ff7: Maskmovdqu {$Zvd}, $Vdq, $VRdq",

437 NACLi_SSE2, st, Binary);

438 NaClDefine(" f20ff0: Lddqu $Vdq, $Mdq", NACLi_SSE3, st, Move);

439 NaClDefIter(" f20ff1+@i: Invalid", 0, 6, NACLi_INVALID, st, Other);

440 NaClDefIter(" f30ff0+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

441 NaClDefine(" 660ff8: Psubb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

442 NaClDefine(" 660ff9: Psubw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

443 NaClDefine(" 660ffa: Psubd $Vdq, $Wdq", NACLi_SSE2, st, Binary);

444 NaClDefine(" 660ffb: Psubq $Vdq, $Wdq", NACLi_SSE2, st, Binary);

445 NaClDefine(" 660ffc: Paddb $Vdq, $Wdq", NACLi_SSE2, st, Binary);

446 NaClDefine(" 660ffd: Paddw $Vdq, $Wdq", NACLi_SSE2, st, Binary);

447 NaClDefine(" 660ffe: Paddd $Vdq, $Wdq", NACLi_SSE2, st, Binary);

448 NaClDefine(" 660fff: Invalid", NACLi_INVALID, st, Other);

449 NaClDefIter(" f20ff8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

450 NaClDefIter(" f30ff8+@i: Invalid", 0, 7, NACLi_INVALID, st, Other);

451 }

452

453 static void NaClDefMmxInsts(struct NaClSymbolTable* st) {

454 NaClDefPrefixInstChoices_32_64(Prefix0F, 0x6e, 1, 2);

455 NaClDefPrefixInstChoices_32_64(Prefix0F, 0x7e, 1, 2);

456 NaClDefine(" 0f60: Punpcklbw $Pq, $Qq", NACLi_MMX, st, Binary);

457 NaClDefine(" 0f61: Punpcklwd $Pq, $Qq", NACLi_MMX, st, Binary);

458 NaClDefine(" 0f62: Punpckldq $Pq, $Qq", NACLi_MMX, st, Binary);

459 NaClDefine(" 0f63: Packsswb $Pq, $Qq", NACLi_MMX, st, Binary);

460 NaClDefine(" 0f64: Pcmpgtb $Pq, $Qq", NACLi_MMX, st, Binary);

461 NaClDefine(" 0f65: Pcmpgtw $Pq, $Qq", NACLi_MMX, st, Binary);

462 NaClDefine(" 0f66: Pcmpgtd $Pq, $Qq", NACLi_MMX, st, Binary);

463 NaClDefine(" 0f67: Packuswb $Pq, $Qq", NACLi_MMX, st, Binary);

464 NaClDefine(" 0f68: Punpckhbw $Pq, $Qd", NACLi_MMX, st, Binary);

465 NaClDefine(" 0f69: Punpckhwd $Pq, $Qd", NACLi_MMX, st, Binary);

466 NaClDefine(" 0f6a: Punpckhdq $Pq, $Qd", NACLi_MMX, st, Binary);

467 NaClDefine(" 0f6b: Packssdw $Pq, $Qq", NACLi_MMX, st, Binary);

468 NaClDefIter(" 0f6c+@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

469 NaClDefine(" 0f6e: Movd $Pq, $Ed/q/d", NACLi_MMX, st, Move);

470 NaClDef_64(" 0f6e: Movq $Pq, $Ed/q/q", NACLi_MMX, st, Move);

471 NaClDefine(" 0f6f: Movq $Pq, $Qq", NACLi_MMX, st, Move);

472 NaClDefine(" 0f70: Pshufw $Pq, $Qq, $Ib",NACLi_MMX, st, Binary);

473 NaClDefIter(" 0f71/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

474 NaClDefine(" 0f71/2: Psrlw $PRq, $Ib", NACLi_MMX, st, Binary);

475 NaClDefine(" 0f71/3: Invalid", NACLi_INVALID, st, Other);

476 NaClDefine(" 0f71/4: Psraw $PRq, $Ib", NACLi_MMX, st, Binary);

477 NaClDefine(" 0f71/5: Invalid", NACLi_INVALID, st, Other);

478 NaClDefine(" 0f71/6: Psllw $PRq, $Ib", NACLi_MMX, st, Binary);

479 NaClDefine(" 0f71/7: Invalid", NACLi_INVALID, st, Other);

480 NaClDefIter(" 0f72/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

481 NaClDefine(" 0f72/2: Psrld $PRq, $Ib", NACLi_MMX, st, Binary);

482 NaClDefine(" 0f72/3: Invalid", NACLi_INVALID, st, Other);

483 NaClDefine(" 0f72/4: Psrad $PRq, $Ib", NACLi_MMX, st, Binary);

484 NaClDefine(" 0f72/5: Invalid", NACLi_INVALID, st, Other);

485 NaClDefine(" 0f72/6: Pslld $PRq, $Ib", NACLi_MMX, st, Binary);

486 NaClDefine(" 0f72/7: Invalid", NACLi_INVALID, st, Other);

487 NaClDefIter(" 0f73/@i: Invalid", 0, 1, NACLi_INVALID, st, Other);

488 NaClDefine(" 0f73/2: Psrlq $PRq, $Ib", NACLi_MMX, st, Binary);

489 NaClDefIter(" 0f73/@i: Invalid", 3, 5, NACLi_INVALID, st, Other);

490 NaClDefine(" 0f73/6: Psllq $PRq, $Ib", NACLi_MMX, st, Binary);

491 NaClDefine(" 0f73/7: Invalid", NACLi_INVALID, st, Other);

492 NaClDefine(" 0f74: Pcmpeqb $Pq, $Qq", NACLi_MMX, st, Binary);

493 NaClDefine(" 0f75: Pcmpeqw $Pq, $Qq", NACLi_MMX, st, Binary);

494 NaClDefine(" 0f76: Pcmpeqd $Pq, $Qq", NACLi_MMX, st, Binary);

495 NaClDefine(" 0f77: Emms", NACLi_MMX, st, Binary);

496 NaClDefIter(" 0f78+@i: Invalid", 0, 5, NACLi_INVALID, st, Other);

497 NaClDefine(" 0f7e: Movd $Ed/q/d, $Pd/q/d",

498 NACLi_MMX, st, Move);

499 NaClDef_64(" 0f7e: Movq $Ed/q/q, $Pd/q/q",

500 NACLi_MMX, st, Move);

501 NaClDefine(" 0f7f: Movq $Qq, $Pq", NACLi_MMX, st, Move);

502 NaClDefine(" 0fd0: Invalid", NACLi_INVALID, st, Other);

503 NaClDefine(" 0fd1: Psrlw $Pq, $Qq", NACLi_MMX, st, Binary);

504 NaClDefine(" 0fd2: Psrld $Pq, $Qq", NACLi_MMX, st, Binary);

505 NaClDefine(" 0fd3: Psrlq $Pq, $Qq", NACLi_MMX, st, Binary);

506 NaClDefine(" 0fd4: Paddq $Pq, $Qq", NACLi_MMX, st, Binary);

507 NaClDefine(" 0fd5: Pmullw $Pq, $Qq", NACLi_MMX, st, Binary);

508 NaClDefine(" 0fd6: Invalid", NACLi_INVALID, st, Other);

509 NaClDefine(" 0fd7: Pmovmskb $Gd, $PRq", NACLi_MMX, st, Move);

510 NaClDefine(" 0fd8: Psubusb $Pq, $Qq", NACLi_MMX, st, Binary);

511 NaClDefine(" 0fd9: Psubusw $Pq, $Qq", NACLi_MMX, st, Binary);

512 NaClDefine(" 0fda: Pminub $Pq, $Qq", NACLi_MMX, st, Binary);

513 NaClDefine(" 0fdb: Pand $Pq, $Qq", NACLi_MMX, st, Binary);

514 NaClDefine(" 0fdc: Paddusb $Pq, $Qq", NACLi_MMX, st, Binary);

515 NaClDefine(" 0fdd: Paddusw $Pq, $Qq", NACLi_MMX, st, Binary);

516 NaClDefine(" 0fde: Pmaxub $Pq, $Qq", NACLi_MMX, st, Binary);

517 NaClDefine(" 0fdf: Pandn $Pq, $Qq", NACLi_MMX, st, Binary);

518 NaClDefine(" 0fe0: Pavgb $Pq, $Qq", NACLi_MMX, st, Binary);

519 NaClDefine(" 0fe1: Psraw $Pq, $Qq", NACLi_MMX, st, Binary);

520 NaClDefine(" 0fe2: Psrad $Pq, $Qq", NACLi_MMX, st, Binary);

521 NaClDefine(" 0fe3: Pavgw $Pq, $Qq", NACLi_MMX, st, Binary);

522 NaClDefine(" 0fe4: Pmulhuw $Pq, $Qq", NACLi_MMX, st, Binary);

523 NaClDefine(" 0fe5: Pmulhw $Pq, $Qq", NACLi_MMX, st, Binary);

524 NaClDefine(" 0fe6: Invalid", NACLi_INVALID, st, Other);

525 NaClDefine(" 0fe7: Movntq $Mq, $Pq", NACLi_MMX, st, Move);

526 NaClDefine(" 0fe8: Psubsb $Pq, $Qq", NACLi_MMX, st, Binary);

527 NaClDefine(" 0fe9: Psubsw $Pq, $Qq", NACLi_MMX, st, Binary);

528 NaClDefine(" 0fea: Pminsw $Pq, $Qq", NACLi_MMX, st, Binary);

529 NaClDefine(" 0feb: Por $Pq, $Qq", NACLi_MMX, st, Binary);

530 NaClDefine(" 0fec: Paddsb $Pq, $Qq", NACLi_MMX, st, Binary);

531 NaClDefine(" 0fed: Paddsw $Pq, $Qq", NACLi_MMX, st, Binary);

532 NaClDefine(" 0fee: Pmaxsw $Pq, $Qq", NACLi_MMX, st, Binary);

533 NaClDefine(" 0fef: Pxor $Pq, $Qq", NACLi_MMX, st, Binary);

534 NaClDefine(" 0ff0: Invalid", NACLi_INVALID, st, Other);

535 NaClDefine(" 0ff1: Psllw $Pq, $Qq", NACLi_MMX, st, Binary);

536 NaClDefine(" 0ff2: Pslld $Pq, $Qq", NACLi_MMX, st, Binary);

537 NaClDefine(" 0ff3: Psllq $Pq, $Qq", NACLi_MMX, st, Binary);

538 NaClDefine(" 0ff4: Pmuludq $Pq, $Qq", NACLi_MMX, st, Binary);

539 NaClDefine(" 0ff5: Pmaddwd $Pq, $Qq", NACLi_MMX, st, Binary);

540 NaClDefine(" 0ff6: Psadbw $Pq, $Qq", NACLi_MMX, st, Binary);

541 NaClDefine(" 0ff7: Maskmovq {$Zvd}, $Pq, $PRq",

542 NACLi_MMX, st, Binary);

543 NaClDefine(" 0ff8: Psubb $Pq, $Qq", NACLi_MMX, st, Binary);

544 NaClDefine(" 0ff9: Psubw $Pq, $Qq", NACLi_MMX, st, Binary);

545 NaClDefine(" 0ffa: Psubd $Pq, $Qq", NACLi_MMX, st, Binary);

546 NaClDefine(" 0ffb: Psubq $Pq, $Qq", NACLi_MMX, st, Binary);

547 NaClDefine(" 0ffc: Paddb $Pq, $Qq", NACLi_MMX, st, Binary);

548 NaClDefine(" 0ffd: Paddw $Pq, $Qq", NACLi_MMX, st, Binary);

549 NaClDefine(" 0ffe: Paddd $Pq, $Qq", NACLi_MMX, st, Binary);

550 NaClDefine(" 0fff: Invalid", NACLi_INVALID, st, Binary);

551 }

552

553 static void NaClDefNarySseInsts(struct NaClSymbolTable* st) {

554 /* Define other forms of MMX and XMM operations, i.e. those in 660f3a. */

555 NaClDefInstPrefix(Prefix660F3A);

556 NaClDefPrefixInstChoices_32_64(Prefix660F3A, 0x16, 1, 2);

557 NaClDefPrefixInstChoices_32_64(Prefix660F3A, 0x22, 1, 2);

558 NaClDefine(" 660f3a08: Roundps $Vdq, $Wdq, $Ib",

559 NACLi_SSE41, st, O1Nary);

560 NaClDefine(" 660f3a09: Roundpd $Vdq, $Wdq, $Ib",

561 NACLi_SSE41, st, O1Nary);

562 NaClDefine(" 660f3a0a: Roundss $Vss, $Wss, $Ib",

563 NACLi_SSE41, st, O1Nary);

564 NaClDefine(" 660f3a0b: Roundsd $Vsd, $Wsd, $Ib",

565 NACLi_SSE41, st, O1Nary);

566 NaClDefine(" 660f3a0c: Blendps $Vdq, $Wdq, $Ib",

567 NACLi_SSE41, st, Nary);

568 NaClDefine(" 660f3a0d: Blendpd $Vdq, $Wdq, $Ib",

569 NACLi_SSE41, st, Nary);

570 NaClDefine(" 660f3a0e: Pblendw $Vdq, $Wdq, $Ib",

571 NACLi_SSE41, st, Nary);

572 NaClDefine(" 0f3a0f: Palignr $Pq, $Qq, $Ib",

573 NACLi_SSSE3, st, Nary);

574 NaClDefine(" 660f3a0f: Palignr $Vdq, $Wdq, $Ib",

575 NACLi_SSSE3, st, Nary);

576 NaClDefine(" 660f3a14: Pextrb $Rd/Mb, $Vdq, $Ib",

577 NACLi_SSE41, st, O1Nary);

578 NaClDefine(" 660f3a15: Pextrw $Rd/Mw, $Vdq, $Ib",

579 NACLi_SSE41, st, O1Nary);

580 NaClDefine(" 660f3a16: Pextrd $Ed/q/d, $Vdq, $Ib",

581 NACLi_SSE41, st, O1Nary);

582 NaClDef_64(" 660f3a16: Pextrq $Ed/q/q, $Vdq, $Ib",

583 NACLi_SSE41, st, O1Nary);

584 NaClDefine(" 660f3a17: Extractps $Ed, $Vdq, $Ib",

585 NACLi_SSE41, st, O1Nary);

586 NaClDefine(" 660f3a20: Pinsrb $Vdq, $Rd/q/Mb, $Ib",

587 NACLi_SSE41, st, O1Nary);

588 NaClDefine(" 660f3a21: Insertps $Vdq, $Udq/Md, $Ib",

589 NACLi_SSE41, st, O1Nary);

590 NaClDefine(" 660f3a22: Pinsrd $Vdq, $Ed/q/d, $Ib",

591 NACLi_SSE41, st, O1Nary);

592 NaClDef_64(" 660f3a22: Pinsrq $Vdq, $Ed/q/q, $Ib",

593 NACLi_SSE41, st, O1Nary);

594 NaClDefine(" 660f3a40: Dpps $Vdq, $Wdq, $Ib",

595 NACLi_SSE41, st, Nary);

596 NaClDefine(" 660f3a41: Dppd $Vdq, $Wdq, $Ib",

597 NACLi_SSE41, st, Nary);

598 NaClDefine(" 660f3a42: Mpsadbw $Vdq, $Wdq, $Ib",

599 NACLi_SSE41, st, Nary);

600 NaClDefine(" 660f3a60: Pcmpestrm {%xmm0}, {$rAXv}, {$rDXv}, "

601 "$Vdq, $Wdq, $Ib",

602 NACLi_SSE42, st, O3Nary);

603 NaClDefine(" 660f3a61: Pcmpestri {$rCXv}, {$rAXv}, {$rDXv}, "

604 "$Vdq, $Wdq, $Ib",

605 NACLi_SSE42, st, O3Nary);

606 NaClDefine(" 660f3a62: Pcmpistrm {%xmm0}, $Vdq, $Wdq, $Ib",

607 NACLi_SSE42, st, O1Nary);

608 NaClDefine(" 660f3a63: Pcmpistri {$rCXv}, $Vdq, $Wdq, $Ib",

609 NACLi_SSE42, st, O1Nary);

610 }

611

612 void NaClDefSseInsts(struct NaClSymbolTable* st) {

613 NaClDefNarySseInsts(st);

614 NaClDefBinarySseInsts(st);

615 NaClDefMmxInsts(st);

616 }

OLD	NEW