1 /////////////////////////////////////////////////////////////////////////
2 // $Id: avx512_mask32.cc 13466 2018-02-16 07:57:32Z sshwarts $
3 /////////////////////////////////////////////////////////////////////////
4 //
5 // Copyright (c) 2014-2018 Stanislav Shwartsman
6 // Written by Stanislav Shwartsman [sshwarts at sourceforge net]
7 //
8 // This library is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Lesser General Public
10 // License as published by the Free Software Foundation; either
11 // version 2 of the License, or (at your option) any later version.
12 //
13 // This library is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 // Lesser General Public License for more details.
17 //
18 // You should have received a copy of the GNU Lesser General Public
19 // License along with this library; if not, write to the Free Software
20 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA B 02110-1301 USA
21 //
22 /////////////////////////////////////////////////////////////////////////
23
24 #define NEED_CPU_REG_SHORTCUTS 1
25 #include "bochs.h"
26 #include "cpu.h"
27 #define LOG_THIS BX_CPU_THIS_PTR
28
29 #if BX_SUPPORT_AVX
30
KADDD_KGdKHdKEdR(bxInstruction_c * i)31 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KADDD_KGdKHdKEdR(bxInstruction_c *i)
32 {
33 #if BX_SUPPORT_EVEX
34 Bit32u opmask = BX_READ_32BIT_OPMASK(i->src1()) + BX_READ_32BIT_OPMASK(i->src2());
35 BX_WRITE_OPMASK(i->dst(), opmask);
36 #endif
37
38 BX_NEXT_INSTR(i);
39 }
40
KANDD_KGdKHdKEdR(bxInstruction_c * i)41 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KANDD_KGdKHdKEdR(bxInstruction_c *i)
42 {
43 #if BX_SUPPORT_EVEX
44 Bit32u opmask = BX_READ_32BIT_OPMASK(i->src1()) & BX_READ_32BIT_OPMASK(i->src2());
45 BX_WRITE_OPMASK(i->dst(), opmask);
46 #endif
47
48 BX_NEXT_INSTR(i);
49 }
50
KANDND_KGdKHdKEdR(bxInstruction_c * i)51 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KANDND_KGdKHdKEdR(bxInstruction_c *i)
52 {
53 #if BX_SUPPORT_EVEX
54 Bit32u opmask = ~(BX_READ_32BIT_OPMASK(i->src1())) & BX_READ_32BIT_OPMASK(i->src2());
55 BX_WRITE_OPMASK(i->dst(), opmask);
56 #endif
57
58 BX_NEXT_INSTR(i);
59 }
60
KMOVD_KGdKEdM(bxInstruction_c * i)61 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KMOVD_KGdKEdM(bxInstruction_c *i)
62 {
63 #if BX_SUPPORT_EVEX
64 bx_address eaddr = BX_CPU_RESOLVE_ADDR(i);
65 Bit32u opmask = read_virtual_dword(i->seg(), eaddr);
66 BX_WRITE_OPMASK(i->dst(), opmask);
67 #endif
68
69 BX_NEXT_INSTR(i);
70 }
71
KMOVD_KGdKEdR(bxInstruction_c * i)72 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KMOVD_KGdKEdR(bxInstruction_c *i)
73 {
74 #if BX_SUPPORT_EVEX
75 BX_WRITE_OPMASK(i->dst(), BX_READ_32BIT_OPMASK(i->src()));
76 #endif
77
78 BX_NEXT_INSTR(i);
79 }
80
KMOVD_KEdKGdM(bxInstruction_c * i)81 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KMOVD_KEdKGdM(bxInstruction_c *i)
82 {
83 #if BX_SUPPORT_EVEX
84 bx_address eaddr = BX_CPU_RESOLVE_ADDR(i);
85 write_virtual_dword(i->seg(), eaddr, BX_READ_32BIT_OPMASK(i->src()));
86 #endif
87
88 BX_NEXT_INSTR(i);
89 }
90
KMOVD_KGdEdR(bxInstruction_c * i)91 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KMOVD_KGdEdR(bxInstruction_c *i)
92 {
93 #if BX_SUPPORT_EVEX
94 BX_WRITE_OPMASK(i->dst(), BX_READ_32BIT_REG(i->src()));
95 #endif
96
97 BX_NEXT_INSTR(i);
98 }
99
KMOVD_GdKEdR(bxInstruction_c * i)100 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KMOVD_GdKEdR(bxInstruction_c *i)
101 {
102 #if BX_SUPPORT_EVEX
103 BX_WRITE_32BIT_REGZ(i->dst(), BX_READ_32BIT_OPMASK(i->src()));
104 #endif
105
106 BX_NEXT_INSTR(i);
107 }
108
KUNPCKWD_KGdKHwKEwR(bxInstruction_c * i)109 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KUNPCKWD_KGdKHwKEwR(bxInstruction_c *i)
110 {
111 #if BX_SUPPORT_EVEX
112 Bit32u opmask = BX_READ_16BIT_OPMASK(i->src1());
113 opmask = (opmask << 16) | BX_READ_16BIT_OPMASK(i->src2());
114
115 BX_WRITE_OPMASK(i->dst(), opmask);
116 #endif
117
118 BX_NEXT_INSTR(i);
119 }
120
KNOTD_KGdKEdR(bxInstruction_c * i)121 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KNOTD_KGdKEdR(bxInstruction_c *i)
122 {
123 #if BX_SUPPORT_EVEX
124 Bit32u opmask = ~BX_READ_32BIT_OPMASK(i->src());
125 BX_WRITE_OPMASK(i->dst(), opmask);
126 #endif
127
128 BX_NEXT_INSTR(i);
129 }
130
KORD_KGdKHdKEdR(bxInstruction_c * i)131 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KORD_KGdKHdKEdR(bxInstruction_c *i)
132 {
133 #if BX_SUPPORT_EVEX
134 Bit32u opmask = BX_READ_32BIT_OPMASK(i->src1()) | BX_READ_32BIT_OPMASK(i->src2());
135 BX_WRITE_OPMASK(i->dst(), opmask);
136 #endif
137
138 BX_NEXT_INSTR(i);
139 }
140
KORTESTD_KGdKEdR(bxInstruction_c * i)141 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KORTESTD_KGdKEdR(bxInstruction_c *i)
142 {
143 #if BX_SUPPORT_EVEX
144 Bit32u tmp = BX_READ_32BIT_OPMASK(i->src1()) | BX_READ_32BIT_OPMASK(i->src2());
145 clearEFlagsOSZAPC();
146 if (tmp == 0)
147 assert_ZF();
148 else if (tmp == 0xffffffff)
149 assert_CF();
150 #endif
151
152 BX_NEXT_INSTR(i);
153 }
154
KSHIFTLD_KGdKEdIbR(bxInstruction_c * i)155 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KSHIFTLD_KGdKEdIbR(bxInstruction_c *i)
156 {
157 #if BX_SUPPORT_EVEX
158 unsigned count = i->Ib();
159 Bit32u opmask = 0;
160 if (count < 32)
161 opmask = BX_READ_32BIT_OPMASK(i->src()) << count;
162
163 BX_WRITE_OPMASK(i->dst(), opmask);
164 #endif
165
166 BX_NEXT_INSTR(i);
167 }
168
KSHIFTRD_KGdKEdIbR(bxInstruction_c * i)169 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KSHIFTRD_KGdKEdIbR(bxInstruction_c *i)
170 {
171 #if BX_SUPPORT_EVEX
172 unsigned count = i->Ib();
173 Bit32u opmask = 0;
174 if (count < 32)
175 opmask = BX_READ_32BIT_OPMASK(i->src()) >> count;
176
177 BX_WRITE_OPMASK(i->dst(), opmask);
178 #endif
179
180 BX_NEXT_INSTR(i);
181 }
182
KXNORD_KGdKHdKEdR(bxInstruction_c * i)183 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KXNORD_KGdKHdKEdR(bxInstruction_c *i)
184 {
185 #if BX_SUPPORT_EVEX
186 Bit32u opmask = ~(BX_READ_32BIT_OPMASK(i->src1()) ^ BX_READ_32BIT_OPMASK(i->src2()));
187 BX_WRITE_OPMASK(i->dst(), opmask);
188 #endif
189
190 BX_NEXT_INSTR(i);
191 }
192
KXORD_KGdKHdKEdR(bxInstruction_c * i)193 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KXORD_KGdKHdKEdR(bxInstruction_c *i)
194 {
195 #if BX_SUPPORT_EVEX
196 Bit32u opmask = BX_READ_32BIT_OPMASK(i->src1()) ^ BX_READ_32BIT_OPMASK(i->src2());
197 BX_WRITE_OPMASK(i->dst(), opmask);
198 #endif
199
200 BX_NEXT_INSTR(i);
201 }
202
KTESTD_KGdKEdR(bxInstruction_c * i)203 void BX_CPP_AttrRegparmN(1) BX_CPU_C::KTESTD_KGdKEdR(bxInstruction_c *i)
204 {
205 #if BX_SUPPORT_EVEX
206 Bit32u op1 = BX_READ_32BIT_OPMASK(i->src1()), op2 = BX_READ_32BIT_OPMASK(i->src2());
207 clearEFlagsOSZAPC();
208 if ((op1 & op2) == 0)
209 assert_ZF();
210 if ((~op1 & op2) == 0)
211 assert_CF();
212 #endif
213
214 BX_NEXT_INSTR(i);
215 }
216
217 #endif
218